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