usr.sbin/fdread/fdutil.c

   1 /*
   2  * Copyright (c) 2001 Joerg Wunsch
   3  *
   4  * All rights reserved.
   5  *
   6  * Redistribution and use in source and binary forms, with or without
   7  * modification, are permitted provided that the following conditions
   8  * are met:
   9  * 1. Redistributions of source code must retain the above copyright
  10  *    notice, this list of conditions and the following disclaimer.
  11  * 2. Redistributions in binary form must reproduce the above copyright
  12  *    notice, this list of conditions and the following disclaimer in the
  13  *    documentation and/or other materials provided with the distribution.
  14  *
  15  * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY EXPRESS OR
  16  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  17  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  18  * IN NO EVENT SHALL THE DEVELOPERS BE LIABLE FOR ANY DIRECT, INDIRECT,
  19  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  20  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  21  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  22  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  23  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  24  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  25  *
  26  * $FreeBSD$
  27  */
  28
  29 #include <dev/ic/nec765.h>
  30
  31 #include <sys/fdcio.h>
  32
  33 #include <err.h>
  34 #include <stdio.h>
  35 #include <stdlib.h>
  36 #include <string.h>
  37 #include <sysexits.h>
  38
  39 #include "fdutil.h"
  40
  41 /*
  42  * Decode the FDC status pointed to by `fdcsp', and print a textual
  43  * translation to stderr.  If `terse' is false, the numerical FDC
  44  * register status is printed, too.
  45  */
  46 void
  47 printstatus(struct fdc_status *fdcsp, int terse)
  48 {
  49         char msgbuf[100];
  50
  51         if (!terse)
  52                 fprintf(stderr,
  53                 "\nFDC status ST0=%#x ST1=%#x ST2=%#x C=%u H=%u R=%u N=%u:\n",
  54                         fdcsp->status[0] & 0xff,
  55                         fdcsp->status[1] & 0xff,
  56                         fdcsp->status[2] & 0xff,
  57                         fdcsp->status[3] & 0xff,
  58                         fdcsp->status[4] & 0xff,
  59                         fdcsp->status[5] & 0xff,
  60                         fdcsp->status[6] & 0xff);
  61
  62         if ((fdcsp->status[0] & NE7_ST0_IC_RC) == 0) {
  63                 sprintf(msgbuf, "timeout");
  64         } else if ((fdcsp->status[0] & NE7_ST0_IC_RC) != NE7_ST0_IC_AT) {
  65                 sprintf(msgbuf, "unexcpted interrupt code %#x",
  66                         fdcsp->status[0] & NE7_ST0_IC_RC);
  67         } else {
  68                 strcpy(msgbuf, "unexpected error code in ST1/ST2");
  69
  70                 if (fdcsp->status[1] & NE7_ST1_EN)
  71                         strcpy(msgbuf, "end of cylinder (wrong format)");
  72                 else if (fdcsp->status[1] & NE7_ST1_DE) {
  73                         if (fdcsp->status[2] & NE7_ST2_DD)
  74                                 strcpy(msgbuf, "CRC error in data field");
  75                         else
  76                                 strcpy(msgbuf, "CRC error in ID field");
  77                 } else if (fdcsp->status[1] & NE7_ST1_MA) {
  78                         if (fdcsp->status[2] & NE7_ST2_MD)
  79                                 strcpy(msgbuf, "no address mark in data field");
  80                         else
  81                                 strcpy(msgbuf, "no address mark in ID field");
  82                 } else if (fdcsp->status[2] & NE7_ST2_WC)
  83                         strcpy(msgbuf, "wrong cylinder (format mismatch)");
  84                 else if (fdcsp->status[1] & NE7_ST1_ND)
  85                         strcpy(msgbuf, "no data (sector not found)");
  86         }
  87         fputs(msgbuf, stderr);
  88 }
  89
  90 static struct fd_type fd_types_auto[1] =
  91     { { 0,0,0,0,0,0,0,0,0,0,0,FL_AUTO } };
  92
  93
  94 static struct fd_type fd_types_288m[] = {
  95 #if 0
  96         { FDF_3_2880 },
  97 #endif
  98         { FDF_3_1722 },
  99         { FDF_3_1476 },
 100         { FDF_3_1440 },
 101         { FDF_3_1200 },
 102         { FDF_3_820 },
 103         { FDF_3_800 },
 104         { FDF_3_720 },
 105         { 0,0,0,0,0,0,0,0,0,0,0,0 }
 106 };
 107
 108 static struct fd_type fd_types_144m[] = {
 109         { FDF_3_1722 },
 110         { FDF_3_1476 },
 111         { FDF_3_1440 },
 112         { FDF_3_1200 },
 113         { FDF_3_820 },
 114         { FDF_3_800 },
 115         { FDF_3_720 },
 116         { 0,0,0,0,0,0,0,0,0,0,0,0 }
 117 };
 118
 119 static struct fd_type fd_types_12m[] = {
 120         { FDF_5_1200 },
 121         { FDF_5_1230 },
 122         { FDF_5_1480 },
 123         { FDF_5_1440 },
 124         { FDF_5_820 },
 125         { FDF_5_800 },
 126         { FDF_5_720 },
 127         { FDF_5_360 | FL_2STEP },
 128         { FDF_5_640 },
 129         { 0,0,0,0,0,0,0,0,0,0,0,0 }
 130 };
 131
 132 static struct fd_type fd_types_720k[] =
 133 {
 134         { FDF_3_720 },
 135         { 0,0,0,0,0,0,0,0,0,0,0,0 }
 136 };
 137
 138 static struct fd_type fd_types_360k[] =
 139 {
 140         { FDF_5_360 },
 141         { 0,0,0,0,0,0,0,0,0,0,0,0 }
 142 };
 143
 144
 145 /*
 146  * Parse a format string, and fill in the parameter pointed to by `out'.
 147  *
 148  * sectrac,secsize,datalen,gap,ncyls,speed,heads,f_gap,f_inter,offs2,flags[...]
 149  *
 150  * sectrac = sectors per track
 151  * secsize = sector size in bytes
 152  * datalen = length of sector if secsize == 128
 153  * gap     = gap length when reading
 154  * ncyls   = number of cylinders
 155  * speed   = transfer speed 250/300/500/1000 KB/s
 156  * heads   = number of heads
 157  * f_gap   = gap length when formatting
 158  * f_inter = sector interleave when formatting
 159  * offs2   = offset of sectors on side 2
 160  * flags   = +/-mfm | +/-2step | +/-perpend
 161  *             mfm - use MFM recording
 162  *             2step - use 2 steps between cylinders
 163  *             perpend - user perpendicular (vertical) recording
 164  *
 165  * Any omitted value will be passed on from parameter `in'.
 166  */
 167 void
 168 parse_fmt(const char *s, enum fd_drivetype type,
 169           struct fd_type in, struct fd_type *out)
 170 {
 171         int i, j;
 172         const char *cp;
 173         char *s1;
 174
 175         *out = in;
 176
 177         for (i = 0;; i++) {
 178                 if (s == NULL)
 179                         break;
 180
 181                 if ((cp = strchr(s, ',')) == NULL) {
 182                         s1 = strdup(s);
 183                         if (s1 == NULL)
 184                                 abort();
 185                         s = 0;
 186                 } else {
 187                         s1 = malloc(cp - s + 1);
 188                         if (s1 == NULL)
 189                                 abort();
 190                         memcpy(s1, s, cp - s);
 191                         s1[cp - s] = 0;
 192
 193                         s = cp + 1;
 194                 }
 195                 if (strlen(s1) == 0) {
 196                         free(s1);
 197                         continue;
 198                 }
 199
 200                 switch (i) {
 201                 case 0:         /* sectrac */
 202                         if (getnum(s1, &out->sectrac))
 203                                 errx(EX_USAGE,
 204                                      "bad numeric value for sectrac: %s", s1);
 205                         break;
 206
 207                 case 1:         /* secsize */
 208                         if (getnum(s1, &j))
 209                                 errx(EX_USAGE,
 210                                      "bad numeric value for secsize: %s", s1);
 211                         if (j == 128) out->secsize = 0;
 212                         else if (j == 256) out->secsize = 1;
 213                         else if (j == 512) out->secsize = 2;
 214                         else if (j == 1024) out->secsize = 3;
 215                         else
 216                                 errx(EX_USAGE, "bad sector size %d", j);
 217                         break;
 218
 219                 case 2:         /* datalen */
 220                         if (getnum(s1, &j))
 221                                 errx(EX_USAGE,
 222                                      "bad numeric value for datalen: %s", s1);
 223                         if (j >= 256)
 224                                 errx(EX_USAGE, "bad datalen %d", j);
 225                         out->datalen = j;
 226                         break;
 227
 228                 case 3:         /* gap */
 229                         if (getnum(s1, &out->gap))
 230                                 errx(EX_USAGE,
 231                                      "bad numeric value for gap: %s", s1);
 232                         break;
 233
 234                 case 4:         /* ncyls */
 235                         if (getnum(s1, &j))
 236                                 errx(EX_USAGE,
 237                                      "bad numeric value for ncyls: %s", s1);
 238                         if (j > 85)
 239                                 errx(EX_USAGE, "bad # of cylinders %d", j);
 240                         out->tracks = j;
 241                         break;
 242
 243                 case 5:         /* speed */
 244                         if (getnum(s1, &j))
 245                                 errx(EX_USAGE,
 246                                      "bad numeric value for speed: %s", s1);
 247                         switch (type) {
 248                         default:
 249                                 abort(); /* paranoia */
 250
 251                         case FDT_360K:
 252                         case FDT_720K:
 253                                 if (j == 250)
 254                                         out->trans = FDC_250KBPS;
 255                                 else
 256                                         errx(EX_USAGE, "bad speed %d", j);
 257                                 break;
 258
 259                         case FDT_12M:
 260                                 if (j == 300)
 261                                         out->trans = FDC_300KBPS;
 262                                 else if (j == 250)
 263                                         out->trans = FDC_250KBPS;
 264                                 else if (j == 500)
 265                                         out->trans = FDC_500KBPS;
 266                                 else
 267                                         errx(EX_USAGE, "bad speed %d", j);
 268                                 break;
 269
 270                         case FDT_288M:
 271                                 if (j == 1000)
 272                                         out->trans = FDC_1MBPS;
 273                                 /* FALLTHROUGH */
 274                         case FDT_144M:
 275                                 if (j == 250)
 276                                         out->trans = FDC_250KBPS;
 277                                 else if (j == 500)
 278                                         out->trans = FDC_500KBPS;
 279                                 else
 280                                         errx(EX_USAGE, "bad speed %d", j);
 281                                 break;
 282                         }
 283                         break;
 284
 285                 case 6:         /* heads */
 286                         if (getnum(s1, &j))
 287                                 errx(EX_USAGE,
 288                                      "bad numeric value for heads: %s", s1);
 289                         if (j == 1 || j == 2)
 290                                 out->heads = j;
 291                         else
 292                                 errx(EX_USAGE, "bad # of heads %d", j);
 293                         break;
 294
 295                 case 7:         /* f_gap */
 296                         if (getnum(s1, &out->f_gap))
 297                                 errx(EX_USAGE,
 298                                      "bad numeric value for f_gap: %s", s1);
 299                         break;
 300
 301                 case 8:         /* f_inter */
 302                         if (getnum(s1, &out->f_inter))
 303                                 errx(EX_USAGE,
 304                                      "bad numeric value for f_inter: %s", s1);
 305                         break;
 306
 307                 case 9:         /* offs2 */
 308                         if (getnum(s1, &out->offset_side2))
 309                                 errx(EX_USAGE,
 310                                      "bad numeric value for offs2: %s", s1);
 311                         break;
 312
 313                 default:
 314                         if (strcmp(s1, "+mfm") == 0)
 315                                 out->flags |= FL_MFM;
 316                         else if (strcmp(s1, "-mfm") == 0)
 317                                 out->flags &= ~FL_MFM;
 318                         else if (strcmp(s1, "+auto") == 0)
 319                                 out->flags |= FL_AUTO;
 320                         else if (strcmp(s1, "-auto") == 0)
 321                                 out->flags &= ~FL_AUTO;
 322                         else if (strcmp(s1, "+2step") == 0)
 323                                 out->flags |= FL_2STEP;
 324                         else if (strcmp(s1, "-2step") == 0)
 325                                 out->flags &= ~FL_2STEP;
 326                         else if (strcmp(s1, "+perpnd") == 0)
 327                                 out->flags |= FL_PERPND;
 328                         else if (strcmp(s1, "-perpnd") == 0)
 329                                 out->flags &= ~FL_PERPND;
 330                         else
 331                                 errx(EX_USAGE, "bad flag: %s", s1);
 332                         break;
 333                 }
 334                 free(s1);
 335         }
 336
 337         out->size = out->tracks * out->heads * out->sectrac;
 338 }
 339
 340 /*
 341  * Print a textual translation of the drive (density) type described
 342  * by `in' to stdout.  The string uses the same form that is parseable
 343  * by parse_fmt().
 344  */
 345 void
 346 print_fmt(struct fd_type in)
 347 {
 348         int secsize, speed;
 349
 350         secsize = 128 << in.secsize;
 351         switch (in.trans) {
 352         case FDC_250KBPS:       speed = 250; break;
 353         case FDC_300KBPS:       speed = 300; break;
 354         case FDC_500KBPS:       speed = 500; break;
 355         case FDC_1MBPS:         speed = 1000; break;
 356         default:                speed = 1; break;
 357         }
 358
 359         printf("%d,%d,%#x,%#x,%d,%d,%d,%#x,%d,%d",
 360                in.sectrac, secsize, in.datalen, in.gap, in.tracks,
 361                speed, in.heads, in.f_gap, in.f_inter, in.offset_side2);
 362         if (in.flags & FL_MFM)
 363                 printf(",+mfm");
 364         if (in.flags & FL_2STEP)
 365                 printf(",+2step");
 366         if (in.flags & FL_PERPND)
 367                 printf(",+perpnd");
 368         if (in.flags & FL_AUTO)
 369                 printf(",+auto");
 370         putc('\n', stdout);
 371 }
 372
 373 /*
 374  * Based on `size' (in kilobytes), walk through the table of known
 375  * densities for drive type `type' and see if we can find one.  If
 376  * found, return it (as a pointer to static storage), otherwise return
 377  * NULL.
 378  */
 379 struct fd_type *
 380 get_fmt(int size, enum fd_drivetype type)
 381 {
 382         int i, n;
 383         struct fd_type *fdtp;
 384
 385         switch (type) {
 386         default:
 387                 return (0);
 388
 389         case FDT_360K:
 390                 fdtp = fd_types_360k;
 391                 n = sizeof fd_types_360k / sizeof(struct fd_type);
 392                 break;
 393
 394         case FDT_720K:
 395                 fdtp = fd_types_720k;
 396                 n = sizeof fd_types_720k / sizeof(struct fd_type);
 397                 break;
 398
 399         case FDT_12M:
 400                 fdtp = fd_types_12m;
 401                 n = sizeof fd_types_12m / sizeof(struct fd_type);
 402                 break;
 403
 404         case FDT_144M:
 405                 fdtp = fd_types_144m;
 406                 n = sizeof fd_types_144m / sizeof(struct fd_type);
 407                 break;
 408
 409         case FDT_288M:
 410                 fdtp = fd_types_288m;
 411                 n = sizeof fd_types_288m / sizeof(struct fd_type);
 412                 break;
 413         }
 414
 415         if (size == -1)
 416                 return fd_types_auto;
 417
 418         for (i = 0; i < n; i++, fdtp++) {
 419                 fdtp->size = fdtp->sectrac * fdtp->heads * fdtp->tracks;
 420                 if (((128 << fdtp->secsize) * fdtp->size / 1024) == size)
 421                         return (fdtp);
 422         }
 423         return (0);
 424 }
 425
 426 /*
 427  * Parse a number from `s'.  If the string cannot be converted into a
 428  * number completely, return -1, otherwise 0.  The result is returned
 429  * in `*res'.
 430  */
 431 int
 432 getnum(const char *s, int *res)
 433 {
 434         unsigned long ul;
 435         char *cp;
 436
 437         ul = strtoul(s, &cp, 0);
 438         if (*cp != '\0')
 439           return (-1);
 440
 441         *res = (int)ul;
 442         return (0);
 443 }
 444
 445 /*
 446  * Return a short name and a verbose description for the drive
 447  * described by `t'.
 448  */
 449 void
 450 getname(enum fd_drivetype t, const char **name, const char **descr)
 451 {
 452
 453         switch (t) {
 454         default:
 455                 *name = "unknown";
 456                 *descr = "unknown drive type";
 457                 break;
 458
 459         case FDT_360K:
 460                 *name = "360K";
 461                 *descr = "5.25\" double-density";
 462                 break;
 463
 464         case FDT_12M:
 465                 *name = "1.2M";
 466                 *descr = "5.25\" high-density";
 467                 break;
 468
 469         case FDT_720K:
 470                 *name = "720K";
 471                 *descr = "3.5\" double-density";
 472                 break;
 473
 474         case FDT_144M:
 475                 *name = "1.44M";
 476                 *descr = "3.5\" high-density";
 477                 break;
 478
 479         case FDT_288M:
 480                 *name = "2.88M";
 481                 *descr = "3.5\" extra-density";
 482                 break;
 483         }
 484 }