Subversion Repositories ngs

Rev

Blame | Last modification | View Log | Download | RSS feed | ?url?

  1. #include <conio.h>
  2. #include <stdio.h>
  3. #include <string.h>
  4. #include <windows.h>
  5.  
  6. #include "flash.h"
  7. #include "ngs_jtag.h"
  8. #include "jtag.h"
  9. #include "bsdl.h"
  10. #include "tap.h"
  11. #include "types.h"
  12.  
  13.  
  14.  
  15.  
  16.  
  17. char idcode[21];
  18. char sampre[21];
  19. char extest[21];
  20.  
  21. char idcode_reply[34];
  22. char idcode_stub[34];
  23.  
  24.  
  25.  
  26.  
  27. int do_flash(int mode, char * filename, int start_address, int length)
  28. {
  29.         int return_value;
  30.         return_value=1;
  31.  
  32.  
  33.         int filesize;
  34.  
  35.         FILE * infile,* outfile;
  36.         infile = NULL;
  37.         outfile = NULL;
  38.  
  39.         unsigned char * fileinmem;
  40.         fileinmem = NULL;
  41.  
  42.  
  43.         // files handling
  44.         if( mode==PROGRAM )
  45.         {
  46.                 infile=fopen(filename,"rb");
  47.                 if( infile==NULL )
  48.                 {
  49.                         printf("cant open %s!\n",filename);
  50.                         return 0;
  51.                 }
  52.  
  53.                 fseek(infile,0,SEEK_END);
  54.                 filesize=ftell(infile);
  55.                 fseek(infile,0,SEEK_SET);
  56.  
  57.                 if( (filesize<=0) || ((filesize+start_address)>MAX_SIZE) )
  58.                 {
  59.                         printf("wrong file size %x at address %x\n",filesize,start_address);
  60.                         return 0;
  61.                 }
  62.        
  63.  
  64.                 fileinmem=(unsigned char *)malloc(filesize);
  65.                 if(fileinmem==NULL)
  66.                 {
  67.                         printf("cant allocate mem for file!\n");
  68.                         return 0;
  69.                 }
  70.  
  71.                 if( filesize!=(int)fread(fileinmem,1,filesize,infile) )
  72.                 {
  73.                         printf("cant read all file into buffer!\n");
  74.                         return 0;
  75.                 }
  76.         }
  77.         else if( mode==READ )
  78.         {
  79.                 outfile=fopen(filename,"wb");
  80.                 if( outfile==NULL )
  81.                 {
  82.                         printf("cant create %s!\n",filename);
  83.                         return -1;
  84.                 }
  85.        
  86.                 fileinmem=(unsigned char *)malloc(MAX_SIZE);
  87.                 if(fileinmem==NULL)
  88.                 {
  89.                         printf("cant allocate mem for reading data!\n");
  90.                         return 0;
  91.                 }
  92.         }
  93.  
  94.  
  95.  
  96.         //jtag init
  97.         JTAG jtag(0x378,256*(BSbegin->DRlen));
  98.  
  99.         jtag.RESET();
  100.         jtag.IDLE();
  101.  
  102.  
  103.         // create commands for FPGA only, CPLD in bypass
  104.         strcpy(idcode,BSbegin->IDCODE);
  105.         strcat(idcode,BSbegin->BYPASS);
  106.  
  107.         strcpy(sampre,BSbegin->SAMPLE);
  108.         strcat(sampre,BSbegin->BYPASS);
  109.  
  110.         strcpy(extest,BSbegin->EXTEST);
  111.         strcat(extest,BSbegin->BYPASS);
  112.  
  113.  
  114.  
  115.         //check presence of FPGA
  116.  
  117.         jtag._IRSCAN(idcode);
  118.  
  119.         memset(idcode_stub,'0',33);
  120.         idcode_stub[33]=0;
  121.         strcpy(idcode_reply,idcode_stub);
  122.  
  123.         jtag.DRSCAN(idcode_stub,idcode_reply);
  124.  
  125.         if( idcode_reply==strstr(idcode_reply,BSbegin->ID) )
  126.         {
  127.                 printf("ep1k30tc144 found!\n");
  128.         }
  129.         else
  130.         {
  131.                 printf("ep1k30tc144 not found!\n");
  132.                 return 0;
  133.         }
  134.        
  135.  
  136.        
  137.         // assing aliases to the pins
  138.         addPINalias("IO72","nramcs0");
  139.         addPINalias("IO70","nramcs1");
  140.         addPINalias("IO69","nramcs2");
  141.         addPINalias("IO68","nramcs3");
  142.         addPINalias("IO67","nromcs");
  143.  
  144.         addPINalias("IO65","nmemoe");
  145.         addPINalias("IO64","nmemwe");
  146.  
  147.         addPINalias("IO49","nz80res");
  148.  
  149.         addPINalias("IO117","d0");
  150.         addPINalias("IO112","d1");
  151.         addPINalias("IO109","d2");
  152.         addPINalias("IO111","d3");
  153.         addPINalias("IO116","d4");
  154.         addPINalias("IO110","d5");
  155.         addPINalias("IO114","d6");
  156.         addPINalias("IO113","d7");
  157.  
  158.         addPINalias("IO102","a0");
  159.         addPINalias("IO101","a1");
  160.         addPINalias("IO100","a2");
  161.         addPINalias("IO99","a3");
  162.         addPINalias("IO98","a4");
  163.         addPINalias("IO97","a5");
  164.         addPINalias("IO96","a6");
  165.         addPINalias("IO95","a7");
  166.         addPINalias("IO92","a8");
  167.         addPINalias("IO91","a9");
  168.         addPINalias("IO90","a10");
  169.         addPINalias("IO89","a11");
  170.         addPINalias("IO88","a12");
  171.         addPINalias("IO87","a13");
  172.         addPINalias("IO82","mema14");
  173.         addPINalias("IO81","mema15");
  174.         addPINalias("IO80","mema16");
  175.         addPINalias("IO79","mema17");
  176.         addPINalias("IO78","mema18");
  177.  
  178.  
  179.  
  180.         //create busses
  181.         struct bus * databus=NULL;
  182.         struct bus * addrbus=NULL;
  183.  
  184.         databus=add_bus_pin(databus,"d7");
  185.         databus=add_bus_pin(databus,"d6");
  186.         databus=add_bus_pin(databus,"d5");
  187.         databus=add_bus_pin(databus,"d4");
  188.         databus=add_bus_pin(databus,"d3");
  189.         databus=add_bus_pin(databus,"d2");
  190.         databus=add_bus_pin(databus,"d1");
  191.         databus=add_bus_pin(databus,"d0");
  192.  
  193.         addrbus=add_bus_pin(addrbus,"mema18");
  194.         addrbus=add_bus_pin(addrbus,"mema17");
  195.         addrbus=add_bus_pin(addrbus,"mema16");
  196.         addrbus=add_bus_pin(addrbus,"mema15");
  197.         addrbus=add_bus_pin(addrbus,"mema14");
  198.         addrbus=add_bus_pin(addrbus,"a13");
  199.         addrbus=add_bus_pin(addrbus,"a12");
  200.         addrbus=add_bus_pin(addrbus,"a11");
  201.         addrbus=add_bus_pin(addrbus,"a10");
  202.         addrbus=add_bus_pin(addrbus,"a9");
  203.         addrbus=add_bus_pin(addrbus,"a8");
  204.         addrbus=add_bus_pin(addrbus,"a7");
  205.         addrbus=add_bus_pin(addrbus,"a6");
  206.         addrbus=add_bus_pin(addrbus,"a5");
  207.         addrbus=add_bus_pin(addrbus,"a4");
  208.         addrbus=add_bus_pin(addrbus,"a3");
  209.         addrbus=add_bus_pin(addrbus,"a2");
  210.         addrbus=add_bus_pin(addrbus,"a1");
  211.         addrbus=add_bus_pin(addrbus,"a0");
  212.  
  213.  
  214.  
  215.  
  216.         // init bscan_state register
  217.        
  218.         char * bscan_state=new char[2+BSbegin->DRlen];
  219.         char * bscan_tmp=new char[2+BSbegin->DRlen];
  220.  
  221.         memset(bscan_tmp,'0',1+BSbegin->DRlen);
  222.         bscan_tmp[1+BSbegin->DRlen]=0;
  223.         strcpy(bscan_state,bscan_tmp);
  224.  
  225.         jtag._IRSCAN(sampre);
  226.         jtag.DRSCAN(bscan_tmp,bscan_state); //read base state of boundary register
  227.  
  228.  
  229.         // set reset of Z80 to 0, set initial values for CS and OE/WE signals
  230.  
  231.         set_pin_dir(bscan_state,"nz80res",OUTPUT);
  232.         set_pin_out(bscan_state,"nz80res",0);
  233.  
  234.         set_pin_dir(bscan_state,"nramcs0",OUTPUT);
  235.         set_pin_dir(bscan_state,"nramcs1",OUTPUT);
  236.         set_pin_dir(bscan_state,"nramcs2",OUTPUT);
  237.         set_pin_dir(bscan_state,"nramcs3",OUTPUT);
  238.         set_pin_dir(bscan_state,"nromcs",OUTPUT);
  239.         set_pin_dir(bscan_state,"nmemoe",OUTPUT);
  240.         set_pin_dir(bscan_state,"nmemwe",OUTPUT);
  241.  
  242.         set_pin_out(bscan_state,"nramcs0",1);
  243.         set_pin_out(bscan_state,"nramcs1",1);
  244.         set_pin_out(bscan_state,"nramcs2",1);
  245.         set_pin_out(bscan_state,"nramcs3",1);
  246.         set_pin_out(bscan_state,"nromcs",1);
  247.         set_pin_out(bscan_state,"nmemoe",1);
  248.         set_pin_out(bscan_state,"nmemwe",1);
  249.  
  250.         jtag._IRSCAN(sampre);
  251.         jtag._DRSCAN(bscan_state);
  252.         jtag._IRSCAN(extest);
  253.         jtag._DRSCAN(bscan_state);
  254.  
  255.  
  256.  
  257.  
  258.  
  259.  
  260.  
  261.         if( mode==READ )
  262.         {
  263.                 unsigned char byte;
  264.                 unsigned int max_addr;
  265.                 unsigned int addr;
  266.  
  267.                 if( start_address>=0 )
  268.                         addr = start_address;
  269.                 else
  270.                         addr = 0;
  271.  
  272.                 if( length>=0 )
  273.                         max_addr = start_address+length;
  274.                 else
  275.                         max_addr = MAX_SIZE;
  276.  
  277.  
  278.                 set_pin_out(bscan_state,"nmemoe",0);
  279.                 set_pin_out(bscan_state,"nmemwe",1);
  280.                 set_pin_out(bscan_state,"nromcs",0);
  281.                
  282.                 set_bus_dir(bscan_state,addrbus,OUTPUT);
  283.                 set_bus_dir(bscan_state,databus,INPUT);
  284.  
  285.                 set_bus_out(bscan_state,addrbus,addr);
  286.                 addr=addr+1;
  287.  
  288.  
  289.                 jtag._IRSCAN(sampre);
  290.                 jtag._DRSCAN(bscan_state);
  291.  
  292.  
  293.                 do
  294.                 {
  295.                         set_bus_out(bscan_state,addrbus,addr);
  296.  
  297.                         jtag._IRSCAN(extest);
  298.                         jtag.DRSCAN(bscan_state,bscan_tmp);
  299.  
  300.                         byte=(unsigned char)get_bus_in(bscan_tmp,databus);
  301.  
  302.                         fileinmem[addr-1] = byte;
  303.  
  304.                         print_cur_addr("read address=%x\n",addr-1);
  305.  
  306.                         addr=addr+1;
  307.  
  308.                 } while( addr<=max_addr );
  309.  
  310.         }
  311.         else if( mode==PROGRAM )
  312.         {
  313.                 unsigned char byte;
  314.                 unsigned int addr;
  315.                 unsigned char * curr;
  316.  
  317.                 unsigned char toggle,oldtoggle;
  318.  
  319.                 int counter;
  320.                
  321.                 counter = filesize;
  322.                 curr = &fileinmem[0];
  323.                 addr = start_address;
  324.  
  325.  
  326.                 set_pin_out(bscan_state,"nmemoe",1);
  327.                 set_pin_out(bscan_state,"nmemwe",1);
  328.                 set_pin_out(bscan_state,"nromcs",0);
  329.  
  330.                 set_bus_dir(bscan_state,addrbus,OUTPUT);
  331.                 set_bus_dir(bscan_state,databus,OUTPUT);
  332.  
  333.  
  334.                 jtag._IRSCAN(sampre); // prepare 1st data
  335.                 jtag._DRSCAN(bscan_state);
  336.  
  337.                 do
  338.                 {
  339.                         byte = *(curr++);
  340.                        
  341.                         //write byte
  342.                         set_bus_out(bscan_state,addrbus,0x0555);
  343.                         set_bus_out(bscan_state,databus,0x00AA);
  344.                         jtag._IRSCAN(extest);
  345.                         jtag._DRSCAN(bscan_state);
  346.                         set_pin_out(bscan_state,"nmemwe",0);
  347.                         jtag._IRSCAN(extest);
  348.                         jtag._DRSCAN(bscan_state);
  349.                         set_pin_out(bscan_state,"nmemwe",1);
  350.                         jtag._IRSCAN(extest);
  351.                         jtag._DRSCAN(bscan_state);
  352.  
  353.                         set_bus_out(bscan_state,addrbus,0x02AA);
  354.                         set_bus_out(bscan_state,databus,0x0055);
  355.                         jtag._IRSCAN(extest);
  356.                         jtag._DRSCAN(bscan_state);
  357.                         set_pin_out(bscan_state,"nmemwe",0);
  358.                         jtag._IRSCAN(extest);
  359.                         jtag._DRSCAN(bscan_state);
  360.                         set_pin_out(bscan_state,"nmemwe",1);
  361.                         jtag._IRSCAN(extest);
  362.                         jtag._DRSCAN(bscan_state);
  363.  
  364.                         set_bus_out(bscan_state,addrbus,0x0555);
  365.                         set_bus_out(bscan_state,databus,0x00A0);
  366.                         jtag._IRSCAN(extest);
  367.                         jtag._DRSCAN(bscan_state);
  368.                         set_pin_out(bscan_state,"nmemwe",0);
  369.                         jtag._IRSCAN(extest);
  370.                         jtag._DRSCAN(bscan_state);
  371.                         set_pin_out(bscan_state,"nmemwe",1);
  372.                         jtag._IRSCAN(extest);
  373.                         jtag._DRSCAN(bscan_state);
  374.  
  375.                         set_bus_out(bscan_state,addrbus,addr);
  376.                         set_bus_out(bscan_state,databus,byte);
  377.                         jtag._IRSCAN(extest);
  378.                         jtag._DRSCAN(bscan_state);
  379.                         set_pin_out(bscan_state,"nmemwe",0);
  380.                         jtag._IRSCAN(extest);
  381.                         jtag._DRSCAN(bscan_state);
  382.                         set_pin_out(bscan_state,"nmemwe",1);
  383.                         jtag._IRSCAN(extest);
  384.                         jtag._DRSCAN(bscan_state);
  385.  
  386.  
  387.                         set_pin_out(bscan_state,"nmemoe",0);
  388.                         set_bus_dir(bscan_state,databus,INPUT);
  389.                         jtag._IRSCAN(extest); // complete last write
  390.                         jtag._DRSCAN(bscan_state);
  391.  
  392.                         set_pin_out(bscan_state,"nmemoe",1);
  393.                         jtag._IRSCAN(extest);
  394.                         jtag.DRSCAN(bscan_state,bscan_tmp);
  395.                         toggle=(unsigned char)get_bus_in(bscan_tmp,databus);
  396.  
  397.                         do
  398.                         {
  399.                                 oldtoggle = toggle;
  400.                                
  401.                                 set_pin_out(bscan_state,"nmemoe",0);
  402.                                 jtag._IRSCAN(extest);
  403.                                 jtag._DRSCAN(bscan_state);
  404.                                 set_pin_out(bscan_state,"nmemoe",1);
  405.                                 jtag._IRSCAN(extest);
  406.                                 jtag.DRSCAN(bscan_state,bscan_tmp);
  407.                                 toggle=(unsigned char)get_bus_in(bscan_tmp,databus);
  408.  
  409.                         } while ( ((toggle&0x40)!=(oldtoggle&0x40)) && !(toggle&0x20) );
  410.  
  411.                         if( (toggle&0x20) && ((toggle&0x40)!=(oldtoggle&0x40)) )
  412.                         {
  413.                                 printf("program failed!\n");
  414.                                 return_value=0;
  415.                         }
  416.  
  417.  
  418.                         set_pin_out(bscan_state,"nmemwe",0);
  419.                         set_bus_dir(bscan_state,databus,OUTPUT);
  420.                         set_bus_out(bscan_state,databus,0x00F0);
  421.                         jtag._IRSCAN(extest);
  422.                         jtag._DRSCAN(bscan_state);
  423.                         set_pin_out(bscan_state,"nmemwe",1);
  424.                         jtag._IRSCAN(extest);
  425.                         jtag._DRSCAN(bscan_state);
  426.  
  427.                         print_cur_addr("write address=%x\n",addr++);
  428.  
  429.  
  430.                 } while(--counter);
  431.  
  432.  
  433.  
  434.  
  435.                
  436.  
  437.  
  438.         }
  439.         else if( mode==ERASE_ALL )
  440.         {
  441.                 unsigned char toggle,oldtoggle;
  442.  
  443.                 set_pin_out(bscan_state,"nmemoe",1);
  444.                 set_pin_out(bscan_state,"nmemwe",1);
  445.                 set_pin_out(bscan_state,"nromcs",0);
  446.                
  447.                 set_bus_dir(bscan_state,addrbus,OUTPUT);
  448.                 set_bus_dir(bscan_state,databus,OUTPUT);
  449.  
  450.  
  451.                 set_bus_out(bscan_state,addrbus,0x0555);
  452.                 set_bus_out(bscan_state,databus,0x00AA);
  453.                 jtag._IRSCAN(sampre); // prepare 1st data
  454.                 jtag._DRSCAN(bscan_state);
  455.                 set_pin_out(bscan_state,"nmemwe",0);
  456.                 jtag._IRSCAN(extest);
  457.                 jtag._DRSCAN(bscan_state);
  458.                 set_pin_out(bscan_state,"nmemwe",1);
  459.                 jtag._IRSCAN(extest);
  460.                 jtag._DRSCAN(bscan_state);
  461.  
  462.                 set_bus_out(bscan_state,addrbus,0x02AA);
  463.                 set_bus_out(bscan_state,databus,0x0055);
  464.                 jtag._IRSCAN(extest);
  465.                 jtag._DRSCAN(bscan_state);
  466.                 set_pin_out(bscan_state,"nmemwe",0);
  467.                 jtag._IRSCAN(extest);
  468.                 jtag._DRSCAN(bscan_state);
  469.                 set_pin_out(bscan_state,"nmemwe",1);
  470.                 jtag._IRSCAN(extest);
  471.                 jtag._DRSCAN(bscan_state);
  472.  
  473.                 set_bus_out(bscan_state,addrbus,0x0555);
  474.                 set_bus_out(bscan_state,databus,0x0080);
  475.                 jtag._IRSCAN(extest);
  476.                 jtag._DRSCAN(bscan_state);
  477.                 set_pin_out(bscan_state,"nmemwe",0);
  478.                 jtag._IRSCAN(extest);
  479.                 jtag._DRSCAN(bscan_state);
  480.                 set_pin_out(bscan_state,"nmemwe",1);
  481.                 jtag._IRSCAN(extest);
  482.                 jtag._DRSCAN(bscan_state);
  483.  
  484.                 set_bus_out(bscan_state,addrbus,0x0555);
  485.                 set_bus_out(bscan_state,databus,0x00AA);
  486.                 jtag._IRSCAN(extest);
  487.                 jtag._DRSCAN(bscan_state);
  488.                 set_pin_out(bscan_state,"nmemwe",0);
  489.                 jtag._IRSCAN(extest);
  490.                 jtag._DRSCAN(bscan_state);
  491.                 set_pin_out(bscan_state,"nmemwe",1);
  492.                 jtag._IRSCAN(extest);
  493.                 jtag._DRSCAN(bscan_state);
  494.  
  495.                 set_bus_out(bscan_state,addrbus,0x02AA);
  496.                 set_bus_out(bscan_state,databus,0x0055);
  497.                 jtag._IRSCAN(extest);
  498.                 jtag._DRSCAN(bscan_state);
  499.                 set_pin_out(bscan_state,"nmemwe",0);
  500.                 jtag._IRSCAN(extest);
  501.                 jtag._DRSCAN(bscan_state);
  502.                 set_pin_out(bscan_state,"nmemwe",1);
  503.                 jtag._IRSCAN(extest);
  504.                 jtag._DRSCAN(bscan_state);
  505.  
  506.                 set_bus_out(bscan_state,addrbus,0x0555);
  507.                 set_bus_out(bscan_state,databus,0x0010);
  508.                 jtag._IRSCAN(extest);  
  509.                 jtag._DRSCAN(bscan_state);
  510.                 set_pin_out(bscan_state,"nmemwe",0);
  511.                 jtag._IRSCAN(extest);
  512.                 jtag._DRSCAN(bscan_state);
  513.                 set_pin_out(bscan_state,"nmemwe",1);
  514.                 jtag._IRSCAN(extest);
  515.                 jtag._DRSCAN(bscan_state);
  516.  
  517.  
  518.                 set_pin_out(bscan_state,"nmemoe",0);
  519.                 set_bus_dir(bscan_state,databus,INPUT);
  520.                 jtag._IRSCAN(extest); // complete last write
  521.                 jtag._DRSCAN(bscan_state);
  522.  
  523.                 set_pin_out(bscan_state,"nmemoe",1);
  524.                 jtag._IRSCAN(extest);
  525.                 jtag.DRSCAN(bscan_state,bscan_tmp);
  526.                 toggle=(unsigned char)get_bus_in(bscan_tmp,databus);
  527.  
  528.                 do
  529.                 {
  530.                         oldtoggle = toggle;
  531.                        
  532.                         set_pin_out(bscan_state,"nmemoe",0);
  533.                         jtag._IRSCAN(extest);
  534.                         jtag._DRSCAN(bscan_state);
  535.                         set_pin_out(bscan_state,"nmemoe",1);
  536.                         jtag._IRSCAN(extest);
  537.                         jtag.DRSCAN(bscan_state,bscan_tmp);
  538.                         toggle=(unsigned char)get_bus_in(bscan_tmp,databus);
  539.  
  540.                 } while ( ((toggle&0x40)!=(oldtoggle&0x40)) && !(toggle&0x20) );
  541.  
  542.                 if( (toggle&0x20) && ((toggle&0x40)!=(oldtoggle&0x40)) )
  543.                 {
  544.                         printf("erase all failed!\n");
  545.                         return_value=0;
  546.                 }
  547.  
  548.  
  549.                 set_pin_out(bscan_state,"nmemwe",0);
  550.                 set_bus_dir(bscan_state,databus,OUTPUT);
  551.                 set_bus_out(bscan_state,databus,0x00F0);
  552.                 jtag._IRSCAN(extest);
  553.                 jtag._DRSCAN(bscan_state);
  554.                 set_pin_out(bscan_state,"nmemwe",1);
  555.                 set_pin_out(bscan_state,"nromcs",1);
  556.                 jtag._IRSCAN(extest);
  557.                 jtag._DRSCAN(bscan_state);
  558.                 jtag._IRSCAN(extest);
  559.                 jtag._DRSCAN(bscan_state);
  560.         }
  561.         else if( mode==ERASE_BLOCK )
  562.         {
  563.                 unsigned char toggle,oldtoggle;
  564.  
  565.                 set_pin_out(bscan_state,"nmemoe",1);
  566.                 set_pin_out(bscan_state,"nmemwe",1);
  567.                 set_pin_out(bscan_state,"nromcs",0);
  568.                
  569.                 set_bus_dir(bscan_state,addrbus,OUTPUT);
  570.                 set_bus_dir(bscan_state,databus,OUTPUT);
  571.  
  572.  
  573.                 set_bus_out(bscan_state,addrbus,0x0555);
  574.                 set_bus_out(bscan_state,databus,0x00AA);
  575.                 jtag._IRSCAN(sampre); // prepare 1st data
  576.                 jtag._DRSCAN(bscan_state);
  577.                 set_pin_out(bscan_state,"nmemwe",0);
  578.                 jtag._IRSCAN(extest);
  579.                 jtag._DRSCAN(bscan_state);
  580.                 set_pin_out(bscan_state,"nmemwe",1);
  581.                 jtag._IRSCAN(extest);
  582.                 jtag._DRSCAN(bscan_state);
  583.  
  584.                 set_bus_out(bscan_state,addrbus,0x02AA);
  585.                 set_bus_out(bscan_state,databus,0x0055);
  586.                 jtag._IRSCAN(extest);
  587.                 jtag._DRSCAN(bscan_state);
  588.                 set_pin_out(bscan_state,"nmemwe",0);
  589.                 jtag._IRSCAN(extest);
  590.                 jtag._DRSCAN(bscan_state);
  591.                 set_pin_out(bscan_state,"nmemwe",1);
  592.                 jtag._IRSCAN(extest);
  593.                 jtag._DRSCAN(bscan_state);
  594.  
  595.                 set_bus_out(bscan_state,addrbus,0x0555);
  596.                 set_bus_out(bscan_state,databus,0x0080);
  597.                 jtag._IRSCAN(extest);
  598.                 jtag._DRSCAN(bscan_state);
  599.                 set_pin_out(bscan_state,"nmemwe",0);
  600.                 jtag._IRSCAN(extest);
  601.                 jtag._DRSCAN(bscan_state);
  602.                 set_pin_out(bscan_state,"nmemwe",1);
  603.                 jtag._IRSCAN(extest);
  604.                 jtag._DRSCAN(bscan_state);
  605.  
  606.                 set_bus_out(bscan_state,addrbus,0x0555);
  607.                 set_bus_out(bscan_state,databus,0x00AA);
  608.                 jtag._IRSCAN(extest);
  609.                 jtag._DRSCAN(bscan_state);
  610.                 set_pin_out(bscan_state,"nmemwe",0);
  611.                 jtag._IRSCAN(extest);
  612.                 jtag._DRSCAN(bscan_state);
  613.                 set_pin_out(bscan_state,"nmemwe",1);
  614.                 jtag._IRSCAN(extest);
  615.                 jtag._DRSCAN(bscan_state);
  616.  
  617.                 set_bus_out(bscan_state,addrbus,0x02AA);
  618.                 set_bus_out(bscan_state,databus,0x0055);
  619.                 jtag._IRSCAN(extest);
  620.                 jtag._DRSCAN(bscan_state);
  621.                 set_pin_out(bscan_state,"nmemwe",0);
  622.                 jtag._IRSCAN(extest);
  623.                 jtag._DRSCAN(bscan_state);
  624.                 set_pin_out(bscan_state,"nmemwe",1);
  625.                 jtag._IRSCAN(extest);
  626.                 jtag._DRSCAN(bscan_state);
  627.  
  628.                 set_bus_out(bscan_state,addrbus,start_address);
  629.                 set_bus_out(bscan_state,databus,0x0030);
  630.                 jtag._IRSCAN(extest);  
  631.                 jtag._DRSCAN(bscan_state);
  632.                 set_pin_out(bscan_state,"nmemwe",0);
  633.                 jtag._IRSCAN(extest);
  634.                 jtag._DRSCAN(bscan_state);
  635.                 set_pin_out(bscan_state,"nmemwe",1);
  636.                 jtag._IRSCAN(extest);
  637.                 jtag._DRSCAN(bscan_state);
  638.  
  639.  
  640.                 set_pin_out(bscan_state,"nmemoe",0);
  641.                 set_bus_dir(bscan_state,databus,INPUT);
  642.                 jtag._IRSCAN(extest); // complete last write
  643.                 jtag._DRSCAN(bscan_state);
  644.  
  645.                 set_pin_out(bscan_state,"nmemoe",1);
  646.                 jtag._IRSCAN(extest);
  647.                 jtag.DRSCAN(bscan_state,bscan_tmp);
  648.                 toggle=(unsigned char)get_bus_in(bscan_tmp,databus);
  649.  
  650.                 do
  651.                 {
  652.                         oldtoggle = toggle;
  653.                        
  654.                         set_pin_out(bscan_state,"nmemoe",0);
  655.                         jtag._IRSCAN(extest);
  656.                         jtag._DRSCAN(bscan_state);
  657.                         set_pin_out(bscan_state,"nmemoe",1);
  658.                         jtag._IRSCAN(extest);
  659.                         jtag.DRSCAN(bscan_state,bscan_tmp);
  660.                         toggle=(unsigned char)get_bus_in(bscan_tmp,databus);
  661.  
  662.                 } while ( ((toggle&0x40)!=(oldtoggle&0x40)) && !(toggle&0x20) );
  663.  
  664.                 if( (toggle&0x20) && ((toggle&0x40)!=(oldtoggle&0x40)) )
  665.                 {
  666.                         printf("erase block failed!\n");
  667.                         return_value=0;
  668.                 }
  669.  
  670.  
  671.                 set_pin_out(bscan_state,"nmemwe",0);
  672.                 set_bus_dir(bscan_state,databus,OUTPUT);
  673.                 set_bus_out(bscan_state,databus,0x00F0);
  674.                 jtag._IRSCAN(extest);
  675.                 jtag._DRSCAN(bscan_state);
  676.                 set_pin_out(bscan_state,"nmemwe",1);
  677.                 set_pin_out(bscan_state,"nromcs",1);
  678.                 jtag._IRSCAN(extest);
  679.                 jtag._DRSCAN(bscan_state);
  680.                 jtag._IRSCAN(extest);
  681.                 jtag._DRSCAN(bscan_state);
  682.         }
  683.  
  684.  
  685.  
  686.  
  687.  
  688.  
  689.  
  690.  
  691.  
  692.  
  693.  
  694.  
  695.  
  696.         //jtag shutdown
  697.         jtag.RESET();
  698.  
  699.         // some deallocations
  700.         del_bus(addrbus);
  701.         del_bus(databus);
  702.  
  703.         delete[] bscan_state;
  704.         delete[] bscan_tmp;
  705.  
  706.  
  707.        
  708.         //writeback read data from flash
  709.         if( mode==READ )
  710.         {
  711.                 unsigned int addr,size;
  712.  
  713.                 addr=0;
  714.                 size=MAX_SIZE;
  715.  
  716.                 if( start_address>=0 ) addr=start_address;
  717.                 if( length>=0 ) size=length;
  718.                
  719.                 if( size!=(int)fwrite(&fileinmem[addr],1,size,outfile) )
  720.                 {
  721.                         printf("cant writeback read file!\n");
  722.                         return 0;
  723.                 }
  724.         }
  725.  
  726.         //close shit
  727.         if(fileinmem) free(fileinmem);
  728.         if(infile) fclose(infile);
  729.         if(outfile) fclose(outfile);
  730.  
  731.  
  732.  
  733.  
  734.         return return_value;
  735. }
  736.  
  737.  
  738.  
  739. void print_cur_addr(char * format_string, unsigned int cur_addr)
  740. {
  741.         static unsigned int old_addr = 0;
  742.  
  743.         if( (cur_addr-old_addr)>=ADDR_DELTA )
  744.         {
  745.                 old_addr = cur_addr;
  746.  
  747.                 printf(format_string,cur_addr);
  748.         }
  749. }
  750.