[mupen64plus-pandora.git] / source / mupen64plus-rsp-hle / src / main.c

/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
 *   Mupen64plus-rsp-hle - main.c                                          *
 *   Mupen64Plus homepage: http://code.google.com/p/mupen64plus/           *
 *   Copyright (C) 2012 Bobby Smiles                                       *
 *   Copyright (C) 2009 Richard Goedeken                                   *
 *   Copyright (C) 2002 Hacktarux                                          *
 *                                                                         *
 *   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; either version 2 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        *
 *   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.,                                       *
 *   51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.          *
 * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */

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

#define M64P_PLUGIN_PROTOTYPES 1
#include "m64p_types.h"
#include "m64p_common.h"
#include "m64p_plugin.h"
#include "hle.h"
#include "alist.h"
#include "cicx105.h"
#include "jpeg.h"

#define min(a,b) (((a) < (b)) ? (a) : (b))

/* some rsp status flags */
#define RSP_STATUS_HALT             0x1
#define RSP_STATUS_BROKE            0x2
#define RSP_STATUS_INTR_ON_BREAK    0x40
#define RSP_STATUS_TASKDONE         0x200

/* some rdp status flags */
#define DP_STATUS_FREEZE            0x2

/* some mips interface interrupt flags */
#define MI_INTR_SP                  0x1


/* helper functions prototypes */
static unsigned int sum_bytes(const unsigned char *bytes, unsigned int size);
static void dump_binary(const char * const filename, const unsigned char * const bytes,
                        unsigned int size);
static void dump_task(const char * const filename, const OSTask_t * const task);

static void handle_unknown_task(unsigned int sum);
static void handle_unknown_non_task(unsigned int sum);

/* global variables */
RSP_INFO rsp;

/* local variables */
static const int FORWARD_AUDIO = 0, FORWARD_GFX = 1;
static void (*l_DebugCallback)(void *, int, const char *) = NULL;
static void *l_DebugCallContext = NULL;
static int l_PluginInit = 0;

/* local functions */


/**
 * Try to figure if the RSP was launched using osSpTask* functions
 * and not run directly (in which case DMEM[0xfc0-0xfff] is meaningless).
 *
 * Previously, the ucode_size field was used to determine this,
 * but it is not robust enough (hi Pokemon Stadium !) because games could write anything
 * in this field : most ucode_boot discard the value and just use 0xf7f anyway.
 *
 * Using ucode_boot_size should be more robust in this regard.
 **/
static int is_task()
{
    return (get_task()->ucode_boot_size <= 0x1000);
}

static void rsp_break(unsigned int setbits)
{
    *rsp.SP_STATUS_REG |= setbits | RSP_STATUS_BROKE | RSP_STATUS_HALT;

    if ((*rsp.SP_STATUS_REG & RSP_STATUS_INTR_ON_BREAK))
    {
        *rsp.MI_INTR_REG |= MI_INTR_SP;
        rsp.CheckInterrupts();
    }
}

static void forward_gfx_task()
{
    if (rsp.ProcessDlistList != NULL)
    {
        rsp.ProcessDlistList();
        *rsp.DPC_STATUS_REG &= ~DP_STATUS_FREEZE;
    }
}

static void forward_audio_task()
{
    if (rsp.ProcessAlistList != NULL)
    {
        rsp.ProcessAlistList();
    }
}

static void show_cfb()
{
    if (rsp.ShowCFB != NULL)
    {
        rsp.ShowCFB();
    }
}

static int try_fast_audio_dispatching()
{
    /* identify audio ucode by using the content of ucode_data */
    const OSTask_t * const task = get_task();
    const unsigned char * const udata_ptr = rsp.RDRAM + task->ucode_data;

    if (*(unsigned int*)(udata_ptr + 0) == 0x00000001)
    {
        if (*(unsigned int*)(udata_ptr + 0x30) == 0xf0000f00)
        {
            /**
            * Many games including:
            * Super Mario 64, Diddy Kong Racing, BlastCorp, GoldenEye, ... (most common)
            **/
            alist_process_ABI1(); return 1;
        }
        else
        {
            /**
            * Mario Kart / Wave Race,
            * LylatWars,
            * FZeroX,
            * Yoshi Story,
            * 1080 Snowboarding,
            * Zelda Ocarina of Time,
            * Zelda Majoras Mask / Pokemon Stadium 2,
            * Animal Crossing
            *
            * FIXME: in fact, all these games do not share the same ABI.
            * That's the reason of the workaround in ucode2.cpp with isZeldaABI and isMKABI
            **/
            alist_process_ABI2(); return 1;
        }
    }
    else
    {
        if (*(unsigned int*)(udata_ptr + 0x10) == 0x00000001)
        {
            /**
             * Musyx ucode found in following games:
             * RogueSquadron, ResidentEvil2, SnowCrossPolaris, TheWorldIsNotEnough,
             * RugratsInParis, NBAShowTime, HydroThunder, Tarzan,
             * GauntletLegend, Rush2049, IndianaJones, BattleForNaboo
             * TODO: implement ucode
             **/
            DebugMessage(M64MSG_WARNING, "MusyX ucode not implemented.");
            /* return 1; */
        }
        else
        {
            /**
             * Many games including:
             * Pokemon Stadium, Banjo Kazooie, Donkey Kong, Banjo Tooie, Jet Force Gemini,
             * Mickey SpeedWay USA, Perfect Dark, Conker Bad Fur Day ...
             **/
            alist_process_ABI3(); return 1;
        }
    }
    
    return 0;
}

static int try_fast_task_dispatching()
{
    /* identify task ucode by its type */
    const OSTask_t * const task = get_task();

    switch (task->type)
    {
        case 1: if (FORWARD_GFX) { forward_gfx_task(); return 1; } break;

        case 2:
            if (FORWARD_AUDIO) { forward_audio_task(); return 1; }
            else if (try_fast_audio_dispatching()) { return 1; }
            break;

        case 7: show_cfb(); return 1;
    }

    return 0;
}

static void normal_task_dispatching()
{
    const OSTask_t * const task = get_task();
    const unsigned int sum =
        sum_bytes(rsp.RDRAM + task->ucode, min(task->ucode_size, 0xf80) >> 1);

    switch (sum)
    {
        /* StoreVe12: found in Zelda Ocarina of Time [misleading task->type == 4] */
        case 0x278: /* Nothing to emulate */ return;

        /* GFX: Twintris [misleading task->type == 0] */                                         
        case 0x212ee:
            if (FORWARD_GFX) { forward_gfx_task(); return; }
            break;

        /* JPEG: found in Pokemon Stadium J */ 
        case 0x2c85a: jpeg_decode_PS0(); return;

        /* JPEG: found in Zelda Ocarina of Time, Pokemon Stadium 1, Pokemon Stadium 2 */
        case 0x2caa6: jpeg_decode_PS(); return;

        /* JPEG: found in Ogre Battle, Bottom of the 9th */
        case 0x130de:
        case 0x278b0:
            jpeg_decode_OB(); return;
    }

    handle_unknown_task(sum);
}

static void non_task_dispatching()
{
    const unsigned int sum = sum_bytes(rsp.IMEM, 0x1000 >> 1);

    switch(sum)
    {
        /* CIC x105 ucode (used during boot of CIC x105 games) */
        case 0x9e2: /* CIC 6105 */
        case 0x9f2: /* CIC 7105 */
            cicx105_ucode(); return;
    }

    handle_unknown_non_task(sum);
}

static void handle_unknown_task(unsigned int sum)
{
    char filename[256];
    const OSTask_t * const task = get_task();

    DebugMessage(M64MSG_WARNING, "unknown OSTask: sum %x PC:%x", sum, *rsp.SP_PC_REG);

    sprintf(&filename[0], "task_%x.log", sum);
    dump_task(filename, task);
    
    // dump ucode_boot
    sprintf(&filename[0], "ucode_boot_%x.bin", sum);
    dump_binary(filename, rsp.RDRAM + (task->ucode_boot & 0x7fffff), task->ucode_boot_size);

    // dump ucode
    if (task->ucode != 0)
    {
        sprintf(&filename[0], "ucode_%x.bin", sum);
        dump_binary(filename, rsp.RDRAM + (task->ucode & 0x7fffff), 0xf80);
    }

    // dump ucode_data
    if (task->ucode_data != 0)
    {
        sprintf(&filename[0], "ucode_data_%x.bin", sum);
        dump_binary(filename, rsp.RDRAM + (task->ucode_data & 0x7fffff), task->ucode_data_size);
    }

    // dump data
    if (task->data_ptr != 0)
    {
        sprintf(&filename[0], "data_%x.bin", sum);
        dump_binary(filename, rsp.RDRAM + (task->data_ptr & 0x7fffff), task->data_size);
    }
}

static void handle_unknown_non_task(unsigned int sum)
{
    char filename[256];

    DebugMessage(M64MSG_WARNING, "unknown RSP code: sum: %x PC:%x", sum, *rsp.SP_PC_REG);

    // dump IMEM & DMEM for further analysis
    sprintf(&filename[0], "imem_%x.bin", sum);
    dump_binary(filename, rsp.IMEM, 0x1000);

    sprintf(&filename[0], "dmem_%x.bin", sum);
    dump_binary(filename, rsp.DMEM, 0x1000);
}


/* Global functions */
void DebugMessage(int level, const char *message, ...)
{
    char msgbuf[1024];
    va_list args;

    if (l_DebugCallback == NULL)
        return;

    va_start(args, message);
    vsprintf(msgbuf, message, args);

    (*l_DebugCallback)(l_DebugCallContext, level, msgbuf);

    va_end(args);
}

/* DLL-exported functions */
EXPORT m64p_error CALL PluginStartup(m64p_dynlib_handle CoreLibHandle, void *Context,
                                   void (*DebugCallback)(void *, int, const char *))
{
    if (l_PluginInit)
        return M64ERR_ALREADY_INIT;

    /* first thing is to set the callback function for debug info */
    l_DebugCallback = DebugCallback;
    l_DebugCallContext = Context;

    /* this plugin doesn't use any Core library functions (ex for Configuration), so no need to keep the CoreLibHandle */

    l_PluginInit = 1;
    return M64ERR_SUCCESS;
}

EXPORT m64p_error CALL PluginShutdown(void)
{
    if (!l_PluginInit)
        return M64ERR_NOT_INIT;

    /* reset some local variable */
    l_DebugCallback = NULL;
    l_DebugCallContext = NULL;

    l_PluginInit = 0;
    return M64ERR_SUCCESS;
}

EXPORT m64p_error CALL PluginGetVersion(m64p_plugin_type *PluginType, int *PluginVersion, int *APIVersion, const char **PluginNamePtr, int *Capabilities)
{
    /* set version info */
    if (PluginType != NULL)
        *PluginType = M64PLUGIN_RSP;

    if (PluginVersion != NULL)
        *PluginVersion = RSP_HLE_VERSION;

    if (APIVersion != NULL)
        *APIVersion = RSP_PLUGIN_API_VERSION;
    
    if (PluginNamePtr != NULL)
        *PluginNamePtr = "Hacktarux/Azimer High-Level Emulation RSP Plugin";

    if (Capabilities != NULL)
    {
        *Capabilities = 0;
    }
                    
    return M64ERR_SUCCESS;
}

EXPORT unsigned int CALL DoRspCycles(unsigned int Cycles)
{
    if (is_task())
    {
        if (!try_fast_task_dispatching()) { normal_task_dispatching(); }
        rsp_break(RSP_STATUS_TASKDONE);
    }
    else
    {
        non_task_dispatching();
        rsp_break(0);
    }

    return Cycles;
}

EXPORT void CALL InitiateRSP(RSP_INFO Rsp_Info, unsigned int *CycleCount)
{
    rsp = Rsp_Info;
}

EXPORT void CALL RomClosed(void)
{
    memset(rsp.DMEM, 0, 0x1000);
    memset(rsp.IMEM, 0, 0x1000);

    init_ucode2();
}


/* local helper functions */
static unsigned int sum_bytes(const unsigned char *bytes, unsigned int size)
{
    unsigned int sum = 0;
    const unsigned char * const bytes_end = bytes + size;

    while (bytes != bytes_end)
        sum += *bytes++;

    return sum;
}


static void dump_binary(const char * const filename, const unsigned char * const bytes,
                        unsigned int size)
{
    FILE *f;

    // if file already exists, do nothing
    f = fopen(filename, "r");
    if (f == NULL)
    {
        // else we write bytes to the file
        f= fopen(filename, "wb");
        if (f != NULL) {
            if (fwrite(bytes, 1, size, f) != size)
            {
                DebugMessage(M64MSG_ERROR, "Writing error on %s", filename);
            }
            fclose(f);
        }
        else
        {
            DebugMessage(M64MSG_ERROR, "Couldn't open %s for writing !", filename);
        }
    }
    else
    {
        fclose(f);
    }
}

static void dump_task(const char * const filename, const OSTask_t * const task)
{
    FILE *f;

    f = fopen(filename, "r");
    if (f == NULL)
    {
        f = fopen(filename, "w");
        fprintf(f,
            "type = %d\n"
            "flags = %d\n"
            "ucode_boot  = %#08x size  = %#x\n"
            "ucode       = %#08x size  = %#x\n"
            "ucode_data  = %#08x size  = %#x\n"
            "dram_stack  = %#08x size  = %#x\n"
            "output_buff = %#08x *size = %#x\n"
            "data        = %#08x size  = %#x\n"
            "yield_data  = %#08x size  = %#x\n",
            task->type, task->flags,
            task->ucode_boot, task->ucode_boot_size,
            task->ucode, task->ucode_size,
            task->ucode_data, task->ucode_data_size,
            task->dram_stack, task->dram_stack_size,
            task->output_buff, task->output_buff_size,
            task->data_ptr, task->data_size,
            task->yield_data_ptr, task->yield_data_size);
        fclose(f);
    }
    else
    {
        fclose(f);
    }
}
Commit	Line	Data
d9e74a6f	1	/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
	2	* Mupen64plus-rsp-hle - main.c *
	3	* Mupen64Plus homepage: http://code.google.com/p/mupen64plus/ *
	4	* Copyright (C) 2012 Bobby Smiles *
	5	* Copyright (C) 2009 Richard Goedeken *
	6	* Copyright (C) 2002 Hacktarux *
	7	* *
	8	* This program is free software; you can redistribute it and/or modify *
	9	* it under the terms of the GNU General Public License as published by *
	10	* the Free Software Foundation; either version 2 of the License, or *
	11	* (at your option) any later version. *
	12	* *
	13	* This program is distributed in the hope that it will be useful, *
	14	* but WITHOUT ANY WARRANTY; without even the implied warranty of *
	15	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
	16	* GNU General Public License for more details. *
	17	* *
	18	* You should have received a copy of the GNU General Public License *
	19	* along with this program; if not, write to the *
	20	* Free Software Foundation, Inc., *
	21	* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. *
	22	* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
	23
	24	#include <stdarg.h>
	25	#include <string.h>
	26	#include <stdio.h>
	27
	28	#define M64P_PLUGIN_PROTOTYPES 1
	29	#include "m64p_types.h"
	30	#include "m64p_common.h"
	31	#include "m64p_plugin.h"
	32	#include "hle.h"
	33	#include "alist.h"
	34	#include "cicx105.h"
	35	#include "jpeg.h"
	36
	37	#define min(a,b) (((a) < (b)) ? (a) : (b))
	38
	39	/* some rsp status flags */
	40	#define RSP_STATUS_HALT 0x1
	41	#define RSP_STATUS_BROKE 0x2
	42	#define RSP_STATUS_INTR_ON_BREAK 0x40
	43	#define RSP_STATUS_TASKDONE 0x200
	44
	45	/* some rdp status flags */
	46	#define DP_STATUS_FREEZE 0x2
	47
	48	/* some mips interface interrupt flags */
	49	#define MI_INTR_SP 0x1
	50
	51
	52	/* helper functions prototypes */
	53	static unsigned int sum_bytes(const unsigned char *bytes, unsigned int size);
	54	static void dump_binary(const char * const filename, const unsigned char * const bytes,
	55	unsigned int size);
	56	static void dump_task(const char * const filename, const OSTask_t * const task);
	57
	58	static void handle_unknown_task(unsigned int sum);
	59	static void handle_unknown_non_task(unsigned int sum);
	60
	61	/* global variables */
	62	RSP_INFO rsp;
	63
	64	/* local variables */
65	static const int FORWARD_AUDIO = 0, FORWARD_GFX = 1;
66	static void (l_DebugCallback)(void , int, const char *) = NULL;
67	static void *l_DebugCallContext = NULL;
68	static int l_PluginInit = 0;
69
70	/* local functions */
71
72
73	/**
74	* Try to figure if the RSP was launched using osSpTask* functions
75	* and not run directly (in which case DMEM[0xfc0-0xfff] is meaningless).
76	*
77	* Previously, the ucode_size field was used to determine this,
78	* but it is not robust enough (hi Pokemon Stadium !) because games could write anything
79	* in this field : most ucode_boot discard the value and just use 0xf7f anyway.
80	*
81	* Using ucode_boot_size should be more robust in this regard.
82	**/
83	static int is_task()
84	{
85	return (get_task()->ucode_boot_size <= 0x1000);
86	}
87
88	static void rsp_break(unsigned int setbits)
89	{
90	*rsp.SP_STATUS_REG \|= setbits \| RSP_STATUS_BROKE \| RSP_STATUS_HALT;
91
92	if ((*rsp.SP_STATUS_REG & RSP_STATUS_INTR_ON_BREAK))
93	{
94	*rsp.MI_INTR_REG \|= MI_INTR_SP;
95	rsp.CheckInterrupts();
96	}
97	}
98
99	static void forward_gfx_task()
100	{
101	if (rsp.ProcessDlistList != NULL)
102	{
103	rsp.ProcessDlistList();
104	*rsp.DPC_STATUS_REG &= ~DP_STATUS_FREEZE;
105	}
106	}
107
108	static void forward_audio_task()
109	{
110	if (rsp.ProcessAlistList != NULL)
111	{
112	rsp.ProcessAlistList();
113	}
114	}
115
116	static void show_cfb()
117	{
118	if (rsp.ShowCFB != NULL)
119	{
120	rsp.ShowCFB();
121	}
122	}
123
124	static int try_fast_audio_dispatching()
125	{
126	/* identify audio ucode by using the content of ucode_data */
127	const OSTask_t * const task = get_task();
128	const unsigned char * const udata_ptr = rsp.RDRAM + task->ucode_data;
129
130	if ((unsigned int)(udata_ptr + 0) == 0x00000001)
131	{
132	if ((unsigned int)(udata_ptr + 0x30) == 0xf0000f00)
133	{
134	/**
135	* Many games including:
136	* Super Mario 64, Diddy Kong Racing, BlastCorp, GoldenEye, ... (most common)
137	**/
138	alist_process_ABI1(); return 1;
139	}
140	else
141	{
142	/**
143	* Mario Kart / Wave Race,
144	* LylatWars,
145	* FZeroX,
146	* Yoshi Story,
147	* 1080 Snowboarding,
148	* Zelda Ocarina of Time,
149	* Zelda Majoras Mask / Pokemon Stadium 2,
150	* Animal Crossing
151	*
152	* FIXME: in fact, all these games do not share the same ABI.
153	* That's the reason of the workaround in ucode2.cpp with isZeldaABI and isMKABI
154	**/
155	alist_process_ABI2(); return 1;
156	}
157	}
158	else
159	{
160	if ((unsigned int)(udata_ptr + 0x10) == 0x00000001)
161	{
162	/**
163	* Musyx ucode found in following games:
164	* RogueSquadron, ResidentEvil2, SnowCrossPolaris, TheWorldIsNotEnough,
165	* RugratsInParis, NBAShowTime, HydroThunder, Tarzan,
166	* GauntletLegend, Rush2049, IndianaJones, BattleForNaboo
167	* TODO: implement ucode
168	**/
169	DebugMessage(M64MSG_WARNING, "MusyX ucode not implemented.");
170	/* return 1; */
171	}
172	else
173	{
174	/**
175	* Many games including:
176	* Pokemon Stadium, Banjo Kazooie, Donkey Kong, Banjo Tooie, Jet Force Gemini,
177	* Mickey SpeedWay USA, Perfect Dark, Conker Bad Fur Day ...
178	**/
179	alist_process_ABI3(); return 1;
180	}
181	}
182
183	return 0;
184	}
185
186	static int try_fast_task_dispatching()
187	{
188	/* identify task ucode by its type */
189	const OSTask_t * const task = get_task();
190
191	switch (task->type)
192	{
193	case 1: if (FORWARD_GFX) { forward_gfx_task(); return 1; } break;
194
195	case 2:
196	if (FORWARD_AUDIO) { forward_audio_task(); return 1; }
197	else if (try_fast_audio_dispatching()) { return 1; }
198	break;
199
200	case 7: show_cfb(); return 1;
201	}
202
203	return 0;
204	}
205
206	static void normal_task_dispatching()
207	{
208	const OSTask_t * const task = get_task();
209	const unsigned int sum =
210	sum_bytes(rsp.RDRAM + task->ucode, min(task->ucode_size, 0xf80) >> 1);
211
212	switch (sum)
213	{
214	/* StoreVe12: found in Zelda Ocarina of Time [misleading task->type == 4] */
215	case 0x278: /* Nothing to emulate */ return;
216
217	/* GFX: Twintris [misleading task->type == 0] */
218	case 0x212ee:
219	if (FORWARD_GFX) { forward_gfx_task(); return; }
220	break;
221
222	/* JPEG: found in Pokemon Stadium J */
223	case 0x2c85a: jpeg_decode_PS0(); return;
224
225	/* JPEG: found in Zelda Ocarina of Time, Pokemon Stadium 1, Pokemon Stadium 2 */
226	case 0x2caa6: jpeg_decode_PS(); return;
227
228	/* JPEG: found in Ogre Battle, Bottom of the 9th */
2d262872	229	case 0x130de:
	230	case 0x278b0:
	231	jpeg_decode_OB(); return;
d9e74a6f	232	}
	233
	234	handle_unknown_task(sum);
	235	}
	236
	237	static void non_task_dispatching()
	238	{
	239	const unsigned int sum = sum_bytes(rsp.IMEM, 0x1000 >> 1);
	240
	241	switch(sum)
	242	{
	243	/* CIC x105 ucode (used during boot of CIC x105 games) */
	244	case 0x9e2: /* CIC 6105 */
	245	case 0x9f2: /* CIC 7105 */
	246	cicx105_ucode(); return;
	247	}
	248
	249	handle_unknown_non_task(sum);
	250	}
	251
	252	static void handle_unknown_task(unsigned int sum)
	253	{
	254	char filename[256];
	255	const OSTask_t * const task = get_task();
	256
	257	DebugMessage(M64MSG_WARNING, "unknown OSTask: sum %x PC:%x", sum, *rsp.SP_PC_REG);
	258
	259	sprintf(&filename[0], "task_%x.log", sum);
	260	dump_task(filename, task);
	261
	262	// dump ucode_boot
	263	sprintf(&filename[0], "ucode_boot_%x.bin", sum);
	264	dump_binary(filename, rsp.RDRAM + (task->ucode_boot & 0x7fffff), task->ucode_boot_size);
	265
	266	// dump ucode
	267	if (task->ucode != 0)
	268	{
	269	sprintf(&filename[0], "ucode_%x.bin", sum);
	270	dump_binary(filename, rsp.RDRAM + (task->ucode & 0x7fffff), 0xf80);
	271	}
	272
	273	// dump ucode_data
	274	if (task->ucode_data != 0)
	275	{
	276	sprintf(&filename[0], "ucode_data_%x.bin", sum);
	277	dump_binary(filename, rsp.RDRAM + (task->ucode_data & 0x7fffff), task->ucode_data_size);
	278	}
	279
	280	// dump data
	281	if (task->data_ptr != 0)
	282	{
	283	sprintf(&filename[0], "data_%x.bin", sum);
	284	dump_binary(filename, rsp.RDRAM + (task->data_ptr & 0x7fffff), task->data_size);
	285	}
	286	}
	287
	288	static void handle_unknown_non_task(unsigned int sum)
	289	{
	290	char filename[256];
	291
	292	DebugMessage(M64MSG_WARNING, "unknown RSP code: sum: %x PC:%x", sum, *rsp.SP_PC_REG);
	293
	294	// dump IMEM & DMEM for further analysis
	295	sprintf(&filename[0], "imem_%x.bin", sum);
296	dump_binary(filename, rsp.IMEM, 0x1000);
297
298	sprintf(&filename[0], "dmem_%x.bin", sum);
299	dump_binary(filename, rsp.DMEM, 0x1000);
300	}
301
302
303	/* Global functions */
304	void DebugMessage(int level, const char *message, ...)
305	{
306	char msgbuf[1024];
307	va_list args;
308
309	if (l_DebugCallback == NULL)
310	return;
311
312	va_start(args, message);
313	vsprintf(msgbuf, message, args);
314
315	(*l_DebugCallback)(l_DebugCallContext, level, msgbuf);
316
317	va_end(args);
318	}
319
320	/* DLL-exported functions */
321	EXPORT m64p_error CALL PluginStartup(m64p_dynlib_handle CoreLibHandle, void *Context,
322	void (DebugCallback)(void , int, const char *))
323	{
324	if (l_PluginInit)
325	return M64ERR_ALREADY_INIT;
326
327	/* first thing is to set the callback function for debug info */
328	l_DebugCallback = DebugCallback;
329	l_DebugCallContext = Context;
330
331	/* this plugin doesn't use any Core library functions (ex for Configuration), so no need to keep the CoreLibHandle */
332
333	l_PluginInit = 1;
334	return M64ERR_SUCCESS;
335	}
336
337	EXPORT m64p_error CALL PluginShutdown(void)
338	{
339	if (!l_PluginInit)
340	return M64ERR_NOT_INIT;
341
342	/* reset some local variable */
343	l_DebugCallback = NULL;
344	l_DebugCallContext = NULL;
345
346	l_PluginInit = 0;
347	return M64ERR_SUCCESS;
348	}
349
350	EXPORT m64p_error CALL PluginGetVersion(m64p_plugin_type PluginType, int PluginVersion, int APIVersion, const char PluginNamePtr, int Capabilities)
351	{
352	/* set version info */
353	if (PluginType != NULL)
354	*PluginType = M64PLUGIN_RSP;
355
356	if (PluginVersion != NULL)
357	*PluginVersion = RSP_HLE_VERSION;
358
359	if (APIVersion != NULL)
360	*APIVersion = RSP_PLUGIN_API_VERSION;
361
362	if (PluginNamePtr != NULL)
363	*PluginNamePtr = "Hacktarux/Azimer High-Level Emulation RSP Plugin";
364
365	if (Capabilities != NULL)
366	{
367	*Capabilities = 0;
368	}
369
370	return M64ERR_SUCCESS;
371	}
372
373	EXPORT unsigned int CALL DoRspCycles(unsigned int Cycles)
374	{
375	if (is_task())
376	{
377	if (!try_fast_task_dispatching()) { normal_task_dispatching(); }
378	rsp_break(RSP_STATUS_TASKDONE);
379	}
380	else
381	{
382	non_task_dispatching();
383	rsp_break(0);
384	}
385
386	return Cycles;
387	}
388
389	EXPORT void CALL InitiateRSP(RSP_INFO Rsp_Info, unsigned int *CycleCount)
390	{
391	rsp = Rsp_Info;
392	}
393
394	EXPORT void CALL RomClosed(void)
395	{
396	memset(rsp.DMEM, 0, 0x1000);
397	memset(rsp.IMEM, 0, 0x1000);
398
399	init_ucode2();
400	}
401
402
403	/* local helper functions */
404	static unsigned int sum_bytes(const unsigned char *bytes, unsigned int size)
405	{
406	unsigned int sum = 0;
407	const unsigned char * const bytes_end = bytes + size;
408
409	while (bytes != bytes_end)
410	sum += *bytes++;
411
412	return sum;
413	}
414
415
416	static void dump_binary(const char * const filename, const unsigned char * const bytes,
417	unsigned int size)
418	{
419	FILE *f;
420
421	// if file already exists, do nothing
422	f = fopen(filename, "r");
423	if (f == NULL)
424	{
425	// else we write bytes to the file
426	f= fopen(filename, "wb");
427	if (f != NULL) {
428	if (fwrite(bytes, 1, size, f) != size)
429	{
430	DebugMessage(M64MSG_ERROR, "Writing error on %s", filename);
431	}
432	fclose(f);
433	}
434	else
435	{
436	DebugMessage(M64MSG_ERROR, "Couldn't open %s for writing !", filename);
437	}
438	}
439	else
440	{
441	fclose(f);
442	}
443	}
444
445	static void dump_task(const char * const filename, const OSTask_t * const task)
446	{
447	FILE *f;
448
449	f = fopen(filename, "r");
450	if (f == NULL)
451	{
452	f = fopen(filename, "w");
453	fprintf(f,
454	"type = %d\n"
455	"flags = %d\n"
456	"ucode_boot = %#08x size = %#x\n"
457	"ucode = %#08x size = %#x\n"
458	"ucode_data = %#08x size = %#x\n"
459	"dram_stack = %#08x size = %#x\n"
460	"output_buff = %#08x *size = %#x\n"
461	"data = %#08x size = %#x\n"
462	"yield_data = %#08x size = %#x\n",
463	task->type, task->flags,
464	task->ucode_boot, task->ucode_boot_size,
465	task->ucode, task->ucode_size,
466	task->ucode_data, task->ucode_data_size,
467	task->dram_stack, task->dram_stack_size,
468	task->output_buff, task->output_buff_size,
469	task->data_ptr, task->data_size,
470	task->yield_data_ptr, task->yield_data_size);
471	fclose(f);
472	}
473	else
474	{
475	fclose(f);
476	}
477	}
478