Sprinter/mame
2
0
Fork 0
mirror of https://github.com/holub/mame synced 2025-05-29 17:13:05 +03:00
Code Issues Actions Packages Projects Releases Wiki Activity

Cleanups and version bump.

Browse Source
This commit is contained in:
Aaron Giles 2009-11-30 01:46:32 +00:00
parent 6967cdf013
commit b5c3081f3e
153 changed files with 748 additions and 748 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
src/emu/audio/generic.c
View File

@ -39,7 +39,7 @@ struct _generic_audio_private
int generic_sound_init(running_machine *machine) int generic_sound_init(running_machine *machine)
{ {
generic_audio_private *state; generic_audio_private *state;
state = machine->generic_audio_data = auto_alloc_clear(machine, generic_audio_private); state = machine->generic_audio_data = auto_alloc_clear(machine, generic_audio_private);
/* register globals with the save state system */ /* register globals with the save state system */

2
src/emu/cpu/i8008/i8008.c
View File

@ -377,7 +377,7 @@ static void execute_one(i8008_state *cpustate, int opcode)
case 6 : // LrI case 6 : // LrI
cpustate->icount -= 8; cpustate->icount -= 8;
if (REG_1==7) cpustate->icount -= 1; // LMI if (REG_1==7) cpustate->icount -= 1; // LMI
SET_REG(cpustate,REG_1, ARG(cpustate)); SET_REG(cpustate,REG_1, ARG(cpustate));
break; break;
case 7 : // RET case 7 : // RET
cpustate->icount -= 5; cpustate->icount -= 5;

10
src/emu/devintrf.c
View File

@ -88,7 +88,7 @@ INLINE int device_matches_type(const device_config *device, device_type type)
***************************************************************************/ ***************************************************************************/
/*------------------------------------------------- /*-------------------------------------------------
device_list_init - initialize a device list device_list_init - initialize a device list
structure, optionally allocating a map for it structure, optionally allocating a map for it
-------------------------------------------------*/ -------------------------------------------------*/
@ -107,7 +107,7 @@ void device_list_init(device_list *devlist, int allocmap)
/*------------------------------------------------- /*-------------------------------------------------
device_list_deinit - free memory attached to device_list_deinit - free memory attached to
a device list and clear out the structure a device list and clear out the structure
-------------------------------------------------*/ -------------------------------------------------*/
@ -116,7 +116,7 @@ void device_list_deinit(device_list *devlist)
/* release all devices */ /* release all devices */
while (devlist->head != NULL) while (devlist->head != NULL)
device_list_remove(devlist, devlist->head->tag); device_list_remove(devlist, devlist->head->tag);
/* release the map memory */ /* release the map memory */
if (devlist->map != NULL) if (devlist->map != NULL)
tagmap_free(devlist->map); tagmap_free(devlist->map);
@ -148,7 +148,7 @@ device_config *device_list_add(device_list *devlist, const device_config *owner,
/* allocate a new device */ /* allocate a new device */
device = (device_config *)alloc_array_or_die(UINT8, sizeof(*device) + strlen(tag) + configlen); device = (device_config *)alloc_array_or_die(UINT8, sizeof(*device) + strlen(tag) + configlen);
/* add to the map */ /* add to the map */
tmerr = tagmap_add_unique_hash(devlist->map, tag, device); tmerr = tagmap_add_unique_hash(devlist->map, tag, device);
if (tmerr == TMERR_DUPLICATE) if (tmerr == TMERR_DUPLICATE)
@ -391,7 +391,7 @@ const device_config *device_list_next(const device_config *prevdevice, device_ty
/*------------------------------------------------- /*-------------------------------------------------
device_list_find_by_tag_slow - retrieve a device_list_find_by_tag_slow - retrieve a
device configuration based on a tag device configuration based on a tag
-------------------------------------------------*/ -------------------------------------------------*/

4
src/emu/devintrf.h
View File

@ -347,10 +347,10 @@ struct _device_list
/* ----- device configuration ----- */ /* ----- device configuration ----- */
/* initialize a device list structure, optionally allocating a map for it */ /* initialize a device list structure, optionally allocating a map for it */
void device_list_init(device_list *devlist, int allocmap); void device_list_init(device_list *devlist, int allocmap);
/* free memory attached to a device list and clear out the structure */ /* free memory attached to a device list and clear out the structure */
void device_list_deinit(device_list *devlist); void device_list_deinit(device_list *devlist);
/* add a new device to the end of a device list */ /* add a new device to the end of a device list */
device_config *device_list_add(device_list *devlist, const device_config *owner, device_type type, const char *tag, UINT32 clock); device_config *device_list_add(device_list *devlist, const device_config *owner, device_type type, const char *tag, UINT32 clock);

14
src/emu/inptport.c
View File

@ -250,7 +250,7 @@ struct _input_port_private
{ {
/* global state */ /* global state */
UINT8 safe_to_read; /* clear at start; set after state is loaded */ UINT8 safe_to_read; /* clear at start; set after state is loaded */
/* types */ /* types */
input_type_state * typestatelist; /* list of live type states */ input_type_state * typestatelist; /* list of live type states */
input_type_state * type_to_typestate[__ipt_max][MAX_PLAYERS]; /* map from type/player to type state */ input_type_state * type_to_typestate[__ipt_max][MAX_PLAYERS]; /* map from type/player to type state */
@ -743,7 +743,7 @@ void input_port_list_deinit(input_port_list *portlist)
/* iterate over all ports and free them */ /* iterate over all ports and free them */
while (portlist->head != NULL) while (portlist->head != NULL)
port_config_free(&portlist->head); port_config_free(&portlist->head);
/* free the map if present */ /* free the map if present */
if (portlist->map != NULL) if (portlist->map != NULL)
tagmap_free(portlist->map); tagmap_free(portlist->map);
@ -752,8 +752,8 @@ void input_port_list_deinit(input_port_list *portlist)
/*------------------------------------------------- /*-------------------------------------------------
input_port_by_tag_slow - return a pointer to input_port_by_tag_slow - return a pointer to
the port_config associated with the given the port_config associated with the given
port tag port tag
-------------------------------------------------*/ -------------------------------------------------*/
@ -1463,7 +1463,7 @@ static INT32 apply_analog_settings(INT32 value, analog_field_state *analog)
/*------------------------------------------------- /*-------------------------------------------------
input_port_write_direct - write a value input_port_write_direct - write a value
to a port to a port
-------------------------------------------------*/ -------------------------------------------------*/
void input_port_write_direct(const input_port_config *port, input_port_value data, input_port_value mem_mask) void input_port_write_direct(const input_port_config *port, input_port_value data, input_port_value mem_mask)
@ -1491,7 +1491,7 @@ void input_port_write_direct(const input_port_config *port, input_port_value dat
/*------------------------------------------------- /*-------------------------------------------------
input_port_write - write a value to a input_port_write - write a value to a
port specified by tag port specified by tag
-------------------------------------------------*/ -------------------------------------------------*/
void input_port_write(running_machine *machine, const char *tag, input_port_value value, input_port_value mask) void input_port_write(running_machine *machine, const char *tag, input_port_value value, input_port_value mask)
@ -1505,7 +1505,7 @@ void input_port_write(running_machine *machine, const char *tag, input_port_valu
/*------------------------------------------------- /*-------------------------------------------------
input_port_write_safe - write a value to input_port_write_safe - write a value to
a port, ignore if the port does not exist a port, ignore if the port does not exist
-------------------------------------------------*/ -------------------------------------------------*/
void input_port_write_safe(running_machine *machine, const char *tag, input_port_value value, input_port_value mask) void input_port_write_safe(running_machine *machine, const char *tag, input_port_value value, input_port_value mask)

4
src/emu/inptport.h
View File

@ -1152,7 +1152,7 @@ const char *input_port_string_from_token(const input_port_token token);
***************************************************************************/ ***************************************************************************/
/*------------------------------------------------- /*-------------------------------------------------
input_port_by_tag - return the config that input_port_by_tag - return the config that
matches the given tag matches the given tag
-------------------------------------------------*/ -------------------------------------------------*/
@ -1161,7 +1161,7 @@ INLINE const input_port_config *input_port_by_tag(const input_port_list *portlis
/* use the map if we have it */ /* use the map if we have it */
if (portlist->map != NULL) if (portlist->map != NULL)
return tagmap_find_hash_only(portlist->map, tag); return tagmap_find_hash_only(portlist->map, tag);
/* otherwise, do it the slow way */ /* otherwise, do it the slow way */
return input_port_by_tag_slow(portlist, tag); return input_port_by_tag_slow(portlist, tag);
} }

10
src/emu/machine/generic.c
View File

@ -77,7 +77,7 @@ void generic_machine_init(running_machine *machine)
{ {
generic_machine_private *state; generic_machine_private *state;
int counternum; int counternum;
/* allocate our state */ /* allocate our state */
machine->generic_machine_data = auto_alloc_clear(machine, generic_machine_private); machine->generic_machine_data = auto_alloc_clear(machine, generic_machine_private);
state = machine->generic_machine_data; state = machine->generic_machine_data;
@ -123,7 +123,7 @@ void generic_machine_init(running_machine *machine)
***************************************************************************/ ***************************************************************************/
/*------------------------------------------------- /*-------------------------------------------------
get_dispensed_tickets - return the number of get_dispensed_tickets - return the number of
tickets dispensed tickets dispensed
-------------------------------------------------*/ -------------------------------------------------*/
@ -135,7 +135,7 @@ int get_dispensed_tickets(running_machine *machine)
/*------------------------------------------------- /*-------------------------------------------------
increment_dispensed_tickets - increment the increment_dispensed_tickets - increment the
number of dispensed tickets number of dispensed tickets
-------------------------------------------------*/ -------------------------------------------------*/
@ -245,7 +245,7 @@ void coin_counter_w(running_machine *machine, int num, int on)
/*------------------------------------------------- /*-------------------------------------------------
coin_counter_get_count - return the coin count coin_counter_get_count - return the coin count
for a given coin for a given coin
-------------------------------------------------*/ -------------------------------------------------*/
@ -272,7 +272,7 @@ void coin_lockout_w(running_machine *machine, int num,int on)
/*------------------------------------------------- /*-------------------------------------------------
coin_lockout_get_state - return current lockout coin_lockout_get_state - return current lockout
state for a particular coin state for a particular coin
-------------------------------------------------*/ -------------------------------------------------*/

2
src/emu/mame.c
View File

@ -1402,7 +1402,7 @@ static running_machine *create_machine(const game_driver *driver)
if (machine->mame_data == NULL) if (machine->mame_data == NULL)
goto error; goto error;
memset(machine->mame_data, 0, sizeof(*machine->mame_data)); memset(machine->mame_data, 0, sizeof(*machine->mame_data));
/* allocate memory for the memory region map */ /* allocate memory for the memory region map */
machine->mame_data->regionmap = tagmap_alloc(); machine->mame_data->regionmap = tagmap_alloc();
if (machine->mame_data->regionmap == NULL) if (machine->mame_data->regionmap == NULL)

2
src/emu/mame.h
View File

@ -211,7 +211,7 @@ struct _running_machine
/* debugger-related information */ /* debugger-related information */
UINT32 debug_flags; /* the current debug flags */ UINT32 debug_flags; /* the current debug flags */
/* generic pointers */ /* generic pointers */
generic_pointers generic; /* generic pointers */ generic_pointers generic; /* generic pointers */

2
src/emu/mconfig.c
View File

@ -70,7 +70,7 @@ machine_config *machine_config_alloc(const machine_config_token *tokens)
/* allocate a new configuration object */ /* allocate a new configuration object */
config = alloc_clear_or_die(machine_config); config = alloc_clear_or_die(machine_config);
/* initialize the device list */ /* initialize the device list */
device_list_init(&config->devicelist, TRUE); device_list_init(&config->devicelist, TRUE);

2
src/emu/sound/cdp1869.c
View File

@ -8,7 +8,7 @@
TODO: TODO:
- remove CDP1802 dependency - remove CDP1802 dependency
- white noise - white noise
- scanline based update - scanline based update
- CMSEL output - CMSEL output

8
src/emu/streams.c
View File

@ -939,22 +939,22 @@ static stream_sample_t *generate_resampled_data(stream_input *input, UINT32 nums
while (numsamples != 0) while (numsamples != 0)
{ {
int nextfrac, startfrac, endfrac; int nextfrac, startfrac, endfrac;
/* fill in with point samples until we hit a boundary */ /* fill in with point samples until we hit a boundary */
while ((nextfrac = basefrac + step) < FRAC_ONE && numsamples--) while ((nextfrac = basefrac + step) < FRAC_ONE && numsamples--)
{ {
*dest++ = (source[0] * gain) >> 8; *dest++ = (source[0] * gain) >> 8;
basefrac = nextfrac; basefrac = nextfrac;
} }
/* if we're done, we're done */ /* if we're done, we're done */
if ((INT32)numsamples-- < 0) if ((INT32)numsamples-- < 0)
break; break;
/* compute starting and ending fractional positions */ /* compute starting and ending fractional positions */
startfrac = basefrac >> (FRAC_BITS - 12); startfrac = basefrac >> (FRAC_BITS - 12);
endfrac = nextfrac >> (FRAC_BITS - 12); endfrac = nextfrac >> (FRAC_BITS - 12);
/* blend between the two samples accordingly */ /* blend between the two samples accordingly */
sample = (source[0] * (0x1000 - startfrac) + source[1] * (endfrac - 0x1000)) / (endfrac - startfrac); sample = (source[0] * (0x1000 - startfrac) + source[1] * (endfrac - 0x1000)) / (endfrac - startfrac);
*dest++ = (sample * gain) >> 8; *dest++ = (sample * gain) >> 8;

2
src/emu/uimenu.c
View File

@ -2431,7 +2431,7 @@ static void menu_bookkeeping_populate(running_machine *machine, ui_menu *menu, a
for (ctrnum = 0; ctrnum < COIN_COUNTERS; ctrnum++) for (ctrnum = 0; ctrnum < COIN_COUNTERS; ctrnum++)
{ {
int count = coin_counter_get_count(machine, ctrnum); int count = coin_counter_get_count(machine, ctrnum);
/* display the coin counter number */ /* display the coin counter number */
astring_catprintf(tempstring, "Coin %c: ", ctrnum + 'A'); astring_catprintf(tempstring, "Coin %c: ", ctrnum + 'A');

8
src/emu/validity.c
View File

@ -326,7 +326,7 @@ static int validate_driver(int drivnum, const machine_config *config, tagmap *na
mame_printf_error("%s: %s is a duplicate name (%s, %s)\n", driver->source_file, driver->name, match->source_file, match->name); mame_printf_error("%s: %s is a duplicate name (%s, %s)\n", driver->source_file, driver->name, match->source_file, match->name);
error = TRUE; error = TRUE;
} }
/* check for duplicate descriptions */ /* check for duplicate descriptions */
if (tagmap_add(descriptions, driver->description, (void *)driver) == TMERR_DUPLICATE) if (tagmap_add(descriptions, driver->description, (void *)driver) == TMERR_DUPLICATE)
{ {
@ -1058,7 +1058,7 @@ static int validate_inputs(int drivnum, const machine_config *config, tagmap *de
mame_printf_error("%s: %s has input port errors:\n%s\n", driver->source_file, driver->name, errorbuf); mame_printf_error("%s: %s has input port errors:\n%s\n", driver->source_file, driver->name, errorbuf);
error = TRUE; error = TRUE;
} }
/* check for duplicate tags */ /* check for duplicate tags */
for (port = portlist->head; port != NULL; port = port->next) for (port = portlist->head; port != NULL; port = port->next)
if (port->tag != NULL) if (port->tag != NULL)
@ -1420,7 +1420,7 @@ int mame_validitychecks(const game_driver *curdriver)
int error = FALSE; int error = FALSE;
UINT16 lsbtest; UINT16 lsbtest;
UINT8 a, b; UINT8 a, b;
tagmap *names = tagmap_alloc(); tagmap *names = tagmap_alloc();
tagmap *descriptions = tagmap_alloc(); tagmap *descriptions = tagmap_alloc();
tagmap *roms = tagmap_alloc(); tagmap *roms = tagmap_alloc();
@ -1472,7 +1472,7 @@ int mame_validitychecks(const game_driver *curdriver)
tagmap_add(defstr, string, (void *)(FPTR)strnum); tagmap_add(defstr, string, (void *)(FPTR)strnum);
} }
prep += get_profile_ticks(); prep += get_profile_ticks();
/* iterate over all drivers */ /* iterate over all drivers */
for (drivnum = 0; drivers[drivnum]; drivnum++) for (drivnum = 0; drivers[drivnum]; drivnum++)
{ {

2
src/emu/video/generic.c
View File

@ -231,7 +231,7 @@ INLINE void set_color_888(running_machine *machine, pen_t color, int rshift, int
void generic_video_init(running_machine *machine) void generic_video_init(running_machine *machine)
{ {
generic_video_private *state; generic_video_private *state;
state = machine->generic_video_data = auto_alloc_clear(machine, generic_video_private); state = machine->generic_video_data = auto_alloc_clear(machine, generic_video_private);
state_save_register_item(machine, "video", NULL, 0, state->flip_screen_x); state_save_register_item(machine, "video", NULL, 0, state->flip_screen_x);

14
src/lib/util/tagmap.c
View File

@ -66,7 +66,7 @@ tagmap *tagmap_alloc(void)
/*------------------------------------------------- /*-------------------------------------------------
tagmap_free - free a tagmap, and all tagmap_free - free a tagmap, and all
entries within it entries within it
-------------------------------------------------*/ -------------------------------------------------*/
@ -78,14 +78,14 @@ void tagmap_free(tagmap *map)
/*------------------------------------------------- /*-------------------------------------------------
tagmap_reset - reset a tagmap by freeing tagmap_reset - reset a tagmap by freeing
all entries all entries
-------------------------------------------------*/ -------------------------------------------------*/
void tagmap_reset(tagmap *map) void tagmap_reset(tagmap *map)
{ {
UINT32 hashindex; UINT32 hashindex;
for (hashindex = 0; hashindex < ARRAY_LENGTH(map->table); hashindex++) for (hashindex = 0; hashindex < ARRAY_LENGTH(map->table); hashindex++)
{ {
tagmap_entry *entry, *next; tagmap_entry *entry, *next;
@ -116,7 +116,7 @@ tagmap_error tagmap_add(tagmap *map, const char *tag, void *object)
/*------------------------------------------------- /*-------------------------------------------------
tagmap_add_unique_hash - add a new entry to a tagmap_add_unique_hash - add a new entry to a
tagmap, ensuring it has a unique hash value tagmap, ensuring it has a unique hash value
-------------------------------------------------*/ -------------------------------------------------*/
@ -135,7 +135,7 @@ void tagmap_remove(tagmap *map, const char *tag)
{ {
UINT32 fullhash = tagmap_hash(tag); UINT32 fullhash = tagmap_hash(tag);
tagmap_entry **entryptr; tagmap_entry **entryptr;
for (entryptr = &map->table[fullhash % ARRAY_LENGTH(map->table)]; *entryptr != NULL; entryptr = &(*entryptr)->next) for (entryptr = &map->table[fullhash % ARRAY_LENGTH(map->table)]; *entryptr != NULL; entryptr = &(*entryptr)->next)
if ((*entryptr)->fullhash == fullhash && strcmp((*entryptr)->tag, tag) == 0) if ((*entryptr)->fullhash == fullhash && strcmp((*entryptr)->tag, tag) == 0)
{ {
@ -170,7 +170,7 @@ static tagmap_error tagmap_add_common(tagmap *map, const char *tag, void *object
/* if we require a unique hash, fail here */ /* if we require a unique hash, fail here */
if (unique_hash) if (unique_hash)
return TMERR_DUPLICATE; return TMERR_DUPLICATE;
/* validate the string */ /* validate the string */
if (strcmp(tag, entry->tag) == 0) if (strcmp(tag, entry->tag) == 0)
return TMERR_DUPLICATE; return TMERR_DUPLICATE;
@ -180,7 +180,7 @@ static tagmap_error tagmap_add_common(tagmap *map, const char *tag, void *object
entry = malloc(sizeof(*entry) + strlen(tag)); entry = malloc(sizeof(*entry) + strlen(tag));
if (entry == NULL) if (entry == NULL)
return TMERR_OUT_OF_MEMORY; return TMERR_OUT_OF_MEMORY;
/* fill in the entry */ /* fill in the entry */
entry->object = object; entry->object = object;
entry->fullhash = fullhash; entry->fullhash = fullhash;

12
src/lib/util/tagmap.h
View File

@ -127,7 +127,7 @@ INLINE UINT32 tagmap_hash(const char *string)
{ {
UINT32 hash = (string[0] << 5) + string[1]; UINT32 hash = (string[0] << 5) + string[1];
char c; char c;
string += 2; string += 2;
while ((c = *string++) != 0) while ((c = *string++) != 0)
hash = ((hash << 5) | (hash >> 27)) + c; hash = ((hash << 5) | (hash >> 27)) + c;
@ -136,7 +136,7 @@ INLINE UINT32 tagmap_hash(const char *string)
/*------------------------------------------------- /*-------------------------------------------------
tagmap_find_prehashed - find an object tagmap_find_prehashed - find an object
associated with a tag, given the tag's associated with a tag, given the tag's
hash hash
-------------------------------------------------*/ -------------------------------------------------*/
@ -144,7 +144,7 @@ INLINE UINT32 tagmap_hash(const char *string)
INLINE void *tagmap_find_prehashed(tagmap *map, const char *tag, UINT32 fullhash) INLINE void *tagmap_find_prehashed(tagmap *map, const char *tag, UINT32 fullhash)
{ {
tagmap_entry *entry; tagmap_entry *entry;
for (entry = map->table[fullhash % ARRAY_LENGTH(map->table)]; entry != NULL; entry = entry->next) for (entry = map->table[fullhash % ARRAY_LENGTH(map->table)]; entry != NULL; entry = entry->next)
if (entry->fullhash == fullhash && strcmp(entry->tag, tag) == 0) if (entry->fullhash == fullhash && strcmp(entry->tag, tag) == 0)
return entry->object; return entry->object;
@ -153,7 +153,7 @@ INLINE void *tagmap_find_prehashed(tagmap *map, const char *tag, UINT32 fullhash
/*------------------------------------------------- /*-------------------------------------------------
tagmap_find - find an object associated tagmap_find - find an object associated
with a tag with a tag
-------------------------------------------------*/ -------------------------------------------------*/
@ -164,7 +164,7 @@ INLINE void *tagmap_find(tagmap *map, const char *tag)
/*------------------------------------------------- /*-------------------------------------------------
tagmap_find_hash_only - find an object tagmap_find_hash_only - find an object
associated with a tag using only the hash; associated with a tag using only the hash;
this generally works well but may occasionally this generally works well but may occasionally
return a false positive return a false positive
@ -174,7 +174,7 @@ INLINE void *tagmap_find_hash_only(tagmap *map, const char *tag)
{ {
UINT32 fullhash = tagmap_hash(tag); UINT32 fullhash = tagmap_hash(tag);
tagmap_entry *entry; tagmap_entry *entry;
for (entry = map->table[fullhash % ARRAY_LENGTH(map->table)]; entry != NULL; entry = entry->next) for (entry = map->table[fullhash % ARRAY_LENGTH(map->table)]; entry != NULL; entry = entry->next)
if (entry->fullhash == fullhash) if (entry->fullhash == fullhash)
return entry->object; return entry->object;

2
src/mame/drivers/1945kiii.c
View File

@ -67,7 +67,7 @@ struct _k3_state
UINT16 * spriteram_1; UINT16 * spriteram_1;
UINT16 * spriteram_2; UINT16 * spriteram_2;
UINT16 * bgram; UINT16 * bgram;
// UINT16 * paletteram16; // currently this uses generic palette handling // UINT16 * paletteram16; // currently this uses generic palette handling
/* video-related */ /* video-related */
tilemap *bg_tilemap; tilemap *bg_tilemap;

6
src/mame/drivers/2mindril.c
View File

@ -68,7 +68,7 @@ struct __2mindril_state
UINT16 * charram; UINT16 * charram;
UINT16 * textram; UINT16 * textram;
UINT16 * unkram; UINT16 * unkram;
// UINT16 * paletteram; // currently this uses generic palette handling // UINT16 * paletteram; // currently this uses generic palette handling
UINT16 * iodata; UINT16 * iodata;
/* input-related */ /* input-related */
@ -120,7 +120,7 @@ static VIDEO_UPDATE( drill )
} }
} }
/*printf("%.4X %.4X %.4X %.4X %.4X %.4X\n", state->unkram[0x60000 / 2], state->unkram[0x60000 / 2 + 1], state->unkram[0x60000 / 2 + 2], /*printf("%.4X %.4X %.4X %.4X %.4X %.4X\n", state->unkram[0x60000 / 2], state->unkram[0x60000 / 2 + 1], state->unkram[0x60000 / 2 + 2],
state->unkram[0x60000 / 2 + 3], state->unkram[0x60000 / 2 + 4], state->unkram[0x60000 / 2 + 5]);*/ state->unkram[0x60000 / 2 + 3], state->unkram[0x60000 / 2 + 4], state->unkram[0x60000 / 2 + 5]);*/
return 0; return 0;
} }
@ -138,7 +138,7 @@ static READ16_HANDLER( drill_io_r )
// if (offset * 2 == 0x4) // if (offset * 2 == 0x4)
/*popmessage("PC=%08x %04x %04x %04x %04x %04x %04x %04x %04x", cpu_get_pc(space->cpu), state->iodata[0/2], state->iodata[2/2], state->iodata[4/2], state->iodata[6/2], /*popmessage("PC=%08x %04x %04x %04x %04x %04x %04x %04x %04x", cpu_get_pc(space->cpu), state->iodata[0/2], state->iodata[2/2], state->iodata[4/2], state->iodata[6/2],
state->iodata[8/2], state->iodata[0xa/2], state->iodata[0xc/2], state->iodata[0xe/2]);*/ state->iodata[8/2], state->iodata[0xa/2], state->iodata[0xc/2], state->iodata[0xe/2]);*/
switch(offset) switch(offset)
{ {

8
src/mame/drivers/actfancr.c
View File

@ -582,10 +582,10 @@ static READ8_HANDLER( cycle_r )
int pc = cpu_get_pc(space->cpu); int pc = cpu_get_pc(space->cpu);
int ret = state->main_ram[0x26]; int ret = state->main_ram[0x26];
if (offset == 1) if (offset == 1)
return state->main_ram[0x27]; return state->main_ram[0x27];
if (pc == 0xe29a && ret == 0) if (pc == 0xe29a && ret == 0)
{ {
cpu_spinuntil_int(space->cpu); cpu_spinuntil_int(space->cpu);
return 1; return 1;
@ -600,10 +600,10 @@ static READ8_HANDLER( cyclej_r )
int pc = cpu_get_pc(space->cpu); int pc = cpu_get_pc(space->cpu);
int ret = state->main_ram[0x26]; int ret = state->main_ram[0x26];
if (offset == 1) if (offset == 1)
return state->main_ram[0x27]; return state->main_ram[0x27];
if (pc == 0xe2b1 && ret == 0) if (pc == 0xe2b1 && ret == 0)
{ {
cpu_spinuntil_int(space->cpu); cpu_spinuntil_int(space->cpu);
return 1; return 1;

8
src/mame/drivers/albazg.c
View File

@ -68,8 +68,8 @@ struct _albazg_state
UINT8 * cus_ram; UINT8 * cus_ram;
UINT8 * videoram; UINT8 * videoram;
UINT8 * colorram; UINT8 * colorram;
// UINT8 * paletteram; // currently this uses generic palette handling // UINT8 * paletteram; // currently this uses generic palette handling
// UINT8 * paletteram_2; // currently this uses generic palette handling // UINT8 * paletteram_2; // currently this uses generic palette handling
/* video-related */ /* video-related */
tilemap *bg_tilemap; tilemap *bg_tilemap;
@ -154,7 +154,7 @@ static WRITE8_HANDLER( custom_ram_w )
{ {
albazg_state *state = (albazg_state *)space->machine->driver_data; albazg_state *state = (albazg_state *)space->machine->driver_data;
// logerror("Custom RAM write at %02x : %02x PC = %x\n", offset + 0xaf80, data, cpu_get_pc(space->cpu)); // logerror("Custom RAM write at %02x : %02x PC = %x\n", offset + 0xaf80, data, cpu_get_pc(space->cpu));
if(state->prot_lock) if(state->prot_lock)
state->cus_ram[offset] = data; state->cus_ram[offset] = data;
} }
@ -192,7 +192,7 @@ static WRITE8_DEVICE_HANDLER( mux_w )
//0x12000 gameplay //0x12000 gameplay
//0x14000 bonus game //0x14000 bonus game
//0x16000 ? //0x16000 ?
if( state->bank != new_bank) if( state->bank != new_bank)
{ {
state->bank = new_bank; state->bank = new_bank;
memory_set_bank(device->machine, 1, state->bank); memory_set_bank(device->machine, 1, state->bank);

6
src/mame/drivers/angelkds.c
View File

@ -753,16 +753,16 @@ ROM_END
static DRIVER_INIT( angelkds ) static DRIVER_INIT( angelkds )
{ {
UINT8 *RAM = memory_region(machine, "user1"); UINT8 *RAM = memory_region(machine, "user1");
memory_configure_bank(machine, 1, 0, 8, &RAM[0x0000], 0x4000); memory_configure_bank(machine, 1, 0, 8, &RAM[0x0000], 0x4000);
} }
static DRIVER_INIT( spcpostn ) static DRIVER_INIT( spcpostn )
{ {
UINT8 *RAM = memory_region(machine, "user1"); UINT8 *RAM = memory_region(machine, "user1");
spcpostn_decode(machine, "maincpu"); spcpostn_decode(machine, "maincpu");
memory_configure_bank(machine, 1, 0, 10, &RAM[0x0000], 0x4000); memory_configure_bank(machine, 1, 0, 10, &RAM[0x0000], 0x4000);
} }

52
src/mame/drivers/armedf.c
View File

@ -493,12 +493,12 @@ static INPUT_PORTS_START( armedf )
PORT_DIPSETTING( 0x01, "5" ) PORT_DIPSETTING( 0x01, "5" )
PORT_DIPSETTING( 0x00, "6" ) PORT_DIPSETTING( 0x00, "6" )
/* SW1:3,4 defined in manual/test-mode as: /* SW1:3,4 defined in manual/test-mode as:
PORT_DIPNAME( 0x04, 0x04, "1st Bonus Life" ) PORT_DIPLOCATION("SW1:3") PORT_DIPNAME( 0x04, 0x04, "1st Bonus Life" ) PORT_DIPLOCATION("SW1:3")
PORT_DIPSETTING( 0x04, "20k" ) PORT_DIPSETTING( 0x04, "20k" )
PORT_DIPSETTING( 0x00, "40k" ) PORT_DIPSETTING( 0x00, "40k" )
PORT_DIPNAME( 0x08, 0x08, "2nd Bonus Life" ) PORT_DIPLOCATION("SW1:4") PORT_DIPNAME( 0x08, 0x08, "2nd Bonus Life" ) PORT_DIPLOCATION("SW1:4")
PORT_DIPSETTING( 0x08, "60k" ) PORT_DIPSETTING( 0x08, "60k" )
PORT_DIPSETTING( 0x00, "80k" )*/ PORT_DIPSETTING( 0x00, "80k" )*/
PORT_DIPNAME( 0x0c, 0x0c, DEF_STR( Bonus_Life ) ) PORT_DIPLOCATION("SW1:3,4") PORT_DIPNAME( 0x0c, 0x0c, DEF_STR( Bonus_Life ) ) PORT_DIPLOCATION("SW1:3,4")
PORT_DIPSETTING( 0x0c, "20k then every 60k" ) PORT_DIPSETTING( 0x0c, "20k then every 60k" )
PORT_DIPSETTING( 0x04, "20k then every 80k" ) PORT_DIPSETTING( 0x04, "20k then every 80k" )
@ -586,12 +586,12 @@ static INPUT_PORTS_START( terraf )
PORT_MODIFY("DSW1") PORT_MODIFY("DSW1")
/* SW1:3,4 defined in manual/test-mode as: /* SW1:3,4 defined in manual/test-mode as:
PORT_DIPNAME( 0x04, 0x04, "1st Bonus Life" ) PORT_DIPLOCATION("SW1:3") PORT_DIPNAME( 0x04, 0x04, "1st Bonus Life" ) PORT_DIPLOCATION("SW1:3")
PORT_DIPSETTING( 0x04, "20k" ) PORT_DIPSETTING( 0x04, "20k" )
PORT_DIPSETTING( 0x00, "50k" ) PORT_DIPSETTING( 0x00, "50k" )
PORT_DIPNAME( 0x08, 0x08, "2nd Bonus Life" ) PORT_DIPLOCATION("SW1:4") PORT_DIPNAME( 0x08, 0x08, "2nd Bonus Life" ) PORT_DIPLOCATION("SW1:4")
PORT_DIPSETTING( 0x08, "60k" ) PORT_DIPSETTING( 0x08, "60k" )
PORT_DIPSETTING( 0x00, "90k" )*/ PORT_DIPSETTING( 0x00, "90k" )*/
PORT_DIPNAME( 0x0c, 0x0c, DEF_STR( Bonus_Life ) ) PORT_DIPLOCATION("SW1:3,4") PORT_DIPNAME( 0x0c, 0x0c, DEF_STR( Bonus_Life ) ) PORT_DIPLOCATION("SW1:3,4")
PORT_DIPSETTING( 0x0c, "20k then every 60k" ) PORT_DIPSETTING( 0x0c, "20k then every 60k" )
PORT_DIPSETTING( 0x04, "20k then every 90k" ) PORT_DIPSETTING( 0x04, "20k then every 90k" )
@ -619,12 +619,12 @@ static INPUT_PORTS_START( kodure )
PORT_MODIFY("DSW1") PORT_MODIFY("DSW1")
/* SW1:3,4 defined in manual/test-mode as: /* SW1:3,4 defined in manual/test-mode as:
PORT_DIPNAME( 0x04, 0x04, "1st Bonus Life" ) PORT_DIPLOCATION("SW1:3") PORT_DIPNAME( 0x04, 0x04, "1st Bonus Life" ) PORT_DIPLOCATION("SW1:3")
PORT_DIPSETTING( 0x04, DEF_STR( None ) ) PORT_DIPSETTING( 0x04, DEF_STR( None ) )
PORT_DIPSETTING( 0x00, "50k" ) PORT_DIPSETTING( 0x00, "50k" )
PORT_DIPNAME( 0x08, 0x08, "2nd Bonus Life" ) PORT_DIPLOCATION("SW1:4") PORT_DIPNAME( 0x08, 0x08, "2nd Bonus Life" ) PORT_DIPLOCATION("SW1:4")
PORT_DIPSETTING( 0x08, "60k" ) PORT_DIPSETTING( 0x08, "60k" )
PORT_DIPSETTING( 0x00, "90k" )*/ PORT_DIPSETTING( 0x00, "90k" )*/
PORT_DIPNAME( 0x0c, 0x0c, DEF_STR( Bonus_Life ) ) PORT_DIPLOCATION("SW1:3,4") PORT_DIPNAME( 0x0c, 0x0c, DEF_STR( Bonus_Life ) ) PORT_DIPLOCATION("SW1:3,4")
PORT_DIPSETTING( 0x08, "50k then every 60k" ) PORT_DIPSETTING( 0x08, "50k then every 60k" )
PORT_DIPSETTING( 0x00, "50k then every 90k" ) PORT_DIPSETTING( 0x00, "50k then every 90k" )
@ -671,12 +671,12 @@ static INPUT_PORTS_START( cclimbr2 )
PORT_MODIFY("DSW1") PORT_MODIFY("DSW1")
/* SW1:3,4 defined in manual/test-mode as: /* SW1:3,4 defined in manual/test-mode as:
PORT_DIPNAME( 0x04, 0x04, "1st Bonus Life" ) PORT_DIPLOCATION("SW1:3") PORT_DIPNAME( 0x04, 0x04, "1st Bonus Life" ) PORT_DIPLOCATION("SW1:3")
PORT_DIPSETTING( 0x04, "30k" ) PORT_DIPSETTING( 0x04, "30k" )
PORT_DIPSETTING( 0x00, "60k" ) PORT_DIPSETTING( 0x00, "60k" )
PORT_DIPNAME( 0x08, 0x08, "2nd Bonus Life" ) PORT_DIPLOCATION("SW1:4") PORT_DIPNAME( 0x08, 0x08, "2nd Bonus Life" ) PORT_DIPLOCATION("SW1:4")
PORT_DIPSETTING( 0x08, "70k" ) PORT_DIPSETTING( 0x08, "70k" )
PORT_DIPSETTING( 0x00, DEF_STR( None ) )*/ PORT_DIPSETTING( 0x00, DEF_STR( None ) )*/
PORT_DIPNAME( 0x0c, 0x0c, DEF_STR( Bonus_Life ) ) PORT_DIPLOCATION("SW1:3,4") PORT_DIPNAME( 0x0c, 0x0c, DEF_STR( Bonus_Life ) ) PORT_DIPLOCATION("SW1:3,4")
PORT_DIPSETTING( 0x0c, "30K and 100k" ) PORT_DIPSETTING( 0x0c, "30K and 100k" )
PORT_DIPSETTING( 0x08, "60k and 130k" ) PORT_DIPSETTING( 0x08, "60k and 130k" )
@ -769,7 +769,7 @@ static MACHINE_START( armedf )
state_save_register_global(machine, state->scroll_msb); state_save_register_global(machine, state->scroll_msb);
state_save_register_global(machine, state->waiting_msb); state_save_register_global(machine, state->waiting_msb);
state_save_register_global(machine, state->vreg); state_save_register_global(machine, state->vreg);
state_save_register_global(machine, state->fg_scrollx); state_save_register_global(machine, state->fg_scrollx);
state_save_register_global(machine, state->fg_scrolly); state_save_register_global(machine, state->fg_scrolly);
state_save_register_global(machine, state->bg_scrollx); state_save_register_global(machine, state->bg_scrollx);
state_save_register_global(machine, state->bg_scrolly); state_save_register_global(machine, state->bg_scrolly);
@ -784,7 +784,7 @@ static MACHINE_RESET( armedf )
state->scroll_msb = 0; state->scroll_msb = 0;
state->waiting_msb = 0; state->waiting_msb = 0;
state->vreg = 0; state->vreg = 0;
state->fg_scrollx = 0; state->fg_scrollx = 0;
state->fg_scrolly = 0; state->fg_scrolly = 0;
state->bg_scrollx = 0; state->bg_scrollx = 0;
state->bg_scrolly = 0; state->bg_scrolly = 0;

2
src/mame/drivers/astrocorp.c
View File

@ -112,7 +112,7 @@ static WRITE16_HANDLER( astrocorp_eeprom_w )
{ {
if (ACCESSING_BITS_0_7) if (ACCESSING_BITS_0_7)
{ {
input_port_write(space->machine, "EEPROMOUT", data, 0xff); input_port_write(space->machine, "EEPROMOUT", data, 0xff);
} }
} }

4
src/mame/drivers/bigevglf.c
View File

@ -116,9 +116,9 @@ static TIMER_CALLBACK( nmi_callback )
{ {
bigevglf_state *state = (bigevglf_state *)machine->driver_data; bigevglf_state *state = (bigevglf_state *)machine->driver_data;
if (state->sound_nmi_enable) if (state->sound_nmi_enable)
cpu_set_input_line(state->audiocpu, INPUT_LINE_NMI, PULSE_LINE); cpu_set_input_line(state->audiocpu, INPUT_LINE_NMI, PULSE_LINE);
else else
state->pending_nmi = 1; state->pending_nmi = 1;
state->sound_state &= ~1; state->sound_state &= ~1;
} }

10
src/mame/drivers/bigfghtr.c
View File

@ -125,8 +125,8 @@ struct _bigfghtr_state
UINT16 * bg_videoram; UINT16 * bg_videoram;
UINT16 * fg_videoram; UINT16 * fg_videoram;
UINT16 * sharedram; UINT16 * sharedram;
// UINT16 * spriteram; // currently this uses generic buffer_spriteram_w // UINT16 * spriteram; // currently this uses generic buffer_spriteram_w
// UINT16 * paletteram; // currently this uses generic palette handling // UINT16 * paletteram; // currently this uses generic palette handling
/* video-related */ /* video-related */
tilemap *bg_tilemap, *fg_tilemap, *tx_tilemap; tilemap *bg_tilemap, *fg_tilemap, *tx_tilemap;
@ -283,17 +283,17 @@ static VIDEO_UPDATE( bigfghtr )
else else
bitmap_fill(bitmap, cliprect, get_black_pen(screen->machine)); bitmap_fill(bitmap, cliprect, get_black_pen(screen->machine));
if(sprite_enable) if(sprite_enable)
draw_sprites(screen->machine, bitmap, cliprect, 2); draw_sprites(screen->machine, bitmap, cliprect, 2);
tilemap_draw(bitmap, cliprect, state->fg_tilemap, 0, 0); tilemap_draw(bitmap, cliprect, state->fg_tilemap, 0, 0);
if(sprite_enable) if(sprite_enable)
draw_sprites(screen->machine, bitmap, cliprect, 1); draw_sprites(screen->machine, bitmap, cliprect, 1);
tilemap_draw(bitmap, cliprect, state->tx_tilemap, 0, 0); tilemap_draw(bitmap, cliprect, state->tx_tilemap, 0, 0);
if (sprite_enable) if (sprite_enable)
draw_sprites(screen->machine, bitmap, cliprect, 0); draw_sprites(screen->machine, bitmap, cliprect, 0);
return 0; return 0;

8
src/mame/drivers/bublbobl.c
View File

@ -725,10 +725,10 @@ static MACHINE_START( common )
{ {
bublbobl_state *state = (bublbobl_state *)machine->driver_data; bublbobl_state *state = (bublbobl_state *)machine->driver_data;
state->maincpu = devtag_get_device(machine, "maincpu"); state->maincpu = devtag_get_device(machine, "maincpu");
state->mcu = devtag_get_device(machine, "mcu"); state->mcu = devtag_get_device(machine, "mcu");
state->audiocpu = devtag_get_device(machine, "audiocpu"); state->audiocpu = devtag_get_device(machine, "audiocpu");
state->slave = devtag_get_device(machine, "slave"); state->slave = devtag_get_device(machine, "slave");
state_save_register_global(machine, state->sound_nmi_enable); state_save_register_global(machine, state->sound_nmi_enable);
state_save_register_global(machine, state->pending_nmi); state_save_register_global(machine, state->pending_nmi);

46
src/mame/drivers/bwing.c
View File

@ -54,58 +54,58 @@ static INTERRUPT_GEN ( bwp1_interrupt )
case 1: case 1:
if (~input_port_read(device->machine, "IN2") & 0x03) if (~input_port_read(device->machine, "IN2") & 0x03)
{ {
if (!state->coin) if (!state->coin)
{ {
state->coin = 1; state->coin = 1;
cpu_set_input_line(device, INPUT_LINE_NMI, ASSERT_LINE); cpu_set_input_line(device, INPUT_LINE_NMI, ASSERT_LINE);
} }
} }
else else
state->coin = 0; state->coin = 0;
break; break;
case 2: case 2:
if (input_port_read(device->machine, "IN3")) if (input_port_read(device->machine, "IN3"))
cpu_set_input_line(device, M6809_FIRQ_LINE, ASSERT_LINE); cpu_set_input_line(device, M6809_FIRQ_LINE, ASSERT_LINE);
break; break;
} }
} }
static INTERRUPT_GEN ( bwp3_interrupt ) static INTERRUPT_GEN ( bwp3_interrupt )
{ {
bwing_state *state = (bwing_state *)device->machine->driver_data; bwing_state *state = (bwing_state *)device->machine->driver_data;
if (!state->bwp3_nmimask) if (!state->bwp3_nmimask)
cpu_set_input_line(device, INPUT_LINE_NMI, ASSERT_LINE); cpu_set_input_line(device, INPUT_LINE_NMI, ASSERT_LINE);
} }
//**************************************************************************** //****************************************************************************
// Memory and I/O Handlers // Memory and I/O Handlers
static WRITE8_HANDLER( bwp12_sharedram1_w ) static WRITE8_HANDLER( bwp12_sharedram1_w )
{ {
bwing_state *state = (bwing_state *)space->machine->driver_data; bwing_state *state = (bwing_state *)space->machine->driver_data;
state->bwp1_sharedram1[offset] = state->bwp2_sharedram1[offset] = data; state->bwp1_sharedram1[offset] = state->bwp2_sharedram1[offset] = data;
} }
static WRITE8_HANDLER( bwp3_u8F_w ) static WRITE8_HANDLER( bwp3_u8F_w )
{ {
bwing_state *state = (bwing_state *)space->machine->driver_data; bwing_state *state = (bwing_state *)space->machine->driver_data;
state->bwp3_u8F_d = data; // prepares custom chip for various operations state->bwp3_u8F_d = data; // prepares custom chip for various operations
} }
static WRITE8_HANDLER( bwp3_nmimask_w ) static WRITE8_HANDLER( bwp3_nmimask_w )
{ {
bwing_state *state = (bwing_state *)space->machine->driver_data; bwing_state *state = (bwing_state *)space->machine->driver_data;
state->bwp3_nmimask = data & 0x80; state->bwp3_nmimask = data & 0x80;
} }
static WRITE8_HANDLER( bwp3_nmiack_w ) static WRITE8_HANDLER( bwp3_nmiack_w )
{ {
bwing_state *state = (bwing_state *)space->machine->driver_data; bwing_state *state = (bwing_state *)space->machine->driver_data;
cpu_set_input_line(state->audiocpu, INPUT_LINE_NMI, CLEAR_LINE); cpu_set_input_line(state->audiocpu, INPUT_LINE_NMI, CLEAR_LINE);
} }
@ -402,8 +402,8 @@ static MACHINE_RESET( bwing )
state->coin = 0; state->coin = 0;
state->palatch = 0; state->palatch = 0;
state->srbank = 0; state->srbank = 0;
state->mapmask = 0; state->mapmask = 0;
state->mapflip = 0; state->mapflip = 0;
for (i = 0; i < MAX_SOUNDS; i++) for (i = 0; i < MAX_SOUNDS; i++)

2
src/mame/drivers/calorie.c
View File

@ -89,7 +89,7 @@ struct _calorie_state
/* memory pointers */ /* memory pointers */
UINT8 * fg_ram; UINT8 * fg_ram;
UINT8 * sprites; UINT8 * sprites;
// UINT8 * paletteram; // currently this uses generic palette handling // UINT8 * paletteram; // currently this uses generic palette handling
/* video-related */ /* video-related */
tilemap *bg_tilemap,*fg_tilemap; tilemap *bg_tilemap,*fg_tilemap;

2
src/mame/drivers/cchance.c
View File

@ -184,7 +184,7 @@ static const ay8910_interface ay8910_config =
static MACHINE_START( cchance ) static MACHINE_START( cchance )
{ {
tnzs_state *state = (tnzs_state *)machine->driver_data; tnzs_state *state = (tnzs_state *)machine->driver_data;
state->mcu = NULL; state->mcu = NULL;
state_save_register_global(machine, state->screenflip); state_save_register_global(machine, state->screenflip);
state_save_register_global(machine, state->hop_io); state_save_register_global(machine, state->hop_io);

4
src/mame/drivers/champbas.c
View File

@ -195,11 +195,11 @@ static READ8_HANDLER( champbja_alt_protection_r )
*/ */
/* bit7 = bit0 */ /* bit7 = bit0 */
if ((offset & 0x01)) if ((offset & 0x01))
data |= 0x80; data |= 0x80;
/* bit4,3,0 = bit6 */ /* bit4,3,0 = bit6 */
if ((offset & 0x40)) if ((offset & 0x40))
data |= 0x19; data |= 0x19;
return data; return data;

2
src/mame/drivers/champbwl.c
View File

@ -335,7 +335,7 @@ static MACHINE_START( champbwl )
tnzs_state *state = (tnzs_state *)machine->driver_data; tnzs_state *state = (tnzs_state *)machine->driver_data;
UINT8 *ROM = memory_region(machine, "maincpu"); UINT8 *ROM = memory_region(machine, "maincpu");
state->mcu = NULL; state->mcu = NULL;
memory_configure_bank(machine, 1, 0, 4, &ROM[0x10000], 0x4000); memory_configure_bank(machine, 1, 0, 4, &ROM[0x10000], 0x4000);

4
src/mame/drivers/chinagat.c
View File

@ -413,8 +413,8 @@ static INPUT_PORTS_START( chinagat )
PORT_DIPSETTING( 0x20, DEF_STR( 1C_4C ) ) PORT_DIPSETTING( 0x20, DEF_STR( 1C_4C ) )
PORT_DIPSETTING( 0x18, DEF_STR( 1C_5C ) ) PORT_DIPSETTING( 0x18, DEF_STR( 1C_5C ) )
/*PORT_DIPNAME( 0x40, 0x00, DEF_STR( Cabinet ) ) PORT_DIPLOCATION("SW1:7") /*PORT_DIPNAME( 0x40, 0x00, DEF_STR( Cabinet ) ) PORT_DIPLOCATION("SW1:7")
PORT_DIPSETTING( 0x00, DEF_STR( Upright ) ) PORT_DIPSETTING( 0x00, DEF_STR( Upright ) )
PORT_DIPSETTING( 0x40, DEF_STR( Cocktail ) )*/ PORT_DIPSETTING( 0x40, DEF_STR( Cocktail ) )*/
PORT_BIT( 0x40, IP_ACTIVE_HIGH, IPT_UNKNOWN ) PORT_BIT( 0x40, IP_ACTIVE_HIGH, IPT_UNKNOWN )
PORT_DIPNAME( 0x80, 0x80, DEF_STR( Flip_Screen ) ) PORT_DIPLOCATION("SW1:8") PORT_DIPNAME( 0x80, 0x80, DEF_STR( Flip_Screen ) ) PORT_DIPLOCATION("SW1:8")
PORT_DIPSETTING( 0x80, DEF_STR( Off ) ) PORT_DIPSETTING( 0x80, DEF_STR( Off ) )

52
src/mame/drivers/cntsteer.c
View File

@ -165,7 +165,7 @@ static void zerotrgt_draw_sprites( running_machine *machine, bitmap_t *bitmap, c
{ {
sy = 240 - sy; sy = 240 - sy;
sx = 240 - sx; sx = 240 - sx;
if (fx) fx = 0; if (fx) fx = 0;
else fx = 1; else fx = 1;
//sy2 = sy - 16; //sy2 = sy - 16;
} }
@ -223,7 +223,7 @@ static void cntsteer_draw_sprites( running_machine *machine, bitmap_t *bitmap, c
{ {
sy = 240 - sy; sy = 240 - sy;
sx = 240 - sx; sx = 240 - sx;
if (fx) fx = 0; if (fx) fx = 0;
else fx = 1; else fx = 1;
//sy2 = sy - 16; //sy2 = sy - 16;
} }
@ -371,15 +371,15 @@ static WRITE8_HANDLER(zerotrgt_vregs_w)
{ {
case 0: state->scrolly = data; break; case 0: state->scrolly = data; break;
case 1: state->scrollx = data; break; case 1: state->scrollx = data; break;
case 2: state->bg_bank = (data & 0x30) << 4; case 2: state->bg_bank = (data & 0x30) << 4;
state->bg_color_bank = (data & 7); state->bg_color_bank = (data & 7);
state->disable_roz = (data & 0x40); state->disable_roz = (data & 0x40);
tilemap_mark_all_tiles_dirty(state->bg_tilemap); tilemap_mark_all_tiles_dirty(state->bg_tilemap);
break; break;
case 3: state->rotation_sign = (data & 1); case 3: state->rotation_sign = (data & 1);
flip_screen_set(space->machine, !(data & 4)); flip_screen_set(space->machine, !(data & 4));
state->scrolly_hi = (data & 0x30) << 4; state->scrolly_hi = (data & 0x30) << 4;
state->scrollx_hi = (data & 0xc0) << 2; state->scrollx_hi = (data & 0xc0) << 2;
break; break;
case 4: state->rotation_x = data; break; case 4: state->rotation_x = data; break;
} }
@ -397,14 +397,14 @@ static WRITE8_HANDLER(cntsteer_vregs_w)
{ {
case 0: state->scrolly = data; break; case 0: state->scrolly = data; break;
case 1: state->scrollx = data; break; case 1: state->scrollx = data; break;
case 2: state->bg_bank = (data & 0x01) << 8; case 2: state->bg_bank = (data & 0x01) << 8;
state->bg_color_bank = (data & 6) >> 1; state->bg_color_bank = (data & 6) >> 1;
tilemap_mark_all_tiles_dirty(state->bg_tilemap); tilemap_mark_all_tiles_dirty(state->bg_tilemap);
break; break;
case 3: state->rotation_sign = (data & 7); case 3: state->rotation_sign = (data & 7);
state->disable_roz = (~data & 0x08); state->disable_roz = (~data & 0x08);
state->scrolly_hi = (data & 0x30) << 4; state->scrolly_hi = (data & 0x30) << 4;
state->scrollx_hi = (data & 0xc0) << 2; state->scrollx_hi = (data & 0xc0) << 2;
break; break;
case 4: state->rotation_x = data; break; case 4: state->rotation_x = data; break;
} }
@ -569,17 +569,17 @@ ADDRESS_MAP_END
/***************************************************************************/ /***************************************************************************/
static WRITE8_HANDLER( nmimask_w ) static WRITE8_HANDLER( nmimask_w )
{ {
cntsteer_state *state = (cntsteer_state *)space->machine->driver_data; cntsteer_state *state = (cntsteer_state *)space->machine->driver_data;
state->nmimask = data & 0x80; state->nmimask = data & 0x80;
} }
static INTERRUPT_GEN ( sound_interrupt ) static INTERRUPT_GEN ( sound_interrupt )
{ {
cntsteer_state *state = (cntsteer_state *)device->machine->driver_data; cntsteer_state *state = (cntsteer_state *)device->machine->driver_data;
if (!state->nmimask) if (!state->nmimask)
cpu_set_input_line(device, INPUT_LINE_NMI, PULSE_LINE); cpu_set_input_line(device, INPUT_LINE_NMI, PULSE_LINE);
} }
static ADDRESS_MAP_START( sound_map, ADDRESS_SPACE_PROGRAM, 8 ) static ADDRESS_MAP_START( sound_map, ADDRESS_SPACE_PROGRAM, 8 )
@ -791,7 +791,7 @@ static MACHINE_START( cntsteer )
state_save_register_global(machine, state->flipscreen); state_save_register_global(machine, state->flipscreen);
state_save_register_global(machine, state->bg_bank); state_save_register_global(machine, state->bg_bank);
state_save_register_global(machine, state->scrolly); state_save_register_global(machine, state->scrolly);
state_save_register_global(machine, state->scrollx); state_save_register_global(machine, state->scrollx);
state_save_register_global(machine, state->scrollx_hi); state_save_register_global(machine, state->scrollx_hi);
state_save_register_global(machine, state->scrolly_hi); state_save_register_global(machine, state->scrolly_hi);
@ -817,7 +817,7 @@ static MACHINE_RESET( cntsteer )
state->flipscreen = 0; state->flipscreen = 0;
state->bg_bank = 0; state->bg_bank = 0;
state->scrolly = 0; state->scrolly = 0;
state->scrollx = 0; state->scrollx = 0;
state->scrollx_hi = 0; state->scrollx_hi = 0;
state->scrolly_hi = 0; state->scrolly_hi = 0;

26
src/mame/drivers/cop01.c
View File

@ -81,12 +81,12 @@ static READ8_HANDLER( cop01_sound_command_r )
/* bit 0 seems to be a timer */ /* bit 0 seems to be a timer */
if ((cpu_get_total_cycles(space->cpu) / TIMER_RATE) & 1) if ((cpu_get_total_cycles(space->cpu) / TIMER_RATE) & 1)
{ {
if (state->pulse == 0) if (state->pulse == 0)
res |= 1; res |= 1;
state->pulse = 1; state->pulse = 1;
} }
else else
state->pulse = 0; state->pulse = 0;
return res; return res;
@ -154,10 +154,10 @@ ADDRESS_MAP_END
/* this just gets some garbage out of the YM3526 */ /* this just gets some garbage out of the YM3526 */
static READ8_HANDLER( kludge ) static READ8_HANDLER( kludge )
{ {
cop01_state *state = (cop01_state *)space->machine->driver_data; cop01_state *state = (cop01_state *)space->machine->driver_data;
return state->timer++; return state->timer++;
} }
static ADDRESS_MAP_START( mightguy_audio_io_map, ADDRESS_SPACE_IO, 8 ) static ADDRESS_MAP_START( mightguy_audio_io_map, ADDRESS_SPACE_IO, 8 )
@ -241,14 +241,14 @@ static INPUT_PORTS_START( cop01 )
PORT_DIPSETTING( 0x08, "5" ) PORT_DIPSETTING( 0x08, "5" )
PORT_DIPSETTING( 0x00, "6" ) PORT_DIPSETTING( 0x00, "6" )
/* DP2:3,4,5 defined in manual/test-mode as: /* DP2:3,4,5 defined in manual/test-mode as:
PORT_DIPNAME( 0x10, 0x10, "1st Bonus Life" ) PORT_DIPNAME( 0x10, 0x10, "1st Bonus Life" )
PORT_DIPSETTING( 0x10, "20000" ) PORT_DIPSETTING( 0x10, "20000" )
PORT_DIPSETTING( 0x00, "30000" ) PORT_DIPSETTING( 0x00, "30000" )
PORT_DIPNAME( 0x60, 0x60, "2nd Bonus Life" ) PORT_DIPNAME( 0x60, 0x60, "2nd Bonus Life" )
PORT_DIPSETTING( 0x60, "30000" ) PORT_DIPSETTING( 0x60, "30000" )
PORT_DIPSETTING( 0x20, "50000" ) PORT_DIPSETTING( 0x20, "50000" )
PORT_DIPSETTING( 0x40, "100000" ) PORT_DIPSETTING( 0x40, "100000" )
PORT_DIPSETTING( 0x00, "150000" ) */ PORT_DIPSETTING( 0x00, "150000" ) */
PORT_DIPNAME( 0x70, 0x70, DEF_STR( Bonus_Life ) ) PORT_DIPNAME( 0x70, 0x70, DEF_STR( Bonus_Life ) )
PORT_DIPSETTING( 0x70, "20k 50k 30k+" ) PORT_DIPSETTING( 0x70, "20k 50k 30k+" )
PORT_DIPSETTING( 0x30, "20k 70k 50k+" ) PORT_DIPSETTING( 0x30, "20k 70k 50k+" )

6
src/mame/drivers/cosmic.c
View File

@ -56,7 +56,7 @@ static WRITE8_HANDLER( panic_sound_output_w )
{ {
int count; int count;
if (data == 0) if (data == 0)
for (count = 0; count < 9; count++) for (count = 0; count < 9; count++)
sample_stop(state->samples, count); sample_stop(state->samples, count);
state->sound_enabled = data; state->sound_enabled = data;
@ -134,7 +134,7 @@ static WRITE8_HANDLER( cosmicg_output_w )
state->sound_enabled = data; state->sound_enabled = data;
if (data == 0) if (data == 0)
for (count = 0; count < 9; count++) for (count = 0; count < 9; count++)
sample_stop(state->samples, count); sample_stop(state->samples, count);
} }
@ -196,7 +196,7 @@ static WRITE8_HANDLER( cosmica_sound_output_w )
{ {
int count; int count;
if (data == 0) if (data == 0)
for (count = 0; count < 12; count++) for (count = 0; count < 12; count++)
sample_stop(state->samples, count); sample_stop(state->samples, count);
else else
{ {

4
src/mame/drivers/cps1.c
View File

@ -448,7 +448,7 @@ static WRITE16_HANDLER( cps1_eeprom_port_w )
bit 6 = clock bit 6 = clock
bit 7 = cs bit 7 = cs
*/ */
input_port_write(space->machine, "EEPROMOUT", data, 0xff); input_port_write(space->machine, "EEPROMOUT", data, 0xff);
} }
} }
@ -2314,7 +2314,7 @@ static INPUT_PORTS_START( punisher )
PORT_BIT( 0x80, IP_ACTIVE_LOW, IPT_OUTPUT ) PORT_WRITE_LINE_DEVICE("eeprom", eepromdev_set_cs_line) PORT_BIT( 0x80, IP_ACTIVE_LOW, IPT_OUTPUT ) PORT_WRITE_LINE_DEVICE("eeprom", eepromdev_set_cs_line)
INPUT_PORTS_END INPUT_PORTS_END
/* Needs further checking */ /* Needs further checking */
static INPUT_PORTS_START( slammast ) static INPUT_PORTS_START( slammast )
PORT_INCLUDE( cps1_4players ) PORT_INCLUDE( cps1_4players )

10
src/mame/drivers/cps2.c
View File

@ -722,7 +722,7 @@ static WRITE16_HANDLER( cps2_eeprom_port_w )
/* bit 7 - */ /* bit 7 - */
/* EEPROM */ /* EEPROM */
input_port_write(space->machine, "EEPROMOUT", data, 0xffff); input_port_write(space->machine, "EEPROMOUT", data, 0xffff);
} }
if (ACCESSING_BITS_0_7) if (ACCESSING_BITS_0_7)
@ -768,10 +768,10 @@ static WRITE16_HANDLER( cps2_eeprom_port_w )
} }
/* /*
set_led_status(space->machine, 0,data & 0x01); set_led_status(space->machine, 0,data & 0x01);
set_led_status(space->machine, 1,data & 0x10); set_led_status(space->machine, 1,data & 0x10);
set_led_status(space->machine, 2,data & 0x20); set_led_status(space->machine, 2,data & 0x20);
*/ */
} }
} }

2
src/mame/drivers/cultures.c
View File

@ -22,7 +22,7 @@ struct _cultures_state
UINT8 * paletteram; UINT8 * paletteram;
UINT8 * bg0_regs_x; UINT8 * bg0_regs_x;
UINT8 * bg1_regs_x; UINT8 * bg1_regs_x;
UINT8 * bg2_regs_x; UINT8 * bg2_regs_x;
UINT8 * bg0_regs_y; UINT8 * bg0_regs_y;
UINT8 * bg1_regs_y; UINT8 * bg1_regs_y;
UINT8 * bg2_regs_y; UINT8 * bg2_regs_y;

2
src/mame/drivers/dcheese.c
View File

@ -130,7 +130,7 @@ static WRITE16_HANDLER( eeprom_control_w )
/* bits $0080-$0010 are probably lamps */ /* bits $0080-$0010 are probably lamps */
if (ACCESSING_BITS_0_7) if (ACCESSING_BITS_0_7)
{ {
input_port_write(space->machine, "EEPROMOUT", data, 0xff); input_port_write(space->machine, "EEPROMOUT", data, 0xff);
ticket_dispenser_w(space, 0, (data & 1) << 7); ticket_dispenser_w(space, 0, (data & 1) << 7);
} }
} }

2
src/mame/drivers/ddealer.c
View File

@ -125,7 +125,7 @@ struct _ddealer_state
UINT16 * left_fg_vram_bottom; UINT16 * left_fg_vram_bottom;
UINT16 * right_fg_vram_bottom; UINT16 * right_fg_vram_bottom;
UINT16 * vregs; UINT16 * vregs;
// UINT16 * paletteram16; // currently this uses generic palette handling // UINT16 * paletteram16; // currently this uses generic palette handling
/* video-related */ /* video-related */
tilemap *back_tilemap; tilemap *back_tilemap;

4
src/mame/drivers/ddragon3.c
View File

@ -567,7 +567,7 @@ static MACHINE_START( ddragon3 )
state_save_register_global(machine, state->vreg); state_save_register_global(machine, state->vreg);
state_save_register_global(machine, state->bg_scrollx); state_save_register_global(machine, state->bg_scrollx);
state_save_register_global(machine, state->bg_scrolly); state_save_register_global(machine, state->bg_scrolly);
state_save_register_global(machine, state->fg_scrollx); state_save_register_global(machine, state->fg_scrollx);
state_save_register_global(machine, state->fg_scrolly); state_save_register_global(machine, state->fg_scrolly);
state_save_register_global(machine, state->bg_tilebase); state_save_register_global(machine, state->bg_tilebase);
state_save_register_global_array(machine, state->io_reg); state_save_register_global_array(machine, state->io_reg);
@ -581,7 +581,7 @@ static MACHINE_RESET( ddragon3 )
state->vreg = 0; state->vreg = 0;
state->bg_scrollx = 0; state->bg_scrollx = 0;
state->bg_scrolly = 0; state->bg_scrolly = 0;
state->fg_scrollx = 0; state->fg_scrollx = 0;
state->fg_scrolly = 0; state->fg_scrolly = 0;
state->bg_tilebase = 0; state->bg_tilebase = 0;

4
src/mame/drivers/deco156.c
View File

@ -148,10 +148,10 @@ static VIDEO_UPDATE( wcvol95 )
static WRITE32_HANDLER(hvysmsh_eeprom_w) static WRITE32_HANDLER(hvysmsh_eeprom_w)
{ {
if (ACCESSING_BITS_0_7) if (ACCESSING_BITS_0_7)
{ {
okim6295_set_bank_base(devtag_get_device(space->machine, "oki2"), 0x40000 * (data & 0x7) ); okim6295_set_bank_base(devtag_get_device(space->machine, "oki2"), 0x40000 * (data & 0x7) );
input_port_write(space->machine, "EEPROMOUT", data, 0xff); input_port_write(space->machine, "EEPROMOUT", data, 0xff);
} }
} }

66
src/mame/drivers/decocass.c
View File

@ -29,62 +29,62 @@ INLINE int swap_bits_5_6(int data)
} }
static WRITE8_HANDLER( ram_w ) static WRITE8_HANDLER( ram_w )
{ {
decocass_state *state = (decocass_state *)space->machine->driver_data; decocass_state *state = (decocass_state *)space->machine->driver_data;
state->decrypted[0x0000 + offset] = swap_bits_5_6(data); state->decrypted[0x0000 + offset] = swap_bits_5_6(data);
state->rambase[0x0000 + offset] = data; state->rambase[0x0000 + offset] = data;
} }
static WRITE8_HANDLER( charram_w ) static WRITE8_HANDLER( charram_w )
{ {
decocass_state *state = (decocass_state *)space->machine->driver_data; decocass_state *state = (decocass_state *)space->machine->driver_data;
state->decrypted[0x6000 + offset] = swap_bits_5_6(data); state->decrypted[0x6000 + offset] = swap_bits_5_6(data);
decocass_charram_w(space, offset, data); decocass_charram_w(space, offset, data);
} }
static WRITE8_HANDLER( fgvideoram_w ) static WRITE8_HANDLER( fgvideoram_w )
{ {
decocass_state *state = (decocass_state *)space->machine->driver_data; decocass_state *state = (decocass_state *)space->machine->driver_data;
state->decrypted[0xc000 + offset] = swap_bits_5_6(data); state->decrypted[0xc000 + offset] = swap_bits_5_6(data);
decocass_fgvideoram_w(space, offset, data); decocass_fgvideoram_w(space, offset, data);
} }
static WRITE8_HANDLER( fgcolorram_w ) static WRITE8_HANDLER( fgcolorram_w )
{ {
decocass_state *state = (decocass_state *)space->machine->driver_data; decocass_state *state = (decocass_state *)space->machine->driver_data;
state->decrypted[0xc400 + offset] = swap_bits_5_6(data); state->decrypted[0xc400 + offset] = swap_bits_5_6(data);
decocass_colorram_w(space, offset, data); decocass_colorram_w(space, offset, data);
} }
static WRITE8_HANDLER( tileram_w ) static WRITE8_HANDLER( tileram_w )
{ {
decocass_state *state = (decocass_state *)space->machine->driver_data; decocass_state *state = (decocass_state *)space->machine->driver_data;
state->decrypted[0xd000 + offset] = swap_bits_5_6(data); state->decrypted[0xd000 + offset] = swap_bits_5_6(data);
decocass_tileram_w(space, offset, data); decocass_tileram_w(space, offset, data);
} }
static WRITE8_HANDLER( objectram_w ) static WRITE8_HANDLER( objectram_w )
{ {
decocass_state *state = (decocass_state *)space->machine->driver_data; decocass_state *state = (decocass_state *)space->machine->driver_data;
state->decrypted[0xd800 + offset] = swap_bits_5_6(data); state->decrypted[0xd800 + offset] = swap_bits_5_6(data);
decocass_objectram_w(space, offset, data); decocass_objectram_w(space, offset, data);
} }
static WRITE8_HANDLER( mirrorvideoram_w ) { offset = ((offset >> 5) & 0x1f) | ((offset & 0x1f) << 5); fgvideoram_w(space, offset, data); } static WRITE8_HANDLER( mirrorvideoram_w ) { offset = ((offset >> 5) & 0x1f) | ((offset & 0x1f) << 5); fgvideoram_w(space, offset, data); }
static WRITE8_HANDLER( mirrorcolorram_w ) { offset = ((offset >> 5) & 0x1f) | ((offset & 0x1f) << 5); fgcolorram_w(space, offset, data); } static WRITE8_HANDLER( mirrorcolorram_w ) { offset = ((offset >> 5) & 0x1f) | ((offset & 0x1f) << 5); fgcolorram_w(space, offset, data); }
static READ8_HANDLER( mirrorvideoram_r ) static READ8_HANDLER( mirrorvideoram_r )
{
decocass_state *state = (decocass_state *)space->machine->driver_data;
offset = ((offset >> 5) & 0x1f) | ((offset & 0x1f) << 5);
return state->fgvideoram[offset];
}
static READ8_HANDLER( mirrorcolorram_r )
{ {
decocass_state *state = (decocass_state *)space->machine->driver_data; decocass_state *state = (decocass_state *)space->machine->driver_data;
offset = ((offset >> 5) & 0x1f) | ((offset & 0x1f) << 5); offset = ((offset >> 5) & 0x1f) | ((offset & 0x1f) << 5);
return state->colorram[offset]; return state->fgvideoram[offset];
}
static READ8_HANDLER( mirrorcolorram_r )
{
decocass_state *state = (decocass_state *)space->machine->driver_data;
offset = ((offset >> 5) & 0x1f) | ((offset & 0x1f) << 5);
return state->colorram[offset];
} }

2
src/mame/drivers/diverboy.c
View File

@ -58,7 +58,7 @@ struct _diverboy_state
{ {
/* memory pointers */ /* memory pointers */
UINT16 * spriteram; UINT16 * spriteram;
// UINT16 * paletteram; // currently this uses generic palette handling // UINT16 * paletteram; // currently this uses generic palette handling
size_t spriteram_size; size_t spriteram_size;
/* devices */ /* devices */

2
src/mame/drivers/dominob.c
View File

@ -41,7 +41,7 @@ struct _dominob_state
UINT8 * spriteram; UINT8 * spriteram;
UINT8 * videoram; UINT8 * videoram;
UINT8 * bgram; UINT8 * bgram;
// UINT8 * paletteram; // currently this uses generic palette handling // UINT8 * paletteram; // currently this uses generic palette handling
size_t spriteram_size; size_t spriteram_size;
/* input-related */ /* input-related */

10
src/mame/drivers/drgnmst.c
View File

@ -52,7 +52,7 @@ static WRITE16_HANDLER( drgnmst_snd_command_w )
{ {
drgnmst_state *state = (drgnmst_state *)space->machine->driver_data; drgnmst_state *state = (drgnmst_state *)space->machine->driver_data;
if (ACCESSING_BITS_0_7) if (ACCESSING_BITS_0_7)
{ {
state->snd_command = (data & 0xff); state->snd_command = (data & 0xff);
cpu_yield(space->cpu); cpu_yield(space->cpu);
@ -95,7 +95,7 @@ static READ8_HANDLER( drgnmst_snd_command_r )
static READ8_HANDLER( drgnmst_snd_flag_r ) static READ8_HANDLER( drgnmst_snd_flag_r )
{ {
drgnmst_state *state = (drgnmst_state *)space->machine->driver_data; drgnmst_state *state = (drgnmst_state *)space->machine->driver_data;
if (state->snd_flag) if (state->snd_flag)
{ {
state->snd_flag = 0; state->snd_flag = 0;
return 0x40; return 0x40;
@ -152,16 +152,16 @@ static WRITE8_HANDLER( drgnmst_snd_control_w )
oki_new_bank = ((state->pic16c5x_port0 & 0xc) >> 2) | ((state->oki_control & 0x80) >> 5); oki_new_bank = ((state->pic16c5x_port0 & 0xc) >> 2) | ((state->oki_control & 0x80) >> 5);
if (oki_new_bank != state->oki0_bank) if (oki_new_bank != state->oki0_bank)
{ {
state->oki0_bank = oki_new_bank; state->oki0_bank = oki_new_bank;
if (state->oki0_bank) if (state->oki0_bank)
oki_new_bank--; oki_new_bank--;
okim6295_set_bank_base(state->oki_1, (oki_new_bank * 0x40000)); okim6295_set_bank_base(state->oki_1, (oki_new_bank * 0x40000));
} }
oki_new_bank = ((state->pic16c5x_port0 & 0x3) >> 0) | ((state->oki_control & 0x20) >> 3); oki_new_bank = ((state->pic16c5x_port0 & 0x3) >> 0) | ((state->oki_control & 0x20) >> 3);
if (oki_new_bank != state->oki1_bank) if (oki_new_bank != state->oki1_bank)
{ {
state->oki1_bank = oki_new_bank; state->oki1_bank = oki_new_bank;
okim6295_set_bank_base(state->oki_2, (oki_new_bank * 0x40000)); okim6295_set_bank_base(state->oki_2, (oki_new_bank * 0x40000));

2
src/mame/drivers/drtomy.c
View File

@ -18,7 +18,7 @@ struct _drtomy_state
UINT16 * spriteram; UINT16 * spriteram;
UINT16 * videoram_bg; UINT16 * videoram_bg;
UINT16 * videoram_fg; UINT16 * videoram_fg;
// UINT16 * paletteram16; // currently this uses generic palette handling // UINT16 * paletteram16; // currently this uses generic palette handling
/* video-related */ /* video-related */
tilemap *tilemap_bg,*tilemap_fg; tilemap *tilemap_bg,*tilemap_fg;

12
src/mame/drivers/drw80pkr.c
View File

@ -237,7 +237,7 @@ static READ8_HANDLER( drw80pkr_io_r )
{ {
ret = pkr_io_ram[offset]; ret = pkr_io_ram[offset];
} }
if (p2 == 0xf7) if (p2 == 0xf7)
{ {
// unknown // unknown
@ -260,10 +260,10 @@ static READ8_HANDLER( drw80pkr_io_r )
// Dip switches tied to sound chip // Dip switches tied to sound chip
// //
// TODO: Unknown switch positions, but found the following flipping bits: // TODO: Unknown switch positions, but found the following flipping bits:
// SW.? = Double Up Option // SW.? = Double Up Option
// SW.? = Coin Denomination // SW.? = Coin Denomination
// SW.4 = Payout Type (0=cash, 1=credit) // SW.4 = Payout Type (0=cash, 1=credit)
// SW.? = Use Joker in Deck // SW.? = Use Joker in Deck
// //
ret = 0x77; // double-up with credit payout ret = 0x77; // double-up with credit payout
} }
@ -276,7 +276,7 @@ static READ8_HANDLER( drw80pkr_io_r )
switch (kbdin) switch (kbdin)
{ {
// The following is very incorrect, but does allow you to // The following is very incorrect, but does allow you to
// play slightly with very messed up hold buttons etc. // play slightly with very messed up hold buttons etc.
// //
// Open/Close the door with 'O' // Open/Close the door with 'O'

44
src/mame/drivers/dunhuang.c
View File

@ -167,20 +167,20 @@ if (input_code_pressed(screen->machine, KEYCODE_Z))
// Tilemaps access // Tilemaps access
static WRITE8_HANDLER( dunhuang_pos_x_w ) static WRITE8_HANDLER( dunhuang_pos_x_w )
{ {
dunhuang_state *state = (dunhuang_state *)space->machine->driver_data; dunhuang_state *state = (dunhuang_state *)space->machine->driver_data;
state->pos_x = data & 0x3f; state->pos_x = data & 0x3f;
state->written = 0; state->written = 0;
state->written2 = 0; state->written2 = 0;
} }
static WRITE8_HANDLER( dunhuang_pos_y_w ) static WRITE8_HANDLER( dunhuang_pos_y_w )
{ {
dunhuang_state *state = (dunhuang_state *)space->machine->driver_data; dunhuang_state *state = (dunhuang_state *)space->machine->driver_data;
state->pos_y = data; state->pos_y = data;
state->written = 0; state->written = 0;
state->written2 = 0; state->written2 = 0;
} }
static WRITE8_HANDLER( dunhuang_tile_w ) static WRITE8_HANDLER( dunhuang_tile_w )
@ -282,46 +282,46 @@ static WRITE8_HANDLER( dunhuang_vert_clear_w )
// The tiles codes are read from the graphics roms too! // The tiles codes are read from the graphics roms too!
// //
static WRITE8_HANDLER( dunhuang_block_dest_w ) static WRITE8_HANDLER( dunhuang_block_dest_w )
{ {
dunhuang_state *state = (dunhuang_state *)space->machine->driver_data; dunhuang_state *state = (dunhuang_state *)space->machine->driver_data;
state->block_dest = data; state->block_dest = data;
} }
static WRITE8_HANDLER( dunhuang_block_x_w ) static WRITE8_HANDLER( dunhuang_block_x_w )
{ {
dunhuang_state *state = (dunhuang_state *)space->machine->driver_data; dunhuang_state *state = (dunhuang_state *)space->machine->driver_data;
state->block_x = data; state->block_x = data;
} }
static WRITE8_HANDLER( dunhuang_block_y_w ) static WRITE8_HANDLER( dunhuang_block_y_w )
{ {
dunhuang_state *state = (dunhuang_state *)space->machine->driver_data; dunhuang_state *state = (dunhuang_state *)space->machine->driver_data;
state->block_y = data; state->block_y = data;
} }
static WRITE8_HANDLER( dunhuang_block_w_w ) static WRITE8_HANDLER( dunhuang_block_w_w )
{ {
dunhuang_state *state = (dunhuang_state *)space->machine->driver_data; dunhuang_state *state = (dunhuang_state *)space->machine->driver_data;
state->block_w = data; state->block_w = data;
} }
static WRITE8_HANDLER( dunhuang_block_c_w ) static WRITE8_HANDLER( dunhuang_block_c_w )
{ {
dunhuang_state *state = (dunhuang_state *)space->machine->driver_data; dunhuang_state *state = (dunhuang_state *)space->machine->driver_data;
state->block_c = data; state->block_c = data;
} }
static WRITE8_HANDLER( dunhuang_block_addr_lo_w ) static WRITE8_HANDLER( dunhuang_block_addr_lo_w )
{ {
dunhuang_state *state = (dunhuang_state *)space->machine->driver_data; dunhuang_state *state = (dunhuang_state *)space->machine->driver_data;
state->block_addr_lo = data; state->block_addr_lo = data;
} }
static WRITE8_HANDLER( dunhuang_block_addr_hi_w ) static WRITE8_HANDLER( dunhuang_block_addr_hi_w )
{ {
dunhuang_state *state = (dunhuang_state *)space->machine->driver_data; dunhuang_state *state = (dunhuang_state *)space->machine->driver_data;
state->block_addr_hi = data; state->block_addr_hi = data;
} }
@ -376,10 +376,10 @@ static WRITE8_HANDLER( dunhuang_block_h_w )
// Palette: HMC HM86171 VGA 256 colour RAMDAC // Palette: HMC HM86171 VGA 256 colour RAMDAC
static WRITE8_HANDLER( dunhuang_paloffs_w ) static WRITE8_HANDLER( dunhuang_paloffs_w )
{ {
dunhuang_state *state = (dunhuang_state *)space->machine->driver_data; dunhuang_state *state = (dunhuang_state *)space->machine->driver_data;
state->paloffs = data * 3; state->paloffs = data * 3;
} }
static WRITE8_HANDLER( dunhuang_paldata_w ) static WRITE8_HANDLER( dunhuang_paldata_w )
@ -417,10 +417,10 @@ ADDRESS_MAP_END
// Inputs // Inputs
static WRITE8_HANDLER( dunhuang_input_w ) static WRITE8_HANDLER( dunhuang_input_w )
{ {
dunhuang_state *state = (dunhuang_state *)space->machine->driver_data; dunhuang_state *state = (dunhuang_state *)space->machine->driver_data;
state->input = data; state->input = data;
} }
static READ8_HANDLER( dunhuang_service_r ) static READ8_HANDLER( dunhuang_service_r )

8
src/mame/drivers/dynadice.c
View File

@ -42,8 +42,8 @@ struct _dynadice_state
{ {
/* memory pointers */ /* memory pointers */
UINT8 * videoram; UINT8 * videoram;
// UINT8 * nvram; // currently this uses generic nvram handling // UINT8 * nvram; // currently this uses generic nvram handling
// UINT8 * paletteram; // currently this uses generic palette handling // UINT8 * paletteram; // currently this uses generic palette handling
/* video-related */ /* video-related */
tilemap *bg_tilemap,*top_tilemap; tilemap *bg_tilemap,*top_tilemap;
@ -79,10 +79,10 @@ static WRITE8_DEVICE_HANDLER( sound_control_w )
D3 - /Reset D3 - /Reset
*/ */
if ((data & 7) == 7) if ((data & 7) == 7)
ay8910_address_w(device, 0, state->ay_data); ay8910_address_w(device, 0, state->ay_data);
if ((data & 7) == 6) if ((data & 7) == 6)
ay8910_data_w(device, 0, state->ay_data); ay8910_data_w(device, 0, state->ay_data);
} }

2
src/mame/drivers/egghunt.c
View File

@ -52,7 +52,7 @@ struct _egghunt_state
UINT8 * bgram; UINT8 * bgram;
UINT8 * atram; UINT8 * atram;
UINT8 * spram; UINT8 * spram;
// UINT8 * paletteram; // currently this uses generic palette handling // UINT8 * paletteram; // currently this uses generic palette handling
/* video-related */ /* video-related */
tilemap *bg_tilemap; tilemap *bg_tilemap;

2
src/mame/drivers/eolith.c
View File

@ -102,7 +102,7 @@ static WRITE32_HANDLER( systemcontrol_w )
coin_counter_w(space->machine, 0, data & coin_counter_bit); coin_counter_w(space->machine, 0, data & coin_counter_bit);
set_led_status(space->machine, 0, data & 1); set_led_status(space->machine, 0, data & 1);
input_port_write(space->machine, "EEPROMOUT", data, 0xff); input_port_write(space->machine, "EEPROMOUT", data, 0xff);
// bit 0x100 and 0x040 ? // bit 0x100 and 0x040 ?
} }

2
src/mame/drivers/eolith16.c
View File

@ -36,7 +36,7 @@ static WRITE16_HANDLER( eeprom_w )
vbuffer = (data & 0x80) >> 7; vbuffer = (data & 0x80) >> 7;
coin_counter_w(space->machine, 0, data & 1); coin_counter_w(space->machine, 0, data & 1);
input_port_write(space->machine, "EEPROMOUT", data, 0xff); input_port_write(space->machine, "EEPROMOUT", data, 0xff);
//data & 0x100 and data & 0x004 always set //data & 0x100 and data & 0x004 always set
} }

2
src/mame/drivers/esd16.c
View File

@ -128,7 +128,7 @@ static READ16_HANDLER( esd_eeprom_r )
static WRITE16_HANDLER( esd_eeprom_w ) static WRITE16_HANDLER( esd_eeprom_w )
{ {
if (ACCESSING_BITS_8_15) if (ACCESSING_BITS_8_15)
input_port_write(space->machine, "EEPROMOUT", data, 0xffff); input_port_write(space->machine, "EEPROMOUT", data, 0xffff);
// logerror("(0x%06x) Unk EEPROM write: %04x %04x\n", cpu_get_pc(space->cpu), data, mem_mask); // logerror("(0x%06x) Unk EEPROM write: %04x %04x\n", cpu_get_pc(space->cpu), data, mem_mask);
} }

2
src/mame/drivers/exerion.c
View File

@ -298,7 +298,7 @@ static MACHINE_RESET( exerion )
state->porta = 0; state->porta = 0;
state->portb = 0; state->portb = 0;
state->cocktail_flip = 0; state->cocktail_flip = 0;
state->char_palette = 0; state->char_palette = 0;
state->sprite_palette = 0; state->sprite_palette = 0;
state->char_bank = 0; state->char_bank = 0;

2
src/mame/drivers/f-32.c
View File

@ -57,7 +57,7 @@ ADDRESS_MAP_END
static READ32_HANDLER( f32_input_port_1_r ) static READ32_HANDLER( f32_input_port_1_r )
{ {
/* burn a bunch of cycles because this is polled frequently during busy loops */ /* burn a bunch of cycles because this is polled frequently during busy loops */
if ((cpu_get_pc(space->cpu) == 0x000379de) || (cpu_get_pc(space->cpu) == 0x000379cc) ) if ((cpu_get_pc(space->cpu) == 0x000379de) || (cpu_get_pc(space->cpu) == 0x000379cc) )
cpu_eat_cycles(space->cpu, 100); cpu_eat_cycles(space->cpu, 100);
//else printf("PC %08x\n", cpu_get_pc(space->cpu) ); //else printf("PC %08x\n", cpu_get_pc(space->cpu) );
return input_port_read(space->machine, "SYSTEM_P2"); return input_port_read(space->machine, "SYSTEM_P2");

8
src/mame/drivers/fantland.c
View File

@ -201,14 +201,14 @@ static READ8_HANDLER( borntofi_inputs_r )
x = (x & 0x7f) - (x & 0x80); x = (x & 0x7f) - (x & 0x80);
y = (y & 0x7f) - (y & 0x80); y = (y & 0x7f) - (y & 0x80);
if (state->old_x[offset] > 0) if (state->old_x[offset] > 0)
{ {
state->input_ret[offset] = (state->input_ret[offset] ^ 0x04) | ((state->input_ret[offset] & 0x04) << 1); state->input_ret[offset] = (state->input_ret[offset] ^ 0x04) | ((state->input_ret[offset] & 0x04) << 1);
state->old_x[offset]--; state->old_x[offset]--;
} }
else if (state->old_x[offset] < 0) else if (state->old_x[offset] < 0)
{ {
state->input_ret[offset] = (state->input_ret[offset] ^ 0x04) | (((~state->input_ret[offset]) & 0x04) << 1); state->input_ret[offset] = (state->input_ret[offset] ^ 0x04) | (((~state->input_ret[offset]) & 0x04) << 1);
state->old_x[offset]++; state->old_x[offset]++;
} }

14
src/mame/drivers/firetrap.c
View File

@ -81,7 +81,7 @@ static READ8_HANDLER( firetrap_8751_bootleg_r )
/* Check for coin insertion */ /* Check for coin insertion */
/* the following only works in the bootleg version, which doesn't have an */ /* the following only works in the bootleg version, which doesn't have an */
/* 8751 - the real thing is much more complicated than that. */ /* 8751 - the real thing is much more complicated than that. */
if ((input_port_read(space->machine, "IN2") & 0x70) != 0x70) if ((input_port_read(space->machine, "IN2") & 0x70) != 0x70)
return 0xff; return 0xff;
return 0; return 0;
@ -119,7 +119,7 @@ static WRITE8_HANDLER( firetrap_8751_w )
firetrap_state *state = (firetrap_state *)space->machine->driver_data; firetrap_state *state = (firetrap_state *)space->machine->driver_data;
/* End of command - important to note, as coin input is supressed while commands are pending */ /* End of command - important to note, as coin input is supressed while commands are pending */
if (data == 0x26) if (data == 0x26)
{ {
state->i8751_current_command = 0; state->i8751_current_command = 0;
state->i8751_return = 0xff; /* This value is XOR'd and must equal 0 */ state->i8751_return = 0xff; /* This value is XOR'd and must equal 0 */
@ -128,7 +128,7 @@ static WRITE8_HANDLER( firetrap_8751_w )
} }
/* Init sequence command */ /* Init sequence command */
else if (data == 0x13) else if (data == 0x13)
{ {
if (!state->i8751_current_command) if (!state->i8751_current_command)
state->i8751_init_ptr = 0; state->i8751_init_ptr = 0;
@ -136,14 +136,14 @@ static WRITE8_HANDLER( firetrap_8751_w )
} }
/* Used to calculate a jump address when coins are inserted */ /* Used to calculate a jump address when coins are inserted */
else if (data == 0xbd) else if (data == 0xbd)
{ {
if (!state->i8751_current_command) if (!state->i8751_current_command)
state->i8751_init_ptr = 0; state->i8751_init_ptr = 0;
state->i8751_return = i8751_coin_data[state->i8751_init_ptr++]; state->i8751_return = i8751_coin_data[state->i8751_init_ptr++];
} }
else if (data == 0x36) else if (data == 0x36)
{ {
if (!state->i8751_current_command) if (!state->i8751_current_command)
state->i8751_init_ptr = 0; state->i8751_init_ptr = 0;
@ -167,7 +167,7 @@ static WRITE8_HANDLER( firetrap_8751_w )
state->i8751_return = 2; state->i8751_return = 2;
else if (data == 0x88) else if (data == 0x88)
state->i8751_return = 3; state->i8751_return = 3;
else else
{ {
state->i8751_return = 0xff; state->i8751_return = 0xff;
logerror("%04x: Unknown i8751 command %02x!\n",cpu_get_pc(space->cpu),data); logerror("%04x: Unknown i8751 command %02x!\n",cpu_get_pc(space->cpu),data);
@ -516,7 +516,7 @@ static INTERRUPT_GEN( firetrap )
/* Make sure coin IRQ's aren't generated when another command is pending, the main cpu /* Make sure coin IRQ's aren't generated when another command is pending, the main cpu
definitely doesn't expect them as it locks out the coin routine */ definitely doesn't expect them as it locks out the coin routine */
if (state->coin_command_pending && !state->i8751_current_command) if (state->coin_command_pending && !state->i8751_current_command)
{ {
state->i8751_return = state->coin_command_pending; state->i8751_return = state->coin_command_pending;
cpu_set_input_line_and_vector(device, 0, HOLD_LINE, 0xff); cpu_set_input_line_and_vector(device, 0, HOLD_LINE, 0xff);

2
src/mame/drivers/flstory.c
View File

@ -43,7 +43,7 @@ static TIMER_CALLBACK( nmi_callback )
flstory_state *state = (flstory_state *)machine->driver_data; flstory_state *state = (flstory_state *)machine->driver_data;
if (state->sound_nmi_enable) if (state->sound_nmi_enable)
cpu_set_input_line(state->audiocpu, INPUT_LINE_NMI, PULSE_LINE); cpu_set_input_line(state->audiocpu, INPUT_LINE_NMI, PULSE_LINE);
else else
state->pending_nmi = 1; state->pending_nmi = 1;
} }

4
src/mame/drivers/freekick.c
View File

@ -82,7 +82,7 @@ static WRITE8_HANDLER( nmi_enable_w )
static INTERRUPT_GEN( freekick_irqgen ) static INTERRUPT_GEN( freekick_irqgen )
{ {
freekick_state *state = (freekick_state *)device->machine->driver_data; freekick_state *state = (freekick_state *)device->machine->driver_data;
if (state->nmi_en) if (state->nmi_en)
cpu_set_input_line(device, INPUT_LINE_NMI, PULSE_LINE); cpu_set_input_line(device, INPUT_LINE_NMI, PULSE_LINE);
} }
@ -106,7 +106,7 @@ static READ8_HANDLER( oigas_3_r )
{ {
case 2: return ~(state->inval >> 8); case 2: return ~(state->inval >> 8);
case 3: return ~(state->inval & 0xff); case 3: return ~(state->inval & 0xff);
case 4: case 4:
switch (state->inval) switch (state->inval)
{ {
case 0xc500: state->outval = 0x17ef; break; case 0xc500: state->outval = 0x17ef; break;

4
src/mame/drivers/gaiden.c
View File

@ -135,9 +135,9 @@ static WRITE16_HANDLER( gaiden_sound_command_w )
{ {
gaiden_state *state = (gaiden_state *)space->machine->driver_data; gaiden_state *state = (gaiden_state *)space->machine->driver_data;
if (ACCESSING_BITS_0_7) if (ACCESSING_BITS_0_7)
soundlatch_w(space, 0, data & 0xff); /* Ninja Gaiden */ soundlatch_w(space, 0, data & 0xff); /* Ninja Gaiden */
if (ACCESSING_BITS_8_15) if (ACCESSING_BITS_8_15)
soundlatch_w(space, 0, data >> 8); /* Tecmo Knight */ soundlatch_w(space, 0, data >> 8); /* Tecmo Knight */
cpu_set_input_line(state->audiocpu, INPUT_LINE_NMI, PULSE_LINE); cpu_set_input_line(state->audiocpu, INPUT_LINE_NMI, PULSE_LINE);
} }

150
src/mame/drivers/gal3.c
View File

@ -5,24 +5,24 @@
System Overview: System Overview:
This is a Scaleable, Multi-CPU and Multi-User System. This is a Scaleable, Multi-CPU and Multi-User System.
The largest scale configuration known so far was capable of 28(!) players and 16 screens wraped around. (retaired in the early 2000's) The largest scale configuration known so far was capable of 28(!) players and 16 screens wraped around. (retaired in the early 2000's)
System has one Master 68020 CPU Board for game play, and one or more Slave 68020 CPU Boards for graphics. System has one Master 68020 CPU Board for game play, and one or more Slave 68020 CPU Boards for graphics.
The Master CPU communicates with (one or more)Slave CPUs via multi-port shared RAM, the "C-RAM board". The Master CPU communicates with (one or more)Slave CPUs via multi-port shared RAM, the "C-RAM board".
Each C-RAM board is configured as 2 banks of Triple-Port Static RAM Units. The 2 Master-CPU-Port of the 2 RAM banks Each C-RAM board is configured as 2 banks of Triple-Port Static RAM Units. The 2 Master-CPU-Port of the 2 RAM banks
are joined together, leaving 4 Slave-CPU-Ports. More than one C-RAM boards can be chained together. are joined together, leaving 4 Slave-CPU-Ports. More than one C-RAM boards can be chained together.
The Master CPU controls a Sound Board and a RSO board. RSO board contains Namco 139 serial communication ICs (x9 pieces), The Master CPU controls a Sound Board and a RSO board. RSO board contains Namco 139 serial communication ICs (x9 pieces),
connecting to several "Personal Boards" (Player-Terminals), which handle players' input and vibration/lamp feedback. connecting to several "Personal Boards" (Player-Terminals), which handle players' input and vibration/lamp feedback.
Each the Sound board, the RSO board, and the Personal board has their own 68000 CPU. Each the Sound board, the RSO board, and the Personal board has their own 68000 CPU.
Slave CPU connects to a cluster of namcos21-type video board sets: DSP-PGN-OBJ. A DSP board has 5x TMS320C25 running at 40MHz. Slave CPU connects to a cluster of namcos21-type video board sets: DSP-PGN-OBJ. A DSP board has 5x TMS320C25 running at 40MHz.
Every 68020 CPU board has 512KB of local Hi-Speed SRAM. Most code/data required by the Slave CPU sub-system are Every 68020 CPU board has 512KB of local Hi-Speed SRAM. Most code/data required by the Slave CPU sub-system are
uploaded from the Master CPU's ROM. Among them are: uploaded from the Master CPU's ROM. Among them are:
Slave CPU program, DSP program, Calculation Tables, Vertex Array Index, Palette, 2D Sprite Data, etc. Slave CPU program, DSP program, Calculation Tables, Vertex Array Index, Palette, 2D Sprite Data, etc.
The current dumped system supports 6 players. It has 2x 68020, 5x 68000 and 10x TMS320C25. The current dumped system supports 6 players. It has 2x 68020, 5x 68000 and 10x TMS320C25.
@ -30,27 +30,27 @@
System Diagram: System Diagram:
--------------- ---------------
Serial Comm Cable Serial Comm Cable
Master 68020 -------- RSO 68000, 9x Namco 139 SCI ICs <==============================> Personal Board 68000 Master 68020 -------- RSO 68000, 9x Namco 139 SCI ICs <==============================> Personal Board 68000
| | ........ more personal boards......... | | ........ more personal boards.........
| | ........ more personal boards......... | | ........ more personal boards.........
| | | |
| |-------- Sound 68000, 4x Namco 140 ICs | |-------- Sound 68000, 4x Namco 140 ICs
|---------| |---------|
| C-RAM | | C-RAM |
| #-# #-# | | #-# #-# |
|---------| |---------|
| | | | | | | |
| | | |------- Slave 68020 | | | |------- Slave 68020
| | | |-------- 1x master DSP, 4x slave DSPs, Polygon, 2D Sprite ------> V-MIX board -----> SCREEN | | | |-------- 1x master DSP, 4x slave DSPs, Polygon, 2D Sprite ------> V-MIX board -----> SCREEN
| | | |-------- ........ more video boards ......... | | | | |-------- ........ more video boards ......... |
| | | |-------- ........ more video boards ......... LD Player | | | |-------- ........ more video boards ......... LD Player
| | | | | |
| | |------- ........ more slave 68020s ......... | | |------- ........ more slave 68020s .........
| | | |
| |------- ........ more slave 68020s ......... | |------- ........ more slave 68020s .........
| |
|------- ........ more slave 68020s ......... |------- ........ more slave 68020s .........
@ -194,16 +194,16 @@ static VIDEO_UPDATE(gal3)
namco_obj_draw(screen->machine, bitmap, cliprect, pri ); namco_obj_draw(screen->machine, bitmap, cliprect, pri );
} }
/* CopyVisiblePolyFrameBuffer( bitmap, cliprect,0,0x7fbf ); /* CopyVisiblePolyFrameBuffer( bitmap, cliprect,0,0x7fbf );
for( pri=pivot; pri<15; pri++ ) for( pri=pivot; pri<15; pri++ )
{ {
namco_obj_draw(screen->machine, bitmap, cliprect, pri ); namco_obj_draw(screen->machine, bitmap, cliprect, pri );
}*/ }*/
// CPU Diag LEDs // CPU Diag LEDs
mst[17]='\0', slv[17]='\0'; mst[17]='\0', slv[17]='\0';
/// printf("mst=0x%x\tslv=0x%x\n", led_mst, led_slv); /// printf("mst=0x%x\tslv=0x%x\n", led_mst, led_slv);
for(i=16;i<32;i++) for(i=16;i<32;i++)
{ {
int t; int t;
@ -211,7 +211,7 @@ static VIDEO_UPDATE(gal3)
t=i; t=i;
else else
t=i+1; t=i+1;
mst[8]=' '; slv[8]=' '; mst[8]=' '; slv[8]=' ';
if(led_mst&(1<<i)) if(led_mst&(1<<i))
mst[t-16]='*'; mst[t-16]='*';
@ -278,12 +278,12 @@ static WRITE32_HANDLER( shareram0_w )
/* /*
static READ32_HANDLER( shareram1_r ) static READ32_HANDLER( shareram1_r )
{ {
return mpSharedRAM1[offset]; return mpSharedRAM1[offset];
} }
static WRITE32_HANDLER( shareram1_w ) static WRITE32_HANDLER( shareram1_w )
{ {
COMBINE_DATA( &mpSharedRAM1[offset] ); COMBINE_DATA( &mpSharedRAM1[offset] );
}*/ }*/
/***************************************************************************************/ /***************************************************************************************/
@ -342,9 +342,9 @@ static WRITE32_HANDLER(namcos21_video_enable_w)
static READ32_HANDLER(rso_r) static READ32_HANDLER(rso_r)
{ {
/*store $5555 @$0046, and readback @$0000 /*store $5555 @$0046, and readback @$0000
read @$0144 and store at A6_21e & A4_5c read @$0144 and store at A6_21e & A4_5c
Check @$009a==1 to start DEMO Check @$009a==1 to start DEMO
HACK*/ HACK*/
offset *= 2; offset *= 2;
return (rsoSharedRAM[offset]<<16)|rsoSharedRAM[offset+1]; return (rsoSharedRAM[offset]<<16)|rsoSharedRAM[offset+1];
} }
@ -362,7 +362,7 @@ static WRITE32_HANDLER(rso_w)
static ADDRESS_MAP_START( cpu_mst_map, ADDRESS_SPACE_PROGRAM, 32 ) static ADDRESS_MAP_START( cpu_mst_map, ADDRESS_SPACE_PROGRAM, 32 )
AM_RANGE(0x00000000, 0x001fffff) AM_ROM AM_RANGE(0x00000000, 0x001fffff) AM_ROM
AM_RANGE(0x20000000, 0x20001fff) AM_RAM AM_BASE(&gal3_nvmem) AM_SIZE(&gal3_nvmem_size) //NVRAM AM_RANGE(0x20000000, 0x20001fff) AM_RAM AM_BASE(&gal3_nvmem) AM_SIZE(&gal3_nvmem_size) //NVRAM
/// AM_RANGE(0x40000000, 0x4000ffff) AM_WRITE() // /// AM_RANGE(0x40000000, 0x4000ffff) AM_WRITE() //
AM_RANGE(0x44000000, 0x44000003) AM_READ_PORT("DSW_CPU_mst" ) AM_RANGE(0x44000000, 0x44000003) AM_READ_PORT("DSW_CPU_mst" )
AM_RANGE(0x44800000, 0x44800003) AM_READ(led_mst_r) AM_WRITE(led_mst_w) //LEDs AM_RANGE(0x44800000, 0x44800003) AM_READ(led_mst_r) AM_WRITE(led_mst_w) //LEDs
AM_RANGE(0x48000000, 0x48000003) AM_READ(SMH_NOP) //irq1 v-blank ack AM_RANGE(0x48000000, 0x48000003) AM_READ(SMH_NOP) //irq1 v-blank ack
@ -370,46 +370,46 @@ static ADDRESS_MAP_START( cpu_mst_map, ADDRESS_SPACE_PROGRAM, 32 )
AM_RANGE(0x60000000, 0x60007fff) AM_READ(shareram0_r) AM_WRITE(shareram0_w) AM_BASE(&mpSharedRAM0) //CRAM AM_RANGE(0x60000000, 0x60007fff) AM_READ(shareram0_r) AM_WRITE(shareram0_w) AM_BASE(&mpSharedRAM0) //CRAM
AM_RANGE(0x60010000, 0x60017fff) AM_READ(shareram0_r) AM_WRITE(shareram0_w) //Mirror AM_RANGE(0x60010000, 0x60017fff) AM_READ(shareram0_r) AM_WRITE(shareram0_w) //Mirror
AM_RANGE(0x80000000, 0x8007ffff) AM_READ(SMH_RAM) AM_WRITE(SMH_RAM) //512K Local RAM AM_RANGE(0x80000000, 0x8007ffff) AM_READ(SMH_RAM) AM_WRITE(SMH_RAM) //512K Local RAM
/// AM_RANGE(0xc0000000, 0xc000000b) AM_WRITENOP //upload? /// AM_RANGE(0xc0000000, 0xc000000b) AM_WRITENOP //upload?
AM_RANGE(0xc000000c, 0xc000000f) AM_READNOP //irq2 ack AM_RANGE(0xc000000c, 0xc000000f) AM_READNOP //irq2 ack
/// AM_RANGE(0xd8000000, 0xd800000f) AM_READ(SMH_RAM) AM_WRITE(SMH_RAM) // protection or 68681? /// AM_RANGE(0xd8000000, 0xd800000f) AM_READ(SMH_RAM) AM_WRITE(SMH_RAM) // protection or 68681?
AM_RANGE(0xf2800000, 0xf2800fff) AM_READWRITE(rso_r, rso_w) //RSO PCB AM_RANGE(0xf2800000, 0xf2800fff) AM_READWRITE(rso_r, rso_w) //RSO PCB
ADDRESS_MAP_END ADDRESS_MAP_END
static ADDRESS_MAP_START( cpu_slv_map, ADDRESS_SPACE_PROGRAM, 32 ) static ADDRESS_MAP_START( cpu_slv_map, ADDRESS_SPACE_PROGRAM, 32 )
AM_RANGE(0x00000000, 0x0007ffff) AM_ROM AM_RANGE(0x00000000, 0x0007ffff) AM_ROM
/// AM_RANGE(0x40000000, 0x4000ffff) AM_WRITE() // /// AM_RANGE(0x40000000, 0x4000ffff) AM_WRITE() //
AM_RANGE(0x44000000, 0x44000003) AM_READ_PORT("DSW_CPU_slv" ) AM_RANGE(0x44000000, 0x44000003) AM_READ_PORT("DSW_CPU_slv" )
AM_RANGE(0x44800000, 0x44800003) AM_READ(led_slv_r) AM_WRITE(led_slv_w) //LEDs AM_RANGE(0x44800000, 0x44800003) AM_READ(led_slv_r) AM_WRITE(led_slv_w) //LEDs
AM_RANGE(0x48000000, 0x48000003) AM_READ(SMH_NOP) //irq1 ack AM_RANGE(0x48000000, 0x48000003) AM_READ(SMH_NOP) //irq1 ack
/// AM_RANGE(0x50000000, 0x50000003) AM_READ() AM_WRITE() /// AM_RANGE(0x50000000, 0x50000003) AM_READ() AM_WRITE()
/// AM_RANGE(0x54000000, 0x54000003) AM_READ() AM_WRITE() /// AM_RANGE(0x54000000, 0x54000003) AM_READ() AM_WRITE()
AM_RANGE(0x60000000, 0x60007fff) AM_READ(shareram0_r) AM_WRITE(shareram0_w) AM_RANGE(0x60000000, 0x60007fff) AM_READ(shareram0_r) AM_WRITE(shareram0_w)
AM_RANGE(0x60010000, 0x60017fff) AM_READ(shareram0_r) AM_WRITE(shareram0_w) AM_RANGE(0x60010000, 0x60017fff) AM_READ(shareram0_r) AM_WRITE(shareram0_w)
AM_RANGE(0x80000000, 0x8007ffff) AM_READ(SMH_RAM) AM_WRITE(SMH_RAM) //512K Local RAM AM_RANGE(0x80000000, 0x8007ffff) AM_READ(SMH_RAM) AM_WRITE(SMH_RAM) //512K Local RAM
AM_RANGE(0xf1200000, 0xf120ffff) AM_READ(SMH_RAM) AM_WRITE(SMH_RAM) //DSP RAM AM_RANGE(0xf1200000, 0xf120ffff) AM_READ(SMH_RAM) AM_WRITE(SMH_RAM) //DSP RAM
/// AM_RANGE(0xf1400000, 0xf1400003) AM_WRITE(pointram_control_w) /// AM_RANGE(0xf1400000, 0xf1400003) AM_WRITE(pointram_control_w)
/// AM_RANGE(0xf1440000, 0xf1440003) AM_READWRITE(pointram_data_r,pointram_data_w) /// AM_RANGE(0xf1440000, 0xf1440003) AM_READWRITE(pointram_data_r,pointram_data_w)
/// AM_RANGE(0x440002, 0x47ffff) AM_WRITENOP /* (frame buffer?) */ /// AM_RANGE(0x440002, 0x47ffff) AM_WRITENOP /* (frame buffer?) */
/// AM_RANGE(0xf1480000, 0xf14807ff) AM_READWRITE(namcos21_depthcue_r,namcos21_depthcue_w) /// AM_RANGE(0xf1480000, 0xf14807ff) AM_READWRITE(namcos21_depthcue_r,namcos21_depthcue_w)
AM_RANGE(0xf1700000, 0xf170ffff) AM_READWRITE(namco_obj32_r,namco_obj32_w) AM_RANGE(0xf1700000, 0xf170ffff) AM_READWRITE(namco_obj32_r,namco_obj32_w)
AM_RANGE(0xf1720000, 0xf1720007) AM_READWRITE(namco_spritepos32_r,namco_spritepos32_w) AM_RANGE(0xf1720000, 0xf1720007) AM_READWRITE(namco_spritepos32_r,namco_spritepos32_w)
AM_RANGE(0xf1740000, 0xf175ffff) AM_READWRITE(paletteram32_r,paletteram32_w) AM_BASE_GENERIC(paletteram) AM_RANGE(0xf1740000, 0xf175ffff) AM_READWRITE(paletteram32_r,paletteram32_w) AM_BASE_GENERIC(paletteram)
AM_RANGE(0xf1760000, 0xf1760003) AM_READWRITE(namcos21_video_enable_r,namcos21_video_enable_w) AM_RANGE(0xf1760000, 0xf1760003) AM_READWRITE(namcos21_video_enable_r,namcos21_video_enable_w)
AM_RANGE(0xf2200000, 0xf220ffff) AM_READ(SMH_RAM) AM_WRITE(SMH_RAM) AM_RANGE(0xf2200000, 0xf220ffff) AM_READ(SMH_RAM) AM_WRITE(SMH_RAM)
AM_RANGE(0xf2700000, 0xf270ffff) AM_READ(SMH_RAM) AM_WRITE(SMH_RAM) //AM_READWRITE(namco_obj16_r,namco_obj16_w) AM_RANGE(0xf2700000, 0xf270ffff) AM_READ(SMH_RAM) AM_WRITE(SMH_RAM) //AM_READWRITE(namco_obj16_r,namco_obj16_w)
AM_RANGE(0xf2720000, 0xf2720007) AM_READ(SMH_RAM) AM_WRITE(SMH_RAM) //AM_READWRITE(namco_spritepos16_r,namco_spritepos16_w) AM_RANGE(0xf2720000, 0xf2720007) AM_READ(SMH_RAM) AM_WRITE(SMH_RAM) //AM_READWRITE(namco_spritepos16_r,namco_spritepos16_w)
AM_RANGE(0xf2740000, 0xf275ffff) AM_READ(SMH_RAM) AM_WRITE(SMH_RAM) //AM_READWRITE(paletteram16_r,paletteram16_w) AM_BASE_GENERIC(paletteram) AM_RANGE(0xf2740000, 0xf275ffff) AM_READ(SMH_RAM) AM_WRITE(SMH_RAM) //AM_READWRITE(paletteram16_r,paletteram16_w) AM_BASE_GENERIC(paletteram)
AM_RANGE(0xf2760000, 0xf2760003) AM_READ(SMH_RAM) AM_WRITE(SMH_RAM) //AM_READWRITE(namcos21_video_enable_r,namcos21_video_enable_w) AM_RANGE(0xf2760000, 0xf2760003) AM_READ(SMH_RAM) AM_WRITE(SMH_RAM) //AM_READWRITE(namcos21_video_enable_r,namcos21_video_enable_w)
ADDRESS_MAP_END ADDRESS_MAP_END
static ADDRESS_MAP_START( rs_cpu_map, ADDRESS_SPACE_PROGRAM, 16 ) static ADDRESS_MAP_START( rs_cpu_map, ADDRESS_SPACE_PROGRAM, 16 )
AM_RANGE(0x000000, 0x03ffff) AM_ROM AM_RANGE(0x000000, 0x03ffff) AM_ROM
AM_RANGE(0x100000, 0x10ffff) AM_READ(SMH_RAM) AM_WRITE(SMH_RAM) //64K working RAM AM_RANGE(0x100000, 0x10ffff) AM_READ(SMH_RAM) AM_WRITE(SMH_RAM) //64K working RAM
/// AM_RANGE(0x180000, 0x183fff) AM_RAM //Nvram /// AM_RANGE(0x180000, 0x183fff) AM_RAM //Nvram
AM_RANGE(0x1c0000, 0x1c0001) AM_READ(SMH_RAM) AM_WRITE(SMH_RAM) //148? AM_RANGE(0x1c0000, 0x1c0001) AM_READ(SMH_RAM) AM_WRITE(SMH_RAM) //148?
AM_RANGE(0x1c2000, 0x1c2001) AM_READ(SMH_RAM) AM_WRITE(SMH_RAM) //? AM_RANGE(0x1c2000, 0x1c2001) AM_READ(SMH_RAM) AM_WRITE(SMH_RAM) //?
@ -466,23 +466,23 @@ static ADDRESS_MAP_START( rs_cpu_map, ADDRESS_SPACE_PROGRAM, 16 )
AM_RANGE(0xc00000, 0xc0000f) AM_READ(SMH_RAM) AM_WRITE(SMH_RAM) //? AM_RANGE(0xc00000, 0xc0000f) AM_READ(SMH_RAM) AM_WRITE(SMH_RAM) //?
AM_RANGE(0xc40000, 0xc43fff) AM_READ(SMH_RAM) AM_WRITE(SMH_RAM) //8 bit AM_RANGE(0xc40000, 0xc43fff) AM_READ(SMH_RAM) AM_WRITE(SMH_RAM) //8 bit
/// AM_RANGE(0xc44000, 0xffffff) AM_READ(SMH_RAM) AM_WRITE(SMH_RAM) ///////////// /// AM_RANGE(0xc44000, 0xffffff) AM_READ(SMH_RAM) AM_WRITE(SMH_RAM) /////////////
ADDRESS_MAP_END ADDRESS_MAP_END
static ADDRESS_MAP_START( sound_cpu_map, ADDRESS_SPACE_PROGRAM, 16 ) static ADDRESS_MAP_START( sound_cpu_map, ADDRESS_SPACE_PROGRAM, 16 )
AM_RANGE(0x000000, 0x07ffff) AM_ROM AM_RANGE(0x000000, 0x07ffff) AM_ROM
AM_RANGE(0x080000, 0x08ffff) AM_READ(SMH_RAM) AM_WRITE(SMH_RAM) AM_RANGE(0x080000, 0x08ffff) AM_READ(SMH_RAM) AM_WRITE(SMH_RAM)
/// AM_RANGE(0x0c0000, 0x0cffff) AM_READ(SMH_RAM) AM_WRITE(SMH_RAM) //00, 20, 30, 40, 50 /// AM_RANGE(0x0c0000, 0x0cffff) AM_READ(SMH_RAM) AM_WRITE(SMH_RAM) //00, 20, 30, 40, 50
/// AM_RANGE(0x100000, 0x10000f) AM_READ(SMH_RAM) AM_WRITE(SMH_RAM) /// AM_RANGE(0x100000, 0x10000f) AM_READ(SMH_RAM) AM_WRITE(SMH_RAM)
AM_RANGE(0x110000, 0x113fff) AM_READ(SMH_RAM) AM_WRITE(SMH_RAM) AM_RANGE(0x110000, 0x113fff) AM_READ(SMH_RAM) AM_WRITE(SMH_RAM)
/// AM_RANGE(0x120000, 0x120003) AM_READ(SMH_RAM) AM_WRITE(SMH_RAM) //2ieme byte /// AM_RANGE(0x120000, 0x120003) AM_READ(SMH_RAM) AM_WRITE(SMH_RAM) //2ieme byte
/// AM_RANGE(0x200000, 0x20017f) AM_READ(SMH_RAM) AM_WRITE(SMH_RAM) //C140 /// AM_RANGE(0x200000, 0x20017f) AM_READ(SMH_RAM) AM_WRITE(SMH_RAM) //C140
AM_RANGE(0x200000, 0x2037ff) AM_DEVREADWRITE8("c140_16a", c140_r, c140_w, 0x00ff) //C140/////////// AM_RANGE(0x200000, 0x2037ff) AM_DEVREADWRITE8("c140_16a", c140_r, c140_w, 0x00ff) //C140///////////
/// AM_RANGE(0x201000, 0x20117f) AM_READ(SMH_RAM) AM_WRITE(SMH_RAM) //C140 /// AM_RANGE(0x201000, 0x20117f) AM_READ(SMH_RAM) AM_WRITE(SMH_RAM) //C140
/// AM_RANGE(0x202000, 0x20217f) AM_READ(SMH_RAM) AM_WRITE(SMH_RAM) //C140 /// AM_RANGE(0x202000, 0x20217f) AM_READ(SMH_RAM) AM_WRITE(SMH_RAM) //C140
/// AM_RANGE(0x203000, 0x20317f) AM_READ(SMH_RAM) AM_WRITE(SMH_RAM) //C140 /// AM_RANGE(0x203000, 0x20317f) AM_READ(SMH_RAM) AM_WRITE(SMH_RAM) //C140
AM_RANGE(0x204000, 0x2047ff) AM_DEVREADWRITE8("c140_16g", c140_r, c140_w, 0x00ff) //C140 AM_RANGE(0x204000, 0x2047ff) AM_DEVREADWRITE8("c140_16g", c140_r, c140_w, 0x00ff) //C140
/// AM_RANGE(0x090000, 0xffffff) AM_READ(SMH_RAM) AM_WRITE(SMH_RAM) /// AM_RANGE(0x090000, 0xffffff) AM_READ(SMH_RAM) AM_WRITE(SMH_RAM)
ADDRESS_MAP_END ADDRESS_MAP_END
static ADDRESS_MAP_START( psn_b1_cpu_map, ADDRESS_SPACE_PROGRAM, 16 ) static ADDRESS_MAP_START( psn_b1_cpu_map, ADDRESS_SPACE_PROGRAM, 16 )
@ -650,11 +650,11 @@ static MACHINE_DRIVER_START( gal3 )
MDRV_CPU_ADD("psn_b1_cpu", M68000, 12000000) // ?? MDRV_CPU_ADD("psn_b1_cpu", M68000, 12000000) // ??
MDRV_CPU_PROGRAM_MAP(psn_b1_cpu_map) MDRV_CPU_PROGRAM_MAP(psn_b1_cpu_map)
/* /*
MDRV_CPU_ADD("psn_b2_cpu", M68000, 12000000) // ?? MDRV_CPU_ADD("psn_b2_cpu", M68000, 12000000) // ??
MDRV_CPU_PROGRAM_MAP(psn_b1_cpu_map,0) MDRV_CPU_PROGRAM_MAP(psn_b1_cpu_map,0)
MDRV_CPU_ADD("psn_b3_cpu", M68000, 12000000) // ?? MDRV_CPU_ADD("psn_b3_cpu", M68000, 12000000) // ??
MDRV_CPU_PROGRAM_MAP(psn_b1_cpu_map,0) MDRV_CPU_PROGRAM_MAP(psn_b1_cpu_map,0)
*/ */
MDRV_QUANTUM_TIME(HZ(60*8000)) /* 8000 CPU slices per frame */ MDRV_QUANTUM_TIME(HZ(60*8000)) /* 8000 CPU slices per frame */
@ -905,6 +905,6 @@ ROM_START( gal3 )
DISK_IMAGE_READONLY( "gal3_ld2", 0, NO_DUMP ) DISK_IMAGE_READONLY( "gal3_ld2", 0, NO_DUMP )
ROM_END ROM_END
/* YEAR, NAME, PARENT, MACHINE, INPUT, INIT, MONITOR, COMPANY, FULLNAME, FLAGS */ /* YEAR, NAME, PARENT, MACHINE, INPUT, INIT, MONITOR, COMPANY, FULLNAME, FLAGS */
GAMEL( 199?, gal3, 0, gal3, gal3, 0, ROT0, "Namco", "Galaxian 3 - Theater 6 : Project Dragoon", GAME_NOT_WORKING | GAME_NO_SOUND, layout_dualhsxs ) GAMEL( 199?, gal3, 0, gal3, gal3, 0, ROT0, "Namco", "Galaxian 3 - Theater 6 : Project Dragoon", GAME_NOT_WORKING | GAME_NO_SOUND, layout_dualhsxs )
//GAMEL( 199?, gal3zlgr, 0, gal3, gal3, 0, ROT0, "Namco", "Galaxian 3 - Theater 6 J2 : Attack of The Zolgear", GAME_NOT_WORKING | GAME_NO_SOUND, layout_dualhsxs ) //GAMEL( 199?, gal3zlgr, 0, gal3, gal3, 0, ROT0, "Namco", "Galaxian 3 - Theater 6 J2 : Attack of The Zolgear", GAME_NOT_WORKING | GAME_NO_SOUND, layout_dualhsxs )

6
src/mame/drivers/galaxi.c
View File

@ -53,8 +53,8 @@ struct _galaxi_state
UINT16 * bg3_ram; UINT16 * bg3_ram;
UINT16 * bg4_ram; UINT16 * bg4_ram;
UINT16 * fg_ram; UINT16 * fg_ram;
// UINT16 * paletteram; // currently this uses generic palette handling // UINT16 * paletteram; // currently this uses generic palette handling
// UINT16 * nvram; // currently this uses generic nvram handling // UINT16 * nvram; // currently this uses generic nvram handling
/* video-related */ /* video-related */
tilemap *bg1_tmap, *bg2_tmap, *bg3_tmap, *bg4_tmap, *fg_tmap; tilemap *bg1_tmap, *bg2_tmap, *bg3_tmap, *bg4_tmap, *fg_tmap;
@ -195,7 +195,7 @@ static VIDEO_UPDATE(galaxi)
static void show_out( running_machine *machine ) static void show_out( running_machine *machine )
{ {
// galaxi_state *state = (galaxi_state *)machine->driver_data; // galaxi_state *state = (galaxi_state *)machine->driver_data;
// popmessage("%04x %04x %04x", state->out[0], state->out[1], state->out[2]); // popmessage("%04x %04x %04x", state->out[0], state->out[1], state->out[2]);
} }

4
src/mame/drivers/groundfx.c
View File

@ -165,7 +165,7 @@ static WRITE32_HANDLER( groundfx_input_w )
if (ACCESSING_BITS_0_7) if (ACCESSING_BITS_0_7)
{ {
input_port_write(space->machine, "EEPROMOUT", data, 0xff); input_port_write(space->machine, "EEPROMOUT", data, 0xff);
} }
break; break;
@ -375,7 +375,7 @@ static MACHINE_DRIVER_START( groundfx )
TAITO_F3_SOUND_SYSTEM_CPU(16000000) TAITO_F3_SOUND_SYSTEM_CPU(16000000)
MDRV_MACHINE_RESET(groundfx) MDRV_MACHINE_RESET(groundfx)
// MDRV_NVRAM_HANDLER(groundfx) // MDRV_NVRAM_HANDLER(groundfx)
MDRV_EEPROM_ADD("eeprom", groundfx_eeprom_interface, 128, default_eeprom) MDRV_EEPROM_ADD("eeprom", groundfx_eeprom_interface, 128, default_eeprom)
/* video hardware */ /* video hardware */

38
src/mame/drivers/hng64.c
View File

@ -580,8 +580,8 @@ static READ32_HANDLER( hng64_sysregs_r )
mame_system_time systime; mame_system_time systime;
mame_get_base_datetime(space->machine, &systime); mame_get_base_datetime(space->machine, &systime);
// if((offset*4) != 0x1084) // if((offset*4) != 0x1084)
// printf("HNG64 port read (PC=%08x) 0x%08x\n", cpu_get_pc(space->cpu),offset*4); // printf("HNG64 port read (PC=%08x) 0x%08x\n", cpu_get_pc(space->cpu),offset*4);
switch(offset*4) switch(offset*4)
{ {
@ -612,7 +612,7 @@ static READ32_HANDLER( hng64_sysregs_r )
case 0x217c: return 0; //RTC status? case 0x217c: return 0; //RTC status?
} }
// printf("%08x\n",offset*4); // printf("%08x\n",offset*4);
//return mame_rand(space->machine)&0xffffffff; //return mame_rand(space->machine)&0xffffffff;
return hng64_sysregs[offset]; return hng64_sysregs[offset];
@ -654,8 +654,8 @@ static WRITE32_HANDLER( hng64_sysregs_w )
{ {
COMBINE_DATA (&hng64_sysregs[offset]); COMBINE_DATA (&hng64_sysregs[offset]);
// if(((offset*4) & 0x1200) == 0x1200) // if(((offset*4) & 0x1200) == 0x1200)
// printf("HNG64 writing to SYSTEM Registers 0x%08x == 0x%08x. (PC=%08x)\n", offset*4, hng64_sysregs[offset], cpu_get_pc(space->cpu)); // printf("HNG64 writing to SYSTEM Registers 0x%08x == 0x%08x. (PC=%08x)\n", offset*4, hng64_sysregs[offset], cpu_get_pc(space->cpu));
switch(offset*4) switch(offset*4)
{ {
@ -796,17 +796,17 @@ static READ32_HANDLER( racing_io_r )
static READ32_HANDLER( hng64_dualport_r ) static READ32_HANDLER( hng64_dualport_r )
{ {
// printf("dualport R %08x %08x (PC=%08x)\n", offset*4, hng64_dualport[offset], cpu_get_pc(space->cpu)); // printf("dualport R %08x %08x (PC=%08x)\n", offset*4, hng64_dualport[offset], cpu_get_pc(space->cpu));
/* /*
command table: command table:
0x0b = ? mode input polling (sams64, bbust2, sams64_2 & roadedge) (*) 0x0b = ? mode input polling (sams64, bbust2, sams64_2 & roadedge) (*)
0x0c = cut down connections, treats the dualport to be normal RAM 0x0c = cut down connections, treats the dualport to be normal RAM
0x11 = ? mode input polling (fatfurwa, xrally, buriki) (*) 0x11 = ? mode input polling (fatfurwa, xrally, buriki) (*)
0x20 = asks for MCU machine code 0x20 = asks for MCU machine code
(*) 0x11 is followed by 0x0b if the latter is used, JVS-esque indirect/direct mode? (*) 0x11 is followed by 0x0b if the latter is used, JVS-esque indirect/direct mode?
*/ */
if(hng_mcu_en == 0x0c) if(hng_mcu_en == 0x0c)
return hng64_dualport[offset]; return hng64_dualport[offset];
@ -834,7 +834,7 @@ Beast Busters 2 outputs (all at offset == 0x1c):
static WRITE32_HANDLER( hng64_dualport_w ) static WRITE32_HANDLER( hng64_dualport_w )
{ {
// printf("dualport WRITE %08x %08x (PC=%08x)\n", offset*4, hng64_dualport[offset], cpu_get_pc(space->cpu)); // printf("dualport WRITE %08x %08x (PC=%08x)\n", offset*4, hng64_dualport[offset], cpu_get_pc(space->cpu));
COMBINE_DATA (&hng64_dualport[offset]); COMBINE_DATA (&hng64_dualport[offset]);
} }
@ -945,7 +945,7 @@ static WRITE32_HANDLER( tcram_w )
static READ32_HANDLER( tcram_r ) static READ32_HANDLER( tcram_r )
{ {
// printf("Q1 R : %.8x %.8x\n", offset, hng64_tcram[offset]) ; // printf("Q1 R : %.8x %.8x\n", offset, hng64_tcram[offset]) ;
if(offset == 0x12) if(offset == 0x12)
return input_port_read(space->machine, "VBLANK"); return input_port_read(space->machine, "VBLANK");
@ -1691,11 +1691,11 @@ static DRIVER_INIT( hng64 )
// region hacking, english error messages are more useful to us, but no english bios is dumped... // region hacking, english error messages are more useful to us, but no english bios is dumped...
#ifdef HACK_REGION #ifdef HACK_REGION
// versions according to fatal fury test mode // versions according to fatal fury test mode
// hng64_patch_bios_region(machine, 0); // 'Others Ver' (invalid?) // hng64_patch_bios_region(machine, 0); // 'Others Ver' (invalid?)
hng64_patch_bios_region(machine, 1); // Japan hng64_patch_bios_region(machine, 1); // Japan
// hng64_patch_bios_region(machine, 2); // USA // hng64_patch_bios_region(machine, 2); // USA
// hng64_patch_bios_region(machine, 3); // Korea // hng64_patch_bios_region(machine, 3); // Korea
// hng64_patch_bios_region(machine, 4); // 'Others' // hng64_patch_bios_region(machine, 4); // 'Others'
#endif #endif
hng64_soundram=auto_alloc_array(machine, UINT16, 0x200000/2); hng64_soundram=auto_alloc_array(machine, UINT16, 0x200000/2);

12
src/mame/drivers/igs017.c
View File

@ -1926,13 +1926,13 @@ static INPUT_PORTS_START( mgdh )
PORT_BIT( 0x80, IP_ACTIVE_LOW, IPT_UNKNOWN ) PORT_BIT( 0x80, IP_ACTIVE_LOW, IPT_UNKNOWN )
PORT_START("BUTTONS") PORT_START("BUTTONS")
PORT_BIT( 0x01, IP_ACTIVE_LOW, IPT_UNKNOWN ) PORT_BIT( 0x01, IP_ACTIVE_LOW, IPT_UNKNOWN )
PORT_BIT( 0x02, IP_ACTIVE_LOW, IPT_BUTTON3 ) PORT_BIT( 0x02, IP_ACTIVE_LOW, IPT_BUTTON3 )
PORT_BIT( 0x04, IP_ACTIVE_LOW, IPT_UNKNOWN ) PORT_BIT( 0x04, IP_ACTIVE_LOW, IPT_UNKNOWN )
PORT_BIT( 0x08, IP_ACTIVE_LOW, IPT_UNKNOWN ) PORT_BIT( 0x08, IP_ACTIVE_LOW, IPT_UNKNOWN )
PORT_BIT( 0x10, IP_ACTIVE_LOW, IPT_UNKNOWN ) PORT_BIT( 0x10, IP_ACTIVE_LOW, IPT_UNKNOWN )
PORT_BIT( 0x20, IP_ACTIVE_LOW, IPT_UNKNOWN ) PORT_BIT( 0x20, IP_ACTIVE_LOW, IPT_UNKNOWN )
PORT_BIT( 0x40, IP_ACTIVE_LOW, IPT_UNKNOWN ) PORT_BIT( 0x40, IP_ACTIVE_LOW, IPT_UNKNOWN )
PORT_BIT( 0x80, IP_ACTIVE_LOW, IPT_BUTTON2 ) PORT_BIT( 0x80, IP_ACTIVE_LOW, IPT_BUTTON2 )
INPUT_PORTS_END INPUT_PORTS_END

36
src/mame/drivers/jokrwild.c
View File

@ -240,14 +240,14 @@ static INPUT_PORTS_START( jokrwild )
PORT_DIPSETTING( 0x80, DEF_STR( Off ) ) PORT_DIPSETTING( 0x80, DEF_STR( Off ) )
PORT_DIPSETTING( 0x00, DEF_STR( On ) ) PORT_DIPSETTING( 0x00, DEF_STR( On ) )
/* PORT_BIT( 0x01, IP_ACTIVE_LOW, IPT_SERVICE ) PORT_NAME("0-1") PORT_CODE(KEYCODE_1) /* PORT_BIT( 0x01, IP_ACTIVE_LOW, IPT_SERVICE ) PORT_NAME("0-1") PORT_CODE(KEYCODE_1)
PORT_BIT( 0x02, IP_ACTIVE_LOW, IPT_SERVICE ) PORT_NAME("0-2") PORT_CODE(KEYCODE_2) PORT_BIT( 0x02, IP_ACTIVE_LOW, IPT_SERVICE ) PORT_NAME("0-2") PORT_CODE(KEYCODE_2)
PORT_BIT( 0x04, IP_ACTIVE_LOW, IPT_SERVICE ) PORT_NAME("0-3") PORT_CODE(KEYCODE_3) PORT_BIT( 0x04, IP_ACTIVE_LOW, IPT_SERVICE ) PORT_NAME("0-3") PORT_CODE(KEYCODE_3)
PORT_BIT( 0x08, IP_ACTIVE_LOW, IPT_SERVICE ) PORT_NAME("0-4") PORT_CODE(KEYCODE_4) PORT_BIT( 0x08, IP_ACTIVE_LOW, IPT_SERVICE ) PORT_NAME("0-4") PORT_CODE(KEYCODE_4)
PORT_BIT( 0x10, IP_ACTIVE_LOW, IPT_SERVICE ) PORT_NAME("0-5") PORT_CODE(KEYCODE_5) PORT_BIT( 0x10, IP_ACTIVE_LOW, IPT_SERVICE ) PORT_NAME("0-5") PORT_CODE(KEYCODE_5)
PORT_BIT( 0x20, IP_ACTIVE_LOW, IPT_SERVICE ) PORT_NAME("0-6") PORT_CODE(KEYCODE_6) PORT_BIT( 0x20, IP_ACTIVE_LOW, IPT_SERVICE ) PORT_NAME("0-6") PORT_CODE(KEYCODE_6)
PORT_BIT( 0x40, IP_ACTIVE_LOW, IPT_SERVICE ) PORT_NAME("0-7") PORT_CODE(KEYCODE_7) PORT_BIT( 0x40, IP_ACTIVE_LOW, IPT_SERVICE ) PORT_NAME("0-7") PORT_CODE(KEYCODE_7)
PORT_BIT( 0x80, IP_ACTIVE_LOW, IPT_SERVICE ) PORT_NAME("0-8") PORT_CODE(KEYCODE_8) PORT_BIT( 0x80, IP_ACTIVE_LOW, IPT_SERVICE ) PORT_NAME("0-8") PORT_CODE(KEYCODE_8)
*/ */
PORT_START("IN1") PORT_START("IN1")
PORT_DIPNAME( 0x01, 0x01, DEF_STR( Unknown ) ) PORT_DIPNAME( 0x01, 0x01, DEF_STR( Unknown ) )
@ -274,14 +274,14 @@ static INPUT_PORTS_START( jokrwild )
PORT_DIPNAME( 0x80, 0x80, DEF_STR( Unknown ) ) PORT_DIPNAME( 0x80, 0x80, DEF_STR( Unknown ) )
PORT_DIPSETTING( 0x80, DEF_STR( Off ) ) PORT_DIPSETTING( 0x80, DEF_STR( Off ) )
PORT_DIPSETTING( 0x00, DEF_STR( On ) ) PORT_DIPSETTING( 0x00, DEF_STR( On ) )
/* PORT_BIT( 0x01, IP_ACTIVE_LOW, IPT_SERVICE ) PORT_NAME("1-1") PORT_CODE(KEYCODE_Q) /* PORT_BIT( 0x01, IP_ACTIVE_LOW, IPT_SERVICE ) PORT_NAME("1-1") PORT_CODE(KEYCODE_Q)
PORT_BIT( 0x02, IP_ACTIVE_LOW, IPT_SERVICE ) PORT_NAME("1-2") PORT_CODE(KEYCODE_W) PORT_BIT( 0x02, IP_ACTIVE_LOW, IPT_SERVICE ) PORT_NAME("1-2") PORT_CODE(KEYCODE_W)
PORT_BIT( 0x04, IP_ACTIVE_LOW, IPT_SERVICE ) PORT_NAME("1-3") PORT_CODE(KEYCODE_E) PORT_BIT( 0x04, IP_ACTIVE_LOW, IPT_SERVICE ) PORT_NAME("1-3") PORT_CODE(KEYCODE_E)
PORT_BIT( 0x08, IP_ACTIVE_LOW, IPT_SERVICE ) PORT_NAME("1-4") PORT_CODE(KEYCODE_R) PORT_BIT( 0x08, IP_ACTIVE_LOW, IPT_SERVICE ) PORT_NAME("1-4") PORT_CODE(KEYCODE_R)
PORT_BIT( 0x10, IP_ACTIVE_LOW, IPT_SERVICE ) PORT_NAME("1-5") PORT_CODE(KEYCODE_T) PORT_BIT( 0x10, IP_ACTIVE_LOW, IPT_SERVICE ) PORT_NAME("1-5") PORT_CODE(KEYCODE_T)
PORT_BIT( 0x20, IP_ACTIVE_LOW, IPT_SERVICE ) PORT_NAME("1-6") PORT_CODE(KEYCODE_Y) PORT_BIT( 0x20, IP_ACTIVE_LOW, IPT_SERVICE ) PORT_NAME("1-6") PORT_CODE(KEYCODE_Y)
PORT_BIT( 0x40, IP_ACTIVE_LOW, IPT_SERVICE ) PORT_NAME("1-7") PORT_CODE(KEYCODE_U) PORT_BIT( 0x40, IP_ACTIVE_LOW, IPT_SERVICE ) PORT_NAME("1-7") PORT_CODE(KEYCODE_U)
PORT_BIT( 0x80, IP_ACTIVE_LOW, IPT_SERVICE ) PORT_NAME("1-8") PORT_CODE(KEYCODE_I) PORT_BIT( 0x80, IP_ACTIVE_LOW, IPT_SERVICE ) PORT_NAME("1-8") PORT_CODE(KEYCODE_I)
*/ */
PORT_START("IN2") PORT_START("IN2")
PORT_BIT( 0x01, IP_ACTIVE_LOW, IPT_SERVICE ) PORT_NAME("2-1") PORT_CODE(KEYCODE_A) PORT_BIT( 0x01, IP_ACTIVE_LOW, IPT_SERVICE ) PORT_NAME("2-1") PORT_CODE(KEYCODE_A)
@ -388,12 +388,12 @@ GFXDECODE_END
static WRITE8_DEVICE_HANDLER( testa_w ) static WRITE8_DEVICE_HANDLER( testa_w )
{ {
// printf("%02x A\n",data); // printf("%02x A\n",data);
} }
static WRITE8_DEVICE_HANDLER( testb_w ) static WRITE8_DEVICE_HANDLER( testb_w )
{ {
// printf("%02x B\n",data); // printf("%02x B\n",data);
} }
static const pia6821_interface pia0_intf = static const pia6821_interface pia0_intf =

2
src/mame/drivers/kaneko16.c
View File

@ -335,7 +335,7 @@ static WRITE16_HANDLER( kaneko16_eeprom_w )
{ {
if (ACCESSING_BITS_0_7) if (ACCESSING_BITS_0_7)
{ {
input_port_write(space->machine, "EEPROMOUT", data, 0xff); input_port_write(space->machine, "EEPROMOUT", data, 0xff);
} }
if (ACCESSING_BITS_8_15) if (ACCESSING_BITS_8_15)

2
src/mame/drivers/konamigq.c
View File

@ -118,7 +118,7 @@ static const UINT8 konamigq_def_eeprom[128] =
static WRITE32_HANDLER( eeprom_w ) static WRITE32_HANDLER( eeprom_w )
{ {
input_port_write(space->machine, "EEPROMOUT", data & 0x07, 0xff); input_port_write(space->machine, "EEPROMOUT", data & 0x07, 0xff);
cputag_set_input_line(space->machine, "soundcpu", INPUT_LINE_RESET, ( data & 0x40 ) ? CLEAR_LINE : ASSERT_LINE ); cputag_set_input_line(space->machine, "soundcpu", INPUT_LINE_RESET, ( data & 0x40 ) ? CLEAR_LINE : ASSERT_LINE );
} }

6
src/mame/drivers/limenko.c
View File

@ -522,7 +522,7 @@ static INPUT_PORTS_START( legendoh )
PORT_BIT( 0x00010000, IP_ACTIVE_LOW, IPT_OUTPUT ) PORT_WRITE_LINE_DEVICE("eeprom", eepromdev_set_cs_line) PORT_BIT( 0x00010000, IP_ACTIVE_LOW, IPT_OUTPUT ) PORT_WRITE_LINE_DEVICE("eeprom", eepromdev_set_cs_line)
PORT_BIT( 0x00020000, IP_ACTIVE_HIGH, IPT_OUTPUT ) PORT_WRITE_LINE_DEVICE("eeprom", eepromdev_set_clock_line) PORT_BIT( 0x00020000, IP_ACTIVE_HIGH, IPT_OUTPUT ) PORT_WRITE_LINE_DEVICE("eeprom", eepromdev_set_clock_line)
PORT_BIT( 0x00040000, IP_ACTIVE_HIGH, IPT_OUTPUT ) PORT_WRITE_LINE_DEVICE("eeprom", eepromdev_write_bit) PORT_BIT( 0x00040000, IP_ACTIVE_HIGH, IPT_OUTPUT ) PORT_WRITE_LINE_DEVICE("eeprom", eepromdev_write_bit)
// PORT_BIT( 0x00080000, IP_ACTIVE_HIGH, IPT_UNKNOWN ) // 0x80000 -> video disabled? // PORT_BIT( 0x00080000, IP_ACTIVE_HIGH, IPT_UNKNOWN ) // 0x80000 -> video disabled?
INPUT_PORTS_END INPUT_PORTS_END
static INPUT_PORTS_START( sb2003 ) static INPUT_PORTS_START( sb2003 )
@ -567,7 +567,7 @@ static INPUT_PORTS_START( sb2003 )
PORT_BIT( 0x00010000, IP_ACTIVE_LOW, IPT_OUTPUT ) PORT_WRITE_LINE_DEVICE("eeprom", eepromdev_set_cs_line) PORT_BIT( 0x00010000, IP_ACTIVE_LOW, IPT_OUTPUT ) PORT_WRITE_LINE_DEVICE("eeprom", eepromdev_set_cs_line)
PORT_BIT( 0x00020000, IP_ACTIVE_HIGH, IPT_OUTPUT ) PORT_WRITE_LINE_DEVICE("eeprom", eepromdev_set_clock_line) PORT_BIT( 0x00020000, IP_ACTIVE_HIGH, IPT_OUTPUT ) PORT_WRITE_LINE_DEVICE("eeprom", eepromdev_set_clock_line)
PORT_BIT( 0x00040000, IP_ACTIVE_HIGH, IPT_OUTPUT ) PORT_WRITE_LINE_DEVICE("eeprom", eepromdev_write_bit) PORT_BIT( 0x00040000, IP_ACTIVE_HIGH, IPT_OUTPUT ) PORT_WRITE_LINE_DEVICE("eeprom", eepromdev_write_bit)
// PORT_BIT( 0x00080000, IP_ACTIVE_HIGH, IPT_UNKNOWN ) // 0x80000 -> video disabled? // PORT_BIT( 0x00080000, IP_ACTIVE_HIGH, IPT_UNKNOWN ) // 0x80000 -> video disabled?
INPUT_PORTS_END INPUT_PORTS_END
static INPUT_PORTS_START( spotty ) static INPUT_PORTS_START( spotty )
@ -611,7 +611,7 @@ static INPUT_PORTS_START( spotty )
PORT_BIT( 0x00010000, IP_ACTIVE_LOW, IPT_OUTPUT ) PORT_WRITE_LINE_DEVICE("eeprom", eepromdev_set_cs_line) PORT_BIT( 0x00010000, IP_ACTIVE_LOW, IPT_OUTPUT ) PORT_WRITE_LINE_DEVICE("eeprom", eepromdev_set_cs_line)
PORT_BIT( 0x00020000, IP_ACTIVE_HIGH, IPT_OUTPUT ) PORT_WRITE_LINE_DEVICE("eeprom", eepromdev_set_clock_line) PORT_BIT( 0x00020000, IP_ACTIVE_HIGH, IPT_OUTPUT ) PORT_WRITE_LINE_DEVICE("eeprom", eepromdev_set_clock_line)
PORT_BIT( 0x00040000, IP_ACTIVE_HIGH, IPT_OUTPUT ) PORT_WRITE_LINE_DEVICE("eeprom", eepromdev_write_bit) PORT_BIT( 0x00040000, IP_ACTIVE_HIGH, IPT_OUTPUT ) PORT_WRITE_LINE_DEVICE("eeprom", eepromdev_write_bit)
// PORT_BIT( 0x00080000, IP_ACTIVE_HIGH, IPT_UNKNOWN ) // 0x80000 -> video disabled? // PORT_BIT( 0x00080000, IP_ACTIVE_HIGH, IPT_UNKNOWN ) // 0x80000 -> video disabled?
INPUT_PORTS_END INPUT_PORTS_END
/***************************************************************************************************** /*****************************************************************************************************

2
src/mame/drivers/metro.c
View File

@ -1785,7 +1785,7 @@ static ADDRESS_MAP_START( puzzlet_map, ADDRESS_SPACE_PROGRAM, 16 )
AM_RANGE( 0x720000, 0x73ffff ) AM_READWRITE( SMH_RAM, metro_vram_1_w ) AM_BASE( &metro_vram_1 ) // Layer 1 AM_RANGE( 0x720000, 0x73ffff ) AM_READWRITE( SMH_RAM, metro_vram_1_w ) AM_BASE( &metro_vram_1 ) // Layer 1
AM_RANGE( 0x740000, 0x75ffff ) AM_READWRITE( SMH_RAM, metro_vram_2_w ) AM_BASE( &metro_vram_2 ) // Layer 2 AM_RANGE( 0x740000, 0x75ffff ) AM_READWRITE( SMH_RAM, metro_vram_2_w ) AM_BASE( &metro_vram_2 ) // Layer 2
AM_RANGE( 0x774000, 0x774fff ) AM_RAM AM_BASE_SIZE_GENERIC( spriteram ) AM_RANGE( 0x774000, 0x774fff ) AM_RAM AM_BASE_SIZE_GENERIC( spriteram )
AM_RANGE( 0x760000, 0x76ffff ) AM_READ( metro_bankedrom_r ) // Banked ROM AM_RANGE( 0x760000, 0x76ffff ) AM_READ( metro_bankedrom_r ) // Banked ROM
// AM_RANGE( 0x772000, 0x773fff ) AM_RAM // AM_RANGE( 0x772000, 0x773fff ) AM_RAM

4
src/mame/drivers/missb2.c
View File

@ -38,7 +38,7 @@ static VIDEO_UPDATE( missb2 )
bitmap_fill(bitmap, cliprect, 255); bitmap_fill(bitmap, cliprect, 255);
if (!state->video_enable) if (!state->video_enable)
return 0; return 0;
/* background map register */ /* background map register */
@ -359,7 +359,7 @@ static MACHINE_START( missb2 )
{ {
bublbobl_state *state = (bublbobl_state *)machine->driver_data; bublbobl_state *state = (bublbobl_state *)machine->driver_data;
state->mcu = NULL; state->mcu = NULL;
state_save_register_global(machine, state->sound_nmi_enable); state_save_register_global(machine, state->sound_nmi_enable);
state_save_register_global(machine, state->pending_nmi); state_save_register_global(machine, state->pending_nmi);

6
src/mame/drivers/namcops2.c
View File

@ -4,7 +4,7 @@
Namco System 246 / System 256 games (Sony PS2 based) Namco System 246 / System 256 games (Sony PS2 based)
PS2 baseboard includes: PS2 baseboard includes:
* R5900 "Emotion Engine" - MIPS III with 128-bit integer regs & SIMD * R5900 "Emotion Engine" - MIPS III with 128-bit integer regs & SIMD
* R3000 IOP - Stock R3000 with cache, not like the PSXCPU * R3000 IOP - Stock R3000 with cache, not like the PSXCPU
* VU0 - can operate either as in-line R5900 coprocessor or run independently * VU0 - can operate either as in-line R5900 coprocessor or run independently
@ -191,12 +191,12 @@ ROM_START( taiko9 )
DISK_REGION("dvd") DISK_REGION("dvd")
ROM_END ROM_END
ROM_START( tekken4 ) ROM_START( tekken4 )
ROM_REGION(0x200000, "bios", 0) ROM_REGION(0x200000, "bios", 0)
SYSTEM246_BIOS SYSTEM246_BIOS
ROM_REGION(0x840000, "key", ROMREGION_ERASE00) ROM_REGION(0x840000, "key", ROMREGION_ERASE00)
ROM_LOAD( "tef3verc.ic002", 0x000000, 0x800000, CRC(8a41290c) SHA1(2c674e3203c7b5302430b1c1115fcf591a0dcbf2) ) ROM_LOAD( "tef3verc.ic002", 0x000000, 0x800000, CRC(8a41290c) SHA1(2c674e3203c7b5302430b1c1115fcf591a0dcbf2) )
ROM_LOAD( "tef3verc_spr.ic002", 0x800000, 0x040000, CRC(af248bf7) SHA1(b99193fcdad683c0bbd684f37dfea5c5412b398e) ) ROM_LOAD( "tef3verc_spr.ic002", 0x800000, 0x040000, CRC(af248bf7) SHA1(b99193fcdad683c0bbd684f37dfea5c5412b398e) )
DISK_REGION("dvd") DISK_REGION("dvd")

118
src/mame/drivers/norautp.c
View File

@ -22,7 +22,7 @@
* Noraut Joker Poker (V3.011a), 2003, Noraut Ltd. * Noraut Joker Poker (V3.011a), 2003, Noraut Ltd.
* Noraut unknown set 1 (console), 198?, Noraut Ltd. * Noraut unknown set 1 (console), 198?, Noraut Ltd.
* Noraut unknown set 2 (console), 198?, Noraut Ltd. * Noraut unknown set 2 (console), 198?, Noraut Ltd.
* Mainline Double Joker Poker, 198?, Mainline London. * Mainline Double Joker Poker, 198?, Mainline London.
* Double Joker Poker (45%-75% payout), 199?, DellFern Ltd. * Double Joker Poker (45%-75% payout), 199?, DellFern Ltd.
* Royal on Ten (Noraut Deluxe hack), 2005, Unknown. * Royal on Ten (Noraut Deluxe hack), 2005, Unknown.
* Credit Poker (ver.30c, standard), 1999, CGI. * Credit Poker (ver.30c, standard), 1999, CGI.
@ -1408,7 +1408,7 @@ static ADDRESS_MAP_START( nortest1_map, ADDRESS_SPACE_PROGRAM, 8 )
ADDRESS_MAP_END ADDRESS_MAP_END
static ADDRESS_MAP_START( norautxp_map, ADDRESS_SPACE_PROGRAM, 8 ) static ADDRESS_MAP_START( norautxp_map, ADDRESS_SPACE_PROGRAM, 8 )
// ADDRESS_MAP_GLOBAL_MASK(~0x4000) // ADDRESS_MAP_GLOBAL_MASK(~0x4000)
ADDRESS_MAP_GLOBAL_MASK(0x7fff) ADDRESS_MAP_GLOBAL_MASK(0x7fff)
AM_RANGE(0x0000, 0x3fff) AM_ROM /* need to be checked */ AM_RANGE(0x0000, 0x3fff) AM_ROM /* need to be checked */
AM_RANGE(0x6000, 0x67ff) AM_RAM AM_BASE_SIZE_GENERIC(nvram) /* HM6116 */ AM_RANGE(0x6000, 0x67ff) AM_RAM AM_BASE_SIZE_GENERIC(nvram) /* HM6116 */
@ -2104,8 +2104,8 @@ ROM_END
Noraut Red Hot 1-bet Joker Poker. Noraut Red Hot 1-bet Joker Poker.
Last release of Noraut's Joker Poker. Always have joker with multi change card Last release of Noraut's Joker Poker. Always have joker with multi change card
and hint card in gamble. Quite popular in Norther Ireland but some operators and hint card in gamble. Quite popular in Norther Ireland but some operators
have the percentage to payout at less than 10% have the percentage to payout at less than 10%
*/ */
@ -2227,7 +2227,7 @@ ROM_END
/* /*
V3011a V3011a
cpu :Z84C0006PEC cpu :Z84C0006PEC
Prog eprom marked Prog eprom marked
@ -2604,7 +2604,7 @@ ROM_END
ROM text showed poker text and ROM text showed poker text and
COPYRIGHT 1986 DREWS INC. COPYRIGHT 1986 DREWS INC.
COPYRIGHT 1986 DREW'S DISTRIBUTING INC. COPYRIGHT 1986 DREW'S DISTRIBUTING INC.
*/ */
ROM_START( drhl ) ROM_START( drhl )
@ -2676,90 +2676,90 @@ ROM_END
*/ */
//static DRIVER_INIT( norautrh ) //static DRIVER_INIT( norautrh )
//{ //{
// UINT8 *ROM = memory_region(machine, "maincpu"); // UINT8 *ROM = memory_region(machine, "maincpu");
// ROM[0x1110] = 0x00; // ROM[0x1110] = 0x00;
// ROM[0x1111] = 0x00; // ROM[0x1111] = 0x00;
//} //}
//static DRIVER_INIT( norautpn ) //static DRIVER_INIT( norautpn )
//{ //{
// UINT8 *ROM = memory_region(machine, "maincpu"); // UINT8 *ROM = memory_region(machine, "maincpu");
// ROM[0x0827] = 0x00; // ROM[0x0827] = 0x00;
// ROM[0x0828] = 0x00; // ROM[0x0828] = 0x00;
//} //}
//static DRIVER_INIT( norautu ) //static DRIVER_INIT( norautu )
//{ //{
// UINT8 *ROM = memory_region(machine, "maincpu"); // UINT8 *ROM = memory_region(machine, "maincpu");
// ROM[0x083c] = 0x00; // ROM[0x083c] = 0x00;
// ROM[0x083d] = 0x00; // ROM[0x083d] = 0x00;
// ROM[0x083e] = 0x00; // ROM[0x083e] = 0x00;
//} //}
//static DRIVER_INIT( gtipoker ) //static DRIVER_INIT( gtipoker )
//{ //{
// UINT8 *ROM = memory_region(machine, "maincpu"); // UINT8 *ROM = memory_region(machine, "maincpu");
// ROM[0x0cc6] = 0x00; // ROM[0x0cc6] = 0x00;
// ROM[0x0cc7] = 0x00; // ROM[0x0cc7] = 0x00;
// ROM[0x0cc8] = 0x00; // ROM[0x0cc8] = 0x00;
// ROM[0x10a5] = 0x00; // ROM[0x10a5] = 0x00;
// ROM[0x10a6] = 0x00; // ROM[0x10a6] = 0x00;
// ROM[0x10a7] = 0x00; // ROM[0x10a7] = 0x00;
//} //}
//static DRIVER_INIT( dphl ) //static DRIVER_INIT( dphl )
//{ //{
// UINT8 *ROM = memory_region(machine, "maincpu"); // UINT8 *ROM = memory_region(machine, "maincpu");
// ROM[0x1510] = 0x00; // ROM[0x1510] = 0x00;
// ROM[0x1511] = 0x00; // ROM[0x1511] = 0x00;
// ROM[0x1512] = 0x00; // ROM[0x1512] = 0x00;
//} //}
//static DRIVER_INIT( dphla ) //static DRIVER_INIT( dphla )
//{ //{
// UINT8 *ROM = memory_region(machine, "maincpu"); // UINT8 *ROM = memory_region(machine, "maincpu");
// ROM[0x0b09] = 0x00; // ROM[0x0b09] = 0x00;
// ROM[0x0b0a] = 0x00; // ROM[0x0b0a] = 0x00;
// ROM[0x0b0b] = 0x00; // ROM[0x0b0b] = 0x00;
//} //}
static DRIVER_INIT( enc ) static DRIVER_INIT( enc )
{ {
/* Attempt to decrypt the program ROM */ /* Attempt to decrypt the program ROM */
// UINT8 *rom = memory_region(machine, "maincpu"); // UINT8 *rom = memory_region(machine, "maincpu");
// UINT8 *buffer; // UINT8 *buffer;
// int size = 0x2000; //memory_region_length(machine, "maincpu"); // int size = 0x2000; //memory_region_length(machine, "maincpu");
// int start = 0; // int start = 0;
// int i; // int i;
// for (i = start; i < size; i++) // for (i = start; i < size; i++)
// { // {
// rom[i] = rom[i] ^ 0x09 ^ 0xff; // rom[i] = rom[i] ^ 0x09 ^ 0xff;
// rom[i+1] = rom[i+1] ^ 0xfb ^ 0xff; // rom[i+1] = rom[i+1] ^ 0xfb ^ 0xff;
// rom[i+2] = rom[i+2] ^ 0xb2 ^ 0xff; // rom[i+2] = rom[i+2] ^ 0xb2 ^ 0xff;
// rom[i+3] = rom[i+3] ^ 0x60 ^ 0xff; // rom[i+3] = rom[i+3] ^ 0x60 ^ 0xff;
// rom[i+4] = rom[i+4] ^ 0xce ^ 0xff; // rom[i+4] = rom[i+4] ^ 0xce ^ 0xff;
// rom[i+5] = rom[i+5] ^ 0x44 ^ 0xff; // rom[i+5] = rom[i+5] ^ 0x44 ^ 0xff;
// rom[i+6] = rom[i+6] ^ 0x6e ^ 0xff; // rom[i+6] = rom[i+6] ^ 0x6e ^ 0xff;
// rom[i+7] = rom[i+7] ^ 0x61 ^ 0xff; // rom[i+7] = rom[i+7] ^ 0x61 ^ 0xff;
// rom[i+8] = rom[i+8] ^ 0x37 ^ 0xff; // rom[i+8] = rom[i+8] ^ 0x37 ^ 0xff;
// rom[i+9] = rom[i+9] ^ 0x5e ^ 0xff; // rom[i+9] = rom[i+9] ^ 0x5e ^ 0xff;
// rom[i+10] = rom[i+10] ^ 0xfb ^ 0xff; // rom[i+10] = rom[i+10] ^ 0xfb ^ 0xff;
// rom[i+11] = rom[i+11] ^ 0xc6 ^ 0xff; // rom[i+11] = rom[i+11] ^ 0xc6 ^ 0xff;
// rom[i+12] = rom[i+12] ^ 0x1d ^ 0xff; // rom[i+12] = rom[i+12] ^ 0x1d ^ 0xff;
// rom[i+13] = rom[i+13] ^ 0x33 ^ 0xff; // rom[i+13] = rom[i+13] ^ 0x33 ^ 0xff;
// rom[i+14] = rom[i+14] ^ 0x00 ^ 0xff; // rom[i+14] = rom[i+14] ^ 0x00 ^ 0xff;
// rom[i+15] = rom[i+15] ^ 0xff ^ 0xff; // rom[i+15] = rom[i+15] ^ 0xff ^ 0xff;
// i = i + 16; // i = i + 16;
// } // }
// buffer = alloc_array_or_die(UINT8, size); // buffer = alloc_array_or_die(UINT8, size);
// memcpy(buffer, rom, size); // memcpy(buffer, rom, size);
// free(buffer); // free(buffer);
} }
static DRIVER_INIT( deb ) static DRIVER_INIT( deb )

46
src/mame/drivers/portrait.c
View File

@ -297,19 +297,19 @@ ROM_START( portrait )
ROM_REGION( 0x20000, "gfx1", 0 ) ROM_REGION( 0x20000, "gfx1", 0 )
ROM_LOAD( "port_00.a1", 0x00000, 0x2000, CRC(eb3e1c12) SHA1(2d38b66f52546b40553244c8a5c961279559f5b6) ) /*bit plane 1*/ ROM_LOAD( "port_00.a1", 0x00000, 0x2000, CRC(eb3e1c12) SHA1(2d38b66f52546b40553244c8a5c961279559f5b6) ) /*bit plane 1*/
ROM_LOAD( "port_10.b1", 0x02000, 0x2000, CRC(0f44e377) SHA1(1955f9f4deab2166f637f43c1f326bd65fc90f6a) ) /*bit plane 1*/ ROM_LOAD( "port_10.b1", 0x02000, 0x2000, CRC(0f44e377) SHA1(1955f9f4deab2166f637f43c1f326bd65fc90f6a) ) /*bit plane 1*/
ROM_LOAD( "port_02.d1", 0x04000, 0x2000, CRC(bd93a3f9) SHA1(9cb479b8840cafd6043ff0cb9d5ca031dcd332ba) ) /*bit plane 2*/ ROM_LOAD( "port_02.d1", 0x04000, 0x2000, CRC(bd93a3f9) SHA1(9cb479b8840cafd6043ff0cb9d5ca031dcd332ba) ) /*bit plane 2*/
ROM_LOAD( "port_12.e1", 0x06000, 0x2000, CRC(656b9f20) SHA1(c1907aba3d19be79d92cd73784b8e7ae94910da6) ) /*bit plane 2*/ ROM_LOAD( "port_12.e1", 0x06000, 0x2000, CRC(656b9f20) SHA1(c1907aba3d19be79d92cd73784b8e7ae94910da6) ) /*bit plane 2*/
ROM_LOAD( "port_04.g1", 0x08000, 0x2000, CRC(2a99feb5) SHA1(b373d2a2bd28aad6dd7a15a2166e03a8b7a34d9b) ) /*bit plane 3*/ ROM_LOAD( "port_04.g1", 0x08000, 0x2000, CRC(2a99feb5) SHA1(b373d2a2bd28aad6dd7a15a2166e03a8b7a34d9b) ) /*bit plane 3*/
ROM_LOAD( "port_14.g1", 0x0a000, 0x2000, CRC(224b7a58) SHA1(b84e70d22d1cab41e5773fc9daa2e4e55ec9d96e) ) /*bit plane 3*/ ROM_LOAD( "port_14.g1", 0x0a000, 0x2000, CRC(224b7a58) SHA1(b84e70d22d1cab41e5773fc9daa2e4e55ec9d96e) ) /*bit plane 3*/
ROM_LOAD( "port_01.a2", 0x10000, 0x2000, CRC(70d27508) SHA1(d011f85b31bb3aa6f386e8e0edb91df10f4c4eb6) ) /*bit plane 1*/ ROM_LOAD( "port_01.a2", 0x10000, 0x2000, CRC(70d27508) SHA1(d011f85b31bb3aa6f386e8e0edb91df10f4c4eb6) ) /*bit plane 1*/
ROM_LOAD( "port_11.b2", 0x12000, 0x2000, CRC(f498e395) SHA1(beb1d12433a350e5b773126de3f2803a9f5620c1) ) /*bit plane 1*/ ROM_LOAD( "port_11.b2", 0x12000, 0x2000, CRC(f498e395) SHA1(beb1d12433a350e5b773126de3f2803a9f5620c1) ) /*bit plane 1*/
ROM_LOAD( "port_03.d2", 0x14000, 0x2000, CRC(03d4153a) SHA1(7ce69ce6a101870dbfca1a9787fb1e660024bc02) ) /*bit plane 2*/ ROM_LOAD( "port_03.d2", 0x14000, 0x2000, CRC(03d4153a) SHA1(7ce69ce6a101870dbfca1a9787fb1e660024bc02) ) /*bit plane 2*/
ROM_LOAD( "port_13.e2", 0x16000, 0x2000, CRC(10fa22b8) SHA1(e8f4c24fcdda0ce5e33bc600acd574a232a9bb21) ) /*bit plane 2*/ ROM_LOAD( "port_13.e2", 0x16000, 0x2000, CRC(10fa22b8) SHA1(e8f4c24fcdda0ce5e33bc600acd574a232a9bb21) ) /*bit plane 2*/
ROM_LOAD( "port_05.g2", 0x18000, 0x2000, CRC(43ea7951) SHA1(df0ae7fa802365979514063e1d67cdd45ecada90) ) /*bit plane 3*/ ROM_LOAD( "port_05.g2", 0x18000, 0x2000, CRC(43ea7951) SHA1(df0ae7fa802365979514063e1d67cdd45ecada90) ) /*bit plane 3*/
ROM_LOAD( "port_15.h2", 0x1a000, 0x2000, CRC(ab20b438) SHA1(ea5d60f6a9f06397bd0c6ee028b463c684090c01) ) /*bit plane 3*/ ROM_LOAD( "port_15.h2", 0x1a000, 0x2000, CRC(ab20b438) SHA1(ea5d60f6a9f06397bd0c6ee028b463c684090c01) ) /*bit plane 3*/
@ -361,33 +361,33 @@ ROM_END
/* tileattr rom /* tileattr rom
this appears to be divided into 2 0x400 banks this appears to be divided into 2 0x400 banks
0x000 - 0x3ff relates to tiles 0x000-0x0ff 0x000 - 0x3ff relates to tiles 0x000-0x0ff
0x400 - 0x7ff relates to tiles 0x100-0x1ff, 0x200-0x2ff, and 0x300-0x3ff 0x400 - 0x7ff relates to tiles 0x100-0x1ff, 0x200-0x2ff, and 0x300-0x3ff
every 2 tiles are somehow related to 8 bytes in the data every 2 tiles are somehow related to 8 bytes in the data
so tiles 0x00 and 0x01 use bytes 0x000-0x007 so tiles 0x00 and 0x01 use bytes 0x000-0x007
0x02 0x008 0x02 0x008
0x04 0x010 0x04 0x010
0x06 0x018 0x06 0x018
0x08 0x020 0x08 0x020
0x0a 0x028 0x0a 0x028
0x0c 0x030 0x0c 0x030
0x0e 0x038 0x0e 0x038
0x10 0x040 0x10 0x040
....... .......
0xfe and 0xff use bytes 0x3f8-0x3ff 0xfe and 0xff use bytes 0x3f8-0x3ff
etc. etc.
it's probably some kind of lookup table for the colours (6bpp = 8 colours, maybe every 2 tiles share the same 8 colours) it's probably some kind of lookup table for the colours (6bpp = 8 colours, maybe every 2 tiles share the same 8 colours)
I guess either the bank (0/1) can be selected, or bank 0 is hardcoded to tiles 0x000-0x0ff (because tilemaps can use I guess either the bank (0/1) can be selected, or bank 0 is hardcoded to tiles 0x000-0x0ff (because tilemaps can use
these tiles too, so it's not a case of it being a sprite/tilemap lookup split) these tiles too, so it's not a case of it being a sprite/tilemap lookup split)
anyway.. this is why the portraits logo is broken across 3 areas (0x1f2, 0x2f2, 0x3f2) so that they can share the same anyway.. this is why the portraits logo is broken across 3 areas (0x1f2, 0x2f2, 0x3f2) so that they can share the same
attributes from this rom attributes from this rom
*/ */

2
src/mame/drivers/snesb.c
View File

@ -723,7 +723,7 @@ static INPUT_PORTS_START( iron )
PORT_DIPUNKNOWN_DIPLOC( 0x20, 0x20, "SW1:6" ) PORT_DIPUNKNOWN_DIPLOC( 0x20, 0x20, "SW1:6" )
PORT_DIPUNKNOWN_DIPLOC( 0x40, 0x40, "SW1:7" ) PORT_DIPUNKNOWN_DIPLOC( 0x40, 0x40, "SW1:7" )
PORT_DIPUNKNOWN_DIPLOC( 0x80, 0x80, "SW1:8" ) PORT_DIPUNKNOWN_DIPLOC( 0x80, 0x80, "SW1:8" )
PORT_START("DSW2") /* IN 13 : dip-switches */ PORT_START("DSW2") /* IN 13 : dip-switches */
PORT_DIPUNKNOWN_DIPLOC( 0x01, 0x01, "SW2:1" ) PORT_DIPUNKNOWN_DIPLOC( 0x01, 0x01, "SW2:1" )
PORT_DIPUNKNOWN_DIPLOC( 0x02, 0x02, "SW2:2" ) PORT_DIPUNKNOWN_DIPLOC( 0x02, 0x02, "SW2:2" )

28
src/mame/drivers/sub.c
View File

@ -144,15 +144,15 @@ VIDEO_UPDATE(sub)
/* /*
sprite bank 1 sprite bank 1
0 xxxx xxxx X offset 0 xxxx xxxx X offset
1 tttt tttt tile offset 1 tttt tttt tile offset
sprite bank 2 sprite bank 2
0 yyyy yyyy Y offset 0 yyyy yyyy Y offset
1 f--- ---- flips the X offset 1 f--- ---- flips the X offset
1 -f-- ---- flip y, inverted 1 -f-- ---- flip y, inverted
1 --cc cccc color 1 --cc cccc color
*/ */
{ {
UINT8 *spriteram = screen->machine->generic.spriteram.u8; UINT8 *spriteram = screen->machine->generic.spriteram.u8;
UINT8 *spriteram_2 = screen->machine->generic.spriteram2.u8; UINT8 *spriteram_2 = screen->machine->generic.spriteram2.u8;
@ -300,11 +300,11 @@ static INPUT_PORTS_START( sub )
PORT_DIPSETTING( 0x90, DEF_STR( 1C_6C ) ) PORT_DIPSETTING( 0x90, DEF_STR( 1C_6C ) )
PORT_DIPSETTING( 0x00, DEF_STR( Free_Play ) ) PORT_DIPSETTING( 0x00, DEF_STR( Free_Play ) )
// Duplicates // Duplicates
// PORT_DIPSETTING( 0xa0, DEF_STR( 1C_3C ) ) // PORT_DIPSETTING( 0xa0, DEF_STR( 1C_3C ) )
// PORT_DIPSETTING( 0xb0, DEF_STR( 1C_5C ) ) // PORT_DIPSETTING( 0xb0, DEF_STR( 1C_5C ) )
// PORT_DIPSETTING( 0xc0, DEF_STR( 1C_6C ) ) // PORT_DIPSETTING( 0xc0, DEF_STR( 1C_6C ) )
// PORT_DIPSETTING( 0xd0, DEF_STR( 1C_1C ) ) // PORT_DIPSETTING( 0xd0, DEF_STR( 1C_1C ) )
// PORT_DIPSETTING( 0xe0, DEF_STR( 1C_2C ) ) // PORT_DIPSETTING( 0xe0, DEF_STR( 1C_2C ) )
PORT_START("DSW1") PORT_START("DSW1")
PORT_DIPNAME( 0x03, 0x00, DEF_STR( Lives ) ) PORT_DIPNAME( 0x03, 0x00, DEF_STR( Lives ) )

2
src/mame/drivers/taito_b.c
View File

@ -394,7 +394,7 @@ static WRITE16_HANDLER( eeprom_w )
/* bit 7 - set all the time (Chip Select?) */ /* bit 7 - set all the time (Chip Select?) */
/* EEPROM */ /* EEPROM */
input_port_write(space->machine, "EEPROMOUT", data, 0xff); input_port_write(space->machine, "EEPROMOUT", data, 0xff);
} }
} }

2
src/mame/drivers/taito_f3.c
View File

@ -99,7 +99,7 @@ static WRITE32_HANDLER( f3_control_w )
case 0x04: /* Eeprom */ case 0x04: /* Eeprom */
if (ACCESSING_BITS_0_7) if (ACCESSING_BITS_0_7)
{ {
input_port_write(space->machine, "EEPROMOUT", data, 0xff); input_port_write(space->machine, "EEPROMOUT", data, 0xff);
} }
return; return;

2
src/mame/drivers/taito_z.c
View File

@ -1060,7 +1060,7 @@ static WRITE16_HANDLER( spacegun_output_bypass_w )
x0000000 (unused) */ x0000000 (unused) */
COMBINE_DATA(&eep_latch); COMBINE_DATA(&eep_latch);
input_port_write(space->machine, "EEPROMOUT", data, 0xff); input_port_write(space->machine, "EEPROMOUT", data, 0xff);
break; break;
default: default:

2
src/mame/drivers/taitojc.c
View File

@ -484,7 +484,7 @@ static WRITE32_HANDLER ( jc_control_w )
{ {
if (ACCESSING_BITS_24_31) if (ACCESSING_BITS_24_31)
{ {
input_port_write(space->machine, "EEPROMOUT", data >> 24, 0xff); input_port_write(space->machine, "EEPROMOUT", data >> 24, 0xff);
} }
return; return;
} }

8
src/mame/drivers/tnzs.c
View File

@ -650,7 +650,7 @@ static SAMPLES_START( kageki_init_samples )
{ {
if (*scan++ == 0x00) if (*scan++ == 0x00)
break; break;
else else
size++; size++;
} }
@ -659,7 +659,7 @@ static SAMPLES_START( kageki_init_samples )
state->samplesize[i] = size; state->samplesize[i] = size;
if (start < 0x100) if (start < 0x100)
start = size = 0; start = size = 0;
// signed 8-bit sample to unsigned 8-bit sample convert // signed 8-bit sample to unsigned 8-bit sample convert
@ -713,8 +713,8 @@ static WRITE8_DEVICE_HANDLER( kageki_csport_w )
{ {
// read dipsw port // read dipsw port
state->kageki_csport_sel = (data & 0x03); state->kageki_csport_sel = (data & 0x03);
} }
else else
{ {
if (data > MAX_SAMPLES) if (data > MAX_SAMPLES)
{ {

2
src/mame/drivers/toaplan2.c
View File

@ -1290,7 +1290,7 @@ static WRITE16_HANDLER( bbakraid_nvram_w )
logerror("CPU #0 PC:%06X - Unknown EEPROM data being written %04X\n",cpu_get_pc(space->cpu),data); logerror("CPU #0 PC:%06X - Unknown EEPROM data being written %04X\n",cpu_get_pc(space->cpu),data);
if ( ACCESSING_BITS_0_7 ) if ( ACCESSING_BITS_0_7 )
input_port_write(space->machine, "EEPROMOUT", data, 0xff); input_port_write(space->machine, "EEPROMOUT", data, 0xff);
raizing_Z80_busreq = data & 0x10; /* see bbakraid_nvram_r above */ raizing_Z80_busreq = data & 0x10; /* see bbakraid_nvram_r above */
} }

2
src/mame/drivers/zr107.c
View File

@ -328,7 +328,7 @@ static WRITE8_HANDLER( sysreg_w )
0x02 = EEPCLK 0x02 = EEPCLK
0x01 = EEPDI 0x01 = EEPDI
*/ */
input_port_write(space->machine, "EEPROMOUT", data & 0x07, 0xff); input_port_write(space->machine, "EEPROMOUT", data & 0x07, 0xff);
cputag_set_input_line(space->machine, "audiocpu", INPUT_LINE_RESET, (data & 0x10) ? CLEAR_LINE : ASSERT_LINE); cputag_set_input_line(space->machine, "audiocpu", INPUT_LINE_RESET, (data & 0x10) ? CLEAR_LINE : ASSERT_LINE);
mame_printf_debug("System register 0 = %02X\n", data); mame_printf_debug("System register 0 = %02X\n", data);
break; break;

6
src/mame/includes/actfancr.h
View File

@ -1,6 +1,6 @@
/************************************************************************* /*************************************************************************
Act Fancer Act Fancer
*************************************************************************/ *************************************************************************/
@ -12,8 +12,8 @@ struct _actfancr_state
UINT8 * pf2_data; UINT8 * pf2_data;
UINT8 * pf1_rowscroll_data; UINT8 * pf1_rowscroll_data;
UINT8 * main_ram; UINT8 * main_ram;
// UINT8 * spriteram; // currently this uses buffered_spriteram // UINT8 * spriteram; // currently this uses buffered_spriteram
// UINT8 * paletteram; // currently this uses generic palette handling // UINT8 * paletteram; // currently this uses generic palette handling
/* video-related */ /* video-related */
tilemap *pf1_tilemap, *pf1_alt_tilemap, *pf2_tilemap; tilemap *pf1_tilemap, *pf1_alt_tilemap, *pf2_tilemap;

2
src/mame/includes/aquarium.h
View File

@ -10,7 +10,7 @@ struct _aquarium_state
UINT16 * mid_videoram; UINT16 * mid_videoram;
UINT16 * bak_videoram; UINT16 * bak_videoram;
UINT16 * spriteram; UINT16 * spriteram;
// UINT16 * paletteram; // currently this uses generic palette handling // UINT16 * paletteram; // currently this uses generic palette handling
size_t spriteram_size; size_t spriteram_size;
/* video-related */ /* video-related */

4
src/mame/includes/armedf.h
View File

@ -10,8 +10,8 @@ struct _armedf_state
UINT16 * bg_videoram; UINT16 * bg_videoram;
UINT16 * fg_videoram; UINT16 * fg_videoram;
UINT16 * legion_cmd; // legion only! UINT16 * legion_cmd; // legion only!
// UINT16 * spriteram; // currently this uses generic buffered_spriteram // UINT16 * spriteram; // currently this uses generic buffered_spriteram
// UINT16 * paletteram; // currently this uses generic palette handling // UINT16 * paletteram; // currently this uses generic palette handling
/* video-related */ /* video-related */
tilemap *bg_tilemap,*fg_tilemap, *tx_tilemap; tilemap *bg_tilemap,*fg_tilemap, *tx_tilemap;

2
src/mame/includes/ashnojoe.h
View File

@ -17,7 +17,7 @@ struct _ashnojoe_state
UINT16 * tileram_6; UINT16 * tileram_6;
UINT16 * tileram_7; UINT16 * tileram_7;
UINT16 * tilemap_reg; UINT16 * tilemap_reg;
// UINT16 * paletteram; // currently this uses generic palette handling // UINT16 * paletteram; // currently this uses generic palette handling
/* video-related */ /* video-related */
tilemap *joetilemap, *joetilemap2, *joetilemap3, *joetilemap4, *joetilemap5, *joetilemap6, *joetilemap7; tilemap *joetilemap, *joetilemap2, *joetilemap3, *joetilemap4, *joetilemap5, *joetilemap6, *joetilemap7;

6
src/mame/includes/blktiger.h
View File

@ -9,9 +9,9 @@ struct _blktiger_state
{ {
/* memory pointers */ /* memory pointers */
UINT8 * txvideoram; UINT8 * txvideoram;
// UINT8 * spriteram; // currently this uses generic buffer_spriteram_w // UINT8 * spriteram; // currently this uses generic buffer_spriteram_w
// UINT8 * paletteram; // currently this uses generic palette handling // UINT8 * paletteram; // currently this uses generic palette handling
// UINT8 * paletteram2; // currently this uses generic palette handling // UINT8 * paletteram2; // currently this uses generic palette handling
/* video-related */ /* video-related */
tilemap *tx_tilemap, *bg_tilemap8x4, *bg_tilemap4x8; tilemap *tx_tilemap, *bg_tilemap8x4, *bg_tilemap4x8;

4
src/mame/includes/bogeyman.h
View File

@ -1,6 +1,6 @@
/************************************************************************* /*************************************************************************
Bogey Manor Bogey Manor
*************************************************************************/ *************************************************************************/
@ -13,7 +13,7 @@ struct _bogeyman_state
UINT8 * colorram; UINT8 * colorram;
UINT8 * colorram2; UINT8 * colorram2;
UINT8 * spriteram; UINT8 * spriteram;
// UINT8 * paletteram; // currently this uses generic palette handling // UINT8 * paletteram; // currently this uses generic palette handling
size_t spriteram_size; size_t spriteram_size;
/* video-related */ /* video-related */

2
src/mame/includes/bombjack.h
View File

@ -11,7 +11,7 @@ struct _bombjack_state
UINT8 * videoram; UINT8 * videoram;
UINT8 * colorram; UINT8 * colorram;
UINT8 * spriteram; UINT8 * spriteram;
// UINT8 * paletteram; // currently this uses generic palette handling // UINT8 * paletteram; // currently this uses generic palette handling
size_t spriteram_size; size_t spriteram_size;
/* video-related */ /* video-related */

4
src/mame/includes/btime.h
View File

@ -5,13 +5,13 @@ struct _btime_state
/* memory pointers */ /* memory pointers */
UINT8 * videoram; UINT8 * videoram;
UINT8 * colorram; UINT8 * colorram;
// UINT8 * paletteram; // currently this uses generic palette handling // UINT8 * paletteram; // currently this uses generic palette handling
UINT8 * lnc_charbank; UINT8 * lnc_charbank;
UINT8 * bnj_backgroundram; UINT8 * bnj_backgroundram;
UINT8 * zoar_scrollram; UINT8 * zoar_scrollram;
UINT8 * deco_charram; UINT8 * deco_charram;
UINT8 * spriteram; // used by disco UINT8 * spriteram; // used by disco
// UINT8 * decrypted; // UINT8 * decrypted;
UINT8 * rambase; UINT8 * rambase;
UINT8 * audio_rambase; UINT8 * audio_rambase;
size_t videoram_size; size_t videoram_size;

2
src/mame/includes/bublbobl.h
View File

@ -6,7 +6,7 @@ struct _bublbobl_state
UINT8 * mcu_sharedram; UINT8 * mcu_sharedram;
UINT8 * videoram; UINT8 * videoram;
UINT8 * objectram; UINT8 * objectram;
// UINT8 * paletteram; // currently this uses generic palette handling // UINT8 * paletteram; // currently this uses generic palette handling
size_t videoram_size; size_t videoram_size;
size_t objectram_size; size_t objectram_size;

2
src/mame/includes/capbowl.h
View File

@ -9,7 +9,7 @@ struct _capbowl_state
{ {
/* memory pointers */ /* memory pointers */
UINT8 * rowaddress; UINT8 * rowaddress;
// UINT8 * nvram; // currently this uses generic_nvram // UINT8 * nvram; // currently this uses generic_nvram
/* video-related */ /* video-related */
offs_t blitter_addr; offs_t blitter_addr;

4
src/mame/includes/ccastles.h
View File

@ -10,8 +10,8 @@ struct _ccastles_state
/* memory pointers */ /* memory pointers */
UINT8 * videoram; UINT8 * videoram;
UINT8 * spriteram; UINT8 * spriteram;
// UINT8 * nvram_stage; // currently this uses generic nvram handlers // UINT8 * nvram_stage; // currently this uses generic nvram handlers
// UINT8 * nvram; // currently this uses generic nvram handlers // UINT8 * nvram; // currently this uses generic nvram handlers
/* video-related */ /* video-related */
const UINT8 *syncprom; const UINT8 *syncprom;

2
src/mame/includes/citycon.h
View File

@ -12,7 +12,7 @@ struct _citycon_state
UINT8 * linecolor; UINT8 * linecolor;
UINT8 * scroll; UINT8 * scroll;
UINT8 * spriteram; UINT8 * spriteram;
// UINT8 * paletteram; // currently this uses generic palette handling // UINT8 * paletteram; // currently this uses generic palette handling
size_t spriteram_size; size_t spriteram_size;
/* video-related */ /* video-related */

4
src/mame/includes/cloud9.h
View File

@ -11,8 +11,8 @@ struct _cloud9_state
UINT8 * videoram; UINT8 * videoram;
UINT8 * spriteram; UINT8 * spriteram;
UINT8 * paletteram; UINT8 * paletteram;
// UINT8 * nvram_stage; // currently this uses generic nvram handlers // UINT8 * nvram_stage; // currently this uses generic nvram handlers
// UINT8 * nvram; // currently this uses generic nvram handlers // UINT8 * nvram; // currently this uses generic nvram handlers
/* video-related */ /* video-related */
const UINT8 *syncprom; const UINT8 *syncprom;

2
src/mame/includes/commando.h
View File

@ -12,7 +12,7 @@ struct _commando_state
UINT8 * colorram; UINT8 * colorram;
UINT8 * videoram2; UINT8 * videoram2;
UINT8 * colorram2; UINT8 * colorram2;
// UINT8 * spriteram; // currently this uses generic buffered_spriteram // UINT8 * spriteram; // currently this uses generic buffered_spriteram
/* video-related */ /* video-related */
tilemap *bg_tilemap, *fg_tilemap; tilemap *bg_tilemap, *fg_tilemap;

2
src/mame/includes/compgolf.h
View File

@ -1,6 +1,6 @@
/************************************************************************* /*************************************************************************
Competition Golf Final Round Competition Golf Final Round
*************************************************************************/ *************************************************************************/

Some files were not shown because too many files have changed in this diff Show More