Subversion Repositories xenie

/***************************************************************************

 *

 * (C) Copyright 2017 DFC Design, s.r.o., Brno, Czech Republic

 * Author: Marek Kvas (m.kvas@dspfpga.com)

 *

 ***************************************************************************

 *

 * This file is part of Xenia Ethernet Example project.

 *

 * Xenia Ethernet Example project 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 3 of the License, or

 * (at your option) any later version.

 *

 * Xenia Ethernet Example project 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 Xenia Ethernet Example project.  If not,

 * see <http://www.gnu.org/licenses/>.

 *

 ***************************************************************************

 */

#include <stdio.h>

#include <stdlib.h>

#include "uprintf.h"

#include "fw.h"

/* Min/max defs */

#define MIN(A, B) (((A) > (B))?(B):(A))

#define MAX(A, B) (((A) > (B))?(A):(B))

/*

 * Free dynamically allocated fw_hdr_ext

 * structure.

 *

 * Function always succeeds.

 */

void fw_free_hdr_ext_ptr(struct fw_hdr_ext **s)

{

        if(*s == NULL)

                return;

        if((*s)->fw_meta_ptr != NULL)

                free((*s)->fw_meta_ptr);

        if((*s)->fw_data_ptr != NULL)

                free((*s)->fw_data_ptr);

        free(*s);

        *s = NULL;

}

/*

 * Check for presence of FW in flash and

 * dynamically allocate structure describing it.

 * FW is recognized by magic on the beginning of

 * header.

 *

 * On success, zero is returned. On error,

 * negative number is returned.

 */

int fw_find_in_flash(struct spansion_flash *sf, uint32_t fw_hdr_flash_offset, struct fw_hdr_ext **fw_hdr_ext_ptr)

{

        int i;

        int res;

        int ret = 0;

        uint8_t rd_buf[SPANSION_FLASH_PAGE_SIZE + SPANSION_FLASH_BUF_OVERHEAD +1];

        struct fw_hdr_ext *fhe;

        uint8_t *dst;

        int byte_count;

        uint32_t flash_addr;

        /* Allocate space for structure */

        fhe = malloc(sizeof(*fhe));

        if(fhe == NULL) {

                ret = -1; goto err;

        }

        fhe->fw_hdr_flash_off = fw_hdr_flash_offset;

        /* Read FW header */

        res = spansion_flash_quad_io_read(sf, fhe->fw_hdr_flash_off,

                        rd_buf, sizeof(fhe->fw_hdr));

        if(res != XST_SUCCESS) {

                ret = -3; goto err;

        }

        /* Copy header from buffer */

        memcpy(&fhe->fw_hdr, rd_buf+SPANSION_FLASH_BUF_OVERHEAD, sizeof(fhe->fw_hdr)); /* be careful about offset */

        /* Check magic */

        if(strncmp("MVFW", fhe->fw_hdr.magic, 4)) {

                ret = -4; goto err;

        }

        /* Read metadata from header (allocate memory for it)*/

        i = fhe->fw_hdr.fw_offset - sizeof(struct fw_hdr);

        fhe->fw_meta_ptr = malloc(i + 1);

        if(fhe->fw_meta_ptr == NULL) {

                ret = -5; goto err;

        }

        dst = fhe->fw_meta_ptr;

        flash_addr = fhe->fw_hdr_flash_off;

        while (i > 0) {

                byte_count = MIN(i, SPANSION_FLASH_PAGE_SIZE);

                res = spansion_flash_quad_io_read(sf, flash_addr, rd_buf, byte_count);

                if(res != XST_SUCCESS) {

                        ret = -6; goto err;

                }

                memcpy(dst, rd_buf + SPANSION_FLASH_BUF_OVERHEAD, byte_count);

                dst += byte_count;

                flash_addr += byte_count;

                i-= byte_count;

        }

        *dst = '\0';

        *fw_hdr_ext_ptr = fhe;

        return ret;

err:

        fw_free_hdr_ext_ptr(&fhe);

        return ret;

}

void fw_print_info(struct fw_hdr_ext *fhe)

{

        uprintf("FW header at: 0x%08x\r\n", fhe->fw_hdr_flash_off);

        uprintf("FW at: 0x%08x (offset 0x%08x)\r\n", fhe->fw_hdr_flash_off + fhe->fw_hdr.fw_offset,

                        fhe->fw_hdr.fw_offset);

        uprintf("FW length: %u B\r\n", fhe->fw_hdr.fw_length);

}

/*

 * Read FW described by fw_hdr_ext_ptr.

 * Buffer for FW is dynamically allocated.

 *

 * On success, zero is returned. On error,

 * negative number is returned.

 */

int fw_read_from_flash(struct spansion_flash *sf, struct fw_hdr_ext *fw_hdr_ext_ptr)

{

        int i;

        int res;

        uint8_t rd_buf[SPANSION_FLASH_PAGE_SIZE + SPANSION_FLASH_BUF_OVERHEAD +1];

        u8 *dst;

        int byte_count;

        uint32_t flash_addr;

        /* Allocate memory for buffer */

        fw_hdr_ext_ptr->fw_data_ptr = malloc(fw_hdr_ext_ptr->fw_hdr.fw_length);

        if(fw_hdr_ext_ptr->fw_data_ptr == NULL)

                return -1;

        /* Read whole fw */

        i = fw_hdr_ext_ptr->fw_hdr.fw_length;

        dst = fw_hdr_ext_ptr->fw_data_ptr;

        flash_addr = fw_hdr_ext_ptr->fw_hdr_flash_off + fw_hdr_ext_ptr->fw_hdr.fw_offset;

        byte_count = 0;

        while (i > 0) {

                byte_count = MIN(i, SPANSION_FLASH_PAGE_SIZE);

                res = spansion_flash_quad_io_read(sf, flash_addr, rd_buf, byte_count);

                if(res != XST_SUCCESS) {

                        return -2;

                }

                memcpy(dst, rd_buf + SPANSION_FLASH_BUF_OVERHEAD, byte_count);

                dst += byte_count;

                flash_addr += byte_count;

                i-= byte_count;

        }

        return 0;

}