sam-t2/sam/system/blaze/ui_mem_cmds.cc

// ========== Copyright Header Begin ==========================================
//
// OpenSPARC T2 Processor File: ui_mem_cmds.cc
// Copyright (c) 2006 Sun Microsystems, Inc.  All Rights Reserved.
// DO NOT ALTER OR REMOVE COPYRIGHT NOTICES.
//
// The above named program is free software; you can redistribute it and/or
// modify it under the terms of the GNU General Public
// License version 2 as published by the Free Software Foundation.
//
// The above named 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 work; if not, write to the Free Software
// Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA.
//
// ========== Copyright Header End ============================================
/*
 * Copyright (C) 2001 Sun Microsystems, Inc.
 * All rights reserved.
 */
#pragma ident "@(#)1.19 07/11/19        ui_mem_cmds.cc"

#include <sys/types.h>
#include <sys/mman.h>
#include <assert.h>
#include <fcntl.h>
#include <stdio.h>
#include <stdlib.h>
#include <strings.h>
#include <unistd.h>
#include <libelf.h>
#include <sys/dkio.h>
#include <sys/dklabel.h>
#include <sys/vtoc.h>


#include "types.h"
#include "mem.h"

#include "system.h"
#include "dr.h"
#include "ui.h"

typedef void* TM_OPAQUE_DATA;
#include "tracemod.h"

#include "blaze_globals.h"
#include "ui_utils.h"
#include "fileutil.h"

///////////////////////////////////////////////////////////////////////

void load_elf64(char *filename, uint64_t base_pa, uint64_t base_va);
static void load_elf64_section(Elf64_Shdr *shdr, Elf_Scn *scn,
                               uint64_t base_pa, uint64_t base_va);

///////////////////////////////////////////////////////////////////////

extern bool_t  schizo_rom_match (uint64_t paddr);
extern bool_t  schizo_rom_store (uint32_t cpu_id, uint64_t  paddr, uint32_t size, uint64_t *buf);

///////////////////////////////////////////////////////////////////////

int load_cmd(char *cp, void *)
{
        char            *filename;
        char            *token;
        uint64_t        base_pa;
        uint64_t        base_va;

        cp = ui_parsew(cp, &token);
        base_pa = strtoll(token, (char**)NULL, 16);

        cp = ui_parsew(cp, &filename);
        cp = ui_parsew(cp, &token);
        base_va = strtoll(token, (char**)NULL, 16);

        load_elf64(filename, base_pa, base_va);

        return UI_CMD_DONE;
}

void load_elf64(char *filename, uint64_t base_pa, uint64_t base_va)
{
        int fd;
        Elf *elf;
        Elf64_Ehdr *ehdr;
        Elf_Scn *scn;
        Elf64_Shdr *shdr;
        Elf_Data *data;
        u_int cnt;

        /* Open the input file */
        fd = SYSTEM_open(filename, O_RDONLY);
        if (fd == -1) {
            ui->error("<%s> not found \n", filename);
            exit (0);
        }


        /* Obtain the ELF descriptor */
        (void) elf_version(EV_CURRENT);
        if ((elf = elf_begin(fd, ELF_C_READ, NULL)) == NULL) {
                ui->error("%s\n", elf_errmsg(elf_errno()));
                exit(0);
        }

        /* Obtain the .shstrtab data buffer */
        if (((ehdr = elf64_getehdr(elf)) == NULL) ||
            ((scn = elf_getscn(elf, ehdr->e_shstrndx)) == NULL) ||
            ((data = elf_getdata(scn, NULL)) == NULL)) {
                ui->error("%s\n", elf_errmsg(elf_errno()));
                exit(0);
        }

        /* Traverse input filename, looking for relevant sections */
        for (cnt = 1, scn = NULL; scn = elf_nextscn(elf, scn); cnt++) {
                if ((shdr = elf64_getshdr(scn)) == NULL) {
                        ui->error("%s\n", elf_errmsg(elf_errno()));
                        exit(0);
                }
                if (strcmp((char *)data->d_buf+shdr->sh_name,
                        ".text") == 0) {
                        load_elf64_section(shdr, scn, base_pa, base_va);
                } else if (strcmp((char *)data->d_buf+shdr->sh_name,
                               ".rodata") == 0) {
                        load_elf64_section(shdr, scn, base_pa, base_va);
                } else if (strcmp((char *)data->d_buf+shdr->sh_name,
                               ".rodata1") == 0) {
                        load_elf64_section(shdr, scn, base_pa, base_va);
                } else if (strcmp((char *)data->d_buf+shdr->sh_name,
                               ".data") == 0) {
                        load_elf64_section(shdr, scn, base_pa, base_va);
                } else if (strcmp((char *)data->d_buf+shdr->sh_name,
                               ".data1") == 0) {
                        load_elf64_section(shdr, scn, base_pa, base_va);
                }
        }

        elf_end(elf);
        close(fd);
}

///////////////////////////////////////////////////////////////

static void load_elf64_section(Elf64_Shdr *shdr, Elf_Scn *scn,
    uint64_t base_pa, uint64_t base_va)
{
        uint64_t offset;
        Elf_Data *data;

        if ((data = elf_getdata(scn, NULL)) == NULL) {
                ui->error("%s\n", elf_errmsg(elf_errno()));
                exit(0);
        }

        offset = shdr->sh_addr - base_va;

        memwrite8u_blk_nl(mm1, base_pa + offset, (const unsigned char *)data->d_buf,
            data->d_size);
}

///////////////////////////////////////////////////////////////


#ifdef NIAGARA

bool_t load_mem_image(const char * file)
{
  FILE * fp = fopen (file, "r");
  if (fp == NULL) {
    ui->perror(file);
    return FALSE;
  }

  char s[512];
  uint64_t pa = 0;

  while(fgets(s, 512, fp) != NULL) {
    if (s[0] == '@') {
      pa = strtoull(s+1, NULL, 16);
      continue;
    }

    char * last_s;
    char * token = strtok_r(s, " \t\n", &last_s);
    if (token == NULL) continue;
    do {
      uint64_t v = strtoull(token, NULL, 16);
      if (schizo_rom_match(pa)) {
        schizo_rom_store (0, pa, 8, &v);
      } else {
        memwrite64u_nl(mm1, pa, v);
      }
      pa += 8;
      token = strtok_r(NULL, " \t\n", &last_s);
    } while(token != NULL);
  }
  return true;

} // bool_t load_mem_image(char * file)

bool_t load_bin_image (char *file, uint64_t addr, uint64_t size, uint64_t seg_size, int zero_pad, int create_lbl)
{
    bool_t  is_ni_rom = FALSE;
    uint64_t tmppa, buf=0;

    int bytes_read =0;

    is_ni_rom = schizo_rom_match (addr);
    if (is_ni_rom) {    // If it is rom, it is special
        ui->output("ni rom: addr = 0x%llx, size = 0x%llx, seg_size = 0x%llx\n", addr, size, seg_size);
        buf = 0;
        tmppa = addr;
        for (int i= 0; i<seg_size/8; i++) {
            schizo_rom_store (0, tmppa, 8, &buf);
            tmppa +=8;
        }

        FILE *   Ffp = fopen (file, "r");

        for (int i=0; i< size/8; i++) {
            bytes_read += fread (&buf, sizeof(uint64_t), 1, Ffp);
            schizo_rom_store (0, addr, 8, &buf);
            addr +=8;
        }
        buf = 0;
        while (size - bytes_read++) {
           schizo_rom_store (0, addr++, 1, &buf);
        }
        ui->output("total bytes to rom_store 0x%x\n", bytes_read);
    } else /* not ni rom */ {

        FILE *   fp = fopen (file, "r");
        char     s[512]; // char *ps;
        uint64_t pa, buf, last_pa = 0;
        uint8_t *buf8;
        int      ret_size = 0;
        int bytes_read =0;
        AddrPair *ap = NULL;
        memT     *msp;

        if (fp == NULL) {
            ui->perror (file);
            return FALSE;
        }
        buf8 = (uint8_t *)malloc(size);
        assert(buf8);
        bytes_read += fread(buf8, sizeof(uint8_t), size, fp);
        memwrite8u_blk_nl(mm1, addr, (const unsigned char *)buf8, (int)size);

        if (create_lbl) {
            ui->error("create_lbl not supported in this version. Please use v4.49 or prior\n");
            exit(1);
        }
    } // ni-rom or phys RAM?
}

#endif //// NIAGARA