source: buchla-68k/orig/BUCHLA/VSDDCALC.C

/*
   =============================================================================
        vsddcalc.c -- calculate some VSDD values
        Version 8 -- 1989-01-25 -- D.N. Lynx Crowe
   =============================================================================
*/

#include "stdio.h"
#include "stddefs.h"

#define PSA     0               /* value for psa */
#define HRS     1               /* value for hrs */

#define VCK     12800000L       /* value for video clock (Hz) */

#define HC0     3               /* width of HSYNC (GCLKs - 1) */
#define HC1     5               /* AHZ start (GCLKs - 1) */
#define HC2     37              /* AHZ stop (GCLKs - 1) */
#define HC3     40              /* horizontal sweep (GCLKs - 1) */

#define VC0     8               /* width of VSYNC (lines - 1) */
#define VC1     10              /* AVZ start (lines - 1) */
#define VC2     360             /* AVZ stop (lines - 1) */
#define VC3     362             /* vertical sweep (lines - 1) */

/* 

*/

short   hrs = HRS,              /* High Resolution Select */
        psa = PSA,              /* Pre-Scaler Active */
        ahp,                    /* active horizontal period (GCLKs) */
        avl,                    /* active vertical lines */
        gpix,                   /* pixels per GCLK */
        hpix,                   /* active pixels per line */
        hc0 = HC0 + 1,          /* width of HSYNC (GCLKs) */
        hc1 = HC1 + 1,          /* AHZ start (GCLKs) */
        hc2 = HC2 + 1,          /* AHZ stop (GCLKs) */
        hc3 = HC3 + 1,          /* horizontal sweep (GCLKs) */
        hc4,                    /* 1/2 horizontal sweep (GCLKs) */
        hrate,                  /* horizontal sweep rate (Hz) */
        ihp,                    /* inactive horizontal period (GCLKs) */
        ivl,                    /* inactive vertical lines */
        vc0 = VC0 + 1,          /* width of VSYNC (lines) */
        vc1 = VC1 + 1,          /* AVZ start (lines) */
        vc2 = VC2 + 1,          /* AVZ stop (lines) */
        vc3 = VC3 + 1,          /* vertical sweep (lines) */
        vrate;                  /* vertical sweep rate (Hz) */

long    gclk,                   /* general clock (Hz) */
        gclkn,                  /* general clock (nanoseconds) */
        vck = VCK,              /* video clock (Hz) */
        pixclk,                 /* pixel clock (Hz) */
        vph,                    /* sync gnerator clock (Hz) */
        ahz,                    /* active horizontal zone time (nanoseconds) */
        avz,                    /* active vertical zone time (nanoseconds) */
        hsweep,                 /* horizontal sweep time (nanoseconds) */
        hsync,                  /* horizontal sync time (nanoseconds) */
        vsweep,                 /* vertical sweep time (nanoseconds) */
        vsync;                  /* vertical sync time (nanoseconds) */

/* 

*/

main()
{
        /* check horizontal constants */

        if (hc0 GE hc1) {

                printf("ERROR:  hc0 {%d} must be < hc1 {%d}\n", hc0, hc1);
                exit(1);
        }

        hc4 = hc3 >> 1;

        if (hc1 GE hc4) {

                printf("ERROR:  hc1 {%d} must be < (hc3 / 2) {%d}\n", hc1, hc4);
                exit(1);
        }

        if (hc4 GE hc2) {

                printf("ERROR:  hc2 {%d} must be > (hc3 / 2) {%d}\n", hc2, hc4);
                exit(1);
        }

        if (hc2 GE hc3) {

                printf("ERROR:  hc2 {%d} must be < hc3 {%d}\n", hc2, hc3);
                exit(1);
        }

        /* check vertical constants */

        if (vc0 GE vc1) {

                printf("ERROR:  vc0 {%d} must be < vc1 {%d}\n", vc0, vc1);
                exit(1);
        }

        if (vc1 GE vc2) {

                printf("ERROR:  vc1 {%d} must be < vc2 {%d}\n", vc1, vc2);
                exit(1);
        }

        if (vc2 GE vc3) {

                printf("ERROR:  vc2 {%d} must be < vc3 {%d}\n", vc2, vc3);
                exit(1);
        }

/* 

*/
        /* caluclate pixel clock */

        if (hrs)
                pixclk = vck;
        else
                pixclk = vck >> 1;

        /* calculate internal clock */

        if (psa)
                vph = vck >> 2;
        else
                vph = vck >> 1;

        /* check internal clock limit */

        if (vph > 8000000L) {

                printf("\nERROR:  Calculated vph {%ld} is > 8000000\n", vph);

                if (psa)
                        printf("   Try a lower value for vck {%ld}\n", vck);
                else
                        printf("   Try psa = 1\n");

                exit(1);
        }

        /* calculate general clock */

        gclk = vph >> 3;
        gclkn  = (1000000000L / (gclk / 1000)) / 1000;

        gpix = pixclk / gclk;

        /* calculate horizontal timings */

        ahp    = hc2 - hc1;
        ihp    = hc3 - ahp;
        hsync  = hc0 * gclkn;
        hsweep = hc3 * gclkn;
        ahz    = ahp * gclkn;
        hpix   = ahp * gpix;
        hrate  = 1000000000L / hsweep;

        /* calculate vertical timings */

        avl    = vc2 - vc1;
        ivl    = vc3 - avl;
        vsync  = vc0 * hsweep;
        vsweep = vc3 * hsweep;
        avz    = avl * hsweep;
        vrate  = 1000000000L / vsweep;

/* 

*/
        /* print the results */

        printf("82716 VSDD Timing Calculations\n");
        printf("------------------------------\n\n");

        printf("   with HRS = %d and PSA = %d\n\n", hrs, psa);

        printf("Clock values\n");
        printf("------------\n\n");

        printf("VCK    = %8ld Hz   Master clock\n", vck);
        printf("PIXCLK = %8ld Hz   Pixel clock\n", pixclk);
        printf("VPH    = %8ld Hz   Internal clock\n", vph);
        printf("GCLK   = %8ld Hz   General clock  (%ld nanoseconds)\n\n",
                gclk, gclkn);


        printf("Horizontal values                 Vertical values\n");
        printf("-----------------                 ---------------\n\n");

        printf("HC0    = %8d GCLKs           VC0    = %8d lines   sync\n",
                hc0, vc0);

        printf("HC1    = %8d GCLKs           VC1    = %8d lines   start\n",
                hc1, vc1);

        printf("HC2    = %8d GCLKs           VC2    = %8d lines   stop\n",
                hc2, vc2);

        printf("HC3    = %8d GCLKs           VC3    = %8d lines   sweep\n\n",
                hc3, vc3);

        printf("AHP    = %8d GCLKs           AVL    = %8d lines   active\n",
                ahp, avl);

        printf("IHP    = %8d GCLKs           IVL    = %8d lines   inactive\n\n",
                ihp, ivl);


        printf("HSYNC  = %8ld nanoseconds     VSYNC  = %8ld nanoseconds\n",
                hsync, vsync);

        printf("HSWEEP = %8ld nanoseconds     VSWEEP = %8ld nanoseconds\n",
                hsweep, vsweep);

        printf("AHZ    = %8ld nanoseconds     AVZ    = %8ld nanoseconds\n\n",
                ahz, avz);


        printf("Miscellaneous values\n");
        printf("--------------------\n\n");

        printf("GPIX   = %8d pixels / GCLK   HPIX   = %8d pixels displayed\n",
                gpix, hpix);

        printf("HRATE  = %8d Hz              VRATE  = %8d Hz\n\n",
                hrate, vrate);

        exit(0);
}