7551d83c35
Mainly focus on files that use BSD 2-Clause license, however the tool I was using misidentified many licenses so this was mostly a manual - error prone - task. The Software Package Data Exchange (SPDX) group provides a specification to make it easier for automated tools to detect and summarize well known opensource licenses. We are gradually adopting the specification, noting that the tags are considered only advisory and do not, in any way, superceed or replace the license texts. No functional change intended.
487 lines
11 KiB
C
487 lines
11 KiB
C
/*-
|
|
* SPDX-License-Identifier: BSD-2-Clause-FreeBSD
|
|
*
|
|
* Copyright (c) 2001 Joerg Wunsch
|
|
*
|
|
* 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 DEVELOPERS ``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 DEVELOPERS 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.
|
|
*
|
|
* $FreeBSD$
|
|
*/
|
|
|
|
#include <dev/ic/nec765.h>
|
|
|
|
#include <sys/fdcio.h>
|
|
|
|
#include <err.h>
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
#include <sysexits.h>
|
|
|
|
#include "fdutil.h"
|
|
|
|
/*
|
|
* Decode the FDC status pointed to by `fdcsp', and print a textual
|
|
* translation to stderr. If `terse' is false, the numerical FDC
|
|
* register status is printed, too.
|
|
*/
|
|
void
|
|
printstatus(struct fdc_status *fdcsp, int terse)
|
|
{
|
|
char msgbuf[100];
|
|
|
|
if (!terse)
|
|
fprintf(stderr,
|
|
"\nFDC status ST0=%#x ST1=%#x ST2=%#x C=%u H=%u R=%u N=%u:\n",
|
|
fdcsp->status[0] & 0xff,
|
|
fdcsp->status[1] & 0xff,
|
|
fdcsp->status[2] & 0xff,
|
|
fdcsp->status[3] & 0xff,
|
|
fdcsp->status[4] & 0xff,
|
|
fdcsp->status[5] & 0xff,
|
|
fdcsp->status[6] & 0xff);
|
|
|
|
if ((fdcsp->status[0] & NE7_ST0_IC_RC) == 0) {
|
|
sprintf(msgbuf, "timeout");
|
|
} else if ((fdcsp->status[0] & NE7_ST0_IC_RC) != NE7_ST0_IC_AT) {
|
|
sprintf(msgbuf, "unexcpted interrupt code %#x",
|
|
fdcsp->status[0] & NE7_ST0_IC_RC);
|
|
} else {
|
|
strcpy(msgbuf, "unexpected error code in ST1/ST2");
|
|
|
|
if (fdcsp->status[1] & NE7_ST1_EN)
|
|
strcpy(msgbuf, "end of cylinder (wrong format)");
|
|
else if (fdcsp->status[1] & NE7_ST1_DE) {
|
|
if (fdcsp->status[2] & NE7_ST2_DD)
|
|
strcpy(msgbuf, "CRC error in data field");
|
|
else
|
|
strcpy(msgbuf, "CRC error in ID field");
|
|
} else if (fdcsp->status[1] & NE7_ST1_MA) {
|
|
if (fdcsp->status[2] & NE7_ST2_MD)
|
|
strcpy(msgbuf, "no address mark in data field");
|
|
else
|
|
strcpy(msgbuf, "no address mark in ID field");
|
|
} else if (fdcsp->status[2] & NE7_ST2_WC)
|
|
strcpy(msgbuf, "wrong cylinder (format mismatch)");
|
|
else if (fdcsp->status[1] & NE7_ST1_ND)
|
|
strcpy(msgbuf, "no data (sector not found)");
|
|
}
|
|
fputs(msgbuf, stderr);
|
|
}
|
|
|
|
static struct fd_type fd_types_auto[1] =
|
|
{ { 0,0,0,0,0,0,0,0,0,0,0,FL_AUTO } };
|
|
|
|
|
|
static struct fd_type fd_types_288m[] = {
|
|
#if 0
|
|
{ FDF_3_2880 },
|
|
#endif
|
|
{ FDF_3_1722 },
|
|
{ FDF_3_1476 },
|
|
{ FDF_3_1440 },
|
|
{ FDF_3_1200 },
|
|
{ FDF_3_820 },
|
|
{ FDF_3_800 },
|
|
{ FDF_3_720 },
|
|
{ 0,0,0,0,0,0,0,0,0,0,0,0 }
|
|
};
|
|
|
|
static struct fd_type fd_types_144m[] = {
|
|
{ FDF_3_1722 },
|
|
{ FDF_3_1476 },
|
|
{ FDF_3_1440 },
|
|
{ FDF_3_1200 },
|
|
{ FDF_3_820 },
|
|
{ FDF_3_800 },
|
|
{ FDF_3_720 },
|
|
{ 0,0,0,0,0,0,0,0,0,0,0,0 }
|
|
};
|
|
|
|
static struct fd_type fd_types_12m[] = {
|
|
{ FDF_5_1200 },
|
|
{ FDF_5_1230 },
|
|
{ FDF_5_1480 },
|
|
{ FDF_5_1440 },
|
|
{ FDF_5_820 },
|
|
{ FDF_5_800 },
|
|
{ FDF_5_720 },
|
|
{ FDF_5_360 | FL_2STEP },
|
|
{ FDF_5_640 },
|
|
{ 0,0,0,0,0,0,0,0,0,0,0,0 }
|
|
};
|
|
|
|
static struct fd_type fd_types_720k[] =
|
|
{
|
|
{ FDF_3_720 },
|
|
{ 0,0,0,0,0,0,0,0,0,0,0,0 }
|
|
};
|
|
|
|
static struct fd_type fd_types_360k[] =
|
|
{
|
|
{ FDF_5_360 },
|
|
{ 0,0,0,0,0,0,0,0,0,0,0,0 }
|
|
};
|
|
|
|
|
|
/*
|
|
* Parse a format string, and fill in the parameter pointed to by `out'.
|
|
*
|
|
* sectrac,secsize,datalen,gap,ncyls,speed,heads,f_gap,f_inter,offs2,flags[...]
|
|
*
|
|
* sectrac = sectors per track
|
|
* secsize = sector size in bytes
|
|
* datalen = length of sector if secsize == 128
|
|
* gap = gap length when reading
|
|
* ncyls = number of cylinders
|
|
* speed = transfer speed 250/300/500/1000 KB/s
|
|
* heads = number of heads
|
|
* f_gap = gap length when formatting
|
|
* f_inter = sector interleave when formatting
|
|
* offs2 = offset of sectors on side 2
|
|
* flags = +/-mfm | +/-2step | +/-perpend
|
|
* mfm - use MFM recording
|
|
* 2step - use 2 steps between cylinders
|
|
* perpend - user perpendicular (vertical) recording
|
|
*
|
|
* Any omitted value will be passed on from parameter `in'.
|
|
*/
|
|
void
|
|
parse_fmt(const char *s, enum fd_drivetype type,
|
|
struct fd_type in, struct fd_type *out)
|
|
{
|
|
int i, j;
|
|
const char *cp;
|
|
char *s1;
|
|
|
|
*out = in;
|
|
|
|
for (i = 0;; i++) {
|
|
if (s == NULL)
|
|
break;
|
|
|
|
if ((cp = strchr(s, ',')) == NULL) {
|
|
s1 = strdup(s);
|
|
if (s1 == NULL)
|
|
abort();
|
|
s = 0;
|
|
} else {
|
|
s1 = malloc(cp - s + 1);
|
|
if (s1 == NULL)
|
|
abort();
|
|
memcpy(s1, s, cp - s);
|
|
s1[cp - s] = 0;
|
|
|
|
s = cp + 1;
|
|
}
|
|
if (strlen(s1) == 0) {
|
|
free(s1);
|
|
continue;
|
|
}
|
|
|
|
switch (i) {
|
|
case 0: /* sectrac */
|
|
if (getnum(s1, &out->sectrac))
|
|
errx(EX_USAGE,
|
|
"bad numeric value for sectrac: %s", s1);
|
|
break;
|
|
|
|
case 1: /* secsize */
|
|
if (getnum(s1, &j))
|
|
errx(EX_USAGE,
|
|
"bad numeric value for secsize: %s", s1);
|
|
if (j == 128) out->secsize = 0;
|
|
else if (j == 256) out->secsize = 1;
|
|
else if (j == 512) out->secsize = 2;
|
|
else if (j == 1024) out->secsize = 3;
|
|
else
|
|
errx(EX_USAGE, "bad sector size %d", j);
|
|
break;
|
|
|
|
case 2: /* datalen */
|
|
if (getnum(s1, &j))
|
|
errx(EX_USAGE,
|
|
"bad numeric value for datalen: %s", s1);
|
|
if (j >= 256)
|
|
errx(EX_USAGE, "bad datalen %d", j);
|
|
out->datalen = j;
|
|
break;
|
|
|
|
case 3: /* gap */
|
|
if (getnum(s1, &out->gap))
|
|
errx(EX_USAGE,
|
|
"bad numeric value for gap: %s", s1);
|
|
break;
|
|
|
|
case 4: /* ncyls */
|
|
if (getnum(s1, &j))
|
|
errx(EX_USAGE,
|
|
"bad numeric value for ncyls: %s", s1);
|
|
if (j > 85)
|
|
errx(EX_USAGE, "bad # of cylinders %d", j);
|
|
out->tracks = j;
|
|
break;
|
|
|
|
case 5: /* speed */
|
|
if (getnum(s1, &j))
|
|
errx(EX_USAGE,
|
|
"bad numeric value for speed: %s", s1);
|
|
switch (type) {
|
|
default:
|
|
abort(); /* paranoia */
|
|
|
|
case FDT_360K:
|
|
case FDT_720K:
|
|
if (j == 250)
|
|
out->trans = FDC_250KBPS;
|
|
else
|
|
errx(EX_USAGE, "bad speed %d", j);
|
|
break;
|
|
|
|
case FDT_12M:
|
|
if (j == 300)
|
|
out->trans = FDC_300KBPS;
|
|
else if (j == 250)
|
|
out->trans = FDC_250KBPS;
|
|
else if (j == 500)
|
|
out->trans = FDC_500KBPS;
|
|
else
|
|
errx(EX_USAGE, "bad speed %d", j);
|
|
break;
|
|
|
|
case FDT_288M:
|
|
if (j == 1000)
|
|
out->trans = FDC_1MBPS;
|
|
/* FALLTHROUGH */
|
|
case FDT_144M:
|
|
if (j == 250)
|
|
out->trans = FDC_250KBPS;
|
|
else if (j == 500)
|
|
out->trans = FDC_500KBPS;
|
|
else
|
|
errx(EX_USAGE, "bad speed %d", j);
|
|
break;
|
|
}
|
|
break;
|
|
|
|
case 6: /* heads */
|
|
if (getnum(s1, &j))
|
|
errx(EX_USAGE,
|
|
"bad numeric value for heads: %s", s1);
|
|
if (j == 1 || j == 2)
|
|
out->heads = j;
|
|
else
|
|
errx(EX_USAGE, "bad # of heads %d", j);
|
|
break;
|
|
|
|
case 7: /* f_gap */
|
|
if (getnum(s1, &out->f_gap))
|
|
errx(EX_USAGE,
|
|
"bad numeric value for f_gap: %s", s1);
|
|
break;
|
|
|
|
case 8: /* f_inter */
|
|
if (getnum(s1, &out->f_inter))
|
|
errx(EX_USAGE,
|
|
"bad numeric value for f_inter: %s", s1);
|
|
break;
|
|
|
|
case 9: /* offs2 */
|
|
if (getnum(s1, &out->offset_side2))
|
|
errx(EX_USAGE,
|
|
"bad numeric value for offs2: %s", s1);
|
|
break;
|
|
|
|
default:
|
|
if (strcmp(s1, "+mfm") == 0)
|
|
out->flags |= FL_MFM;
|
|
else if (strcmp(s1, "-mfm") == 0)
|
|
out->flags &= ~FL_MFM;
|
|
else if (strcmp(s1, "+auto") == 0)
|
|
out->flags |= FL_AUTO;
|
|
else if (strcmp(s1, "-auto") == 0)
|
|
out->flags &= ~FL_AUTO;
|
|
else if (strcmp(s1, "+2step") == 0)
|
|
out->flags |= FL_2STEP;
|
|
else if (strcmp(s1, "-2step") == 0)
|
|
out->flags &= ~FL_2STEP;
|
|
else if (strcmp(s1, "+perpnd") == 0)
|
|
out->flags |= FL_PERPND;
|
|
else if (strcmp(s1, "-perpnd") == 0)
|
|
out->flags &= ~FL_PERPND;
|
|
else
|
|
errx(EX_USAGE, "bad flag: %s", s1);
|
|
break;
|
|
}
|
|
free(s1);
|
|
}
|
|
|
|
out->size = out->tracks * out->heads * out->sectrac;
|
|
}
|
|
|
|
/*
|
|
* Print a textual translation of the drive (density) type described
|
|
* by `in' to stdout. The string uses the same form that is parseable
|
|
* by parse_fmt().
|
|
*/
|
|
void
|
|
print_fmt(struct fd_type in)
|
|
{
|
|
int secsize, speed;
|
|
|
|
secsize = 128 << in.secsize;
|
|
switch (in.trans) {
|
|
case FDC_250KBPS: speed = 250; break;
|
|
case FDC_300KBPS: speed = 300; break;
|
|
case FDC_500KBPS: speed = 500; break;
|
|
case FDC_1MBPS: speed = 1000; break;
|
|
default: speed = 1; break;
|
|
}
|
|
|
|
printf("%d,%d,%#x,%#x,%d,%d,%d,%#x,%d,%d",
|
|
in.sectrac, secsize, in.datalen, in.gap, in.tracks,
|
|
speed, in.heads, in.f_gap, in.f_inter, in.offset_side2);
|
|
if (in.flags & FL_MFM)
|
|
printf(",+mfm");
|
|
if (in.flags & FL_2STEP)
|
|
printf(",+2step");
|
|
if (in.flags & FL_PERPND)
|
|
printf(",+perpnd");
|
|
if (in.flags & FL_AUTO)
|
|
printf(",+auto");
|
|
putc('\n', stdout);
|
|
}
|
|
|
|
/*
|
|
* Based on `size' (in kilobytes), walk through the table of known
|
|
* densities for drive type `type' and see if we can find one. If
|
|
* found, return it (as a pointer to static storage), otherwise return
|
|
* NULL.
|
|
*/
|
|
struct fd_type *
|
|
get_fmt(int size, enum fd_drivetype type)
|
|
{
|
|
int i, n;
|
|
struct fd_type *fdtp;
|
|
|
|
switch (type) {
|
|
default:
|
|
return (0);
|
|
|
|
case FDT_360K:
|
|
fdtp = fd_types_360k;
|
|
n = sizeof fd_types_360k / sizeof(struct fd_type);
|
|
break;
|
|
|
|
case FDT_720K:
|
|
fdtp = fd_types_720k;
|
|
n = sizeof fd_types_720k / sizeof(struct fd_type);
|
|
break;
|
|
|
|
case FDT_12M:
|
|
fdtp = fd_types_12m;
|
|
n = sizeof fd_types_12m / sizeof(struct fd_type);
|
|
break;
|
|
|
|
case FDT_144M:
|
|
fdtp = fd_types_144m;
|
|
n = sizeof fd_types_144m / sizeof(struct fd_type);
|
|
break;
|
|
|
|
case FDT_288M:
|
|
fdtp = fd_types_288m;
|
|
n = sizeof fd_types_288m / sizeof(struct fd_type);
|
|
break;
|
|
}
|
|
|
|
if (size == -1)
|
|
return fd_types_auto;
|
|
|
|
for (i = 0; i < n; i++, fdtp++) {
|
|
fdtp->size = fdtp->sectrac * fdtp->heads * fdtp->tracks;
|
|
if (((128 << fdtp->secsize) * fdtp->size / 1024) == size)
|
|
return (fdtp);
|
|
}
|
|
return (0);
|
|
}
|
|
|
|
/*
|
|
* Parse a number from `s'. If the string cannot be converted into a
|
|
* number completely, return -1, otherwise 0. The result is returned
|
|
* in `*res'.
|
|
*/
|
|
int
|
|
getnum(const char *s, int *res)
|
|
{
|
|
unsigned long ul;
|
|
char *cp;
|
|
|
|
ul = strtoul(s, &cp, 0);
|
|
if (*cp != '\0')
|
|
return (-1);
|
|
|
|
*res = (int)ul;
|
|
return (0);
|
|
}
|
|
|
|
/*
|
|
* Return a short name and a verbose description for the drive
|
|
* described by `t'.
|
|
*/
|
|
void
|
|
getname(enum fd_drivetype t, const char **name, const char **descr)
|
|
{
|
|
|
|
switch (t) {
|
|
default:
|
|
*name = "unknown";
|
|
*descr = "unknown drive type";
|
|
break;
|
|
|
|
case FDT_360K:
|
|
*name = "360K";
|
|
*descr = "5.25\" double-density";
|
|
break;
|
|
|
|
case FDT_12M:
|
|
*name = "1.2M";
|
|
*descr = "5.25\" high-density";
|
|
break;
|
|
|
|
case FDT_720K:
|
|
*name = "720K";
|
|
*descr = "3.5\" double-density";
|
|
break;
|
|
|
|
case FDT_144M:
|
|
*name = "1.44M";
|
|
*descr = "3.5\" high-density";
|
|
break;
|
|
|
|
case FDT_288M:
|
|
*name = "2.88M";
|
|
*descr = "3.5\" extra-density";
|
|
break;
|
|
}
|
|
}
|