makejv3: rework somewhat

- Add skewing option
- Add DOS formatting (ie 512 byte/sector) option

(and yes I plan to switch the trs80 ports to 512 byte/sector PC format
floppies for double density at least so we are compatible with other Fuzix
platforms)

diff --git a/Kernel/tools/makejv3.c b/Kernel/tools/makejv3.c
index c9476ef..00f7112 100644 (file)
--- a/Kernel/tools/makejv3.c
+++ b/Kernel/tools/makejv3.c
@@ -1,3 +1,9 @@
+/*
+ *     Make a jv3 file. At the moment we don't support taking a data
+ *     file and writing it mashed up to match a skewed disk. So you can
+ *     either have a skewed empty disk, or a non skewed data one.
+ */
+
 #include <stdio.h>
 #include <stdint.h>
 #include <unistd.h>
@@ -13,11 +19,10 @@
    
    One of the weirder disk formats emulation folk use */
 
-/* We should do skewing, but that makes writing the image fun, so for now
-   don't bother */
+/* We should do skewing, but that makes writing the image fun, so it's
+   optional */
 
-#if 0
-static int skew[2][18] = {
+static const int skew[2][18] = {
        {
         0x06, 0x0C, 0x01, 0x07, 0x0D, 0x02, 0x08, 0x0E,
         0x03, 0x09, 0x0F, 0x04, 0x0A, 0x10, 0x05, 0x0b,
@@ -25,10 +30,17 @@ static int skew[2][18] = {
        {
         0x01, 0x05, 0x09, 0x02, 0x06, 0x0A, 0x03, 0x00, 0x07, 0x04}
 };
-#endif
 
-static void jvc_writeheaders(int dd, int ntrack, int nside, int nsec,
-                            uint8_t * ptr)
+static int skewed;
+static int infd;
+static int outfd;
+static int ntrack;
+static int nside = 2;
+static int nsec;
+static int ddens;
+static int data;
+
+static void jvc_writeheaders(uint8_t * ptr)
 {
        int i, j, k;
 
@@ -38,8 +50,8 @@ static void jvc_writeheaders(int dd, int ntrack, int nside, int nsec,
                for (j = 0; j < nside; j++) {
                        for (k = 0; k < nsec; k++) {
                                *ptr++ = i;
-                               *ptr++ = k;     /*skew[dd][k] + 1; */
-                               *ptr++ = (0x80 * dd) | (0x10 * j);
+                               *ptr++ = skewed == 0 ? k : skew[ddens][k];
+                               *ptr++ = (0x80 * ddens) | (0x10 * j);
                        }
                }
        }
@@ -48,16 +60,35 @@ static void jvc_writeheaders(int dd, int ntrack, int nside, int nsec,
 }
 
 
-static void jvcwritesectors(int infd, int outfd, int ntrack, int nside,
-                           int nsec)
+static void jvc_pc_writeheaders(uint8_t * ptr)
 {
        int i, j, k;
-       static char buf[256];
+
        for (i = 0; i < ntrack; i++) {
                for (j = 0; j < nside; j++) {
                        for (k = 1; k <= nsec; k++) {
+                               *ptr++ = i;
+                               *ptr++ =
+                                   skewed == 0 ? k : skew[1][k - 1] + 1;
+                               /* 512 byte sectors */
+                               *ptr++ = 0x83 | (0x10 * j);
+                       }
+               }
+       }
+       /* Writeable */
+       *ptr = 1;
+}
+
+static char buf[512];
+
+static void jvc_writesectors(void)
+{
+       int i, j, k;
+       for (i = 0; i < ntrack; i++) {
+               for (j = 0; j < nside; j++) {
+                       for (k = 0; k < nsec; k++) {
                                /* 0 itself is fine - we just blank the rest */
-                               if (read(infd, buf, 256) < 0) {
+                               if (data && read(infd, buf, 256) < 0) {
                                        perror("read sectors");
                                        exit(1);
                                }
@@ -70,34 +101,73 @@ static void jvcwritesectors(int infd, int outfd, int ntrack, int nside,
        }
 }
 
+static void jvc_pc_writesectors(void)
+{
+       int i, j, k;
+       for (i = 0; i < ntrack; i++) {
+               for (j = 0; j < nside; j++) {
+                       for (k = 1; k <= nsec; k++) {
+                               /* 0 itself is fine - we just blank the rest */
+                               if (data && read(infd, buf, 512) < 0) {
+                                       perror("read sectors");
+                                       exit(1);
+                               }
+                               if (write(outfd, buf, 512) != 512) {
+                                       perror("write jvc3");
+                                       exit(1);
+                               }
+                       }
+               }
+       }
+}
+
+
 static char hdrbuf[8704];
 
 static void usage(void)
 {
        fprintf(stderr,
-               "makejv3: example types dd40, dd80, dd40s, dd80s, sd40, sd80, sd40s, sd80s\n");
+               "makejv3: example types dd40, dd80, dd40s, pcdd40s, dd80s, sd40, sd80, sd40s, sd80s\n");
        exit(1);
 }
 
 void main(int argc, char *argv[])
 {
-       int infd, outfd;
-       int nside = 2, dd = 1;
-       char *p = argv[1];
+       int pc = 0;
+       char *p = NULL;
+       char *in = NULL;
        int tracks = 0;
+       int opt;
 
-       if (argc != 4) {
-               fprintf(stderr, "%s [type] [rawfs] [jv3file]\n", argv[0]);
-               exit(1);
+       while ((opt = getopt(argc, argv, "t:d:ms")) != -1) {
+               switch (opt) {
+               case 't':
+                       p = optarg;
+                       break;
+               case 'd':
+                       in = optarg;
+                       break;
+               case 'm':
+                       pc = 1;
+                       ddens = 1;
+                       break;
+               case 's':
+                       skewed = 1;
+                       break;
+               default:
+                       usage();
+               }
        }
+       if (p == NULL || optind != argc - 1)
+               usage();
 
        if ((*p != 's' && *p != 'd') || p[1] != 'd')
                usage();
        if (*p == 's')
-               dd = 0;
+               ddens = 0;
        p += 2;
        while (isdigit(*p)) {
-               tracks = tracks * 10 + (*p - '0');
+               ntrack = ntrack * 10 + (*p - '0');
                p++;
        }
        if (*p == 's') {
@@ -107,22 +177,42 @@ void main(int argc, char *argv[])
        if (*p)
                usage();
 
-       infd = open(argv[2], O_RDONLY);
-       if (infd == -1) {
-               perror(argv[2]);
-               exit(1);
+       if (in) {
+               infd = open(in, O_RDONLY);
+               if (infd == -1) {
+                       perror(in);
+                       exit(1);
+               }
+               data = 1;
+               if (skewed) {
+                       fprintf(stderr,
+                               "%s: skewing and data not supported together.\n",
+                               argv[0]);
+                       exit(1);
+               }
        }
-       outfd = open(argv[3], O_WRONLY | O_TRUNC | O_CREAT, 0666);
+       outfd = open(argv[optind], O_WRONLY | O_TRUNC | O_CREAT, 0666);
        if (outfd == -1) {
                perror(argv[3]);
                exit(1);
        }
-       jvc_writeheaders(dd, tracks, nside, dd ? 18 : 10, hdrbuf);
+       if (pc) {
+               if (!ddens)
+                       usage();
+               nsec = 9;
+               jvc_pc_writeheaders(hdrbuf);
+       } else {
+               nsec = ddens ? 18 : 10;
+               jvc_writeheaders(hdrbuf);
+       }
        if (write(outfd, hdrbuf, 8704) != 8704) {
                perror(argv[3]);
                exit(1);
        }
-       jvcwritesectors(infd, outfd, tracks, nside, dd ? 18 : 10);
+       if (pc)
+               jvc_pc_writesectors();
+       else
+               jvc_writesectors();
        close(infd);
        close(outfd);
        exit(0);