home *** CD-ROM | disk | FTP | other *** search
/ CD Actual 14 / CDACTUAL.iso / cdactual / demobin / share / program / c / ZFMAT.ZIP / ZFMAT.C next >
Encoding:
C/C++ Source or Header  |  1988-06-08  |  13.6 KB  |  377 lines
  1. /* ----------------------------------------------------------------
  2.    Copyright 1988 by Edward V.  Dong, All Rights Reserved.  
  3.  
  4.    This source code is placed into the public domain.  However,
  5.    contributions are always welcome.  This is a modified form of the
  6.    source code used in the author's ZIP program.
  7.  
  8.    Edward V Dong's Floppy Formattor is a Turbo C program to format
  9.    floppy diskettes, based on earlier work by Frank Nystrom
  10.    (COPYIT.C;CIS 71631,355), Kim Kokkonen (FMAT.PAS; Compuserve
  11.    72457,2131), and Peter Norton (BOOT.ASM).  This programs formats,
  12.    accurately, 360K diskettes in either standard 360K drives or 1.2M
  13.    drives.
  14.  
  15.    Essentially, formatting is all performed by the BIOS, through calls
  16.    to Turbo C's biosdisk() routine.  To format a disk, the tracks are
  17.    first formatted, then boot record, two copies of the file allocation
  18.    table (FAT), and the root directory are written to the diskette. 
  19.    This program then verifies each track, again via the BIOS.  The
  20.    basic formatting and verification routines are derived from
  21.    Nystrom's COPYIT.C; the boot record used is a custom one, based on
  22.    Norton's BOOT.ASM.  The FAT and root directory routines are rehosted
  23.    versions based on Kokkonen's FMAT.PAS.
  24.  
  25.    To format 360K diskettes in 1.2 megabyte drives, the DASD must be
  26.    set - this is only possible for DOS 3.0 or higher and for AT class
  27.    machines.  The routines here are based on Kokkonen's Turbo Pascal
  28.    work, ported to Turbo C.  Through some experimentation and analysis,
  29.    the only difference with running on an AT machine is to use a delay
  30.    of about 0.3 seconds between biosdisk calls to allow the disk heads
  31.    to settle.
  32.  
  33.    Quick disk reformat is here done as a rewrite of the diskette's boot
  34.    sector, FAT, and root directory.  A "quick" reformat ASSUMES that the
  35.    diskette has no bad sectors at all.  Depending on configuration,
  36.    DOS retains a copy of the old FAT which shows the old free space,
  37.    even though the directory has been cleared.  This is only true for
  38.    AT's and 1.2 meg drives; as a workaround, one track is formatted,
  39.    which seem to force AT floppy disk controller to recognize that the
  40.    disk has been changed; and therefore DOS will read the diskette to
  41.    acquire the new FAT and directory information.
  42.  
  43.    Programming Note: Character bytes are set as unsigned.  This was
  44.    compiled using the Large Model, but is essentially independent of
  45.    C memory model.
  46.  
  47.    Edward V. Dong, 12205 Alexandria Pl, Chino, CA 91710.   18 May 1988
  48.    Change History
  49.    --------------
  50.    08 Jun 88 - Add check for type of drive (360K or 1.2Meg)
  51.    04 Jun 88 - set up logical disk sectoring -
  52.    01 Jun 88 - fix message on disk space -
  53.    18 May 88 - original issue
  54.   ----------------------------------------------------------------*/
  55.  
  56. #include <stdio.h>
  57. #include <stdlib.h>
  58. #include <dir.h>
  59. #include <dos.h>
  60. #include <mem.h>
  61. #include <string.h>
  62. #include <bios.h>     /* bioskey() */
  63. #include <conio.h>    /* getch()   */
  64. #include <alloc.h>    /* farcoreleft() */
  65.  
  66. /* defines for readability */
  67.  
  68. #define YES          1
  69. #define ERR         -1
  70. #define NO_ERR       0
  71. #define NO           0
  72. #define VIDEO    16        /* BIOS interrupt number */
  73.  
  74.                 /*  Disk Constants...*/
  75.  
  76. #define BYTES_PER_SECTOR      512
  77. #define SECTORS_PER_TRACK     9
  78. #define SD_PER_DSK            2
  79. #define TR_PER_DSK            40
  80.  
  81.                       /* biosdisk() BIOS function cmd calls */
  82.  
  83. #define READ_TRK    2
  84. #define WRITE_TRK    3
  85. #define VERIFY_TRK    4
  86. #define FORMAT_TRK    5
  87.  
  88. /* When you initialize the disk you need to pass the bios some things.
  89.  */
  90.  
  91. struct {
  92.      struct {
  93.           struct {
  94.               char cyl,
  95.                   head,
  96.                    rec,
  97.                    num;
  98.           } format_record[SECTORS_PER_TRACK];
  99.      } side[SD_PER_DSK];
  100. } trk_fmt[TR_PER_DSK];
  101.  
  102.  
  103. typedef struct  {
  104.         struct  {
  105.             char data[BYTES_PER_SECTOR * SECTORS_PER_TRACK];
  106.             }head[ SD_PER_DSK];
  107.         }TRACK;
  108.  
  109. char buffer[BYTES_PER_SECTOR * SECTORS_PER_TRACK];
  110.  
  111. /* The following is a custom boot record created using Peter Norton's
  112.    BOOT.ASM, modified for DSDD 9-sector disks. */
  113.  
  114. char boot_rec[] = {            /* custom boot record */
  115. 0xEB,0x2A,0x90,0x20,0x45,0x2E,0x44,0x6F,0x6E,0x67,0x20,0,0x02,0x02,0x01,0,
  116. 0x02,0x70,0,0xD0,0x02,0xFD,0x02,0,0x09,0,0x02,0,0,0,0,0,
  117. 0,0,0,0,0,0,0,0,0,0,0,0,0xB8,0xC0,0x07,0x50,
  118. 0x1F,0xBB,0x56,0,0x90,0xB9,0x49,0x01,0x90,0xB4,0x0E,0x8A,0x07,0x1E,0x51,0x53,
  119. 0xCD,0x10,0x5B,0x59,0x1F,0x43,0xE2,0xF1,0xB4,0,0xCD,0x16,0xB4,0x0F,0xCD,0x10,
  120. 0xB4,0,0xCD,0x10,0xCD,0x19,0x0D,0x0A,0x0D,0x0A,0x0D,0x0A,0x0D,0x0A,0x20,0x20,
  121. 0x20,0x20,0x20,0x53,0x74,0x61,0x72,0x74,0x20,0x79,0x6F,0x75,0x72,0x20,0x63,0x6F,
  122. 0x6D,0x70,0x75,0x74,0x65,0x72,0x20,0x77,0x69,0x74,0x68,0x0D,0x0A,0x20,0x20,0x20,
  123. 0x20,0x20,0x61,0x20,0x44,0x4F,0x53,0x20,0x73,0x79,0x73,0x74,0x65,0x6D,0x20,0x64,
  124. 0x69,0x73,0x6B,0x65,0x74,0x74,0x65,0x2E,0x0D,0x0A,0x0D,0x0A,0x0D,0x0A,0x20,0x20,
  125. 0x20,0x20,0x20,0x54,0x68,0x69,0x73,0x20,0x69,0x73,0x0D,0x0A,0x20,0x20,0x20,0x20,
  126. 0x20,0x20,0x20,0x20,0x20,0x20,0x44,0x72,0x61,0x67,0x6F,0x6E,0x57,0x61,0x72,0x65,
  127. 0x20,0x53,0x6F,0x66,0x74,0x77,0x61,0x72,0x65,0x0D,0x0A,0x20,0x20,0x20,0x20,0x20,
  128. 0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x56,0x65,0x72,0x73,0x69,0x6F,0x6E,0x20,
  129. 0x31,0x2E,0x30,0x30,0x20,0x20,0x20,0x20,0x0D,0x0A,0x0D,0x0A,0x20,0x20,0x20,0x20,
  130. 0x20,0x66,0x72,0x6F,0x6D,0x0D,0x0A,0x20,0x20,0x20,0x20,0x20,0x45,0x64,0x77,0x61,
  131. 0x72,0x64,0x20,0x56,0x2E,0x20,0x44,0x6F,0x6E,0x67,0x0D,0x0A,0x20,0x20,0x20,0x20,
  132. 0x20,0x31,0x32,0x32,0x30,0x35,0x20,0x41,0x6C,0x65,0x78,0x61,0x6E,0x64,0x72,0x69,
  133. 0x61,0x20,0x50,0x6C,0x61,0x63,0x65,0x0D,0x0A,0x20,0x20,0x20,0x20,0x20,0x43,0x68,
  134. 0x69,0x6E,0x6F,0x2C,0x20,0x43,0x41,0x20,0x39,0x31,0x37,0x31,0x30,0x0D,0x0A,0x0D,
  135. 0x0A,0x5A,0x49,0x50,0x3A,0x20,0x54,0x68,0x65,0x20,0x55,0x6C,0x74,0x69,0x6D,0x61,
  136. 0x74,0x65,0x20,0x55,0x74,0x69,0x6C,0x69,0x74,0x79,0x0D,0x0A,0x0D,0x0A,0x0D,0x0A,
  137. 0x0D,0x0A,0x20,0x20,0x20,0x20,0x49,0x6E,0x73,0x65,0x72,0x74,0x20,0x61,0x20,0x44,
  138. 0x4F,0x53,0x20,0x64,0x69,0x73,0x6B,0x65,0x74,0x74,0x65,0x0D,0x0A,0x20,0x20,0x20,
  139. 0x20,0x70,0x72,0x65,0x73,0x73,0x20,0x61,0x6E,0x79,0x20,0x6B,0x65,0x79,0x20,0x74,
  140. 0x6F,0x20,0x73,0x74,0x61,0x72,0x74,0x20,0x44,0x4F,0x53,0x2E,0x2E,0x2E,0x20,0,
  141. 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
  142. 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0x55,0xAA
  143.     };
  144.  
  145. /* ----------------------------------------------------------------- */
  146. /* setDASD is used to command a 1.2M drive to format for 360K disks  */
  147. /* ----------------------------------------------------------------- */
  148.  
  149. int setDASD(int drive,char dType)    /* set DASD to format 360K floppies */
  150. {
  151. union REGS inregs;
  152. union REGS outregs;
  153. int i;
  154. char drive2;
  155.     drive2 = (drive);        /* cast operation */
  156.     i = 0;
  157.     while ((i<3) && (!outregs.x.cflag))
  158.     {    inregs.h.ah = 0x17;
  159.         inregs.h.al = dType;
  160.         inregs.h.dl = drive2;
  161.         int86(0x13,&inregs,&outregs);
  162.         i++;
  163.     }
  164.     if (outregs.x.cflag) return(-1);
  165.     return(0);
  166. }
  167.  
  168. /* -----------------------------------------------------------------
  169.    The following routine inserts a delay of 0.3 seconds between calls
  170.    to biosdisk(), to provide for disk head settling for AT class
  171.    machines.  Delay is not needed for standard PC's or XT's.  A delay
  172.    might be needed for Turbo PC/XT's, however.  
  173.  
  174.    FLOPPY is the Turbo C "direct BIOS" call, with the embedded delay. 
  175.    DISKOP calls FLOPPY, but uses DOS logical sector number (0==boot
  176.    sector, etc.).  This simplifies the programming for writing the
  177.    boot sector (0), FAT sectors (1-4), and root directory sectors
  178.    (5-12).
  179.  
  180.    DOS logical sector numbers sequences through physical disk sectors
  181.    by first using head 0, track 0, then physical sectors 1 through
  182.    maximum sectors per track; then head 1, track 0, then sectors again;
  183.    then back to head 0, etc.
  184.    ----------------------------------------------------------------- */
  185.  
  186. int DISKOP(int cmd,int drive,int sect,int nsects,void *buffer,int sect_per_trk)
  187. {
  188.     return(FLOPPY(cmd,drive,(sect/sect_per_trk) % 2,
  189.         (sect/sect_per_trk) % sect_per_trk,
  190.         (sect % sect_per_trk) + 1,nsects,buffer));
  191. }
  192.  
  193. int FLOPPY(int cmd,int drive,int head,int track,int sector,int nsects,
  194.         void *buffer)
  195. {
  196. int value;
  197. char MachineType;
  198.     MachineType = peekb(0xf000,0xfffe);
  199.     value = biosdisk(cmd,drive,head,track,sector,nsects,buffer);
  200.     if (MachineType == 0x0fc) delay(300);
  201.     return(value);
  202. }
  203.  
  204. /* ---------------------------------------------------------------------
  205.    The theory in chk_disk is that the first two sectors aren't formatted,
  206.    if the disk is not formatted.  Generally, if these sectors aren't
  207.    formatted (or readable), the diskette needs formatting anyway.
  208.    --------------------------------------------------------------------- */
  209.  
  210. int chk_dsk(int drive,int *quick)    /* check if disk already formatted */
  211. {
  212.     *quick = 0;
  213.     if( (FLOPPY(READ_TRK, drive, 0, 0, 1, 9, buffer) == 0) &&
  214.         (FLOPPY(READ_TRK, drive, 1, 0, 1, 9, buffer) == 0))
  215.     {    printf("Disk in %c: already formatted...Reformat? [y/N]", 
  216.             drive+'A');
  217.         if (toupper(getch()) != 'Y')
  218.             return(ERR);
  219.         printf("\nQuick reformat (IF diskette has NO bad sectors) [y/N]");
  220.         if (toupper(getch()) == 'Y')
  221.             *quick = 1;
  222.     }
  223.         return(NO_ERR);     /* not formatted */
  224. }
  225.  
  226. int verify_error(int drive,int sd,int tr,char FAT[])
  227. {
  228. int iptr, cluster, topcluster;
  229.     if (FLOPPY(VERIFY_TRK,drive,sd,tr,1,9,buffer))
  230.     {    cluster = ((9*(sd+2*tr)) >> 1) - 4;
  231.         topcluster = cluster + 5;
  232.         while (cluster < topcluster)
  233.         {    iptr = (3 * cluster) >> 1;
  234.             if ((cluster & 1)==1)
  235.                 FAT[iptr] |= 0xff70;
  236.                 else FAT[iptr] |= 0x0ff7;
  237.             cluster++;
  238.         }
  239.         return(ERR);
  240.     }
  241.     return(NO_ERR);
  242. }
  243.  
  244. int disk_format(int drive,int verify)    /* this does the formatting */
  245. {
  246. register int loop, tr, sd;
  247. int  iptr, cluster, topcluster, i, s, tries, success, quick;
  248. char dType, NoOfCyl;
  249. char DirSector[512], FAT[1024];
  250. char MachineType;
  251. union REGS inregs,outregs;
  252. struct SREGS sregs;
  253.  
  254. /* initialize file allocation table (FAT) */
  255.     setmem(FAT,1024,0);    /* fill fat with all zeroes */
  256.                 /* fill in the ID bytes */
  257.     FAT[0] = 0xfd;        /* 9 sector DSDD drive */
  258.     FAT[1] = 0xff;        /* boilerplate */
  259.     FAT[2] = 0xff;
  260.  
  261. /* check machine type & DOS version, to handle 1.2meg drives */
  262.     MachineType = peekb(0xf000,0xfffe);
  263.     printf("\nFormatting Drive %c: \n", drive+'A');
  264.     if ((MachineType == 0x0fc) && ((_version & 0x00ff) == 3))
  265.     {    /* get drive type */
  266.         tries = 0;
  267.  
  268. /* call BIOS to determine number of cylinders formattable by drive */
  269.         inregs.h.ah = 8;        /* call needed */
  270.         inregs.h.dl = drive;
  271.         int86(0x13,&inregs,&outregs);    /* call BIOS */
  272.         NoOfCyl = outregs.h.ch;
  273.  
  274. /* if NoOfCyl = 79, then it's a 1.2 meg drive; else if 39, then it's a 
  275.    360K drive; anything else is not supported! */
  276.         if (NoOfCyl == 79)        /* 1.2 meg drive */
  277.         {    inregs.x.ax = drive;
  278.             inregs.h.ah = 0x15;
  279.             int86(0x13,&inregs,&outregs);    /* invoke BIOS */
  280.             dType = outregs.h.ah;    /* see if 360k supported */
  281.             if ((dType==0) || (dType==3))
  282.             {    printf("ERROR: Invalid drive %c (dType=%d)\n",
  283.                     drive+'A',dType);
  284.                 if (getch()==0) getch();
  285.                 return(ERR);
  286.             }
  287.             if (dType==2)
  288.                 setDASD(drive,dType);    /* set DASD type */
  289.         }
  290.         else if (NoOfCyl != 39)        /* not 1.2M or 360K drive! */
  291.         {    printf("Drive Type Not Supported: #%d\n",
  292.                 NoOfCyl+1);
  293.             return(ERR);
  294.         }
  295.  
  296.     }
  297.  
  298. /* see if disk already formatted */
  299.     if (chk_dsk(drive,&quick)) return(ERR);
  300.  
  301. /* use BIOS to format a track & format 40 tracks */
  302.     for(tr = 0;   tr < TR_PER_DSK;  tr++)
  303.         for(sd = 0;  sd < SD_PER_DSK;  sd++)
  304.         {    for(s = 0;  s < SECTORS_PER_TRACK;  s++)
  305.             {       trk_fmt[tr].side[sd].format_record[s].cyl = tr;
  306.                         trk_fmt[tr].side[sd].format_record[s].head = sd;
  307.                         trk_fmt[tr].side[sd].format_record[s].rec = s +1;
  308.                         trk_fmt[tr].side[sd].format_record[s].num = 2;
  309.                 }
  310.             success = tries = 0;
  311.             while (!success && (tries < 3))
  312.             {    if (!FLOPPY(FORMAT_TRK, drive, sd, tr, 1, 9,
  313.                     &(trk_fmt[tr].side[sd].format_record[0])))
  314.                     success = 1;
  315.                     else tries++;
  316.             }
  317.             if (success)
  318.             {    if (quick) goto WriteBOOT;
  319.                 printf("Head %d, Cyl %d(F)\r",sd,tr);
  320.                 if (verify)
  321.                 {    if (verify_error(drive,sd,tr,FAT))
  322.                         printf("Head %d, Cyl %d(E)\r",sd,tr);
  323.                     else printf("Head %d, Cyl %d(V)\r",sd,tr);
  324.                 }
  325.             }
  326.             else
  327.             {    printf("Format Error - aborting...\n");
  328.                 return(ERR);
  329.             }
  330.          }
  331.  
  332. WriteBOOT:            /* create boot record on the floppy */
  333.     printf("DiskFormat: Writing BOOT record\r");
  334.     DISKOP(WRITE_TRK,drive,0,1,boot_rec,9);
  335.  
  336. /* create 2 copies of file allocation table (FAT) on the floppy */
  337.     printf("DiskFormat: Writing FAT blocks\r");
  338.     for (i=1; i<3; i++)
  339.         if (DISKOP(WRITE_TRK,drive,2*i-1,2,FAT,9))
  340.             printf("Error writing FAT #%d\n",i);
  341.  
  342. /* create root directory on the floppy */
  343.     printf("DiskFormat: Writing root directory\r");
  344.     setmem(DirSector,512,0xf6);    /* fill with format bytes */
  345.     for (i=0;i<481;i++)        /* mark each directory entry as avail */
  346.         if ((i % 32) == 0)
  347.             DirSector[i] = 0;
  348.     for (i=5; i<12; i++)        /* 7 sectors */
  349.         DISKOP(WRITE_TRK,drive,i,1,DirSector,9);
  350.  
  351. /* all done */
  352.     return(NO_ERR);
  353. }
  354.  
  355. void DiskFormat(void)
  356. {
  357. int    drive, verify;
  358.     drive = 2;
  359.     while ((drive!=0)&&(drive!=1))
  360.     {    printf("Enter drive to format [A,B]:");
  361.         drive = toupper(getch());
  362.         if (drive==27) return;
  363.         drive -= 'A';
  364.     }
  365.     printf("\rVerify during formatting? [Y/n]: ");
  366.     if (toupper(getch())=='N')
  367.         verify = 0;
  368.         else verify = 1;
  369.     if (disk_format(drive,verify) == 0)
  370.         printf("Format [%c] Complete: \n",drive+'A');
  371. }
  372.  
  373. main(void)
  374. {
  375.     DiskFormat();
  376. }
  377.