[BACK]Return to newdisk.c CVS log [TXT] [DIR] Up to [RetroPC.NET] / np2 / fdd

Diff for /np2/fdd/newdisk.c between versions 1.1 and 1.6

version 1.1, 2003/10/16 17:58:27 version 1.6, 2004/01/27 07:24:25
Line 1 Line 1
 #include        "compiler.h"  #include        "compiler.h"
 #include        "dosio.h"  #include        "dosio.h"
 #include        "fddfile.h"  
 #include        "newdisk.h"  #include        "newdisk.h"
   #include        "fddfile.h"
   #include        "sxsi.h"
   #include        "hddboot.res"
   
   
   // ---- fdd
   
   void newdisk_fdd(const char *fname, REG8 type, const char *label) {
   
           _D88HEAD        d88head;
           FILEH           fh;
   
           ZeroMemory(&d88head, sizeof(d88head));
           STOREINTELDWORD(d88head.fd_size, sizeof(d88head));
           milstr_ncpy((char *)d88head.fd_name, label, sizeof(d88head.fd_name));
           d88head.fd_type = type;
           fh = file_create(fname);
           if (fh != FILEH_INVALID) {
                   file_write(fh, &d88head, sizeof(d88head));
                   file_close(fh);
           }
   }
   
   
   // ---- hdd
   
   static BOOL writezero(FILEH fh, UINT size) {
   
           BYTE    work[256];
           UINT    wsize;
   
           ZeroMemory(work, sizeof(work));
           while(size) {
                   wsize = min(size, sizeof(work));
                   if (file_write(fh, work, wsize) != wsize) {
                           return(FAILURE);
                   }
                   size -= wsize;
           }
           return(SUCCESS);
   }
   
   static void writehddipl(FILEH fh, UINT ssize) {
   
 static const BYTE hdddiskboot[] = {          BYTE    work[1024];
                         0xb8,0x00,0x10,0xbb,0x00,0x80,0x8e,0xd0,0x8b,0xe3,0x8c,0xc8,  
                         0x8e,0xd8,0xb8,0x00,0xa0,0x8e,0xc0,0xb9,0x00,0x10,0xb8,0x20,  
                         0x00,0x33,0xff,0xfc,0xf3,0xab,0xb0,0xe1,0xb9,0xe0,0x1f,0xaa,  
                         0x47,0xe2,0xfc,0xbe,0x44,0x00,0x33,0xff,0xe8,0x08,0x00,0xbf,  
                         0xa0,0x00,0xe8,0x02,0x00,0xeb,0xfe,0x2e,0xad,0x85,0xc0,0x74,  
                         0x06,0xab,0x83,0xc7,0x02,0xeb,0xf4,0xc3,0x04,0x33,0x04,0x4e,  
                         0x05,0x4f,0x01,0x3c,0x05,0x49,0x05,0x47,0x05,0x23,0x05,0x39,  
                         0x05,0x2f,0x05,0x24,0x05,0x61,0x01,0x3c,0x05,0x38,0x04,0x4f,  
                         0x05,0x55,0x05,0x29,0x01,0x3c,0x05,0x5e,0x05,0x43,0x05,0x48,  
                         0x04,0x35,0x04,0x6c,0x04,0x46,0x04,0x24,0x04,0x5e,0x04,0x3b,  
                         0x04,0x73,0x01,0x25,0x00,0x00,0x05,0x47,0x05,0x23,0x05,0x39,  
                         0x05,0x2f,0x05,0x24,0x05,0x61,0x01,0x3c,0x05,0x38,0x04,0x72,  
                         0x21,0x5e,0x26,0x7e,0x18,0x65,0x01,0x24,0x05,0x6a,0x05,0x3b,  
                         0x05,0x43,0x05,0x48,0x04,0x37,0x04,0x46,0x12,0x3c,0x04,0x35,  
                         0x04,0x24,0x01,0x25,0x00,0x00};  
   
           ZeroMemory(work, sizeof(work));
           CopyMemory(work, hdddiskboot, sizeof(hdddiskboot));
           if (ssize < 1024) {
                   work[ssize - 2] = 0x55;
                   work[ssize - 1] = 0xaa;
           }
           file_write(fh, work, sizeof(work));
   }
   
 void newdisk_hdd(const char *fname, UINT hddsize) {  void newdisk_thd(const char *fname, UINT hddsize) {
   
         FILEH   fh;          FILEH   fh;
         BYTE    work[256];          BYTE    work[256];
         UINT    size;          UINT    size;
         UINT    wsize;  
   
         if ((fname == NULL) || (hddsize < 5) || (hddsize > 256)) {          if ((fname == NULL) || (hddsize < 5) || (hddsize > 256)) {
                 return;                  return;
Line 38  void newdisk_hdd(const char *fname, UINT Line 71  void newdisk_hdd(const char *fname, UINT
                 size = hddsize * 15;                  size = hddsize * 15;
                 STOREINTELWORD(work, size);                  STOREINTELWORD(work, size);
                 file_write(fh, work, 256);                  file_write(fh, work, 256);
                 file_write(fh, hdddiskboot, sizeof(hdddiskboot));                  writehddipl(fh, 256);
                 ZeroMemory(work, sizeof(work));  
                 size = 0x400 - sizeof(hdddiskboot);  
                 while(size) {  
                         wsize = min(size, sizeof(work));  
                         size -= wsize;  
                         file_write(fh, work, wsize);  
                 }  
                 file_close(fh);                  file_close(fh);
         }          }
 }  }
   
 void newdisk_fdd(const char *fname, BYTE type, const char *label) {  void newdisk_nhd(const char *fname, UINT hddsize) {
   
         _D88HEAD        d88head;          FILEH   fh;
           NHDHDR  nhd;
           UINT    tmp;
   
           if ((fname == NULL) || (hddsize < 5) || (hddsize > 512)) {
                   return;
           }
           fh = file_create(fname);
           if (fh != FILEH_INVALID) {
                   ZeroMemory(&nhd, sizeof(nhd));
                   CopyMemory(&nhd.sig, sig_nhd, 15);
                   STOREINTELDWORD(nhd.headersize, sizeof(nhd));
                   tmp = hddsize * 16;
                   STOREINTELDWORD(nhd.cylinders, tmp);
                   STOREINTELWORD(nhd.surfaces, 8);
                   STOREINTELWORD(nhd.sectors, 32);
                   STOREINTELWORD(nhd.sectorsize, 256);
                   file_write(fh, &nhd, sizeof(nhd));
                   writehddipl(fh, 256);
                   file_close(fh);
           }
   }
   
   // hddtype = 0:5MB / 1:10MB / 2:15MB / 3:20MB / 5:30MB / 6:40MB
   void newdisk_hdi(const char *fname, UINT hddtype) {
   
   const SASIHDD   *sasi;
         FILEH           fh;          FILEH           fh;
           HDIHDR          hdi;
           UINT32          tmp;
   
         ZeroMemory(&d88head, sizeof(d88head));          hddtype &= 7;
         STOREINTELDWORD(d88head.fd_size, sizeof(d88head));          if ((fname == NULL) || (hddtype == 7)) {
         milstr_ncpy((char *)d88head.fd_name, label, sizeof(d88head.fd_name));                  return;
         d88head.fd_type = type;          }
           sasi = sasihdd + hddtype;
         fh = file_create(fname);          fh = file_create(fname);
         if (fh != FILEH_INVALID) {          if (fh != FILEH_INVALID) {
                 file_write(fh, &d88head, sizeof(d88head));                  ZeroMemory(&hdi, sizeof(hdi));
                   tmp = 256 * sasi->sectors * sasi->surfaces * sasi->cylinders;
   //              STOREINTELDWORD(hdi.hddtype, 0);                                // ???
                   STOREINTELDWORD(hdi.headersize, 4096);
                   STOREINTELDWORD(hdi.hddsize, tmp);
                   STOREINTELDWORD(hdi.sectorsize, 256);
                   STOREINTELDWORD(hdi.sectors, sasi->sectors);
                   STOREINTELDWORD(hdi.surfaces, sasi->surfaces);
                   STOREINTELDWORD(hdi.cylinders, sasi->cylinders);
                   file_write(fh, &hdi, sizeof(hdi));
                   writezero(fh, 4096 - sizeof(hdi));
                   writehddipl(fh, 256);
                   file_close(fh);
           }
   }
   
   void newdisk_vhd(const char *fname, UINT hddsize) {
   
           FILEH   fh;
           VHDHDR  vhd;
           UINT    tmp;
   
           if ((fname == NULL) || (hddsize < 2) || (hddsize > 512)) {
                   return;
           }
           fh = file_create(fname);
           if (fh != FILEH_INVALID) {
                   ZeroMemory(&vhd, sizeof(vhd));
                   CopyMemory(&vhd.sig, sig_vhd, 7);
                   STOREINTELWORD(vhd.mbsize, (UINT16)hddsize);
                   STOREINTELWORD(vhd.sectorsize, 256);
                   vhd.sectors = 32;
                   vhd.surfaces = 8;
                   tmp = hddsize * 16;             // = * 1024 * 1024 / (8 * 32 * 256);
                   STOREINTELWORD(vhd.cylinders, (UINT16)tmp);
                   tmp *= 8 * 32;
                   STOREINTELDWORD(vhd.totals, tmp);
                   file_write(fh, &vhd, sizeof(vhd));
                   writehddipl(fh, 256);
                 file_close(fh);                  file_close(fh);
         }          }
 }  }
Removed from v.1.1  
changed lines
  Added in v.1.6

RetroPC.NET-CVS <cvs@retropc.net>