Subversion Repositories zxusbnet

Rev

Rev 167 | Blame | Compare with Previous | Last modification | View Log | Download | RSS feed | ?url?

  1.  
  2. #include <string.h>
  3. #include <stdio.h>
  4. #include <intrz80.h>
  5. #include "w5300.h"
  6. #include "zxevo_io.h"
  7. #include "mylib\mylib.h"
  8. #include "usb\hal.h"    
  9. #include "usb\sl811.h"    
  10. #include "usb\tpbulk.h"  
  11.  
  12. extern char LSTMHZ[3][4];  
  13. unsigned char RX_BUF[2*1024];  
  14. unsigned char mhz=2;
  15. unsigned char editbuf[16];
  16.  
  17. const unsigned char mac[]={0x02,0x02,0x6A,0x6A,0x3B,0x3B};
  18. const unsigned char wb[]={60,4,0,0,0,0,0,0};
  19. unsigned int iinchip_source_port=25;
  20. const unsigned char strip[]="%u.%u.%u.%u";
  21. unsigned char wait_con;
  22. unsigned int len;
  23. extern unsigned char xdata DBUF[BUFFER_LENGTH];
  24. extern FLAGS bdata bFlags;
  25.  
  26. void main11(void);
  27. void myint(void);
  28. void winlog(void);
  29.  
  30. unsigned char rndini(unsigned char start){
  31.         static unsigned char h,l;
  32.         if(start) h=l=0;
  33.         else {
  34.                 h=h+0x77;
  35.                 l=h+(l>>1);
  36.         }
  37.         return l;
  38. }
  39.  
  40. unsigned char rnd(unsigned char start){
  41.         static unsigned char tab[256];
  42.         static unsigned char l;
  43.         if(start){
  44.                 unsigned int i;
  45.                 l=0;
  46.                 rndini(1);
  47.         for (i = 0; i < 256; i++)
  48.             tab[i] = rndini(0);
  49.         return 0;
  50.         }
  51.         else {
  52.         unsigned char b,a;
  53.         l++;
  54.         b=tab[l];
  55.         a = l + 31;
  56.         b+=tab[a];
  57.         a+=24;
  58.         tab[a]=b;
  59.         return b;
  60.         }
  61. }
  62.  
  63. void broadcast(void){  
  64.         static unsigned char tmp[5];
  65.         iinchip_source_port++;  
  66.         printf("Open socket in UDP mode");
  67.     do{
  68.         putchar('.');
  69.         *S_CR(0) =Sn_CR_CLOSE;
  70.         while(*S_CR(0));
  71.                 *S_MR(0) = Sn_MR_UDP; /* sets TCP mode */
  72.                 *S_PORTR(0) = iinchip_source_port; /* sets source port number */
  73.                 *S_CR(0) = Sn_CR_OPEN; /* sets OPEN command */
  74.                 while(*S_CR(0));
  75.         }while(*S_SSR(0) != SOCK_UDP);
  76.         puts(" OK");
  77.        
  78.         tmp[0]=GAR[0]|(~SUBR[0]);  /* set TCP SERVER IP address*/
  79.         tmp[1]=GAR[1]|(~SUBR[1]);  /* set TCP SERVER IP address*/
  80.         tmp[2]=GAR[2]|(~SUBR[2]);  /* set TCP SERVER IP address*/
  81.         tmp[3]=GAR[3]|(~SUBR[3]);  /* set TCP SERVER IP address*/
  82.         S_DIPR(0)[0]=tmp[0];  /* set TCP SERVER IP address*/
  83.         S_DIPR(0)[1]=tmp[1];  /* set TCP SERVER IP address*/
  84.         S_DIPR(0)[2]=tmp[2];  /* set TCP SERVER IP address*/
  85.         S_DIPR(0)[3]=tmp[3];  /* set TCP SERVER IP address*/
  86.         *S_DPORTR(0) = 4000;  /* set TCP SERVER listen port number*/
  87.        
  88.     printf("Send to ");
  89.     printf(strip,tmp[1],tmp[0],tmp[3],tmp[2]);
  90.         *S_TX1(0) = 0;
  91.         *S_TX(0) = 0;
  92.         *S_TX_WRSR(0) = 2;
  93.         *S_CR(0) = Sn_CR_SEND;
  94.         while(*S_CR(0));
  95.         puts(" OK");
  96.     printf("Close socket ");
  97.         *S_CR(0) = Sn_CR_CLOSE;
  98.         while(*S_CR(0));
  99.         puts(" OK\rPress any key");
  100. }
  101.  
  102. void update_main_menu(void){
  103.         unsigned char * ptr=RX_BUF;
  104.         ptr+=sprintf(ptr,"   ZXUSBNet test    \r\r[0]z80 %sMHz\r[1]GATEWAY:%u.%u.%u.%u\r",
  105.                 LSTMHZ[mhz],GAR[1],GAR[0],GAR[3],GAR[2]);
  106.         ptr+=sprintf(ptr,"[2]MASK:%u.%u.%u.%u\r",SUBR[1],SUBR[0],SUBR[3],SUBR[2]);
  107.         ptr+=sprintf(ptr,"[3]IP:%u.%u.%u.%u\r",SIPR[1],SIPR[0],SIPR[3],SIPR[2]);
  108.         sprintf(ptr,"[4]Send broadcast\r\
  109. [5]Receive packet\r\
  110. [6]Визнет мемтест\r\
  111. [7]sl811 тест\r\
  112. [8]Miniterminal(no return)\r\
  113. [9]О программе");
  114. }
  115.  
  116. void reconnect(void){
  117.         printf("Open socket in TCP mode");
  118.         iinchip_source_port++;
  119.     WIZ_SOCKET(0, Sn_MR_TCP, 23);
  120.         puts(" OK");   
  121.         printf("Set listening mode ");
  122.         *S_CR(0) = Sn_CR_LISTEN;
  123.         while(*S_CR(0));
  124.         puts(" OK");       
  125.     puts("Please connect to port 23");
  126. }
  127.  
  128. unsigned int receive(void){
  129.         unsigned int len;
  130.         unsigned char * ptr=RX_BUF;
  131.         if(!(*S_RX_RSR(0))) return 0;
  132.         while(*S_RX_RSR(0)!=*S_RX_RSR(0));
  133.         PACK_SIZE(0,len);
  134.     disable_interrupt();
  135.         output(0x82ab,input(0x82ab)&(0xff^0x08));      
  136.         {
  137.                 unsigned char i=(len+1)>>9;
  138.                 while(i){
  139.                         memcpy(ptr,S_RX_FAKE(0),512);
  140.                         i--;
  141.                         ptr+=512;
  142.                 }
  143.         }
  144.         {
  145.                 unsigned int j=(len+1)&0x01fe;
  146.                 memcpy(ptr,S_RX_FAKE(0),j);
  147.         }
  148.         output(0x82ab,input(0x82ab)|0x08);
  149.         *S_CR(0) = Sn_CR_RECV; 
  150.         while(*S_CR(0));       
  151.     enable_interrupt();
  152.         return len;
  153. }
  154.  
  155. void recv_p(void){
  156.         unsigned int ps = 0;
  157.         wait_con=1;
  158.         reconnect();
  159.         rnd(1);
  160.         while(1){
  161.        
  162.                 unsigned char stat;
  163.                 stat=*S_SSR(0);
  164.                 if((stat==SOCK_CLOSE_WAIT)||(stat==SOCK_CLOSED)) {
  165.                 if(len=receive()){
  166.                         unsigned char * ptr=RX_BUF;
  167.                         //unsigned char i=*RX_BUF;
  168.                         //printf("Length %u. check:\r",len);
  169.                         while(len){
  170.                                 unsigned char i=rnd(0);
  171.                                 if(*ptr!=i)
  172.                                         printf("bad 0x%04x: 0x%04x 0x%04x\r",ptr-RX_BUF,i,*ptr);
  173.                                 ptr++;
  174.                                 len--;
  175.                         }
  176.                         continue;
  177.                 }
  178.                         break;
  179.                 }
  180.                 else if(stat!=SOCK_ESTABLISHED) {
  181.                         continue;
  182.                 }
  183.                 if(wait_con){
  184.                         wait_con=0;
  185.                         printf("Connected :");
  186.                 printf(strip,S_DIPR(0)[1],S_DIPR(0)[0],S_DIPR(0)[3],S_DIPR(0)[2]);
  187.                 puts("\r Please send packets");
  188.                 continue;
  189.                 }
  190.                 if(len=receive()){
  191.                         //unsigned char * ptr=RX_BUF;
  192.                         //unsigned char b=0;
  193.                         ps++;
  194.                         //output8(0xfe,((unsigned char)ps)&0x07);
  195.                         /*
  196.                         while(len){
  197.                                 unsigned char i=rnd(0);
  198.                                 if(*ptr!=i){
  199.                                         printf("bad pack %lu 0x%04x: 0x%02x 0x%02x\r",ps,ptr-RX_BUF,i,*ptr);
  200.                                         b++;
  201.                                         if(b==10)getchar();
  202.                                 }
  203.                                 ptr++;
  204.                                 len--;
  205.                         }*/
  206.                         printf("\r%x",ps);
  207.                         continue;
  208.                 }
  209.         }
  210.         puts("press any key"); 
  211. }
  212.  
  213. void miniterm(void){   
  214.         wait_con=1;  
  215.         reconnect();
  216.         while(1){
  217.                 unsigned char stat;
  218.                 stat=*S_SSR(0);
  219.                 if((stat==SOCK_CLOSE_WAIT)||(stat==SOCK_CLOSED)) {
  220.                         puts("Socked closed");
  221.                         wait_con=1;
  222.                         reconnect();
  223.                         continue;
  224.                 }
  225.                 else if(stat!=SOCK_ESTABLISHED) {
  226.                         continue;
  227.                 }
  228.                 else if(wait_con){
  229.                         wait_con=0;
  230.                         printf("Connected :");
  231.                 printf(strip,S_DIPR(0)[1],S_DIPR(0)[0],S_DIPR(0)[3],S_DIPR(0)[2]);
  232.                 puts("\r Please type the text");
  233.                 continue;
  234.                 }
  235.                 else if(len=receive()){
  236.                         *(RX_BUF+len)=0;
  237.                         printf(RX_BUF);
  238.                         continue;
  239.                 }
  240. /*              if(fls&FLS_STR) {
  241.                         //kbd_pars();
  242.                         msg_send(kbd_buf.buf);
  243.                         fls=fls&(FLS_STR^0xff)|FLS_KBD;
  244.                         continue;
  245.                 }
  246.                 if(fls&FLS_CURS) flash_cursor();
  247.                 if(fls&FLS_KBD) kbd_read();
  248. */
  249.         }  
  250. }
  251.  
  252. unsigned int blok;
  253.  
  254. void memtest(unsigned char wp){
  255.         unsigned char hmr=0;
  256.         rnd(1);
  257.         blok=0;
  258.         output(0x83ab,0);
  259.         DelayMs(100);
  260.         output(0x83ab,0x10);
  261.         DelayMs(500);
  262.        
  263.         //output(0x82ab,0x0c);
  264.        
  265.         if(wp)
  266.         {
  267.                 output(0x82ab,0x50);
  268.                 output(0x01ab,0x80);
  269.         }
  270.         else   
  271.         {
  272.                 output(0x82ab,0x4c);
  273.                 *WMR=0x80;
  274.         }
  275.        
  276.         DelayMs(500);
  277.         //printf("Введите старший байт MR, в формате FF: ");
  278.     //scanf("%.2X",hmr);
  279.         if(wp){
  280.                 output(0x00ab,hmr);
  281.                 output(0x01ab,0x20);
  282.         }
  283.         else{
  284.                 *(WMR+1)=hmr;
  285.                 *WMR=0x20;
  286.         }
  287.         if(wp){
  288.                 output(0x81ab,0x08);   
  289.                 output(0x01ab,Sn_MR_TCP);
  290.                 output(0x03ab,Sn_CR_OPEN);
  291.                 while(input(0x09ab) != SOCK_INIT);
  292.         }
  293.         else
  294.         {
  295.                 *S_MR(0)=Sn_MR_TCP;
  296.                 *S_CR(0)=Sn_CR_OPEN;
  297.                 while(*S_SSR(0) != SOCK_INIT);
  298.         }
  299.         while(1){
  300.                 unsigned int i=8192;
  301.                 printf("\nБлок(8KB): %u    ",blok);
  302.                 rnd(1);
  303.                 while(i)
  304.                 {
  305.                         i--;
  306.                         i--;
  307.                         if(wp)
  308.                         {
  309.                                 //output(0x82ab,0x90); 
  310.                                 output(0x30ab,rnd(0));
  311.                                 //output(0x82ab,0x90);
  312.                                 output(0x31ab,rnd(0));
  313.                         }
  314.                         else
  315.                         {
  316.                                 *S_TX1(0) = rnd(0);
  317.                                 *S_TX(0)  = rnd(0);
  318.                         }
  319.                 }
  320.                 i=8192;
  321.                 rnd(1);
  322.                 while(i)
  323.                 {
  324.                         unsigned char trueb=rnd(0);
  325.                         unsigned char readb1;
  326.                         unsigned char readb0;
  327.                         if(wp)
  328.                         {
  329.                                 //output(0x82ab,0x90); 
  330.                                 readb1=input(0x30ab);
  331.                                 //output(0x82ab,0x90);
  332.                                 readb0=input(0x31ab);
  333.                         }
  334.                         else
  335.                         {
  336.                                 readb1=*S_TX1(0);
  337.                                 readb0=*S_TX(0);
  338.                         }
  339.                         i--;
  340.                         if(trueb != readb1){
  341.                                 printf("bad 0x%04x: 0x%02x 0x%02x\r",8192-i,trueb,readb1);
  342.                                 if(getkey())while(!getkey());
  343.                         }
  344.                         trueb=rnd(0);
  345.                         i--;
  346.                         if(trueb != readb0){
  347.                                 printf("bad 0x%04x: 0x%02x 0x%02x\r",8192-i,trueb,readb0);
  348.                                 if(getkey())while(!getkey());                          
  349.                         }
  350.                 }
  351.                 blok++;
  352.         }
  353. }
  354.  
  355. void usb_test(void){
  356.         static unsigned char temp;
  357.     SL811_RESET();
  358.     USBReset();
  359.         temp=SL811Read(cDATASet)>>4;
  360.         switch(temp)
  361.         {       case 0:puts("SL811H");break;
  362.                 case 1:puts("SL811HS rev 1.2");break;
  363.                 case 2:puts("SL811HS rev 1.5");break;
  364.                 default:puts("Unknown rev");
  365.         }
  366.     sl811_init_my();
  367.  
  368.         printf("SL811 init Ok \n");
  369.         //DirStartCluster=0;  
  370.         for(temp=0;temp<64;temp++)  
  371.                 DBUF[temp]=0;
  372.                
  373.                 if(bFlags.bits.SLAVE_FOUND)
  374.                 {
  375.                         bFlags.bits.SLAVE_FOUND=FALSE;
  376.                         DelayMs(25);
  377.                         if(EnumUsbDev(1))                               // enumerate USB device, assign USB address = #1
  378.                         {
  379.                                 bFlags.bits.SLAVE_ENUMERATED = TRUE;    // Set slave USB device enumerated flag
  380.                                 puts("\rSlave enumerated Ok");
  381.                         }
  382.                 }
  383.                 if(bFlags.bits.SLAVE_REMOVED)
  384.                 {
  385.                         bFlags.bits.SLAVE_REMOVED=FALSE;
  386.                         bFlags.bits.SLAVE_ENUMERATED = FALSE;
  387.                         bFlags.bits.SLAVE_IS_ATTACHED = FALSE;
  388.                         puts("\rSlave removed");
  389.                 }
  390.                 if(bFlags.bits.bMassDevice)
  391.                 {
  392.                         bFlags.bits.bMassDevice=FALSE;
  393.                         temp=EnumMassDev();
  394.                         if(temp==TRUE)
  395.                         {
  396.                                 bFlags.bits.SLAVE_IS_ATTACHED = TRUE;
  397.                                 puts("\rSlave is attached");
  398.                         }
  399.                         else
  400.                         {
  401.                                 printf("\rMass device, ERROR = 0x%x \n",temp);
  402.                                 bFlags.bits.SLAVE_IS_ATTACHED = FALSE;
  403.                                 temp=SL811Read(IntStatus);
  404.                                 if(!(temp & 0x40)) bFlags.bits.SLAVE_FOUND=TRUE;
  405.                                 printf("\rSlave is NOT attached, ERROR = 0x%x \n",temp);
  406.             }
  407.                 }
  408.         if(bFlags.bits.SLAVE_IS_ATTACHED){
  409.                 unsigned char b=0;
  410.                 blok=1;
  411.                 puts("Press any key, for read USB test");
  412.                 while(!getkey());
  413.                
  414.                 puts("Write 128KB");
  415.                 rnd(1);
  416.                 while(blok<0x100){
  417.                         unsigned char * ptr=RX_BUF;
  418.                         len=2048;
  419.                         while(len){
  420.                                 *ptr=rnd(0);
  421.                                 ptr++;
  422.                                 len--;
  423.                         }
  424.                         RBC_Write(blok,4,RX_BUF);
  425.                         blok+=4;
  426.                         printf("\nSectors: %u",blok);
  427.                 }
  428.                 blok=1;
  429.                
  430.                 puts("\rRead test:");
  431.                 rnd(1);
  432.                 while(1){
  433.                         unsigned char * ptr=RX_BUF;
  434.                         printf("\nSectors: %u    ",blok);
  435.                         RBC_Read(blok&0xff,4,RX_BUF);
  436.                         //RBC_Write(blok|0x4000,1,RX_BUF);
  437.                         len=2048;
  438.                         while(len){
  439.                                 unsigned char i=rnd(0);
  440.                                 if(*ptr!=i){
  441.                                         printf("\rbad 0x%04x: 0x%02x 0x%02x",ptr-RX_BUF,i,*ptr);
  442.                                         b++;
  443.                                         if(getkey())while(!getkey());
  444.                                 }
  445.                                 ptr++;
  446.                                 len--;
  447.                         }
  448.                         blok+=4;
  449.                         if((blok&0xff)==1){
  450.                                 rnd(1);
  451.                         }
  452.                 }
  453.                 printf("\nBads: %u",b);
  454.         }      
  455. }
  456. const unsigned char * pmsg="Port %X %s detected\r\n";
  457. void testports(void){
  458.         unsigned char err=0;
  459.         if(((output(0x81ab,0),input(0x81ab)&0x0f)==0x00)&&
  460.                 ((output(0x81ab,0x0a),input(0x81ab)&0x0f)==0x0a)){
  461.                 printf(pmsg,0x81ab,"");
  462.         }else {
  463.                 printf(pmsg,0x81ab,"not");
  464.                 err=1;
  465.         }
  466.         if(((output(0x82ab,0x40),input(0x82ab)&0x5f)==0x40)&&
  467.                 ((output(0x82ab,0x5b),input(0x82ab)&0x5f)==0x5b)){
  468.                 printf(pmsg,0x82ab,"");
  469.         }else {
  470.                 printf(pmsg,0x82ab,"not");
  471.                 err=1;
  472.         }
  473.         if(((output(0x83ab,0),input(0x83ab)&0x7c)==0x00)&&
  474.                 ((output(0x83ab,0x14),input(0x83ab)&0x7c)==0x14)){
  475.                 printf(pmsg,0x83ab,"");
  476.         }else {
  477.                 printf(pmsg,0x83ab,"not");
  478.                 err=1;
  479.         }
  480.         output(0x83ab,0);
  481.         if(err){
  482.                 puts("ZXNetUsb not found!\r\nPress reset.");
  483.                 while(1);
  484.         }
  485. }
  486. void findchips(void){
  487.         printf("w5300 through ports...");
  488.         output(0x82ab,0x50);
  489.         output(0x81ab,0x03);
  490.         if((input(0x3eab)==0x53)&&(input(0x3fab)==0x00)) puts("found");
  491.         else puts("not found!");
  492.         printf("w5300 through memmap...");
  493.         output(0x82ab,0x4c);
  494.         if(*WIDW==0x5300) puts("found");
  495.         else puts("not found!");
  496. }
  497. void main(void){
  498.         winlog();
  499.         testports();
  500.     wiz_reset();
  501.         findchips();
  502.         //puts("Press any key");
  503.         //getkey();
  504.         //while(!getkey());
  505.     WIZ_SYS_INIT(wb,wb);
  506.     memcpy(SHAR,mac,6);
  507.         my_im2_init(myint);
  508.         enable_interrupt();
  509.         main11();
  510.        
  511.         while(1);
  512. }
  513.  
  514.