URL https://opencores.org/ocsvn/s6soc/s6soc/trunk

Subversion Repositories s6soc

[/] [s6soc/] [trunk/] [sw/] [host/] [zipload.cpp] - Blame information for rev 26

Go to most recent revision | Details | Compare with Previous | View Log


////////////////////////////////////////////////////////////////////////////////
//
// Filename:    zipload.cpp
//
// Project:     CMod S6 System on a Chip, ZipCPU demonstration project
//
// Purpose:     To load the flash--both a the two configurations and the 
//              a program for the ZipCPU into (flash) memory.
//
//      Steps:
//              1. Reboot the CMod into the alternate/debug/command mode
//              2. Load flash memory
//              3. Reload (reboot) the CMod configuration into ZipCPU mode
//              4. Program should start on its own.
//
// Creator:     Dan Gisselquist, Ph.D.
//              Gisselquist Technology, LLC
//
////////////////////////////////////////////////////////////////////////////////
//
// Copyright (C) 2015-2016, Gisselquist Technology, LLC
//
// This program is free software (firmware): you can redistribute it and/or
// modify it under the terms of  the GNU General Public License as published
// by the Free Software Foundation, either version 3 of the License, or (at
// your option) any later version.
//
// This program is distributed in the hope that it will be useful, but WITHOUT
// ANY WARRANTY; without even the implied warranty of MERCHANTIBILITY or
// FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
// for more details.
//
// License:     GPL, v3, as defined and found on www.gnu.org,
//              http://www.gnu.org/licenses/gpl.html
//
//
////////////////////////////////////////////////////////////////////////////////
//
//
//
#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <strings.h>
#include <ctype.h>
#include <string.h>
#include <signal.h>
#include <assert.h>
 
#include "devbus.h"
#include "llcomms.h"
#include "deppi.h"
#include "regdefs.h"
#include "flashdrvr.h"
 
bool    iself(const char *fname) {
        FILE    *fp;
        bool    ret = true;
 
        if ((!fname)||(!fname[0]))
                return false;
 
        fp = fopen(fname, "rb");
 
        if (!fp)        return false;
        if (0x7f != fgetc(fp))  ret = false;
        if ('E'  != fgetc(fp))  ret = false;
        if ('L'  != fgetc(fp))  ret = false;
        if ('F'  != fgetc(fp))  ret = false;
        fclose(fp);
        return  ret;
}
 
long    fgetwords(FILE *fp) {
        // Return the number of words in the current file, and return the 
        // file as though it had never been adjusted
        long    fpos, flen;
        fpos = ftell(fp);
        if (0 != fseek(fp, 0l, SEEK_END)) {
                fprintf(stderr, "ERR: Could not determine file size\n");
                perror("O/S Err:");
                exit(-2);
        } flen = ftell(fp);
        if (0 != fseek(fp, fpos, SEEK_SET)) {
                fprintf(stderr, "ERR: Could not seek on file\n");
                perror("O/S Err:");
                exit(-2);
        } flen /= sizeof(FPGA::BUSW);
        return flen;
}
 
FPGA    *m_fpga;
class   SECTION {
public:
        unsigned        m_start, m_len;
        FPGA::BUSW      m_data[1];
};
 
SECTION **singlesection(int nwords) {
        fprintf(stderr, "NWORDS = %d\n", nwords);
        size_t  sz = (2*(sizeof(SECTION)+sizeof(SECTION *))
                +(nwords-1)*(sizeof(FPGA::BUSW)));
        char    *d = (char *)malloc(sz);
        SECTION **r = (SECTION **)d;
        memset(r, 0, sz);
        r[0] = (SECTION *)(&d[2*sizeof(SECTION *)]);
        r[0]->m_len   = nwords;
        r[1] = (SECTION *)(&r[0]->m_data[r[0]->m_len]);
        r[0]->m_start = 0;
        r[1]->m_start = 0;
        r[1]->m_len   = 0;
 
        return r;
}
 
SECTION **rawsection(const char *fname) {
        SECTION         **secpp, *secp;
        unsigned        num_words;
        FILE            *fp;
        int             nr;
 
        fp = fopen(fname, "r");
        if (fp == NULL) {
                fprintf(stderr, "Could not open: %s\n", fname);
                exit(-1);
        }
 
        if ((num_words=fgetwords(fp)) > FLASHWORDS-(RESET_ADDRESS-SPIFLASH)) {
                fprintf(stderr, "File overruns flash memory\n");
                exit(-1);
        }
        secpp = singlesection(num_words);
        secp = secpp[0];
        secp->m_start = RAMBASE;
        secp->m_len = num_words;
        nr= fread(secp->m_data, sizeof(FPGA::BUSW), num_words, fp);
        if (nr != (int)num_words) {
                fprintf(stderr, "Could not read entire file\n");
                perror("O/S Err:");
                exit(-2);
        } assert(secpp[1]->m_len == 0);
 
        return secpp;
}
 
unsigned        byteswap(unsigned n) {
        unsigned        r;
 
        r = (n&0x0ff); n>>= 8;
        r = (r<<8) | (n&0x0ff); n>>= 8;
        r = (r<<8) | (n&0x0ff); n>>= 8;
        r = (r<<8) | (n&0x0ff); n>>= 8;
 
        return r;
}
 
// #define      CHEAP_AND_EASY
#ifdef  CHEAP_AND_EASY
#else
#include <libelf.h>
#include <gelf.h>
 
void    elfread(const char *fname, unsigned &entry, SECTION **&sections) {
        Elf     *e;
        int     fd, i;
        size_t  n;
        char    *id;
        Elf_Kind        ek;
        GElf_Ehdr       ehdr;
        GElf_Phdr       phdr;
        const   bool    dbg = false;
 
        if (elf_version(EV_CURRENT) == EV_NONE) {
                fprintf(stderr, "ELF library initialization err, %s\n", elf_errmsg(-1));
                perror("O/S Err:");
                exit(EXIT_FAILURE);
        } if ((fd = open(fname, O_RDONLY, 0)) < 0) {
                fprintf(stderr, "Could not open %s\n", fname);
                perror("O/S Err:");
                exit(EXIT_FAILURE);
        } if ((e = elf_begin(fd, ELF_C_READ, NULL))==NULL) {
                fprintf(stderr, "Could not run elf_begin, %s\n", elf_errmsg(-1));
                exit(EXIT_FAILURE);
        }
 
        ek = elf_kind(e);
        if (ek == ELF_K_ELF) {
                ; // This is the kind of file we should expect
        } else if (ek == ELF_K_AR) {
                fprintf(stderr, "Cannot run an archive!\n");
                exit(EXIT_FAILURE);
        } else if (ek == ELF_K_NONE) {
                ;
        } else {
                fprintf(stderr, "Unexpected ELF file kind!\n");
                exit(EXIT_FAILURE);
        }
 
        if (gelf_getehdr(e, &ehdr) == NULL) {
                fprintf(stderr, "getehdr() failed: %s\n", elf_errmsg(-1));
                exit(EXIT_FAILURE);
        } if ((i=gelf_getclass(e)) == ELFCLASSNONE) {
                fprintf(stderr, "getclass() failed: %s\n", elf_errmsg(-1));
                exit(EXIT_FAILURE);
        } if ((id = elf_getident(e, NULL)) == NULL) {
                fprintf(stderr, "getident() failed: %s\n", elf_errmsg(-1));
                exit(EXIT_FAILURE);
        } if (i != ELFCLASS32) {
                fprintf(stderr, "This is a 64-bit ELF file, ZipCPU ELF files are all 32-bit\n");
                exit(EXIT_FAILURE);
        }
 
        if (dbg) {
        printf("    %-20s 0x%jx\n", "e_type", (uintmax_t)ehdr.e_type);
        printf("    %-20s 0x%jx\n", "e_machine", (uintmax_t)ehdr.e_machine);
        printf("    %-20s 0x%jx\n", "e_version", (uintmax_t)ehdr.e_version);
        printf("    %-20s 0x%jx\n", "e_entry", (uintmax_t)ehdr.e_entry);
        printf("    %-20s 0x%jx\n", "e_phoff", (uintmax_t)ehdr.e_phoff);
        printf("    %-20s 0x%jx\n", "e_shoff", (uintmax_t)ehdr.e_shoff);
        printf("    %-20s 0x%jx\n", "e_flags", (uintmax_t)ehdr.e_flags);
        printf("    %-20s 0x%jx\n", "e_ehsize", (uintmax_t)ehdr.e_ehsize);
        printf("    %-20s 0x%jx\n", "e_phentsize", (uintmax_t)ehdr.e_phentsize);
        printf("    %-20s 0x%jx\n", "e_shentsize", (uintmax_t)ehdr.e_shentsize);
        printf("\n");
        }
 
 
        // Check whether or not this is an ELF file for the ZipCPU ...
        if (ehdr.e_machine != 0x0dadd) {
                fprintf(stderr, "This is not a ZipCPU ELF file\n");
                exit(EXIT_FAILURE);
        }
 
        // Get our entry address
        entry = ehdr.e_entry;
 
 
        // Now, let's go look at the program header
        if (elf_getphdrnum(e, &n) != 0) {
                fprintf(stderr, "elf_getphdrnum() failed: %s\n", elf_errmsg(-1));
                exit(EXIT_FAILURE);
        }
 
        unsigned total_octets = 0, current_offset=0, current_section=0;
        for(i=0; i<(int)n; i++) {
                total_octets += sizeof(SECTION *)+sizeof(SECTION);
 
                if (gelf_getphdr(e, i, &phdr) != &phdr) {
                        fprintf(stderr, "getphdr() failed: %s\n", elf_errmsg(-1));
                        exit(EXIT_FAILURE);
                }
 
                if (dbg) {
                printf("    %-20s 0x%x\n", "p_type",   phdr.p_type);
                printf("    %-20s 0x%jx\n", "p_offset", phdr.p_offset);
                printf("    %-20s 0x%jx\n", "p_vaddr",  phdr.p_vaddr);
                printf("    %-20s 0x%jx\n", "p_paddr",  phdr.p_paddr);
                printf("    %-20s 0x%jx\n", "p_filesz", phdr.p_filesz);
                printf("    %-20s 0x%jx\n", "p_memsz",  phdr.p_memsz);
                printf("    %-20s 0x%x [", "p_flags",  phdr.p_flags);
 
                if (phdr.p_flags & PF_X)        printf(" Execute");
                if (phdr.p_flags & PF_R)        printf(" Read");
                if (phdr.p_flags & PF_W)        printf(" Write");
                printf("]\n");
                printf("    %-20s 0x%jx\n", "p_align", phdr.p_align);
                }
 
                total_octets += phdr.p_memsz;
        }
 
        char    *d = (char *)malloc(total_octets + sizeof(SECTION)+sizeof(SECTION *));
        memset(d, 0, total_octets);
 
        SECTION **r = sections = (SECTION **)d;
        current_offset = (n+1)*sizeof(SECTION *);
        current_section = 0;
 
        for(i=0; i<(int)n; i++) {
                r[i] = (SECTION *)(&d[current_offset]);
 
                if (gelf_getphdr(e, i, &phdr) != &phdr) {
                        fprintf(stderr, "getphdr() failed: %s\n", elf_errmsg(-1));
                        exit(EXIT_FAILURE);
                }
 
                if (dbg) {
                printf("    %-20s 0x%jx\n", "p_offset", phdr.p_offset);
                printf("    %-20s 0x%jx\n", "p_vaddr",  phdr.p_vaddr);
                printf("    %-20s 0x%jx\n", "p_paddr",  phdr.p_paddr);
                printf("    %-20s 0x%jx\n", "p_filesz", phdr.p_filesz);
                printf("    %-20s 0x%jx\n", "p_memsz",  phdr.p_memsz);
                printf("    %-20s 0x%x [", "p_flags",  phdr.p_flags);
 
                if (phdr.p_flags & PF_X)        printf(" Execute");
                if (phdr.p_flags & PF_R)        printf(" Read");
                if (phdr.p_flags & PF_W)        printf(" Write");
                printf("]\n");
 
                printf("    %-20s 0x%jx\n", "p_align", phdr.p_align);
                }
 
                current_section++;
 
                r[i]->m_start = phdr.p_paddr;
                r[i]->m_len   = phdr.p_filesz/ sizeof(FPGA::BUSW);
 
                current_offset += phdr.p_memsz + sizeof(SECTION);
 
                // Now, let's read in our section ...
                if (lseek(fd, phdr.p_offset, SEEK_SET) < 0) {
                        fprintf(stderr, "Could not seek to file position %08lx\n", phdr.p_offset);
                        perror("O/S Err:");
                        exit(EXIT_FAILURE);
                } if (phdr.p_filesz > phdr.p_memsz)
                        phdr.p_filesz = 0;
                if (read(fd, r[i]->m_data, phdr.p_filesz) != (int)phdr.p_filesz) {
                        fprintf(stderr, "Didnt read entire section\n");
                        perror("O/S Err:");
                        exit(EXIT_FAILURE);
                }
 
                // Next, we need to byte swap it from big to little endian
                for(unsigned j=0; j<r[i]->m_len; j++)
                        r[i]->m_data[j] = byteswap(r[i]->m_data[j]);
 
                if (dbg) for(unsigned j=0; j<r[i]->m_len; j++)
                        fprintf(stderr, "ADR[%04x] = %08x\n", r[i]->m_start+j,
                        r[i]->m_data[j]);
        }
 
        r[i] = (SECTION *)(&d[current_offset]);
        r[current_section]->m_start = 0;
        r[current_section]->m_len   = 0;
 
        elf_end(e);
        close(fd);
}
#endif
 
void    usage(void) {
        printf("USAGE: ziprun [-h] [<bit-file> [<alt-bit-file>]] <zip-program-file>\n");
        printf("\n"
"\t-h\tDisplay this usage statement\n");
}
 
int main(int argc, char **argv) {
        int             skp=0;
        bool            permit_raw_files = false, debug_only = false;
        unsigned        entry = RAMBASE;
        FLASHDRVR       *flash = NULL;
        const char      *bitfile = NULL, *altbitfile = NULL;
 
        if (argc < 2) {
                usage();
                exit(EXIT_SUCCESS);
        }
 
        skp=1;
        for(int argn=0; argn<argc-skp; argn++) {
                if (argv[argn+skp][0] == '-') {
                        switch(argv[argn+skp][1]) {
                        case 'd':
                                debug_only = true;
                                break;
                        case 'h':
                                usage();
                                exit(EXIT_SUCCESS);
                                break;
                        case 'r':
                                permit_raw_files = true;
                                break;
                        default:
                                fprintf(stderr, "Unknown option, -%c\n\n",
                                        argv[argn+skp][0]);
                                usage();
                                exit(EXIT_FAILURE);
                                break;
                        } skp++; argn--;
                } else { // Check for bit files
                        int sl = strlen(argv[argn+skp]);
                        if ((sl>4)&&(strcmp(&argv[argn+skp][sl-4],".bit")==0)) {
                                if (bitfile == NULL)
                                        bitfile = argv[argn+skp];
                                else if (altbitfile == NULL)
                                        altbitfile = argv[argn+skp];
                                else {
                                        fprintf(stderr, "Err: Too many bit files listed\n");
                                        exit(EXIT_FAILURE);
                                } skp++; argn--;
                        } else
                                argv[argn] = argv[argn+skp];
                }
        } argc -= skp;
 
 
        if ((bitfile)&&(access(bitfile,R_OK)!=0)) {
                fprintf(stderr, "Cannot open bitfile, %s\n", bitfile);
                exit(EXIT_FAILURE);
        } if ((altbitfile)&&(access(altbitfile,R_OK)!=0)) {
                fprintf(stderr, "Cannot open alternate bitfile, %s\n",
                        altbitfile);
                exit(EXIT_FAILURE);
        } if(((!bitfile)&&(argc<=0)) || ((argc>0)&&(access(argv[0],R_OK)!=0))) {
                // If there's no code file, or the code file cannot be opened
                if (argc>0)
                        fprintf(stderr, "Cannot open executable, %s\n", argv[0]);
                else
                        usage();
                exit(EXIT_FAILURE);
        }
 
        const char *codef = (argc>0)?argv[0]:NULL;
        DEVBUS::BUSW    *fbuf = new DEVBUS::BUSW[FLASHWORDS];
 
        // Set the flash buffer to all ones
        memset(fbuf, -1, FLASHWORDS*sizeof(fbuf[0]));
 
        if (debug_only) {
                m_fpga = NULL;
        } else {
                char    szSel[64];
                strcpy(szSel, "SN:210282768825");
                m_fpga = new FPGA(new DEPPI(szSel));
        }
 
        flash = (debug_only)?NULL : new FLASHDRVR(m_fpga);
 
        // First, see if we need to load a bit file
        if (bitfile) {
                int     len;
                FILE    *fp = fopen(bitfile, "rb");
 
                fseek(fp, 0x5dl, SEEK_SET);
                len = fread(&fbuf[CONFIG_ADDRESS-SPIFLASH],
                                sizeof(fbuf[0]),
                                FLASHWORDS-(CONFIG_ADDRESS-SPIFLASH), fp);
                assert(len + CONFIG_ADDRESS < ALTCONFIG_ADDRESS);
                fclose(fp);
 
                for(int i=0; i<4; i++) {
                        // printf("0x%08x\n", fbuf[i]);
                        assert(fbuf[i] == 0x0ffffffff);
                } // printf("0x%08x\n", fbuf[4]);
                assert(fbuf[4] == 0x0665599aa);
 
                printf("Loading: %s\n", bitfile);
                if ((flash)&&(!flash->write(CONFIG_ADDRESS, len, &fbuf[CONFIG_ADDRESS-SPIFLASH], true))) {
                        fprintf(stderr, "Could not write primary bitfile\n");
                        exit(EXIT_FAILURE);
                }
        } if (altbitfile) {
                int     len;
                FILE    *fp = fopen(altbitfile, "rb");
 
                // The alternate configuration follows the first configuration
                len = fread(&fbuf[ALTCONFIG_ADDRESS-SPIFLASH],
                                sizeof(fbuf[0]),
                                FLASHWORDS-(ALTCONFIG_ADDRESS-SPIFLASH), fp);
                assert(len + ALTCONFIG_ADDRESS < RESET_ADDRESS);
                fclose(fp);
                printf("Loading: %s\n", altbitfile);
 
                if ((flash)&&(!flash->write(ALTCONFIG_ADDRESS, len, &fbuf[ALTCONFIG_ADDRESS-SPIFLASH], true))) {
                        fprintf(stderr, "Could not write alternate bitfile\n");
                        exit(EXIT_FAILURE);
                }
        }
 
        if (codef) try {
                SECTION **secpp = NULL, *secp;
 
                if(iself(codef)) {
                        // zip-readelf will help with both of these ...
                        elfread(codef, entry, secpp);
                        assert(entry == RESET_ADDRESS);
                } else if (permit_raw_files) {
                        secpp = rawsection(codef);
                        entry = RESET_ADDRESS;
                } else {
                        fprintf(stderr, "ERR: %s is not in ELF format\n", codef);
                        exit(EXIT_FAILURE);
                }
 
                printf("Loading: %s\n", codef);
                // assert(secpp[1]->m_len = 0);
                for(int i=0; secpp[i]->m_len; i++) {
                        bool    valid = false;
                        secp=  secpp[i];
                        if ((secp->m_start >= RESET_ADDRESS)
                                &&(secp->m_start+secp->m_len
                                                <= SPIFLASH+FLASHWORDS))
                                valid = true;
                        if ((secp->m_start >= RAMBASE)
                                &&(secp->m_start+secp->m_len
                                                <= RAMBASE+MEMWORDS))
                                valid = true;
                        if (!valid) {
                                fprintf(stderr, "No such memory on board: 0x%08x - %08x\n",
                                        secp->m_start, secp->m_start+secp->m_len);
                                exit(EXIT_FAILURE);
                        }
                }
 
                unsigned        startaddr = RESET_ADDRESS, codelen = 0;
                for(int i=0; secpp[i]->m_len; i++) {
                        secp = secpp[i];
                        if ((secp->m_start >= RAMBASE)
                                &&(secp->m_start+secp->m_len
                                                <= RAMBASE+MEMWORDS)) {
                                for(int i=0; (unsigned)i<secp->m_len; i++) {
                                        if (secp->m_data[i] != 0) {
                                                fprintf(stderr, "ERR: Cannot set RAM upon bootup!\n");
                                                fprintf(stderr, "(The bootloaders just not that smart ... yet)\n");
                                                fprintf(stderr, "Attempting to set %08x - %08x\n", secp->m_start, secp->m_start+secp->m_len-1);
                                                fprintf(stderr, "%08x cannot be set to %08x\n", secp->m_start+i, secp->m_data[i]);
                                                exit(EXIT_FAILURE);
                                        }
                                }
                        } else {
                                if (secp->m_start < startaddr) {
                                        codelen += (startaddr-secp->m_start);
                                        startaddr = secp->m_start;
                                } if (secp->m_start+secp->m_len > startaddr+codelen) {
                                        codelen = secp->m_start+secp->m_len-startaddr;
                                } memcpy(&fbuf[secp->m_start-SPIFLASH],
                                        secp->m_data,
                                        secp->m_len*sizeof(FPGA::BUSW));
                        }
                }
                if ((flash)&&(!flash->write(startaddr, codelen, &fbuf[startaddr-SPIFLASH], true))) {
                        fprintf(stderr, "ERR: Could not write program to flash\n");
                        exit(EXIT_FAILURE);
                } else if (!flash)
                        printf("flash->write(%08x, %d, ... );\n", startaddr,
                                codelen);
                if (m_fpga) m_fpga->readio(R_VERSION); // Check for bus errors
 
                // Now ... how shall we start this CPU?
                printf("The CPU should be fully loaded, you may now start\n");
                printf("it.  To start the CPU, either toggle power or type\n");
                printf("%% wbregs fpgagen1 0 \n");
                printf("%% wbregs fpgagen2 0x0300 \n");
                printf("%% wbregs fpgacmd  14 \n");
        } catch(BUSERR a) {
                fprintf(stderr, "XULA-BUS error: %08x\n", a.addr);
                exit(-2);
        }
 
        if (m_fpga) delete      m_fpga;
 
        return EXIT_SUCCESS;
}
 

Browse

Tools

Subversion Repositories s6soc

[/] [s6soc/] [trunk/] [sw/] [host/] [zipload.cpp] - Blame information for rev 26

Line No.	Rev	Author	Line
1	11	dgisselq	`////////////////////////////////////////////////////////////////////////////////`
2			`//`
3			`// Filename: zipload.cpp`
4			`//`
5			`// Project: CMod S6 System on a Chip, ZipCPU demonstration project`
6			`//`
7			`// Purpose: To load the flash--both a the two configurations and the`
8			`// a program for the ZipCPU into (flash) memory.`
9			`//`
10			`// Steps:`
11			`// 1. Reboot the CMod into the alternate/debug/command mode`
12			`// 2. Load flash memory`
13			`// 3. Reload (reboot) the CMod configuration into ZipCPU mode`
14			`// 4. Program should start on its own.`
15			`//`
16			`// Creator: Dan Gisselquist, Ph.D.`
17			`// Gisselquist Technology, LLC`
18			`//`
19			`////////////////////////////////////////////////////////////////////////////////`
20			`//`
21			`// Copyright (C) 2015-2016, Gisselquist Technology, LLC`
22			`//`
23			`// This program is free software (firmware): you can redistribute it and/or`
24			`// modify it under the terms of the GNU General Public License as published`
25			`// by the Free Software Foundation, either version 3 of the License, or (at`
26			`// your option) any later version.`
27			`//`
28			`// This program is distributed in the hope that it will be useful, but WITHOUT`
29			`// ANY WARRANTY; without even the implied warranty of MERCHANTIBILITY or`
30			`// FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License`
31			`// for more details.`
32			`//`
33			`// License: GPL, v3, as defined and found on www.gnu.org,`
34			`// http://www.gnu.org/licenses/gpl.html`
35			`//`
36			`//`
37			`////////////////////////////////////////////////////////////////////////////////`
38			`//`
39			`//`
40			`//`
41			`#include <stdio.h>`
42			`#include <stdlib.h>`
43			`#include <sys/types.h>`
44			`#include <sys/stat.h>`
45			`#include <fcntl.h>`
46			`#include <unistd.h>`
47			`#include <strings.h>`
48			`#include <ctype.h>`
49			`#include <string.h>`
50			`#include <signal.h>`
51			`#include <assert.h>`
52
53			`#include "devbus.h"`
54			`#include "llcomms.h"`
55			`#include "deppi.h"`
56			`#include "regdefs.h"`
57			`#include "flashdrvr.h"`
58
59			`bool iself(const char *fname) {`
60			`FILE *fp;`
61			`bool ret = true;`
62
63			`if ((!fname)\|\|(!fname[0]))`
64			`return false;`
65
66			`fp = fopen(fname, "rb");`
67
68			`if (!fp) return false;`
69			`if (0x7f != fgetc(fp)) ret = false;`
70			`if ('E' != fgetc(fp)) ret = false;`
71			`if ('L' != fgetc(fp)) ret = false;`
72			`if ('F' != fgetc(fp)) ret = false;`
73			`fclose(fp);`
74			`return ret;`
75			`}`
76
77			`long fgetwords(FILE *fp) {`
78			`// Return the number of words in the current file, and return the`
79			`// file as though it had never been adjusted`
80			`long fpos, flen;`
81			`fpos = ftell(fp);`
82			`if (0 != fseek(fp, 0l, SEEK_END)) {`
83			`fprintf(stderr, "ERR: Could not determine file size\n");`
84			`perror("O/S Err:");`
85			`exit(-2);`
86			`} flen = ftell(fp);`
87			`if (0 != fseek(fp, fpos, SEEK_SET)) {`
88			`fprintf(stderr, "ERR: Could not seek on file\n");`
89			`perror("O/S Err:");`
90			`exit(-2);`
91			`} flen /= sizeof(FPGA::BUSW);`
92			`return flen;`
93			`}`
94
95			`FPGA *m_fpga;`
96			`class SECTION {`
97			`public:`
98			`unsigned m_start, m_len;`
99			`FPGA::BUSW m_data[1];`
100			`};`
101
102			`SECTION **singlesection(int nwords) {`
103			`fprintf(stderr, "NWORDS = %d\n", nwords);`
104			`size_t sz = (2(sizeof(SECTION)+sizeof(SECTION ))`
105			`+(nwords-1)*(sizeof(FPGA::BUSW)));`
106			`char d = (char )malloc(sz);`
107			`SECTION r = (SECTION )d;`
108			`memset(r, 0, sz);`
109			`r[0] = (SECTION )(&d[2sizeof(SECTION *)]);`
110			`r[0]->m_len = nwords;`
111			`r[1] = (SECTION *)(&r[0]->m_data[r[0]->m_len]);`
112			`r[0]->m_start = 0;`
113			`r[1]->m_start = 0;`
114			`r[1]->m_len = 0;`
115
116			`return r;`
117			`}`
118
119			`SECTION *rawsection(const char fname) {`
120			`SECTION *secpp, secp;`
121			`unsigned num_words;`
122			`FILE *fp;`
123			`int nr;`
124
125			`fp = fopen(fname, "r");`
126			`if (fp == NULL) {`
127			`fprintf(stderr, "Could not open: %s\n", fname);`
128			`exit(-1);`
129			`}`
130
131			`if ((num_words=fgetwords(fp)) > FLASHWORDS-(RESET_ADDRESS-SPIFLASH)) {`
132			`fprintf(stderr, "File overruns flash memory\n");`
133			`exit(-1);`
134			`}`
135			`secpp = singlesection(num_words);`
136			`secp = secpp[0];`
137			`secp->m_start = RAMBASE;`
138			`secp->m_len = num_words;`
139			`nr= fread(secp->m_data, sizeof(FPGA::BUSW), num_words, fp);`
140			`if (nr != (int)num_words) {`
141			`fprintf(stderr, "Could not read entire file\n");`
142			`perror("O/S Err:");`
143			`exit(-2);`
144			`} assert(secpp[1]->m_len == 0);`
145
146			`return secpp;`
147			`}`
148
149			`unsigned byteswap(unsigned n) {`
150			`unsigned r;`
151
152			`r = (n&0x0ff); n>>= 8;`
153			`r = (r<<8) \| (n&0x0ff); n>>= 8;`
154			`r = (r<<8) \| (n&0x0ff); n>>= 8;`
155			`r = (r<<8) \| (n&0x0ff); n>>= 8;`
156
157			`return r;`
158			`}`
159
160			`// #define CHEAP_AND_EASY`
161			`#ifdef CHEAP_AND_EASY`
162			`#else`
163			`#include <libelf.h>`
164			`#include <gelf.h>`
165
166			`void elfread(const char fname, unsigned &entry, SECTION *&sections) {`
167			`Elf *e;`
168			`int fd, i;`
169			`size_t n;`
170			`char *id;`
171			`Elf_Kind ek;`
172			`GElf_Ehdr ehdr;`
173			`GElf_Phdr phdr;`
174			`const bool dbg = false;`
175
176			`if (elf_version(EV_CURRENT) == EV_NONE) {`
177			`fprintf(stderr, "ELF library initialization err, %s\n", elf_errmsg(-1));`
178			`perror("O/S Err:");`
179			`exit(EXIT_FAILURE);`
180			`} if ((fd = open(fname, O_RDONLY, 0)) < 0) {`
181			`fprintf(stderr, "Could not open %s\n", fname);`
182			`perror("O/S Err:");`
183			`exit(EXIT_FAILURE);`
184			`} if ((e = elf_begin(fd, ELF_C_READ, NULL))==NULL) {`
185			`fprintf(stderr, "Could not run elf_begin, %s\n", elf_errmsg(-1));`
186			`exit(EXIT_FAILURE);`
187			`}`
188
189			`ek = elf_kind(e);`
190			`if (ek == ELF_K_ELF) {`
191			`; // This is the kind of file we should expect`
192			`} else if (ek == ELF_K_AR) {`
193			`fprintf(stderr, "Cannot run an archive!\n");`
194			`exit(EXIT_FAILURE);`
195			`} else if (ek == ELF_K_NONE) {`
196			`;`
197			`} else {`
198			`fprintf(stderr, "Unexpected ELF file kind!\n");`
199			`exit(EXIT_FAILURE);`
200			`}`
201
202			`if (gelf_getehdr(e, &ehdr) == NULL) {`
203			`fprintf(stderr, "getehdr() failed: %s\n", elf_errmsg(-1));`
204			`exit(EXIT_FAILURE);`
205			`} if ((i=gelf_getclass(e)) == ELFCLASSNONE) {`
206			`fprintf(stderr, "getclass() failed: %s\n", elf_errmsg(-1));`
207			`exit(EXIT_FAILURE);`
208			`} if ((id = elf_getident(e, NULL)) == NULL) {`
209			`fprintf(stderr, "getident() failed: %s\n", elf_errmsg(-1));`
210			`exit(EXIT_FAILURE);`
211			`} if (i != ELFCLASS32) {`
212			`fprintf(stderr, "This is a 64-bit ELF file, ZipCPU ELF files are all 32-bit\n");`
213			`exit(EXIT_FAILURE);`
214			`}`
215
216			`if (dbg) {`
217			`printf(" %-20s 0x%jx\n", "e_type", (uintmax_t)ehdr.e_type);`
218			`printf(" %-20s 0x%jx\n", "e_machine", (uintmax_t)ehdr.e_machine);`
219			`printf(" %-20s 0x%jx\n", "e_version", (uintmax_t)ehdr.e_version);`
220			`printf(" %-20s 0x%jx\n", "e_entry", (uintmax_t)ehdr.e_entry);`
221			`printf(" %-20s 0x%jx\n", "e_phoff", (uintmax_t)ehdr.e_phoff);`
222			`printf(" %-20s 0x%jx\n", "e_shoff", (uintmax_t)ehdr.e_shoff);`
223			`printf(" %-20s 0x%jx\n", "e_flags", (uintmax_t)ehdr.e_flags);`
224			`printf(" %-20s 0x%jx\n", "e_ehsize", (uintmax_t)ehdr.e_ehsize);`
225			`printf(" %-20s 0x%jx\n", "e_phentsize", (uintmax_t)ehdr.e_phentsize);`
226			`printf(" %-20s 0x%jx\n", "e_shentsize", (uintmax_t)ehdr.e_shentsize);`
227			`printf("\n");`
228			`}`
229
230
231			`// Check whether or not this is an ELF file for the ZipCPU ...`
232			`if (ehdr.e_machine != 0x0dadd) {`
233			`fprintf(stderr, "This is not a ZipCPU ELF file\n");`
234			`exit(EXIT_FAILURE);`
235			`}`
236
237			`// Get our entry address`
238			`entry = ehdr.e_entry;`
239
240
241			`// Now, let's go look at the program header`
242			`if (elf_getphdrnum(e, &n) != 0) {`
243			`fprintf(stderr, "elf_getphdrnum() failed: %s\n", elf_errmsg(-1));`
244			`exit(EXIT_FAILURE);`
245			`}`
246
247			`unsigned total_octets = 0, current_offset=0, current_section=0;`
248			`for(i=0; i<(int)n; i++) {`
249			`total_octets += sizeof(SECTION *)+sizeof(SECTION);`
250
251			`if (gelf_getphdr(e, i, &phdr) != &phdr) {`
252			`fprintf(stderr, "getphdr() failed: %s\n", elf_errmsg(-1));`
253			`exit(EXIT_FAILURE);`
254			`}`
255
256			`if (dbg) {`
257			`printf(" %-20s 0x%x\n", "p_type", phdr.p_type);`
258			`printf(" %-20s 0x%jx\n", "p_offset", phdr.p_offset);`
259			`printf(" %-20s 0x%jx\n", "p_vaddr", phdr.p_vaddr);`
260			`printf(" %-20s 0x%jx\n", "p_paddr", phdr.p_paddr);`
261			`printf(" %-20s 0x%jx\n", "p_filesz", phdr.p_filesz);`
262			`printf(" %-20s 0x%jx\n", "p_memsz", phdr.p_memsz);`
263			`printf(" %-20s 0x%x [", "p_flags", phdr.p_flags);`
264
265			`if (phdr.p_flags & PF_X) printf(" Execute");`
266			`if (phdr.p_flags & PF_R) printf(" Read");`
267			`if (phdr.p_flags & PF_W) printf(" Write");`
268			`printf("]\n");`
269			`printf(" %-20s 0x%jx\n", "p_align", phdr.p_align);`
270			`}`
271
272			`total_octets += phdr.p_memsz;`
273			`}`
274
275			`char d = (char )malloc(total_octets + sizeof(SECTION)+sizeof(SECTION *));`
276			`memset(d, 0, total_octets);`
277
278			`SECTION r = sections = (SECTION )d;`
279			`current_offset = (n+1)sizeof(SECTION );`
280			`current_section = 0;`
281
282			`for(i=0; i<(int)n; i++) {`
283			`r[i] = (SECTION *)(&d[current_offset]);`
284
285			`if (gelf_getphdr(e, i, &phdr) != &phdr) {`
286			`fprintf(stderr, "getphdr() failed: %s\n", elf_errmsg(-1));`
287			`exit(EXIT_FAILURE);`
288			`}`
289
290			`if (dbg) {`
291			`printf(" %-20s 0x%jx\n", "p_offset", phdr.p_offset);`
292			`printf(" %-20s 0x%jx\n", "p_vaddr", phdr.p_vaddr);`
293			`printf(" %-20s 0x%jx\n", "p_paddr", phdr.p_paddr);`
294			`printf(" %-20s 0x%jx\n", "p_filesz", phdr.p_filesz);`
295			`printf(" %-20s 0x%jx\n", "p_memsz", phdr.p_memsz);`
296			`printf(" %-20s 0x%x [", "p_flags", phdr.p_flags);`
297
298			`if (phdr.p_flags & PF_X) printf(" Execute");`
299			`if (phdr.p_flags & PF_R) printf(" Read");`
300			`if (phdr.p_flags & PF_W) printf(" Write");`
301			`printf("]\n");`
302
303			`printf(" %-20s 0x%jx\n", "p_align", phdr.p_align);`
304			`}`
305
306			`current_section++;`
307
308	26	dgisselq	`r[i]->m_start = phdr.p_paddr;`
309	11	dgisselq	`r[i]->m_len = phdr.p_filesz/ sizeof(FPGA::BUSW);`
310
311			`current_offset += phdr.p_memsz + sizeof(SECTION);`
312
313			`// Now, let's read in our section ...`
314			`if (lseek(fd, phdr.p_offset, SEEK_SET) < 0) {`
315			`fprintf(stderr, "Could not seek to file position %08lx\n", phdr.p_offset);`
316			`perror("O/S Err:");`
317			`exit(EXIT_FAILURE);`
318			`} if (phdr.p_filesz > phdr.p_memsz)`
319			`phdr.p_filesz = 0;`
320			`if (read(fd, r[i]->m_data, phdr.p_filesz) != (int)phdr.p_filesz) {`
321			`fprintf(stderr, "Didnt read entire section\n");`
322			`perror("O/S Err:");`
323			`exit(EXIT_FAILURE);`
324			`}`
325
326			`// Next, we need to byte swap it from big to little endian`
327			`for(unsigned j=0; j<r[i]->m_len; j++)`
328			`r[i]->m_data[j] = byteswap(r[i]->m_data[j]);`
329
330			`if (dbg) for(unsigned j=0; j<r[i]->m_len; j++)`
331			`fprintf(stderr, "ADR[%04x] = %08x\n", r[i]->m_start+j,`
332			`r[i]->m_data[j]);`
333			`}`
334
335			`r[i] = (SECTION *)(&d[current_offset]);`
336			`r[current_section]->m_start = 0;`
337			`r[current_section]->m_len = 0;`
338
339			`elf_end(e);`
340			`close(fd);`
341			`}`
342			`#endif`
343
344			`void usage(void) {`
345			`printf("USAGE: ziprun [-h] [<bit-file> [<alt-bit-file>]] <zip-program-file>\n");`
346			`printf("\n"`
347			`"\t-h\tDisplay this usage statement\n");`
348			`}`
349
350			`int main(int argc, char **argv) {`
351			`int skp=0;`
352	26	dgisselq	`bool permit_raw_files = false, debug_only = false;`
353	11	dgisselq	`unsigned entry = RAMBASE;`
354			`FLASHDRVR *flash = NULL;`
355			`const char bitfile = NULL, altbitfile = NULL;`
356
357			`if (argc < 2) {`
358			`usage();`
359			`exit(EXIT_SUCCESS);`
360			`}`
361
362			`skp=1;`
363			`for(int argn=0; argn<argc-skp; argn++) {`
364			`if (argv[argn+skp][0] == '-') {`
365			`switch(argv[argn+skp][1]) {`
366	26	dgisselq	`case 'd':`
367			`debug_only = true;`
368			`break;`
369	11	dgisselq	`case 'h':`
370			`usage();`
371			`exit(EXIT_SUCCESS);`
372	26	dgisselq	`break;`
373	11	dgisselq	`case 'r':`
374			`permit_raw_files = true;`
375			`break;`
376	26	dgisselq	`default:`
377			`fprintf(stderr, "Unknown option, -%c\n\n",`
378			`argv[argn+skp][0]);`
379			`usage();`
380			`exit(EXIT_FAILURE);`
381			`break;`
382	11	dgisselq	`} skp++; argn--;`
383			`} else { // Check for bit files`
384			`int sl = strlen(argv[argn+skp]);`
385			`if ((sl>4)&&(strcmp(&argv[argn+skp][sl-4],".bit")==0)) {`
386			`if (bitfile == NULL)`
387			`bitfile = argv[argn+skp];`
388			`else if (altbitfile == NULL)`
389			`altbitfile = argv[argn+skp];`
390			`else {`
391			`fprintf(stderr, "Err: Too many bit files listed\n");`
392			`exit(EXIT_FAILURE);`
393			`} skp++; argn--;`
394			`} else`
395			`argv[argn] = argv[argn+skp];`
396			`}`
397			`} argc -= skp;`
398
399
400			`if ((bitfile)&&(access(bitfile,R_OK)!=0)) {`
401			`fprintf(stderr, "Cannot open bitfile, %s\n", bitfile);`
402			`exit(EXIT_FAILURE);`
403			`} if ((altbitfile)&&(access(altbitfile,R_OK)!=0)) {`
404			`fprintf(stderr, "Cannot open alternate bitfile, %s\n",`
405			`altbitfile);`
406			`exit(EXIT_FAILURE);`
407			`} if(((!bitfile)&&(argc<=0)) \|\| ((argc>0)&&(access(argv[0],R_OK)!=0))) {`
408			`// If there's no code file, or the code file cannot be opened`
409			`if (argc>0)`
410			`fprintf(stderr, "Cannot open executable, %s\n", argv[0]);`
411			`else`
412			`usage();`
413			`exit(EXIT_FAILURE);`
414			`}`
415
416			`const char *codef = (argc>0)?argv[0]:NULL;`
417			`DEVBUS::BUSW *fbuf = new DEVBUS::BUSW[FLASHWORDS];`
418
419			`// Set the flash buffer to all ones`
420			`memset(fbuf, -1, FLASHWORDS*sizeof(fbuf[0]));`
421
422	26	dgisselq	`if (debug_only) {`
423			`m_fpga = NULL;`
424			`} else {`
425	11	dgisselq	`char szSel[64];`
426			`strcpy(szSel, "SN:210282768825");`
427			`m_fpga = new FPGA(new DEPPI(szSel));`
428			`}`
429
430	26	dgisselq	`flash = (debug_only)?NULL : new FLASHDRVR(m_fpga);`
431	11	dgisselq
432			`// First, see if we need to load a bit file`
433			`if (bitfile) {`
434			`int len;`
435			`FILE *fp = fopen(bitfile, "rb");`
436
437			`fseek(fp, 0x5dl, SEEK_SET);`
438			`len = fread(&fbuf[CONFIG_ADDRESS-SPIFLASH],`
439			`sizeof(fbuf[0]),`
440			`FLASHWORDS-(CONFIG_ADDRESS-SPIFLASH), fp);`
441			`assert(len + CONFIG_ADDRESS < ALTCONFIG_ADDRESS);`
442			`fclose(fp);`
443
444			`for(int i=0; i<4; i++) {`
445			`// printf("0x%08x\n", fbuf[i]);`
446			`assert(fbuf[i] == 0x0ffffffff);`
447			`} // printf("0x%08x\n", fbuf[4]);`
448			`assert(fbuf[4] == 0x0665599aa);`
449
450			`printf("Loading: %s\n", bitfile);`
451	26	dgisselq	`if ((flash)&&(!flash->write(CONFIG_ADDRESS, len, &fbuf[CONFIG_ADDRESS-SPIFLASH], true))) {`
452	11	dgisselq	`fprintf(stderr, "Could not write primary bitfile\n");`
453			`exit(EXIT_FAILURE);`
454			`}`
455			`} if (altbitfile) {`
456			`int len;`
457			`FILE *fp = fopen(altbitfile, "rb");`
458
459			`// The alternate configuration follows the first configuration`
460			`len = fread(&fbuf[ALTCONFIG_ADDRESS-SPIFLASH],`
461			`sizeof(fbuf[0]),`
462			`FLASHWORDS-(ALTCONFIG_ADDRESS-SPIFLASH), fp);`
463			`assert(len + ALTCONFIG_ADDRESS < RESET_ADDRESS);`
464			`fclose(fp);`
465			`printf("Loading: %s\n", altbitfile);`
466
467	26	dgisselq	`if ((flash)&&(!flash->write(ALTCONFIG_ADDRESS, len, &fbuf[ALTCONFIG_ADDRESS-SPIFLASH], true))) {`
468	11	dgisselq	`fprintf(stderr, "Could not write alternate bitfile\n");`
469			`exit(EXIT_FAILURE);`
470			`}`
471			`}`
472
473			`if (codef) try {`
474			`SECTION *secpp = NULL, secp;`
475
476			`if(iself(codef)) {`
477			`// zip-readelf will help with both of these ...`
478			`elfread(codef, entry, secpp);`
479			`assert(entry == RESET_ADDRESS);`
480			`} else if (permit_raw_files) {`
481			`secpp = rawsection(codef);`
482			`entry = RESET_ADDRESS;`
483			`} else {`
484			`fprintf(stderr, "ERR: %s is not in ELF format\n", codef);`
485			`exit(EXIT_FAILURE);`
486			`}`
487
488			`printf("Loading: %s\n", codef);`
489			`// assert(secpp[1]->m_len = 0);`
490			`for(int i=0; secpp[i]->m_len; i++) {`
491			`bool valid = false;`
492			`secp= secpp[i];`
493			`if ((secp->m_start >= RESET_ADDRESS)`
494			`&&(secp->m_start+secp->m_len`
495			`<= SPIFLASH+FLASHWORDS))`
496			`valid = true;`
497	14	dgisselq	`if ((secp->m_start >= RAMBASE)`
498			`&&(secp->m_start+secp->m_len`
499			`<= RAMBASE+MEMWORDS))`
500			`valid = true;`
501	11	dgisselq	`if (!valid) {`
502			`fprintf(stderr, "No such memory on board: 0x%08x - %08x\n",`
503			`secp->m_start, secp->m_start+secp->m_len);`
504			`exit(EXIT_FAILURE);`
505			`}`
506			`}`
507
508	19	dgisselq	`unsigned startaddr = RESET_ADDRESS, codelen = 0;`
509	11	dgisselq	`for(int i=0; secpp[i]->m_len; i++) {`
510			`secp = secpp[i];`
511	14	dgisselq	`if ((secp->m_start >= RAMBASE)`
512			`&&(secp->m_start+secp->m_len`
513			`<= RAMBASE+MEMWORDS)) {`
514			`for(int i=0; (unsigned)i<secp->m_len; i++) {`
515			`if (secp->m_data[i] != 0) {`
516			`fprintf(stderr, "ERR: Cannot set RAM upon bootup!\n");`
517			`fprintf(stderr, "(The bootloaders just not that smart ... yet)\n");`
518	19	dgisselq	`fprintf(stderr, "Attempting to set %08x - %08x\n", secp->m_start, secp->m_start+secp->m_len-1);`
519			`fprintf(stderr, "%08x cannot be set to %08x\n", secp->m_start+i, secp->m_data[i]);`
520	14	dgisselq	`exit(EXIT_FAILURE);`
521			`}`
522			`}`
523	19	dgisselq	`} else {`
524			`if (secp->m_start < startaddr) {`
525			`codelen += (startaddr-secp->m_start);`
526			`startaddr = secp->m_start;`
527			`} if (secp->m_start+secp->m_len > startaddr+codelen) {`
528			`codelen = secp->m_start+secp->m_len-startaddr;`
529			`} memcpy(&fbuf[secp->m_start-SPIFLASH],`
530			`secp->m_data,`
531			`secp->m_len*sizeof(FPGA::BUSW));`
532	11	dgisselq	`}`
533			`}`
534	26	dgisselq	`if ((flash)&&(!flash->write(startaddr, codelen, &fbuf[startaddr-SPIFLASH], true))) {`
535	19	dgisselq	`fprintf(stderr, "ERR: Could not write program to flash\n");`
536			`exit(EXIT_FAILURE);`
537	26	dgisselq	`} else if (!flash)`
538			`printf("flash->write(%08x, %d, ... );\n", startaddr,`
539			`codelen);`
540			`if (m_fpga) m_fpga->readio(R_VERSION); // Check for bus errors`
541	11	dgisselq
542			`// Now ... how shall we start this CPU?`
543			`printf("The CPU should be fully loaded, you may now start\n");`
544			`printf("it. To start the CPU, either toggle power or type\n");`
545			`printf("%% wbregs fpgagen1 0 \n");`
546			`printf("%% wbregs fpgagen2 0x0300 \n");`
547			`printf("%% wbregs fpgacmd 14 \n");`
548			`} catch(BUSERR a) {`
549			`fprintf(stderr, "XULA-BUS error: %08x\n", a.addr);`
550			`exit(-2);`
551			`}`
552
553	26	dgisselq	`if (m_fpga) delete m_fpga;`
554	11	dgisselq
555			`return EXIT_SUCCESS;`
556			`}`
557