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;
 
 
void init_packet()
{
    /* receive packet buffer */
    rx_packet_g = malloc(sizeof(packet_t));
    rx_packet_g->tcp_window_scale = 0;
}
 
 
void ethernet_header(char *buf, mac_t* target_mac, unsigned short type)
{
    /* ethernet header */
    /* DA */
    strncpy(&buf[0], target_mac, 6);
    // print_serial("%s:L%d ethernet header target mac %x:%x:%x:%x:%x:%x\n\r",
    //    __FILE__, __LINE__,
    //    target_mac->mac[0], target_mac->mac[1], target_mac->mac[2],
    //    target_mac->mac[3], target_mac->mac[4], target_mac->mac[5]
    //    );
 
    /* SA */
    strncpy(&buf[6], &self_g.mac[0], 6);
    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, ip_t* target_ip, 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 */
    strncpy(&buf[12], &self_g.ip[0], 4);
 
    /* Destination IP */
    strncpy(&buf[16], target_ip, 4);
 
    /* header checksum */
    header_checksum = header_checksum16(buf, 20, 0);
    buf[10] = (header_checksum>>8)&0xff;
    buf[11] = header_checksum&0xff;
}
 
 
 
void arp_reply(mac_t* arp_sender_mac, ip_t* arp_sender_ip)
{
    char buf [44];
    ethernet_header(buf, arp_sender_mac, 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->mac[0];
    buf[33] = arp_sender_mac->mac[1];
    buf[34] = arp_sender_mac->mac[2];
    buf[35] = arp_sender_mac->mac[3];
    buf[36] = arp_sender_mac->mac[4];
    buf[37] = arp_sender_mac->mac[5];
 
    /* Target IP */
    buf[38] = arp_sender_ip->ip[0];
    buf[39] = arp_sender_ip->ip[1];
    buf[40] = arp_sender_ip->ip[2];
    buf[41] = arp_sender_ip->ip[3];
    ethmac_tx_packet(buf, 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 [96];  // not sure how long this needs  to be = (char*)ETHMAC_TX_BUFFER;
 
    ethernet_header(buf, (mac_t*) rx_packet->src_mac, 0x0800);  /*bytes 0 to 13*/
    ip_header(&buf[14], (ip_t*) rx_packet->src_ip, 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;
    ethmac_tx_packet(buf, rx_packet->ip_len+14);
}
 
 
void parse_rx_packet(char * buf, packet_t* rx_packet)
{
    int i;
 
    for (i=0;i<6;i++)
        rx_packet->dst_mac[i] = buf[i];
 
    for (i=0;i<6;i++)
        rx_packet->src_mac[i] = buf[i+6];
 
    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;
    mac_t arp_sender_mac;
    ip_t arp_sender_ip;
 
    arp_op = buf[6]<<8 | buf[7];
 
    strncpy(&arp_sender_mac, &buf[8], 6);
    strncpy(&arp_sender_ip, &buf[14], 4);
 
    // 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 &&
        buf[24]==self_g.ip[0] &&
        buf[25]==self_g.ip[1] &&
        buf[26]==self_g.ip[2] &&
        buf[27]==self_g.ip[3]) {
 
        // ARP reply
        arp_reply(&arp_sender_mac, &arp_sender_ip);
        }
}
 
 
 
void parse_ip_packet(char * buf, packet_t* rx_packet)
{
    unsigned int ip_version;
 
    ip_version = buf[0]>>4;
    if (ip_version != 4) {
        print_serial("%s:L%d IP version %d not supported\n\r", __FILE__, __LINE__, 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);
}