/* Copyright 2014 Theo Berkau

This file is part of yssloader.

yssloader 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; either version 2 of the License, or

(at your option) any later version.

yssloader 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 Yabause; if not, write to the Free Software

Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA

*/

#include <ida.hpp>

#include <idp.hpp>

#include <loader.hpp>

#include <name.hpp>

#include <search.hpp>

#include <diskio.hpp>

#define f_YSS 0x4444

#define PLFM_SCUDSP 0x8124

#define PLFM_SCSPDSP 0x8125

bool yssEndian;

void create_load_seg(linput_t *li, ea_t start, ea_t end, int type, const char *name);

//--------------------------------------------------------------------------

//

// check input file format. if recognized, then return 1

// and fill 'fileformatname'.

// otherwise return 0

//

static int idaapi accept_yss_file(linput_t *li, char fileformatname[MAX_FILE_FORMAT_NAME], int n)

}

static INLINE int StateCheckRetrieveHeader(linput_t *li, const char *name, int *version, int *size) {

}

typedef struct

{

uint32 R[16];

uint32 SR;

uint32 GBR;

uint32 VBR;

uint32 MACH;

uint32 MACL;

uint32 PR;

uint32 PC;

} sh2regs_struct;

void SH2LoadState(linput_t *li, bool isslave, sh2regs_struct *regs, int size)

}

typedef struct

{

uint8 vector;

uint8 level;

uint16 mask;

uint32 statusbit;

} scuinterrupt_struct;

typedef struct

{

/* DMA registers */

uint32 D0R;

uint32 D0W;

uint32 D0C;

uint32 D0AD;

uint32 D0EN;

uint32 D0MD;

uint32 D1R;

uint32 D1W;

uint32 D1C;

uint32 D1AD;

uint32 D1EN;

uint32 D1MD;

uint32 D2R;

uint32 D2W;

uint32 D2C;

uint32 D2AD;

uint32 D2EN;

uint32 D2MD;

uint32 DSTP;

uint32 DSTA;

/* DSP registers */

uint32 PPAF;

uint32 PPD;

uint32 PDA;

uint32 PDD;

/* Timer registers */

uint32 T0C;

uint32 T1S;

uint32 T1MD;

/* Interrupt registers */

uint32 IMS;

uint32 IST;

/* A-bus registers */

uint32 AIACK;

uint32 ASR0;

uint32 ASR1;

uint32 AREF;

/* SCU registers */

uint32 RSEL;

uint32 VER;

/* internal variables */

uint32 timer0;

uint32 timer1;

scuinterrupt_struct interrupts[30];

uint32 NumberOfInterrupts;

} scuregs_struct;

typedef struct {

uint32 ProgramRam[256];

uint32 MD[4][64];

union {

struct {

uint32 P:8; // Program Ram Address

uint32 unused3:7;

uint32 LE:1; // Program counter load enable bit

uint32 EX:1; // Program execute control bit

uint32 ES:1; // Program step execute control bit

uint32 E:1; // Program end interrupt flag

uint32 V:1; // Overflow flag

uint32 C:1; // Carry flag

uint32 Z:1; // Zero flag

uint32 S:1; // Sine flag

uint32 T0:1; // D0 bus use DMA execute flag

uint32 unused2:1;

uint32 EP:1; // Temporary stop execution flag

uint32 PR:1; // Pause cancel flag

uint32 unused1:5;

} part;

uint32 all;

} ProgControlPort;

uint8 PC;

uint8 TOP;

uint16 LOP;

int32 jmpaddr;

int32 delayed;

uint8 DataRamPage;

uint8 DataRamReadAddress;

uint8 CT[4];

uint32 RX;

uint32 RY;

uint32 RA0;

uint32 WA0;

union {

struct {

int64 L:32;

int64 H:16;

int64 unused:16;

} part;

int64 all;

} AC;

union {

struct {

int64 L:32;

int64 H:16;

int64 unused:16;

} part;

int64 all;

} P;

union {

struct {

int64 L:32;

int64 H:16;

int64 unused:16;

} part;

int64 all;

} ALU;

union {

struct {

int64 L:32;

int64 H:16;

int64 unused:16;

} part;

int64 all;

} MUL;

} scudspregs_struct;

void ScuLoadState (linput_t *li, ea_t *pc, int size)

}

void SoundLoadState (linput_t *li, ea_t *pc, int size)

}

void Vdp1LoadState(linput_t *li, int size)

}

void Vdp2LoadState(linput_t *li, int size)

}

void make_vector(ea_t addr, char *name)

}

void identify_vector_table()

}

void find_align(ea_t ea, ea_t maxea, asize_t length, int alignment)

}

void find_bios_funcs()

}

bool find_parse_ip(ea_t ea, bool parsecode)

}

void create_load_seg(linput_t *li, ea_t start, ea_t end, int type, const char *name)

}

bool load_header(linput_t *li)

}

ea_t find_string(char *search_str)

}

void get_lib_version(ea_t addr, int str_offset, char *version_str, size_t version_str_size)

}

void load_scudsp_data(linput_t *li)

}

void load_scspdsp_data(linput_t *li)

{

}

void load_68k_data(linput_t *li)

}

void load_sh2_data(linput_t *li)

}

static void idaapi load_yss_file(linput_t *li, ushort neflags,

}

idaman loader_t ida_module_data LDSC;

//----------------------------------------------------------------------

//

// LOADER DESCRIPTION BLOCK

//

//----------------------------------------------------------------------

loader_t LDSC = {

IDP_INTERFACE_VERSION,

0, // loader flags

accept_yss_file, // test yss format.

load_yss_file, // load file into the database.

NULL, // yss save

NULL, // no special handling for moved segments

NULL // no special handling for File->New

};

//----------------------------------------------------------------------