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 "address_map.h"

#include "line-buffer.h"

#include "timer.h"

#include "utilities.h"

#include "packet.h"

#include "udp.h"

int         udp_checksum_errors_g = 0;

block_t*    udp_file_g = NULL;

block_t*    udp_current_block_g = NULL;

void parse_udp_packet(char * buf, packet_t* rx_packet)

{

    unsigned int udp_src_port    = buf[0]<<8|buf[1];

    unsigned int udp_dst_port    = buf[2]<<8|buf[3];

    unsigned int udp_len         = buf[4]<<8|buf[5];

    unsigned short prot_udp=17;

    unsigned short word16;

    unsigned long  sum = 0;

    unsigned int   checksum;

    int mode_offset;

    int binary_mode;

    int i;

    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_udp + udp_len;

    checksum = header_checksum16(buf, udp_len, sum);

    if (checksum)

        udp_checksum_errors_g++;

     /* TFTP */

    if (udp_dst_port == 69 && !checksum) {

        unsigned int opcode = buf[8]<<8|buf[9];

        unsigned int block  = buf[10]<<8|buf[11];

        int tftp_len = udp_len - 12;

        mode_offset = next_string(&buf[10]);

        binary_mode = strcmp("octet", &buf[10+mode_offset]);

        switch (opcode) {

            case  UDP_READ:

                udp_reply(rx_packet, udp_dst_port, udp_src_port, 0, UDP_ERROR);

                break;

            case  UDP_WRITE:

                udp_file_g = init_buffer_512();

                udp_file_g->filename = malloc(256);

                strcpy(udp_file_g->filename, &buf[10]);

                if (strncmp(&buf[10], "vmlinux") == 0)

                    udp_file_g->linux_boot == 1;

                udp_current_block_g = udp_file_g;

                if (binary_mode)

                    udp_reply(rx_packet, udp_dst_port, udp_src_port, 0, UDP_ACK);

                else

                    udp_reply(rx_packet, udp_dst_port, udp_src_port, 0, UDP_ERROR);

                break;

            case  UDP_DATA:

                udp_reply(rx_packet, udp_dst_port, udp_src_port, block, UDP_ACK);

                if (block > udp_file_g->last_block) {

                    // Have not already received this block

                    udp_file_g->last_block = block;

                    /* receive and save a block */

                    udp_current_block_g->bytes = tftp_len;

                    udp_file_g->total_bytes += tftp_len;

                    udp_file_g->total_blocks++;

                    memcpy(udp_current_block_g->buf512, &buf[12], tftp_len);

                    /* Prepare the next block */

                    if (tftp_len == 512) {

                        udp_current_block_g->next = init_buffer_512();

                        udp_current_block_g = udp_current_block_g->next;

                        }

                    else { /* Last block */

                        udp_file_g->ready = 1;

                        }

                    }

                break;

            default: break;

            }

        }

}

void udp_reply(packet_t* rx_packet, int udp_src_port, int udp_dst_port, int block, int reply_type)

{

    char* buf = (char*)ETHMAC_TX_BUFFER;

    unsigned short checksum;

    unsigned short prot_udp=17;

    unsigned short udp_len;

    unsigned short word16;

    unsigned long  sum = 0;

    int i;

    mac_ip_t target;

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

    /* udp header */

    buf[34] = (udp_src_port & 0xff00)>>8;

    buf[35] =  udp_src_port & 0xff;

    buf[36] = (udp_dst_port & 0xff00)>>8;

    buf[37] =  udp_dst_port & 0xff;

    if (reply_type == UDP_ACK)

        udp_len = 8+4;

    else /* error */

        udp_len = 8+2+2+14;

    buf[38] = (udp_len      & 0xff00)>>8;

    buf[39] =  udp_len      & 0xff;

    buf[40] = 0;  // checksum

    buf[41] = 0;  // checksum

    // -------------------------------------

    // tftf payload 

    // -------------------------------------

    // Opcode

    buf[42] = 0;

    buf[43] = reply_type & 0xff;  // Acknowledgment    

    if (reply_type == UDP_ACK) {

        // block

        buf[44] = (block & 0xff00)>>8;

        buf[45] =  block & 0xff;

        }

    else {/* error */

        // Error Code

        buf[44] = 0;

        buf[45] = 0;

        // 46 to 59

        strncpy(&buf[46], "Not supported", 14);

        }

    // -------------------------------------

    // UDP Checksum calculation

    // -------------------------------------

    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_udp + udp_len;

    checksum = header_checksum16(&buf[34], udp_len, sum);

    buf[40] = (checksum & 0xff00)>>8;  // checksum

    buf[41] =  checksum & 0xff;        // checksum

    ip_header(&buf[14], &target, 20+udp_len, 17); /* 20 byes of tcp  options, bytes 14 to 33, ip_proto = 17, UDP */

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

    tx_packet(34+udp_len);  // packet length in bytes

}

block_t* init_buffer_512()

{

    block_t* block = malloc(sizeof(block_t));

    block->buf512 = malloc(512);

    block->next   = NULL;

    block->bytes  = 0;

    block->last_block  = 0;

    block->total_bytes  = 0;

    block->total_blocks  = 0;

    block->ready  = 0;

    block->filename  = NULL;

    return block;

}