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;

socket_t*   first_socket_g;

socket_t*   socket1_g;

/* input argument is a pointer to the previous socket,

   if this is the first socket object, then it is NULL */

socket_t* new_socket(socket_t* prev)

{

    socket_t* socket;

    int i;

    socket = (socket_t*) malloc(sizeof(socket_t));

    socket->rx_packet = (packet_t*) malloc(sizeof(packet_t));

    /* Create space for an array of pointers */

    socket->tcp_buf = malloc (TCP_TX_BUFFERS * sizeof (void *));

    /* Create space for a set of buffers, each pointed to by an element of the array */

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

        socket->tcp_buf[i] = (packet_buffer_t*) malloc (sizeof (packet_buffer_t));

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

        socket->tcp_buf[i]->starting_seq = 0;

        socket->tcp_buf[i]->ending_seq   = 0;

        socket->tcp_buf[i]->len_bytes    = 0;

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

        }

    socket->telnet_txbuf = init_line_buffer(0x80000);

    socket->telnet_rxbuf = init_line_buffer(0x1000);

    socket->packets_sent = 0;

    socket->packets_received = 0;

    socket->packets_resent = 0;

    socket->telnet_sent_opening_message = 0;

    socket->telnet_echo_mode = 0;

    socket->telnet_connection_state = TELNET_CLOSED;

    socket->telnet_options_sent = 0;

    socket->tcp_current_buf = 0;

    socket->tcp_reset = 0;

    socket->tcp_connection_state = TCP_CLOSED;

    socket->tcp_disconnect = 0;

    socket->tcp_seq = 0x100;  /* should be random initial seq number for tcp */

    socket->tcp_last_seq = socket->tcp_seq;

    socket->tcp_last_ack = 0;

    /* Chain the socket objects together */

    if (prev == NULL){

        socket->first = socket;

        socket->id = 0;

        }

    else {

        socket->first = prev->first;

        socket->id = prev->id + 1;

        prev->next = socket;

        }

    socket->next  = NULL;

    return socket;

}

/* All received tcp packets with dset ip == me arrive here */

void parse_tcp_packet(char * buf, packet_t* rx_packet)

{

    int i;

    int ptr;

    socket_t* socket;

    int found=0;

    /* 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++;

        return;

    }

    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];

    /* only interested in telnet packet to dest port xx */

    if (rx_packet->tcp_dst_port != 23) {

        return;

    }

    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

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

    /*  seach for an open socket that matches the tcp connection */

    socket = first_socket_g;

    for(;;){

        if (socket->tcp_connection_state != TCP_CLOSED &&

            socket->rx_packet->tcp_src_port == rx_packet->tcp_src_port) {

            found=1;

            break;

            }

        if (socket->next!=NULL)

            socket=socket->next;

        else

            break;

        }

    /* Search for an available closed soeckt to reuse */

    if (!found){

        socket = first_socket_g;

        for(;;){

            if (socket->tcp_connection_state == TCP_CLOSED) {

                found=1;

                break;

                }

            if (socket->next!=NULL)

                socket=socket->next;

            else

                break;

            }

        }

    /* All available sockets being used. Add a new one to the end of the chain */

    if (!found) {

        socket = new_socket(socket);

    }

    /* Copy the rx_packet structure into the socket */

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

    tcp_response(buf, socket);

}

/* 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 */