Subversion Repositories amber

/*----------------------------------------------------------------

//                                                              //

//  boot-loader-ethmac.c                                        //

//                                                              //

//  This file is part of the Amber project                      //

//  http://www.opencores.org/project,amber                      //

//                                                              //

//  Description                                                 //

//  The main functions for the boot loader application. This    //

//  application is embedded in the FPGA's SRAM and is used      //

//  to load larger applications into the DDR3 memory on         //

//  the development board.                                      //

//                                                              //

//  Author(s):                                                  //

//      - Conor Santifort, csantifort.amber@gmail.com           //

//                                                              //

//////////////////////////////////////////////////////////////////

//                                                              //

// Copyright (C) 2011 Authors and OPENCORES.ORG                 //

//                                                              //

// This source file may be used and distributed without         //

// restriction provided that this copyright statement is not    //

// removed from the file and that any derivative work contains  //

// the original copyright notice and the associated disclaimer. //

//                                                              //

// This source file is free software; you can redistribute it   //

// and/or modify it under the terms of the GNU Lesser General   //

// Public License as published by the Free Software Foundation; //

// either version 2.1 of the License, or (at your option) any   //

// later version.                                               //

//                                                              //

// This source is distributed in the hope that it will be       //

// useful, but WITHOUT ANY WARRANTY; without even the implied   //

// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR      //

// PURPOSE.  See the GNU Lesser General Public License for more //

// details.                                                     //

//                                                              //

// You should have received a copy of the GNU Lesser General    //

// Public License along with this source; if not, download it   //

// from http://www.opencores.org/lgpl.shtml                     //

//                                                              //

----------------------------------------------------------------*/

#include "amber_registers.h"

#include "address_map.h"

#include "line-buffer.h"

#include "timer.h"

#include "utilities.h"

#include "packet.h"

#include "tcp.h"

#include "telnet.h"

/* Global variables */

int         tcp_checksum_errors_g = 0;

void parse_tcp_packet(char * buf, packet_t* rx_packet)

{

    int i;

    int ptr;

    socket_t* socket;

    /* TCP Length */

    rx_packet->tcp_len         = rx_packet->ip_len - rx_packet->ip_header_len*4;

    rx_packet->tcp_hdr_len     = (buf[12]>>4)*4;

    // Guard against incorrect tcp_hdr_len value

    if (rx_packet->tcp_hdr_len < rx_packet->tcp_len)

        rx_packet->tcp_payload_len = rx_packet->tcp_len - rx_packet->tcp_hdr_len;

    else

        rx_packet->tcp_payload_len = 0;

    /* Verify the TCP checksum is correct */

    if (tcp_checksum(buf, rx_packet, 0)) {

        tcp_checksum_errors_g++;

        goto error_out;

    }

    rx_packet->tcp_src_port    = buf[0]<<8|buf[1];

    rx_packet->tcp_dst_port    = buf[2]<<8|buf[3];

    rx_packet->tcp_seq         = buf[4]<<24|buf[5]<<16|buf[6]<<8|buf[7];

    rx_packet->tcp_ack         = buf[8]<<24|buf[9]<<16|buf[10]<<8|buf[11];

    rx_packet->tcp_flags       = buf[13];

    rx_packet->tcp_window_size = buf[14]<<8|buf[15];

    if (rx_packet->tcp_hdr_len > 20) {

        /* Get the source time stamp */

        parse_tcp_options(buf, rx_packet);

        }

    /*  --------------------------------------------------

        Assign the received packet to a socket

        -------------------------------------------------- */

    /* socket 0 open and matches ? */

    if (socket0_g->tcp_connection_state != TCP_CLOSED &&

        socket0_g->rx_packet->tcp_src_port == rx_packet->tcp_src_port)

        socket = socket0_g;

    /* socket 1 open and matches ? */

    else if (socket1_g->tcp_connection_state != TCP_CLOSED &&

        socket1_g->rx_packet->tcp_src_port == rx_packet->tcp_src_port)

        socket = socket1_g;

    /* no matches. Pick an unused socket */

    else if (socket0_g->tcp_connection_state == TCP_CLOSED)

        socket = socket0_g;

    else if (socket1_g->tcp_connection_state == TCP_CLOSED)

        socket = socket1_g;

    else

        goto error_out;

    /* Copy the rx_packet structure into the socket */

    memcpy(socket->rx_packet, rx_packet, sizeof(packet_t));

    tcp_response(buf, socket);

    error_out:

        return;

}

/* Get the tcp source time stamp by walking through the options */

void parse_tcp_options(char * buf, packet_t* rx_packet)

{

    int ptr;

    ptr = 20;

    while (ptr < rx_packet->tcp_hdr_len-1) {

        switch (buf[ptr]) {

            case 0:  ptr=rx_packet->tcp_hdr_len; break; // end of options

            case 1:  ptr++; break;

            case 2:  ptr = ptr + buf[ptr+1]; break;  // max segment size 

            case 3:  ptr = ptr + buf[ptr+1]; break;  // Window Scale

            case 4:  ptr = ptr + buf[ptr+1]; break;  // SACK Permitted

            case 5:  ptr = ptr + buf[ptr+1]; break;  // SACK

            case 8:

                // Time Stamp Option 

                rx_packet->tcp_src_time_stamp = buf[ptr+2]<<24|buf[ptr+3]<<16|buf[ptr+4]<<8|buf[ptr+5];

                ptr = ptr + buf[ptr+1];

                break;

            case 28:  // User Timeout Option

                ptr = ptr + buf[ptr+1]; break;

            default:

                ptr++; break;

            }

        }

}

void tcp_response(char * buf, socket_t* socket)

{

    socket->packets_received++;

    /* Mark the ack in the tcp tx packet buffer so the tx packet does not get resent */

    if (socket->rx_packet->tcp_flags & 0x10) // ack flag set ?    

        tcp_ack(socket);

    // Other side requesting to reset a connection ?

    if (socket->rx_packet->tcp_flags & 0x04) { // RST 

        // Reset the connection

        socket->tcp_disconnect = 1;

        }

    // open a connection

    else if (socket->tcp_connection_state == TCP_CLOSED) {

        if (socket->rx_packet->tcp_flags & 0x02) { // SYN 

            // Open connection

            tcp_open(socket);

            socket->tcp_connection_state = TCP_PENDING;

            }

        /* ACK any FIN received */

        else if (socket->rx_packet->tcp_flags & 0x01) // FIN 

            tcp_reply(socket, NULL, 0);

        }

    // Sent the first ack packet to establish a connection.

    // Have just received the second packet from the server    

    else if (socket->tcp_connection_state == TCP_PENDING) {

        /* Add 1 to the sequence number as a special case to open

           the connection */

        socket->tcp_seq++;

        socket->tcp_connection_state = TCP_OPEN;

        }

    // connection is already open

    else {

        /* contains tcp payload */

        if (socket->rx_packet->tcp_payload_len != 0) {

            /* Ack the packet only if the payload length is non-zero */

            tcp_reply(socket, NULL, 0);

            /* Process the tcp contents */

            if (socket->rx_packet->tcp_dst_port == TELNET_PORT)

                /* telnet */

                parse_telnet_options(&buf[socket->rx_packet->tcp_hdr_len], socket);

            }

        }

}

void tcp_disconnect(socket_t * socket)

{

    if (socket->tcp_connection_state != TCP_CLOSED) {

        socket->tcp_connection_state = TCP_CLOSED;

        socket->telnet_connection_state = TELNET_CLOSED;

        socket->telnet_options_sent = 0;

        socket->telnet_sent_opening_message = 0;

        tcp_reply(socket, NULL, 0);

        socket->tcp_disconnect = 0;

        socket->telnet_echo_mode = 0;  // reset this setting

    }

}

/* Transmit a string of length line_len

   Suspend interrupts so this process does not get interrupted */

void tcp_tx(socket_t* socket, char* buf, int len)

{

    /* Disable ethmac_int interrupt */

    *(unsigned int *) ( ADR_AMBER_IC_IRQ0_ENABLECLR ) = 0x100;

    tcp_reply(socket, buf, len);

    /* Enable ethmac_int interrupt */

    *(unsigned int *) ( ADR_AMBER_IC_IRQ0_ENABLESET ) = 0x100;

}

/* TODO merge this into tcp_reply */

void tcp_open(socket_t* socket)

{

    int i, j;

    unsigned short header_checksum;

    mac_ip_t target;

    int ip_length;

    char * buf;

    buf = socket->tcp_buf[socket->tcp_current_buf]->buf;

    target.mac[0] = socket->rx_packet->src_mac[0];

    target.mac[1] = socket->rx_packet->src_mac[1];

    target.mac[2] = socket->rx_packet->src_mac[2];

    target.mac[3] = socket->rx_packet->src_mac[3];

    target.mac[4] = socket->rx_packet->src_mac[4];

    target.mac[5] = socket->rx_packet->src_mac[5];

    target.ip[0]  = socket->rx_packet->src_ip[0];

    target.ip[1]  = socket->rx_packet->src_ip[1];

    target.ip[2]  = socket->rx_packet->src_ip[2];

    target.ip[3]  = socket->rx_packet->src_ip[3];

    /* Include 20 bytes of tcp options */

    ip_length = 20+20+20; /* 20 bytes ip header, 20 bytes tcp header, 20 bytes tcp options */

    socket->tcp_buf[socket->tcp_current_buf]->payload_valid = 1;

    socket->tcp_buf[socket->tcp_current_buf]->ack_received = 0;

    socket->tcp_buf[socket->tcp_current_buf]->starting_seq = tcp_header(&buf[34], socket, 0, TCP_NEW);

    socket->tcp_buf[socket->tcp_current_buf]->ending_seq   = socket->tcp_buf[socket->tcp_current_buf]->starting_seq + 1;

    set_timer(&socket->tcp_buf[socket->tcp_current_buf]->resend_time, 500);

    ip_header(&buf[14], &target, ip_length, 6); /* 20 byes of tcp  options, bytes 14 to 33, ip_proto = 6, TCP*/

    ethernet_header(buf, &target, 0x0800);  /* bytes 0 to 13*/

    socket->tcp_buf[socket->tcp_current_buf]->len_bytes = 14+ip_length;

    strncpy((char*)ETHMAC_TX_BUFFER, buf, socket->tcp_buf[socket->tcp_current_buf]->len_bytes);

    tx_packet(socket->tcp_buf[socket->tcp_current_buf]->len_bytes);  // MAC header, IP header, TCP header, TCP options

    socket->packets_sent++;

    /* Pick the next tx buffer to use */

    if (socket->tcp_current_buf == TCP_TX_BUFFERS-1)

        socket->tcp_current_buf=0;

    else

        socket->tcp_current_buf++;

}

void tcp_reply(socket_t* socket, char* telnet_payload, int telnet_payload_length)

{

    int i, j;

    mac_ip_t target;

    int ip_length;

    char * buf;

    buf = socket->tcp_buf[socket->tcp_current_buf]->buf;

    target.mac[0] = socket->rx_packet->src_mac[0];

    target.mac[1] = socket->rx_packet->src_mac[1];

    target.mac[2] = socket->rx_packet->src_mac[2];

    target.mac[3] = socket->rx_packet->src_mac[3];

    target.mac[4] = socket->rx_packet->src_mac[4];

    target.mac[5] = socket->rx_packet->src_mac[5];

    target.ip[0]  = socket->rx_packet->src_ip[0];

    target.ip[1]  = socket->rx_packet->src_ip[1];

    target.ip[2]  = socket->rx_packet->src_ip[2];

    target.ip[3]  = socket->rx_packet->src_ip[3];

    ip_length = 20+20 + telnet_payload_length;

    /* Copy the payload into the transmit buffer */

    if (telnet_payload_length != 0) {

        for (i=14+ip_length-telnet_payload_length, j=0; i<14+ip_length;i++,j++) {

            buf[i] = telnet_payload[j];

            }

        }

    if (telnet_payload_length)

        socket->tcp_buf[socket->tcp_current_buf]->payload_valid = 1;

    else

        socket->tcp_buf[socket->tcp_current_buf]->payload_valid = 0;

    socket->tcp_buf[socket->tcp_current_buf]->ack_received = 0;

    socket->tcp_buf[socket->tcp_current_buf]->starting_seq = tcp_header(&buf[34], socket, telnet_payload_length, TCP_NORMAL);

    socket->tcp_buf[socket->tcp_current_buf]->ending_seq   = socket->tcp_buf[socket->tcp_current_buf]->starting_seq + telnet_payload_length;

    set_timer(&socket->tcp_buf[socket->tcp_current_buf]->resend_time, 500);

    ip_header(&buf[14], &target, ip_length, 6); /* 20 byes of tcp  options, bytes 14 to 33, ip_proto = 6, TCP*/

    ethernet_header(buf, &target, 0x0800);  /*bytes 0 to 13*/

    socket->tcp_buf[socket->tcp_current_buf]->len_bytes = 14+ip_length;

    strncpy((char*)ETHMAC_TX_BUFFER, buf, socket->tcp_buf[socket->tcp_current_buf]->len_bytes);

    tx_packet(socket->tcp_buf[socket->tcp_current_buf]->len_bytes);  // MAC header, IP header, TCP header, TCP options

    socket->packets_sent++;

    /* Pick the next tx buffer to use */

    if (socket->tcp_current_buf == TCP_TX_BUFFERS-1)

        socket->tcp_current_buf=0;

    else

        socket->tcp_current_buf++;

}

/* Find the packets lower than or equal to seq and mark them as acked */

void tcp_ack(socket_t* socket)

{

    int i, ack_valid;

    unsigned int ack      = socket->rx_packet->tcp_ack;

    unsigned int last_ack = socket->tcp_last_ack;

    for (i=0;i<TCP_TX_BUFFERS;i=i+1) {

        if (socket->tcp_buf[i]->payload_valid) {

            if (ack > last_ack) {

                ack_valid = (socket->tcp_buf[i]->ending_seq > last_ack) &&

                            (socket->tcp_buf[i]->ending_seq <= ack);

                }

            else { /* ack is a little after 0, last_ack is a little before 0 */

                if (socket->tcp_buf[i]->ending_seq < last_ack)

                    /* ending sequence is a little after 0 */

                    ack_valid = socket->tcp_buf[i]->ending_seq <= ack;

                else

                    ack_valid = 1;

                }

            if (ack_valid)  {

                socket->tcp_buf[i]->ack_received = 1;

                if (socket->tcp_buf[i]->ending_seq == ack) break;

                }

            }

        }

   socket->tcp_last_ack = ack;

}

/* Check if any tcp packets need to be re-transmitted */

void tcp_retransmit(socket_t* socket)

{

    int i;

    /* Find the packet that matches seq */

    for (i=0;i<TCP_TX_BUFFERS;i=i+1) {

        if (socket->tcp_buf[i]->payload_valid && !socket->tcp_buf[i]->ack_received) {

            if (timer_expired(&socket->tcp_buf[i]->resend_time))  {

                /* Update the timer to trigger again in another little while */

                set_timer(&socket->tcp_buf[i]->resend_time, 500);

                socket->packets_resent++;

                /* Disable ethmac_int interrupt */

                *(unsigned int *) ( ADR_AMBER_IC_IRQ0_ENABLECLR ) = 0x100;

                strncpy((char*)ETHMAC_TX_BUFFER, socket->tcp_buf[i]->buf, socket->tcp_buf[i]->len_bytes);

                tx_packet(socket->tcp_buf[i]->len_bytes);  // MAC header, IP header, TCP header, TCP options

                socket->packets_sent++;

                /* Enable ethmac_int interrupt */

                *(unsigned int *) ( ADR_AMBER_IC_IRQ0_ENABLESET ) = 0x100;

                break;

                }

            }

        }

}

/* return the starting seq number for this packet */

unsigned int tcp_header(char *buf, socket_t* socket, int payload_length, int options)

{

    unsigned short header_checksum;

    unsigned int seq_num;

    unsigned int ack_num;

    char flags = 0;

    unsigned short len_tcp;

    unsigned int starting_seq;

    /* Source Port */

    buf[0] = socket->rx_packet->tcp_dst_port >>8;

    buf[1] = socket->rx_packet->tcp_dst_port &0xff;

    /* Destination Port */

    buf[2] = socket->rx_packet->tcp_src_port >>8;

    buf[3] = socket->rx_packet->tcp_src_port &0xff;

    /* Sequence Number */

    /* Increment the sequence number for the next packet */

    starting_seq = socket->tcp_seq;

    socket->tcp_last_seq = socket->tcp_seq;

    socket->tcp_seq += payload_length;

    buf[4] =  starting_seq>>24;

    buf[5] = (starting_seq>>16)&0xff;

    buf[6] = (starting_seq>>8)&0xff;

    buf[7] =  starting_seq&0xff;

    /* Ack Number */

    if (options == TCP_NEW)

        ack_num = socket->rx_packet->tcp_seq + 1;

    else if (socket->rx_packet->tcp_flags & 0x01) // FIN 

        // +1 to the final ack

        ack_num = socket->rx_packet->tcp_seq + 1;

    else

        ack_num = socket->rx_packet->tcp_seq + socket->rx_packet->tcp_payload_len;

    buf[8]  =  ack_num>>24;

    buf[9]  = (ack_num>>16)&0xff;

    buf[10] = (ack_num>>8)&0xff;

    buf[11] =  ack_num&0xff;

    /* Data offset with OPTIONS */

    if (options == TCP_NEW)

        buf[12] = 0xa0;  /* upper 4 bits, min is 5 */

    else

        buf[12] = 0x50;  /* upper 4 bits, min is 5 */

    /* Flags */

    flags = 0x10;       /* ACK */

    if (options == TCP_NEW)    /* Valid in first reply in new connection only */

        flags |= 0x02;  /* SYNchronise */

    if (socket->tcp_disconnect)

        flags |= 0x01;  /* FINish */

    if (socket->tcp_reset)

        flags |= 0x04;  /* Reset */

    buf[13] = flags;

    /* Window Size */

    buf[14] = socket->rx_packet->tcp_window_size >> 8;

    buf[15] = socket->rx_packet->tcp_window_size & 0xff;

    /* Checksum */

    buf[16] = 0;

    buf[17] = 0;

    /* Urgent Pointer */

    buf[18] = 0;

    buf[19] = 0;

    if (options == TCP_NEW) {

        /* OPTION: max seg size */

        buf[20] = 0x02;

        buf[21] = 0x04;

        buf[22] = 0x05;

        buf[23] = 0xb4;

        /* OPTION Sack OK */

        buf[24] = 0x04;

        buf[25] = 0x02;

        /* OPTION Time Stamp */

        buf[26] = 0x08;

        buf[27] = 0x0a;

        buf[28] = 0x00;

        buf[29] = 0x61;

        buf[30] = 0x1f;

        buf[31] = 0xc6;

        buf[32] =  socket->rx_packet->tcp_src_time_stamp>>24;

        buf[33] = (socket->rx_packet->tcp_src_time_stamp>>16)&0xff;

        buf[34] = (socket->rx_packet->tcp_src_time_stamp>>8)&0xff;

        buf[35] =  socket->rx_packet->tcp_src_time_stamp&0xff;

        /* OPTION: NOP */

        buf[36] = 0x01;

        /* OPTION Window Scale */

        buf[37] = 0x03;

        buf[38] = 0x03;

        buf[39] = 0x06;

        }

    /* Length */

    if (options == TCP_NEW)

        len_tcp = 40+payload_length;

    else

        len_tcp = 20+payload_length;

    /* header checksum */

    header_checksum = tcp_checksum(buf, socket->rx_packet, len_tcp);

    buf[16] = (header_checksum>>8)&0xff;

    buf[17] = header_checksum&0xff;

    return starting_seq;

}

unsigned short tcp_checksum(unsigned char *buf, packet_t* rx_packet, unsigned short len_tcp)

{

    unsigned short prot_tcp=6;

    unsigned short word16;

    unsigned long  sum;

    int i;

    //initialize sum to zero

    sum=0;

    if (!len_tcp) len_tcp = rx_packet->tcp_len;

    // add the TCP pseudo header which contains:

    // the IP source and destinationn addresses,

    for (i=0;i<4;i=i+2){

            word16 =((rx_packet->src_ip[i]<<8)&0xFF00)+(rx_packet->src_ip[i+1]&0xFF);

            sum=sum+word16;

    }

    for (i=0;i<4;i=i+2){

            word16 =((rx_packet->dst_ip[i]<<8)&0xFF00)+(rx_packet->dst_ip[i+1]&0xFF);

            sum=sum+word16;

    }

    // the protocol number and the length of the TCP packet

    sum = sum + prot_tcp + len_tcp;

    return header_checksum16(buf, len_tcp, sum);

}