VOID Cache_DestroyCache(APTR cache)
{
struct Cache *c = cache;
ULONG i;
Cache_Flush(c);
for(i = 0; i < c->block_count; i++)
FreeVec(c->blocks[i]);
FreeVec(c->blocks);
FreeVec(c->hash_table);
FreeVec(c);
}
static void Rulesets_OnChange_ruleset (cvar_t *var, char *value, qbool *cancel)
{
extern void Cmd_ReInitAllMacro (void);
if (cls.state != ca_disconnected) {
Com_Printf ("%s can be changed only in disconneced mode\n", var->name);
*cancel = true;
return;
}
if (strncasecmp (value, "smackdown", 9) && strncasecmp (value, "mtfl", 4) && strncasecmp (value, "default", 7)) {
Com_Printf_State (PRINT_INFO, "Unknown ruleset \"%s\"\n", value);
*cancel = true;
return;
}
// All checks passed so we can remove old ruleset and set a new one
switch (rulesetDef.ruleset) {
case rs_smackdown:
Rulesets_Smackdown (false);
break;
case rs_mtfl:
Rulesets_MTFL (false);
break;
case rs_default:
break;
default:
break;
}
// we need to mark custom textures in the memory (like for backpack and eyes) to be reloaded again
Cache_Flush ();
if (!strncasecmp (value, "smackdown", 9)) {
Rulesets_Smackdown (true);
Com_Printf_State (PRINT_OK, "Ruleset Smackdown initialized\n");
} else if (!strncasecmp (value, "mtfl", 4)) {
Rulesets_MTFL (true);
Com_Printf_State (PRINT_OK, "Ruleset MTFL initialized\n");
} else if (!strncasecmp (value, "default", 7)) {
Rulesets_Default ();
Com_Printf_State (PRINT_OK, "Ruleset default initialized\n");
} else {
Sys_Error ("OnChange_ruleset: WTF?\n");
// this will never happen
*cancel = true;
return;
}
Cmd_ReInitAllMacro ();
}
/*********************************************************************************************
* name: IISClose
* func: Close IIS circuit
* para: none
* ret: none
* modify:
* comment:
*********************************************************************************************/
void IISClose()
{
rIISCON = 0x0; // IIS stop
Cache_Flush();
/* recover Port B and Port C state */
rPDATB = 0x7ff; // P9-LED1 P10-LED2
rPCONB = 0x1cf;
rPDATC = 0xff00;
rPCONC = 0x0ff0ffff;
rPUPC = 0x30ff;
rINTMSK |= BIT_GLOBAL; // Mask interrupt
}
static void
Cache_f(void)
{
if (Cmd_Argc() == 2) {
if (!strcmp(Cmd_Argv(1), "print")) {
Cache_Print();
return;
}
if (!strcmp(Cmd_Argv(1), "flush")) {
Cache_Flush();
return;
}
}
Con_Printf("Usage: cache print|flush\n");
}
static void set_cache_and_start_app(
uint32_t drom_addr,
uint32_t drom_load_addr,
uint32_t drom_size,
uint32_t irom_addr,
uint32_t irom_load_addr,
uint32_t irom_size,
uint32_t entry_addr)
{
ESP_LOGD(TAG, "configure drom and irom and start");
Cache_Read_Disable( 0 );
Cache_Flush( 0 );
/* Clear the MMU entries that are already set up,
so the new app only has the mappings it creates.
*/
for (int i = 0; i < DPORT_FLASH_MMU_TABLE_SIZE; i++) {
DPORT_PRO_FLASH_MMU_TABLE[i] = DPORT_FLASH_MMU_TABLE_INVALID_VAL;
}
uint32_t drom_page_count = (drom_size + 64*1024 - 1) / (64*1024); // round up to 64k
ESP_LOGV(TAG, "d mmu set paddr=%08x vaddr=%08x size=%d n=%d", drom_addr & 0xffff0000, drom_load_addr & 0xffff0000, drom_size, drom_page_count );
int rc = cache_flash_mmu_set( 0, 0, drom_load_addr & 0xffff0000, drom_addr & 0xffff0000, 64, drom_page_count );
ESP_LOGV(TAG, "rc=%d", rc );
rc = cache_flash_mmu_set( 1, 0, drom_load_addr & 0xffff0000, drom_addr & 0xffff0000, 64, drom_page_count );
ESP_LOGV(TAG, "rc=%d", rc );
uint32_t irom_page_count = (irom_size + 64*1024 - 1) / (64*1024); // round up to 64k
ESP_LOGV(TAG, "i mmu set paddr=%08x vaddr=%08x size=%d n=%d", irom_addr & 0xffff0000, irom_load_addr & 0xffff0000, irom_size, irom_page_count );
rc = cache_flash_mmu_set( 0, 0, irom_load_addr & 0xffff0000, irom_addr & 0xffff0000, 64, irom_page_count );
ESP_LOGV(TAG, "rc=%d", rc );
rc = cache_flash_mmu_set( 1, 0, irom_load_addr & 0xffff0000, irom_addr & 0xffff0000, 64, irom_page_count );
ESP_LOGV(TAG, "rc=%d", rc );
DPORT_REG_CLR_BIT( DPORT_PRO_CACHE_CTRL1_REG, (DPORT_PRO_CACHE_MASK_IRAM0) | (DPORT_PRO_CACHE_MASK_IRAM1 & 0) | (DPORT_PRO_CACHE_MASK_IROM0 & 0) | DPORT_PRO_CACHE_MASK_DROM0 | DPORT_PRO_CACHE_MASK_DRAM1 );
DPORT_REG_CLR_BIT( DPORT_APP_CACHE_CTRL1_REG, (DPORT_APP_CACHE_MASK_IRAM0) | (DPORT_APP_CACHE_MASK_IRAM1 & 0) | (DPORT_APP_CACHE_MASK_IROM0 & 0) | DPORT_APP_CACHE_MASK_DROM0 | DPORT_APP_CACHE_MASK_DRAM1 );
Cache_Read_Enable( 0 );
// Application will need to do Cache_Flush(1) and Cache_Read_Enable(1)
ESP_LOGD(TAG, "start: 0x%08x", entry_addr);
typedef void (*entry_t)(void) __attribute__((noreturn));
entry_t entry = ((entry_t) entry_addr);
// TODO: we have used quite a bit of stack at this point.
// use "movsp" instruction to reset stack back to where ROM stack starts.
(*entry)();
}
static void VID_Restart_f(void)
{
extern void GFX_Init(void);
extern void ReloadPaletteAndColormap(void);
qbool old_con_suppress;
if (!host_initialized) { // sanity
Com_Printf("Can't do %s yet\n", Cmd_Argv(0));
return;
}
VID_Shutdown();
ReloadPaletteAndColormap();
// keys can get stuck because SDL2 doesn't send keyup event when the video system is down
Key_ClearStates();
VID_Init(host_basepal);
// force models to reload (just flush, no actual loading code here)
Cache_Flush();
// shut up warnings during GFX_Init();
old_con_suppress = con_suppress;
con_suppress = (developer.value ? false : true);
// reload 2D textures, particles textures, some other textures and gfx.wad
GFX_Init();
// reload skins
Skin_Skins_f();
con_suppress = old_con_suppress;
// we need done something like for map reloading, for example reload textures for brush models
R_NewMap(true);
// force all cached models to be loaded, so no short HDD lag then u walk over level and discover new model
Mod_TouchModels();
// window may be re-created, so caption need to be forced to update
CL_UpdateCaption(true);
}
static void S_Restart_f (void)
{
Com_DPrintf("Restarting sound system....\n");
Cache_Flush();
S_StopAllSounds (true);
S_Shutdown();
Com_DPrintf("sound: Shutdown OK\n");
if (!S_Startup()) {
snd_initialized = false;
return;
}
ambient_sfx[AMBIENT_WATER] = S_PrecacheSound ("ambience/water1.wav");
ambient_sfx[AMBIENT_SKY] = S_PrecacheSound ("ambience/wind2.wav");
S_StopAllSounds (true);
if (developer.value)
S_SoundInfo_f();
}
APTR Cache_GetBlock(APTR cache, ULONG blockNum, UBYTE **data)
{
struct Cache *c = cache;
struct BlockRange *b = NULL, *b2;
LONG error = 0, data_offset;
struct MinList *l =
&c->hash_table[(blockNum >> RANGE_SHIFT) & (c->hash_size - 1)];
struct MinNode *n;
/* Change block number to the start block of a range and get byte offset
* within range */
data_offset = (blockNum - (blockNum & ~RANGE_MASK)) * c->block_size;
blockNum &= ~RANGE_MASK;
/* Check existing valid blocks first */
ForeachNode(l, b2)
{
if(b2->num == blockNum)
b = b2;
}
if(b != NULL)
{
/* Block found, so increment its usage count and remove it from the
* free list */
if(b->use_count++ == 0)
{
if(b->state != BS_DIRTY)
Remove((struct Node *)&b->node2);
}
}
else
{
/* Get a free buffer to read block from disk */
n = (struct MinNode *)RemHead((struct List *)&c->free_list);
if(n == NULL)
{
/* No free blocks, so flush dirty list to try and free up some
* more blocks, then try again */
Cache_Flush(c);
n = (struct MinNode *)RemHead((struct List *)&c->free_list);
}
if(n != NULL)
{
b = (struct BlockRange *)NODE2(n);
/* Read the block from disk */
if(AccessDisk(FALSE, blockNum, RANGE_SIZE, c->block_size,
b->data, c->priv) == 0)
{
/* Remove block from its old position in the hash */
if(b->state == BS_VALID)
Remove((struct Node *)b);
/* Add it to the hash at the new location */
AddHead((struct List *)l, (struct Node *)&b->node1);
b->num = blockNum;
b->state = BS_VALID;
b->use_count = 1;
}
else
{
/* Read failed, so put the block back on the free list */
b->state = BS_EMPTY;
AddHead((struct List *)&c->free_list,
(struct Node *)&b->node2);
b = NULL;
error = ERROR_UNKNOWN;
}
}
else
error = ERROR_NO_FREE_STORE;
}
/* Set data pointer and error, and return cache block handle */
*data = b ? (b->data + data_offset) : NULL;
SetIoErr(error);
return b;
}
/*
==================
Host_Game_f
==================
*/
void Host_Game_f (void)
{
int i;
unsigned int path_id;
searchpath_t *search = com_searchpaths;
pack_t *pak;
char pakfile[MAX_OSPATH]; //FIXME: it's confusing to use this string for two different things
if (Cmd_Argc() > 1)
{
if (!registered.value) //disable command for shareware quake
{
Con_Printf("You must have the registered version to use modified games\n");
return;
}
if (strstr(Cmd_Argv(1), ".."))
{
Con_Printf ("Relative pathnames are not allowed.\n");
return;
}
q_strlcpy (pakfile, va("%s/%s", host_parms->basedir, Cmd_Argv(1)), sizeof(pakfile));
if (!Q_strcasecmp(pakfile, com_gamedir)) //no change
{
Con_Printf("\"game\" is already \"%s\"\n", COM_SkipPath(com_gamedir));
return;
}
com_modified = true;
//Kill the server
CL_Disconnect ();
Host_ShutdownServer(true);
//Write config file
Host_WriteConfiguration ();
//Kill the extra game if it is loaded
if (NumGames(com_searchpaths) > 1 + com_nummissionpacks)
KillGameDir(com_searchpaths);
q_strlcpy (com_gamedir, pakfile, sizeof(com_gamedir));
if (Q_strcasecmp(Cmd_Argv(1), GAMENAME)) //game is not id1
{
// assign a path_id to this game directory
if (com_searchpaths)
path_id = com_searchpaths->path_id << 1;
else path_id = 1U;
search = (searchpath_t *) Z_Malloc(sizeof(searchpath_t));
search->path_id = path_id;
q_strlcpy (search->filename, pakfile, sizeof(search->filename));
search->next = com_searchpaths;
com_searchpaths = search;
//Load the paks if any are found:
for (i = 0; ; i++)
{
q_snprintf (pakfile, sizeof(pakfile), "%s/pak%i.pak", com_gamedir, i);
pak = COM_LoadPackFile (pakfile);
if (!pak)
break;
search = (searchpath_t *) Z_Malloc(sizeof(searchpath_t));
search->path_id = path_id;
search->pack = pak;
search->next = com_searchpaths;
com_searchpaths = search;
}
}
//clear out and reload appropriate data
Cache_Flush ();
if (!isDedicated)
{
TexMgr_NewGame ();
Draw_NewGame ();
R_NewGame ();
}
ExtraMaps_NewGame ();
//Cbuf_InsertText ("exec quake.rc\n");
Con_Printf("\"game\" changed to \"%s\"\n", COM_SkipPath(com_gamedir));
}
else //Diplay the current gamedir
Con_Printf("\"game\" is \"%s\"\n", COM_SkipPath(com_gamedir));
}
