home *** CD-ROM | disk | FTP | other *** search
/ World of A1200 / World_Of_A1200.iso / programs / develop / galer / galer_english / source / galersrce.lha / GAL.c next >
Encoding:
C/C++ Source or Header  |  1993-03-26  |  21.2 KB  |  812 lines
  1. /****************************************************************/
  2. /*                                */
  3. /* GAL.c - enthält Routinen zum Beschreiben und zum Lesen    */
  4. /* von GALs                            */
  5. /*                                */
  6. /* compilieren: cc GAL.c                    */
  7. /*                                */
  8. /****************************************************************/
  9.  
  10.  
  11.  
  12. #include <exec/types.h>
  13. #include <intuition/intuition.h>
  14. #include <ctype.h>
  15. #include <stdio.h>
  16.  
  17. #include "GALer.h"
  18.  
  19.  
  20. extern    char    path[];
  21. extern    int    GALType, JedecSecurity, JedecGALType;
  22. extern    struct    JedecStruct    Jedec;
  23. extern    struct    Configuration    Config;
  24. extern    struct    Gadget        SGadget20;
  25. extern    struct    Gadget        SGadget21;
  26. extern    struct    Gadget        SGadget22;
  27. extern    struct    Gadget        SGadget23;
  28. extern    struct    IntuiText    SIText19, ITextW;
  29. extern    struct    Requester    req;
  30.  
  31.  
  32. int    MaxFuseAdr, SigAdr;
  33.  
  34. extern    long    prog_time;
  35.  
  36. struct    JedecStruct    Jedec2;
  37.  
  38.  
  39. UBYTE    SignatureTxt[] = "Signature:$00 $00 $00 $00 $00 $00 $00 $00  :  XXXXXXXX";
  40. UBYTE    PTTxt[]        = "PT: 0000000000000000000000000000000000000000000000000000000000000000";
  41. UBYTE    ConTxt[]       = "XOR(n): 00000000    SYN: 0    AC0: 0";
  42. UBYTE    AC1Txt[]       = "AC1(n): 00000000";
  43.  
  44.  
  45. struct IntuiText CmpIText5 = { 2,0,JAM1,23,30,NULL,
  46.                    (UBYTE *)"       Compare once more?",NULL};
  47.  
  48. struct IntuiText CmpIText4 = { 2,0,JAM1,67,10,NULL,
  49.                    (UBYTE *)"Cancel comparison.",&CmpIText5};
  50.  
  51. struct IntuiText CmpIText3 = { 2,0,JAM1,47,10,NULL,
  52.                    (UBYTE *)"   Signature not equal!",&CmpIText5 };
  53.  
  54. struct IntuiText CmpIText2 = { 2,0,JAM1,91,10,NULL,
  55.                    (UBYTE *)"   NOT equal!",&CmpIText5 };
  56.  
  57. struct IntuiText CmpIText1 = { 2,0,JAM1,87,10,NULL,
  58.                    (UBYTE *)"     Equal!",&CmpIText5 };
  59.  
  60.  
  61.  
  62.  
  63. /*ProgramGAL
  64.   liest Jedec-Datei ein und programmiert anschließend das GAL
  65.   Aufruf: ProgramGAL();
  66. */
  67. void ProgramGAL()
  68. {
  69.  if (MyRequest(GALTYPE_REQ,(UBYTE *)"Program a GAL?")) {
  70.    if (MyFileReq((char *)"Load JEDEC file", (char *)".jed",YES)) {
  71.      if (!(GetJedec(&path[0]))) {
  72.        if (GALType != JedecGALType) {        /*überprüfen, ob der einge-*/
  73.      JedecError(25,NO);            /*stellte GAL-Typ zum Jedec-*/
  74.      return;                /*File paßt*/
  75.     }
  76.        if (ReadGALParameter(YES))        /*GAL-Parameter holen*/
  77.      return;                /*bei Fehler return*/
  78.        if (!ProgJedecToGAL(PROGGAL)) {
  79.      if (JedecSecurity)            /*war im Jedec-File das Sec.*/
  80.        SetSecurity(NO);            /*gesetzt? */ 
  81.      MyRequest(INFO_REQ,(UBYTE *)"GAL programmed.");
  82.     }
  83.        else
  84.      return;
  85.       }
  86.     }
  87.   }
  88. }
  89.  
  90.  
  91. /* GAL kopieren
  92. */
  93. void CopyGAL()
  94. {
  95. int    flag;
  96. BYTE    atype;
  97.  
  98.  if (MyRequest(GALTYPE_REQ,(UBYTE *)"Copy GAL?")) {
  99.    if (ReadGALParameter(YES))            /*GAL-Parameter holen*/
  100.      return;                    /*bei Fehler return*/
  101.    PrintText((UBYTE *)"reading GAL...",1);
  102.    ReadGALToJedec();
  103.    PrintText((UBYTE *)" o.k.",0);
  104.  
  105.    flag = 0;
  106.    for (;;) {
  107.      if (flag)
  108.        if (!MyRequest(CONT_REQ,(UBYTE *)"Copy the GAL once more?"))
  109.          break;
  110.      flag = 1;
  111.  
  112.      if (Config.AutoAType) {
  113.        MyRequest(INFO_REQ,(UBYTE *)"Please insert dest. GAL.");
  114.        if (!ReadGALParameter(YES))        /*GAL-Parameter holen*/
  115.          ProgJedecToGAL(COPYGAL);        /*kein Fehler, dann prog.*/
  116.       }
  117.      else {
  118.        atype = Config.AType;
  119.        Config.AType = MyRequest(ATYPE_REQ,(UBYTE *)"Please insert dest. GAL.");
  120.        if (!ReadGALParameter(YES))        /*GAL-Parameter holen*/
  121.          ProgJedecToGAL(COPYGAL);        /*kein Fehler, dann prog.*/
  122.        Config.AType = atype;
  123.       }
  124.     }
  125.   }
  126. }
  127.  
  128.  
  129.  
  130. /* überprüfe, ob GAL leer ist*/
  131. void Leertest()
  132. {
  133. int result;
  134.  
  135.  if (MyRequest(GALTYPE_REQ,(UBYTE *)"Blank test?")) {
  136.    if (ReadGALParameter(YES))            /*GAL-Parameter holen*/
  137.      return;                    /*bei Fehler return*/
  138.    PrintText((UBYTE *)"executing blank test...",1);
  139.    result = CheckGAL();
  140.    PrintText((UBYTE *)" ready",0);
  141.  
  142.    if (result)
  143.      MyRequest(INFO_REQ,(UBYTE *)"GAL is blank!");
  144.    else
  145.      MyRequest(INFO_REQ,(UBYTE *)"GAL is NOT blank!");
  146.   }
  147. }
  148.  
  149.  
  150.  
  151. /* CheckGAL:   teste ob GAL leer ist
  152.    Vor dem Aufruf von dieser Routine sollten mit ReadGALParameter(YES) die
  153.    GAL-Parameter erfolgreich gelesen worden sein.
  154.    Aufruf:   return=CheckGAL();
  155.    Ergebnis: return = 0 : GAL ist leer
  156.               1 : Logik-Matrix ist nicht leer
  157.               2 : Logik-Matrix ist leer, aber Rest nicht
  158. */
  159. int CheckGAL()
  160. {
  161. int    n, row;
  162.  
  163.  
  164.  LED(ON);
  165.  EditMode(VERIFY);                /*GAL in Verify-Mode*/
  166.  
  167.  for (row=0; row<=MaxFuseAdr; row++) {        /*Logik-Matrix lesen*/
  168.    SetRow(row);                /*Adresse anlegen*/
  169.    STRImpuls(VERIFY_TIME);        /*Bits in's Schieberegister holen*/
  170.    for (n=0; n<ROW_SIZE; n++) {        /*seriell auslesen*/
  171.      if (!SDOut()) {                /*SDOut-Ausgang lesen*/
  172.        ExitEditMode();
  173.        return(1);
  174.       }
  175.      Clock();                    /*nächstes Bit an SDOut holen*/
  176.     }
  177.   }
  178.  
  179.  SetRow(SigAdr);                 /*Signatur auslesesn*/
  180.  STRImpuls(VERIFY_TIME);
  181.  for (n=0; n<SIG_SIZE; n++) {
  182.     if (!SDOut()) {
  183.       ExitEditMode();
  184.       return(2);
  185.      }
  186.     Clock();
  187.    }
  188.  
  189.  SetRow(ACW_ADR);                /*Architecture Control Word holen*/
  190.  STRImpuls(VERIFY_TIME);            /*Bits in's Schieberegister*/
  191.  for (n=0; n<ACW_SIZE; n++) {
  192.    if (!SDOut()) {
  193.      ExitEditMode();
  194.      return(2);
  195.     }
  196.    Clock();
  197.   }
  198.  
  199.  ExitEditMode();
  200.  return(0);                    /*GAL ist leer*/
  201. }
  202.  
  203.  
  204.  
  205.  
  206. /*testen, ob Sicherungsbit gesetzt ist
  207.   Das geht so (hoffe ich zumindest): Die Funktion CheckGAL gibt eine 0
  208.   zurück wenn das GAL leer ist, eine 1 wenn in der Logik-Matrix eine
  209.   0 vorkommt und eine 2 wenn erst im ACW oder in der Signatur eine 0 vor-
  210.   kommt. Wenn in der Logik-Matrix eine 0 vorkommt, kann das Security-Bit
  211.   nicht gesetzt sein. Wenn in der Logik-Matrix nur 1 vorkommt und der Rest
  212.   (Signatur...), der ja auch bei gesetztem Bit ausgelesen werden kann,
  213.   eine 0 enthält, folgt daraus, daß das Secruity-Bit gesetzt ist.
  214. */
  215. void TestSecurity()
  216. {
  217. int result;
  218.  
  219.  if (MyRequest(GALTYPE_REQ,(UBYTE *)"Test security bit?")) {
  220.    if (ReadGALParameter(YES))            /*GAL-Parameter holen*/
  221.      return;                    /*bei Fehler return*/
  222.    result = CheckGAL();
  223.    if (result == 2)
  224.      MyRequest(INFO_REQ,(UBYTE *)"Security bit is set!");
  225.    else
  226.      if (result == 1)
  227.        MyRequest(INFO_REQ,(UBYTE *)"Security bit is NOT set!");
  228.      else
  229.        MyRequest(INFO_REQ,(UBYTE *)"GAL is blank!");
  230.   }
  231. }
  232.  
  233.  
  234.  
  235.  
  236.  
  237.  
  238.  
  239. /* Compare:  führt Vergleich durch zwischen GAL-GAL, GAL-Jedec, Jedec-GAL
  240.    Aufruf:     Compare();
  241.    Ergebnis:     ---
  242. */
  243. void Compare()
  244. {
  245. int    n, row, cmptype, result, execute;
  246. int    logic, acw, signature;
  247. BYTE    atype;
  248. UBYTE    *old_txt;
  249.  
  250.  
  251.  if (!(cmptype = CompareRequester()))            /*Abbruch?*/
  252.    return;
  253.  
  254.  if (cmptype == 1)                    /*GAL mit GAL*/
  255.    if (!MyRequest(GALTYPE_REQ,(UBYTE *)"Compare GAL with GAL."))
  256.      return;
  257.  if (cmptype == 2)                    /*GAL mit Jedec*/
  258.    if (!MyRequest(GALTYPE_REQ,(UBYTE *)"Compare GAL with JEDEC file."))
  259.      return;
  260.  if ((cmptype == 3) && (Config.GALTypeReq)) {
  261.    old_txt = SIText19.IText;
  262.    SIText19.IText = (UBYTE *)" GAL which you want to compare with a JEDEC file.";
  263.    result = MyRequest(GALTYPE_REQ,(UBYTE *)"Compare JEDEC file with GAL. Please select type of");
  264.    SIText19.IText = old_txt;
  265.  
  266.    if (!result)
  267.      return;
  268.   }
  269.  
  270.  
  271.  if ((cmptype == 1) || (cmptype == 2)) {
  272.    if (ReadGALParameter(YES))            /*GAL-Parameter holen*/
  273.      return;                    /*bei Fehler return*/
  274.    PrintText((UBYTE *)"reading GAL...",1);
  275.    ReadGALToJedec();                /*Jedec-Struktur erstellen*/
  276.    PrintText((UBYTE *)" o.k.",0);
  277.   }
  278.  if (cmptype == 3) {
  279.    if (MyFileReq((char *)"Load JEDEC file", (char *)".jed",YES)) {
  280.      if (GetJedec(&path[0]))            /*Jedec-File in Struktur*/
  281.        return;
  282.      if (GALType != JedecGALType) {        /*überprüfen, ob der einge-*/
  283.        JedecError(25,NO);            /*stellte GAL-Typ zum Jedec-*/
  284.        return;                    /*File paßt*/
  285.       }
  286.     }
  287.    else
  288.      return;
  289.   }
  290.  
  291.  
  292.  for (n=0; n<sizeof(Jedec2); n++)        /*Jedec-Struktur sichern*/
  293.    Jedec2.GALLogic[n] = Jedec.GALLogic[n];
  294.  
  295.  
  296.  for (;;) {
  297.    execute = 1;
  298.    if ((cmptype == 1) || (cmptype == 3)) {
  299.      if (Config.AutoAType) {
  300.        MyRequest(INFO_REQ,(UBYTE *)"Please insert GAL too compare.");
  301.        if (!ReadGALParameter(YES)) {        /*GAL-Parameter holen*/
  302.      PrintText((UBYTE *)"reading GAL...",1); /*o.k.? dann weiter*/
  303.      ReadGALToJedec();
  304.      PrintText((UBYTE *)" o.k.",0);
  305.     }
  306.        else
  307.      execute = 0;
  308.       }
  309.      else {
  310.        atype = Config.AType;        /*GAL-Typ sichern*/
  311.        Config.AType = MyRequest(ATYPE_REQ,(UBYTE *)"Please insert GAL too compare.");
  312.        if (!ReadGALParameter(YES)) {        /*GAL-Parameter holen*/
  313.      PrintText((UBYTE *)"reading GAL...",1);
  314.      ReadGALToJedec();
  315.      PrintText((UBYTE *)" o.k.",0);
  316.      Config.AType = atype;        /*GAL-Typ wieder herstellen*/
  317.     }
  318.        else
  319.      execute = 0;
  320.       }
  321.     }
  322.  
  323.  
  324.    if (cmptype == 2) {
  325.      if (MyFileReq((char *)"Load JEDEC file", (char *)".jed",YES)) {
  326.        if (GetJedec(&path[0]))            /*Jedec-File in Struktur*/
  327.      execute = 0;
  328.        if (GALType != JedecGALType) {        /*überprüfen, ob der einge-*/
  329.      JedecError(25,NO);            /*stellte GAL-Typ zum Jedec-*/
  330.      execute = 0;
  331.     }
  332.       }
  333.      else
  334.        execute = 0;
  335.     }
  336.  
  337.   if (execute) {
  338.     logic = acw = signature = 1;
  339.  
  340.     for (row=0; row<=MaxFuseAdr; row++) {    /*Logik-Matrizen vergleichen*/
  341.       for (n=0; n<ROW_SIZE; n++) {
  342.         if (Jedec.GALLogic[row+(MaxFuseAdr+1)*n] != Jedec2.GALLogic[row+(MaxFuseAdr+1)*n]) {
  343.       logic = 0;
  344.          }
  345.         if (!logic) break;
  346.        }
  347.       if (!logic) break;
  348.      }
  349.  
  350.     for (n=LOGIC20_SIZE; n<sizeof(Jedec2); n++) {    /*ACW, Signatur*/
  351.       if (Jedec.GALLogic[n] != Jedec2.GALLogic[n])
  352.         if ((n < SIG20) || (n >= SIG20+SIG_SIZE))
  353.           acw = 0;
  354.         else
  355.       signature = 0;
  356.      }
  357.  
  358.  
  359.     if (logic && acw && signature)        /*völlig identisch?*/
  360.       req.ReqText = &CmpIText1;
  361.     if (!logic || !acw)                /*NICHT identisch?*/
  362.       req.ReqText = &CmpIText2;
  363.     if (logic && acw && !signature)        /*bis auf Sig. identisch?*/
  364.       req.ReqText = &CmpIText3;
  365.    }
  366.   else
  367.     req.ReqText = &CmpIText4;            /*Vergleich abgebrochen*/
  368.  
  369.  
  370.   result = MyRequest(CONT_REQ,NULL);
  371.  
  372.   req.ReqText = &ITextW;
  373.   if (!result)
  374.     return;                    
  375.  
  376.  }
  377. }
  378.  
  379.  
  380.  
  381.  
  382. /****************************************************************/
  383. /* Die nachfolgenden Routinen greifen direkt über das Modul    */
  384. /* "port.asm" auf das GAL zu.                    */
  385. /****************************************************************/
  386.  
  387. /* PrintACW
  388.    gibt das Architecture Control Word aus
  389.    Aufruf: PrintACW
  390. */
  391. void PrintACW()
  392. {
  393. BYTE    bit;
  394. int    n, acw_num, xor_num, ac1_num ;
  395.  
  396.  acw_num = xor_num = ac1_num =0;
  397.  
  398.  if (MyRequest(GALTYPE_REQ,(UBYTE *)"Read ACW?")) {
  399.    if (ReadGALParameter(YES))            /*GAL-Parameter holen*/
  400.      return;                    /*bei Fehler return*/
  401.    LED(ON);                    /*LED anschalten*/
  402.    EditMode(VERIFY);                /*GAL in Edit-Mode versetzen*/
  403.    SetRow(ACW_ADR);                /*ACW adressieren*/
  404.    STRImpuls(VERIFY_TIME);            /*ACW in's Schiebereg. holen*/
  405.    for (n=0; n<ACW_SIZE; n++) {            /*ACW einlesen*/
  406.       bit=(BYTE)SDOut();
  407.       Clock();
  408.  
  409.                     /*Standard-Typ (kein A-Typ)*/
  410.       if ((!Config.AutoAType && !Config.AType) || (Config.AutoAType && !GALAType())) {
  411.         if (n < 32) {                /*PT0-31 eintragen*/
  412.           PTTxt[4+acw_num]=bit+'0';
  413.       acw_num++;
  414.          }
  415.         if (n >= 50) {                /*PT32-63 eintragen*/
  416.           PTTxt[4+acw_num]=bit+'0';
  417.       acw_num++;
  418.          }
  419.         if (n == 36)                 /*AC0-Bit*/
  420.           ConTxt[35]=bit+'0';
  421.         if (n == 45)                 /*SYN-Bit*/
  422.           ConTxt[25]=bit+'0';
  423.         if ((n >= 32) && (n <= 35)) {         /*4 XOR-Bits*/
  424.           ConTxt[8+xor_num]=bit+'0';
  425.           xor_num++;
  426.          }
  427.         if ((n >= 46) && (n <= 49)) {         /*4 XOR-Bits*/
  428.           ConTxt[8+xor_num]=bit+'0';
  429.           xor_num++;
  430.          }
  431.         if ((n >= 37) && (n <= 44)) {        /*AC1-Bits*/
  432.       AC1Txt[8+ac1_num]=bit+'0';
  433.       ac1_num++;
  434.          }
  435.        }
  436.       else {                /*A-Typ*/
  437.         if ((n >= 9) && (n <= 72)) {        /*PT0-63 eintragen*/
  438.           PTTxt[4+acw_num]=bit+'0';
  439.       acw_num++;
  440.          }
  441.         if (n == 36)                 /*AC0-Bit*/
  442.           ConTxt[35]=bit+'0';
  443.         if (n == 77)                 /*SYN-Bit*/
  444.           ConTxt[25]=bit+'0';
  445.         if (n <= 3) {                 /*XOR-Bits*/
  446.           ConTxt[8+xor_num]=bit+'0';
  447.           xor_num++;
  448.          }
  449.         if (n >= 78) {                 /*XOR-Bits*/
  450.           ConTxt[8+xor_num]=bit+'0';
  451.           xor_num++;
  452.          }
  453.         if ((n >= 5) && (n <= 8)) {        /*AC1-Bits*/
  454.       AC1Txt[8+ac1_num]=bit+'0';
  455.       ac1_num++;
  456.          }
  457.         if ((n >= 73) && (n <= 76)) {        /*AC1-Bits*/
  458.       AC1Txt[8+ac1_num]=bit+'0';
  459.       ac1_num++;
  460.          }
  461.        }
  462.      }
  463.    ExitEditMode();
  464.  
  465.    PrintText(&PTTxt[0],1);
  466.    PrintText(&ConTxt[0],1);
  467.    PrintText(&AC1Txt[0],1);
  468.   }
  469. }
  470.  
  471.  
  472.  
  473. /* PrintSignature
  474.    gibt Signatur im Textfeld aus
  475.    Aufruf: PrintSignature();
  476. */
  477. void PrintSignature()
  478. {
  479. UBYTE    strn[6];
  480. BYTE    byte;
  481. int    n;
  482.  
  483.  if (MyRequest(GALTYPE_REQ,(UBYTE *)"Read signature?")) {
  484.    if (ReadGALParameter(YES))            /*GAL-Parameter holen*/
  485.      return;                    /*bei Fehler return*/
  486.    LED(ON);                    /*LED anschalten*/
  487.    EditMode(VERIFY);                /*GAL in Edit-Mode versetzen*/
  488.    SetRow(SigAdr);                /*Signatur adressieren*/
  489.    STRImpuls(VERIFY_TIME);            /*Signatur in's Schiebereg. holen*/
  490.                          /*Signatur einlesen*/
  491.    byte = 0;
  492.    for (n=0; n<SIG_SIZE; n++) {
  493.      byte |= (BYTE)SDOut();            /*acht Bits zu einem Byte*/
  494.      if (!((n+1)%8)) {                /*Text erstellen*/
  495.        sprintf(&strn[0],"%02x",(int)byte);
  496.        strncpy(&SignatureTxt[11+4*((n+1)/8-1)],&strn[0],2);
  497.        if (isprint(byte))
  498.          SignatureTxt[46+((n+1)/8-1)]=byte;
  499.        else
  500.          SignatureTxt[46+((n+1)/8-1)]='.';
  501.        byte = 0;
  502.       }
  503.      byte<<=1;
  504.      Clock();
  505.     } 
  506.    ExitEditMode();
  507.  
  508.    PrintText(&SignatureTxt[0],1);
  509.   }
  510. }
  511.  
  512.  
  513.  
  514.  
  515. /* ProgJedecToGAL
  516.    schreibt die Jedec-Struktur in das GAL
  517.    (eigentliche Programmier-Routine)
  518.    Aufruf:    result = ProgJedecToGAL(mode);
  519.    Parameter: mode = COPYGAL: Aufruf erfolgt von GAL-Copy-Routine
  520.            = PROGGAL: Aufruf erfolgt von GAL-Programmier-Routine
  521.  
  522.    Ergebnis: 0: GAL erfolgreich programmiert
  523.          1: GAL wurde nicht programmiert, da es nicht leer ist
  524.          2: Verify ist fehlgeschlagen
  525. */
  526. int ProgJedecToGAL(mode)
  527. int mode;
  528. {
  529. int    n, i, row, bit;
  530.  
  531.                     /*Leertest durchführen*/
  532.  if (((mode == COPYGAL) && Config.CopyEmptyTest) || ((mode == PROGGAL) && Config.ProgEmptyTest)) {
  533.    PrintText((UBYTE *)"executing blank test...",1);
  534.    if (CheckGAL()) {
  535.      PrintText((UBYTE *)" GAL is NOT empty",0);
  536.      if (MyRequest(ERASE_REQ,(UBYTE *)"GAL is NOT empty! Clear it?"))
  537.        EraseIt();
  538.      else
  539.        return(1);
  540.     }
  541.    else
  542.      PrintText((UBYTE *)" o.k.",0);
  543.  
  544.   }
  545.  
  546.  PrintText((UBYTE *)"programming GAL...",1);
  547.  
  548.  LED(ON);
  549.  EditMode(PROG);
  550.  
  551.  for (row=0; row<=MaxFuseAdr; row++) {         /*Logik-Matrix schreiben*/
  552.     SetRow(row);
  553.     for (n=0; n<ROW_SIZE; n++) {
  554.        SDIn((int)Jedec.GALLogic[row+(MaxFuseAdr+1)*n]); /*Bit an SDIn-Eingang anlegen*/
  555.        Clock();            /*Bit in Schieberegister takten*/
  556.       }
  557.     SetPV(PROG);            /*P/V auf "programmieren"*/
  558.     STRImpuls(prog_time);        /*Row (64 Bit) programmieren*/
  559.     SetPV(VERIFY);            /*P/V wieder auf "lesen"*/
  560.    }
  561.  
  562.  SetRow(SigAdr);                 /*Signatur schreiben*/
  563.  for (n=0; n<SIG_SIZE; n++) {
  564.     SDIn((int)Jedec.GALSig[n]);            /*Bit an SDIn-Eingang anlegen*/
  565.     Clock();            /*Bit in Schieberegister takten*/
  566.    }
  567.  SetPV(PROG);                    /*P/V auf "programmieren"*/
  568.  STRImpuls(prog_time);                /*Daten programmieren*/
  569.  SetPV(VERIFY);                    /*P/V auf "lesen"*/
  570.  
  571.  
  572.  SetRow(ACW_ADR);                /*ACW schreiben*/
  573.  for (n=0; n<ACW_SIZE; n++) {
  574.                     /*Standard-Typ (kein A-Typ)*/
  575.     if ((!Config.AutoAType && !Config.AType) || (Config.AutoAType && !GALAType())) {
  576.       if (n <= 31)                /*PT0-PT31*/
  577.     bit = Jedec.GALPT[n];
  578.       if ((n >= 32) && (n <= 35))        /*4 XOR-Bits*/
  579.     bit = Jedec.GALXOR[n-32];
  580.       if (n == 36)                /*AC0-Bit*/
  581.     bit = Jedec.GALAC0;
  582.       if ((n >= 37) && (n <= 44))         /*AC1-Bits*/
  583.     bit = Jedec.GALAC1[n-37];
  584.       if (n == 45)                 /*SYN-Bit*/
  585.     bit = Jedec.GALSYN;
  586.       if ((n >= 46) && (n <= 49))        /*4 XOR-Bits*/
  587.     bit = Jedec.GALXOR[n-42];
  588.       if ((n >= 50) && (n <= 81))        /*PT32-PT63*/
  589.     bit = Jedec.GALPT[n-18];
  590.      }
  591.     else {                /* A-Typ */
  592.       if (n <= 3)                /*4 XOR-Bits*/
  593.     bit = Jedec.GALXOR[n];
  594.       if (n == 4)                /*AC0-Bit*/
  595.     bit = Jedec.GALAC0;
  596.       if ((n >= 5) && (n <= 8))            /*AC1-Bits*/
  597.     bit = Jedec.GALAC1[n-5];
  598.       if ((n >= 9) && (n <= 72))        /*PT0-PT63*/
  599.     bit = Jedec.GALPT[n-9];
  600.       if ((n >= 73) && (n <= 76))        /*AC1-Bits*/
  601.     bit = Jedec.GALAC1[n-69];
  602.       if (n == 77)                /*SYN-Bit*/
  603.     bit = Jedec.GALSYN;
  604.       if (n >= 78)                /*XOR-Bits*/
  605.     bit = Jedec.GALXOR[n-74];
  606.      }
  607.     SDIn((int)bit);            /*Bit an SDIn-Eingang anlegen*/
  608.     Clock();                /*Bit in Schieberegister takten*/
  609.    }
  610.  
  611.  
  612.  SetPV(PROG);                /*P/V auf "programmieren"*/
  613.  STRImpuls(prog_time);            /*Daten programmieren*/
  614.  SetPV(VERIFY);                /*P/V auf "lesen"*/
  615.  
  616.  ExitEditMode();
  617.  
  618.  PrintText((UBYTE *)" o.k.",0);
  619.  
  620.  
  621.                         /*Verify durchführen*/
  622.  if (((mode == COPYGAL) && Config.CopyVerify) || ((mode == PROGGAL) && Config.ProgVerify)) {
  623.    PrintText((UBYTE *)"verifying...",1);
  624.  
  625.    for (i=0; i<sizeof(Jedec2); i++)        /*Jedec-Struktur sichern*/
  626.      Jedec2.GALLogic[i] = Jedec.GALLogic[i];
  627.  
  628.    ReadGALToJedec();            /*GAL nach Programmierung einlesen*/
  629.  
  630.    for (row=0; row<=MaxFuseAdr; row++) {    /*Logik-Matrizen vergleichen*/
  631.      for (n=0; n<ROW_SIZE; n++) {
  632.        if (Jedec.GALLogic[row+(MaxFuseAdr+1)*n] != Jedec2.GALLogic[row+(MaxFuseAdr+1)*n]) {
  633.          MyRequest(ERR_REQ,(UBYTE *)"Verify not successful!!!");
  634.          PrintText((UBYTE *)" failed",0);
  635.      for (i=0; i<sizeof(Jedec2); i++)    /*Jedec-Struktur restaurieren*/
  636.        Jedec.GALLogic[i] = Jedec2.GALLogic[i];
  637.      return(2);
  638.         }
  639.       }
  640.     }
  641.  
  642.    for (n=LOGIC20_SIZE; n<sizeof(Jedec2); n++)    /*ACW, Signatur,...*/
  643.      if (Jedec.GALLogic[n] != Jedec2.GALLogic[n]) {
  644.        MyRequest(ERR_REQ,(UBYTE *)"Verify not successful!!!");
  645.        PrintText((UBYTE *)" failed",0);
  646.        for (i=0; i<sizeof(Jedec2); i++)        /*Jedec-Struktur restaurieren*/
  647.      Jedec.GALLogic[i] = Jedec2.GALLogic[i];
  648.        return(2);
  649.       }
  650.  
  651.    for (i=0; i<sizeof(Jedec2); i++)    /*Jedec-Struktur restaurieren*/
  652.       Jedec.GALLogic[i] = Jedec2.GALLogic[i];    /*wurde durch Verify überschrieben*/
  653.    PrintText((UBYTE *)" o.k.",0);
  654.   }
  655.  
  656.  return(0);
  657. }
  658.  
  659.  
  660.  
  661. /* ReadGALToJedec
  662.    liest das GAL in die Jedec-Struktur
  663.    (MaxFuseAdr und SigAdr müssen initialisiert sein)
  664.    Aufruf:  ReadGALToJedec()
  665. */
  666. void ReadGALToJedec()
  667. {
  668. int    n, row;
  669. BYTE    bit;
  670.  
  671.  LED(ON);
  672.  EditMode(VERIFY);                /*GAL in Verify-Mode*/
  673.  
  674.  for (row=0; row<=MaxFuseAdr; row++) {        /*Logik-Matrix lesen*/
  675.     SetRow(row);                /*Adresse anlegen*/
  676.     STRImpuls(VERIFY_TIME);        /*Bits in's Schieberegister holen*/
  677.     for (n=0; n<ROW_SIZE; n++) {        /*seriell auslesen*/
  678.        Jedec.GALLogic[row+(MaxFuseAdr+1)*n]=(BYTE)SDOut();    /*SDOut-Ausgang lesen*/
  679.        Clock();                    /*nächstes Bit an SDOut holen*/
  680.       }
  681.    }
  682.  
  683.  
  684.  SetRow(SigAdr);                 /*Signatur auslesesn*/
  685.  STRImpuls(VERIFY_TIME);
  686.  for (n=0; n<SIG_SIZE; n++) {
  687.     Jedec.GALSig[n]=(BYTE)SDOut();
  688.     Clock();
  689.    }
  690.  
  691.  
  692.  SetRow(ACW_ADR);                /*Architecture Control Word holen*/
  693.  STRImpuls(VERIFY_TIME);            /*Bits in's Schieberegister*/
  694.  for (n=0; n<ACW_SIZE; n++) {
  695.     bit=(BYTE)SDOut();
  696.     Clock();                       /*kein A-Typ*/
  697.     if ((!Config.AutoAType && !Config.AType) || (Config.AutoAType && !GALAType())) {
  698.       if (n <= 31)
  699.     Jedec.GALPT[n] = bit;
  700.       if ((n >= 32) && (n <= 35))        /*4 XOR-Bits*/
  701.     Jedec.GALXOR[n-32] = bit;
  702.       if (n == 36)                /*AC0-Bit*/
  703.     Jedec.GALAC0 = bit;
  704.       if ((n >= 37) && (n <= 44))        /*AC1-Bits*/
  705.     Jedec.GALAC1[n-37] = bit;
  706.       if (n == 45)                 /*SYN-Bit*/
  707.     Jedec.GALSYN=bit;
  708.       if ((n >= 46) && (n <= 49))        /*4 XOR-Bits*/
  709.     Jedec.GALXOR[n-42] = bit;
  710.       if ((n >= 50) && (n <= 81))        /*PT32-PT63*/
  711.     Jedec.GALPT[n-18] = bit;
  712.      }
  713.     else {                /* A-Typ */
  714.       if (n <= 3)                /*4 XOR-Bits 19-16*/
  715.     Jedec.GALXOR[n] = bit;
  716.       if (n == 4)                /*AC0-Bit*/
  717.     Jedec.GALAC0 = bit;
  718.       if ((n >= 5) && (n <= 8))            /*AC1-Bits*/
  719.     Jedec.GALAC1[n-5] = bit;
  720.       if ((n >= 9) && (n <= 72))        /*PT0-PT63*/
  721.     Jedec.GALPT[n-9] = bit;
  722.       if (n == 77)                /*SYN-Bit*/
  723.     Jedec.GALSYN = bit;
  724.       if ((n >= 73) && (n <= 76))        /*AC1-Bits*/
  725.     Jedec.GALAC1[n-69] = bit;
  726.       if (n >= 78)                /*XOR-Bits*/
  727.     Jedec.GALXOR[n-74] = bit;
  728.      }
  729.    }
  730.  
  731.  ExitEditMode();
  732. }
  733.  
  734.  
  735.  
  736. /* Sicherungsbit setzen
  737.     flag = 0: Aufruf von der ProgramGAL-Routine aufgrund eines
  738.           gesetzten "JedecSecurity"-Flags
  739.     flag = 1: Aufruf von einer anderen Routine als der ProgramGAL-Routine
  740. */
  741. void SetSecurity(flag)
  742. int  flag;
  743. {
  744. int result;
  745.  
  746.  if (flag)
  747.    result = MyRequest(GALTYPE_REQ,(UBYTE *)"Set security bit?");
  748.  else
  749.    result = MyRequest(CONT_REQ,(UBYTE *)"Set security bit?");
  750.  
  751.  if (result) {
  752.    if (flag)
  753.      if (ReadGALParameter(YES))            /*GAL-Parameter holen*/
  754.        return;                    /*bei Fehler return*/
  755.    LED(ON);
  756.    EditMode(PROG);
  757.    SetRow(SECURITY_ADR);
  758.    SDIn(1);
  759.    SetPV(PROG);                /*P/V-Pin auf "programmieren*/
  760.    STRImpuls(prog_time);        /*STR-Impuls geben*/
  761.    SetPV(VERIFY);            /*P/V wieder auf "lesen*/
  762.    ExitEditMode();
  763.    if (flag)
  764.      MyRequest(INFO_REQ,(UBYTE *)"Security bit is set.");
  765.   }
  766. }
  767.  
  768.  
  769.  
  770.  
  771.  
  772. /* GAL löschen */
  773. void Loeschen()
  774. {
  775. int result;
  776.  
  777.  if (MyRequest(GALTYPE_REQ,(UBYTE *)"Erase GAL?")){
  778.    if (ReadGALParameter(YES))            /*GAL-Parameter holen*/
  779.      return;                    /*bei Fehler return*/
  780.    EraseIt();
  781.    if (Config.EraseEmptyTest) {
  782.      PrintText("GAL is erased",1);
  783.      PrintText("executing blank test...",1);
  784.      result = CheckGAL();
  785.      PrintText(" ready",0);
  786.      if (result) {
  787.        MyRequest(ERR_REQ,(UBYTE *)"Couldn't erase GAL!");
  788.        return;
  789.       }
  790.     }
  791.    MyRequest(INFO_REQ,(UBYTE *)"GAL is erased.");
  792.   }
  793. }
  794.  
  795.  
  796. /*GAL löschen.
  797.   Vor dem Aufruf sollten die GAL-Parameter eingelesen worden sein (mit
  798.   ReadGALParameter(YES);)
  799. */
  800. void EraseIt()
  801. {
  802.    LED(ON);
  803.    EditMode(PROG);
  804.    SetRow(ERASE_ADR);
  805.    SDIn(1);
  806.    SetPV(PROG);                /*P/V-Pin auf "programmieren"*/
  807.    STRImpuls(BULK_TIME);        /*STR-Imputs geben*/
  808.    SetPV(VERIFY);            /*und P/V wieder auf "lesen"*/
  809.    ExitEditMode();
  810. }
  811.  
  812.