ata.c

atmelmega128ATA驱动内含FAT32源码

      incoming_ack =make32(packet[TCP_acknum],packet[TCP_acknum+1], \
	  packet[TCP_acknum+2],packet[TCP_acknum+3]);

      //check for the number of bytes acknowledged
      //determine how many bytes are outstanding and adjust the outgoing 
	  //sequence number accordingly
      if(incoming_ack <= expected_ack)
         my_seqnum = expected_ack - (expected_ack - incoming_ack);
     
      //my expected acknowledgement number
      expected_ack = my_seqnum +tcpdatalen_out;
      send_tcp_packet();
	  
   }

   //this code segment processes the incoming SYN from the Telnet client
   //and sends back the initial sequence number (ISN) and acknowledges
   //the incoming SYN packet
   if(SYN_IN && portaddr == MY_PORT_ADDRESS)
   {
      tcpdatalen_in = 0x01;
      set_synflag;

      setipaddrs();

      data_L = packet[TCP_srcport];
      packet[TCP_srcport] = packet[TCP_destport];
      packet[TCP_destport] = data_L;

      data_L = packet[TCP_srcport+1];
      packet[TCP_srcport+1] = packet[TCP_destport+1];
      packet[TCP_destport+1] = data_L;

      assemble_ack();

      if(++ISN == 0x0000 || ++ISN == 0xFFFF)
       	 my_seqnum = 0x1234FFFF;

      set_packet32(TCP_seqnum,my_seqnum);

      packet[TCP_hdrflags+1] = 0x00;
      SYN_OUT;
      ACK_OUT;

      packet[TCP_cksum] = 0x00;
      packet[TCP_cksum+1] = 0x00;

      hdr_chksum =0;
      hdrlen = 0x08;
      addr = &packet[ip_srcaddr];
      cksum();
      hdr_chksum = hdr_chksum + packet[ip_proto];
      tcplen = make16(packet[ip_pktlen],packet[ip_pktlen+1]) - \
	  ((packet[ip_vers_len] & 0x0F) * 4);
      hdr_chksum = hdr_chksum + tcplen;
      hdrlen = tcplen;
      addr = &packet[TCP_srcport];
      cksum();
      chksum16= ~(hdr_chksum + ((hdr_chksum & 0xFFFF0000) >> 16));
      packet[TCP_cksum] = make8(chksum16,1);
      packet[TCP_cksum+1] = make8(chksum16,0);
      echo_packet();
   }

   //this code segment processes a FIN from the Telnet client
   //and acknowledges the FIN and any incoming data.
   if(FIN_IN && portaddr == MY_PORT_ADDRESS)
   {
      if(tcpdatalen_in)
      {
         for(i=0;i<tcpdatalen_in;++i)
         {
            aux_data[i] = packet[TCP_data+i];
            application_code();
         }
      }

      set_finflag;

      ++tcpdatalen_in;

      incoming_ack =make32(packet[TCP_acknum],packet[TCP_acknum+1], \
	  packet[TCP_acknum+2],packet[TCP_acknum+3]);
      if(incoming_ack <= expected_ack)
         my_seqnum = expected_ack - (expected_ack - incoming_ack);

      expected_ack = my_seqnum +tcpdatalen_out;
      send_tcp_packet();

   }
}
//******************************************************************
//*	Assemble the Acknowledgment
//*   This function assembles the acknowledgment to send to
//*   to the client by adding the received data count to the
//*   client's incoming sequence number.
//******************************************************************
void assemble_ack()
{
   client_seqnum=make32(packet[TCP_seqnum],packet[TCP_seqnum+1], \
   packet[TCP_seqnum+2],packet[TCP_seqnum+3]);
   client_seqnum = client_seqnum + tcpdatalen_in;
   set_packet32(TCP_acknum,client_seqnum);
}
//******************************************************************
//*	Send TCP Packet
//*   This routine assembles and sends a complete TCP/IP packet.
//*   40 bytes of IP and TCP header data is assumed.
//******************************************************************
void send_tcp_packet()
{
   //count IP and TCP header bytes.. Total = 40 bytes
   ip_packet_len = 40 + tcpdatalen_out;
   packet[ip_pktlen] = make8(ip_packet_len,1);
   packet[ip_pktlen+1] = make8(ip_packet_len,0);
   setipaddrs();

   data_L = packet[TCP_srcport];
   packet[TCP_srcport] = packet[TCP_destport];
   packet[TCP_destport] = data_L;
   data_L = packet[TCP_srcport+1];
   packet[TCP_srcport+1] = packet[TCP_destport+1];
   packet[TCP_destport+1] = data_L;

   assemble_ack();
   set_packet32(TCP_seqnum,my_seqnum);


   packet[TCP_hdrflags+1] = 0x00;
   ACK_OUT;
   if(flags & finflag)
   {
      FIN_OUT;
      clr_finflag;
   }

   packet[TCP_cksum] = 0x00;
   packet[TCP_cksum+1] = 0x00;

   hdr_chksum =0;
   hdrlen = 0x08;
   addr = &packet[ip_srcaddr];
   cksum();
   hdr_chksum = hdr_chksum + packet[ip_proto];
   tcplen = ip_packet_len - ((packet[ip_vers_len] & 0x0F) * 4);
   hdr_chksum = hdr_chksum + tcplen;
   hdrlen = tcplen;
   addr = &packet[TCP_srcport];
   cksum();
   chksum16= ~(hdr_chksum + ((hdr_chksum & 0xFFFF0000) >> 16));
   packet[TCP_cksum] = make8(chksum16,1);
   packet[TCP_cksum+1] = make8(chksum16,0);

   txlen = ip_packet_len + 14;
   if(txlen < 60)
      txlen = 60;
   data_L = make8(txlen,0);
   data_H = make8(txlen,1);
   write_rtl(CR,0x22);
   write_rtl(TPSR,txstart);
   write_rtl(RSAR0,0x00);
   write_rtl(RSAR1,0x40);
   write_rtl(ISR,0xFF);
   write_rtl(RBCR0,data_L);
   write_rtl(RBCR1,data_H);
   write_rtl(CR,0x12);

   for(i=0;i<txlen;++i)
      write_rtl(RDMAPORT,packet[enetpacketDest0+i]);

   byte_read = 0;
   while(!(byte_read & RDC))
      read_rtl(ISR);

   write_rtl(TBCR0,data_L);
   write_rtl(TBCR1,data_H);
   write_rtl(CR,0x24);
}
//******************************************************************
//*	Read/Write for show_regs
//*   This routine reads a NIC register and dumps it out to the
//*   serial port as ASCII.
//******************************************************************
void readwrite()
{
     read_rtl(i);
     bin2hex(byte_read);
     printf("\t%c%c",high_char,low_char);
}
//******************************************************************
//*	Displays Control Registers in Pages 1, 2 and 3
//*   This routine dumps all of the NIC internal registers
//*   to the serial port as ASCII characters.
//******************************************************************
void show_regs()
{
   write_rtl(CR,0x21);
   cls();
   printf("\r\n");
   printf("    Realtek 8019AS Register Dump\n\n\r");
   printf("REG\tPage0\tPage1\tPage2\tPage3\n\r");

   for(i=0;i<16;++i)
   {
     bin2hex((unsigned char) i);
     printf("%c%c",high_char,low_char);
     write_rtl(CR,0x21);
     readwrite();
     write_rtl(CR,0x61);
     readwrite();
     write_rtl(CR,0xA1);
     readwrite();
     write_rtl(CR,0xE1);
     readwrite();
     printf("\r\n");
   }
}
//******************************************************************
//*	Dump Receive Ring Buffer Header
//*   This routine dumps the 4-byte receive buffer ring header
//*   to the serial port as ASCII characters.
//******************************************************************
void dump_header()
{
    for(i=0;i<4;++i)
      {
         bin2hex(pageheader[i]);
         printf("\r\n%c%c",high_char,low_char);
      }
}
//******************************************************************
//*	Converts Binary to Displayable Hex Characters
//*   ie.. 0x00 in gives 0x30 and 0x30 out
//******************************************************************
void bin2hex(unsigned char binchar)
{
   high_nibble = (binchar & 0xF0) / 16;
   if(high_nibble > 0x09)
      high_char = high_nibble + 0x37;
   else
      high_char = high_nibble + 0x30;

   low_nibble = (binchar & 0x0F);
   if(low_nibble > 0x09)
      low_char = low_nibble + 0x37;
   else
      low_char = low_nibble + 0x30;
}
//******************************************************************
//*	Used with Tera Term to clear the screen (VT-100 command)
//******************************************************************
void cls(void)
{
   printf("%c[2J",esc);
}
//******************************************************************
//*   show_packet
//*	This routine is for diagnostic purposes and displays
//*   the Packet Buffer memory in the AVR.
//******************************************************************
void show_packet()
{
   cls();
   printf("\r\n");
   data_L = 0x00;
   for(i=0;i<96;++i)
   {
      bin2hex(packet[i]);
      printf(" %c%c",high_char,low_char);
      if(++data_L == 0x10)
         {
            data_L = 0x00;
            printf("\r\n");
         }
   }
}
//******************************************************************
//*   show_aux_packet
//*	This routine is a diagnostic that displays Auxillary
//*   Packet Buffer buffer memory in the AVR.
//******************************************************************
void show_aux_packet()
{
   cls();
   printf("\r\n");
   data_L = 0x00;
   for(i=0;i<80;++i)
   {
      bin2hex(aux_data[i]);
      printf(" %c%c",high_char,low_char);
      if(++data_L == 0x10)
         {
            data_L = 0x00;
            printf("\r\n");
         }
   }
}
//******************************************************************
//*	Write RTL8019AS Address
//******************************************************************
void rtladdr(unsigned char val)
{
   tortl;
   rtldata = val;
   latch_ram_addr;
   fromrtl;
}
//******************************************************************
//*	Write to NIC Control Register
//******************************************************************
void write_rtl(unsigned int regaddr, unsigned int regdata)
{
    rtladdr(regaddr);
	tortl;
    rtldata = regdata;
	nop;
	CLR_ETH_IOWB;
	nop;
	nop;
    SET_ETH_IOWB;
	nop;
    fromrtl;
}
//******************************************************************
//*	Read From NIC Control Register
//******************************************************************
void read_rtl(unsigned int regaddr)
{
   rtladdr(regaddr);	
   CLR_ETH_IORB;
   nop;
   nop;
   byte_read = PINA;
   nop;
   SET_ETH_IORB;
   nop;
}
//******************************************************************
//*	Handle Receive Ring Buffer Overrun
//*   No packets are recovered
//******************************************************************
void overrun()
{
   read_rtl(CR);
   data_L = byte_read;
   write_rtl(CR,0x21);
   delay_ms(2);
   write_rtl(RBCR0,0x00);
   write_rtl(RBCR1,0x00);
   if(!(data_L & 0x04))
      resend = 0;
   else if(data_L & 0x04)
      {
         read_rtl(ISR);
         data_L = byte_read;
         if((data_L & 0x02) || (data_L & 0x08))
            resend = 0;
         else
            resend = 1;
      }

   write_rtl(TCR,0x02);
   write_rtl(CR,0x22);
   write_rtl(BNRY,rxstart);
   write_rtl(CR,0x62);
   write_rtl(CURR,rxstart);
   write_rtl(CR,0x22);
   write_rtl(ISR,0x10);
   write_rtl(TCR,tcrval);
}
//******************************************************************
//*	Echo Packet Function
//*   This routine does not modify the incoming packet size and
//*   thus echoes the original packet structure.
//******************************************************************
void echo_packet()
{
   write_rtl(CR,0x22);
   write_rtl(TPSR,txstart);
   write_rtl(RSAR0,0x00);
   write_rtl(RSAR1,0x40);
   write_rtl(ISR,0xFF);
   write_rtl(RBCR0,pageheader[enetpacketLenL] - 4 );
   write_rtl(RBCR1,pageheader[enetpacketLenH]);
   write_rtl(CR,0x12);

   txlen = make16(pageheader[enetpacketLenH],pageheader[enetpacketLenL]) - 4;
   for(i=0;i<txlen;++i)
      write_rtl(RDMAPORT,packet[enetpacketDest0+i]);

   byte_read = 0;
   while(!(byte_read & RDC))
      read_rtl(ISR);

   write_rtl(TBCR0,pageheader[enetpacketLenL] - 4);
   write_rtl(TBCR1,pageheader[enetpacketLenH]);
   write_rtl(CR,0x24);
   
}
//******************************************************************
//*	Get A Packet From the Ring