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"

/* Global variables */

mac_ip_t self_g = { {0x00, 0x0e, 0x70, 0x70, 0x70, 0x70},  /* MAC Address  */

                    {192, 168, 0, 17}                      /* IPv4 address */

                  };

packet_t*   rx_packet_g;

socket_t*   socket0_g;

socket_t*   socket1_g;

socket_t* init_socket(int socket_id)

{

    socket_t* socket;

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

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

    init_packet_buffers(socket);

    socket->telnet_txbuf = init_line_buffer(0x80000);

    socket->telnet_rxbuf = init_line_buffer(0x1000);

    socket->id = socket_id;

    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;

    return socket;

}

void init_packet_buffers (socket_t* socket)

{

    int i;

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

        }

}

void ethernet_header(char *buf, mac_ip_t* target, unsigned short type)

{

    /* ethernet header */

    /* DA */

    buf[ 0] = target->mac[0];

    buf[ 1] = target->mac[1];

    buf[ 2] = target->mac[2];

    buf[ 3] = target->mac[3];

    buf[ 4] = target->mac[4];

    buf[ 5] = target->mac[5];

    /* SA */

    buf[ 6] = self_g.mac[0];

    buf[ 7] = self_g.mac[1];

    buf[ 8] = self_g.mac[2];

    buf[ 9] = self_g.mac[3];

    buf[10] = self_g.mac[4];

    buf[11] = self_g.mac[5];

    /* type */

    buf[12] = type>>8;

    buf[13] = type&0xff;

}

void ip_header(char *buf, mac_ip_t* target, unsigned short ip_len, char ip_proto)

{

    unsigned short header_checksum;

    static unsigned short ip_id = 0;

    /* Version, Header length */

    buf[0] = 0x45;

    /* dscp */

    buf[1] = 0;

    /* ip len */

    buf[2] = ip_len>>8;

    buf[3] = ip_len&0xff;

    /* ID */

    buf[4] = (ip_id>>8)&0xff;

    buf[5] = ip_id&0xff;

    //ip_id++;

    /* Fragment */

    buf[6] = 0;

    buf[7] = 0;

    /* ttl */

    buf[8] = 64;

    /* Protocol */

    buf[9] = ip_proto;

    /* header checksum */

    buf[10] = 0;

    buf[11] = 0;

    /* Source IP */

    buf[12] = self_g.ip[0];

    buf[13] = self_g.ip[1];

    buf[14] = self_g.ip[2];

    buf[15] = self_g.ip[3];

    /* Destination IP */

    buf[16] = target->ip[0];

    buf[17] = target->ip[1];

    buf[18] = target->ip[2];

    buf[19] = target->ip[3];

    /* header checksum */

    header_checksum = header_checksum16(buf, 20, 0);

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

    buf[11] = header_checksum&0xff;

}

void arp_reply(char *buf, mac_ip_t* arp_sender)

{

    ethernet_header(buf, arp_sender, 0x0806);

    /* Hardware Type */

    buf[14] = 0x00;

    buf[15] = 0x01;

    /* Protocol Type */

    buf[16] = 0x08;

    buf[17] = 0x00;

    /* HLEN */

    buf[18] = 0x06;

    /* PLEN */

    buf[19] = 0x04;

    /* Operation = Reply */

    buf[20] = 0x00;

    buf[21] = 0x02;

    /* Sender MAC */

    buf[22] = self_g.mac[0];

    buf[23] = self_g.mac[1];

    buf[24] = self_g.mac[2];

    buf[25] = self_g.mac[3];

    buf[26] = self_g.mac[4];

    buf[27] = self_g.mac[5];

    /* Sender IP */

    buf[28] = self_g.ip[0];

    buf[29] = self_g.ip[1];

    buf[30] = self_g.ip[2];

    buf[31] = self_g.ip[3];

    /* Target MAC */

    buf[32] = arp_sender->mac[0];

    buf[33] = arp_sender->mac[1];

    buf[34] = arp_sender->mac[2];

    buf[35] = arp_sender->mac[3];

    buf[36] = arp_sender->mac[4];

    buf[37] = arp_sender->mac[5];

    /* Target IP */

    buf[38] = arp_sender->ip[0];

    buf[39] = arp_sender->ip[1];

    buf[40] = arp_sender->ip[2];

    buf[41] = arp_sender->ip[3];

    tx_packet(42);

}

void ping_reply(packet_t* rx_packet, int ping_id, int ping_seq, char * rxbuf)

{

    int i;

    unsigned short header_checksum;

    mac_ip_t target;

    char * buf = (char*)ETHMAC_TX_BUFFER;

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

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

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

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

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

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

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

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

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

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

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

    ip_header(&buf[14], &target, rx_packet->ip_len, 1); /* bytes 14 to 33, ip_proto = 1, ICMP*/

    /* ICMP */

    /* Type = reply */

    buf[34] = 0;

    /* Code = 0 */

    buf[35] = 0;

    /* checksum */

    buf[36] = 0;

    buf[37] = 0;

    /* ID */

    buf[38] = ping_id>>8;

    buf[39] = ping_id&0xff;

    /* SEQ */

    buf[40] = ping_seq>>8;

    buf[41] = ping_seq&0xff;

    for (i=8; i< rx_packet->ip_len - rx_packet->ip_header_len*4; i++) {

        buf[34+i] = rxbuf[i];

        }

    header_checksum = header_checksum16(&buf[34], (rx_packet->ip_len)-20, 0);

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

    buf[37] = header_checksum&0xff;

    tx_packet(rx_packet->ip_len+14);

}

void parse_rx_packet(char * buf, packet_t* rx_packet)

{

    int i;

    rx_packet->dst_mac[0] = buf[0];

    rx_packet->dst_mac[1] = buf[1];

    rx_packet->dst_mac[1] = buf[2];

    rx_packet->dst_mac[3] = buf[3];

    rx_packet->dst_mac[4] = buf[4];

    rx_packet->dst_mac[5] = buf[5];

    rx_packet->src_mac[0] = buf[6];

    rx_packet->src_mac[1] = buf[7];

    rx_packet->src_mac[2] = buf[8];

    rx_packet->src_mac[3] = buf[9];

    rx_packet->src_mac[4] = buf[10];

    rx_packet->src_mac[5] = buf[11];

    rx_packet->eth_type   = (buf[12]<<8) + buf[13];

    /* ARP */

    if (rx_packet->eth_type == 0x0806) {

        parse_arp_packet(&buf[14]);

        }

    /* Internet Protocol  */

    else if (rx_packet->eth_type == 0x0800){

        parse_ip_packet(&buf[14], rx_packet);

        }

}

void parse_arp_packet(char * buf)

{

    /* ARP is a broadcast message (mac broadcast address)

      asking 'does this IP address belong to you?"

    */

    int arp_op;

    mac_ip_t arp_sender, arp_target;

    arp_op = buf[6]<<8 | buf[7];

    arp_sender.mac[0] = buf[8];

    arp_sender.mac[1] = buf[9];

    arp_sender.mac[2] = buf[10];

    arp_sender.mac[3] = buf[11];

    arp_sender.mac[4] = buf[12];

    arp_sender.mac[5] = buf[13];

    arp_sender.ip [0] = buf[14];

    arp_sender.ip [1] = buf[15];

    arp_sender.ip [2] = buf[16];

    arp_sender.ip [3] = buf[17];

    arp_target.mac[0] = buf[18];

    arp_target.mac[1] = buf[19];

    arp_target.mac[2] = buf[20];

    arp_target.mac[3] = buf[21];

    arp_target.mac[4] = buf[22];

    arp_target.mac[5] = buf[23];

    arp_target.ip [0] = buf[24];

    arp_target.ip [1] = buf[25];

    arp_target.ip [2] = buf[26];

    arp_target.ip [3] = buf[27];

    /* Send a reply ? */

    if (arp_op==1 &&

        arp_target.ip[0]==self_g.ip[0] &&

        arp_target.ip[1]==self_g.ip[1] &&

        arp_target.ip[2]==self_g.ip[2] &&

        arp_target.ip[3]==self_g.ip[3]) {

        // ARP reply

        arp_reply((char*)ETHMAC_TX_BUFFER, &arp_sender);

        }

}

void parse_ip_packet(char * buf, packet_t* rx_packet)

{

    unsigned int ip_version;

    ip_version = buf[0]>>4;

    if (ip_version != 4) {

        //printf("%s: IP version %d not supported\n", __func__, ip_version);

        return;

        }

    /* Get destination IP address */

    rx_packet->dst_ip[0] = buf[16];

    rx_packet->dst_ip[1] = buf[17];

    rx_packet->dst_ip[2] = buf[18];

    rx_packet->dst_ip[3] = buf[19];

    /* If its not my address then ignore the packet */

    if (rx_packet->dst_ip[0] != self_g.ip[0] ||

        rx_packet->dst_ip[1] != self_g.ip[1] ||

        rx_packet->dst_ip[2] != self_g.ip[2] ||

        rx_packet->dst_ip[3] != self_g.ip[3] ) {

        return;

        }

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

    rx_packet->ip_header_len  = buf[0] & 0xf;

    rx_packet->ip_proto       = buf[9];

    rx_packet->src_ip[0]      = buf[12];

    rx_packet->src_ip[1]      = buf[13];

    rx_packet->src_ip[2]      = buf[14];

    rx_packet->src_ip[3]      = buf[15];

    /* Ping packets */

    if (rx_packet->ip_proto == 1){

        parse_ping_packet(&buf[(rx_packet->ip_header_len)*4], rx_packet);

        }

    /* TCP packets */

    else if (rx_packet->ip_proto == 6){

        parse_tcp_packet(&buf[(rx_packet->ip_header_len)*4], rx_packet);

        }

    /* UDP packets */

    else if (rx_packet->ip_proto == 17){

        parse_udp_packet(&buf[(rx_packet->ip_header_len)*4], rx_packet);

        }

}

void parse_ping_packet(char * buf, packet_t* rx_packet)

{

    int ping_id;

    int ping_seq;

    ping_id     = buf[4]<<8|buf[5];

    ping_seq    = buf[6]<<8|buf[7];

    ping_reply(rx_packet, ping_id, ping_seq, buf);

}

unsigned short header_checksum16(unsigned char *buf, unsigned short len, unsigned int sum)

 {

     // build the sum of 16bit words

     while(len>1) {

         sum += 0xFFFF & (*buf<<8|*(buf+1));

         buf+=2;

         len-=2;

         }

     // if there is a byte left then add it (padded with zero)

     if (len) {

         sum += (0xFF & *buf)<<8;

         }

     // now calculate the sum over the bytes in the sum

     // until the result is only 16bit long

     while (sum>>16) {

         sum = (sum & 0xFFFF)+(sum >> 16);

         }

     // build 1's complement:

     return( (unsigned short ) sum ^ 0xFFFF);

}