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

#include "tcp.h"

#include "tftp.h"

#include "elfsplitter.h"

block_t*    udp_file_g = NULL;

block_t*    udp_current_block_g = NULL;

time_t*     reboot_timer_g;

int         reboot_stage_g;

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;

    block->linux_boot = 0;

    return block;

}

void parse_tftp_packet(char * buf, packet_t* rx_packet, int tftp_len, unsigned int udp_src_port, unsigned int udp_dst_port)

{

    int mode_offset;

    int binary_mode;

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

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

    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", 7) == 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 init_tftp()

{

    reboot_timer_g = new_timer();

    reboot_stage_g = 0;

}

void process_tftp ()

{

    socket_t* socket;

    /* Check for newly downloaded tftp file. Add to all tx buffers */

    /* Has a file been uploaded via tftp ? */

    if (udp_file_g != NULL) {

        /* Notify telnet clients that file has been received */

        if (udp_file_g->ready) {

            udp_file_g->ready = 0;

            print_serial("Received file %s, %d bytes",

                udp_file_g->filename, udp_file_g->total_bytes);

            if (udp_file_g->linux_boot)

                print_serial(", linux image detected\r\n");

            else

                print_serial("\r\n");

            if (process_file() == 0) {

                /* Disconnect in 1 second */

                set_timer(reboot_timer_g, 1000);

                }

            else

                print_serial("Not an elf file\r\n");

            }

        }

    /* reboot timer expired */

    if (timer_expired(reboot_timer_g)) {

        /* First stage of reboot sequence is to nicely disconnect */

        if (reboot_stage_g == 0) {

            set_timer(reboot_timer_g, 1000);

            reboot_stage_g = 1;

            socket = first_socket_g;

            if (socket != NULL){

                for(;;){

                    socket->tcp_disconnect = 1;

                    if (socket->next!=NULL)

                        socket=socket->next;

                    else

                        break;

                    }

                }

            }

        else {

        /* Second stage of reboot sequence is to turn off ethmac and then jump to restart vector */

            close_link();

            reboot();

            }

        }

}

/* copy tftp file into a single contiguous buffer so

   if can be processed by elf splitter */

int process_file()

{

    block_t* block;

    char*    buf512;

    char*    tftp_file;

    char*    line;

    int      line_len;

    int      ret;

    tftp_file = malloc(udp_file_g->total_bytes);

    block = udp_file_g;

    buf512= tftp_file;

    while (block->next) {

        memcpy(buf512, block->buf512, block->bytes);

        buf512=&buf512[512];

        block=block->next;

        }

    memcpy(buf512, block->buf512, block->bytes);

    buf512=&buf512[512];

    return elfsplitter(tftp_file);

}

/* Disable interrupts

   Load new values into the interrupt vector memory space

   Jump to address 0

*/

void reboot()

{

   int i;

   /* Disable all interrupts */

   /* Disable ethmac_int interrupt */

   /* Disable timer 0 interrupt in interrupt controller */

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

   for(i=0;i<MEM_BUF_ENTRIES;i++)

       if (elf_mem0_g->entry[i].valid)

           *(char *)(i) = elf_mem0_g->entry[i].data;

   if (udp_file_g->linux_boot) {

        print_serial("linux reboot\n\r");

        _jump_to_program(LINUX_JUMP_ADR);

        }

   else {

        print_serial("normal reboot\n\r");

        _restart();

        }

}