* Code cleanup:

[people/ms/u-boot.git] / board / MAI / bios_emulator / scitech / src / common / gtfcalc.c

/****************************************************************************
*
*                   VESA Generalized Timing Formula (GTF)
*                               Version 1.1
*
*  ========================================================================
*
*    The contents of this file are subject to the SciTech MGL Public
*    License Version 1.0 (the "License"); you may not use this file
*    except in compliance with the License. You may obtain a copy of
*    the License at http://www.scitechsoft.com/mgl-license.txt
*
*    Software distributed under the License is distributed on an
*    "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
*    implied. See the License for the specific language governing
*    rights and limitations under the License.
*
*    The Original Code is Copyright (C) 1991-1998 SciTech Software, Inc.
*
*    The Initial Developer of the Original Code is SciTech Software, Inc.
*    All Rights Reserved.
*
*  ========================================================================
*
* Developed by: SciTech Software, Inc.
*
* Language:     ANSI C
* Environment:  Any.
*
* Description:  C module for generating GTF compatible timings given a set
*               of input requirements. Translated from the original GTF
*               1.14 spreadsheet definition.
*
*               Compile with #define TESTING to build a command line test
*               program.
*
*               NOTE: The code in here has been written for clarity and
*                     to follow the original GTF spec as closely as
*                     possible.
*
****************************************************************************/

#include "gtf.h"
#ifndef __WIN32_VXD__
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
#include <math.h>
#endif

/*------------------------- Global Variables ------------------------------*/

static GTF_constants GC = {
    1.8,                    /* Margin size as percentage of display     */
    8,                      /* Character cell granularity               */
    1,                      /* Minimum front porch in lines/chars       */
    3,                      /* Width of V sync in lines                 */
    8,                      /* Width of H sync as percent of total      */
    550,                    /* Minimum vertical sync + back porch (us)  */
    600,                    /* Blanking formula gradient                */
    40,                     /* Blanking formula offset                  */
    128,                    /* Blanking formula scaling factor          */
    20,                     /* Blanking formula scaling factor weight   */
    };

/*-------------------------- Implementation -------------------------------*/

#ifdef __WIN32_VXD__
/* These functions are not supported in a VxD, so we stub them out so this
 * module will at least compile. Calling the functions in here will do
 * something wierd!
 */
double sqrt(double x)
{ return x; }

double floor(double x)
{ return x; }

double pow(double x,double y)
{ return x*y; }
#endif

static double round(double v)
{
    return floor(v + 0.5);
}

static void GetInternalConstants(GTF_constants *c)
/****************************************************************************
*
* Function:     GetInternalConstants
* Parameters:   c   - Place to store the internal constants
*
* Description:  Calculates the rounded, internal set of GTF constants.
*               These constants are different to the real GTF constants
*               that can be set up for the monitor. The calculations to
*               get these real constants are defined in the 'Work Area'
*               after the constants are defined in the Excel spreadsheet.
*
****************************************************************************/
{
    c->margin = GC.margin;
    c->cellGran = round(GC.cellGran);
    c->minPorch = round(GC.minPorch);
    c->vSyncRqd = round(GC.vSyncRqd);
    c->hSync = GC.hSync;
    c->minVSyncBP = GC.minVSyncBP;
    if (GC.k == 0)
        c->k = 0.001;
    else
        c->k = GC.k;
    c->m = (c->k / 256) * GC.m;
    c->c = (GC.c - GC.j) * (c->k / 256) + GC.j;
    c->j = GC.j;
}

void GTF_calcTimings(double hPixels,double vLines,double freq,
    int type,ibool wantMargins,ibool wantInterlace,GTF_timings *t)
/****************************************************************************
*
* Function:     GTF_calcTimings
* Parameters:   hPixels     - X resolution
*               vLines      - Y resolution
*               freq        - Frequency (Hz, KHz or MHz depending on type)
*               type        - 1 - vertical, 2 - horizontal, 3 - dot clock
*               margins     - True if margins should be generated
*               interlace   - True if interlaced timings to be generated
*               t           - Place to store the resulting timings
*
* Description:  Calculates a set of GTF timing parameters given a specified
*               resolution and vertical frequency. The horizontal frequency
*               and dot clock will be automatically generated by this
*               routines.
*
*               For interlaced modes the CRTC parameters are calculated for
*               a single field, so will be half what would be used in
*               a non-interlaced mode.
*
****************************************************************************/
{
    double          interlace,vFieldRate,hPeriod;
    double          topMarginLines,botMarginLines;
    double          leftMarginPixels,rightMarginPixels;
    double          hPeriodEst,vSyncBP,vBackPorch;
    double          vTotalLines,vFieldRateEst;
    double          hTotalPixels,hTotalActivePixels,hBlankPixels;
    double          idealDutyCycle,hSyncWidth,hSyncBP,hBackPorch;
    double          idealHPeriod;
    double          vFreq,hFreq,dotClock;
    GTF_constants   c;

    /* Get rounded GTF constants used for internal calculations */
    GetInternalConstants(&c);

    /* Move input parameters into appropriate variables */
    vFreq = hFreq = dotClock = freq;

    /* Round pixels to character cell granularity */
    hPixels = round(hPixels / c.cellGran) * c.cellGran;

    /* For interlaced mode halve the vertical parameters, and double
     * the required field refresh rate.
     */
    vFieldRate = vFreq;
    interlace = 0;
    if (wantInterlace)
        dotClock *= 2;

    /* Determine the lines for margins */
    if (wantMargins) {
        topMarginLines = round(c.margin / 100 * vLines);
        botMarginLines = round(c.margin / 100 * vLines);
        }
    else {
        topMarginLines = 0;
        botMarginLines = 0;
        }

    if (type != GTF_lockPF) {
        if (type == GTF_lockVF) {
            /* Estimate the horizontal period */
            hPeriodEst = ((1/vFieldRate) - (c.minVSyncBP/1000000)) /
                (vLines + (2*topMarginLines) + c.minPorch + interlace) * 1000000;

            /* Find the number of lines in vSync + back porch */
            vSyncBP = round(c.minVSyncBP / hPeriodEst);
            }
        else if (type == GTF_lockHF) {
            /* Find the number of lines in vSync + back porch */
            vSyncBP = round((c.minVSyncBP * hFreq) / 1000);
            }

        /* Find the number of lines in the V back porch alone */
        vBackPorch = vSyncBP - c.vSyncRqd;

        /* Find the total number of lines in the vertical period */
        vTotalLines = vLines + topMarginLines + botMarginLines + vSyncBP
            + interlace + c.minPorch;

        if (type == GTF_lockVF) {
            /* Estimate the vertical frequency */
            vFieldRateEst = 1000000 / (hPeriodEst * vTotalLines);

            /* Find the actual horizontal period */
            hPeriod = (hPeriodEst * vFieldRateEst) / vFieldRate;

            /* Find the actual vertical field frequency */
            vFieldRate = 1000000 / (hPeriod * vTotalLines);
            }
        else if (type == GTF_lockHF) {
            /* Find the actual vertical field frequency */
            vFieldRate = (hFreq / vTotalLines) * 1000;
            }
        }

    /* Find the number of pixels in the left and right margins */
    if (wantMargins) {
        leftMarginPixels = round(hPixels * c.margin) / (100 * c.cellGran);
        rightMarginPixels = round(hPixels * c.margin) / (100 * c.cellGran);
        }
    else {
        leftMarginPixels = 0;
        rightMarginPixels = 0;
        }

    /* Find the total number of active pixels in image + margins */
    hTotalActivePixels = hPixels + leftMarginPixels + rightMarginPixels;

    if (type == GTF_lockVF) {
        /* Find the ideal blanking duty cycle */
        idealDutyCycle = c.c - ((c.m * hPeriod) / 1000);
        }
    else if (type == GTF_lockHF) {
        /* Find the ideal blanking duty cycle */
        idealDutyCycle = c.c - (c.m / hFreq);
        }
    else if (type == GTF_lockPF) {
        /* Find ideal horizontal period from blanking duty cycle formula */
        idealHPeriod = (((c.c - 100) + (sqrt((pow(100-c.c,2)) +
            (0.4 * c.m * (hTotalActivePixels + rightMarginPixels +
            leftMarginPixels) / dotClock)))) / (2 * c.m)) * 1000;

        /* Find the ideal blanking duty cycle */
        idealDutyCycle = c.c - ((c.m * idealHPeriod) / 1000);
        }

    /* Find the number of pixels in blanking time */
    hBlankPixels = round((hTotalActivePixels * idealDutyCycle) /
        ((100 - idealDutyCycle) * c.cellGran)) * c.cellGran;

    /* Find the total number of pixels */
    hTotalPixels = hTotalActivePixels + hBlankPixels;

    /* Find the horizontal back porch */
    hBackPorch = round((hBlankPixels / 2) / c.cellGran) * c.cellGran;

    /* Find the horizontal sync width */
    hSyncWidth = round(((c.hSync/100) * hTotalPixels) / c.cellGran) * c.cellGran;

    /* Find the horizontal sync + back porch */
    hSyncBP = hBackPorch + hSyncWidth;

    if (type == GTF_lockPF) {
        /* Find the horizontal frequency */
        hFreq = (dotClock / hTotalPixels) * 1000;

        /* Find the number of lines in vSync + back porch */
        vSyncBP = round((c.minVSyncBP * hFreq) / 1000);

        /* Find the number of lines in the V back porch alone */
        vBackPorch = vSyncBP - c.vSyncRqd;

        /* Find the total number of lines in the vertical period */
        vTotalLines = vLines + topMarginLines + botMarginLines + vSyncBP
            + interlace + c.minPorch;

        /* Find the actual vertical field frequency */
        vFieldRate = (hFreq / vTotalLines) * 1000;
        }
    else {
        if (type == GTF_lockVF) {
            /* Find the horizontal frequency */
            hFreq = 1000 / hPeriod;
            }
        else if (type == GTF_lockHF) {
            /* Find the horizontal frequency */
            hPeriod = 1000 / hFreq;
            }

        /* Find the pixel clock frequency */
        dotClock = hTotalPixels / hPeriod;
        }

    /* Return the computed frequencies */
    t->vFreq = vFieldRate;
    t->hFreq = hFreq;
    t->dotClock = dotClock;

    /* Determine the vertical timing parameters */
    t->h.hTotal = (int)hTotalPixels;
    t->h.hDisp = (int)hTotalActivePixels;
    t->h.hSyncStart = t->h.hTotal - (int)hSyncBP;
    t->h.hSyncEnd = t->h.hTotal - (int)hBackPorch;
    t->h.hFrontPorch = t->h.hSyncStart - t->h.hDisp;
    t->h.hSyncWidth = (int)hSyncWidth;
    t->h.hBackPorch = (int)hBackPorch;

    /* Determine the vertical timing parameters */
    t->v.vTotal = (int)vTotalLines;
    t->v.vDisp = (int)vLines;
    t->v.vSyncStart = t->v.vTotal - (int)vSyncBP;
    t->v.vSyncEnd = t->v.vTotal - (int)vBackPorch;
    t->v.vFrontPorch = t->v.vSyncStart - t->v.vDisp;
    t->v.vSyncWidth = (int)c.vSyncRqd;
    t->v.vBackPorch = (int)vBackPorch;
    if (wantInterlace) {
        /* Halve the timings for interlaced modes */
        t->v.vTotal /= 2;
        t->v.vDisp /= 2;
        t->v.vSyncStart /= 2;
        t->v.vSyncEnd /= 2;
        t->v.vFrontPorch /= 2;
        t->v.vSyncWidth /= 2;
        t->v.vBackPorch /= 2;
        t->dotClock /= 2;
        }

    /* Mark as GTF timing using the sync polarities */
    t->interlace = (wantInterlace) ? 'I' : 'N';
    t->hSyncPol = '-';
    t->vSyncPol = '+';
}

void GTF_getConstants(GTF_constants *constants)
{ *constants = GC; }

void GTF_setConstants(GTF_constants *constants)
{ GC = *constants; }

#ifdef  TESTING_GTF

void main(int argc,char *argv[])
{
    FILE        *f;
    double      xPixels,yPixels,freq;
    ibool       interlace;
    GTF_timings t;

    if (argc != 5 && argc != 6) {
        printf("Usage: GTFCALC <xPixels> <yPixels> <freq> [[Hz] [KHz] [MHz]] [I]\n");
        printf("\n");
        printf("where <xPixels> is the horizontal resolution of the mode, <yPixels> is the\n");
        printf("vertical resolution of the mode. The <freq> value will be the frequency to\n");
        printf("drive the calculations, and will be either the vertical frequency (in Hz)\n");
        printf("the horizontal frequency (in KHz) or the dot clock (in MHz). To generate\n");
        printf("timings for an interlaced mode, add 'I' to the end of the command line.\n");
        printf("\n");
        printf("For example to generate timings for 640x480 at 60Hz vertical:\n");
        printf("\n");
        printf("    GTFCALC 640 480 60 Hz\n");
        printf("\n");
        printf("For example to generate timings for 640x480 at 31.5KHz horizontal:\n");
        printf("\n");
        printf("    GTFCALC 640 480 31.5 KHz\n");
        printf("\n");
        printf("For example to generate timings for 640x480 with a 25.175Mhz dot clock:\n");
        printf("\n");
        printf("    GTFCALC 640 480 25.175 MHz\n");
        printf("\n");
        printf("GTFCALC will print a summary of the results found, and dump the CRTC\n");
        printf("values to the UVCONFIG.CRT file in the format used by SciTech Display Doctor.\n");
        exit(1);
        }

    /* Get values from command line */
    xPixels = atof(argv[1]);
    yPixels = atof(argv[2]);
    freq = atof(argv[3]);
    interlace = ((argc == 6) && (argv[5][0] == 'I'));

    /* Compute the CRTC timings */
    if (toupper(argv[4][0]) == 'H')
        GTF_calcTimings(xPixels,yPixels,freq,GTF_lockVF,false,interlace,&t);
    else if (toupper(argv[4][0]) == 'K')
        GTF_calcTimings(xPixels,yPixels,freq,GTF_lockHF,false,interlace,&t);
    else if (toupper(argv[4][0]) == 'M')
        GTF_calcTimings(xPixels,yPixels,freq,GTF_lockPF,false,interlace,&t);
    else {
        printf("Unknown command line!\n");
        exit(1);
        }

    /* Dump summary info to standard output */
    printf("CRTC values for %.0fx%.0f @ %.2f %s\n", xPixels, yPixels, freq, argv[4]);
    printf("\n");
    printf("  hTotal      = %-4d    vTotal      = %-4d\n",
        t.h.hTotal, t.v.vTotal);
    printf("  hDisp       = %-4d    vDisp       = %-4d\n",
        t.h.hDisp, t.v.vDisp);
    printf("  hSyncStart  = %-4d    vSyncStart  = %-4d\n",
        t.h.hSyncStart, t.v.vSyncStart);
    printf("  hSyncEnd    = %-4d    vSyncEnd    = %-4d\n",
        t.h.hSyncEnd, t.v.vSyncEnd);
    printf("  hFrontPorch = %-4d    vFrontPorch = %-4d\n",
        t.h.hFrontPorch, t.v.vFrontPorch);
    printf("  hSyncWidth  = %-4d    vSyncWidth  = %-4d\n",
        t.h.hSyncWidth, t.v.vSyncWidth);
    printf("  hBackPorch  = %-4d    vBackPorch  = %-4d\n",
        t.h.hBackPorch, t.v.vBackPorch);
    printf("\n");
    printf("  Interlaced  = %s\n", (t.interlace == 'I') ? "Yes" : "No");
    printf("  H sync pol  = %c\n", t.hSyncPol);
    printf("  V sync pol  = %c\n", t.vSyncPol);
    printf("\n");
    printf("  Vert freq   = %.2f Hz\n", t.vFreq);
    printf("  Horiz freq  = %.2f KHz\n", t.hFreq);
    printf("  Dot Clock   = %.2f Mhz\n",    t.dotClock);

    /* Dump to file in format used by SciTech Display Doctor */
    if ((f = fopen("UVCONFIG.CRT","w")) != NULL) {
        fprintf(f, "[%.0f %.0f]\n", xPixels, yPixels);
        fprintf(f, "%d %d %d %d '%c' %s\n",
            t.h.hTotal, t.h.hDisp,
            t.h.hSyncStart, t.h.hSyncEnd,
            t.hSyncPol, (t.interlace == 'I') ? "I" : "NI");
        fprintf(f, "%d %d %d %d '%c'\n",
            t.v.vTotal, t.v.vDisp,
            t.v.vSyncStart, t.v.vSyncEnd,
            t.vSyncPol);
        fprintf(f, "%.2f\n", t.dotClock);
        fclose(f);
        }
}

#endif  /* TESTING */