/*
 * LPC 2000 Loader, http://www.pjrc.com/arm/lpc2k_pgm
 * Copyright (c) 2004, PJRC.COM, LLC, <paul@pjrc.com>
 *
 * This program is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License as published by the
 * Free Software Foundation; version 2 of the License.
 *
 * This program 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 General
 * Public License for more details.
 *
 * You should have received a copy of the GNU General Public License along
 * with this program; if not, write to the Free Software Foundation, Inc.,
 * 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
 */

/* If this code fails to build, please provide at least the following
 * information when requesting (free) technical support.
 *
 * 1: Complete copy of all messages during the build.
 * 2: Output of "gtk-config --version"
 * 3: Output of "gtk-config --libs"
 * 4: Output of "gtk-config --cflags"
 * 5: Output of "uname -a"
 * 6: Version of GTK installed... eg, type: ls -l /lib/libgtk*
 * 7: Other info... which linux distribution, version, other software
 */

#include <stdio.h>
#include <string.h>


// the maximum flash image size we can support
// chips with larger memory may be used, but only this
// much intel-hex data can be loaded into memory!
#define MAX_MEMORY_SIZE 0x80000


#include "ihex.h"


static unsigned char firmware_image[MAX_MEMORY_SIZE];
static unsigned char firmware_mask[MAX_MEMORY_SIZE];
static int end_record_seen = 0;
static int byte_count;
static unsigned int extended_addr = 0;


static int parse_hex_line(char *line);


/****************************************************************/
/*                              */
/*            Read Intel Hex File           */
/*                              */
/****************************************************************/



int read_intel_hex(const char *filename)
{
    FILE *fp;
    int i, lineno = 0;
    char buf[1024];

    byte_count = 0;
    end_record_seen = 0;

    for (i = 0; i < MAX_MEMORY_SIZE; i++) {
        firmware_image[i] = 0xFF;
        firmware_mask[i] = 0;
    }

    extended_addr = 0;

    fp = fopen(filename, "r");

    if (fp == NULL) {
        printf("Unable to read file %s\n", filename);
        return -1;
    }

    while (!feof(fp)) {
        *buf = '\0';
        fgets(buf, sizeof(buf), fp);
        lineno++;

        if (*buf) {
            if (parse_hex_line(buf) == 0) {
                printf("Warning, parse error line %d\n", lineno);
                fclose(fp);
                return -2;
            }
        }

        if (end_record_seen) {
            break;
        }

        if (feof(stdin)) {
            break;
        }
    }

    fclose(fp);
    return byte_count;
}


/* from ihex.c, at http://www.pjrc.com/tech/8051/pm2_docs/intel-hex.html */

/* parses a line of intel hex code, stores the data in bytes[] */
/* and the beginning address in addr, and returns a 1 if the */
/* line was valid, or a 0 if an error occured.  The variable */
/* num gets the number of bytes that were stored into bytes[] */


int
parse_hex_line(char *line)
{
    unsigned int addr, code, num;
    unsigned int sum, len, cksum, i;
    char *ptr;

    num = 0;

    if (line[0] != ':') {
        return 0;
    }

    if (strlen(line) < 11) {
        return 0;
    }

    ptr = line + 1;

    if (!sscanf(ptr, "%02x", &len)) {
        return 0;
    }

    ptr += 2;

    if (strlen(line) < (11 + (len * 2))) {
        return 0;
    }

    if (!sscanf(ptr, "%04x", &addr)) {
        return 0;
    }

    ptr += 4;

    /* printf("Line: length=%d Addr=%d\n", len, addr); */
    if (!sscanf(ptr, "%02x", &code)) {
        return 0;
    }

    if (addr + extended_addr + len >= MAX_MEMORY_SIZE) {
        return 0;
    }

    ptr += 2;
    sum = (len & 255) + ((addr >> 8) & 255) + (addr & 255) + (code & 255);

    if (code != 0) {
        if (code == 1) {
            end_record_seen = 1;
            return 1;
        }

        if (code == 2 && len == 2) {
            if (!sscanf(ptr, "%04x", &i)) {
                return 1;
            }

            ptr += 4;
            sum += ((i >> 8) & 255) + (i & 255);

            if (!sscanf(ptr, "%02x", &cksum)) {
                return 1;
            }

            if (((sum & 255) + (cksum & 255)) & 255) {
                return 1;
            }

            extended_addr = i << 4;
            //printf("ext addr = %05X\n", extended_addr);
        }

        if (code == 4 && len == 2) {
            if (!sscanf(ptr, "%04x", &i)) {
                return 1;
            }

            ptr += 4;
            sum += ((i >> 8) & 255) + (i & 255);

            if (!sscanf(ptr, "%02x", &cksum)) {
                return 1;
            }

            if (((sum & 255) + (cksum & 255)) & 255) {
                return 1;
            }

            extended_addr = i << 16;
            //printf("ext addr = %08X\n", extended_addr);
        }

        return 1;   // non-data line
    }

    byte_count += len;

    while (num != len) {
        if (sscanf(ptr, "%02x", &i) != 1) {
            return 0;
        }

        i &= 255;
        firmware_image[addr + extended_addr + num] = i;
        firmware_mask[addr + extended_addr + num] = 1;
        ptr += 2;
        sum += i;
        (num)++;

        if (num >= 256) {
            return 0;
        }
    }

    if (!sscanf(ptr, "%02x", &cksum)) {
        return 0;
    }

    if (((sum & 255) + (cksum & 255)) & 255) {
        return 0;    /* checksum error */
    }

    return 1;
}


int bytes_within_range(int begin, int end)
{
    int i;

    if (begin < 0 || begin >= MAX_MEMORY_SIZE ||
        end < 0 || end >= MAX_MEMORY_SIZE) {
        return 0;
    }

    for (i = begin; i <= end; i++) {
        if (firmware_mask[i]) {
            return 1;
        }
    }

    return 0;
}

void get_ihex_data(int addr, int len, unsigned char *bytes)
{
    int i;

    if (addr < 0 || len < 0 || addr + len >= MAX_MEMORY_SIZE) {
        for (i = 0; i < len; i++) {
            bytes[i] = 255;
        }

        return;
    }

    for (i = 0; i < len; i++) {
        if (firmware_mask[addr]) {
            bytes[i] = firmware_image[addr];
        }
        else {
            bytes[i] = 255;
        }

        addr++;
    }
}

void put_ihex_data(int addr, int len, const unsigned char *bytes)
{
    int i;

    if (addr < 0 || len < 0 || addr + len >= MAX_MEMORY_SIZE) {
        return;
    }

    for (i = 0; i < len; i++) {
        firmware_image[addr] = bytes[i];
        firmware_mask[addr] = 1;
        addr++;
    }
}