Ported DC, SMS and SG1000 to main folder, nw

.gitattributes

@@ -665,6 +665,8 @@ src/emu/fileio.c svneol=native#text/plain
 src/emu/fileio.h svneol=native#text/plain
 src/emu/hash.c svneol=native#text/plain
 src/emu/hash.h svneol=native#text/plain
+src/emu/hashfile.c svneol=native#text/plain
+src/emu/hashfile.h svneol=native#text/plain
 src/emu/image.c svneol=native#text/plain
 src/emu/image.h svneol=native#text/plain
 src/emu/imagedev/bitbngr.c svneol=native#text/plain
@@ -857,6 +859,8 @@ src/emu/machine/msm58321.c svneol=native#text/plain
 src/emu/machine/msm58321.h svneol=native#text/plain
 src/emu/machine/msm6242.c svneol=native#text/plain
 src/emu/machine/msm6242.h svneol=native#text/plain
+src/emu/machine/msm8251.c svneol=native#text/plain
+src/emu/machine/msm8251.h svneol=native#text/plain
 src/emu/machine/nmc9306.c svneol=native#text/plain
 src/emu/machine/nmc9306.h svneol=native#text/plain
 src/emu/machine/nvram.c svneol=native#text/plain
@@ -903,6 +907,8 @@ src/emu/machine/scsihd.c svneol=native#text/plain
 src/emu/machine/scsihd.h svneol=native#text/plain
 src/emu/machine/secflash.c svneol=native#text/plain
 src/emu/machine/secflash.h svneol=native#text/plain
+src/emu/machine/serial.c svneol=native#text/plain
+src/emu/machine/serial.h svneol=native#text/plain
 src/emu/machine/smc91c9x.c svneol=native#text/plain
 src/emu/machine/smc91c9x.h svneol=native#text/plain
 src/emu/machine/timekpr.c svneol=native#text/plain
@@ -917,6 +923,8 @@ src/emu/machine/upd4701.c svneol=native#text/plain
 src/emu/machine/upd4701.h svneol=native#text/plain
 src/emu/machine/upd7201.c svneol=native#text/plain
 src/emu/machine/upd7201.h svneol=native#text/plain
+src/emu/machine/upd765.c svneol=native#text/plain
+src/emu/machine/upd765.h svneol=native#text/plain
 src/emu/machine/wd33c93.c svneol=native#text/plain
 src/emu/machine/wd33c93.h svneol=native#text/plain
 src/emu/machine/x2212.c svneol=native#text/plain
@@ -1783,6 +1791,7 @@ src/mame/drivers/darkseal.c svneol=native#text/plain
 src/mame/drivers/dassault.c svneol=native#text/plain
 src/mame/drivers/dblewing.c svneol=native#text/plain
 src/mame/drivers/dbz.c svneol=native#text/plain
+src/mame/drivers/dc.c svneol=native#text/plain
 src/mame/drivers/dcheese.c svneol=native#text/plain
 src/mame/drivers/dcon.c svneol=native#text/plain
 src/mame/drivers/dday.c svneol=native#text/plain
@@ -2407,6 +2416,7 @@ src/mame/drivers/segas16b.c svneol=native#text/plain
 src/mame/drivers/segas18.c svneol=native#text/plain
 src/mame/drivers/segas24.c svneol=native#text/plain
 src/mame/drivers/segas32.c svneol=native#text/plain
+src/mame/drivers/segasms.c svneol=native#text/plain
 src/mame/drivers/segaxbd.c svneol=native#text/plain
 src/mame/drivers/segaybd.c svneol=native#text/plain
 src/mame/drivers/seibuspi.c svneol=native#text/plain
@@ -2419,6 +2429,7 @@ src/mame/drivers/sf.c svneol=native#text/plain
 src/mame/drivers/sfbonus.c svneol=native#text/plain
 src/mame/drivers/sfcbox.c svneol=native#text/plain
 src/mame/drivers/sfkick.c svneol=native#text/plain
+src/mame/drivers/sg1000.c svneol=native#text/plain
 src/mame/drivers/sg1000a.c svneol=native#text/plain
 src/mame/drivers/shadfrce.c svneol=native#text/plain
 src/mame/drivers/shangha3.c svneol=native#text/plain
@@ -2705,6 +2716,8 @@ src/mame/drivers/zodiack.c svneol=native#text/plain
 src/mame/drivers/zr107.c svneol=native#text/plain
 src/mame/etc/fd1094dp.c svneol=native#text/plain
 src/mame/etc/jrcrypt.c svneol=native#text/plain
+src/mame/formats/basicdsk.c svneol=native#text/plain
+src/mame/formats/basicdsk.h svneol=native#text/plain
 src/mame/includes/1942.h svneol=native#text/plain
 src/mame/includes/1943.h svneol=native#text/plain
 src/mame/includes/20pacgal.h svneol=native#text/plain
@@ -3196,6 +3209,7 @@ src/mame/includes/segamsys.h svneol=native#text/plain
 src/mame/includes/segas16.h svneol=native#text/plain
 src/mame/includes/segas24.h svneol=native#text/plain
 src/mame/includes/segas32.h svneol=native#text/plain
+src/mame/includes/segasms.h svneol=native#text/plain
 src/mame/includes/sei_crtc.h svneol=native#text/plain
 src/mame/includes/seibuspi.h svneol=native#text/plain
 src/mame/includes/seicross.h svneol=native#text/plain
@@ -3203,6 +3217,7 @@ src/mame/includes/senjyo.h svneol=native#text/plain
 src/mame/includes/seta.h svneol=native#text/plain
 src/mame/includes/seta2.h svneol=native#text/plain
 src/mame/includes/sf.h svneol=native#text/plain
+src/mame/includes/sg1000.h svneol=native#text/plain
 src/mame/includes/shadfrce.h svneol=native#text/plain
 src/mame/includes/shangha3.h svneol=native#text/plain
 src/mame/includes/shangkid.h svneol=native#text/plain
@@ -3510,6 +3525,7 @@ src/mame/layout/slots.lay svneol=native#text/plain
 src/mame/layout/sltblgpo.lay svneol=native#text/plain
 src/mame/layout/sltblgtk.lay svneol=native#text/plain
 src/mame/layout/smoto.lay svneol=native#text/plain
+src/mame/layout/sms1.lay svneol=native#text/plain
 src/mame/layout/snookr10.lay svneol=native#text/plain
 src/mame/layout/solarq.lay svneol=native#text/plain
 src/mame/layout/sos.lay svneol=native#text/plain
@@ -3580,6 +3596,8 @@ src/mame/machine/cdislave.c svneol=native#text/plain
 src/mame/machine/cdislave.h svneol=native#text/plain
 src/mame/machine/chaknpop.c svneol=native#text/plain
 src/mame/machine/cps2crpt.c svneol=native#text/plain
+src/mame/machine/ctronics.c svneol=native#text/plain
+src/mame/machine/ctronics.h svneol=native#text/plain
 src/mame/machine/cx4data.c svneol=native#text/plain
 src/mame/machine/cx4fn.c svneol=native#text/plain
 src/mame/machine/cx4oam.c svneol=native#text/plain
@@ -3587,6 +3605,7 @@ src/mame/machine/cx4ops.c svneol=native#text/plain
 src/mame/machine/dc-ctrl.c svneol=native#text/plain
 src/mame/machine/dc-ctrl.h svneol=native#text/plain
 src/mame/machine/dc.c svneol=native#text/plain
+src/mame/machine/dccons.c svneol=native#text/plain
 src/mame/machine/dec0.c svneol=native#text/plain
 src/mame/machine/deco102.c svneol=native#text/plain
 src/mame/machine/deco156.c svneol=native#text/plain
@@ -3609,6 +3628,8 @@ src/mame/machine/gaelcrpt.c svneol=native#text/plain
 src/mame/machine/galaxold.c svneol=native#text/plain
 src/mame/machine/gaplus.c svneol=native#text/plain
 src/mame/machine/gdcrypt.c svneol=native#text/plain
+src/mame/machine/gdrom.c svneol=native#text/plain
+src/mame/machine/gdrom.h svneol=native#text/plain
 src/mame/machine/harddriv.c svneol=native#text/plain
 src/mame/machine/irem_cpu.c svneol=native#text/plain
 src/mame/machine/irem_cpu.h svneol=native#text/plain
@@ -3720,6 +3741,7 @@ src/mame/machine/segaic16.c svneol=native#text/plain
 src/mame/machine/segaic16.h svneol=native#text/plain
 src/mame/machine/segamsys.c svneol=native#text/plain
 src/mame/machine/segas32.c svneol=native#text/plain
+src/mame/machine/segasms.c svneol=native#text/plain
 src/mame/machine/seibuspi.c svneol=native#text/plain
 src/mame/machine/seibuspi.h svneol=native#text/plain
 src/mame/machine/seicop.c svneol=native#text/plain
@@ -4342,6 +4364,8 @@ src/mame/video/skykid.c svneol=native#text/plain
 src/mame/video/skyraid.c svneol=native#text/plain
 src/mame/video/slapfght.c svneol=native#text/plain
 src/mame/video/slapshot.c svneol=native#text/plain
+src/mame/video/smsvdp.c svneol=native#text/plain
+src/mame/video/smsvdp.h svneol=native#text/plain
 src/mame/video/snes.c svneol=native#text/plain
 src/mame/video/snk.c svneol=native#text/plain
 src/mame/video/snk6502.c svneol=native#text/plain

src/emu/emu.mak

@@ -44,6 +44,7 @@ OBJDIRS += \
 #-------------------------------------------------
 
 EMUOBJS = \
+	$(EMUOBJ)/hashfile.o \
 	$(EMUOBJ)/addrmap.o \
 	$(EMUOBJ)/attotime.o \
 	$(EMUOBJ)/audit.o \
@@ -204,6 +205,7 @@ EMUMACHINEOBJS = \
 	$(EMUMACHINE)/msm5832.o	\
 	$(EMUMACHINE)/msm58321.o	\
 	$(EMUMACHINE)/msm6242.o		\
+	$(EMUMACHINE)/msm8251.o		\
 	$(EMUMACHINE)/nmc9306.o		\
 	$(EMUMACHINE)/nvram.o		\
 	$(EMUMACHINE)/pc16552d.o	\
@@ -225,6 +227,7 @@ EMUMACHINEOBJS = \
 	$(EMUMACHINE)/scsidev.o		\
 	$(EMUMACHINE)/scsihd.o		\
 	$(EMUMACHINE)/secflash.o	\
+	$(EMUMACHINE)/serial.o	\
 	$(EMUMACHINE)/smc91c9x.o	\
 	$(EMUMACHINE)/timekpr.o		\
 	$(EMUMACHINE)/tmp68301.o	\
@@ -232,6 +235,7 @@ EMUMACHINEOBJS = \
 	$(EMUMACHINE)/upd1990a.o	\
 	$(EMUMACHINE)/upd4701.o		\
 	$(EMUMACHINE)/upd7201.o		\
+	$(EMUMACHINE)/upd765.o		\
 	$(EMUMACHINE)/wd33c93.o		\
 	$(EMUMACHINE)/x2212.o		\
 	$(EMUMACHINE)/x76f041.o		\

src/emu/hashfile.c

@@ -0,0 +1,617 @@
+/*********************************************************************
+
+    hashfile.c
+
+    Code for parsing hash info (*.hsi) files
+
+*********************************************************************/
+
+#include "hashfile.h"
+#include "pool.h"
+#include "expat.h"
+#include "emuopts.h"
+#include "hash.h"
+
+
+/***************************************************************************
+    TYPE DEFINITIONS
+***************************************************************************/
+
+typedef struct _hash_info hash_info;
+struct _hash_info
+{
+	hash_collection *hashes;
+	const char *extrainfo;
+};
+
+typedef struct _hash_file hash_file;
+
+typedef void (*hashfile_error_func)(const char *message);
+
+
+
+/***************************************************************************
+    FUNCTION PROTOTYPES
+***************************************************************************/
+
+/* opens a hash file; if is_preload is non-zero, the entire file is preloaded */
+hash_file *hashfile_open(emu_options &options, const char *sysname, int is_preload, hashfile_error_func error_proc);
+
+/* closes a hash file and associated resources */
+void hashfile_close(hash_file *hashfile);
+
+/* looks up information in a hash file */
+const hash_info *hashfile_lookup(hash_file *hashfile, const hash_collection *hashes);
+
+/***************************************************************************
+    TYPE DEFINITIONS
+***************************************************************************/
+
+struct _hash_file
+{
+	emu_file *file;
+	object_pool *pool;
+	astring functions[IO_COUNT];
+
+	hash_info **preloaded_hashes;
+	int preloaded_hash_count;
+
+	void (*error_proc)(const char *message);
+};
+
+
+
+enum hash_parse_position
+{
+	HASH_POS_ROOT,
+	HASH_POS_MAIN,
+	HASH_POS_HASH
+};
+
+
+
+struct hash_parse_state
+{
+	XML_Parser parser;
+	hash_file *hashfile;
+	int done;
+
+	int (*selector_proc)(hash_file *hashfile, void *param, const char *name, const hash_collection *hashes);
+	void (*use_proc)(hash_file *hashfile, void *param, hash_info *hi);
+	void (*error_proc)(const char *message);
+	void *param;
+
+	enum hash_parse_position pos;
+	char **text_dest;
+	hash_info *hi;
+};
+
+
+
+/***************************************************************************
+    PROTOTYPES
+***************************************************************************/
+
+static void *expat_malloc(size_t size);
+static void *expat_realloc(void *ptr, size_t size);
+static void expat_free(void *ptr);
+
+
+
+/***************************************************************************
+    CORE IMPLEMENTATION
+***************************************************************************/
+
+/*-------------------------------------------------
+    parse_error
+-------------------------------------------------*/
+
+static void ATTR_PRINTF(2,3) parse_error(struct hash_parse_state *state, const char *fmt, ...)
+{
+	char buf[256];
+	va_list va;
+
+	if (state->error_proc)
+	{
+		va_start(va, fmt);
+		vsnprintf(buf, ARRAY_LENGTH(buf), fmt, va);
+		va_end(va);
+		(*state->error_proc)(buf);
+	}
+}
+
+
+
+/*-------------------------------------------------
+    unknown_tag
+-------------------------------------------------*/
+
+static void unknown_tag(struct hash_parse_state *state, const char *tagname)
+{
+	parse_error(state, "[%lu:%lu]: Unknown tag: %s\n",
+		XML_GetCurrentLineNumber(state->parser),
+		XML_GetCurrentColumnNumber(state->parser),
+		tagname);
+}
+
+
+
+/*-------------------------------------------------
+    unknown_attribute
+-------------------------------------------------*/
+
+static void unknown_attribute(struct hash_parse_state *state, const char *attrname)
+{
+	parse_error(state, "[%lu:%lu]: Unknown attribute: %s\n",
+		XML_GetCurrentLineNumber(state->parser),
+		XML_GetCurrentColumnNumber(state->parser),
+		attrname);
+}
+
+
+
+/*-------------------------------------------------
+    unknown_attribute_value
+-------------------------------------------------*/
+
+static void unknown_attribute_value(struct hash_parse_state *state,
+	const char *attrname, const char *attrvalue)
+{
+	parse_error(state, "[%lu:%lu]: Unknown attribute value: %s\n",
+		XML_GetCurrentLineNumber(state->parser),
+		XML_GetCurrentColumnNumber(state->parser),
+		attrvalue);
+}
+
+
+
+/*-------------------------------------------------
+    start_handler
+-------------------------------------------------*/
+
+static void start_handler(void *data, const char *tagname, const char **attributes)
+{
+	struct hash_parse_state *state = (struct hash_parse_state *) data;
+	const char *name;
+	hash_info *hi;
+	char **text_dest;
+	hash_collection hashes;
+	astring all_functions;
+	char functions;
+	iodevice_t device;
+	int i;
+
+	switch(state->pos)
+	{
+		case HASH_POS_ROOT:
+			if (!strcmp(tagname, "hashfile"))
+			{
+			}
+			else
+			{
+				unknown_tag(state, tagname);
+			}
+			break;
+
+		case HASH_POS_MAIN:
+			if (!strcmp(tagname, "hash"))
+			{
+				// we are now examining a hash tag
+				name = NULL;
+				device = IO_COUNT;
+
+				while(attributes[0])
+				{
+					functions = 0;
+					if (!strcmp(attributes[0], "name"))
+					{
+						/* name attribute */
+						name = attributes[1];
+					}
+					else if (!strcmp(attributes[0], "crc32"))
+					{
+						/* crc32 attribute */
+						functions = hash_collection::HASH_CRC;
+					}
+					else if (!strcmp(attributes[0], "md5"))
+					{
+						/* md5 attribute */
+						functions = hash_collection::HASH_MD5;
+					}
+					else if (!strcmp(attributes[0], "sha1"))
+					{
+						/* sha1 attribute */
+						functions = hash_collection::HASH_SHA1;
+					}
+					else if (!strcmp(attributes[0], "type"))
+					{
+						/* type attribute */
+						i = 0;//device_typeid(attributes[1]);
+						if (i < 0)
+							unknown_attribute_value(state, attributes[0], attributes[1]);
+						else
+							device = (iodevice_t) i;
+					}
+					else
+					{
+						/* unknown attribute */
+						unknown_attribute(state, attributes[0]);
+					}
+
+					if (functions)
+					{
+						hashes.add_from_string(functions, attributes[1], strlen(attributes[1]));
+						all_functions.cat(functions);
+					}
+
+					attributes += 2;
+				}
+
+				/* do we use this hash? */
+				if (!state->selector_proc || state->selector_proc(state->hashfile, state->param, name, &hashes))
+				{
+					hi = (hash_info*)pool_malloc_lib(state->hashfile->pool, sizeof(hash_info));
+					if (!hi)
+						return;
+					memset(hi, 0, sizeof(*hi));
+
+					hi->hashes = &hashes;
+					state->hi = hi;
+				}
+			}
+			else
+			{
+				unknown_tag(state, tagname);
+			}
+			break;
+
+		case HASH_POS_HASH:
+			text_dest = NULL;
+
+			if (!strcmp(tagname, "year")) {
+			}
+			else if (!strcmp(tagname, "manufacturer")){
+			}
+			else if (!strcmp(tagname, "status")){
+			}
+			else if (!strcmp(tagname, "pcb")){
+			}
+			else if (!strcmp(tagname, "extrainfo")) {
+				text_dest = (char **) &state->hi->extrainfo;
+			}
+			else
+				unknown_tag(state, tagname);
+
+			if (text_dest && state->hi)
+				state->text_dest = text_dest;
+			break;
+	}
+	state->pos = (hash_parse_position) (state->pos + 1);
+}
+
+
+
+/*-------------------------------------------------
+    end_handler
+-------------------------------------------------*/
+
+static void end_handler(void *data, const char *name)
+{
+	struct hash_parse_state *state = (struct hash_parse_state *) data;
+	state->text_dest = NULL;
+
+	state->pos = (hash_parse_position) (state->pos - 1);
+	switch(state->pos)
+	{
+		case HASH_POS_ROOT:
+		case HASH_POS_HASH:
+			break;
+
+		case HASH_POS_MAIN:
+			if (state->hi)
+			{
+				if (state->use_proc)
+					(*state->use_proc)(state->hashfile, state->param, state->hi);
+				state->hi = NULL;
+			}
+			break;
+	}
+}
+
+
+
+/*-------------------------------------------------
+    data_handler
+-------------------------------------------------*/
+
+static void data_handler(void *data, const XML_Char *s, int len)
+{
+	struct hash_parse_state *state = (struct hash_parse_state *) data;
+	int text_len;
+	char *text;
+
+	if (state->text_dest)
+	{
+		text = *state->text_dest;
+
+		text_len = text ? strlen(text) : 0;
+		text = (char*)pool_realloc_lib(state->hashfile->pool, text, text_len + len + 1);
+		if (!text)
+			return;
+
+		memcpy(&text[text_len], s, len);
+		text[text_len + len] = '\0';
+		*state->text_dest = text;
+	}
+}
+
+
+
+/*-------------------------------------------------
+    hashfile_parse
+-------------------------------------------------*/
+
+static void hashfile_parse(hash_file *hashfile,
+	int (*selector_proc)(hash_file *hashfile, void *param, const char *name, const hash_collection *hashes),
+	void (*use_proc)(hash_file *hashfile, void *param, hash_info *hi),
+	void (*error_proc)(const char *message),
+	void *param)
+{
+	struct hash_parse_state state;
+	char buf[1024];
+	UINT32 len;
+	XML_Memory_Handling_Suite memcallbacks;
+
+	hashfile->file->seek(0, SEEK_SET);
+
+	memset(&state, 0, sizeof(state));
+	state.hashfile = hashfile;
+	state.selector_proc = selector_proc;
+	state.use_proc = use_proc;
+	state.error_proc = error_proc;
+	state.param = param;
+
+	/* create the XML parser */
+	memcallbacks.malloc_fcn = expat_malloc;
+	memcallbacks.realloc_fcn = expat_realloc;
+	memcallbacks.free_fcn = expat_free;
+	state.parser = XML_ParserCreate_MM(NULL, &memcallbacks, NULL);
+	if (!state.parser)
+		goto done;
+
+	XML_SetUserData(state.parser, &state);
+	XML_SetElementHandler(state.parser, start_handler, end_handler);
+	XML_SetCharacterDataHandler(state.parser, data_handler);
+
+	while(!state.done)
+	{
+		len = hashfile->file->read(buf, sizeof(buf));
+		state.done = hashfile->file->eof();
+		if (XML_Parse(state.parser, buf, len, state.done) == XML_STATUS_ERROR)
+		{
+			parse_error(&state, "[%lu:%lu]: %s\n",
+				XML_GetCurrentLineNumber(state.parser),
+				XML_GetCurrentColumnNumber(state.parser),
+				XML_ErrorString(XML_GetErrorCode(state.parser)));
+			goto done;
+		}
+	}
+
+done:
+	if (state.parser)
+		XML_ParserFree(state.parser);
+}
+
+
+
+/*-------------------------------------------------
+    preload_use_proc
+-------------------------------------------------*/
+
+static void preload_use_proc(hash_file *hashfile, void *param, hash_info *hi)
+{
+	hash_info **new_preloaded_hashes;
+
+	new_preloaded_hashes = (hash_info **)pool_realloc_lib(hashfile->pool, hashfile->preloaded_hashes,
+		(hashfile->preloaded_hash_count + 1) * sizeof(*new_preloaded_hashes));
+	if (!new_preloaded_hashes)
+		return;
+
+	hashfile->preloaded_hashes = new_preloaded_hashes;
+	hashfile->preloaded_hashes[hashfile->preloaded_hash_count++] = hi;
+}
+
+
+
+/*-------------------------------------------------
+    hashfile_open
+-------------------------------------------------*/
+
+hash_file *hashfile_open(emu_options &options, const char *sysname, int is_preload,
+	void (*error_proc)(const char *message))
+{
+	hash_file *hashfile = NULL;
+	object_pool *pool = NULL;
+	file_error filerr;
+
+	/* create a pool for this hash file */
+	pool = pool_alloc_lib(error_proc);
+	if (!pool)
+		goto error;
+
+	/* allocate space for this hash file */
+	hashfile = (hash_file *) pool_malloc_lib(pool, sizeof(*hashfile));
+	if (!hashfile)
+		goto error;
+
+	/* set up the hashfile structure */
+	memset(hashfile, 0, sizeof(*hashfile));
+	hashfile->pool = pool;
+	hashfile->error_proc = error_proc;
+
+	/* open a file */
+	hashfile->file = global_alloc(emu_file(options.hash_path(), OPEN_FLAG_READ));
+	filerr = hashfile->file->open(sysname, ".hsi");
+	if (filerr != FILERR_NONE)
+	{
+		global_free(hashfile->file);
+		hashfile->file = NULL;
+		goto error;
+	}
+
+	if (is_preload)
+		hashfile_parse(hashfile, NULL, preload_use_proc, hashfile->error_proc, NULL);
+
+	return hashfile;
+
+error:
+	if (hashfile != NULL)
+		hashfile_close(hashfile);
+	return NULL;
+}
+
+
+
+/*-------------------------------------------------
+    hashfile_close
+-------------------------------------------------*/
+
+void hashfile_close(hash_file *hashfile)
+{
+	global_free(hashfile->file);
+	pool_free_lib(hashfile->pool);
+}
+
+
+
+/*-------------------------------------------------
+    singular_selector_proc
+-------------------------------------------------*/
+
+struct hashlookup_params
+{
+	const hash_collection *hashes;
+	hash_info *hi;
+};
+
+static int singular_selector_proc(hash_file *hashfile, void *param, const char *name, const hash_collection *hashes)
+{
+	astring tempstr;
+	struct hashlookup_params *hlparams = (struct hashlookup_params *) param;
+	return (*hashes == *hlparams->hashes);
+}
+
+
+
+/*-------------------------------------------------
+    singular_use_proc
+-------------------------------------------------*/
+
+static void singular_use_proc(hash_file *hashfile, void *param, hash_info *hi)
+{
+	struct hashlookup_params *hlparams = (struct hashlookup_params *) param;
+	hlparams->hi = hi;
+}
+
+
+
+/*-------------------------------------------------
+    hashfile_lookup
+-------------------------------------------------*/
+
+const hash_info *hashfile_lookup(hash_file *hashfile, const hash_collection *hashes)
+{
+	struct hashlookup_params param;
+	int i;
+
+	param.hashes = hashes;
+	param.hi = NULL;
+
+	for (i = 0; i < hashfile->preloaded_hash_count; i++)
+	{
+		if (singular_selector_proc(hashfile, &param, NULL, hashfile->preloaded_hashes[i]->hashes))
+			return hashfile->preloaded_hashes[i];
+	}
+
+	hashfile_parse(hashfile, singular_selector_proc, singular_use_proc,
+		hashfile->error_proc, (void *) &param);
+	return param.hi;
+}
+
+const char *extra_info = NULL;
+
+const char *read_hash_config(device_image_interface &image, const char *sysname)
+{
+	hash_file *hashfile = NULL;
+	const hash_info *info = NULL;
+
+	/* open the hash file */
+	hashfile = hashfile_open(image.device().machine().options(), sysname, FALSE, NULL);
+	if (!hashfile)
+		return NULL;
+
+	/* look up this entry in the hash file */
+	info = hashfile_lookup(hashfile, &image.hash());
+
+	if (!info || !info->extrainfo)
+	{
+		hashfile_close(hashfile);
+		return NULL;
+	}
+
+	extra_info = auto_strdup(image.device().machine(),info->extrainfo);
+	if (!extra_info)
+	{
+		hashfile_close(hashfile);
+		return NULL;
+	}
+
+	/* copy the relevant entries */
+	hashfile_close(hashfile);
+
+	return extra_info;
+}
+
+const char *hashfile_extrainfo(device_image_interface &image)
+{
+	const char *rc;
+
+	/* now read the hash file */
+	image.crc();
+	extra_info = NULL;
+	int drv = driver_list::find(image.device().machine().system());
+	do
+	{
+		rc = read_hash_config(image,driver_list::driver(drv).name);
+		drv = driver_list::compatible_with(drv);
+	}
+	while(rc!=NULL && drv != -1);
+	return rc;
+}
+
+/***************************************************************************
+    EXPAT INTERFACES
+***************************************************************************/
+
+/*-------------------------------------------------
+    expat_malloc/expat_realloc/expat_free -
+    wrappers for memory allocation functions so
+    that they pass through out memory tracking
+    systems
+-------------------------------------------------*/
+
+static void *expat_malloc(size_t size)
+{
+	return global_alloc_array_clear(UINT8,size);
+}
+
+static void *expat_realloc(void *ptr, size_t size)
+{
+	if (ptr) global_free(ptr);
+	return global_alloc_array_clear(UINT8,size);
+}
+
+static void expat_free(void *ptr)
+{
+	global_free(ptr);
+}

src/emu/hashfile.h

@@ -0,0 +1,17 @@
+/*********************************************************************
+
+    hashfile.h
+
+    Code for parsing hash info (*.hsi) files
+
+*********************************************************************/
+
+#ifndef __HASHFILE_H__
+#define __HASHFILE_H__
+
+#include "emu.h"
+
+
+const char *hashfile_extrainfo(device_image_interface &image);
+
+#endif /* __HASHFILE_H__ */

src/emu/machine/msm8251.c

@@ -0,0 +1,825 @@
+/*********************************************************************
+
+    msm8251.c
+
+    MSM/Intel 8251 Universal Synchronous/Asynchronous Receiver Transmitter code
+
+*********************************************************************/
+
+#include "emu.h"
+#include "msm8251.h"
+
+
+/***************************************************************************
+    MACROS
+***************************************************************************/
+
+#define VERBOSE 0
+
+#define LOG(x)	do { if (VERBOSE) logerror x; } while (0)
+
+
+/***************************************************************************
+    TYPE DEFINITIONS
+***************************************************************************/
+
+typedef struct _msm8251_t msm8251_t;
+struct _msm8251_t
+{
+	devcb_resolved_read_line	in_rxd_func;
+	devcb_resolved_write_line	out_txd_func;
+	devcb_resolved_read_line	in_dsr_func;
+	devcb_resolved_write_line	out_dtr_func;
+	devcb_resolved_write_line	out_rts_func;
+	devcb_resolved_write_line	out_rxrdy_func;
+	devcb_resolved_write_line	out_txrdy_func;
+	devcb_resolved_write_line	out_txempty_func;
+	devcb_resolved_write_line	out_syndet_func;
+
+	/* flags controlling how msm8251_control_w operates */
+	UINT8 flags;
+	/* offset into sync_bytes used during sync byte transfer */
+	UINT8 sync_byte_offset;
+	/* number of sync bytes written so far */
+	UINT8 sync_byte_count;
+	/* the sync bytes written */
+	UINT8 sync_bytes[2];
+	/* status of msm8251 */
+	UINT8 status;
+	UINT8 command;
+	/* mode byte - bit definitions depend on mode - e.g. synchronous, asynchronous */
+	UINT8 mode_byte;
+
+	/* data being received */
+	UINT8 data;
+
+	/* receive reg */
+	serial_receive_register receive_reg;
+	/* transmit reg */
+	serial_transmit_register transmit_reg;
+
+	data_form form;
+
+	/* the serial connection that data is transfered over */
+	/* this is usually connected to the serial device */
+	serial_connection connection;
+};
+
+
+
+/***************************************************************************
+    PROTOTYPES
+***************************************************************************/
+
+static void msm8251_in_callback(running_machine &machine, int id, unsigned long state);
+static void msm8251_update_tx_empty(device_t *device);
+static void msm8251_update_tx_ready(device_t *device);
+
+
+
+/***************************************************************************
+    INLINE FUNCTIONS
+***************************************************************************/
+
+INLINE msm8251_t *get_token(device_t *device)
+{
+	assert(device != NULL);
+	assert(device->type() == MSM8251);
+
+	return (msm8251_t *) downcast<legacy_device_base *>(device)->token();
+}
+
+
+INLINE const msm8251_interface *get_interface(device_t *device)
+{
+	assert(device != NULL);
+	assert(device->type() == MSM8251);
+
+	return (const msm8251_interface *) device->static_config();
+}
+
+
+/***************************************************************************
+    GLOBAL VARIABLES
+***************************************************************************/
+
+const msm8251_interface default_msm8251_interface = { DEVCB_NULL, };
+
+
+/***************************************************************************
+    IMPLEMENTATION
+***************************************************************************/
+
+/*-------------------------------------------------
+    msm8251_in_callback
+-------------------------------------------------*/
+
+static void msm8251_in_callback(running_machine &machine, int id, unsigned long state)
+{
+	device_t *device;
+	msm8251_t *uart;
+	int changed;
+
+	/* NPW 29-Nov-2008 - These two lines are a hack and indicate why our "serial" infrastructure needs to be updated */
+	device = machine.device("uart");
+	uart = get_token(device);
+
+	changed = uart->connection.input_state^state;
+
+	uart->connection.input_state = state;
+
+	/* did cts change state? */
+	if (changed & SERIAL_STATE_CTS)
+	{
+		/* yes */
+		/* update tx ready */
+		/* msm8251_update_tx_ready(device); */
+	}
+}
+
+
+
+/*-------------------------------------------------
+    DEVICE_START( msm8251 )
+-------------------------------------------------*/
+
+static DEVICE_START( msm8251 )
+{
+	msm8251_t *uart = get_token(device);
+	const msm8251_interface *intf = get_interface(device);
+
+	serial_helper_setup();
+
+	// resolve callbacks
+	uart->out_rxrdy_func.resolve(intf->out_rxrdy_func, *device);
+	uart->out_txrdy_func.resolve(intf->out_txrdy_func, *device);
+	uart->out_txempty_func.resolve(intf->out_txempty_func, *device);
+
+	/* setup this side of the serial connection */
+	serial_connection_init(device->machine(),&uart->connection);
+	serial_connection_set_in_callback(device->machine(),&uart->connection, msm8251_in_callback);
+	uart->connection.input_state = 0;
+}
+
+
+
+/*-------------------------------------------------
+    msm8251_update_rx_ready
+-------------------------------------------------*/
+
+static void msm8251_update_rx_ready(device_t *device)
+{
+	msm8251_t *uart = get_token(device);
+	int state;
+
+	state = uart->status & MSM8251_STATUS_RX_READY;
+
+	/* masked? */
+	if ((uart->command & (1<<2))==0)
+	{
+		state = 0;
+	}
+
+	uart->out_rxrdy_func(state != 0);
+}
+
+
+
+/*-------------------------------------------------
+    msm8251_receive_clock
+-------------------------------------------------*/
+
+void msm8251_receive_clock(device_t *device)
+{
+	msm8251_t *uart = get_token(device);
+
+	/* receive enable? */
+	if (uart->command & (1<<2))
+	{
+		//logerror("MSM8251\n");
+		/* get bit received from other side and update receive register */
+		receive_register_update_bit(&uart->receive_reg, get_in_data_bit(uart->connection.input_state));
+
+		if (uart->receive_reg.flags & RECEIVE_REGISTER_FULL)
+		{
+			receive_register_extract(&uart->receive_reg, &uart->form);
+			msm8251_receive_character(device, uart->receive_reg.byte_received);
+		}
+	}
+}
+
+
+
+/*-------------------------------------------------
+    msm8251_transmit_clock
+-------------------------------------------------*/
+
+void msm8251_transmit_clock(device_t *device)
+{
+	msm8251_t *uart = get_token(device);
+
+	/* transmit enable? */
+	if (uart->command & (1<<0))
+	{
+
+		/* transmit register full? */
+		if ((uart->status & MSM8251_STATUS_TX_READY)==0)
+		{
+			/* if transmit reg is empty */
+			if ((uart->transmit_reg.flags & TRANSMIT_REGISTER_EMPTY)!=0)
+			{
+				/* set it up */
+				transmit_register_setup(&uart->transmit_reg, &uart->form, uart->data);
+				/* msm8251 transmit reg now empty */
+				uart->status |=MSM8251_STATUS_TX_EMPTY;
+				/* ready for next transmit */
+				uart->status |=MSM8251_STATUS_TX_READY;
+
+				msm8251_update_tx_empty(device);
+				msm8251_update_tx_ready(device);
+			}
+		}
+
+		/* if transmit is not empty... transmit data */
+		if ((uart->transmit_reg.flags & TRANSMIT_REGISTER_EMPTY)==0)
+		{
+	//      logerror("MSM8251\n");
+			transmit_register_send_bit(device->machine(),&uart->transmit_reg, &uart->connection);
+		}
+	}
+
+#if 0
+	/* hunt mode? */
+	/* after each bit has been shifted in, it is compared against the current sync byte */
+	if (uart->command & (1<<7))
+	{
+		/* data matches sync byte? */
+		if (uart->data == uart->sync_bytes[uart->sync_byte_offset])
+		{
+			/* sync byte matches */
+			/* update for next sync byte? */
+			uart->sync_byte_offset++;
+
+			/* do all sync bytes match? */
+			if (uart->sync_byte_offset == uart->sync_byte_count)
+			{
+				/* ent hunt mode */
+				uart->command &=~(1<<7);
+			}
+		}
+		else
+		{
+			/* if there is no match, reset */
+			uart->sync_byte_offset = 0;
+		}
+	}
+#endif
+}
+
+
+
+/*-------------------------------------------------
+    msm8251_update_tx_ready
+-------------------------------------------------*/
+
+static void msm8251_update_tx_ready(device_t *device)
+{
+	msm8251_t *uart = get_token(device);
+
+	/* clear tx ready state */
+	int tx_ready;
+
+	/* tx ready output is set if:
+        DB Buffer Empty &
+        CTS is set &
+        Transmit enable is 1
+    */
+
+	tx_ready = 0;
+
+	/* transmit enable? */
+	if ((uart->command & (1<<0))!=0)
+	{
+		/* other side has rts set (comes in as CTS at this side) */
+		if (uart->connection.input_state & SERIAL_STATE_CTS)
+		{
+			if (uart->status & MSM8251_STATUS_TX_EMPTY)
+			{
+				/* enable transfer */
+				tx_ready = 1;
+			}
+		}
+	}
+
+	uart->out_txrdy_func(tx_ready);
+}
+
+
+
+/*-------------------------------------------------
+    msm8251_update_tx_empty
+-------------------------------------------------*/
+
+static void msm8251_update_tx_empty(device_t *device)
+{
+	msm8251_t *uart = get_token(device);
+
+	if (uart->status & MSM8251_STATUS_TX_EMPTY)
+	{
+		/* tx is in marking state (high) when tx empty! */
+		set_out_data_bit(uart->connection.State, 1);
+		serial_connection_out(device->machine(),&uart->connection);
+	}
+
+	uart->out_txempty_func((uart->status & MSM8251_STATUS_TX_EMPTY) != 0);
+}
+
+
+
+/*-------------------------------------------------
+    DEVICE_RESET( msm8251 )
+-------------------------------------------------*/
+
+static DEVICE_RESET( msm8251 )
+{
+	msm8251_t *uart = get_token(device);
+
+	LOG(("MSM8251: Reset\n"));
+
+	/* what is the default setup when the 8251 has been reset??? */
+
+	/* msm8251 datasheet explains the state of tx pin at reset */
+	/* tx is set to 1 */
+	set_out_data_bit(uart->connection.State,1);
+
+	/* assumption, rts is set to 1 */
+	uart->connection.State &= ~SERIAL_STATE_RTS;
+	serial_connection_out(device->machine(), &uart->connection);
+
+	transmit_register_reset(&uart->transmit_reg);
+	receive_register_reset(&uart->receive_reg);
+	/* expecting mode byte */
+	uart->flags |= MSM8251_EXPECTING_MODE;
+	/* not expecting a sync byte */
+	uart->flags &= ~MSM8251_EXPECTING_SYNC_BYTE;
+
+	/* no character to read by cpu */
+	/* transmitter is ready and is empty */
+	uart->status = MSM8251_STATUS_TX_EMPTY | MSM8251_STATUS_TX_READY;
+	uart->mode_byte = 0;
+	uart->command = 0;
+
+	/* update tx empty pin output */
+	msm8251_update_tx_empty(device);
+	/* update rx ready pin output */
+	msm8251_update_rx_ready(device);
+	/* update tx ready pin output */
+	msm8251_update_tx_ready(device);
+}
+
+
+
+/*-------------------------------------------------
+    WRITE8_DEVICE_HANDLER(msm8251_control_w)
+-------------------------------------------------*/
+
+WRITE8_DEVICE_HANDLER(msm8251_control_w)
+{
+	msm8251_t *uart = get_token(device);
+
+	if (uart->flags & MSM8251_EXPECTING_MODE)
+	{
+		if (uart->flags & MSM8251_EXPECTING_SYNC_BYTE)
+		{
+			LOG(("MSM8251: Sync byte\n"));
+
+			LOG(("Sync byte: %02x\n", data));
+			/* store sync byte written */
+			uart->sync_bytes[uart->sync_byte_offset] = data;
+			uart->sync_byte_offset++;
+
+			if (uart->sync_byte_offset == uart->sync_byte_count)
+			{
+				/* finished transfering sync bytes, now expecting command */
+				uart->flags &= ~(MSM8251_EXPECTING_MODE | MSM8251_EXPECTING_SYNC_BYTE);
+				uart->sync_byte_offset = 0;
+			//  uart->status = MSM8251_STATUS_TX_EMPTY | MSM8251_STATUS_TX_READY;
+			}
+		}
+		else
+		{
+			LOG(("MSM8251: Mode byte\n"));
+
+			uart->mode_byte = data;
+
+			/* Synchronous or Asynchronous? */
+			if ((data & 0x03)!=0)
+			{
+				/*  Asynchronous
+
+                    bit 7,6: stop bit length
+                        0 = inhibit
+                        1 = 1 bit
+                        2 = 1.5 bits
+                        3 = 2 bits
+                    bit 5: parity type
+                        0 = parity odd
+                        1 = parity even
+                    bit 4: parity test enable
+                        0 = disable
+                        1 = enable
+                    bit 3,2: character length
+                        0 = 5 bits
+                        1 = 6 bits
+                        2 = 7 bits
+                        3 = 8 bits
+                    bit 1,0: baud rate factor
+                        0 = defines command byte for synchronous or asynchronous
+                        1 = x1
+                        2 = x16
+                        3 = x64
+                */
+
+				LOG(("MSM8251: Asynchronous operation\n"));
+
+				LOG(("Character length: %d\n", (((data>>2) & 0x03)+5)));
+
+				if (data & (1<<4))
+				{
+					LOG(("enable parity checking\n"));
+				}
+				else
+				{
+					LOG(("parity check disabled\n"));
+				}
+
+				if (data & (1<<5))
+				{
+					LOG(("even parity\n"));
+				}
+				else
+				{
+					LOG(("odd parity\n"));
+				}
+
+				{
+					UINT8 stop_bit_length;
+
+					stop_bit_length = (data>>6) & 0x03;
+
+					switch (stop_bit_length)
+					{
+						case 0:
+						{
+							/* inhibit */
+							LOG(("stop bit: inhibit\n"));
+						}
+						break;
+
+						case 1:
+						{
+							/* 1 */
+							LOG(("stop bit: 1 bit\n"));
+						}
+						break;
+
+						case 2:
+						{
+							/* 1.5 */
+							LOG(("stop bit: 1.5 bits\n"));
+						}
+						break;
+
+						case 3:
+						{
+							/* 2 */
+							LOG(("stop bit: 2 bits\n"));
+						}
+						break;
+					}
+				}
+
+				uart->form.word_length = ((data>>2) & 0x03)+5;
+				uart->form.parity = SERIAL_PARITY_NONE;
+				switch ((data>>6) & 0x03)
+				{
+					case 0:
+					case 1:
+						uart->form.stop_bit_count =  1;
+						break;
+					case 2:
+					case 3:
+						uart->form.stop_bit_count =  2;
+						break;
+				}
+				receive_register_setup(&uart->receive_reg, &uart->form);
+
+
+#if 0
+				/* data bits */
+				uart->receive_char_length = (((data>>2) & 0x03)+5);
+
+				if (data & (1<<4))
+				{
+					/* parity */
+					uart->receive_char_length++;
+				}
+
+				/* stop bits */
+				uart->receive_char_length++;
+
+				uart->receive_flags &=~MSM8251_TRANSFER_RECEIVE_SYNCHRONISED;
+				uart->receive_flags |= MSM8251_TRANSFER_RECEIVE_WAITING_FOR_START_BIT;
+#endif
+				/* not expecting mode byte now */
+				uart->flags &= ~MSM8251_EXPECTING_MODE;
+//              uart->status = MSM8251_STATUS_TX_EMPTY | MSM8251_STATUS_TX_READY;
+			}
+			else
+			{
+				/*  bit 7: Number of sync characters
+                        0 = 1 character
+                        1 = 2 character
+                    bit 6: Synchronous mode
+                        0 = Internal synchronisation
+                        1 = External synchronisation
+                    bit 5: parity type
+                        0 = parity odd
+                        1 = parity even
+                    bit 4: parity test enable
+                        0 = disable
+                        1 = enable
+                    bit 3,2: character length
+                        0 = 5 bits
+                        1 = 6 bits
+                        2 = 7 bits
+                        3 = 8 bits
+                    bit 1,0 = 0
+                */
+				LOG(("MSM8251: Synchronous operation\n"));
+
+				/* setup for sync byte(s) */
+				uart->flags |= MSM8251_EXPECTING_SYNC_BYTE;
+				uart->sync_byte_offset = 0;
+				if (data & 0x07)
+				{
+					uart->sync_byte_count = 1;
+				}
+				else
+				{
+					uart->sync_byte_count = 2;
+				}
+
+			}
+		}
+	}
+	else
+	{
+		/* command */
+		LOG(("MSM8251: Command byte\n"));
+
+		uart->command = data;
+
+		LOG(("Command byte: %02x\n", data));
+
+		if (data & (1<<7))
+		{
+			LOG(("hunt mode\n"));
+		}
+
+		if (data & (1<<5))
+		{
+			LOG(("/rts set to 0\n"));
+		}
+		else
+		{
+			LOG(("/rts set to 1\n"));
+		}
+
+		if (data & (1<<2))
+		{
+			LOG(("receive enable\n"));
+		}
+		else
+		{
+			LOG(("receive disable\n"));
+		}
+
+		if (data & (1<<1))
+		{
+			LOG(("/dtr set to 0\n"));
+		}
+		else
+		{
+			LOG(("/dtr set to 1\n"));
+		}
+
+		if (data & (1<<0))
+		{
+			LOG(("transmit enable\n"));
+		}
+		else
+		{
+			LOG(("transmit disable\n"));
+		}
+
+
+		/*  bit 7:
+                0 = normal operation
+                1 = hunt mode
+            bit 6:
+                0 = normal operation
+                1 = internal reset
+            bit 5:
+                0 = /RTS set to 1
+                1 = /RTS set to 0
+            bit 4:
+                0 = normal operation
+                1 = reset error flag
+            bit 3:
+                0 = normal operation
+                1 = send break character
+            bit 2:
+                0 = receive disable
+                1 = receive enable
+            bit 1:
+                0 = /DTR set to 1
+                1 = /DTR set to 0
+            bit 0:
+                0 = transmit disable
+                1 = transmit enable
+        */
+
+		uart->connection.State &=~SERIAL_STATE_RTS;
+		if (data & (1<<5))
+		{
+			/* rts set to 0 */
+			uart->connection.State |= SERIAL_STATE_RTS;
+		}
+
+		uart->connection.State &=~SERIAL_STATE_DTR;
+		if (data & (1<<1))
+		{
+			uart->connection.State |= SERIAL_STATE_DTR;
+		}
+
+		if ((data & (1<<0))==0)
+		{
+			/* held in high state when transmit disable */
+			set_out_data_bit(uart->connection.State,1);
+		}
+
+
+		/* refresh outputs */
+		serial_connection_out(device->machine(), &uart->connection);
+
+		if (data & (1<<4))
+		{
+			uart->status &= ~(MSM8251_STATUS_PARITY_ERROR | MSM8251_STATUS_OVERRUN_ERROR | MSM8251_STATUS_FRAMING_ERROR);
+		}
+
+		if (data & (1<<6))
+		{
+			device->reset();
+		}
+
+		msm8251_update_rx_ready(device);
+		msm8251_update_tx_ready(device);
+
+	}
+}
+
+
+
+/*-------------------------------------------------
+    READ8_DEVICE_HANDLER(msm8251_status_r)
+-------------------------------------------------*/
+
+READ8_DEVICE_HANDLER(msm8251_status_r)
+{
+	msm8251_t *uart = get_token(device);
+
+	LOG(("status: %02x\n", uart->status));
+	return uart->status;
+}
+
+
+
+/*-------------------------------------------------
+    WRITE8_DEVICE_HANDLER(msm8251_data_w)
+-------------------------------------------------*/
+
+WRITE8_DEVICE_HANDLER(msm8251_data_w)
+{
+	msm8251_t *uart = get_token(device);
+
+	uart->data = data;
+
+	logerror("write data: %02x\n",data);
+
+	/* writing clears */
+	uart->status &=~MSM8251_STATUS_TX_READY;
+
+	/* if transmitter is active, then tx empty will be signalled */
+
+	msm8251_update_tx_ready(device);
+}
+
+
+
+/*-------------------------------------------------
+    msm8251_receive_character - called when last
+    bit of data has been received
+-------------------------------------------------*/
+
+void msm8251_receive_character(device_t *device, UINT8 ch)
+{
+	msm8251_t *uart = get_token(device);
+
+	logerror("msm8251 receive char: %02x\n",ch);
+
+	uart->data = ch;
+
+	/* char has not been read and another has arrived! */
+	if (uart->status & MSM8251_STATUS_RX_READY)
+	{
+		uart->status |= MSM8251_STATUS_OVERRUN_ERROR;
+	}
+	uart->status |= MSM8251_STATUS_RX_READY;
+
+	msm8251_update_rx_ready(device);
+}
+
+
+
+/*-------------------------------------------------
+    READ8_DEVICE_HANDLER(msm8251_data_r) - read data
+-------------------------------------------------*/
+
+READ8_DEVICE_HANDLER(msm8251_data_r)
+{
+	msm8251_t *uart = get_token(device);
+
+	logerror("read data: %02x, STATUS=%02x\n",uart->data,uart->status);
+	/* reading clears */
+	uart->status &= ~MSM8251_STATUS_RX_READY;
+
+	msm8251_update_rx_ready(device);
+	return uart->data;
+}
+
+
+
+/*-------------------------------------------------
+    msm8251_connect_to_serial_device - initialise
+    transfer using serial device - set the callback
+    which will be called when serial device has
+    updated it's state
+-------------------------------------------------*/
+
+void msm8251_connect_to_serial_device(device_t *device, device_t *image)
+{
+	msm8251_t *uart = get_token(device);
+	serial_device_connect(image, &uart->connection);
+}
+
+
+
+/*-------------------------------------------------
+    msm8251_connect
+-------------------------------------------------*/
+
+void msm8251_connect(device_t *device, serial_connection *other_connection)
+{
+	msm8251_t *uart = get_token(device);
+	serial_connection_link(device->machine(), &uart->connection, other_connection);
+}
+
+
+/*-------------------------------------------------
+    DEVICE_GET_INFO( msm8251 )
+-------------------------------------------------*/
+
+DEVICE_GET_INFO( msm8251 )
+{
+	switch (state)
+	{
+		/* --- the following bits of info are returned as 64-bit signed integers --- */
+		case DEVINFO_INT_TOKEN_BYTES:					info->i = sizeof(msm8251_t);				break;
+		case DEVINFO_INT_INLINE_CONFIG_BYTES:			info->i = 0;								break;
+
+		/* --- the following bits of info are returned as pointers to data or functions --- */
+		case DEVINFO_FCT_START:							info->start = DEVICE_START_NAME(msm8251);	break;
+		case DEVINFO_FCT_STOP:							/* Nothing */								break;
+		case DEVINFO_FCT_RESET:							info->reset = DEVICE_RESET_NAME(msm8251);	break;
+
+		/* --- the following bits of info are returned as NULL-terminated strings --- */
+		case DEVINFO_STR_NAME:							strcpy(info->s, "Intel 8251 UART");				break;
+		case DEVINFO_STR_FAMILY:						strcpy(info->s, "Intel 8251 UART");				break;
+		case DEVINFO_STR_VERSION:						strcpy(info->s, "1.0");							break;
+		case DEVINFO_STR_SOURCE_FILE:					strcpy(info->s, __FILE__);							break;
+		case DEVINFO_STR_CREDITS:						/* Nothing */								break;
+	}
+}
+
+DEFINE_LEGACY_DEVICE(MSM8251, msm8251);

src/emu/machine/msm8251.h

@@ -0,0 +1,88 @@
+/*********************************************************************
+
+    msm8251.h
+
+    MSM/Intel 8251 Universal Synchronous/Asynchronous Receiver Transmitter code
+
+*********************************************************************/
+
+#ifndef __MSM8251_H__
+#define __MSM8251_H__
+
+#include "machine/serial.h"
+
+
+/***************************************************************************
+    CONSTANTS
+***************************************************************************/
+
+DECLARE_LEGACY_DEVICE(MSM8251, msm8251);
+
+#define MSM8251_EXPECTING_MODE 0x01
+#define MSM8251_EXPECTING_SYNC_BYTE 0x02
+
+#define MSM8251_STATUS_FRAMING_ERROR 0x020
+#define MSM8251_STATUS_OVERRUN_ERROR 0x010
+#define MSM8251_STATUS_PARITY_ERROR 0x08
+#define MSM8251_STATUS_TX_EMPTY		0x04
+#define MSM8251_STATUS_RX_READY	0x02
+#define MSM8251_STATUS_TX_READY	0x01
+
+#define MCFG_MSM8251_ADD(_tag, _intrf) \
+	MCFG_DEVICE_ADD(_tag, MSM8251, 0) \
+	MCFG_DEVICE_CONFIG(_intrf)
+
+#define MCFG_MSM8251_REMOVE(_tag) \
+	MCFG_DEVICE_REMOVE(_tag)
+
+
+/***************************************************************************
+    TYPE DEFINITIONS
+***************************************************************************/
+
+typedef struct _msm8251_interface msm8251_interface;
+struct _msm8251_interface
+{
+	devcb_read_line		in_rxd_func;
+	devcb_write_line	out_txd_func;
+	devcb_read_line		in_dsr_func;
+	devcb_write_line	out_dtr_func;
+	devcb_write_line	out_rts_func;
+	devcb_write_line	out_rxrdy_func;
+	devcb_write_line	out_txrdy_func;
+	devcb_write_line	out_txempty_func;
+	devcb_write_line	out_syndet_func;
+};
+
+
+/***************************************************************************
+    PROTOTYPES
+***************************************************************************/
+
+extern const msm8251_interface default_msm8251_interface;
+
+/* read data register */
+READ8_DEVICE_HANDLER(msm8251_data_r);
+
+/* read status register */
+READ8_DEVICE_HANDLER(msm8251_status_r);
+
+/* write data register */
+WRITE8_DEVICE_HANDLER(msm8251_data_w);
+
+/* write control word */
+WRITE8_DEVICE_HANDLER(msm8251_control_w);
+
+/* The 8251 has seperate transmit and receive clocks */
+/* use these two functions to update the msm8251 for each clock */
+/* on NC100 system, the clocks are the same */
+void msm8251_transmit_clock(device_t *device);
+void msm8251_receive_clock(device_t *device);
+
+/* connecting to serial output */
+void msm8251_connect_to_serial_device(device_t *device, device_t *image);
+void msm8251_connect(device_t *device, serial_connection *other_connection);
+
+void msm8251_receive_character(device_t *device, UINT8 ch);
+
+#endif /* __MSM8251_H__ */

src/emu/machine/serial.c

@@ -0,0 +1,733 @@
+/* internal serial transmission */
+
+/* select a file on host filesystem to transfer using serial method,
+setup serial interface software in driver and let the transfer begin */
+
+/* this is used in the Amstrad NC Notepad emulation */
+
+
+
+/*
+
+    the output starts at 1 level. It changes to 0 when the start bit has been transmitted.
+    This therefore signals that data is following.
+    When all data bits have been received, stop bits are transmitted with a value of 1.
+
+    msm8251 expects this in asynchronous mode:
+    packet format:
+
+    bit count           function        value
+    1                   start bit       0
+    note 1              data bits       x
+    note 2              parity bit      x
+    note 3              stop bits       1
+
+    Note:
+    1. Data size can be defined (usual value is 8)
+    2. Parity bit (if parity is set to odd or even). Value of bit
+        is defined by data parity.
+    3. There should be at least 1 stop bit.
+*/
+
+#include "emu.h"
+#include "serial.h"
+
+
+#define VERBOSE 0
+#define LOG(x) do { if (VERBOSE) logerror x; } while (0)
+
+/* a read/write bit stream. used to transmit data and to receive data */
+typedef struct _data_stream data_stream;
+struct _data_stream
+{
+	/* pointer to buffer */
+	unsigned char *pData;
+	/* length of buffer */
+	unsigned long DataLength;
+
+	/* bit offset within current byte */
+	unsigned long BitCount;
+	/* byte offset within data */
+	unsigned long ByteCount;
+};
+
+typedef struct _serial_t serial_t;
+struct _serial_t
+{
+	/* transmit data bit-stream */
+	data_stream transmit;
+	/* receive data bit-stream */
+	data_stream receive;
+
+	/* register to receive data */
+	serial_receive_register	receive_reg;
+	/* register to transmit data */
+	serial_transmit_register transmit_reg;
+
+	/* connection to transmit/receive data over */
+	serial_connection connection;
+
+	/* data form to transmit/receive */
+	data_form form;
+
+	int transmit_state;
+
+	/* baud rate */
+	unsigned long BaudRate;
+
+	/* baud rate timer */
+	emu_timer	*timer;
+};
+
+INLINE serial_t *get_safe_token(device_t *device)
+{
+	assert(device != NULL);
+	//assert(device->type() == SERIAL);
+
+	return (serial_t *)downcast<legacy_device_base *>(device)->token();
+}
+
+
+/* the serial streams */
+static TIMER_CALLBACK(serial_device_baud_rate_callback);
+
+
+/*********************************************************/
+
+static unsigned char serial_parity_table[256];
+
+void serial_helper_setup(void)
+{
+	int i;
+
+	/* if sum of all bits in the byte is even, then the data
+    has even parity, otherwise it has odd parity */
+	for (i=0; i<256; i++)
+	{
+		int data;
+		int sum;
+		int b;
+
+		sum = 0;
+		data = i;
+
+		for (b=0; b<8; b++)
+		{
+			sum+=data & 0x01;
+
+			data = data>>1;
+		}
+
+		serial_parity_table[i] = sum & 0x01;
+	}
+}
+
+static unsigned char serial_helper_get_parity(unsigned char data)
+{
+	return serial_parity_table[data & 0x0ff];
+}
+
+static void serial_device_in_callback(running_machine &machine, int id, unsigned long status)
+{
+/*  serial_t *ser = get_safe_token(device);
+
+    ser->connection.input_state = status;*/
+}
+
+/***** SERIAL DEVICE ******/
+void serial_device_setup(device_t *device, int baud_rate, int num_data_bits, int stop_bit_count, int parity_code)
+{
+	serial_t *ser = get_safe_token(device);
+
+	ser->BaudRate = baud_rate;
+	ser->form.word_length = num_data_bits;
+	ser->form.stop_bit_count = stop_bit_count;
+	ser->form.parity = parity_code;
+	ser->timer = device->machine().scheduler().timer_alloc(FUNC(serial_device_baud_rate_callback), (void *)device);
+
+	serial_connection_init(device->machine(),&ser->connection);
+	serial_connection_set_in_callback(device->machine(),&ser->connection, serial_device_in_callback);
+
+	/* signal to other end it is clear to send! */
+	/* data is initially high state */
+	/* set /rts */
+	ser->connection.State |= SERIAL_STATE_RTS;
+	/* signal to other end data is ready to be accepted */
+	/* set /dtr */
+	ser->connection.State |= SERIAL_STATE_DTR;
+	set_out_data_bit(ser->connection.State, 1);
+	serial_connection_out(device->machine(),&ser->connection);
+	transmit_register_reset(&ser->transmit_reg);
+	receive_register_reset(&ser->receive_reg);
+	receive_register_setup(&ser->receive_reg, &ser->form);
+}
+
+
+unsigned long serial_device_get_state(device_t *device)
+{
+	serial_t *ser = get_safe_token(device);
+
+	return ser->connection.State;
+}
+
+void serial_device_set_transmit_state(device_t *device, int state)
+{
+	int previous_state;
+	serial_t *ser = get_safe_token(device);
+
+	previous_state = ser->transmit_state;
+
+	ser->transmit_state = state;
+
+	if ((state^previous_state)!=0)
+	{
+		if (state)
+		{
+			/* start timer */
+			ser->timer->adjust(attotime::zero, 0, attotime::from_hz(ser->BaudRate));
+		}
+		else
+		{
+			/* remove timer */
+			ser->timer->reset();
+		}
+	}
+
+}
+
+/* get a bit from input stream */
+static int data_stream_get_data_bit_from_data_byte(data_stream *stream)
+{
+	int data_bit;
+	int data_byte;
+
+	if (stream->ByteCount<stream->DataLength)
+	{
+		/* get data from buffer */
+		data_byte= stream->pData[stream->ByteCount];
+	}
+	else
+	{
+		/* over end of buffer, so return 0 */
+		data_byte= 0;
+	}
+
+	/* get bit from data */
+	data_bit = (data_byte>>(7-stream->BitCount)) & 0x01;
+
+	/* update bit count */
+	stream->BitCount++;
+	/* ripple overflow onto byte count */
+	stream->ByteCount+=stream->BitCount>>3;
+	/* lock bit count into range */
+	stream->BitCount &=0x07;
+
+	/* do not let it read over end of data */
+	if (stream->ByteCount>=stream->DataLength)
+	{
+		stream->ByteCount = stream->DataLength-1;
+	}
+
+	return data_bit;
+}
+
+
+void receive_register_setup(serial_receive_register *receive, data_form *data_form)
+{
+	receive->bit_count = data_form->word_length + data_form->stop_bit_count;
+
+	if (data_form->parity != SERIAL_PARITY_NONE)
+	{
+		receive->bit_count++;
+	}
+}
+
+
+/* this is generic code to be used in serial chip implementations */
+/* the majority of serial chips work in the same way and this code will work */
+/* for them */
+
+/* receive a bit */
+void receive_register_update_bit(serial_receive_register *receive, int bit)
+{
+	int previous_bit;
+
+	LOG(("receive register receive bit: %1x\n",bit));
+	previous_bit = receive->register_data & 1;
+
+	/* shift previous bit 7 out */
+	receive->register_data = receive->register_data<<1;
+	/* shift new bit in */
+	receive->register_data = (receive->register_data & 0xfffe) | bit;
+	/* update bit count received */
+	receive->bit_count_received++;
+
+	/* asyncrhonouse mode */
+	if (receive->flags & RECEIVE_REGISTER_WAITING_FOR_START_BIT)
+	{
+		/* the previous bit is stored in uart.receive char bit 0 */
+		/* has the bit state changed? */
+		if (((previous_bit ^ bit) & 0x01)!=0)
+		{
+			/* yes */
+			if (bit==0)
+			{
+				//logerror("receive register saw start bit\n");
+
+				/* seen start bit! */
+				/* not waiting for start bit now! */
+				receive->flags &=~RECEIVE_REGISTER_WAITING_FOR_START_BIT;
+				receive->flags |=RECEIVE_REGISTER_SYNCHRONISED;
+				/* reset bit count received */
+				receive->bit_count_received = 0;
+			}
+		}
+	}
+	else
+	if (receive->flags & RECEIVE_REGISTER_SYNCHRONISED)
+	{
+		/* received all bits? */
+		if (receive->bit_count_received==receive->bit_count)
+		{
+			receive->bit_count_received = 0;
+			receive->flags &=~RECEIVE_REGISTER_SYNCHRONISED;
+			receive->flags |= RECEIVE_REGISTER_WAITING_FOR_START_BIT;
+			//logerror("receive register full\n");
+			receive->flags |= RECEIVE_REGISTER_FULL;
+		}
+	}
+}
+
+void receive_register_reset(serial_receive_register *receive_reg)
+{
+	receive_reg->bit_count_received = 0;
+	receive_reg->flags &=~RECEIVE_REGISTER_FULL;
+	receive_reg->flags &=~RECEIVE_REGISTER_SYNCHRONISED;
+	receive_reg->flags |= RECEIVE_REGISTER_WAITING_FOR_START_BIT;
+}
+
+void receive_register_extract(serial_receive_register *receive_reg, data_form *data_form)
+{
+	unsigned long data_shift;
+	UINT8 data;
+
+	receive_register_reset(receive_reg);
+
+	data_shift = 0;
+
+	/* if parity is even or odd, there should be a parity bit in the stream! */
+	if (data_form->parity!=SERIAL_PARITY_NONE)
+	{
+		data_shift++;
+	}
+
+	data_shift+=data_form->stop_bit_count;
+
+	/* strip off stop bits and parity */
+	data = receive_reg->register_data>>data_shift;
+
+	/* mask off other bits so data byte has 0's in unused bits */
+	data = data & (0x0ff
+		>>
+		(8-(data_form->word_length)));
+
+	receive_reg->byte_received  = data;
+
+	/* parity enable? */
+	switch (data_form->parity)
+	{
+		case SERIAL_PARITY_NONE:
+			break;
+
+		/* check parity */
+		case SERIAL_PARITY_ODD:
+		case SERIAL_PARITY_EVEN:
+		{
+			//unsigned char computed_parity;
+			//unsigned char parity_received;
+
+			/* get state of parity bit received */
+			//parity_received = (receive_reg->register_data>>data_form->stop_bit_count) & 0x01;
+
+			/* compute parity for received bits */
+			//computed_parity = serial_helper_get_parity(data);
+
+			if (data_form->parity == SERIAL_PARITY_ODD)
+			{
+				/* odd parity */
+
+
+			}
+			else
+			{
+				/* even parity */
+
+
+			}
+
+		}
+		break;
+	}
+}
+
+/***** TRANSMIT REGISTER *****/
+
+void transmit_register_reset(serial_transmit_register *transmit_reg)
+{
+	transmit_reg->flags |=TRANSMIT_REGISTER_EMPTY;
+}
+
+/* used to construct data in stream format */
+static void transmit_register_add_bit(serial_transmit_register *transmit_reg, int bit)
+{
+	/* combine bit */
+	transmit_reg->register_data = transmit_reg->register_data<<1;
+	transmit_reg->register_data &=~1;
+	transmit_reg->register_data|=(bit & 0x01);
+	transmit_reg->bit_count++;
+}
+
+
+/* generate data in stream format ready for transfer */
+void transmit_register_setup(serial_transmit_register *transmit_reg, data_form *data_form,unsigned char data_byte)
+{
+	int i;
+	unsigned char transmit_data;
+
+
+	transmit_reg->bit_count_transmitted = 0;
+	transmit_reg->bit_count = 0;
+	transmit_reg->flags &=~TRANSMIT_REGISTER_EMPTY;
+
+	/* start bit */
+	transmit_register_add_bit(transmit_reg,0);
+
+	/* data bits */
+	transmit_data = data_byte;
+	for (i=0; i<data_form->word_length; i++)
+	{
+		int databit;
+
+		/* get bit from data */
+		databit = (transmit_data>>(data_form->word_length-1)) & 0x01;
+		/* add bit to formatted byte */
+		transmit_register_add_bit(transmit_reg, databit);
+		transmit_data = transmit_data<<1;
+	}
+
+	/* parity */
+	if (data_form->parity!=SERIAL_PARITY_NONE)
+	{
+		/* odd or even parity */
+		unsigned char parity;
+
+		/* get parity */
+		/* if parity = 0, data has even parity - i.e. there is an even number of one bits in the data */
+		/* if parity = 1, data has odd parity - i.e. there is an odd number of one bits in the data */
+		parity = serial_helper_get_parity(data_byte);
+
+		transmit_register_add_bit(transmit_reg, parity);
+	}
+
+	/* stop bit(s) */
+	for (i=0; i<data_form->stop_bit_count; i++)
+	{
+		transmit_register_add_bit(transmit_reg,1);
+	}
+}
+
+
+/* get a bit from the transmit register */
+static int transmit_register_get_data_bit(serial_transmit_register *transmit_reg)
+{
+	int bit;
+
+	bit = (transmit_reg->register_data>>
+		(transmit_reg->bit_count - 1 -
+		transmit_reg->bit_count_transmitted)) & 0x01;
+
+	transmit_reg->bit_count_transmitted++;
+
+	/* have all bits of this stream formatted byte been sent? */
+	if (transmit_reg->bit_count_transmitted==transmit_reg->bit_count)
+	{
+		/* yes - generate a new byte to send */
+		transmit_reg->flags |= TRANSMIT_REGISTER_EMPTY;
+	}
+
+	return bit;
+}
+
+
+void transmit_register_send_bit(running_machine &machine, serial_transmit_register *transmit_reg, serial_connection *connection)
+{
+	int data;
+
+	data = transmit_register_get_data_bit(transmit_reg);
+
+	/* set tx data bit */
+	set_out_data_bit(connection->State, data);
+
+	/* state out through connection */
+	serial_connection_out(machine, connection);
+}
+
+static void serial_protocol_none_sent_char(device_t *device)
+{
+	int i;
+	int bit;
+	unsigned char data_byte;
+	serial_t *ser = get_safe_token(device);
+
+	/* generate byte to transmit */
+	data_byte = 0;
+	for (i=0; i<ser->form.word_length; i++)
+	{
+		data_byte = data_byte<<1;
+		bit = data_stream_get_data_bit_from_data_byte(&ser->transmit);
+		data_byte = data_byte|bit;
+	}
+	/* setup register */
+	transmit_register_setup(&ser->transmit_reg,&ser->form, data_byte);
+
+	logerror("serial device transmitted char: %02x\n",data_byte);
+}
+
+static TIMER_CALLBACK(serial_device_baud_rate_callback)
+{
+	serial_t *ser = get_safe_token((device_t*)ptr);
+
+	/* receive data into receive register */
+	receive_register_update_bit(&ser->receive_reg, get_in_data_bit(ser->connection.input_state));
+
+	if (ser->receive_reg.flags & RECEIVE_REGISTER_FULL)
+	{
+		//logerror("SERIAL DEVICE\n");
+		receive_register_extract(&ser->receive_reg, &ser->form);
+
+		logerror("serial device receive char: %02x\n",ser->receive_reg.byte_received);
+	}
+
+	/* is transmit empty? */
+	if (ser->transmit_reg.flags & TRANSMIT_REGISTER_EMPTY)
+	{
+		/* char has been sent, execute callback */
+		serial_protocol_none_sent_char((device_t*)ptr);
+	}
+
+	/* other side says it is clear to send? */
+	if (ser->connection.input_state & SERIAL_STATE_CTS)
+	{
+		/* send bit */
+		transmit_register_send_bit(machine, &ser->transmit_reg, &ser->connection);
+	}
+}
+
+/* connect the specified connection to this serial device */
+void serial_device_connect(device_t *device, serial_connection *connection)
+{
+	serial_t *ser = get_safe_token(device);
+	serial_connection_link(device->machine(), connection, &ser->connection);
+}
+
+
+/* load image */
+static int serial_device_load_internal(device_image_interface &image, unsigned char **ptr, int *pDataSize)
+{
+	int datasize;
+	unsigned char *data;
+
+	/* get file size */
+	datasize = image.length();
+
+	if (datasize!=0)
+	{
+		/* malloc memory for this data */
+		data = (unsigned char *)malloc(datasize);
+
+		if (data!=NULL)
+		{
+			/* read whole file */
+			image.fread(data, datasize);
+
+			*ptr = data;
+			*pDataSize = datasize;
+
+			logerror("File loaded!\r\n");
+
+			/* ok! */
+			return 1;
+		}
+	}
+	return 0;
+}
+
+/* reset position in stream */
+static void data_stream_reset(data_stream *stream)
+{
+	/* reset byte offset */
+	stream->ByteCount= 0;
+	/* reset bit count */
+	stream->BitCount = 0;
+}
+
+/* free stream */
+static void data_stream_free(data_stream *stream)
+{
+	if (stream->pData!=NULL)
+	{
+		free(stream->pData);
+		stream->pData = NULL;
+	}
+	stream->DataLength = 0;
+}
+
+/* initialise stream */
+static void data_stream_init(data_stream *stream, unsigned char *pData, unsigned long DataLength)
+{
+	stream->pData = pData;
+	stream->DataLength = DataLength;
+	data_stream_reset(stream);
+}
+
+DEVICE_START(serial)
+{
+	//serial_t *ser = get_safe_token(device);
+}
+
+DEVICE_RESET(serial)
+{
+//  serial_t *ser = get_safe_token(device);
+}
+
+DEVICE_IMAGE_LOAD(serial)
+{
+	int data_length;
+	unsigned char *data;
+	device_t *device = &image.device();
+
+	serial_t *ser = get_safe_token(device);
+
+	/* load file and setup transmit data */
+	if (serial_device_load_internal(image, &data, &data_length))
+	{
+		data_stream_init(&ser->transmit, data, data_length);
+		return IMAGE_INIT_PASS;
+	}
+
+	return IMAGE_INIT_FAIL;
+}
+
+
+DEVICE_IMAGE_UNLOAD(serial)
+{
+	device_t *device = &image.device();
+	serial_t *ser = get_safe_token(device);
+
+	/* stop transmit */
+	serial_device_set_transmit_state(device, 0);
+	/* free streams */
+	data_stream_free(&ser->transmit);
+	data_stream_free(&ser->receive);
+}
+
+
+DEVICE_GET_INFO( serial )
+{
+	switch ( state )
+	{
+		case DEVINFO_INT_TOKEN_BYTES:				info->i = sizeof(serial_t);								break;
+		case DEVINFO_INT_INLINE_CONFIG_BYTES:		info->i = 0;											break;
+		case DEVINFO_INT_IMAGE_TYPE:	            info->i = IO_SERIAL;                                	break;
+		case DEVINFO_INT_IMAGE_READABLE:            info->i = 1;                                        	break;
+		case DEVINFO_INT_IMAGE_WRITEABLE:			info->i = 1;                                        	break;
+		case DEVINFO_INT_IMAGE_CREATABLE:	    	info->i = 1;                                        	break;
+
+		case DEVINFO_FCT_START:		                info->start = DEVICE_START_NAME( serial );          	break;
+		case DEVINFO_FCT_RESET:						info->reset = DEVICE_RESET_NAME( serial );				break;
+		case DEVINFO_FCT_IMAGE_LOAD:		        info->f = (genf *) DEVICE_IMAGE_LOAD_NAME( serial );	break;
+		case DEVINFO_FCT_IMAGE_UNLOAD:		        info->f = (genf *) DEVICE_IMAGE_UNLOAD_NAME(serial );	break;
+		case DEVINFO_STR_NAME:		                strcpy( info->s, "Serial port");	                    break;
+		case DEVINFO_STR_FAMILY:                    strcpy(info->s, "Serial port");	                        break;
+		case DEVINFO_STR_IMAGE_FILE_EXTENSIONS:	    strcpy(info->s, "");                                    break;
+		case DEVINFO_STR_VERSION:					strcpy(info->s, "1.0");									break;
+		case DEVINFO_STR_SOURCE_FILE:				strcpy(info->s, __FILE__);								break;
+		case DEVINFO_STR_CREDITS:					strcpy(info->s, "Copyright the MESS Team"); 			break;
+	}
+}
+
+/*******************************************************************************/
+/*******************************************************************************/
+/********* SERIAL CONNECTION ***********/
+
+
+/* this converts state at this end to a state the other end can accept */
+/* e.g. CTS at this end becomes RTS at other end.
+        RTS at this end becomes CTS at other end.
+        TX at this end becomes RX at other end.
+        RX at this end becomes TX at other end.
+        etc
+
+        The same thing is done inside the serial null-terminal lead */
+
+static unsigned long serial_connection_spin_bits(unsigned long input_status)
+{
+
+	return
+		/* cts -> rts */
+		(((input_status & 0x01)<<1) |
+		/* rts -> cts */
+		((input_status>>1) & 0x01) |
+		/* dsr -> dtr */
+		(((input_status>>2) & 0x01)<<3) |
+		/* dtr -> dsr */
+		(((input_status>>3) & 0x01)<<2) |
+		/* rx -> tx */
+		(((input_status>>4) & 0x01)<<5) |
+		/* tx -> rx */
+		(((input_status>>5) & 0x01)<<4));
+}
+
+
+/* setup callbacks for connection */
+void serial_connection_init(running_machine &machine, serial_connection *connection)
+{
+	connection->out_callback = NULL;
+	connection->in_callback = NULL;
+}
+
+/* set callback which will be executed when in status has changed */
+void serial_connection_set_in_callback(running_machine &machine, serial_connection *connection, void (*in_cb)(running_machine &machine, int id, unsigned long status))
+{
+	connection->in_callback = in_cb;
+}
+
+/* output new state through connection */
+void serial_connection_out(running_machine &machine, serial_connection *connection)
+{
+	if (connection->out_callback!=NULL)
+	{
+		unsigned long state_at_other_end;
+
+		state_at_other_end = serial_connection_spin_bits(connection->State);
+
+		connection->out_callback(machine, connection->id, state_at_other_end);
+	}
+}
+
+/* join two serial connections together */
+void serial_connection_link(running_machine &machine, serial_connection *connection_a, serial_connection *connection_b)
+{
+	/* both connections should have their in connection setup! */
+	/* the in connection is the callback they use to update their state based
+    on the output from the other side */
+	connection_a->out_callback = connection_b->in_callback;
+	connection_b->out_callback = connection_a->in_callback;
+
+	/* let b know the state of a */
+	serial_connection_out(machine,connection_a);
+	/* let a know the state of b */
+	serial_connection_out(machine,connection_b);
+}
+
+DEFINE_LEGACY_IMAGE_DEVICE(SERIAL, serial);

src/emu/machine/serial.h

@@ -0,0 +1,247 @@
+/*****************************************************************************
+ *
+ * machine/serial.h
+ *
+ * internal serial transmission
+ *
+ * This code is used to transmit a file stored on the host filesystem
+ * (e.g. PC harddrive) to an emulated system.
+ *
+ * The file is converted into a serial bit-stream which can be received
+ * by the emulated serial chip in the emulated system.
+ *
+ * The file can be transmitted using different protocols.
+ *
+ * A and B are two computers linked with a serial connection
+ * A and B can transmit and receive data, through the same connection
+ *
+ * These flags apply to A and B, and give the state of the input & output
+ * signals at each side.
+ *
+ ****************************************************************************/
+
+#ifndef SERIAL_H_
+#define SERIAL_H_
+
+
+/*
+    CTS = Clear to Send. (INPUT)
+    Other end of connection is ready to accept data
+
+
+    NOTE:
+
+      This output is active low on serial chips (e.g. 0 is CTS is set),
+      but here it is active high!
+*/
+#define SERIAL_STATE_CTS	0x0001
+
+/*
+    RTS = Request to Send. (OUTPUT)
+    This end is ready to send data, and requests if the other
+    end is ready to accept it
+
+    NOTE:
+
+      This output is active low on serial chips (e.g. 0 is RTS is set),
+      but here it is active high!
+*/
+#define SERIAL_STATE_RTS	0x0002
+
+/*
+    DSR = Data Set ready. (INPUT)
+    Other end of connection has data
+
+
+    NOTE:
+
+      This output is active low on serial chips (e.g. 0 is DSR is set),
+      but here it is active high!
+*/
+#define SERIAL_STATE_DSR	0x0004
+
+/*
+    DTR = Data terminal Ready. (OUTPUT)
+    TX contains new data.
+
+    NOTE:
+
+      This output is active low on serial chips (e.g. 0 is DTR is set),
+      but here it is active high!
+*/
+#define SERIAL_STATE_DTR	0x0008
+/* RX = Recieve data. (INPUT) */
+#define SERIAL_STATE_RX_DATA	0x00010
+/* TX = Transmit data. (OUTPUT) */
+#define SERIAL_STATE_TX_DATA	0x00020
+
+/* parity selections */
+/* if all the bits are added in a byte, if the result is:
+    even -> parity is even
+    odd -> parity is odd
+*/
+enum
+{
+	SERIAL_PARITY_NONE,		/* no parity. a parity bit will not be in the transmitted/received data */
+	SERIAL_PARITY_ODD,		/* odd parity */
+	SERIAL_PARITY_EVEN		/* even parity */
+};
+
+/* this macro is used to extract the received data from the status */
+#define get_in_data_bit(x) ((x & SERIAL_STATE_RX_DATA)>>4)
+
+/* this macro is used to set the transmitted data in the status */
+#define set_out_data_bit(x, data) \
+	x&=~SERIAL_STATE_TX_DATA; \
+	x|=(data<<5)
+
+
+/*******************************************************************************/
+/**** SERIAL CONNECTION ***/
+
+
+/* this structure represents a serial connection */
+typedef struct _serial_connection serial_connection;
+struct _serial_connection
+{
+	int id;
+	/* state of this side */
+	unsigned long State;
+
+	/* state of other side - store here */
+	unsigned long input_state;
+
+	/* this callback is executed when this side has refreshed it's state,
+    to let the other end know */
+	void	(*out_callback)(running_machine &machine, int id, unsigned long state);
+	/* this callback is executed when the other side has refreshed it's state,
+    to let the other end know */
+	void	(*in_callback)(running_machine &machine, int id, unsigned long state);
+};
+
+/*----------- defined in machine/serial.c -----------*/
+
+/* setup out and in callbacks */
+void serial_connection_init(running_machine &machine, serial_connection *connection);
+
+/* set callback which will be executed when in status has changed */
+void serial_connection_set_in_callback(running_machine &machine, serial_connection *connection, void (*in_cb)(running_machine &machine, int id, unsigned long status));
+
+/* output status, if callback is setup it will be executed with the new status */
+void serial_connection_out(running_machine &machine, serial_connection *connection);
+
+/* join two serial connections */
+void serial_connection_link(running_machine &machine, serial_connection *connection_a, serial_connection *connection_b);
+
+
+/*******************************************************************************/
+
+/* form of data being transmitted and received */
+typedef struct _data_form data_form;
+struct _data_form
+{
+	/* length of word in bits */
+	unsigned long word_length;
+	/* parity state */
+	unsigned long parity;
+	/* number of stop bits */
+	unsigned long stop_bit_count;
+};
+
+/*******************************************************************************/
+
+/*******************************************************************************/
+/**** RECEIVE AND TRANSMIT GENERIC CODE ****/
+
+/* this can be used by most of the serial chip implementations,
+because they all work in roughly the same way.
+There is generic code to send and receive data in the specified form */
+
+/* receive is waiting for start bit. The transition from high-low indicates
+start of start bit. This is used to synchronise with the data being transfered */
+#define RECEIVE_REGISTER_WAITING_FOR_START_BIT 0x01
+/* receive is synchronised with data, data bits will be clocked in */
+#define RECEIVE_REGISTER_SYNCHRONISED 0x02
+/* set if receive register has been filled */
+#define RECEIVE_REGISTER_FULL 0x04
+
+
+/* the receive register holds data in receive form! */
+/* this must be extracted to get the data byte received */
+typedef struct _serial_receive_register serial_receive_register;
+struct _serial_receive_register
+{
+	/* data */
+	unsigned long register_data;
+	/* flags */
+	unsigned long flags;
+	/* bit count received */
+	unsigned long bit_count_received;
+	/* length of data to receive - includes data bits, parity bit and stop bit */
+	unsigned long bit_count;
+
+	/* the byte of data received */
+	unsigned char byte_received;
+};
+
+void	receive_register_setup(serial_receive_register *receive, data_form *data_form);
+void	receive_register_update_bit(serial_receive_register *receive, int bit_state);
+void	receive_register_extract(serial_receive_register *receive_reg, data_form *data_form);
+void	receive_register_reset(serial_receive_register *receive_reg);
+
+/* the transmit register is the final stage
+in the serial transmit procedure */
+/* normally, data is written to the transmit reg,
+then it is assembled into transmit form and transmitted */
+/* the transmit register holds data in transmit form */
+
+/* register is empty and ready to be filled with data */
+#define TRANSMIT_REGISTER_EMPTY 0x0001
+
+typedef struct _serial_transmit_register serial_transmit_register;
+struct _serial_transmit_register
+{
+	/* data */
+	unsigned long register_data;
+	/* flags */
+	unsigned long flags;
+	/* number of bits transmitted */
+	unsigned long bit_count_transmitted;
+	/* length of data to send */
+	unsigned long bit_count;
+};
+
+/* setup transmit reg ready for transmit */
+void transmit_register_setup(serial_transmit_register *transmit_reg, data_form *data_form,unsigned char data_byte);
+void	transmit_register_send_bit(running_machine &machine, serial_transmit_register *transmit_reg, serial_connection *connection);
+void	transmit_register_reset(serial_transmit_register *transmit_reg);
+
+/*******************************************************************************/
+/**** SERIAL HELPER ****/
+
+void serial_helper_setup(void);
+
+/*******************************************************************************/
+/**** SERIAL DEVICE ****/
+
+unsigned long serial_device_get_state(device_t *device);
+
+/* connect this device to the emulated serial chip */
+/* id is the serial device to connect to */
+/* connection is the serial connection to connect to the serial device */
+void serial_device_connect(device_t *image, serial_connection *connection);
+
+DECLARE_LEGACY_IMAGE_DEVICE(SERIAL, serial);
+
+#define MCFG_SERIAL_ADD(_tag) \
+	MCFG_DEVICE_ADD(_tag, SERIAL, 0)
+
+DEVICE_START(serial);
+DEVICE_IMAGE_LOAD(serial);
+
+void serial_device_setup(device_t *image, int baud_rate, int num_data_bits, int stop_bit_count, int parity_code);
+
+/* set the transmit state of the serial device */
+void serial_device_set_transmit_state(device_t *image, int state);
+
+#endif /* SERIAL_H_ */

src/emu/machine/upd765.h

@@ -0,0 +1,161 @@
+/***************************************************************************
+
+    machine/upd765.h
+
+    Functions to emulate a NEC upd765/Intel 8272 compatible
+    floppy disk controller
+
+***************************************************************************/
+
+#ifndef __UPD765_H__
+#define __UPD765_H__
+
+#include "devcb.h"
+#include "imagedev/flopdrv.h"
+
+
+/***************************************************************************
+    MACROS
+***************************************************************************/
+
+DECLARE_LEGACY_DEVICE(UPD765A, upd765a);
+DECLARE_LEGACY_DEVICE(UPD765B, upd765b);
+DECLARE_LEGACY_DEVICE(SMC37C78, smc37c78);
+DECLARE_LEGACY_DEVICE(UPD72065, upd72065);
+
+/***************************************************************************
+    TYPE DEFINITIONS
+***************************************************************************/
+
+/* RDY pin connected state */
+typedef enum
+{
+	UPD765_RDY_PIN_NOT_CONNECTED = 0,
+	UPD765_RDY_PIN_CONNECTED = 1
+} UPD765_RDY_PIN;
+
+#define UPD765_DAM_DELETED_DATA 0x0f8
+#define UPD765_DAM_DATA 0x0fb
+
+typedef device_t *(*upd765_get_image_func)(device_t *device, int floppy_index);
+#define UPD765_GET_IMAGE(name)	device_t *name(device_t *device, int floppy_index )
+
+
+typedef struct upd765_interface
+{
+	/* interrupt issued */
+	devcb_write_line out_int_func;
+
+	/* dma data request */
+	devcb_write_line out_drq_func;
+
+	/* image lookup */
+	upd765_get_image_func get_image;
+
+	UPD765_RDY_PIN rdy_pin;
+
+	const char *floppy_drive_tags[4];
+} upd765_interface;
+
+
+/***************************************************************************
+    FUNCTION PROTOTYPES
+***************************************************************************/
+
+/* read of data register */
+READ8_DEVICE_HANDLER(upd765_data_r);
+/* write to data register */
+WRITE8_DEVICE_HANDLER(upd765_data_w);
+/* read of main status register */
+READ8_DEVICE_HANDLER(upd765_status_r);
+
+/* dma acknowledge with write */
+WRITE8_DEVICE_HANDLER(upd765_dack_w);
+/* dma acknowledge with read */
+READ8_DEVICE_HANDLER(upd765_dack_r);
+
+/* reset upd765 */
+void upd765_reset(device_t *device, int);
+
+/* reset pin of upd765 */
+WRITE_LINE_DEVICE_HANDLER(upd765_reset_w);
+
+/* set upd765 terminal count input state */
+WRITE_LINE_DEVICE_HANDLER(upd765_tc_w);
+
+/* set upd765 ready input*/
+WRITE_LINE_DEVICE_HANDLER(upd765_ready_w);
+
+void upd765_idle(device_t *device);
+
+/*********************/
+/* STATUS REGISTER 1 */
+
+/* this is set if a TC signal was not received after the sector data was read */
+#define UPD765_ST1_END_OF_CYLINDER (1<<7)
+/* this is set if the sector ID being searched for is not found */
+#define UPD765_ST1_NO_DATA (1<<2)
+/* set if disc is write protected and a write/format operation was performed */
+#define UPD765_ST1_NOT_WRITEABLE (1<<1)
+
+/*********************/
+/* STATUS REGISTER 2 */
+
+/* C parameter specified did not match C value read from disc */
+#define UPD765_ST2_WRONG_CYLINDER (1<<4)
+/* C parameter specified did not match C value read from disc, and C read from disc was 0x0ff */
+#define UPD765_ST2_BAD_CYLINDER (1<<1)
+/* this is set if the FDC encounters a Deleted Data Mark when executing a read data
+command, or FDC encounters a Data Mark when executing a read deleted data command */
+#define UPD765_ST2_CONTROL_MARK (1<<6)
+
+/***************************************************************************
+    DEVICE CONFIGURATION MACROS
+***************************************************************************/
+
+#define MCFG_UPD765A_ADD(_tag, _intrf) \
+	MCFG_DEVICE_ADD(_tag, UPD765A, 0) \
+	MCFG_DEVICE_CONFIG(_intrf)
+
+#define MCFG_UPD765A_MODIFY(_tag, _intrf) \
+  MCFG_DEVICE_MODIFY(_tag)	      \
+  MCFG_DEVICE_CONFIG(_intrf)
+
+#define MCFG_UPD765A_REMOVE(_tag)		\
+  MCFG_DEVICE_REMOVE(_tag)
+
+#define MCFG_UPD765B_ADD(_tag, _intrf) \
+	MCFG_DEVICE_ADD(_tag, UPD765B, 0) \
+	MCFG_DEVICE_CONFIG(_intrf)
+
+#define MCFG_UPD765B_MODIFY(_tag, _intrf) \
+  MCFG_DEVICE_MODIFY(_tag)	      \
+  MCFG_DEVICE_CONFIG(_intrf)
+
+#define MCFG_UPD765B_REMOVE(_tag)		\
+  MCFG_DEVICE_REMOVE(_tag)
+
+#define MCFG_SMC37C78_ADD(_tag, _intrf) \
+	MCFG_DEVICE_ADD(_tag, SMC37C78, 0) \
+	MCFG_DEVICE_CONFIG(_intrf)
+
+#define MCFG_SMC37C78_MODIFY(_tag, _intrf) \
+  MCFG_DEVICE_MODIFY(_tag)	      \
+  MCFG_DEVICE_CONFIG(_intrf)
+
+#define MCFG_SMC37C78_REMOVE(_tag)		\
+  MCFG_DEVICE_REMOVE(_tag)
+
+#define MCFG_UPD72065_ADD(_tag, _intrf) \
+	MCFG_DEVICE_ADD(_tag, UPD72065, 0) \
+	MCFG_DEVICE_CONFIG(_intrf)
+
+#define MCFG_UPD72065_MODIFY(_tag, _intrf) \
+  MCFG_DEVICE_MODIFY(_tag)	      \
+  MCFG_DEVICE_CONFIG(_intrf)
+
+#define MCFG_UPD72065_REMOVE(_tag)		\
+  MCFG_DEVICE_REMOVE(_tag)
+
+
+#endif /* __UPD765_H__ */

src/mame/drivers/dc.c

@@ -0,0 +1,379 @@
+/*
+
+    dc.c - Sega Dreamcast driver
+    by R. Belmont
+
+    SH-4 @ 200 MHz
+    ARM7DI @ 2.8223 MHz (no T or M extensions)
+    PowerVR 3D video
+    AICA audio
+    GD-ROM drive (modified ATAPI interface)
+
+            NTSC/N  NTSC/I   PAL/N   PAL/I   VGA
+        (x/240) (x/480) (x/240)  (x/480) (640x480)
+    VTOTAL   262     524      312     624    524
+    HTOTAL   857     857      863     863    857
+
+    PCLKs = 26917135 (NTSC 480 @ 59.94), 26944080 (VGA 480 @ 60.0), 13458568 (NTSC 240 @ 59.94),
+            25925600 (PAL 480 @ 50.00), 13462800 (PAL 240 @ 50.00)
+
+*/
+
+#include "emu.h"
+#include "cpu/arm7/arm7.h"
+#include "cpu/sh4/sh4.h"
+#include "cpu/arm7/arm7core.h"
+#include "sound/aica.h"
+#include "includes/dc.h"
+#include "imagedev/chd_cd.h"
+#include "machine/maple-dc.h"
+#define CPU_CLOCK (200000000)
+
+#ifdef MESS
+UINT16 actel_id;
+int jvsboard_type;
+#else
+extern UINT16 actel_id;
+extern int jvsboard_type;
+#endif
+
+// things from mess/machine/dc.c
+void dreamcast_atapi_init(running_machine &machine);
+void dreamcast_atapi_reset(running_machine &machine);
+extern READ64_HANDLER( dc_mess_gdrom_r );
+extern WRITE64_HANDLER( dc_mess_gdrom_w );
+extern READ64_HANDLER( dc_mess_g1_ctrl_r );
+extern WRITE64_HANDLER( dc_mess_g1_ctrl_w );
+
+static UINT32 *dc_sound_ram;
+static UINT64 *dc_ram;
+
+static READ64_HANDLER( dcus_idle_skip_r )
+{
+	if (cpu_get_pc(&space->device())==0xc0ba52a)
+		device_spin_until_time(&space->device(), attotime::from_usec(2500));
+	//  device_spinuntil_int(&space->device());
+
+	return dc_ram[0x2303b0/8];
+}
+
+static READ64_HANDLER( dcjp_idle_skip_r )
+{
+	if (cpu_get_pc(&space->device())==0xc0bac62)
+		device_spin_until_time(&space->device(), attotime::from_usec(2500));
+	//  device_spinuntil_int(&space->device());
+
+	return dc_ram[0x2302f8/8];
+}
+
+static DRIVER_INIT(dc)
+{
+	dreamcast_atapi_init(machine);
+}
+
+static DRIVER_INIT(dcus)
+{
+	machine.device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_read_handler(0xc2303b0, 0xc2303b7, FUNC(dcus_idle_skip_r));
+
+	DRIVER_INIT_CALL(dc);
+}
+
+static DRIVER_INIT(dcjp)
+{
+	machine.device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_read_handler(0xc2302f8, 0xc2302ff, FUNC(dcjp_idle_skip_r));
+
+	DRIVER_INIT_CALL(dc);
+}
+
+static UINT64 PDTRA, PCTRA;
+static READ64_HANDLER( dc_pdtra_r )
+{
+	UINT64 out = PCTRA<<32;
+
+	out |= PDTRA & ~3;
+
+	// if both bits are inputs
+	if (!(PCTRA & 0x5))
+	{
+		out |= 3;
+	}
+
+	// one's input one's output, always pull up both bits
+	if (((PCTRA & 5) == 1) || ((PCTRA & 5) == 4))
+	{
+		if (PDTRA & 3)
+		{
+			out |= 3;
+		}
+	}
+
+	return out;
+}
+
+static WRITE64_HANDLER( dc_pdtra_w )
+{
+	PCTRA = (data>>16) & 0xffff;
+	PDTRA = (data & 0xffff);
+}
+
+static READ64_HANDLER( dc_arm_r )
+{
+	return *((UINT64 *)dc_sound_ram+offset);
+}
+
+static WRITE64_HANDLER( dc_arm_w )
+{
+	COMBINE_DATA((UINT64 *)dc_sound_ram + offset);
+}
+
+ // SB_LMMODE0
+ static WRITE64_HANDLER( ta_texture_directpath0_w )
+ {
+	int mode = pvrctrl_regs[SB_LMMODE0]&1;
+	if (mode&1)
+	{
+		printf("ta_texture_directpath0_w 32-bit access!\n");
+		COMBINE_DATA(&dc_framebuffer_ram[offset]);
+	}
+	else
+	{
+		COMBINE_DATA(&dc_texture_ram[offset]);
+	}
+ }
+
+ // SB_LMMODE1
+ static WRITE64_HANDLER( ta_texture_directpath1_w )
+ {
+	int mode = pvrctrl_regs[SB_LMMODE1]&1;
+	if (mode&1)
+	{
+		printf("ta_texture_directpath0_w 32-bit access!\n");
+		COMBINE_DATA(&dc_framebuffer_ram[offset]);
+	}
+	else
+	{
+		COMBINE_DATA(&dc_texture_ram[offset]);
+	}
+ }
+
+static ADDRESS_MAP_START( dc_map, AS_PROGRAM, 64 )
+	AM_RANGE(0x00000000, 0x001fffff) AM_ROM	AM_WRITENOP				// BIOS
+	AM_RANGE(0x00200000, 0x0021ffff) AM_ROM AM_REGION("maincpu", 0x200000)	// flash
+	AM_RANGE(0x005f6800, 0x005f69ff) AM_READWRITE( dc_sysctrl_r, dc_sysctrl_w )
+	AM_RANGE(0x005f6c00, 0x005f6cff) AM_DEVREADWRITE32_MODERN( "maple_dc", maple_dc_device, sb_mdstar_r, sb_mdstar_w, U64(0xffffffff00000000) )
+	AM_RANGE(0x005f7000, 0x005f70ff) AM_READWRITE( dc_mess_gdrom_r, dc_mess_gdrom_w )
+	AM_RANGE(0x005f7400, 0x005f74ff) AM_READWRITE( dc_mess_g1_ctrl_r, dc_mess_g1_ctrl_w )
+	AM_RANGE(0x005f7800, 0x005f78ff) AM_READWRITE( dc_g2_ctrl_r, dc_g2_ctrl_w )
+	AM_RANGE(0x005f7c00, 0x005f7cff) AM_READWRITE( pvr_ctrl_r, pvr_ctrl_w )
+	AM_RANGE(0x005f8000, 0x005f9fff) AM_READWRITE( pvr_ta_r, pvr_ta_w )
+	AM_RANGE(0x00600000, 0x006007ff) AM_READWRITE( dc_modem_r, dc_modem_w )
+	AM_RANGE(0x00700000, 0x00707fff) AM_DEVREADWRITE("aica", dc_aica_reg_r, dc_aica_reg_w )
+	AM_RANGE(0x00710000, 0x0071000f) AM_READWRITE( dc_rtc_r, dc_rtc_w )
+	AM_RANGE(0x00800000, 0x009fffff) AM_READWRITE( dc_arm_r, dc_arm_w )
+
+	/* Area 1 */
+	AM_RANGE(0x04000000, 0x04ffffff) AM_RAM	AM_BASE( &dc_texture_ram )      // texture memory 64 bit access
+	AM_RANGE(0x05000000, 0x05ffffff) AM_RAM AM_BASE( &dc_framebuffer_ram ) // apparently this actually accesses the same memory as the 64-bit texture memory access, but in a different format, keep it apart for now
+
+	/* Area 3 */
+	AM_RANGE(0x0c000000, 0x0cffffff) AM_RAM AM_SHARE("share4") AM_BASE(&dc_ram)
+	AM_RANGE(0x0d000000, 0x0dffffff) AM_RAM AM_SHARE("share4")// extra ram on Naomi (mirror on DC)
+	AM_RANGE(0x0e000000, 0x0effffff) AM_RAM AM_SHARE("share4")// mirror
+	AM_RANGE(0x0f000000, 0x0fffffff) AM_RAM AM_SHARE("share4")// mirror
+
+	/* Area 4 */
+	AM_RANGE(0x10000000, 0x107fffff) AM_WRITE( ta_fifo_poly_w )
+	AM_RANGE(0x10800000, 0x10ffffff) AM_WRITE( ta_fifo_yuv_w )
+	AM_RANGE(0x11000000, 0x117fffff) AM_WRITE( ta_texture_directpath0_w ) AM_MIRROR(0x00800000)  // access to texture / fraembfufer memory (either 32-bit or 64-bit area depending on SB_LMMODE0 register - cannot be written directly, only through dma / store queue
+
+	AM_RANGE(0x12000000, 0x127fffff) AM_WRITE( ta_fifo_poly_w )
+	AM_RANGE(0x12800000, 0x12ffffff) AM_WRITE( ta_fifo_yuv_w )
+	AM_RANGE(0x13000000, 0x137fffff) AM_WRITE( ta_texture_directpath1_w ) AM_MIRROR(0x00800000) // access to texture / fraembfufer memory (either 32-bit or 64-bit area depending on SB_LMMODE1 register - cannot be written directly, only through dma / store queue
+
+	AM_RANGE(0x8c000000, 0x8cffffff) AM_RAM AM_SHARE("share4")	// another RAM mirror
+
+	AM_RANGE(0xa0000000, 0xa01fffff) AM_ROM AM_REGION("maincpu", 0)
+ADDRESS_MAP_END
+
+static ADDRESS_MAP_START( dc_port, AS_IO, 64 )
+	AM_RANGE(0x00000000, 0x00000007) AM_READWRITE( dc_pdtra_r, dc_pdtra_w )
+ADDRESS_MAP_END
+
+static ADDRESS_MAP_START( dc_audio_map, AS_PROGRAM, 32 )
+	AM_RANGE(0x00000000, 0x001fffff) AM_RAM AM_BASE(&dc_sound_ram)		/* shared with SH-4 */
+	AM_RANGE(0x00800000, 0x00807fff) AM_DEVREADWRITE("aica", dc_arm_aica_r, dc_arm_aica_w)
+ADDRESS_MAP_END
+
+static MACHINE_RESET( dc_console )
+{
+	device_t *aica = machine.device("aica");
+	MACHINE_RESET_CALL(dc);
+	aica_set_ram_base(aica, dc_sound_ram, 2*1024*1024);
+	dreamcast_atapi_reset(machine);
+}
+
+static void aica_irq(device_t *device, int irq)
+{
+	cputag_set_input_line(device->machine(), "soundcpu", ARM7_FIRQ_LINE, irq ? ASSERT_LINE : CLEAR_LINE);
+}
+
+static const aica_interface dc_aica_interface =
+{
+	0,
+	0,
+	aica_irq
+};
+
+static const struct sh4_config sh4cpu_config = {  1,  0,  1,  0,  0,  0,  1,  1,  0, CPU_CLOCK };
+
+static MACHINE_CONFIG_START( dc, driver_device )
+	/* basic machine hardware */
+	MCFG_CPU_ADD("maincpu", SH4, CPU_CLOCK)
+	MCFG_CPU_CONFIG(sh4cpu_config)
+	MCFG_CPU_PROGRAM_MAP(dc_map)
+	MCFG_CPU_IO_MAP(dc_port)
+
+	MCFG_CPU_ADD("soundcpu", ARM7, ((XTAL_33_8688MHz*2)/3)/8)	// AICA bus clock is 2/3rds * 33.8688.  ARM7 gets 1 bus cycle out of each 8.
+	MCFG_CPU_PROGRAM_MAP(dc_audio_map)
+
+	MCFG_MACHINE_START( dc )
+	MCFG_MACHINE_RESET( dc_console )
+
+	MCFG_MAPLE_DC_ADD( "maple_dc", "maincpu" )
+
+	/* video hardware */
+	MCFG_SCREEN_ADD("screen", RASTER)
+	MCFG_SCREEN_REFRESH_RATE(60)
+	MCFG_SCREEN_VBLANK_TIME(ATTOSECONDS_IN_USEC(2500) /* not accurate */)
+	MCFG_SCREEN_FORMAT(BITMAP_FORMAT_RGB32)
+	MCFG_SCREEN_SIZE(640, 480)
+	MCFG_SCREEN_VISIBLE_AREA(0, 640-1, 0, 480-1)
+	MCFG_SCREEN_UPDATE(dc)
+
+	MCFG_PALETTE_LENGTH(0x1000)
+
+	MCFG_VIDEO_START(dc)
+
+	MCFG_SPEAKER_STANDARD_STEREO("lspeaker", "rspeaker")
+	MCFG_SOUND_ADD("aica", AICA, 0)
+	MCFG_SOUND_CONFIG(dc_aica_interface)
+	MCFG_SOUND_ROUTE(0, "lspeaker", 2.0)
+	MCFG_SOUND_ROUTE(0, "rspeaker", 2.0)
+
+	MCFG_CDROM_ADD( "cdrom" )
+MACHINE_CONFIG_END
+
+ROM_START(dc)
+	ROM_REGION(0x220000, "maincpu", 0)
+        ROM_LOAD( "dc101d_us.bin", 0x000000, 0x200000, CRC(89f2b1a1) SHA1(8951d1bb219ab2ff8583033d2119c899cc81f18c) )	// BIOS
+        ROM_LOAD( "dcus_ntsc.bin", 0x200000, 0x020000, CRC(c611b498) SHA1(94d44d7f9529ec1642ba3771ed3c5f756d5bc872) )	// Flash
+ROM_END
+
+ROM_START( dceu )
+	ROM_REGION(0x220000, "maincpu", 0)
+        ROM_LOAD( "dc101d_eu.bin", 0x000000, 0x200000, CRC(a2564fad) SHA1(edc5d3d70a93c935703d26119b37731fd317d2bf) )	// BIOS
+        ROM_LOAD( "dceu_pal.bin", 0x200000, 0x020000, CRC(b7e5aeeb) SHA1(11e02433e13b793ec7ffe0ae2356750bb8a575b4) )	// Flash
+ROM_END
+
+ROM_START( dcjp )
+	ROM_REGION(0x220000, "maincpu", 0)
+        ROM_LOAD( "dc1004jp.bin", 0x000000, 0x200000, CRC(5454841f) SHA1(1ea132c0fbbf07ef76789eadc07908045c089bd6) )	// BIOS
+        /* ROM_LOAD( "dcjp_ntsc.bad", 0x200000, 0x020000, BAD_DUMP CRC(307a7035) SHA1(1411423a9d071340ea52c56e19c1aafc4e1309ee) )      // Hacked Flash */
+        ROM_LOAD( "dcjp_ntsc.bin", 0x200000, 0x020000, CRC(5F92BF76) SHA1(BE78B834F512AB2CF3D67B96E377C9F3093FF82A) )  // Flash
+ROM_END
+
+ROM_START( dcdev )
+	ROM_REGION(0x220000, "maincpu", 0)
+        ROM_LOAD( "hkt-0120.bin", 0x000000, 0x200000, CRC(2186E0E5) SHA1(6BD18FB83F8FDB56F1941E079580E5DD672A6DAD) )		// BIOS
+        ROM_LOAD( "hkt-0120-flash.bin", 0x200000, 0x020000, CRC(7784C304) SHA1(31EF57F550D8CD13E40263CBC657253089E53034) )	// Flash
+ROM_END
+
+static INPUT_PORTS_START( dc )
+	PORT_START("P1L")
+	PORT_BIT( 0x80, IP_ACTIVE_LOW, IPT_JOYSTICK_RIGHT ) PORT_8WAY PORT_PLAYER(1)
+	PORT_BIT( 0x40, IP_ACTIVE_LOW, IPT_JOYSTICK_LEFT ) PORT_8WAY PORT_PLAYER(1)
+	PORT_BIT( 0x20, IP_ACTIVE_LOW, IPT_JOYSTICK_DOWN ) PORT_8WAY PORT_PLAYER(1)
+	PORT_BIT( 0x10, IP_ACTIVE_LOW, IPT_JOYSTICK_UP ) PORT_8WAY PORT_PLAYER(1)
+	PORT_BIT( 0x08, IP_ACTIVE_LOW, IPT_START1 )
+	PORT_BIT( 0x04, IP_ACTIVE_LOW, IPT_BUTTON1 ) PORT_PLAYER(1)
+	PORT_BIT( 0x02, IP_ACTIVE_LOW, IPT_BUTTON2 ) PORT_PLAYER(1)
+	PORT_BIT( 0x01, IP_ACTIVE_LOW, IPT_BUTTON3 ) PORT_PLAYER(1)
+	PORT_START("P1H")
+	PORT_BIT( 0x80, IP_ACTIVE_LOW, IPT_COIN1 )
+	PORT_SERVICE_NO_TOGGLE( 0x40, IP_ACTIVE_LOW )
+	PORT_BIT( 0x20, IP_ACTIVE_LOW, IPT_SERVICE1 )
+	PORT_BIT( 0x10, IP_ACTIVE_LOW, IPT_UNKNOWN )
+	PORT_BIT( 0x08, IP_ACTIVE_LOW, IPT_UNKNOWN )
+	PORT_BIT( 0x04, IP_ACTIVE_LOW, IPT_BUTTON4 ) PORT_PLAYER(1)
+	PORT_BIT( 0x02, IP_ACTIVE_LOW, IPT_BUTTON5 ) PORT_PLAYER(1)
+	PORT_BIT( 0x01, IP_ACTIVE_LOW, IPT_BUTTON6 ) PORT_PLAYER(1)
+
+	PORT_START("P2L")
+	PORT_BIT( 0x80, IP_ACTIVE_LOW, IPT_JOYSTICK_RIGHT ) PORT_8WAY PORT_PLAYER(2)
+	PORT_BIT( 0x40, IP_ACTIVE_LOW, IPT_JOYSTICK_LEFT ) PORT_8WAY PORT_PLAYER(2)
+	PORT_BIT( 0x20, IP_ACTIVE_LOW, IPT_JOYSTICK_DOWN ) PORT_8WAY PORT_PLAYER(2)
+	PORT_BIT( 0x10, IP_ACTIVE_LOW, IPT_JOYSTICK_UP ) PORT_8WAY PORT_PLAYER(2)
+	PORT_BIT( 0x08, IP_ACTIVE_LOW, IPT_START2 )
+	PORT_BIT( 0x04, IP_ACTIVE_LOW, IPT_BUTTON1 ) PORT_PLAYER(2)
+	PORT_BIT( 0x02, IP_ACTIVE_LOW, IPT_BUTTON2 ) PORT_PLAYER(2)
+	PORT_BIT( 0x01, IP_ACTIVE_LOW, IPT_BUTTON3 ) PORT_PLAYER(2)
+	PORT_START("P2H")
+	PORT_BIT( 0x80, IP_ACTIVE_LOW, IPT_COIN2 )
+	PORT_BIT( 0x40, IP_ACTIVE_LOW, IPT_UNKNOWN )
+	PORT_BIT( 0x20, IP_ACTIVE_LOW, IPT_SERVICE2 )
+	PORT_BIT( 0x10, IP_ACTIVE_LOW, IPT_UNKNOWN )
+	PORT_BIT( 0x08, IP_ACTIVE_LOW, IPT_UNKNOWN )
+	PORT_BIT( 0x04, IP_ACTIVE_LOW, IPT_BUTTON4 ) PORT_PLAYER(2)
+	PORT_BIT( 0x02, IP_ACTIVE_LOW, IPT_BUTTON5 ) PORT_PLAYER(2)
+	PORT_BIT( 0x01, IP_ACTIVE_LOW, IPT_BUTTON6 ) PORT_PLAYER(2)
+
+	PORT_START("P3L")
+	PORT_BIT( 0x80, IP_ACTIVE_LOW, IPT_JOYSTICK_RIGHT ) PORT_8WAY PORT_PLAYER(3)
+	PORT_BIT( 0x40, IP_ACTIVE_LOW, IPT_JOYSTICK_LEFT ) PORT_8WAY PORT_PLAYER(3)
+	PORT_BIT( 0x20, IP_ACTIVE_LOW, IPT_JOYSTICK_DOWN ) PORT_8WAY PORT_PLAYER(3)
+	PORT_BIT( 0x10, IP_ACTIVE_LOW, IPT_JOYSTICK_UP ) PORT_8WAY PORT_PLAYER(3)
+	PORT_BIT( 0x08, IP_ACTIVE_LOW, IPT_START3 )
+	PORT_BIT( 0x04, IP_ACTIVE_LOW, IPT_BUTTON1 ) PORT_PLAYER(3)
+	PORT_BIT( 0x02, IP_ACTIVE_LOW, IPT_BUTTON2 ) PORT_PLAYER(3)
+	PORT_BIT( 0x01, IP_ACTIVE_LOW, IPT_BUTTON3 ) PORT_PLAYER(3)
+	PORT_START("P3H")
+	PORT_BIT( 0x80, IP_ACTIVE_LOW, IPT_COIN3 )
+	PORT_BIT( 0x40, IP_ACTIVE_LOW, IPT_UNKNOWN )
+	PORT_BIT( 0x20, IP_ACTIVE_LOW, IPT_SERVICE3 )
+	PORT_BIT( 0x10, IP_ACTIVE_LOW, IPT_UNKNOWN )
+	PORT_BIT( 0x08, IP_ACTIVE_LOW, IPT_UNKNOWN )
+	PORT_BIT( 0x04, IP_ACTIVE_LOW, IPT_BUTTON4 ) PORT_PLAYER(3)
+	PORT_BIT( 0x02, IP_ACTIVE_LOW, IPT_BUTTON5 ) PORT_PLAYER(3)
+	PORT_BIT( 0x01, IP_ACTIVE_LOW, IPT_BUTTON6 ) PORT_PLAYER(3)
+
+	PORT_START("P4L")
+	PORT_BIT( 0x80, IP_ACTIVE_LOW, IPT_JOYSTICK_RIGHT ) PORT_8WAY PORT_PLAYER(4)
+	PORT_BIT( 0x40, IP_ACTIVE_LOW, IPT_JOYSTICK_LEFT ) PORT_8WAY PORT_PLAYER(4)
+	PORT_BIT( 0x20, IP_ACTIVE_LOW, IPT_JOYSTICK_DOWN ) PORT_8WAY PORT_PLAYER(4)
+	PORT_BIT( 0x10, IP_ACTIVE_LOW, IPT_JOYSTICK_UP ) PORT_8WAY PORT_PLAYER(4)
+	PORT_BIT( 0x08, IP_ACTIVE_LOW, IPT_START4 )
+	PORT_BIT( 0x04, IP_ACTIVE_LOW, IPT_BUTTON1 ) PORT_PLAYER(4)
+	PORT_BIT( 0x02, IP_ACTIVE_LOW, IPT_BUTTON2 ) PORT_PLAYER(4)
+	PORT_BIT( 0x01, IP_ACTIVE_LOW, IPT_BUTTON3 ) PORT_PLAYER(4)
+	PORT_START("P4H")
+	PORT_BIT( 0x80, IP_ACTIVE_LOW, IPT_COIN4 )
+	PORT_BIT( 0x40, IP_ACTIVE_LOW, IPT_UNKNOWN )
+	PORT_BIT( 0x20, IP_ACTIVE_LOW, IPT_SERVICE4 )
+	PORT_BIT( 0x10, IP_ACTIVE_LOW, IPT_UNKNOWN )
+	PORT_BIT( 0x08, IP_ACTIVE_LOW, IPT_UNKNOWN )
+	PORT_BIT( 0x04, IP_ACTIVE_LOW, IPT_BUTTON4 ) PORT_PLAYER(4)
+	PORT_BIT( 0x02, IP_ACTIVE_LOW, IPT_BUTTON5 ) PORT_PLAYER(4)
+	PORT_BIT( 0x01, IP_ACTIVE_LOW, IPT_BUTTON6 ) PORT_PLAYER(4)
+
+	PORT_START("MAMEDEBUG") \
+	PORT_DIPNAME( 0x01, 0x00, "Bilinear Filtering" )
+	PORT_DIPSETTING(    0x00, DEF_STR( Off ) )
+	PORT_DIPSETTING(    0x01, DEF_STR( On ) )
+INPUT_PORTS_END
+
+
+/*    YEAR  NAME    PARENT  COMPAT  MACHINE INPUT   INIT      COMPANY FULLNAME */
+CONS( 1999, dc,     dcjp,   0,      dc,     dc,     dcus,   "Sega", "Dreamcast (USA, NTSC)", GAME_NOT_WORKING )
+CONS( 1998, dcjp,   0,      0,      dc,     dc,     dcjp,   "Sega", "Dreamcast (Japan, NTSC)", GAME_NOT_WORKING )
+CONS( 1999, dceu,   dcjp,   0,      dc,     dc,     dcus,   "Sega", "Dreamcast (Europe, PAL)", GAME_NOT_WORKING )
+CONS( 1998, dcdev,  dcjp,   0,      dc,     dc,     dc,     "Sega", "HKT-0120 Sega Dreamcast Development Box", GAME_NOT_WORKING )

src/mame/drivers/segasms.c

@@ -0,0 +1,783 @@
+/******************************************************************************
+ Contributors:
+
+    Marat Fayzullin (MG source)
+    Charles Mac Donald
+    Mathis Rosenhauer
+    Brad Oliver
+    Michael Luong
+
+ To do:
+
+ - PSG control for Game Gear (needs custom SN76489 with stereo output for each channel)
+ - SIO interface for Game Gear (needs netplay, I guess)
+ - SMS lightgun support
+ - LCD persistence emulation for GG
+ - SMS 3D glass support
+
+ The Game Gear SIO and PSG hardware are not emulated but have some
+ placeholders in 'machine/sms.c'
+
+ Changes:
+    Apr 02 - Added raster palette effects for SMS & GG (ML)
+                 - Added sprite collision (ML)
+                 - Added zoomed sprites (ML)
+    May 02 - Fixed paging bug (ML)
+                 - Fixed sprite and tile priority bug (ML)
+                 - Fixed bug #66 (ML)
+                 - Fixed bug #78 (ML)
+                 - try to implement LCD persistence emulation for GG (ML)
+    Jun 10, 02 - Added bios emulation (ML)
+    Jun 12, 02 - Added PAL & NTSC systems (ML)
+    Jun 25, 02 - Added border emulation (ML)
+    Jun 27, 02 - Version bits for Game Gear (bits 6 of port 00) (ML)
+    Nov-Dec, 05 - Numerous cleanups, fixes, updates (WP)
+    Mar, 07 - More cleanups, fixes, mapper additions, etc (WP)
+
+SMS Store Unit memory map for the second CPU:
+
+0000-3FFF - BIOS
+4000-47FF - RAM
+8000      - System Control Register (R/W)
+            Reading:
+            bit7      - ready (0 = ready, 1 = not ready)
+            bit6-bit5 - unknown
+            bit4-bit3 - timer selection bit switches
+            bit2-bit0 - unknown
+            Writing:
+            bit7-bit4 - unknown, maybe led of selected game to set?
+            bit3      - unknown, 1 seems to be written all the time
+            bit2      - unknown, 1 seems to be written all the time
+            bit1      - reset signal for sms cpu, 0 = reset low, 1 = reset high
+            bit0      - which cpu receives interrupt signals, 0 = sms cpu, 1 = controlling cpu
+C000      - Card/Cartridge selction register (W)
+            bit7-bit4 - slot to select
+            bit3      - slot type (0 = cartridge, 1 = card ?)
+            bit2-bit0 - unknown
+C400      - ???? (used once)
+D800      - Selection buttons #1, 1-8 (R)
+DC00      - Selection buttons #2, 9-16 (R)
+
+ ******************************************************************************/
+
+#include "emu.h"
+#include "cpu/z80/z80.h"
+#include "sound/sn76496.h"
+#include "sound/2413intf.h"
+#include "includes/segasms.h"
+#include "video/smsvdp.h"
+#include "imagedev/cartslot.h"
+
+#include "sms1.lh"
+
+#define MASTER_CLOCK_PAL	53203400	/* This might be a tiny bit too low */
+
+
+static ADDRESS_MAP_START( sms1_mem, AS_PROGRAM, 8 )
+	AM_RANGE(0x0000, 0x03ff) AM_ROMBANK("bank1")					/* First 0x0400 part always points to first page */
+	AM_RANGE(0x0400, 0x3fff) AM_ROMBANK("bank2")					/* switchable rom bank */
+	AM_RANGE(0x4000, 0x5fff) AM_ROMBANK("bank3")					/* switchable rom bank */
+	AM_RANGE(0x6000, 0x7fff) AM_ROMBANK("bank4")					/* switchable rom bank */
+	AM_RANGE(0x8000, 0x9fff) AM_READ_BANK("bank5") AM_WRITE(sms_cartram_w)	/* ROM bank / on-cart RAM */
+	AM_RANGE(0xa000, 0xbfff) AM_READ_BANK("bank6") AM_WRITE(sms_cartram2_w)	/* ROM bank / on-cart RAM */
+	AM_RANGE(0xc000, 0xdff7) AM_MIRROR(0x2000) AM_RAM			/* RAM (mirror at 0xE000) */
+	AM_RANGE(0xdff8, 0xdfff) AM_RAM						/* RAM "underneath" frame registers */
+	AM_RANGE(0xfff8, 0xfffb) AM_READWRITE(sms_sscope_r, sms_sscope_w)	/* 3-D glasses */
+	AM_RANGE(0xfffc, 0xffff) AM_READWRITE(sms_mapper_r, sms_mapper_w)	/* Bankswitch control */
+ADDRESS_MAP_END
+
+static ADDRESS_MAP_START( sms_mem, AS_PROGRAM, 8 )
+	AM_RANGE(0x0000, 0x03ff) AM_ROMBANK("bank1")					/* First 0x0400 part always points to first page */
+	AM_RANGE(0x0400, 0x3fff) AM_ROMBANK("bank2")					/* switchable rom bank */
+	AM_RANGE(0x4000, 0x5fff) AM_ROMBANK("bank3")					/* switchable rom bank */
+	AM_RANGE(0x6000, 0x7fff) AM_ROMBANK("bank4")					/* switchable rom bank */
+	AM_RANGE(0x8000, 0x9fff) AM_READ_BANK("bank5") AM_WRITE(sms_cartram_w)	/* ROM bank / on-cart RAM */
+	AM_RANGE(0xa000, 0xbfff) AM_READ_BANK("bank6") AM_WRITE(sms_cartram2_w)	/* ROM bank / on-cart RAM */
+	AM_RANGE(0xc000, 0xdffb) AM_MIRROR(0x2000) AM_RAM			/* RAM (mirror at 0xE000) */
+	AM_RANGE(0xdffc, 0xdfff) AM_RAM						/* RAM "underneath" frame registers */
+	AM_RANGE(0xfffc, 0xffff) AM_READWRITE(sms_mapper_r, sms_mapper_w)	/* Bankswitch control */
+ADDRESS_MAP_END
+
+static ADDRESS_MAP_START( sms_store_mem, AS_PROGRAM, 8 )
+	AM_RANGE(0x0000, 0x3fff) AM_ROM						/* BIOS */
+	AM_RANGE(0x4000, 0x47ff) AM_RAM						/* RAM */
+	AM_RANGE(0x6000, 0x7fff) AM_ROMBANK("bank10")					/* Cartridge/card peek area */
+	AM_RANGE(0x8000, 0x8000) AM_READWRITE(sms_store_control_r, sms_store_control_w)	/* Control */
+	AM_RANGE(0xc000, 0xc000) AM_READWRITE(sms_store_cart_select_r, sms_store_cart_select_w) 	/* cartridge/card slot selector */
+	AM_RANGE(0xd800, 0xd800) AM_READ(sms_store_select1)			/* Game selector port #1 */
+	AM_RANGE(0xdc00, 0xdc00) AM_READ(sms_store_select2)			/* Game selector port #2 */
+ADDRESS_MAP_END
+
+static ADDRESS_MAP_START( sms_io, AS_IO, 8 )
+	ADDRESS_MAP_GLOBAL_MASK(0xff)
+	ADDRESS_MAP_UNMAP_HIGH
+	AM_RANGE(0x00, 0x00) AM_MIRROR(0x3e) AM_WRITE(sms_bios_w)
+	AM_RANGE(0x01, 0x01) AM_MIRROR(0x3e) AM_WRITE(sms_io_control_w)
+	AM_RANGE(0x40, 0x7f)                 AM_READ(sms_count_r)
+	AM_RANGE(0x40, 0x7f)                 AM_DEVWRITE("smsiii", sn76496_w)
+	AM_RANGE(0x80, 0x80) AM_MIRROR(0x3e) AM_DEVREADWRITE("sms_vdp", sms_vdp_data_r, sms_vdp_data_w)
+	AM_RANGE(0x81, 0x81) AM_MIRROR(0x3e) AM_DEVREADWRITE("sms_vdp", sms_vdp_ctrl_r, sms_vdp_ctrl_w)
+	AM_RANGE(0xc0, 0xc0) AM_MIRROR(0x1e) AM_READ(sms_input_port_0_r)
+	AM_RANGE(0xc1, 0xc1) AM_MIRROR(0x1e) AM_READ(sms_input_port_1_r)
+	AM_RANGE(0xe0, 0xe0) AM_MIRROR(0x0e) AM_READ(sms_input_port_0_r)
+	AM_RANGE(0xe1, 0xe1) AM_MIRROR(0x0e) AM_READ(sms_input_port_1_r)
+	AM_RANGE(0xf0, 0xf0)                 AM_READWRITE(sms_input_port_0_r, sms_ym2413_register_port_0_w)
+	AM_RANGE(0xf1, 0xf1)                 AM_READWRITE(sms_input_port_1_r, sms_ym2413_data_port_0_w)
+	AM_RANGE(0xf2, 0xf2)                 AM_READWRITE(sms_fm_detect_r, sms_fm_detect_w)
+	AM_RANGE(0xf3, 0xf3)                 AM_READ(sms_input_port_1_r)
+	AM_RANGE(0xf4, 0xf4) AM_MIRROR(0x02) AM_READ(sms_input_port_0_r)
+	AM_RANGE(0xf5, 0xf5) AM_MIRROR(0x02) AM_READ(sms_input_port_1_r)
+	AM_RANGE(0xf8, 0xf8) AM_MIRROR(0x06) AM_READ(sms_input_port_0_r)
+	AM_RANGE(0xf9, 0xf9) AM_MIRROR(0x06) AM_READ(sms_input_port_1_r)
+ADDRESS_MAP_END
+
+static ADDRESS_MAP_START( gg_io, AS_IO, 8 )
+	ADDRESS_MAP_GLOBAL_MASK(0xff)
+	ADDRESS_MAP_UNMAP_HIGH
+	AM_RANGE(0x00, 0x00)                 AM_READ(gg_input_port_2_r)
+	AM_RANGE(0x01, 0x05)                 AM_READWRITE(gg_sio_r, gg_sio_w)
+	AM_RANGE(0x06, 0x06)                 AM_DEVWRITE("gamegear", sn76496_stereo_w)
+	AM_RANGE(0x07, 0x07)                 AM_WRITE(sms_io_control_w)
+	AM_RANGE(0x08, 0x08) AM_MIRROR(0x06) AM_WRITE(sms_bios_w)
+	AM_RANGE(0x09, 0x09) AM_MIRROR(0x06) AM_WRITE(sms_io_control_w)
+	AM_RANGE(0x10, 0x10) AM_MIRROR(0x0e) AM_WRITE(sms_bios_w)
+	AM_RANGE(0x11, 0x11) AM_MIRROR(0x0e) AM_WRITE(sms_io_control_w)
+	AM_RANGE(0x20, 0x20) AM_MIRROR(0x1e) AM_WRITE(sms_bios_w)
+	AM_RANGE(0x21, 0x21) AM_MIRROR(0x1e) AM_WRITE(sms_io_control_w)
+	AM_RANGE(0x40, 0x7f)                 AM_READ(sms_count_r)
+	AM_RANGE(0x40, 0x7f)                 AM_DEVWRITE("gamegear", sn76496_w)
+	AM_RANGE(0x80, 0x80) AM_MIRROR(0x3e) AM_DEVREADWRITE("sms_vdp", sms_vdp_data_r, sms_vdp_data_w)
+	AM_RANGE(0x81, 0x81) AM_MIRROR(0x3e) AM_DEVREADWRITE("sms_vdp", sms_vdp_ctrl_r, sms_vdp_ctrl_w)
+	AM_RANGE(0xc0, 0xc0)                 AM_READ_PORT("PORT_DC")
+	AM_RANGE(0xc1, 0xc1)                 AM_READ_PORT("PORT_DD")
+	AM_RANGE(0xdc, 0xdc)                 AM_READ_PORT("PORT_DC")
+	AM_RANGE(0xdd, 0xdd)                 AM_READ_PORT("PORT_DD")
+ADDRESS_MAP_END
+
+
+static INPUT_PORTS_START( sms )
+	PORT_START("PORT_DC")
+	PORT_BIT( 0x01, IP_ACTIVE_LOW, IPT_JOYSTICK_UP ) PORT_CATEGORY(10) PORT_PLAYER(1) PORT_8WAY
+	PORT_BIT( 0x02, IP_ACTIVE_LOW, IPT_JOYSTICK_DOWN ) PORT_CATEGORY(10) PORT_PLAYER(1) PORT_8WAY
+	PORT_BIT( 0x04, IP_ACTIVE_LOW, IPT_JOYSTICK_LEFT ) PORT_CATEGORY(10) PORT_PLAYER(1) PORT_8WAY
+	PORT_BIT( 0x08, IP_ACTIVE_LOW, IPT_JOYSTICK_RIGHT ) PORT_CATEGORY(10) PORT_PLAYER(1) PORT_8WAY
+	PORT_BIT( 0x10, IP_ACTIVE_LOW, IPT_BUTTON1 ) PORT_CATEGORY(10) PORT_PLAYER(1)
+	PORT_BIT( 0x20, IP_ACTIVE_LOW, IPT_BUTTON2 ) PORT_CATEGORY(10) PORT_PLAYER(1)
+	PORT_BIT( 0x40, IP_ACTIVE_LOW, IPT_JOYSTICK_UP ) PORT_CATEGORY(20) PORT_PLAYER(2) PORT_8WAY
+	PORT_BIT( 0x80, IP_ACTIVE_LOW, IPT_JOYSTICK_DOWN ) PORT_CATEGORY(20) PORT_PLAYER(2) PORT_8WAY
+
+	PORT_START("PORT_DD")
+	PORT_BIT( 0x01, IP_ACTIVE_LOW, IPT_JOYSTICK_LEFT ) PORT_CATEGORY(20) PORT_PLAYER(2) PORT_8WAY
+	PORT_BIT( 0x02, IP_ACTIVE_LOW, IPT_JOYSTICK_RIGHT ) PORT_CATEGORY(20) PORT_PLAYER(2) PORT_8WAY
+	PORT_BIT( 0x04, IP_ACTIVE_LOW, IPT_BUTTON1 ) PORT_CATEGORY(20) PORT_PLAYER(2)
+	PORT_BIT( 0x08, IP_ACTIVE_LOW, IPT_BUTTON2 ) PORT_CATEGORY(20) PORT_PLAYER(2)
+	PORT_BIT( 0x10, IP_ACTIVE_LOW, IPT_UNUSED ) /* Software Reset bit */
+	PORT_BIT( 0x20, IP_ACTIVE_LOW, IPT_UNUSED )
+	PORT_BIT( 0x40, IP_ACTIVE_LOW, IPT_UNUSED ) /* Port A TH */
+	PORT_BIT( 0x80, IP_ACTIVE_LOW, IPT_UNUSED ) /* Port B TH */
+
+	PORT_START("PAUSE")
+	PORT_BIT( 0x7f, IP_ACTIVE_LOW, IPT_UNUSED )
+	PORT_BIT( 0x80, IP_ACTIVE_LOW, IPT_START ) PORT_NAME(DEF_STR(Pause))
+
+	PORT_START("LPHASER0")	/* Light phaser X - player 1 */
+	PORT_BIT( 0xff, 0x80, IPT_LIGHTGUN_X ) PORT_CROSSHAIR( X, 1.0, 0.0, 0 ) PORT_SENSITIVITY(50) PORT_KEYDELTA(15) PORT_CATEGORY(11) PORT_PLAYER(1) PORT_CHANGED(lgun1_changed, NULL)
+
+	PORT_START("LPHASER1")	/* Light phaser Y - player 1 */
+	PORT_BIT( 0xff, 0x80, IPT_LIGHTGUN_Y ) PORT_CROSSHAIR( Y, 1.0, 0.0, 0 ) PORT_SENSITIVITY(50) PORT_KEYDELTA(15) PORT_CATEGORY(11) PORT_PLAYER(1) PORT_CHANGED(lgun1_changed, NULL)
+
+	PORT_START("LPHASER2")	/* Light phaser X - player 2 */
+	PORT_BIT( 0xff, 0x80, IPT_LIGHTGUN_X ) PORT_CROSSHAIR( X, 1.0, 0.0, 0 ) PORT_SENSITIVITY(50) PORT_KEYDELTA(15) PORT_CATEGORY(21) PORT_PLAYER(2) PORT_CHANGED(lgun2_changed, NULL)
+
+	PORT_START("LPHASER3")	/* Light phaser Y - player 2 */
+	PORT_BIT( 0xff, 0x80, IPT_LIGHTGUN_Y ) PORT_CROSSHAIR( Y, 1.0, 0.0, 0 ) PORT_SENSITIVITY(50) PORT_KEYDELTA(25) PORT_CATEGORY(21) PORT_PLAYER(2) PORT_CHANGED(lgun2_changed, NULL)
+
+	PORT_START("RFU")	/* Rapid Fire Unit */
+	PORT_CONFNAME( 0x03, 0x00, "Rapid Fire Unit - Player 1" )
+	PORT_CONFSETTING(	0x00, DEF_STR( Off ) )
+	PORT_CONFSETTING(	0x01, "Button A" )
+	PORT_CONFSETTING(	0x02, "Button B" )
+	PORT_CONFSETTING(	0x03, "Button A + B" )
+	PORT_CONFNAME( 0x0c, 0x00, "Rapid Fire Unit - Player 2" )
+	PORT_CONFSETTING(	0x00, DEF_STR( Off ) )
+	PORT_CONFSETTING(	0x04, "Button A" )
+	PORT_CONFSETTING(	0x08, "Button B" )
+	PORT_CONFSETTING(	0x0c, "Button A + B" )
+
+	PORT_START("PADDLE0")	/* Paddle player 1 */
+	PORT_BIT( 0xff, 0x80, IPT_PADDLE) PORT_SENSITIVITY(40) PORT_KEYDELTA(20) PORT_CENTERDELTA(0) PORT_MINMAX(0,255) PORT_CATEGORY(12) PORT_PLAYER(1)
+
+	PORT_START("PADDLE1")	/* Paddle player 2 */
+	PORT_BIT( 0xff, 0x80, IPT_PADDLE) PORT_SENSITIVITY(40) PORT_KEYDELTA(20) PORT_CENTERDELTA(0) PORT_MINMAX(0,255) PORT_CATEGORY(22) PORT_PLAYER(2)
+
+	PORT_START("CTRLIPT")	/* Light Phaser and Paddle Control buttons */
+	PORT_BIT( 0x01, IP_ACTIVE_LOW, IPT_BUTTON1 ) PORT_CATEGORY(11) PORT_PLAYER(1)
+	PORT_BIT( 0x02, IP_ACTIVE_LOW, IPT_BUTTON1 ) PORT_CATEGORY(12) PORT_PLAYER(1)
+	PORT_BIT( 0x04, IP_ACTIVE_LOW, IPT_BUTTON1 ) PORT_CATEGORY(13) PORT_PLAYER(1)
+	PORT_BIT( 0x08, IP_ACTIVE_LOW, IPT_BUTTON2 ) PORT_CATEGORY(13) PORT_PLAYER(1)
+	PORT_BIT( 0x10, IP_ACTIVE_LOW, IPT_BUTTON1 ) PORT_CATEGORY(21) PORT_PLAYER(2)
+	PORT_BIT( 0x20, IP_ACTIVE_LOW, IPT_BUTTON1 ) PORT_CATEGORY(22) PORT_PLAYER(2)
+	PORT_BIT( 0x40, IP_ACTIVE_LOW, IPT_BUTTON1 ) PORT_CATEGORY(23) PORT_PLAYER(2)
+	PORT_BIT( 0x80, IP_ACTIVE_LOW, IPT_BUTTON2 ) PORT_CATEGORY(23) PORT_PLAYER(2)
+
+	PORT_START("CTRLSEL")	/* Controller selection */
+	PORT_CATEGORY_CLASS( 0x0f, 0x00, "Player 1 Controller" )
+	PORT_CATEGORY_ITEM( 0x00, DEF_STR( Joystick ), 10 )
+	PORT_CATEGORY_ITEM( 0x01, "Light Phaser", 11 )
+	PORT_CATEGORY_ITEM( 0x02, "Sega Paddle Control", 12 )
+	PORT_CATEGORY_ITEM( 0x03, "Sega Sports Pad", 13 )
+	PORT_CATEGORY_CLASS( 0xf0, 0x00, "Player 2 Controller" )
+	PORT_CATEGORY_ITEM( 0x00, DEF_STR( Joystick ), 20 )
+	PORT_CATEGORY_ITEM( 0x10, "Light Phaser", 21 )
+	PORT_CATEGORY_ITEM( 0x20, "Sega Paddle Control", 22 )
+	PORT_CATEGORY_ITEM( 0x30, "Sega Sports Pad", 23 )
+
+	PORT_START("SPORT0")	/* Player 1 Sports Pad X axis */
+	PORT_BIT( 0xff, 0x00, IPT_TRACKBALL_X ) PORT_SENSITIVITY(50) PORT_KEYDELTA(40) PORT_RESET PORT_REVERSE PORT_CATEGORY(13) PORT_PLAYER(1)
+
+	PORT_START("SPORT1")	/* Player 1 Sports Pad Y axis */
+	PORT_BIT( 0xff, 0x00, IPT_TRACKBALL_Y ) PORT_SENSITIVITY(50) PORT_KEYDELTA(40) PORT_RESET PORT_REVERSE PORT_CATEGORY(13) PORT_PLAYER(1)
+
+	PORT_START("SPORT2")	/* Player 2 Sports Pad X axis */
+	PORT_BIT( 0xff, 0x00, IPT_TRACKBALL_X ) PORT_SENSITIVITY(50) PORT_KEYDELTA(40) PORT_RESET PORT_REVERSE PORT_CATEGORY(23) PORT_PLAYER(2)
+
+	PORT_START("SPORT3")	/* Player 2 Sports Pad Y axis */
+	PORT_BIT( 0xff, 0x00, IPT_TRACKBALL_Y ) PORT_SENSITIVITY(50) PORT_KEYDELTA(40) PORT_RESET PORT_REVERSE PORT_CATEGORY(23) PORT_PLAYER(2)
+INPUT_PORTS_END
+
+static INPUT_PORTS_START( sms1 )
+	PORT_INCLUDE( sms )
+
+	PORT_START("RESET")
+	PORT_BIT( 0x01, IP_ACTIVE_LOW, IPT_SERVICE1 ) PORT_NAME("Reset Button")
+
+	PORT_START("SEGASCOPE")
+	PORT_CONFNAME( 0x01, 0x00, "SegaScope (3-D Glasses)" )
+	PORT_CONFSETTING( 0x00, DEF_STR( Off ) )
+	PORT_CONFSETTING( 0x01, DEF_STR( On ) )
+
+	PORT_START("SSCOPE_BINOCULAR")
+	PORT_CONFNAME( 0x03, 0x00, "SegaScope - Binocular Hack" ) PORT_CONDITION("SEGASCOPE", 0x01, PORTCOND_EQUALS, 0x01)
+	PORT_CONFSETTING( 0x00, DEF_STR( Off ) )
+	PORT_CONFSETTING( 0x01, "Left Lens" )
+	PORT_CONFSETTING( 0x02, "Right Lens" )
+	PORT_CONFSETTING( 0x03, "Both Lens" )
+	PORT_BIT( 0x03, 0x00, IPT_UNUSED ) PORT_CONDITION("SEGASCOPE", 0x01, PORTCOND_EQUALS, 0x00)
+INPUT_PORTS_END
+
+static INPUT_PORTS_START( smsj )
+	PORT_INCLUDE( sms1 )
+
+	PORT_START("TVDRAW")
+	PORT_CONFNAME( 0x01, 0x00, "Terebi Oekaki Graphics Tablet" )
+	PORT_CONFSETTING( 0x00, DEF_STR( Off ) )
+	PORT_CONFSETTING( 0x01, DEF_STR( On ) )
+
+	PORT_START("TVDRAW_X")
+	PORT_BIT( 0xff, 0x80, IPT_LIGHTGUN_X ) PORT_NAME("Tablet - X Axis") PORT_CROSSHAIR(X, 1.0, 0.0, 0) PORT_SENSITIVITY(50) PORT_KEYDELTA(10) PORT_PLAYER(1)
+		PORT_CONDITION("TVDRAW", 0x01, PORTCOND_EQUALS, 0x01)
+
+	PORT_START("TVDRAW_Y")
+	PORT_BIT( 0xff, 0x60, IPT_LIGHTGUN_Y ) PORT_NAME("Tablet - Y Axis") PORT_CROSSHAIR(Y, 1.0, 0.0, 0) PORT_MINMAX(0, 191) PORT_SENSITIVITY(50) PORT_KEYDELTA(10) PORT_PLAYER(1)
+		PORT_CONDITION("TVDRAW", 0x01, PORTCOND_EQUALS, 0x01)
+
+	PORT_START("TVDRAW_PEN")
+	PORT_BIT( 0x01, IP_ACTIVE_LOW, IPT_BUTTON3 ) PORT_NAME("Tablet - Pen") PORT_CONDITION("TVDRAW", 0x01, PORTCOND_EQUALS, 0x01)
+INPUT_PORTS_END
+
+static INPUT_PORTS_START( gg )
+	PORT_START("PORT_DC")
+	PORT_BIT( 0x01, IP_ACTIVE_LOW, IPT_JOYSTICK_UP ) PORT_PLAYER(1) PORT_8WAY
+	PORT_BIT( 0x02, IP_ACTIVE_LOW, IPT_JOYSTICK_DOWN ) PORT_PLAYER(1) PORT_8WAY
+	PORT_BIT( 0x04, IP_ACTIVE_LOW, IPT_JOYSTICK_LEFT ) PORT_PLAYER(1) PORT_8WAY
+	PORT_BIT( 0x08, IP_ACTIVE_LOW, IPT_JOYSTICK_RIGHT ) PORT_PLAYER(1) PORT_8WAY
+	PORT_BIT( 0x10, IP_ACTIVE_LOW, IPT_BUTTON1 ) PORT_PLAYER(1)
+	PORT_BIT( 0x20, IP_ACTIVE_LOW, IPT_BUTTON2 ) PORT_PLAYER(1)
+	PORT_BIT( 0xc0, IP_ACTIVE_LOW, IPT_UNUSED )
+
+	PORT_START("PORT_DD")
+	PORT_BIT( 0xff, IP_ACTIVE_LOW, IPT_UNUSED )
+
+	PORT_START("START")
+	PORT_BIT( 0x7f, IP_ACTIVE_LOW, IPT_UNUSED )
+	PORT_BIT( 0x80, IP_ACTIVE_LOW, IPT_START ) PORT_NAME("Start") /* Game Gear START */
+INPUT_PORTS_END
+
+static PALETTE_INIT( sms )
+{
+	int i;
+	for (i = 0; i < 64; i++)
+	{
+		int r = i & 0x03;
+		int g = (i & 0x0c) >> 2;
+		int b = (i & 0x30) >> 4;
+		palette_set_color_rgb(machine, i, r << 6, g << 6, b << 6);
+	}
+	/* TMS9918 palette */
+	palette_set_color_rgb(machine, 64+ 0,   0,   0,   0);
+	palette_set_color_rgb(machine, 64+ 1,   0,   0,   0);
+	palette_set_color_rgb(machine, 64+ 2,  33, 200,  66);
+	palette_set_color_rgb(machine, 64+ 3,  94, 220, 120);
+	palette_set_color_rgb(machine, 64+ 4,  84,  85, 237);
+	palette_set_color_rgb(machine, 64+ 5, 125, 118, 252);
+	palette_set_color_rgb(machine, 64+ 6, 212,  82,  77);
+	palette_set_color_rgb(machine, 64+ 7,  66, 235, 245);
+	palette_set_color_rgb(machine, 64+ 8, 252,  85,  84);
+	palette_set_color_rgb(machine, 64+ 9, 255, 121, 120);
+	palette_set_color_rgb(machine, 64+10, 212, 193,  84);
+	palette_set_color_rgb(machine, 64+11, 230, 206, 128);
+	palette_set_color_rgb(machine, 64+12,  33, 176,  59);
+	palette_set_color_rgb(machine, 64+13, 201,  91, 186);
+	palette_set_color_rgb(machine, 64+14, 204, 204, 204);
+	palette_set_color_rgb(machine, 64+15, 255, 255, 255);
+}
+
+static PALETTE_INIT( gamegear )
+{
+	int i;
+	for (i = 0; i < 4096; i++)
+	{
+		int r = i & 0x000f;
+		int g = (i & 0x00f0) >> 4;
+		int b = (i & 0x0f00) >> 8;
+		palette_set_color_rgb(machine, i, r << 4, g << 4, b << 4);
+	}
+}
+
+
+
+static void sms_int_callback( running_machine &machine, int state )
+{
+	cputag_set_input_line(machine, "maincpu", 0, state);
+}
+
+static const smsvdp_interface _315_5124_intf =
+{
+	MODEL_315_5124,
+	sms_int_callback,
+	sms_pause_callback
+};
+
+static const smsvdp_interface _315_5246_intf =
+{
+	MODEL_315_5246,
+	sms_int_callback,
+	sms_pause_callback
+};
+
+static const smsvdp_interface _315_5378_intf =
+{
+	MODEL_315_5378,
+	sms_int_callback,
+	sms_pause_callback
+};
+
+static const smsvdp_interface sms_store_intf =
+{
+	MODEL_315_5124,
+	sms_store_int_callback,
+	sms_pause_callback
+};
+
+static MACHINE_CONFIG_FRAGMENT( sms_cartslot )
+	MCFG_CARTSLOT_ADD("cart1")
+	MCFG_CARTSLOT_EXTENSION_LIST("sms,bin")
+	MCFG_CARTSLOT_NOT_MANDATORY
+	MCFG_CARTSLOT_INTERFACE("sms_cart")
+	MCFG_CARTSLOT_START(sms_cart)
+	MCFG_CARTSLOT_LOAD(sms_cart)
+
+	MCFG_SOFTWARE_LIST_ADD("cart_list","sms")
+MACHINE_CONFIG_END
+
+static MACHINE_CONFIG_FRAGMENT( gg_cartslot )
+	MCFG_CARTSLOT_ADD("cart1")
+	MCFG_CARTSLOT_EXTENSION_LIST("gg,bin")
+	MCFG_CARTSLOT_MANDATORY
+	MCFG_CARTSLOT_INTERFACE("gamegear_cart")
+	MCFG_CARTSLOT_START(sms_cart)
+	MCFG_CARTSLOT_LOAD(sms_cart)
+
+	MCFG_SOFTWARE_LIST_ADD("cart_list","gamegear")
+MACHINE_CONFIG_END
+
+static MACHINE_CONFIG_START( sms_ntsc_base, sms_state )
+	/* basic machine hardware */
+	MCFG_CPU_ADD("maincpu", Z80, XTAL_53_693175MHz/15)
+	MCFG_CPU_PROGRAM_MAP(sms_mem)
+	MCFG_CPU_IO_MAP(sms_io)
+
+	MCFG_QUANTUM_TIME(attotime::from_hz(60))
+
+	MCFG_MACHINE_START(sms)
+	MCFG_MACHINE_RESET(sms)
+
+	/* sound hardware */
+	MCFG_SPEAKER_STANDARD_MONO("mono")
+	MCFG_SOUND_ADD("smsiii", SMSIII, XTAL_53_693175MHz/15)
+	MCFG_SOUND_ROUTE(ALL_OUTPUTS, "mono", 1.00)
+
+	MCFG_FRAGMENT_ADD( sms_cartslot )
+MACHINE_CONFIG_END
+
+static MACHINE_CONFIG_DERIVED( sms2_ntsc, sms_ntsc_base )
+	/* video hardware */
+	MCFG_SCREEN_ADD("screen", RASTER)
+	MCFG_SCREEN_FORMAT(BITMAP_FORMAT_RGB32)
+	MCFG_SCREEN_RAW_PARAMS(XTAL_53_693175MHz/10, SMS_X_PIXELS, LBORDER_START + LBORDER_X_PIXELS - 2, LBORDER_START + LBORDER_X_PIXELS + 256 + 10, NTSC_Y_PIXELS, TBORDER_START + NTSC_224_TBORDER_Y_PIXELS, TBORDER_START + NTSC_224_TBORDER_Y_PIXELS + 224)
+	MCFG_SCREEN_UPDATE(sms)
+
+	MCFG_PALETTE_LENGTH(64+16)
+	MCFG_PALETTE_INIT(sms)
+
+	MCFG_SMSVDP_ADD("sms_vdp", _315_5246_intf)
+MACHINE_CONFIG_END
+
+static MACHINE_CONFIG_DERIVED( sms1_ntsc, sms_ntsc_base )
+
+	MCFG_CPU_MODIFY("maincpu")
+	MCFG_CPU_PROGRAM_MAP(sms1_mem)	// This adds the SegaScope handlers for 3-D glasses
+	MCFG_CPU_IO_MAP(sms_io)
+
+	/* video hardware */
+	MCFG_SCREEN_ADD("screen", RASTER)
+	MCFG_SCREEN_FORMAT(BITMAP_FORMAT_RGB32)
+	MCFG_SCREEN_RAW_PARAMS(XTAL_53_693175MHz/10, SMS_X_PIXELS, LBORDER_START + LBORDER_X_PIXELS - 2, LBORDER_START + LBORDER_X_PIXELS + 256 + 10, NTSC_Y_PIXELS, TBORDER_START + NTSC_224_TBORDER_Y_PIXELS, TBORDER_START + NTSC_224_TBORDER_Y_PIXELS + 224)
+	MCFG_SCREEN_UPDATE(sms1)
+
+	MCFG_SCREEN_ADD("left_lcd", LCD)	// This is needed for SegaScope Left LCD
+	MCFG_SCREEN_FORMAT(BITMAP_FORMAT_RGB32)
+	MCFG_SCREEN_RAW_PARAMS(XTAL_53_693175MHz/10, SMS_X_PIXELS, LBORDER_START + LBORDER_X_PIXELS - 2, LBORDER_START + LBORDER_X_PIXELS + 256 + 10, NTSC_Y_PIXELS, TBORDER_START + NTSC_224_TBORDER_Y_PIXELS, TBORDER_START + NTSC_224_TBORDER_Y_PIXELS + 224)
+	MCFG_SCREEN_UPDATE(sms1)
+
+	MCFG_SCREEN_ADD("right_lcd", LCD)	// This is needed for SegaScope Right LCD
+	MCFG_SCREEN_FORMAT(BITMAP_FORMAT_RGB32)
+	MCFG_SCREEN_RAW_PARAMS(XTAL_53_693175MHz/10, SMS_X_PIXELS, LBORDER_START + LBORDER_X_PIXELS - 2, LBORDER_START + LBORDER_X_PIXELS + 256 + 10, NTSC_Y_PIXELS, TBORDER_START + NTSC_224_TBORDER_Y_PIXELS, TBORDER_START + NTSC_224_TBORDER_Y_PIXELS + 224)
+	MCFG_SCREEN_UPDATE(sms1)
+
+	MCFG_DEFAULT_LAYOUT(layout_sms1)
+
+	MCFG_PALETTE_LENGTH(64+16)
+	MCFG_PALETTE_INIT(sms)
+
+	MCFG_VIDEO_START(sms1)
+
+	MCFG_SMSVDP_ADD("sms_vdp", _315_5124_intf)
+MACHINE_CONFIG_END
+
+#define MCFG_SMSSDISP_CARTSLOT_ADD(_tag) \
+	MCFG_CARTSLOT_ADD(_tag) \
+	MCFG_CARTSLOT_EXTENSION_LIST("sms,bin") \
+	MCFG_CARTSLOT_NOT_MANDATORY \
+	MCFG_CARTSLOT_INTERFACE("sms_cart") \
+	MCFG_CARTSLOT_START(sms_cart) \
+	MCFG_CARTSLOT_LOAD(sms_cart)
+
+static MACHINE_CONFIG_DERIVED( sms_sdisp, sms2_ntsc )
+
+	MCFG_DEVICE_REMOVE("sms_vdp")
+	MCFG_SMSVDP_ADD("sms_vdp", sms_store_intf)
+
+	MCFG_CPU_ADD("control", Z80, XTAL_53_693175MHz/15)
+	MCFG_CPU_PROGRAM_MAP(sms_store_mem)
+	/* Both CPUs seem to communicate with the VDP etc? */
+	MCFG_CPU_IO_MAP(sms_io)
+
+	MCFG_CARTSLOT_MODIFY("cart1")
+	MCFG_CARTSLOT_EXTENSION_LIST("sms,bin")
+	MCFG_CARTSLOT_MANDATORY
+	MCFG_CARTSLOT_INTERFACE("sms_cart")
+	MCFG_CARTSLOT_START(sms_cart)
+	MCFG_CARTSLOT_LOAD(sms_cart)
+
+	MCFG_SMSSDISP_CARTSLOT_ADD("cart2")
+	MCFG_SMSSDISP_CARTSLOT_ADD("cart3")
+	MCFG_SMSSDISP_CARTSLOT_ADD("cart4")
+	MCFG_SMSSDISP_CARTSLOT_ADD("cart5")
+	MCFG_SMSSDISP_CARTSLOT_ADD("cart6")
+	MCFG_SMSSDISP_CARTSLOT_ADD("cart7")
+	MCFG_SMSSDISP_CARTSLOT_ADD("cart8")
+	MCFG_SMSSDISP_CARTSLOT_ADD("cart9")
+	MCFG_SMSSDISP_CARTSLOT_ADD("cart10")
+	MCFG_SMSSDISP_CARTSLOT_ADD("cart11")
+	MCFG_SMSSDISP_CARTSLOT_ADD("cart12")
+	MCFG_SMSSDISP_CARTSLOT_ADD("cart13")
+	MCFG_SMSSDISP_CARTSLOT_ADD("cart14")
+	MCFG_SMSSDISP_CARTSLOT_ADD("cart15")
+	MCFG_SMSSDISP_CARTSLOT_ADD("cart16")
+MACHINE_CONFIG_END
+
+static MACHINE_CONFIG_START( sms_pal_base, sms_state )
+	/* basic machine hardware */
+	MCFG_CPU_ADD("maincpu", Z80, MASTER_CLOCK_PAL/15)
+	MCFG_CPU_PROGRAM_MAP(sms_mem)
+	MCFG_CPU_IO_MAP(sms_io)
+
+	MCFG_QUANTUM_TIME(attotime::from_hz(60))
+
+	MCFG_MACHINE_START(sms)
+	MCFG_MACHINE_RESET(sms)
+
+	/* sound hardware */
+	MCFG_SPEAKER_STANDARD_MONO("mono")
+	MCFG_SOUND_ADD("smsiii", SMSIII, MASTER_CLOCK_PAL/15)
+	MCFG_SOUND_ROUTE(ALL_OUTPUTS, "mono", 1.00)
+
+	MCFG_FRAGMENT_ADD( sms_cartslot )
+MACHINE_CONFIG_END
+
+static MACHINE_CONFIG_DERIVED( sms2_pal, sms_pal_base )
+
+	/* video hardware */
+	MCFG_SCREEN_ADD("screen", RASTER)
+	MCFG_SCREEN_FORMAT(BITMAP_FORMAT_RGB32)
+	MCFG_SCREEN_RAW_PARAMS(MASTER_CLOCK_PAL/10, SMS_X_PIXELS, LBORDER_START + LBORDER_X_PIXELS - 2, LBORDER_START + LBORDER_X_PIXELS + 256 + 10, PAL_Y_PIXELS, TBORDER_START + PAL_240_TBORDER_Y_PIXELS, TBORDER_START + PAL_240_TBORDER_Y_PIXELS + 240)
+	MCFG_SCREEN_UPDATE(sms)
+
+	MCFG_PALETTE_LENGTH(64+16)
+	MCFG_PALETTE_INIT(sms)
+
+	MCFG_SMSVDP_ADD("sms_vdp", _315_5246_intf)
+MACHINE_CONFIG_END
+
+static MACHINE_CONFIG_DERIVED( sms1_pal, sms_pal_base )
+
+	MCFG_CPU_MODIFY("maincpu")
+	MCFG_CPU_PROGRAM_MAP(sms1_mem)	// This adds the SegaScope handlers for 3-D glasses
+	MCFG_CPU_IO_MAP(sms_io)
+
+	/* video hardware */
+	MCFG_SCREEN_ADD("screen", RASTER)
+	MCFG_SCREEN_FORMAT(BITMAP_FORMAT_RGB32)
+	MCFG_SCREEN_RAW_PARAMS(MASTER_CLOCK_PAL/10, SMS_X_PIXELS, LBORDER_START + LBORDER_X_PIXELS - 2, LBORDER_START + LBORDER_X_PIXELS + 256 + 10, PAL_Y_PIXELS, TBORDER_START + PAL_240_TBORDER_Y_PIXELS, TBORDER_START + PAL_240_TBORDER_Y_PIXELS + 240)
+	MCFG_SCREEN_UPDATE(sms1)
+
+	MCFG_SCREEN_ADD("left_lcd", LCD)	// This is needed for SegaScope Left LCD
+	MCFG_SCREEN_FORMAT(BITMAP_FORMAT_RGB32)
+	MCFG_SCREEN_RAW_PARAMS(MASTER_CLOCK_PAL/10, SMS_X_PIXELS, LBORDER_START + LBORDER_X_PIXELS - 2, LBORDER_START + LBORDER_X_PIXELS + 256 + 10, PAL_Y_PIXELS, TBORDER_START + PAL_240_TBORDER_Y_PIXELS, TBORDER_START + PAL_240_TBORDER_Y_PIXELS + 240)
+	MCFG_SCREEN_UPDATE(sms1)
+
+	MCFG_SCREEN_ADD("right_lcd", LCD)	// This is needed for SegaScope Right LCD
+	MCFG_SCREEN_FORMAT(BITMAP_FORMAT_RGB32)
+	MCFG_SCREEN_RAW_PARAMS(MASTER_CLOCK_PAL/10, SMS_X_PIXELS, LBORDER_START + LBORDER_X_PIXELS - 2, LBORDER_START + LBORDER_X_PIXELS + 256 + 10, PAL_Y_PIXELS, TBORDER_START + PAL_240_TBORDER_Y_PIXELS, TBORDER_START + PAL_240_TBORDER_Y_PIXELS + 240)
+	MCFG_SCREEN_UPDATE(sms1)
+
+	MCFG_PALETTE_LENGTH(64+16)
+	MCFG_PALETTE_INIT(sms)
+
+	MCFG_DEFAULT_LAYOUT(layout_sms1)
+
+	MCFG_SMSVDP_ADD("sms_vdp", _315_5124_intf)
+MACHINE_CONFIG_END
+
+static MACHINE_CONFIG_DERIVED( sms_fm, sms1_ntsc )
+
+	MCFG_SOUND_ADD("ym2413", YM2413, XTAL_53_693175MHz/15)
+	MCFG_SOUND_ROUTE(ALL_OUTPUTS, "mono", 1.00)
+MACHINE_CONFIG_END
+
+static MACHINE_CONFIG_DERIVED( sg1000m3, sms_fm )
+
+	MCFG_CARTSLOT_MODIFY("cart1")
+	MCFG_CARTSLOT_EXTENSION_LIST("sms,bin,sg")
+	MCFG_CARTSLOT_MANDATORY
+	MCFG_CARTSLOT_START(sms_cart)
+	MCFG_CARTSLOT_LOAD(sms_cart)
+MACHINE_CONFIG_END
+
+static MACHINE_CONFIG_DERIVED( sms2_fm, sms2_ntsc )
+
+	MCFG_SOUND_ADD("ym2413", YM2413, XTAL_53_693175MHz/15)
+	MCFG_SOUND_ROUTE(ALL_OUTPUTS, "mono", 1.00)
+MACHINE_CONFIG_END
+
+static MACHINE_CONFIG_START( gamegear, sms_state )
+	/* basic machine hardware */
+	MCFG_CPU_ADD("maincpu", Z80, XTAL_53_693175MHz/15)
+	MCFG_CPU_PROGRAM_MAP(sms_mem)
+	MCFG_CPU_IO_MAP(gg_io)
+
+	MCFG_QUANTUM_TIME(attotime::from_hz(60))
+
+	MCFG_MACHINE_START(sms)
+	MCFG_MACHINE_RESET(sms)
+
+	/* video hardware */
+	MCFG_SCREEN_ADD("screen", LCD)
+	MCFG_SCREEN_FORMAT(BITMAP_FORMAT_RGB32)
+	MCFG_SCREEN_RAW_PARAMS(XTAL_53_693175MHz/10, SMS_X_PIXELS, LBORDER_START + LBORDER_X_PIXELS + 6*8, LBORDER_START + LBORDER_X_PIXELS + 26*8, NTSC_Y_PIXELS, TBORDER_START + NTSC_192_TBORDER_Y_PIXELS + 3*8, TBORDER_START + NTSC_192_TBORDER_Y_PIXELS + 21*8 )
+	MCFG_SCREEN_UPDATE(gamegear)
+
+	MCFG_PALETTE_LENGTH(4096)
+	MCFG_PALETTE_INIT(gamegear)
+
+	MCFG_VIDEO_START(gamegear)
+
+	MCFG_SMSVDP_ADD("sms_vdp", _315_5378_intf)
+
+	/* sound hardware */
+	MCFG_SPEAKER_STANDARD_STEREO("lspeaker","rspeaker")
+	MCFG_SOUND_ADD("gamegear", GAMEGEAR, XTAL_53_693175MHz/15)
+	MCFG_SOUND_ROUTE(0, "lspeaker", 1.00)
+	MCFG_SOUND_ROUTE(1, "rspeaker", 1.00)
+
+	/* cartridge */
+	MCFG_FRAGMENT_ADD( gg_cartslot )
+MACHINE_CONFIG_END
+
+
+ROM_START(sms1)
+	ROM_REGION(0x4000, "maincpu", 0)
+	ROM_FILL(0x0000, 0x4000, 0xff)
+
+	ROM_REGION(0x20000, "user1", 0)
+	ROM_SYSTEM_BIOS( 0, "bios13", "US/European BIOS v1.3 (1986)" )
+	ROMX_LOAD("bios13fx.rom", 0x0000, 0x2000, CRC(0072ED54) SHA1(c315672807d8ddb8d91443729405c766dd95cae7), ROM_BIOS(1))
+	ROM_SYSTEM_BIOS( 1, "hangonsh", "US/European BIOS v2.4 with Hang On and Safari Hunt (1988)" )
+	ROMX_LOAD("hshbios.rom", 0x0000, 0x20000, CRC(91E93385) SHA1(9e179392cd416af14024d8f31c981d9ee9a64517), ROM_BIOS(2))
+	ROM_SYSTEM_BIOS( 2, "hangon", "US/European BIOS v3.4 with Hang On (1988)" )
+	ROMX_LOAD("hangbios.rom", 0x0000, 0x20000, CRC(8EDF7AC6) SHA1(51fd6d7990f62cd9d18c9ecfc62ed7936169107e), ROM_BIOS(3))
+	ROM_SYSTEM_BIOS( 3, "missiled", "US/European BIOS v4.4 with Missile Defense 3D (1988)" )
+	ROMX_LOAD("missiled.rom", 0x0000, 0x20000, CRC(E79BB689) SHA1(aa92ae576ca670b00855e278378d89e9f85e0351), ROM_BIOS(4))
+	ROM_SYSTEM_BIOS( 4, "proto", "US Master System Prototype BIOS" )
+	ROMX_LOAD("m404prot.rom", 0x0000, 0x2000, CRC(1a15dfcc) SHA1(4a06c8e66261611dce0305217c42138b71331701), ROM_BIOS(5))
+ROM_END
+
+ROM_START(sms)
+	ROM_REGION(0x4000, "maincpu", 0)
+	ROM_FILL(0x0000, 0x4000, 0xff)
+
+	ROM_REGION(0x20000, "user1", 0)
+	ROM_SYSTEM_BIOS( 0, "alexkidd", "US/European BIOS with Alex Kidd in Miracle World (1990)" )
+	ROMX_LOAD("akbios.rom", 0x0000, 0x20000, CRC(CF4A09EA) SHA1(3af7b66248d34eb26da40c92bf2fa4c73a46a051), ROM_BIOS(1))
+ROM_END
+
+ROM_START(smssdisp)
+	ROM_REGION(0x4000, "maincpu", 0)
+	ROM_FILL(0x0000, 0x4000, 0x00)
+
+	ROM_REGION(0x4000, "user1", 0)
+	ROM_FILL(0x0000, 0x4000, 0xff)
+
+	ROM_REGION(0x4000, "control", 0)
+	ROM_LOAD("smssdisp.rom", 0x0000, 0x4000, CRC(ee2c29ba) SHA1(fc465122134d95363112eb51b9ab71db3576cefd))
+ROM_END
+
+ROM_START(sms1pal)
+	ROM_REGION(0x4000, "maincpu", 0)
+	ROM_FILL(0x0000, 0x4000, 0xff)
+
+	ROM_REGION(0x20000, "user1", 0)
+	ROM_SYSTEM_BIOS( 0, "bios13", "US/European BIOS v1.3 (1986)" )
+	ROMX_LOAD("bios13fx.rom", 0x0000, 0x2000, CRC(0072ED54) SHA1(c315672807d8ddb8d91443729405c766dd95cae7), ROM_BIOS(1))
+	ROM_SYSTEM_BIOS( 1, "hangonsh", "US/European BIOS v2.4 with Hang On and Safari Hunt (1988)" )
+	ROMX_LOAD("hshbios.rom", 0x0000, 0x20000, CRC(91E93385) SHA1(9e179392cd416af14024d8f31c981d9ee9a64517), ROM_BIOS(2))
+	ROM_SYSTEM_BIOS( 2, "hangon", "Sega Master System - US/European BIOS v3.4 with Hang On (1988)" )
+	ROMX_LOAD("hangbios.rom", 0x0000, 0x20000, CRC(8EDF7AC6) SHA1(51fd6d7990f62cd9d18c9ecfc62ed7936169107e), ROM_BIOS(3))
+	ROM_SYSTEM_BIOS( 3, "missiled", "US/European BIOS v4.4 with Missile Defense 3D (1988)" )
+	ROMX_LOAD("missiled.rom", 0x0000, 0x20000, CRC(E79BB689) SHA1(aa92ae576ca670b00855e278378d89e9f85e0351), ROM_BIOS(4))
+ROM_END
+
+ROM_START(smspal)
+	ROM_REGION(0x4000, "maincpu", 0)
+	ROM_FILL(0x0000, 0x4000, 0xff)
+
+	ROM_REGION(0x40000, "user1", 0)
+	ROM_SYSTEM_BIOS( 0, "alexkidd", "US/European BIOS with Alex Kidd in Miracle World (1990)" )
+	ROMX_LOAD("akbios.rom", 0x0000, 0x20000, CRC(CF4A09EA) SHA1(3af7b66248d34eb26da40c92bf2fa4c73a46a051), ROM_BIOS(1))
+	ROM_SYSTEM_BIOS( 1, "sonic", "European/Brazilian BIOS with Sonic the Hedgehog (1991)" )
+	ROMX_LOAD("sonbios.rom", 0x0000, 0x40000, CRC(81C3476B) SHA1(6aca0e3dffe461ba1cb11a86cd4caf5b97e1b8df), ROM_BIOS(2))
+ROM_END
+
+ROM_START(sg1000m3)
+	ROM_REGION(0x4000, "maincpu", 0)
+	ROM_FILL(0x0000, 0x4000, 0x00)
+ROM_END
+
+ROM_START(smsj)
+	ROM_REGION(0x4000, "maincpu", 0)
+	ROM_FILL(0x0000, 0x4000, 0xff)
+
+	ROM_REGION(0x4000, "user1", 0)
+	ROM_SYSTEM_BIOS( 0, "jbios21", "Japanese BIOS v2.1 (1987)" )
+	ROMX_LOAD("jbios21.rom", 0x0000, 0x2000, CRC(48D44A13) SHA1(a8c1b39a2e41137835eda6a5de6d46dd9fadbaf2), ROM_BIOS(1))
+ROM_END
+
+ROM_START(sms2kr)
+	ROM_REGION(0x4000, "maincpu", 0)
+	ROM_FILL(0x0000, 0x4000, 0xff)
+
+	ROM_REGION(0x20000, "user1", 0)
+	ROM_SYSTEM_BIOS( 0, "akbioskr", "Samsung Gam*Boy II with Alex Kidd in Miracle World (1990)" )
+	ROMX_LOAD("akbioskr.rom", 0x000, 0x20000, CRC(9c5bad91) SHA1(2feafd8f1c40fdf1bd5668f8c5c02e5560945b17), ROM_BIOS(1))
+ROM_END
+
+ROM_START(gamegear)
+	ROM_REGION(0x4000, "maincpu", 0)
+	ROM_FILL(0x0000, 0x4000, 0x00)
+
+	ROM_REGION(0x0400, "user1", 0)
+	ROM_SYSTEM_BIOS( 0, "none", "No BIOS" ) /* gamegear */
+	ROM_SYSTEM_BIOS( 1, "majesco", "Majesco BIOS" ) /* gamg */
+	ROMX_LOAD("majbios.rom", 0x0000, 0x0400, CRC(0EBEA9D4) SHA1(914aa165e3d879f060be77870d345b60cfeb4ede), ROM_BIOS(2))
+ROM_END
+
+#define rom_gamegeaj rom_gamegear
+
+/***************************************************************************
+
+  Game driver(s)
+
+  US
+   - Sega Master System I (sms1)
+     - prototype bios - 1986
+     - without built-in game v1.3 - 1986
+     - built-in Hang On/Safari Hunt v2.4 - 1988
+     - built-in Hang On v3.4 - 1988
+     - built-in Missile Defense 3-D v4.4 - 1988
+     - built-in Hang On/Astro Warrior ????
+   - Sega Master System II (sms/sms2)
+     - built-in Alex Kidd in Miracle World - 1990
+
+  JP
+   - Sega SG-1000 Mark III (smsm3)
+     - no bios
+   - Sega Master System (I) (smsj)
+     - without built-in game v2.1 - 1987
+
+  KR
+   - Sega Master System II (sms2kr)
+     - built-in Alex Kidd in Miracle World (Korean)
+
+  EU
+   - Sega Master System I (sms1pal)
+     - without built-in game v1.3 - 1986
+     - built-in Hang On/Safari Hunt v2.4 - 1988
+     - built-in Hang On v3.4 - 1988
+     - built-in Missile Defense 3-D v4.4 - 1988
+     - built-in Hang On/Astro Warrior ????
+   - Sega Master System II (sms2pal)
+     - built-in Alex Kidd in Miracle World - 1990
+     - built-in Sonic the Hedgehog - 1991
+
+  BR
+   - Sega Master System I - 1987
+   - Sega Master System II???
+   - Sega Master System III - Tec Toy, 1987
+   - Sega Master System Compact - Tec Toy, 1992
+   - Sega Master System Girl - Tec Toy, 1992
+
+***************************************************************************/
+
+/*    YEAR  NAME        PARENT      COMPAT  MACHINE      INPUT   INIT      COMPANY     FULLNAME                            FLAGS */
+CONS( 1984, sg1000m3,   sms,        0,      sg1000m3,    smsj,   sg1000m3, "Sega",     "SG-1000 Mark III",                 0 )
+CONS( 1986, sms1,       sms,        0,      sms1_ntsc,   sms1,   sms1,     "Sega",     "Master System I",                  0 )
+CONS( 1986, sms1pal,    sms,        0,      sms1_pal,    sms1,   sms1,     "Sega",     "Master System I (PAL)" ,           0 )
+CONS( 1986, smssdisp,   sms,        0,      sms_sdisp,   sms,    smssdisp, "Sega",     "Master System Store Display Unit", GAME_NOT_WORKING )
+CONS( 1987, smsj,       sms,        0,      sms_fm,      smsj,   smsj,     "Sega",     "Master System (Japan)",            0 )
+CONS( 1990, sms,        0,          0,      sms2_ntsc,   sms,    sms1,     "Sega",     "Master System II",                 0 )
+CONS( 1990, smspal,     sms,        0,      sms2_pal,    sms,    sms1,     "Sega",     "Master System II (PAL)",           0 )
+CONS( 1990, sms2kr,     sms,        0,      sms2_fm,     sms,    sms2kr,   "Samsung",  "Gam*Boy II (Korea)",               0 )
+
+CONS( 1990, gamegear,   0,          sms,    gamegear,    gg,     gamegear, "Sega",     "Game Gear (Europe/America)",       0 )
+CONS( 1990, gamegeaj,   gamegear,   0,      gamegear,    gg,     gamegeaj, "Sega",     "Game Gear (Japan)",                0 )

src/mame/formats/basicdsk.c

@@ -0,0 +1,352 @@
+/*********************************************************************
+
+    formats/basicdsk.c
+
+    Floppy format code for basic disks
+
+*********************************************************************/
+
+#include <stdlib.h>
+#include <string.h>
+#include <assert.h>
+
+#include "basicdsk.h"
+
+static floperr_t basicdsk_read_sector(floppy_image *floppy, int head, int track, int sector, void *buffer, size_t buflen);
+static floperr_t basicdsk_write_sector(floppy_image *floppy, int head, int track, int sector, const void *buffer, size_t buflen, int ddam);
+static floperr_t basicdsk_read_indexed_sector(floppy_image *floppy, int head, int track, int sector, void *buffer, size_t buflen);
+static floperr_t basicdsk_write_indexed_sector(floppy_image *floppy, int head, int track, int sector, const void *buffer, size_t buflen, int ddam);
+static floperr_t basicdsk_get_sector_length(floppy_image *floppy, int head, int track, int sector, UINT32 *sector_length);
+static floperr_t basicdsk_get_indexed_sector_info(floppy_image *floppy, int head, int track, int sector_index, int *cylinder, int *side, int *sector, UINT32 *sector_length, unsigned long *flags);
+static int basicdsk_get_heads_per_disk(floppy_image *floppy);
+static int basicdsk_get_tracks_per_disk(floppy_image *floppy);
+static floperr_t basicdsk_format_track(floppy_image *floppy, int head, int track, option_resolution *params);
+
+
+
+#define BASICDSK_TAG	"basicdsktag"
+
+struct basicdsk_tag
+{
+	struct basicdsk_geometry geometry;
+};
+
+
+
+/********************************************************************/
+
+static const struct basicdsk_geometry *get_geometry(floppy_image *floppy)
+{
+	const struct basicdsk_tag *tag;
+	tag = (const basicdsk_tag *)floppy_tag(floppy);
+	return &tag->geometry;
+}
+
+
+
+floperr_t basicdsk_construct(floppy_image *floppy, const struct basicdsk_geometry *geometry)
+{
+	struct basicdsk_tag *tag;
+	struct FloppyCallbacks *format;
+
+	assert(geometry->heads);
+	assert(geometry->tracks);
+	assert(geometry->sectors);
+
+	tag = (struct basicdsk_tag *) floppy_create_tag(floppy, sizeof(struct basicdsk_tag));
+	if (!tag)
+		return FLOPPY_ERROR_OUTOFMEMORY;
+	tag->geometry = *geometry;
+
+	/* set up format callbacks */
+	format = floppy_callbacks(floppy);
+	format->read_sector = basicdsk_read_sector;
+	format->write_sector = basicdsk_write_sector;
+	format->read_indexed_sector = basicdsk_read_indexed_sector;
+	format->write_indexed_sector = basicdsk_write_indexed_sector;
+	format->get_sector_length = basicdsk_get_sector_length;
+	format->get_heads_per_disk = basicdsk_get_heads_per_disk;
+	format->get_tracks_per_disk = basicdsk_get_tracks_per_disk;
+	format->get_indexed_sector_info = basicdsk_get_indexed_sector_info;
+	format->format_track = basicdsk_format_track;
+
+	return FLOPPY_ERROR_SUCCESS;
+}
+
+
+
+static floperr_t get_offset(floppy_image *floppy, int head, int track, int sector, int sector_is_index, UINT64 *offset)
+{
+	const struct basicdsk_geometry *geom;
+	UINT64 offs;
+
+	geom = get_geometry(floppy);
+
+	/* translate the sector to a raw sector */
+	if (!sector_is_index)
+	{
+		sector -= geom->first_sector_id;
+	}
+
+	if (geom->translate_sector)
+		sector = geom->translate_sector(floppy, sector);
+
+	/* check to see if we are out of range */
+	if ((head < 0) || (head >= geom->heads) || (track < 0) || (track >= geom->tracks)
+			|| (sector < 0) || (sector >= geom->sectors))
+		return FLOPPY_ERROR_SEEKERROR;
+
+	if (geom->translate_offset)
+		offs = geom->translate_offset(floppy, geom, track, head, sector);
+	else
+	{
+		offs = 0;
+		offs += track;
+		offs *= geom->heads;
+		offs += head;
+		offs *= geom->sectors;
+		offs += sector;
+	}
+	offs *= geom->sector_length;
+	offs += geom->offset;
+
+	if (offset)
+		*offset = offs;
+	return FLOPPY_ERROR_SUCCESS;
+}
+
+
+
+static int internal_basicdsk_translate_sector_interleave(floppy_image *floppy, int sector)
+{
+	const struct basicdsk_geometry *geom = get_geometry(floppy);
+	if (sector >= geom->sectors)
+		return sector;
+	return geom->sector_map[sector];
+}
+
+
+
+static floperr_t internal_basicdsk_read_sector(floppy_image *floppy, int head, int track, int sector, int sector_is_index, void *buffer, size_t buflen)
+{
+	UINT64 offset;
+	floperr_t err;
+
+	err = get_offset(floppy, head, track, sector, sector_is_index, &offset);
+	if (err)
+		return err;
+	floppy_image_read(floppy, buffer, offset, buflen);
+	return FLOPPY_ERROR_SUCCESS;
+}
+
+
+
+static floperr_t internal_basicdsk_write_sector(floppy_image *floppy, int head, int track, int sector, int sector_is_index, const void *buffer, size_t buflen, int ddam)
+{
+	UINT64 offset;
+	floperr_t err;
+
+	err = get_offset(floppy, head, track, sector, sector_is_index, &offset);
+	if (err)
+		return err;
+
+	floppy_image_write(floppy, buffer, offset, buflen);
+	return FLOPPY_ERROR_SUCCESS;
+}
+
+
+
+static floperr_t basicdsk_read_sector(floppy_image *floppy, int head, int track, int sector, void *buffer, size_t buflen)
+{
+	return internal_basicdsk_read_sector(floppy, head, track, sector, FALSE, buffer, buflen);
+}
+
+static floperr_t basicdsk_write_sector(floppy_image *floppy, int head, int track, int sector, const void *buffer, size_t buflen, int ddam)
+{
+	return internal_basicdsk_write_sector(floppy, head, track, sector, FALSE, buffer, buflen, ddam);
+}
+
+static floperr_t basicdsk_read_indexed_sector(floppy_image *floppy, int head, int track, int sector, void *buffer, size_t buflen)
+{
+	return internal_basicdsk_read_sector(floppy, head, track, sector, TRUE, buffer, buflen);
+}
+
+static floperr_t basicdsk_write_indexed_sector(floppy_image *floppy, int head, int track, int sector, const void *buffer, size_t buflen, int ddam)
+{
+	return internal_basicdsk_write_sector(floppy, head, track, sector, TRUE, buffer, buflen, ddam);
+}
+
+
+
+static floperr_t basicdsk_format_track(floppy_image *floppy, int head, int track, option_resolution *params)
+{
+	floperr_t err = FLOPPY_ERROR_SUCCESS;
+	UINT8 local_buffer[512];
+	void *alloc_buffer = NULL;
+	void *buffer;
+	UINT32 sector_length;
+	int sector;
+	const struct basicdsk_geometry *geometry;
+
+	geometry = get_geometry(floppy);
+
+	sector_length = geometry->sector_length;
+
+	if (sector_length > sizeof(local_buffer))
+	{
+		alloc_buffer = malloc(sector_length);
+		if (!alloc_buffer)
+		{
+			err = FLOPPY_ERROR_OUTOFMEMORY;
+			goto done;
+		}
+		buffer = alloc_buffer;
+	}
+	else
+	{
+		alloc_buffer = NULL;
+		buffer = local_buffer;
+	}
+
+	memset(buffer, floppy_get_filler(floppy), sector_length);
+
+	for (sector = 0; sector < geometry->sectors; sector++)
+	{
+		err = basicdsk_write_sector(floppy, head, track, sector + geometry->first_sector_id, buffer, sector_length, 0);
+		if (err)
+			goto done;
+	}
+
+done:
+	if (alloc_buffer)
+		free(alloc_buffer);
+	return err;
+}
+
+
+
+static int basicdsk_get_heads_per_disk(floppy_image *floppy)
+{
+	return get_geometry(floppy)->heads;
+}
+
+
+
+static int basicdsk_get_tracks_per_disk(floppy_image *floppy)
+{
+	return get_geometry(floppy)->tracks;
+}
+
+
+
+static floperr_t basicdsk_get_sector_length(floppy_image *floppy, int head, int track, int sector, UINT32 *sector_length)
+{
+	floperr_t err;
+
+	err = get_offset(floppy, head, track, sector, FALSE, NULL);
+	if (err)
+		return err;
+
+	if (sector_length)
+		*sector_length = get_geometry(floppy)->sector_length;
+	return FLOPPY_ERROR_SUCCESS;
+}
+
+
+
+static floperr_t basicdsk_get_indexed_sector_info(floppy_image *floppy, int head, int track, int sector_index, int *cylinder, int *side, int *sector, UINT32 *sector_length, unsigned long *flags)
+{
+	const struct basicdsk_geometry *geom = get_geometry(floppy);
+
+	if (geom->translate_sector)
+		sector_index = geom->translate_sector(floppy, sector_index);
+
+	sector_index += geom->first_sector_id;
+
+	if (cylinder)
+		*cylinder = track;
+	if (side)
+		*side = head;
+	if (sector)
+		*sector = sector_index;
+	if (flags) {
+		/* TODO: read DAM or DDAM and determine flags */
+		*flags = 0;
+		if (geom->get_ddam)
+			*flags = geom->get_ddam(floppy, geom, track, head, sector_index);
+	}
+	return basicdsk_get_sector_length(floppy, head, track, sector_index, sector_length);
+}
+
+
+
+/********************************************************************
+ * Generic Basicdsk Constructors
+ ********************************************************************/
+
+static void basicdsk_default_geometry(const struct FloppyFormat *format, struct basicdsk_geometry *geometry)
+{
+	optreserr_t err;
+	int sector_length;
+	memset(geometry, 0, sizeof(*geometry));
+
+	err = option_resolution_getdefault(format->param_guidelines, PARAM_HEADS,			&geometry->heads);
+	assert(!err);
+	err = option_resolution_getdefault(format->param_guidelines, PARAM_TRACKS,			&geometry->tracks);
+	assert(!err);
+	err = option_resolution_getdefault(format->param_guidelines, PARAM_SECTORS,			&geometry->sectors);
+	assert(!err);
+	err = option_resolution_getdefault(format->param_guidelines, PARAM_FIRST_SECTOR_ID,	&geometry->first_sector_id);
+	assert(!err);
+	err = option_resolution_getdefault(format->param_guidelines, PARAM_INTERLEAVE,		&geometry->interleave);
+	if (err!=0) {
+		geometry->interleave = 1;
+	}
+	err = option_resolution_getdefault(format->param_guidelines, PARAM_SECTOR_LENGTH,	&sector_length);
+	assert(!err);
+	geometry->sector_length = sector_length;
+
+	if (geometry->interleave > 1)
+	{
+		int sector = 0;
+
+		for (int i = 0; i < geometry->sectors; i++)
+		{
+			geometry->sector_map[i] = sector;
+
+			sector += geometry->interleave;
+
+			if (sector >= geometry->sectors)
+				sector -= geometry->sectors;
+		}
+
+		geometry->translate_sector = internal_basicdsk_translate_sector_interleave;
+	}
+}
+
+
+
+FLOPPY_CONSTRUCT(basicdsk_construct_default)
+{
+	struct basicdsk_geometry geometry;
+	basicdsk_default_geometry(format, &geometry);
+	return basicdsk_construct(floppy, &geometry);
+}
+
+
+
+FLOPPY_IDENTIFY(basicdsk_identify_default)
+{
+	UINT64 expected_size;
+	struct basicdsk_geometry geometry;
+
+	basicdsk_default_geometry(format, &geometry);
+
+	expected_size = geometry.sector_length;
+	expected_size *= geometry.heads;
+	expected_size *= geometry.tracks;
+	expected_size *= geometry.sectors;
+	*vote = (floppy_image_size(floppy) == expected_size) ? 100 : 0;
+	return FLOPPY_ERROR_SUCCESS;
+}
+

src/mame/formats/basicdsk.h

@@ -0,0 +1,35 @@
+/*********************************************************************
+
+    formats/basicdsk.h
+
+    Floppy format code for basic disks
+
+*********************************************************************/
+
+#ifndef BASICDSK_H
+#define BASICDSK_H
+
+#include "imagedev/flopimg.h"
+
+struct basicdsk_geometry
+{
+	int heads;
+	int tracks;
+	int sectors;
+	int first_sector_id;
+	int interleave;
+	int sector_map[256];
+	UINT32 sector_length;
+	UINT64 offset;
+
+	int (*translate_sector)(floppy_image *floppy, int sector);
+	UINT64 (*translate_offset)(floppy_image *floppy, const struct basicdsk_geometry *geom, int track, int head, int sector);
+	UINT64 (*get_ddam)(floppy_image *floppy, const struct basicdsk_geometry *geom, int track, int head, int sector);
+};
+
+floperr_t basicdsk_construct(floppy_image *floppy, const struct basicdsk_geometry *geometry);
+
+FLOPPY_IDENTIFY(basicdsk_identify_default);
+FLOPPY_CONSTRUCT(basicdsk_construct_default);
+
+#endif /* BASICDSK_H */

src/mame/includes/segasms.h

@@ -0,0 +1,183 @@
+/*****************************************************************************
+ *
+ * includes/sms.h
+ *
+ ****************************************************************************/
+
+#ifndef SMS_H_
+#define SMS_H_
+
+#define LOG_REG
+#define LOG_PAGING
+#define LOG_COLOR
+
+#define NVRAM_SIZE             (0x08000)
+#define CPU_ADDRESSABLE_SIZE   (0x10000)
+
+#define MAX_CARTRIDGES        16
+
+class sms_state : public driver_device
+{
+public:
+	sms_state(const machine_config &mconfig, device_type type, const char *tag)
+	: driver_device(mconfig, type, tag) { }
+
+	// device_ts
+	device_t *m_main_cpu;
+	device_t *m_control_cpu;
+	device_t *m_vdp;
+	device_t *m_ym;
+	device_t *m_main_scr;
+	device_t *m_left_lcd;
+	device_t *m_right_lcd;
+
+	UINT8 m_bios_page_count;
+	UINT8 m_fm_detect;
+	UINT8 m_ctrl_reg;
+	int m_paused;
+	UINT8 m_bios_port;
+	UINT8 *m_BIOS;
+	UINT8 *m_mapper_ram;
+	UINT8 m_mapper[4];
+	// we are going to use 1-6, same as bank numbers. Notice, though, that most mappers
+	// only work on 16K banks and, hence, banks 4-6 are not always directly set
+	// (they often use bank3 + 0x2000 and bank5 + 0x2000)
+	UINT8 *m_banking_bios[7];
+	UINT8 *m_banking_cart[7];
+	UINT8 *m_banking_none[7];
+	UINT8 m_gg_sio[5];
+	UINT8 m_store_control;
+	UINT8 m_input_port0;
+	UINT8 m_input_port1;
+
+	// for gamegear LCD persistence hack
+	bitmap_t *m_tmp_bitmap;
+	bitmap_t *m_prev_bitmap;
+
+	// for 3D glass binocular hack
+	bitmap_t *m_prevleft_bitmap;
+	bitmap_t *m_prevright_bitmap;
+
+	/* Model identifiers */
+	UINT8 m_is_gamegear;
+	UINT8 m_is_region_japan;
+	UINT8 m_has_bios_0400;
+	UINT8 m_has_bios_2000;
+	UINT8 m_has_bios_full;
+	UINT8 m_has_bios;
+	UINT8 m_has_fm;
+
+	/* Data needed for Rapid Fire Unit support */
+	emu_timer *m_rapid_fire_timer;
+	UINT8 m_rapid_fire_state_1;
+	UINT8 m_rapid_fire_state_2;
+
+	/* Data needed for Paddle Control controller */
+	UINT32 m_last_paddle_read_time;
+	UINT8 m_paddle_read_state;
+
+	/* Data needed for Sports Pad controller */
+	UINT32 m_last_sports_pad_time_1;
+	UINT32 m_last_sports_pad_time_2;
+	UINT8 m_sports_pad_state_1;
+	UINT8 m_sports_pad_state_2;
+	UINT8 m_sports_pad_last_data_1;
+	UINT8 m_sports_pad_last_data_2;
+	UINT8 m_sports_pad_1_x;
+	UINT8 m_sports_pad_1_y;
+	UINT8 m_sports_pad_2_x;
+	UINT8 m_sports_pad_2_y;
+
+	/* Data needed for Light Phaser */
+	emu_timer *m_lphaser_1_timer;
+	emu_timer *m_lphaser_2_timer;
+	UINT8 m_lphaser_1_latch;
+	UINT8 m_lphaser_2_latch;
+	int m_lphaser_x_offs;	/* Needed to 'calibrate' lphaser; set at cart loading */
+
+	/* Data needed for SegaScope (3D glasses) */
+	UINT8 m_sscope_state;
+
+	/* Data needed for Terebi Oekaki (TV Draw) */
+	UINT8 m_tvdraw_data;
+
+	/* Cartridge slot info */
+	UINT8 m_current_cartridge;
+	struct
+	{
+		UINT8 *ROM;        /* Pointer to ROM image data */
+		UINT32 size;       /* Size of the ROM image */
+		UINT8 features;    /* on-cartridge special hardware */
+		UINT8 *cartSRAM;   /* on-cartridge SRAM */
+		UINT8 sram_save;   /* should be the contents of the on-cartridge SRAM be saved */
+		UINT8 *cartRAM;    /* additional on-cartridge RAM (64KB for Ernie Els Golf) */
+		UINT32 ram_size;   /* size of the on-cartridge RAM */
+		UINT8 ram_page;    /* currently swapped in cartridge RAM */
+	} m_cartridge[MAX_CARTRIDGES];
+};
+
+
+/*----------- defined in machine/sms.c -----------*/
+
+/* Function prototypes */
+WRITE8_HANDLER( sms_cartram_w );
+WRITE8_HANDLER( sms_cartram2_w );
+WRITE8_HANDLER( sms_fm_detect_w );
+READ8_HANDLER( sms_fm_detect_r );
+READ8_HANDLER( sms_input_port_0_r );
+READ8_HANDLER( sms_input_port_1_r );
+WRITE8_HANDLER( sms_ym2413_register_port_0_w );
+WRITE8_HANDLER( sms_ym2413_data_port_0_w );
+WRITE8_HANDLER( sms_io_control_w );
+READ8_HANDLER( sms_count_r );
+WRITE8_HANDLER( sms_sscope_w );
+READ8_HANDLER( sms_sscope_r );
+WRITE8_HANDLER( sms_mapper_w );
+READ8_HANDLER( sms_mapper_r );
+WRITE8_HANDLER( sms_bios_w );
+WRITE8_HANDLER( gg_sio_w );
+READ8_HANDLER( gg_sio_r );
+READ8_HANDLER( gg_input_port_2_r );
+
+INPUT_CHANGED( lgun1_changed );
+INPUT_CHANGED( lgun2_changed );
+
+void sms_pause_callback( running_machine &machine );
+void sms_store_int_callback( running_machine &machine, int state );
+
+DEVICE_START( sms_cart );
+DEVICE_IMAGE_LOAD( sms_cart );
+
+MACHINE_START( sms );
+MACHINE_RESET( sms );
+
+READ8_HANDLER( sms_store_cart_select_r );
+WRITE8_HANDLER( sms_store_cart_select_w );
+READ8_HANDLER( sms_store_select1 );
+READ8_HANDLER( sms_store_select2 );
+READ8_HANDLER( sms_store_control_r );
+WRITE8_HANDLER( sms_store_control_w );
+
+#define IO_EXPANSION    (0x80)	/* Expansion slot enable (1= disabled, 0= enabled) */
+#define IO_CARTRIDGE    (0x40)	/* Cartridge slot enable (1= disabled, 0= enabled) */
+#define IO_CARD         (0x20)	/* Card slot disabled (1= disabled, 0= enabled) */
+#define IO_WORK_RAM     (0x10)	/* Work RAM disabled (1= disabled, 0= enabled) */
+#define IO_BIOS_ROM     (0x08)	/* BIOS ROM disabled (1= disabled, 0= enabled) */
+#define IO_CHIP         (0x04)	/* I/O chip disabled (1= disabled, 0= enabled) */
+
+
+DRIVER_INIT( sg1000m3 );
+DRIVER_INIT( sms1 );
+DRIVER_INIT( smsj );
+DRIVER_INIT( sms2kr );
+DRIVER_INIT( smssdisp );
+DRIVER_INIT( gamegear );
+DRIVER_INIT( gamegeaj );
+
+VIDEO_START( sms1 );
+VIDEO_START( gamegear );
+SCREEN_UPDATE( sms1 );
+SCREEN_UPDATE( sms );
+SCREEN_UPDATE( gamegear );
+
+#endif /* SMS_H_ */

src/mame/includes/sg1000.h

@@ -0,0 +1,102 @@
+#ifndef __SG1000__
+#define __SG1000__
+
+#include "machine/ram.h"
+
+#define SCREEN_TAG		"screen"
+#define Z80_TAG			"z80"
+#define SN76489A_TAG	"sn76489a"
+#define UPD765_TAG		"upd765"
+#define CASSETTE_TAG	"cassette"
+#define UPD8251_TAG		"upd8251"
+#define UPD9255_TAG		"upd9255"
+#define UPD9255_0_TAG	"upd9255_0"
+#define UPD9255_1_TAG	"upd9255_1"
+#define CENTRONICS_TAG	"centronics"
+
+#define IS_CARTRIDGE_TV_DRAW(ptr) \
+	(!strncmp("annakmn", (const char *)&ptr[0x13b3], 7))
+
+#define IS_CARTRIDGE_THE_CASTLE(ptr) \
+	(!strncmp("ASCII 1986", (const char *)&ptr[0x1cc3], 10))
+
+#define IS_CARTRIDGE_BASIC_LEVEL_III(ptr) \
+	(!strncmp("SC-3000 BASIC Level 3 ver 1.0", (const char *)&ptr[0x6a20], 29))
+
+#define IS_CARTRIDGE_MUSIC_EDITOR(ptr) \
+	(!strncmp("PIANO", (const char *)&ptr[0x0841], 5))
+
+class sg1000_state : public driver_device
+{
+public:
+	sg1000_state(const machine_config &mconfig, device_type type, const char *tag)
+		: driver_device(mconfig, type, tag),
+		  m_maincpu(*this, Z80_TAG),
+		  m_ram(*this, RAM_TAG)
+	{ }
+
+	required_device<cpu_device> m_maincpu;
+	required_device<device_t> m_ram;
+
+	virtual void machine_start();
+
+	void install_cartridge(UINT8 *ptr, int size);
+
+	DECLARE_WRITE8_MEMBER( tvdraw_axis_w );
+	DECLARE_READ8_MEMBER( tvdraw_status_r );
+	DECLARE_READ8_MEMBER( tvdraw_data_r );
+	DECLARE_READ8_MEMBER( joysel_r );
+
+	/* keyboard state */
+	UINT8 m_keylatch;
+
+	/* TV Draw state */
+	UINT8 m_tvdraw_data;
+};
+
+class sc3000_state : public sg1000_state
+{
+public:
+	sc3000_state(const machine_config &mconfig, device_type type, const char *tag)
+		: sg1000_state(mconfig, type, tag),
+		  m_cassette(*this, CASSETTE_TAG)
+	{ }
+
+	required_device<device_t> m_cassette;
+
+	virtual void machine_start();
+
+	void install_cartridge(UINT8 *ptr, int size);
+
+	DECLARE_READ8_MEMBER( ppi_pa_r );
+	DECLARE_READ8_MEMBER( ppi_pb_r );
+	DECLARE_WRITE8_MEMBER( ppi_pc_w );
+};
+
+class sf7000_state : public sc3000_state
+{
+public:
+	sf7000_state(const machine_config &mconfig, device_type type, const char *tag)
+		: sc3000_state(mconfig, type, tag),
+		  m_fdc(*this, UPD765_TAG),
+		  m_centronics(*this, CENTRONICS_TAG),
+		  m_floppy0(*this, FLOPPY_0)
+	{ }
+
+	required_device<device_t> m_fdc;
+	required_device<device_t> m_centronics;
+	required_device<device_t> m_floppy0;
+
+	virtual void machine_start();
+	virtual void machine_reset();
+
+	DECLARE_READ8_MEMBER( ppi_pa_r );
+	DECLARE_WRITE8_MEMBER( ppi_pc_w );
+	DECLARE_WRITE_LINE_MEMBER( fdc_intrq_w );
+
+	/* floppy state */
+	int m_fdc_irq;
+	int m_fdc_index;
+};
+
+#endif

src/mame/layout/sms1.lay

@@ -0,0 +1,62 @@
+<?xml version="1.0"?>
+<mamelayout version="2">
+	<view name="Main Screen Standard (4:3)">
+		<screen index="0">
+			<bounds left="0" top="0" right="4" bottom="3" />
+		</screen>
+	</view>
+
+	<view name="SegaScope Left LCD Standard (4:3)">
+		<screen index="1">
+			<bounds left="0" top="0" right="4" bottom="3" />
+		</screen>
+	</view>
+
+	<view name="SegaScope Right LCD Standard (4:3)">
+		<screen index="2">
+			<bounds left="0" top="0" right="4" bottom="3" />
+		</screen>
+	</view>
+
+	<view name="Main Screen Pixel Aspect (~scr0nativexaspect~:~scr0nativeyaspect~)">
+		<screen index="0">
+			<bounds left="0" top="0" right="~scr0width~" bottom="~scr0height~" />
+		</screen>
+	</view>
+
+	<view name="SegaScope Left LCD Aspect (~scr1nativexaspect~:~scr1nativeyaspect~)">
+		<screen index="1">
+			<bounds left="0" top="0" right="~scr1width~" bottom="~scr1height~" />
+		</screen>
+	</view>
+
+	<view name="SegaScope Right LCD Pixel Aspect (~scr1nativexaspect~:~scr1nativeyaspect~)">
+		<screen index="2">
+			<bounds left="0" top="0" right="~scr1width~" bottom="~scr1height~" />
+		</screen>
+	</view>
+
+	<view name="Main Screen">
+		<screen index="0">
+			<bounds x="0" y="0" width="4" height="3" />
+		</screen>
+	</view>
+
+	<view name="SegaScope 3-D Glasses">
+		<screen index="1">
+			<bounds x="0" y="0" width="4" height="3" />
+		</screen>
+		<screen index="2">
+			<bounds x="4.03" y="0" width="4" height="3" />
+		</screen>
+	</view>
+
+	<view name="SegaScope 3-D Glasses (Gapless)">
+		<screen index="1">
+			<bounds x="0" y="0" width="4" height="3" />
+		</screen>
+		<screen index="2">
+			<bounds x="4" y="0" width="4" height="3" />
+		</screen>
+	</view>
+</mamelayout>

src/mame/machine/ctronics.c

@@ -0,0 +1,391 @@
+/***************************************************************************
+
+    Centronics printer interface
+
+***************************************************************************/
+
+#include "emu.h"
+#include "ctronics.h"
+#include "imagedev/printer.h"
+
+
+/***************************************************************************
+    FUNCTION PROTOTYPES
+***************************************************************************/
+
+static WRITE_LINE_DEVICE_HANDLER( centronics_printer_online );
+static TIMER_CALLBACK( ack_callback );
+static TIMER_CALLBACK( busy_callback );
+
+
+/***************************************************************************
+    TYPE DEFINITIONS
+***************************************************************************/
+
+typedef struct _centronics_state centronics_state;
+struct _centronics_state
+{
+	device_t *printer;
+
+	devcb_resolved_write_line out_ack_func;
+	devcb_resolved_write_line out_busy_func;
+	devcb_resolved_write_line out_not_busy_func;
+
+	int strobe;
+	int busy;
+	int ack;
+	int auto_fd;
+	int pe;
+	int fault;
+
+	UINT8 data;
+};
+
+
+/*****************************************************************************
+    INLINE FUNCTIONS
+*****************************************************************************/
+
+INLINE centronics_state *get_safe_token(device_t *device)
+{
+	assert(device != NULL);
+	assert(device->type() == CENTRONICS);
+
+	return (centronics_state *)downcast<legacy_device_base *>(device)->token();
+}
+
+
+/*****************************************************************************
+    GLOBAL VARIABLES
+*****************************************************************************/
+
+const centronics_interface standard_centronics =
+{
+	FALSE,
+	DEVCB_NULL,
+	DEVCB_NULL,
+	DEVCB_NULL
+};
+
+
+/*****************************************************************************
+    PRINTER INTERFACE
+*****************************************************************************/
+
+static MACHINE_CONFIG_FRAGMENT( centronics )
+	MCFG_PRINTER_ADD("printer")
+	MCFG_PRINTER_ONLINE(centronics_printer_online)
+MACHINE_CONFIG_END
+
+
+/*****************************************************************************
+    DEVICE INTERFACE
+*****************************************************************************/
+
+static DEVICE_START( centronics )
+{
+	centronics_state *centronics = get_safe_token(device);
+	const centronics_interface *intf = (const centronics_interface *)device->static_config();
+
+	/* validate some basic stuff */
+	assert(device->static_config() != NULL);
+
+	/* set some initial values */
+	centronics->pe = FALSE;
+	centronics->fault = FALSE;
+	centronics->busy = TRUE;
+	centronics->strobe = TRUE;
+
+	/* get printer device */
+	centronics->printer = device->subdevice("printer");
+
+	/* resolve callbacks */
+	centronics->out_ack_func.resolve(intf->out_ack_func, *device);
+	centronics->out_busy_func.resolve(intf->out_busy_func, *device);
+	centronics->out_not_busy_func.resolve(intf->out_not_busy_func, *device);
+
+	/* register for state saving */
+	device->save_item(NAME(centronics->auto_fd));
+	device->save_item(NAME(centronics->strobe));
+	device->save_item(NAME(centronics->busy));
+	device->save_item(NAME(centronics->ack));
+	device->save_item(NAME(centronics->data));
+}
+
+static DEVICE_RESET( centronics )
+{
+}
+
+DEVICE_GET_INFO( centronics )
+{
+	switch (state)
+	{
+		/* --- the following bits of info are returned as 64-bit signed integers --- */
+		case DEVINFO_INT_TOKEN_BYTES:			info->i = sizeof(centronics_state);		break;
+		case DEVINFO_INT_INLINE_CONFIG_BYTES:	info->i = 0;							break;
+
+		/* --- the following bits of info are returned as pointers --- */
+		case DEVINFO_PTR_MACHINE_CONFIG:		info->machine_config = MACHINE_CONFIG_NAME(centronics);	break;
+
+		/* --- the following bits of info are returned as pointers to data or functions --- */
+		case DEVINFO_FCT_START:					info->start = DEVICE_START_NAME(centronics);		break;
+		case DEVINFO_FCT_STOP:					/* Nothing */										break;
+		case DEVINFO_FCT_RESET:					info->reset = DEVICE_RESET_NAME(centronics);		break;
+
+		/* --- the following bits of info are returned as NULL-terminated strings --- */
+		case DEVINFO_STR_NAME:					strcpy(info->s, "Centronics");			break;
+		case DEVINFO_STR_FAMILY:				strcpy(info->s, "Centronics");			break;
+		case DEVINFO_STR_VERSION:				strcpy(info->s, "1.0");					break;
+		case DEVINFO_STR_SOURCE_FILE:			strcpy(info->s, __FILE__);				break;
+		case DEVINFO_STR_CREDITS:				strcpy(info->s, "Copyright MESS Team");	break;
+	}
+}
+
+
+/***************************************************************************
+    IMPLEMENTATION
+***************************************************************************/
+
+/*-------------------------------------------------
+    centronics_printer_online - callback that
+    sets us busy when the printer goes offline
+-------------------------------------------------*/
+
+void centronics_printer_online(device_t *device, int state)
+{
+	centronics_state *centronics = get_safe_token(device->owner());
+
+	/* when going online, set PE and FAULT high and BUSY low */
+	centronics->pe = state;
+	centronics->fault = state;
+	centronics->busy = !state;
+}
+
+
+static TIMER_CALLBACK( ack_callback )
+{
+	centronics_state *centronics = (centronics_state *)ptr;
+
+	/* signal change */
+	centronics->out_ack_func(param);
+	centronics->ack = param;
+
+	if (param == FALSE)
+	{
+		/* data is now ready, output it */
+		printer_output(centronics->printer, centronics->data);
+
+		/* ready to receive more data, return BUSY to low */
+		machine.scheduler().timer_set(attotime::from_usec(7), FUNC(busy_callback), FALSE, ptr);
+	}
+}
+
+
+static TIMER_CALLBACK( busy_callback )
+{
+	centronics_state *centronics = (centronics_state *)ptr;
+
+	/* signal change */
+	centronics->out_busy_func(param);
+	centronics->out_not_busy_func(!param);
+	centronics->busy = param;
+
+	if (param == TRUE)
+	{
+		/* timer to turn ACK low to receive data */
+		machine.scheduler().timer_set(attotime::from_usec(10), FUNC(ack_callback), FALSE, ptr);
+	}
+	else
+	{
+		/* timer to return ACK to high state */
+		machine.scheduler().timer_set(attotime::from_usec(5), FUNC(ack_callback), TRUE, ptr);
+	}
+}
+
+
+/*-------------------------------------------------
+    centronics_data_w - write print data
+-------------------------------------------------*/
+
+WRITE8_DEVICE_HANDLER( centronics_data_w )
+{
+	centronics_state *centronics = get_safe_token(device);
+	centronics->data = data;
+}
+
+
+/*-------------------------------------------------
+    centronics_data_r - return current data
+-------------------------------------------------*/
+
+READ8_DEVICE_HANDLER( centronics_data_r )
+{
+	centronics_state *centronics = get_safe_token(device);
+	return centronics->data;
+}
+
+
+/*-------------------------------------------------
+    set_line - helper to set individual bits
+-------------------------------------------------*/
+
+static void set_line(device_t *device, int line, int state)
+{
+	centronics_state *centronics = get_safe_token(device);
+
+	if (state)
+		centronics->data |= 1 << line;
+	else
+		centronics->data &= ~(1 << line);
+}
+
+
+/*-------------------------------------------------
+    centronics_dx_w - write line dx print data
+-------------------------------------------------*/
+
+WRITE_LINE_DEVICE_HANDLER( centronics_d0_w ) { set_line(device, 0, state); }
+WRITE_LINE_DEVICE_HANDLER( centronics_d1_w ) { set_line(device, 1, state); }
+WRITE_LINE_DEVICE_HANDLER( centronics_d2_w ) { set_line(device, 2, state); }
+WRITE_LINE_DEVICE_HANDLER( centronics_d3_w ) { set_line(device, 3, state); }
+WRITE_LINE_DEVICE_HANDLER( centronics_d4_w ) { set_line(device, 4, state); }
+WRITE_LINE_DEVICE_HANDLER( centronics_d5_w ) { set_line(device, 5, state); }
+WRITE_LINE_DEVICE_HANDLER( centronics_d6_w ) { set_line(device, 6, state); }
+WRITE_LINE_DEVICE_HANDLER( centronics_d7_w ) { set_line(device, 7, state); }
+
+
+/*-------------------------------------------------
+    centronics_strobe_w - signal that data is
+    ready
+-------------------------------------------------*/
+
+WRITE_LINE_DEVICE_HANDLER( centronics_strobe_w )
+{
+	centronics_state *centronics = get_safe_token(device);
+
+	/* look for a high -> low transition */
+	if (centronics->strobe == TRUE && state == FALSE && centronics->busy == FALSE)
+	{
+		/* STROBE has gone low, data is ready */
+		device->machine().scheduler().timer_set(attotime::zero, FUNC(busy_callback), TRUE, centronics);
+	}
+
+	centronics->strobe = state;
+}
+
+
+/*-------------------------------------------------
+    centronics_prime_w - initialize and reset
+    printer (centronics mode)
+-------------------------------------------------*/
+
+WRITE_LINE_DEVICE_HANDLER( centronics_prime_w )
+{
+	assert(((const centronics_interface *)device->static_config())->is_ibmpc == FALSE);
+
+	/* reset printer if line is low */
+	if (state == FALSE)
+		DEVICE_RESET_CALL( centronics );
+}
+
+
+/*-------------------------------------------------
+    centronics_init_w - initialize and reset
+    printer (ibm mode)
+-------------------------------------------------*/
+
+WRITE_LINE_DEVICE_HANDLER( centronics_init_w )
+{
+	assert(((const centronics_interface *)device->static_config())->is_ibmpc == TRUE);
+
+	/* reset printer if line is low */
+	if (state == FALSE)
+		DEVICE_RESET_CALL( centronics );
+}
+
+
+/*-------------------------------------------------
+    centronics_autofeed_w - auto line feed
+-------------------------------------------------*/
+
+WRITE_LINE_DEVICE_HANDLER( centronics_autofeed_w )
+{
+	centronics_state *centronics = get_safe_token(device);
+	assert(((const centronics_interface *)device->static_config())->is_ibmpc == TRUE);
+
+	centronics->auto_fd = state;
+}
+
+
+/*-------------------------------------------------
+    centronics_ack_r - return the state of the
+    ack line
+-------------------------------------------------*/
+
+READ_LINE_DEVICE_HANDLER( centronics_ack_r )
+{
+	centronics_state *centronics = get_safe_token(device);
+	return centronics->ack;
+}
+
+
+/*-------------------------------------------------
+    centronics_busy_r - return the state of the
+    busy line
+-------------------------------------------------*/
+
+READ_LINE_DEVICE_HANDLER( centronics_busy_r )
+{
+	centronics_state *centronics = get_safe_token(device);
+	return centronics->busy;
+}
+
+
+/*-------------------------------------------------
+    centronics_pe_r - return the state of the
+    pe line
+-------------------------------------------------*/
+
+READ_LINE_DEVICE_HANDLER( centronics_pe_r )
+{
+	centronics_state *centronics = get_safe_token(device);
+	return centronics->pe;
+}
+
+
+/*-------------------------------------------------
+    centronics_not_busy_r - return the state of the
+    not busy line
+-------------------------------------------------*/
+
+READ_LINE_DEVICE_HANDLER( centronics_not_busy_r )
+{
+	centronics_state *centronics = get_safe_token(device);
+	return !centronics->busy;
+}
+
+
+/*-------------------------------------------------
+    centronics_vcc_r - return the state of the
+    vcc line
+-------------------------------------------------*/
+
+READ_LINE_DEVICE_HANDLER( centronics_vcc_r )
+{
+	/* always return high */
+	return TRUE;
+}
+
+
+/*-------------------------------------------------
+    centronics_fault_r - return the state of the
+    fault line
+-------------------------------------------------*/
+
+READ_LINE_DEVICE_HANDLER( centronics_fault_r )
+{
+	centronics_state *centronics = get_safe_token(device);
+	return centronics->fault;
+}
+
+DEFINE_LEGACY_DEVICE(CENTRONICS, centronics);

src/mame/machine/ctronics.h

@@ -0,0 +1,75 @@
+/***************************************************************************
+
+    Centronics printer interface
+
+***************************************************************************/
+
+#ifndef __CTRONICS_H__
+#define __CTRONICS_H__
+
+#include "devcb.h"
+
+
+/***************************************************************************
+    TYPE DEFINITIONS
+***************************************************************************/
+
+typedef struct _centronics_interface centronics_interface;
+struct _centronics_interface
+{
+	int is_ibmpc;
+
+	devcb_write_line out_ack_func;
+	devcb_write_line out_busy_func;
+	devcb_write_line out_not_busy_func;
+};
+
+
+/***************************************************************************
+    FUNCTION PROTOTYPES
+***************************************************************************/
+WRITE8_DEVICE_HANDLER( centronics_data_w );
+READ8_DEVICE_HANDLER( centronics_data_r );
+
+/* access to the individual bits */
+WRITE_LINE_DEVICE_HANDLER( centronics_d0_w );
+WRITE_LINE_DEVICE_HANDLER( centronics_d1_w );
+WRITE_LINE_DEVICE_HANDLER( centronics_d2_w );
+WRITE_LINE_DEVICE_HANDLER( centronics_d3_w );
+WRITE_LINE_DEVICE_HANDLER( centronics_d4_w );
+WRITE_LINE_DEVICE_HANDLER( centronics_d5_w );
+WRITE_LINE_DEVICE_HANDLER( centronics_d6_w );
+WRITE_LINE_DEVICE_HANDLER( centronics_d7_w );
+
+WRITE_LINE_DEVICE_HANDLER( centronics_strobe_w );
+WRITE_LINE_DEVICE_HANDLER( centronics_prime_w );
+WRITE_LINE_DEVICE_HANDLER( centronics_init_w );
+WRITE_LINE_DEVICE_HANDLER( centronics_autofeed_w );
+
+READ_LINE_DEVICE_HANDLER( centronics_ack_r );
+READ_LINE_DEVICE_HANDLER( centronics_busy_r );
+READ_LINE_DEVICE_HANDLER( centronics_pe_r );
+READ_LINE_DEVICE_HANDLER( centronics_not_busy_r );
+READ_LINE_DEVICE_HANDLER( centronics_vcc_r );
+READ_LINE_DEVICE_HANDLER( centronics_fault_r );
+
+
+/***************************************************************************
+    DEVICE CONFIGURATION MACROS
+***************************************************************************/
+
+DECLARE_LEGACY_DEVICE(CENTRONICS, centronics);
+
+#define MCFG_CENTRONICS_ADD(_tag, _intf) \
+	MCFG_DEVICE_ADD(_tag, CENTRONICS, 0) \
+	MCFG_DEVICE_CONFIG(_intf)
+
+
+/***************************************************************************
+    DEFAULT INTERFACES
+***************************************************************************/
+
+extern const centronics_interface standard_centronics;
+
+
+#endif /* __CTRONICS_H__ */

src/mame/machine/dccons.c

@@ -0,0 +1,725 @@
+/*
+
+    dc.c - Sega Dreamcast hardware
+
+    MESS (DC home console) hardware overrides (GD-ROM drive etc)
+
+    c230048 - 5 is written, want 6
+    c0d9d9e - where bad happens, from routine @ c0da260
+
+    c0d9d8e - R0 on return is the value to put in
+
+    cfffee0 - stack location when bad happens
+
+*/
+
+#include "emu.h"
+#include "cdrom.h"
+#include "debugger.h"
+#include "includes/dc.h"
+#include "cpu/sh4/sh4.h"
+#include "sound/aica.h"
+#include "includes/naomi.h"
+#include "machine/gdrom.h"
+#include "imagedev/chd_cd.h"
+
+#define ATAPI_CYCLES_PER_SECTOR (5000)	// TBD for Dreamcast
+
+#define ATAPI_STAT_BSY	   0x80
+#define ATAPI_STAT_DRDY    0x40
+#define ATAPI_STAT_DMARDDF 0x20
+#define ATAPI_STAT_SERVDSC 0x10
+#define ATAPI_STAT_DRQ     0x08
+#define ATAPI_STAT_CORR    0x04
+#define ATAPI_STAT_CHECK   0x01
+
+#define ATAPI_INTREASON_COMMAND 0x01
+#define ATAPI_INTREASON_IO      0x02
+#define ATAPI_INTREASON_RELEASE 0x04
+
+#define ATAPI_REG_DATA		0
+#define ATAPI_REG_FEATURES	1
+#define ATAPI_REG_INTREASON	2
+#define ATAPI_REG_SAMTAG	3
+#define ATAPI_REG_COUNTLOW	4
+#define ATAPI_REG_COUNTHIGH	5
+#define ATAPI_REG_DRIVESEL	6
+#define ATAPI_REG_CMDSTATUS	7
+#define ATAPI_REG_ERROR		16	// read-only ERROR (write is FEATURES)
+
+#define ATAPI_REG_MAX 24
+
+#define ATAPI_XFER_PIO		0x00
+#define ATAPI_XFER_PIO_FLOW	0x08
+#define ATAPI_XFER_MULTI_DMA	0x20
+#define ATAPI_XFER_ULTRA_DMA	0x40
+
+#define ATAPI_DATA_SIZE ( 64 * 1024 )
+
+static UINT8 *atapi_regs;
+static emu_timer *atapi_timer;
+static SCSIInstance *gdrom_device;
+static UINT8 *atapi_data;
+static int atapi_data_ptr, atapi_data_len, atapi_xferlen, atapi_xferbase, atapi_cdata_wait, atapi_xfermod;
+static UINT32 gdrom_alt_status;
+static UINT8 xfer_mode = ATAPI_XFER_PIO;
+
+#define MAX_TRANSFER_SIZE ( 63488 )
+
+extern UINT32 dc_sysctrl_regs[0x200/4];
+
+extern UINT32 g1bus_regs[0x100/4];
+
+static void gdrom_raise_irq(running_machine &machine)
+{
+	dc_sysctrl_regs[SB_ISTEXT] |= IST_EXT_GDROM;
+	dc_update_interrupt_status(machine);
+}
+
+static TIMER_CALLBACK( atapi_xfer_end )
+{
+	UINT8 sector_buffer[ 4096 ];
+
+	atapi_timer->adjust(attotime::never);
+
+	printf("atapi_xfer_end atapi_xferlen = %d, atapi_xfermod=%d\n", atapi_xfermod, atapi_xferlen );
+
+	mame_printf_debug("ATAPI: xfer_end.  xferlen = %d, atapi_xfermod = %d\n", atapi_xferlen, atapi_xfermod);
+
+	while (atapi_xferlen > 0 )
+	{
+		struct sh4_ddt_dma ddtdata;
+
+		// get a sector from the SCSI device
+		SCSIReadData( gdrom_device, sector_buffer, 2048 );
+
+		atapi_xferlen -= 2048;
+
+		// perform the DMA
+		ddtdata.destination = atapi_xferbase;	// destination address
+		ddtdata.length = 2048/4;
+		ddtdata.size = 4;
+		ddtdata.buffer = sector_buffer;
+		ddtdata.direction=1;	// 0 source to buffer, 1 buffer to destination
+		ddtdata.channel= -1;	// not used
+		ddtdata.mode= -1;		// copy from/to buffer
+		printf("ATAPI: DMA one sector to %x, %x remaining\n", atapi_xferbase, atapi_xferlen);
+		sh4_dma_ddt(machine.device("maincpu"), &ddtdata);
+
+		atapi_xferbase += 2048;
+	}
+
+	if (atapi_xfermod > MAX_TRANSFER_SIZE)
+	{
+		atapi_xferlen = MAX_TRANSFER_SIZE;
+		atapi_xfermod = atapi_xfermod - MAX_TRANSFER_SIZE;
+	}
+	else
+	{
+		atapi_xferlen = atapi_xfermod;
+		atapi_xfermod = 0;
+	}
+
+	if (atapi_xferlen > 0)
+	{
+		printf("ATAPI: starting next piece of multi-part transfer\n");
+		atapi_regs[ATAPI_REG_COUNTLOW] = atapi_xferlen & 0xff;
+		atapi_regs[ATAPI_REG_COUNTHIGH] = (atapi_xferlen>>8)&0xff;
+
+		atapi_timer->adjust(machine.device<cpu_device>("maincpu")->cycles_to_attotime((ATAPI_CYCLES_PER_SECTOR * (atapi_xferlen/2048))));
+	}
+	else
+	{
+		printf("ATAPI: Transfer completed, dropping DRQ\n");
+		atapi_regs[ATAPI_REG_CMDSTATUS] = ATAPI_STAT_DRDY;
+		gdrom_alt_status = ATAPI_STAT_DRDY;
+		atapi_regs[ATAPI_REG_INTREASON] = ATAPI_INTREASON_IO | ATAPI_INTREASON_COMMAND;
+
+		g1bus_regs[SB_GDST]=0;
+		dc_sysctrl_regs[SB_ISTNRM] |= IST_DMA_GDROM;
+		dc_update_interrupt_status(machine);
+	}
+
+	gdrom_raise_irq(machine);
+
+	printf( "atapi_xfer_end: %d %d\n", atapi_xferlen, atapi_xfermod );
+}
+
+static READ32_HANDLER( atapi_r )
+{
+	running_machine &machine = space->machine();
+	int reg, data;
+
+	if (mem_mask == 0x0000ffff)	// word-wide command read
+	{
+//      mame_printf_debug("ATAPI: packet read = %04x\n", atapi_data[atapi_data_ptr]);
+
+		// assert IRQ and drop DRQ
+		if (atapi_data_ptr == 0 && atapi_data_len == 0)
+		{
+			// get the data from the device
+			if( atapi_xferlen > 0 )
+			{
+				SCSIReadData( gdrom_device, atapi_data, atapi_xferlen );
+				atapi_data_len = atapi_xferlen;
+			}
+
+			if (atapi_xfermod > MAX_TRANSFER_SIZE)
+			{
+				atapi_xferlen = MAX_TRANSFER_SIZE;
+				atapi_xfermod = atapi_xfermod - MAX_TRANSFER_SIZE;
+			}
+			else
+			{
+				atapi_xferlen = atapi_xfermod;
+				atapi_xfermod = 0;
+			}
+
+//          printf( "atapi_r: atapi_xferlen=%d\n", atapi_xferlen );
+			if( atapi_xferlen != 0 )
+			{
+				atapi_regs[ATAPI_REG_CMDSTATUS] = ATAPI_STAT_DRQ | ATAPI_STAT_SERVDSC;
+				gdrom_alt_status = ATAPI_STAT_DRQ | ATAPI_STAT_SERVDSC;
+				atapi_regs[ATAPI_REG_INTREASON] = ATAPI_INTREASON_IO;
+			}
+			else
+			{
+				//mame_printf_debug("ATAPI: dropping DRQ\n");
+				atapi_regs[ATAPI_REG_CMDSTATUS] = 0;
+				gdrom_alt_status = 0;
+				atapi_regs[ATAPI_REG_INTREASON] = ATAPI_INTREASON_IO;
+			}
+
+			atapi_regs[ATAPI_REG_COUNTLOW] = atapi_xferlen & 0xff;
+			atapi_regs[ATAPI_REG_COUNTHIGH] = (atapi_xferlen>>8)&0xff;
+
+			gdrom_raise_irq(machine);
+		}
+
+		if( atapi_data_ptr < atapi_data_len )
+		{
+			data = atapi_data[atapi_data_ptr++];
+			data |= ( atapi_data[atapi_data_ptr++] << 8 );
+			if( atapi_data_ptr >= atapi_data_len )
+			{
+//              printf( "atapi_r: read all bytes\n" );
+				atapi_data_ptr = 0;
+				atapi_data_len = 0;
+
+				if( atapi_xferlen == 0 )
+				{
+					atapi_regs[ATAPI_REG_CMDSTATUS] = 0;
+					gdrom_alt_status = 0;
+					atapi_regs[ATAPI_REG_INTREASON] = ATAPI_INTREASON_IO;
+					gdrom_raise_irq(machine);
+				}
+			}
+		}
+		else
+		{
+			data = 0;
+		}
+	}
+	else
+	{
+		reg = offset;
+
+		// get read-only side of read-only/write-only registers from elsewhere
+		if (reg == ATAPI_REG_FEATURES)
+		{
+			reg = ATAPI_REG_ERROR;
+		}
+		data = atapi_regs[reg];
+
+		#if 0
+		switch( reg )
+		{
+		case ATAPI_REG_DATA:
+			printf( "atapi_r: data=%02x\n", data );
+			break;
+		case ATAPI_REG_ERROR:
+			printf( "atapi_r: error=%02x\n", data );
+			break;
+		case ATAPI_REG_INTREASON:
+			printf( "atapi_r: intreason=%02x\n", data );
+			break;
+		case ATAPI_REG_SAMTAG:
+			printf( "atapi_r: samtag=%02x\n", data );
+			break;
+		case ATAPI_REG_COUNTLOW:
+			printf( "atapi_r: countlow=%02x\n", data );
+			break;
+		case ATAPI_REG_COUNTHIGH:
+			printf( "atapi_r: counthigh=%02x\n", data );
+			break;
+		case ATAPI_REG_DRIVESEL:
+			printf( "atapi_r: drivesel=%02x\n", data );
+			break;
+		case ATAPI_REG_CMDSTATUS:
+			printf( "atapi_r: cmdstatus=%02x\n", data );
+			break;
+		}
+		#endif
+
+		mame_printf_debug("ATAPI: read reg %d = %x (PC=%x)\n", reg, data, cpu_get_pc(&space->device()));
+	}
+
+//  printf( "atapi_r( %08x, %08x ) %08x\n", offset, mem_mask, data );
+	return data;
+}
+
+static WRITE32_HANDLER( atapi_w )
+{
+	running_machine &machine = space->machine();
+	int reg;
+
+//  printf( "atapi_w( %08x, %08x, %08x )\n", offset, mem_mask, data );
+
+	if (mem_mask == 0x0000ffff)	// word-wide command write
+	{
+//      printf("atapi_w: data=%04x\n", data );
+
+//      printf("ATAPI: packet write %04x\n", data);
+		atapi_data[atapi_data_ptr++] = data & 0xff;
+		atapi_data[atapi_data_ptr++] = data >> 8;
+
+		if (atapi_cdata_wait)
+		{
+//                  printf("ATAPI: waiting, ptr %d wait %d\n", atapi_data_ptr, atapi_cdata_wait);
+			if (atapi_data_ptr == atapi_cdata_wait)
+			{
+				// send it to the device
+				SCSIWriteData( gdrom_device, atapi_data, atapi_cdata_wait );
+
+				// assert IRQ
+				gdrom_raise_irq(machine);
+
+				// not sure here, but clear DRQ at least?
+				atapi_regs[ATAPI_REG_CMDSTATUS] = 0;
+			}
+		}
+
+		else if ( atapi_data_ptr == 12 )
+		{
+			int phase;
+
+//          printf("atapi_w: command %02x\n", atapi_data[0]&0xff );
+
+			// reset data pointer for reading SCSI results
+			atapi_data_ptr = 0;
+			atapi_data_len = 0;
+
+			// send it to the SCSI device
+			SCSISetCommand( gdrom_device, atapi_data, 12 );
+			SCSIExecCommand( gdrom_device, &atapi_xferlen );
+			SCSIGetPhase( gdrom_device, &phase );
+
+			if (atapi_xferlen != -1)
+			{
+				printf("ATAPI: SCSI command %02x returned %d bytes from the device\n", atapi_data[0]&0xff, atapi_xferlen);
+
+				// store the returned command length in the ATAPI regs, splitting into
+				// multiple transfers if necessary
+				atapi_xfermod = 0;
+				if (atapi_xferlen > MAX_TRANSFER_SIZE)
+				{
+					atapi_xfermod = atapi_xferlen - MAX_TRANSFER_SIZE;
+					atapi_xferlen = MAX_TRANSFER_SIZE;
+				}
+
+				atapi_regs[ATAPI_REG_COUNTLOW] = atapi_xferlen & 0xff;
+				atapi_regs[ATAPI_REG_COUNTHIGH] = (atapi_xferlen>>8)&0xff;
+
+				gdrom_alt_status = 0;	// (I guess?)
+
+				if (atapi_xferlen == 0)
+				{
+					// if no data to return, set the registers properly
+					atapi_regs[ATAPI_REG_CMDSTATUS] = ATAPI_STAT_DRDY;
+					atapi_regs[ATAPI_REG_INTREASON] = ATAPI_INTREASON_IO|ATAPI_INTREASON_COMMAND;
+				}
+				else
+				{
+					// indicate data ready: set DRQ and DMA ready, and IO in INTREASON
+					if (atapi_regs[ATAPI_REG_FEATURES] & 0x01)	// DMA feature
+					{
+						atapi_regs[ATAPI_REG_CMDSTATUS] = ATAPI_STAT_BSY | ATAPI_STAT_DRDY | ATAPI_STAT_SERVDSC;
+					}
+					else
+					{
+						atapi_regs[ATAPI_REG_CMDSTATUS] = ATAPI_STAT_DRQ | ATAPI_STAT_SERVDSC | ATAPI_STAT_DRQ;
+					}
+					atapi_regs[ATAPI_REG_INTREASON] = ATAPI_INTREASON_IO;
+				}
+
+				switch( phase )
+				{
+				case SCSI_PHASE_DATAOUT:
+					atapi_cdata_wait = atapi_xferlen;
+					break;
+				}
+
+				// perform special ATAPI processing of certain commands
+				switch (atapi_data[0]&0xff)
+				{
+					case 0x00: // BUS RESET / TEST UNIT READY
+					case 0xbb: // SET CDROM SPEED
+						atapi_regs[ATAPI_REG_CMDSTATUS] = 0;
+						break;
+
+					case 0x45: // PLAY
+						atapi_regs[ATAPI_REG_CMDSTATUS] = ATAPI_STAT_BSY;
+						atapi_timer->adjust( downcast<cpu_device *>(&space->device())->cycles_to_attotime(ATAPI_CYCLES_PER_SECTOR ) );
+						break;
+				}
+
+				// assert IRQ
+				gdrom_raise_irq(machine);
+			}
+			else
+			{
+            			printf("ATAPI: SCSI device returned error!\n");
+
+				atapi_regs[ATAPI_REG_CMDSTATUS] = ATAPI_STAT_DRQ | ATAPI_STAT_CHECK;
+				atapi_regs[ATAPI_REG_ERROR] = 0x50;	// sense key = ILLEGAL REQUEST
+				atapi_regs[ATAPI_REG_COUNTLOW] = 0;
+				atapi_regs[ATAPI_REG_COUNTHIGH] = 0;
+			}
+		}
+	}
+	else
+	{
+		reg = offset;
+#if 0
+		switch( reg )
+		{
+		case ATAPI_REG_DATA:
+			printf( "atapi_w: data=%02x\n", data );
+	    		break;
+	    	case ATAPI_REG_FEATURES:
+			printf( "atapi_w: features=%02x\n", data );
+	    		break;
+	    	case ATAPI_REG_INTREASON:
+			printf( "atapi_w: intreason=%02x\n", data );
+	    		break;
+	    	case ATAPI_REG_SAMTAG:
+			printf( "atapi_w: samtag=%02x\n", data );
+	    		break;
+	    	case ATAPI_REG_COUNTLOW:
+			printf( "atapi_w: countlow=%02x\n", data );
+	    		break;
+	    	case ATAPI_REG_COUNTHIGH:
+			printf( "atapi_w: counthigh=%02x\n", data );
+	    		break;
+	    	case ATAPI_REG_DRIVESEL:
+			printf( "atapi_w: drivesel=%02x\n", data );
+	    		break;
+	    	case ATAPI_REG_CMDSTATUS:
+			printf( "atapi_w: cmdstatus=%02x\n", data );
+			break;
+		}
+#endif
+		atapi_regs[reg] = data;
+//      mame_printf_debug("ATAPI: reg %d = %x (offset %x mask %x PC=%x)\n", reg, data, offset, mem_mask, cpu_get_pc(&space->device()));
+
+		if (reg == ATAPI_REG_CMDSTATUS)
+		{
+			printf("ATAPI command %x issued! (PC=%x)\n", data, cpu_get_pc(&space->device()));
+
+			switch (data)
+			{
+				case 0xa0:	// PACKET
+					atapi_regs[ATAPI_REG_CMDSTATUS] = ATAPI_STAT_DRQ;
+					gdrom_alt_status = ATAPI_STAT_DRQ;
+					atapi_regs[ATAPI_REG_INTREASON] = ATAPI_INTREASON_COMMAND;
+
+					atapi_data_ptr = 0;
+					atapi_data_len = 0;
+
+					/* we have no data */
+					atapi_xferlen = 0;
+					atapi_xfermod = 0;
+
+					atapi_cdata_wait = 0;
+					break;
+
+				case 0xa1:	// IDENTIFY PACKET DEVICE
+					atapi_regs[ATAPI_REG_CMDSTATUS] = ATAPI_STAT_DRQ;
+					gdrom_alt_status = ATAPI_STAT_DRQ;
+
+					atapi_data_ptr = 0;
+					atapi_data_len = 512;
+
+					/* we have no data */
+					atapi_xferlen = 0;
+					atapi_xfermod = 0;
+
+					memset( atapi_data, 0, atapi_data_len );
+
+					atapi_data[ 0 ^ 1 ] = 0x86;	// ATAPI device, cmd set 6 compliant, DRQ within 3 ms of PACKET command
+					atapi_data[ 1 ^ 1 ] = 0x00;
+
+					memset( &atapi_data[ 46 ], ' ', 8 );
+					atapi_data[ 46 ^ 1 ] = 'S';
+					atapi_data[ 47 ^ 1 ] = 'E';
+
+					memset( &atapi_data[ 54 ], ' ', 40 );
+					atapi_data[ 54 ^ 1 ] = 'C';
+					atapi_data[ 55 ^ 1 ] = 'D';
+					atapi_data[ 56 ^ 1 ] = '-';
+					atapi_data[ 57 ^ 1 ] = 'R';
+					atapi_data[ 58 ^ 1 ] = 'O';
+					atapi_data[ 59 ^ 1 ] = 'M';
+					atapi_data[ 60 ^ 1 ] = ' ';
+					atapi_data[ 61 ^ 1 ] = 'D';
+					atapi_data[ 62 ^ 1 ] = 'R';
+					atapi_data[ 63 ^ 1 ] = 'I';
+					atapi_data[ 64 ^ 1 ] = 'V';
+					atapi_data[ 65 ^ 1 ] = 'E';
+					atapi_data[ 66 ^ 1 ] = ' ';
+					atapi_data[ 67 ^ 1 ] = ' ';
+					atapi_data[ 68 ^ 1 ] = ' ';
+					atapi_data[ 69 ^ 1 ] = ' ';
+					atapi_data[ 70 ^ 1 ] = '6';
+					atapi_data[ 71 ^ 1 ] = '.';
+					atapi_data[ 72 ^ 1 ] = '4';
+					atapi_data[ 73 ^ 1 ] = '2';
+
+					atapi_data[ 98 ^ 1 ] = 0x04; // IORDY may be disabled
+					atapi_data[ 99 ^ 1 ] = 0x00;
+
+					atapi_regs[ATAPI_REG_COUNTLOW] = 0;
+					atapi_regs[ATAPI_REG_COUNTHIGH] = 2;
+
+					gdrom_raise_irq(space->machine());
+					break;
+
+				case 0xef:	// SET FEATURES
+					// set xfer mode?
+					if (atapi_regs[ATAPI_REG_FEATURES] == 0x03)
+					{
+						printf("Set transfer mode to %x\n", atapi_regs[ATAPI_REG_COUNTLOW] & 0xf8);
+						xfer_mode = atapi_regs[ATAPI_REG_COUNTLOW] & 0xf8;
+					}
+					else
+					{
+						printf("ATAPI: Unknown set features %x\n", atapi_regs[ATAPI_REG_FEATURES]);
+					}
+
+					atapi_regs[ATAPI_REG_CMDSTATUS] = 0;
+					gdrom_alt_status = 0;	// is this correct?
+
+					atapi_data_ptr = 0;
+					atapi_data_len = 0;
+
+					gdrom_raise_irq(space->machine());
+					break;
+
+				default:
+					mame_printf_debug("ATAPI: Unknown IDE command %x\n", data);
+					break;
+			}
+		}
+	}
+}
+
+static void dreamcast_atapi_exit(running_machine& machine)
+{
+	if (gdrom_device != NULL)
+	{
+		SCSIDeleteInstance( gdrom_device );
+	}
+}
+
+void dreamcast_atapi_init(running_machine &machine)
+{
+	atapi_regs = auto_alloc_array(machine, UINT8,  ATAPI_REG_MAX );
+	memset(atapi_regs, 0, sizeof(atapi_regs));
+
+	atapi_regs[ATAPI_REG_CMDSTATUS] = 0;
+	atapi_regs[ATAPI_REG_ERROR] = 1;
+	atapi_regs[ATAPI_REG_COUNTLOW] = 0x14;
+	atapi_regs[ATAPI_REG_COUNTHIGH] = 0xeb;
+
+	atapi_data_ptr = 0;
+	atapi_data_len = 0;
+	atapi_cdata_wait = 0;
+
+	atapi_timer = machine.scheduler().timer_alloc(FUNC(atapi_xfer_end));
+	atapi_timer->adjust(attotime::never);
+
+	gdrom_device = NULL;
+
+	machine.add_notifier(MACHINE_NOTIFY_EXIT, machine_notify_delegate(FUNC(dreamcast_atapi_exit),&machine));
+
+	atapi_data = auto_alloc_array(machine, UINT8,  ATAPI_DATA_SIZE );
+
+	state_save_register_global_pointer(machine,  atapi_regs, ATAPI_REG_MAX );
+	state_save_register_global_pointer(machine,  atapi_data, ATAPI_DATA_SIZE / 2 );
+	state_save_register_global(machine,  atapi_data_ptr );
+	state_save_register_global(machine,  atapi_data_len );
+	state_save_register_global(machine,  atapi_xferlen );
+	state_save_register_global(machine,  atapi_xferbase );
+	state_save_register_global(machine,  atapi_cdata_wait );
+	state_save_register_global(machine,  atapi_xfermod );
+}
+
+void dreamcast_atapi_reset(running_machine &machine)
+{
+	atapi_regs[ATAPI_REG_CMDSTATUS] = 0;
+	atapi_regs[ATAPI_REG_ERROR] = 1;
+	atapi_regs[ATAPI_REG_COUNTLOW] = 0x14;
+	atapi_regs[ATAPI_REG_COUNTHIGH] = 0xeb;
+
+	atapi_data_ptr = 0;
+	atapi_data_len = 0;
+	atapi_cdata_wait = 0;
+
+	atapi_xferlen = 0;
+	atapi_xfermod = 0;
+
+	if ( cd_get_cdrom_file(machine.device( "cdrom" )) != NULL )
+	{
+		SCSIAllocInstance( machine, &SCSIClassGDROM, &gdrom_device, "cdrom" );
+	}
+	else
+	{
+		gdrom_device = NULL;
+	}
+}
+
+/*
+
+ GDROM regsters:
+
+ 5f7018: alternate status/device control
+ 5f7080: data
+ 5f7084: error/features
+ 5f7088: interrupt reason/sector count
+ 5f708c: sector number
+ 5f7090: byte control low
+ 5f7094: byte control high
+ 5f7098: drive select
+ 5f709c: status/command
+
+c002910 - ATAPI packet writes
+c002796 - aux status read after that
+c000776 - DMA triggered to c008000
+
+*/
+
+READ64_HANDLER( dc_mess_gdrom_r )
+{
+	UINT32 off;
+
+	if ((int)~mem_mask & 1)
+	{
+		off=(offset << 1) | 1;
+	}
+	else
+	{
+		off=offset << 1;
+	}
+
+//  printf("gdrom_r: @ %x (off %x), mask %llx (PC %x)\n", offset, off, mem_mask, cpu_get_pc(&space->device()));
+
+	if (offset == 3)
+	{
+		return gdrom_alt_status;
+	}
+	else if (off >= 0x20)
+	{
+		return atapi_r(space, off-0x20, 0xff);
+	}
+
+	return 0;
+}
+
+WRITE64_HANDLER( dc_mess_gdrom_w )
+{
+	UINT32 dat,off;
+
+	if ((int)~mem_mask & 1)
+	{
+		dat=(UINT32)(data >> 32);
+		off=(offset << 1) | 1;
+	}
+	else
+	{
+		dat=(UINT32)data;
+		off=offset << 1;
+	}
+
+//  printf("GDROM: [%08x=%x]write %llx to %x, mask %llx (PC %x)\n", 0x5f7000+off*4, dat, data, offset, mem_mask, cpu_get_pc(&space->device()));
+
+	if (off >= 0x20)
+	{
+		atapi_w(space, off-0x20, dat, (UINT32)mem_mask);
+	}
+}
+
+// register decode helpers
+
+// this accepts only 32-bit accesses
+INLINE int decode_reg32_64(running_machine &machine, UINT32 offset, UINT64 mem_mask, UINT64 *shift)
+{
+	int reg = offset * 2;
+
+	*shift = 0;
+
+	// non 32-bit accesses have not yet been seen here, we need to know when they are
+	if ((mem_mask != U64(0xffffffff00000000)) && (mem_mask != U64(0x00000000ffffffff)))
+	{
+		mame_printf_verbose("%s:Wrong mask!\n", machine.describe_context());
+//      debugger_break(machine);
+	}
+
+	if (mem_mask == U64(0xffffffff00000000))
+	{
+		reg++;
+		*shift = 32;
+	}
+
+	return reg;
+}
+
+READ64_HANDLER( dc_mess_g1_ctrl_r )
+{
+	int reg;
+	UINT64 shift;
+
+	reg = decode_reg32_64(space->machine(), offset, mem_mask, &shift);
+	mame_printf_verbose("G1CTRL:  Unmapped read %08x\n", 0x5f7400+reg*4);
+	return (UINT64)g1bus_regs[reg] << shift;
+}
+
+WRITE64_HANDLER( dc_mess_g1_ctrl_w )
+{
+	int reg;
+	UINT64 shift;
+	UINT32 old,dat;
+
+	reg = decode_reg32_64(space->machine(), offset, mem_mask, &shift);
+	dat = (UINT32)(data >> shift);
+	old = g1bus_regs[reg];
+
+	g1bus_regs[reg] = dat; // 5f7400+reg*4=dat
+	mame_printf_verbose("G1CTRL: [%08x=%x] write %" I64FMT "x to %x, mask %" I64FMT "x\n", 0x5f7400+reg*4, dat, data, offset, mem_mask);
+	switch (reg)
+	{
+	case SB_GDST:
+		if (dat & 1 && g1bus_regs[SB_GDEN] == 1) // 0 -> 1
+		{
+			if (g1bus_regs[SB_GDDIR] == 0)
+			{
+				printf("G1CTRL: unsupported transfer\n");
+				return;
+			}
+
+			atapi_xferbase = g1bus_regs[SB_GDSTAR];
+			atapi_timer->adjust(space->machine().device<cpu_device>("maincpu")->cycles_to_attotime((ATAPI_CYCLES_PER_SECTOR * (atapi_xferlen/2048))));
+		}
+		break;
+	}
+}
+

src/mame/machine/gdrom.c

@@ -0,0 +1,874 @@
+/***************************************************************************
+
+ gdrom.c - Implementation of the Sega GD-ROM device
+
+***************************************************************************/
+
+#include "emu.h"
+#include "machine/scsidev.h"
+#include "cdrom.h"
+#include "sound/cdda.h"
+#include "imagedev/chd_cd.h"
+#include "gdrom.h"
+
+typedef struct
+{
+	UINT32 lba;
+	UINT32 blocks;
+	UINT32 last_lba;
+	UINT32 bytes_per_sector;
+	UINT32 num_subblocks;
+	UINT32 cur_subblock;
+	UINT32 play_err_flag;
+	UINT32 read_type;	// for command 0x30 only
+	UINT32 data_select;	// for command 0x30 only
+	cdrom_file *cdrom;
+	bool is_file;
+} SCSIGd;
+
+static const UINT8 GDROM_Cmd11_Reply[32] =
+{
+	0x00, 0x00, 0x00, 0x00, 0x00, 0xB4, 0x19, 0x00, 0x00, 0x08, 0x53, 0x45, 0x20, 0x20, 0x20, 0x20,
+	0x20, 0x20, 0x52, 0x65, 0x76, 0x20, 0x36, 0x2E, 0x34, 0x32, 0x39, 0x39, 0x30, 0x33, 0x31, 0x36
+};
+
+static void phys_frame_to_msf(int phys_frame, int *m, int *s, int *f)
+{
+	*m = phys_frame / (60*75);
+	phys_frame -= (*m * 60 * 75);
+	*s = phys_frame / 75;
+	*f = phys_frame % 75;
+}
+
+
+// scsicd_exec_command
+//
+// Execute a SCSI command.
+
+static int scsicd_exec_command( SCSIInstance *scsiInstance, UINT8 *statusCode )
+{
+	UINT8 *command;
+	int commandLength;
+	SCSIGd *our_this = (SCSIGd *)SCSIThis( &SCSIClassGDROM, scsiInstance );
+
+	cdrom_file *cdrom = our_this->cdrom;
+	device_t *cdda;
+	int trk;
+
+	SCSIGetCommand( scsiInstance, &command, &commandLength );
+
+	switch ( command[0] )
+	{
+
+
+		case 0x03: // REQUEST SENSE
+			SCSISetPhase( scsiInstance, SCSI_PHASE_DATAIN );
+			return SCSILengthFromUINT8( &command[ 4 ] );
+
+		case 0x11: // REQ_MODE
+			SCSISetPhase( scsiInstance, SCSI_PHASE_DATAIN );
+			printf("REQ_MODE %02x %02x %02x %02x %02x %02x\n",
+				command[0], command[1],
+				command[2], command[3],
+				command[4], command[5]);
+//          if (SCSILengthFromUINT8( &command[ 4 ] ) < 32) return -1;
+			return 32; //SCSILengthFromUINT8( &command[ 4 ] );
+
+		case 0x12: // INQUIRY
+			logerror("GDROM: REQUEST SENSE\n");
+			SCSISetPhase( scsiInstance, SCSI_PHASE_DATAIN );
+			return SCSILengthFromUINT8( &command[ 4 ] );
+
+		case 0x15: // MODE SELECT(6)
+			logerror("GDROM: MODE SELECT(6) length %x control %x\n", command[4], command[5]);
+			SCSISetPhase( scsiInstance, SCSI_PHASE_DATAOUT );
+			return SCSILengthFromUINT8( &command[ 4 ] );
+
+		case 0x1a: // MODE SENSE(6)
+			SCSISetPhase( scsiInstance, SCSI_PHASE_DATAIN );
+			return SCSILengthFromUINT8( &command[ 4 ] );
+
+		case 0x1b: // START STOP UNIT
+			cdda = cdda_from_cdrom(scsiInstance->machine(), cdrom);
+			if (cdda != NULL)
+			{
+				cdda_stop_audio(cdda);
+			}
+			SCSISetPhase( scsiInstance, SCSI_PHASE_STATUS );
+			return 0;
+
+		case 0x1e: // PREVENT ALLOW MEDIUM REMOVAL
+			SCSISetPhase( scsiInstance, SCSI_PHASE_STATUS );
+			return 0;
+
+		case 0x25: // READ CAPACITY
+			SCSISetPhase( scsiInstance, SCSI_PHASE_DATAIN );
+			return 8;
+
+		case 0x28: // READ(10)
+
+			our_this->lba = command[2]<<24 | command[3]<<16 | command[4]<<8 | command[5];
+			our_this->blocks = SCSILengthFromUINT16( &command[7] );
+
+			logerror("GDROM: READ(10) at LBA %x for %d blocks (%d bytes)\n", our_this->lba, our_this->blocks, our_this->blocks * our_this->bytes_per_sector);
+
+			if (our_this->num_subblocks > 1)
+			{
+				our_this->cur_subblock = our_this->lba % our_this->num_subblocks;
+				our_this->lba /= our_this->num_subblocks;
+			}
+			else
+			{
+				our_this->cur_subblock = 0;
+			}
+
+			cdda = cdda_from_cdrom(scsiInstance->machine(), cdrom);
+			if (cdda != NULL)
+			{
+				cdda_stop_audio(cdda);
+			}
+
+			SCSISetPhase( scsiInstance, SCSI_PHASE_DATAIN );
+			return our_this->blocks * our_this->bytes_per_sector;
+
+		case 0x30: // CD_READ
+			if (command[1] & 1)
+			{
+				fatalerror("GDROM: MSF mode used for CD_READ, unsupported");
+				return 0;
+			}
+			else
+			{
+				our_this->lba = (command[2]<<16 | command[3]<<8 | command[4]) - 150;
+				our_this->blocks = command[8]<<16 | command[9]<<8 | command[10];
+
+				our_this->read_type = (command[1] >> 1) & 7;
+				our_this->data_select = (command[1]>>4) & 0xf;
+
+				if (our_this->read_type != 2)	// mode 1
+				{
+					fatalerror("GDROM: Unhandled read_type %d", our_this->read_type);
+				}
+
+				if (our_this->data_select != 2)	// just sector data
+				{
+					fatalerror("GDROM: Unhandled data_select %d", our_this->data_select);
+				}
+
+				printf("GDROM: CD_READ at LBA %x for %d blocks (%d bytes, read type %d, data select %d)\n", our_this->lba, our_this->blocks, our_this->blocks * our_this->bytes_per_sector, our_this->read_type, our_this->data_select);
+
+				if (our_this->num_subblocks > 1)
+				{
+					our_this->cur_subblock = our_this->lba % our_this->num_subblocks;
+					our_this->lba /= our_this->num_subblocks;
+				}
+				else
+				{
+					our_this->cur_subblock = 0;
+				}
+
+				cdda = cdda_from_cdrom(scsiInstance->machine(), cdrom);
+				if (cdda != NULL)
+				{
+					cdda_stop_audio(cdda);
+				}
+
+				SCSISetPhase( scsiInstance, SCSI_PHASE_DATAIN );
+				return our_this->blocks * our_this->bytes_per_sector;
+			}
+
+		case 0x42: // READ SUB-CHANNEL
+//                      logerror("GDROM: READ SUB-CHANNEL type %d\n", command[3]);
+			SCSISetPhase( scsiInstance, SCSI_PHASE_DATAIN );
+			return SCSILengthFromUINT16( &command[ 7 ] );
+
+		case 0x43: // READ TOC
+		{
+			int start_trk = command[6];
+			int end_trk = cdrom_get_last_track(cdrom);
+			int length;
+			int allocation_length = SCSILengthFromUINT16( &command[ 7 ] );
+
+			if( start_trk == 0 )
+			{
+				start_trk = 1;
+			}
+			if( start_trk == 0xaa )
+			{
+				end_trk = start_trk;
+			}
+
+			length = 4 + ( 8 * ( ( end_trk - start_trk ) + 1 ) );
+			if( length > allocation_length )
+			{
+				length = allocation_length;
+			}
+			else if( length < 4 )
+			{
+				length = 4;
+			}
+
+			cdda = cdda_from_cdrom(scsiInstance->machine(), cdrom);
+			if (cdda != NULL)
+			{
+				cdda_stop_audio(cdda);
+			}
+
+			SCSISetPhase( scsiInstance, SCSI_PHASE_DATAIN );
+			return length;
+		}
+		case 0x45: // PLAY AUDIO(10)
+			our_this->lba = command[2]<<24 | command[3]<<16 | command[4]<<8 | command[5];
+			our_this->blocks = SCSILengthFromUINT16( &command[7] );
+
+			// special cases: lba of 0 means MSF of 00:02:00
+			if (our_this->lba == 0)
+			{
+				our_this->lba = 150;
+			}
+			else if (our_this->lba == 0xffffffff)
+			{
+				logerror("GDROM: play audio from current not implemented!\n");
+			}
+
+			logerror("GDROM: PLAY AUDIO(10) at LBA %x for %x blocks\n", our_this->lba, our_this->blocks);
+
+			trk = cdrom_get_track(cdrom, our_this->lba);
+
+			if (cdrom_get_track_type(cdrom, trk) == CD_TRACK_AUDIO)
+			{
+				our_this->play_err_flag = 0;
+				cdda = cdda_from_cdrom(scsiInstance->machine(), cdrom);
+				if (cdda != NULL)
+					cdda_start_audio(cdda, our_this->lba, our_this->blocks);
+			}
+			else
+			{
+				logerror("GDROM: track is NOT audio!\n");
+				our_this->play_err_flag = 1;
+			}
+
+			SCSISetPhase( scsiInstance, SCSI_PHASE_STATUS );
+			return 0;
+
+		case 0x48: // PLAY AUDIO TRACK/INDEX
+			// be careful: tracks here are zero-based, but the SCSI command
+			// uses the real CD track number which is 1-based!
+			our_this->lba = cdrom_get_track_start(cdrom, command[4]-1);
+			our_this->blocks = cdrom_get_track_start(cdrom, command[7]-1) - our_this->lba;
+			if (command[4] > command[7])
+			{
+				our_this->blocks = 0;
+			}
+
+			if (command[4] == command[7])
+			{
+				our_this->blocks = cdrom_get_track_start(cdrom, command[4]) - our_this->lba;
+			}
+
+			if (our_this->blocks && cdrom)
+			{
+				cdda = cdda_from_cdrom(scsiInstance->machine(), cdrom);
+				if (cdda != NULL)
+					cdda_start_audio(cdda, our_this->lba, our_this->blocks);
+			}
+
+			logerror("GDROM: PLAY AUDIO T/I: strk %d idx %d etrk %d idx %d frames %d\n", command[4], command[5], command[7], command[8], our_this->blocks);
+			SCSISetPhase( scsiInstance, SCSI_PHASE_STATUS );
+			return 0;
+
+		case 0x4b: // PAUSE/RESUME
+			if (cdrom)
+			{
+				cdda = cdda_from_cdrom(scsiInstance->machine(), cdrom);
+				if (cdda != NULL)
+					cdda_pause_audio(cdda, (command[8] & 0x01) ^ 0x01);
+			}
+
+			logerror("GDROM: PAUSE/RESUME: %s\n", command[8]&1 ? "RESUME" : "PAUSE");
+			SCSISetPhase( scsiInstance, SCSI_PHASE_STATUS );
+			return 0;
+
+		case 0x55: // MODE SELECT(10)
+			logerror("GDROM: MODE SELECT length %x control %x\n", command[7]<<8 | command[8], command[1]);
+			SCSISetPhase( scsiInstance, SCSI_PHASE_DATAOUT );
+			return SCSILengthFromUINT16( &command[ 7 ] );
+
+		case 0x5a: // MODE SENSE(10)
+			SCSISetPhase( scsiInstance, SCSI_PHASE_DATAIN );
+			return SCSILengthFromUINT16( &command[ 7 ] );
+
+		case 0xa5: // PLAY AUDIO(12)
+			our_this->lba = command[2]<<24 | command[3]<<16 | command[4]<<8 | command[5];
+			our_this->blocks = command[6]<<24 | command[7]<<16 | command[8]<<8 | command[9];
+
+			// special cases: lba of 0 means MSF of 00:02:00
+			if (our_this->lba == 0)
+			{
+				our_this->lba = 150;
+			}
+			else if (our_this->lba == 0xffffffff)
+			{
+				logerror("GDROM: play audio from current not implemented!\n");
+			}
+
+			logerror("GDROM: PLAY AUDIO(12) at LBA %x for %x blocks\n", our_this->lba, our_this->blocks);
+
+			trk = cdrom_get_track(cdrom, our_this->lba);
+
+			if (cdrom_get_track_type(cdrom, trk) == CD_TRACK_AUDIO)
+			{
+				our_this->play_err_flag = 0;
+				cdda = cdda_from_cdrom(scsiInstance->machine(), cdrom);
+				if (cdda != NULL)
+					cdda_start_audio(cdda, our_this->lba, our_this->blocks);
+			}
+			else
+			{
+				logerror("GDROM: track is NOT audio!\n");
+				our_this->play_err_flag = 1;
+			}
+			SCSISetPhase( scsiInstance, SCSI_PHASE_STATUS );
+			return 0;
+
+		case 0xa8: // READ(12)
+			our_this->lba = command[2]<<24 | command[3]<<16 | command[4]<<8 | command[5];
+			our_this->blocks = command[7]<<16 | command[8]<<8 | command[9];
+
+			logerror("GDROM: READ(12) at LBA %x for %x blocks (%x bytes)\n", our_this->lba, our_this->blocks, our_this->blocks * our_this->bytes_per_sector);
+
+			if (our_this->num_subblocks > 1)
+			{
+				our_this->cur_subblock = our_this->lba % our_this->num_subblocks;
+				our_this->lba /= our_this->num_subblocks;
+			}
+			else
+			{
+				our_this->cur_subblock = 0;
+			}
+
+			cdda = cdda_from_cdrom(scsiInstance->machine(), cdrom);
+			if (cdda != NULL)
+			{
+				cdda_stop_audio(cdda);
+			}
+
+			SCSISetPhase( scsiInstance, SCSI_PHASE_DATAIN );
+			return our_this->blocks * our_this->bytes_per_sector;
+
+		case 0xbb: // SET CD SPEED
+			logerror("GDROM: SET CD SPEED to %d kbytes/sec.\n", command[2]<<8 | command[3]);
+			SCSISetPhase( scsiInstance, SCSI_PHASE_STATUS );
+			return 0;
+
+		default:
+			return SCSIBase( &SCSIClassGDROM, SCSIOP_EXEC_COMMAND, scsiInstance, 0, NULL );
+	}
+}
+
+// scsicd_read_data
+//
+// Read data from the device resulting from the execution of a command
+
+static void scsicd_read_data( SCSIInstance *scsiInstance, UINT8 *data, int dataLength )
+{
+	UINT8 *command;
+	int commandLength;
+	SCSIGd *our_this = (SCSIGd *)SCSIThis( &SCSIClassGDROM, scsiInstance );
+
+	int i;
+	UINT32 last_phys_frame;
+	cdrom_file *cdrom = our_this->cdrom;
+	UINT32 temp;
+	UINT8 tmp_buffer[2048];
+	device_t *cdda;
+
+	SCSIGetCommand( scsiInstance, &command, &commandLength );
+
+	switch ( command[0] )
+	{
+		case 0x03: // REQUEST SENSE
+			logerror("GDROM: Reading REQUEST SENSE data\n");
+
+			memset( data, 0, dataLength );
+
+			data[0] = 0x71;	// deferred error
+
+			cdda = cdda_from_cdrom(scsiInstance->machine(), cdrom);
+			if (cdda != NULL && cdda_audio_active(cdda))
+			{
+				data[12] = 0x00;
+				data[13] = 0x11;	// AUDIO PLAY OPERATION IN PROGRESS
+			}
+			else if (our_this->play_err_flag)
+			{
+				our_this->play_err_flag = 0;
+				data[12] = 0x64;	// ILLEGAL MODE FOR THIS TRACK
+				data[13] = 0x00;
+			}
+			// (else 00/00 means no error to report)
+			break;
+
+		case 0x11: // REQ_MODE
+			printf("REQ_MODE: dataLength %d\n", dataLength);
+			memcpy(data, &GDROM_Cmd11_Reply[0], (dataLength >= 32) ? 32 : dataLength);
+			break;
+
+		case 0x12: // INQUIRY
+			memset( data, 0, dataLength );
+			data[0] = 0x05; // device is present, device is CD/DVD (MMC-3)
+			data[1] = 0x80; // media is removable
+			data[2] = 0x05; // device complies with SPC-3 standard
+			data[3] = 0x02; // response data format = SPC-3 standard
+			// some Konami games freak out if this isn't "Sony", so we'll lie
+			// this is the actual drive on my Nagano '98 board
+			strcpy((char *)&data[8], "Sony");
+			strcpy((char *)&data[16], "CDU-76S");
+			strcpy((char *)&data[32], "1.0");
+			break;
+
+		case 0x25: // READ CAPACITY
+			logerror("GDROM: READ CAPACITY\n");
+
+			temp = cdrom_get_track_start(cdrom, 0xaa);
+			temp--;	// return the last used block on the disc
+
+			data[0] = (temp>>24) & 0xff;
+			data[1] = (temp>>16) & 0xff;
+			data[2] = (temp>>8) & 0xff;
+			data[3] = (temp & 0xff);
+			data[4] = 0;
+			data[5] = 0;
+			data[6] = (our_this->bytes_per_sector>>8)&0xff;
+			data[7] = (our_this->bytes_per_sector & 0xff);
+			break;
+
+		case 0x28: // READ(10)
+		case 0xa8: // READ(12)
+			logerror("GDROM: read %x dataLength, \n", dataLength);
+			if ((our_this->cdrom) && (our_this->blocks))
+			{
+				while (dataLength > 0)
+				{
+					if (!cdrom_read_data(our_this->cdrom, our_this->lba, tmp_buffer, CD_TRACK_MODE1))
+					{
+						logerror("GDROM: CD read error!\n");
+					}
+
+					logerror("True LBA: %d, buffer half: %d\n", our_this->lba, our_this->cur_subblock * our_this->bytes_per_sector);
+
+					memcpy(data, &tmp_buffer[our_this->cur_subblock * our_this->bytes_per_sector], our_this->bytes_per_sector);
+
+					our_this->cur_subblock++;
+					if (our_this->cur_subblock >= our_this->num_subblocks)
+					{
+						our_this->cur_subblock = 0;
+
+						our_this->lba++;
+						our_this->blocks--;
+					}
+
+					our_this->last_lba = our_this->lba;
+					dataLength -= our_this->bytes_per_sector;
+					data += our_this->bytes_per_sector;
+				}
+			}
+			break;
+
+		case 0x30: // CD_READ
+			logerror("GDROM: read %x dataLength, \n", dataLength);
+			if ((our_this->cdrom) && (our_this->blocks))
+			{
+				while (dataLength > 0)
+				{
+					if (!cdrom_read_data(our_this->cdrom, our_this->lba, tmp_buffer, CD_TRACK_MODE1))
+					{
+						logerror("GDROM: CD read error!\n");
+					}
+
+					logerror("True LBA: %d, buffer half: %d\n", our_this->lba, our_this->cur_subblock * our_this->bytes_per_sector);
+
+					memcpy(data, &tmp_buffer[our_this->cur_subblock * our_this->bytes_per_sector], our_this->bytes_per_sector);
+
+					our_this->cur_subblock++;
+					if (our_this->cur_subblock >= our_this->num_subblocks)
+					{
+						our_this->cur_subblock = 0;
+
+						our_this->lba++;
+						our_this->blocks--;
+					}
+
+					our_this->last_lba = our_this->lba;
+					dataLength -= our_this->bytes_per_sector;
+					data += our_this->bytes_per_sector;
+				}
+			}
+
+		case 0x42: // READ SUB-CHANNEL
+			switch (command[3])
+			{
+				case 1:	// return current position
+				{
+					int audio_active;
+					int msf;
+
+					if (!cdrom)
+					{
+						return;
+					}
+
+					logerror("GDROM: READ SUB-CHANNEL Time = %x, SUBQ = %x\n", command[1], command[2]);
+
+					msf = command[1] & 0x2;
+
+					cdda = cdda_from_cdrom(scsiInstance->machine(), cdrom);
+					audio_active = cdda != NULL && cdda_audio_active(cdda);
+					if (audio_active)
+					{
+						if (cdda_audio_paused(cdda))
+						{
+							data[1] = 0x12;		// audio is paused
+						}
+						else
+						{
+							data[1] = 0x11;		// audio in progress
+						}
+					}
+					else
+					{
+						if (cdda != NULL && cdda_audio_ended(cdda))
+						{
+							data[1] = 0x13;	// ended successfully
+						}
+						else
+						{
+//                          data[1] = 0x14;    // stopped due to error
+							data[1] = 0x15;	// No current audio status to return
+						}
+					}
+
+					// if audio is playing, get the latest LBA from the CDROM layer
+					if (audio_active)
+					{
+						our_this->last_lba = cdda_get_audio_lba(cdda);
+					}
+					else
+					{
+						our_this->last_lba = 0;
+					}
+
+					data[2] = 0;
+					data[3] = 12;		// data length
+					data[4] = 0x01;	// sub-channel format code
+					data[5] = 0x10 | (audio_active ? 0 : 4);
+					data[6] = cdrom_get_track(cdrom, our_this->last_lba) + 1;	// track
+					data[7] = 0;	// index
+
+					last_phys_frame = our_this->last_lba;
+
+					if (msf)
+					{
+						int m,s,f;
+						phys_frame_to_msf(last_phys_frame, &m, &s, &f);
+						data[8] = 0;
+						data[9] = m;
+						data[10] = s;
+						data[11] = f;
+					}
+					else
+					{
+						data[8] = last_phys_frame>>24;
+						data[9] = (last_phys_frame>>16)&0xff;
+						data[10] = (last_phys_frame>>8)&0xff;
+						data[11] = last_phys_frame&0xff;
+					}
+
+					last_phys_frame -= cdrom_get_track_start(cdrom, data[6] - 1);
+
+					if (msf)
+					{
+						int m,s,f;
+						phys_frame_to_msf(last_phys_frame, &m, &s, &f);
+						data[12] = 0;
+						data[13] = m;
+						data[14] = s;
+						data[15] = f;
+					}
+					else
+					{
+						data[12] = last_phys_frame>>24;
+						data[13] = (last_phys_frame>>16)&0xff;
+						data[14] = (last_phys_frame>>8)&0xff;
+						data[15] = last_phys_frame&0xff;
+					}
+					break;
+				}
+				default:
+					logerror("GDROM: Unknown subchannel type %d requested\n", command[3]);
+			}
+			break;
+
+		case 0x43: // READ TOC
+			/*
+                Track numbers are problematic here: 0 = lead-in, 0xaa = lead-out.
+                That makes sense in terms of how real-world CDs are referred to, but
+                our internal routines for tracks use "0" as track 1.  That probably
+                should be fixed...
+            */
+			logerror("GDROM: READ TOC, format = %d time=%d\n", command[2]&0xf,(command[1]>>1)&1);
+			switch (command[2] & 0x0f)
+			{
+				case 0:		// normal
+					{
+						int start_trk;
+						int end_trk;
+						int len;
+						int in_len;
+						int dptr;
+						UINT32 tstart;
+
+						start_trk = command[6];
+						if( start_trk == 0 )
+						{
+							start_trk = 1;
+						}
+
+						end_trk = cdrom_get_last_track(cdrom);
+						len = (end_trk * 8) + 2;
+
+						// the returned TOC DATA LENGTH must be the full amount,
+						// regardless of how much we're able to pass back due to in_len
+						dptr = 0;
+						data[dptr++] = (len>>8) & 0xff;
+						data[dptr++] = (len & 0xff);
+						data[dptr++] = 1;
+						data[dptr++] = end_trk;
+
+						if( start_trk == 0xaa )
+						{
+							end_trk = 0xaa;
+						}
+
+						in_len = command[7]<<8 | command[8];
+
+						for (i = start_trk; i <= end_trk; i++)
+						{
+							int cdrom_track = i;
+							if( cdrom_track != 0xaa )
+							{
+								cdrom_track--;
+							}
+
+							if( dptr >= in_len )
+							{
+								break;
+							}
+
+							data[dptr++] = 0;
+							data[dptr++] = cdrom_get_adr_control(cdrom, cdrom_track);
+							data[dptr++] = i;
+							data[dptr++] = 0;
+
+							tstart = cdrom_get_track_start(cdrom, cdrom_track);
+							if ((command[1]&2)>>1)
+								tstart = lba_to_msf(tstart);
+							data[dptr++] = (tstart>>24) & 0xff;
+							data[dptr++] = (tstart>>16) & 0xff;
+							data[dptr++] = (tstart>>8) & 0xff;
+							data[dptr++] = (tstart & 0xff);
+						}
+					}
+					break;
+				default:
+					logerror("GDROM: Unhandled READ TOC format %d\n", command[2]&0xf);
+					break;
+			}
+			break;
+
+		case 0x1a: // MODE SENSE(6)
+		case 0x5a: // MODE SENSE(10)
+			logerror("GDROM: MODE SENSE page code = %x, PC = %x\n", command[2] & 0x3f, (command[2]&0xc0)>>6);
+
+			switch (command[2] & 0x3f)
+			{
+				case 0xe:	// CD Audio control page
+					data[0] = 0x8e;	// page E, parameter is savable
+					data[1] = 0x0e;	// page length
+					data[2] = 0x04;	// IMMED = 1, SOTC = 0
+					data[3] = data[4] = data[5] = data[6] = data[7] = 0; // reserved
+
+					// connect each audio channel to 1 output port
+					data[8] = 1;
+					data[10] = 2;
+					data[12] = 4;
+					data[14] = 8;
+
+					// indicate max volume
+					data[9] = data[11] = data[13] = data[15] = 0xff;
+					break;
+
+				default:
+					logerror("GDROM: MODE SENSE unknown page %x\n", command[2] & 0x3f);
+					break;
+			}
+			break;
+
+		default:
+			SCSIBase( &SCSIClassGDROM, SCSIOP_READ_DATA, scsiInstance, dataLength, data );
+			break;
+	}
+}
+
+// scsicd_write_data
+//
+// Write data to the CD-ROM device as part of the execution of a command
+
+static void scsicd_write_data( SCSIInstance *scsiInstance, UINT8 *data, int dataLength )
+{
+	UINT8 *command;
+	int commandLength;
+	SCSIGd *our_this = (SCSIGd *)SCSIThis( &SCSIClassGDROM, scsiInstance );
+	SCSIGetCommand( scsiInstance, &command, &commandLength );
+
+	switch (command[ 0 ])
+	{
+		case 0x15: // MODE SELECT(6)
+		case 0x55: // MODE SELECT(10)
+			logerror("GDROM: MODE SELECT page %x\n", data[0] & 0x3f);
+
+			switch (data[0] & 0x3f)
+			{
+				case 0x0:	// vendor-specific
+					// check for SGI extension to force 512-byte blocks
+					if ((data[3] == 8) && (data[10] == 2))
+					{
+						logerror("GDROM: Experimental SGI 512-byte block extension enabled\n");
+
+						our_this->bytes_per_sector = 512;
+						our_this->num_subblocks = 4;
+					}
+					else
+					{
+						logerror("GDROM: Unknown vendor-specific page!\n");
+					}
+					break;
+
+				case 0xe:	// audio page
+					logerror("Ch 0 route: %x vol: %x\n", data[8], data[9]);
+					logerror("Ch 1 route: %x vol: %x\n", data[10], data[11]);
+					logerror("Ch 2 route: %x vol: %x\n", data[12], data[13]);
+					logerror("Ch 3 route: %x vol: %x\n", data[14], data[15]);
+					break;
+			}
+			break;
+
+		default:
+			SCSIBase( &SCSIClassGDROM, SCSIOP_WRITE_DATA, scsiInstance, dataLength, data );
+			break;
+	}
+}
+
+static void scsicd_alloc_instance( SCSIInstance *scsiInstance, const char *diskregion )
+{
+	running_machine &machine = scsiInstance->machine();
+	SCSIGd *our_this = (SCSIGd *)SCSIThis( &SCSIClassGDROM, scsiInstance );
+
+	our_this->lba = 0;
+	our_this->blocks = 0;
+	our_this->last_lba = 0;
+	our_this->bytes_per_sector = 2048;
+	our_this->num_subblocks = 1;
+	our_this->cur_subblock = 0;
+	our_this->play_err_flag = 0;
+
+	state_save_register_item( machine, "scsicd", diskregion, 0, our_this->lba );
+	state_save_register_item( machine, "scsicd", diskregion, 0, our_this->blocks );
+	state_save_register_item( machine, "scsicd", diskregion, 0, our_this->last_lba );
+	state_save_register_item( machine, "scsicd", diskregion, 0, our_this->bytes_per_sector );
+	state_save_register_item( machine, "scsicd", diskregion, 0, our_this->num_subblocks );
+	state_save_register_item( machine, "scsicd", diskregion, 0, our_this->cur_subblock );
+	state_save_register_item( machine, "scsicd", diskregion, 0, our_this->play_err_flag );
+
+	if (machine.device( diskregion )) {
+		our_this->is_file = TRUE;
+		our_this->cdrom = cd_get_cdrom_file( machine.device( diskregion ) );
+	} else {
+		our_this->is_file = FALSE;
+		our_this->cdrom = cdrom_open(get_disk_handle( machine, diskregion ));
+	}
+
+	if (!our_this->cdrom)
+	{
+		logerror("GDROM: no CD found!\n");
+	}
+}
+
+static void scsicd_delete_instance( SCSIInstance *scsiInstance )
+{
+	SCSIGd *our_this = (SCSIGd *)SCSIThis( &SCSIClassGDROM, scsiInstance );
+	if (!our_this->is_file) {
+		if( our_this->cdrom )
+		{
+			cdrom_close( our_this->cdrom );
+		}
+	}
+}
+
+static void scsicd_get_device( SCSIInstance *scsiInstance, cdrom_file **cdrom )
+{
+	SCSIGd *our_this = (SCSIGd *)SCSIThis( &SCSIClassGDROM, scsiInstance );
+	*cdrom = our_this->cdrom;
+}
+
+static void scsicd_set_device( SCSIInstance *scsiInstance, cdrom_file *cdrom )
+{
+	SCSIGd *our_this = (SCSIGd *)SCSIThis( &SCSIClassGDROM, scsiInstance );
+	our_this->cdrom = cdrom;
+}
+
+static int scsigd_dispatch(int operation, void *file, INT64 intparm, void *ptrparm)
+{
+	SCSIAllocInstanceParams *params;
+
+	switch (operation)
+	{
+		case SCSIOP_EXEC_COMMAND:
+			return scsicd_exec_command( (SCSIInstance *)file, (UINT8 *)ptrparm );
+
+		case SCSIOP_READ_DATA:
+			scsicd_read_data( (SCSIInstance *)file, (UINT8 *)ptrparm, intparm );
+			return 0;
+
+		case SCSIOP_WRITE_DATA:
+			scsicd_write_data( (SCSIInstance *)file, (UINT8 *)ptrparm, intparm );
+			return 0;
+
+		case SCSIOP_ALLOC_INSTANCE:
+			params = (SCSIAllocInstanceParams *)ptrparm;
+			SCSIBase( &SCSIClassGDROM, operation, (SCSIInstance *)file, intparm, (UINT8 *)ptrparm );
+			scsicd_alloc_instance( params->instance, params->diskregion );
+			return 0;
+
+		case SCSIOP_DELETE_INSTANCE:
+			scsicd_delete_instance( (SCSIInstance *)file );
+			break;
+
+		case SCSIOP_GET_DEVICE:
+			scsicd_get_device( (SCSIInstance *)file, (cdrom_file **)ptrparm );
+			return 0;
+
+		case SCSIOP_SET_DEVICE:
+			scsicd_set_device( (SCSIInstance *)file, (cdrom_file *)ptrparm );
+			return 0;
+	}
+
+	return SCSIBase( &SCSIClassGDROM, operation, (SCSIInstance *)file, intparm, (UINT8 *)ptrparm );
+}
+
+const SCSIClass SCSIClassGDROM =
+{
+	&SCSIClassDevice,
+	scsigd_dispatch,
+	sizeof( SCSIGd )
+};

src/mame/machine/gdrom.h

@@ -0,0 +1,17 @@
+/***************************************************************************
+
+ gdrom.h
+
+***************************************************************************/
+
+#ifndef _GDROM_H_
+#define _GDROM_H_
+
+#include "machine/scsi.h"
+
+// Sega GD-ROM handler
+extern const SCSIClass SCSIClassGDROM;
+#define SCSI_DEVICE_GDROM &SCSIClassGDROM
+
+#endif
+

src/mame/mame.mak

@@ -18,6 +18,7 @@ DRIVERS = $(MAMEOBJ)/drivers
 LAYOUT = $(MAMEOBJ)/layout
 MACHINE = $(MAMEOBJ)/machine
 VIDEO = $(MAMEOBJ)/video
+FORMATS = $(MAMEOBJ)/formats
 
 OBJDIRS += \
 	$(AUDIO) \
@@ -25,6 +26,7 @@ OBJDIRS += \
 	$(LAYOUT) \
 	$(MACHINE) \
 	$(VIDEO) \
+	$(FORMATS) \
 
 
 
@@ -335,6 +337,7 @@ DRVLIBS += \
 	$(MAMEOBJ)/misc.a \
 	$(MAMEOBJ)/pinball.a \
 	$(MAMEOBJ)/shared.a \
+	$(MAMEOBJ)/formats.a \
 
 
 
@@ -345,6 +348,7 @@ DRVLIBS += \
 
 $(MAMEOBJ)/shared.a: \
 	$(MACHINE)/nmk112.o \
+	$(MACHINE)/ctronics.o \
 	$(MACHINE)/pckeybrd.o \
 	$(MACHINE)/pcshare.o \
 	$(MACHINE)/segacrpt.o \
@@ -352,7 +356,12 @@ $(MAMEOBJ)/shared.a: \
 	$(MACHINE)/ticket.o \
 	$(VIDEO)/avgdvg.o \
 
+#-------------------------------------------------
+# file formats, mostly used for MESS software
+#-------------------------------------------------
 
+$(MAMEOBJ)/formats.a: \
+	$(FORMATS)/basicdsk.o	\
 
 #-------------------------------------------------
 # manufacturer-specific groupings for drivers
@@ -1219,6 +1228,13 @@ $(MAMEOBJ)/sega.a: \
 	$(VIDEO)/segaic16.o \
 	$(VIDEO)/sega16sp.o \
 	$(VIDEO)/segaic24.o \
+	$(VIDEO)/smsvdp.o \
+	$(MACHINE)/segasms.o \
+	$(DRIVERS)/segasms.o \
+	$(DRIVERS)/sg1000.o \
+	$(DRIVERS)/dc.o \
+	$(MACHINE)/dccons.o \
+	$(MACHINE)/gdrom.o \
 
 $(MAMEOBJ)/seibu.a: \
 	$(DRIVERS)/bloodbro.o $(VIDEO)/bloodbro.o \
@@ -1976,6 +1992,8 @@ $(DRIVERS)/segaorun.o:	$(LAYOUT)/outrun.lh
 
 $(DRIVERS)/segas32.o:	$(LAYOUT)/radr.lh
 
+$(DRIVERS)/segasms.o:	$(LAYOUT)/sms1.lh
+
 $(DRIVERS)/segaybd.o:	$(LAYOUT)/pdrift.lh
 
 $(DRIVERS)/snookr10.o:	$(LAYOUT)/snookr10.lh

src/mame/video/smsvdp.h

@@ -0,0 +1,86 @@
+/*************************************************************************
+
+    smsvdp.h
+
+    Implementation of Sega VDP chip used in Master System and Game Gear
+
+**************************************************************************/
+
+#ifndef __SMSVDP_H__
+#define __SMSVDP_H__
+
+#include "devcb.h"
+
+
+/***************************************************************************
+    CONSTANTS
+***************************************************************************/
+
+
+#define MODEL_315_5124			0x0001
+#define MODEL_315_5246			0x0002
+#define MODEL_315_5378			0x0004
+
+#define SMS_X_PIXELS			342		/* 342 pixels */
+#define NTSC_Y_PIXELS			262		/* 262 lines */
+#define PAL_Y_PIXELS			313		/* 313 lines */
+#define LBORDER_START			(1 + 2 + 14 + 8)
+#define LBORDER_X_PIXELS		(0x0d)		/* 13 pixels */
+#define RBORDER_X_PIXELS		(0x0f)		/* 15 pixels */
+#define TBORDER_START			(3 + 13)
+#define NTSC_192_TBORDER_Y_PIXELS	(0x1b)		/* 27 lines */
+#define NTSC_192_BBORDER_Y_PIXELS	(0x18)		/* 24 lines */
+#define NTSC_224_TBORDER_Y_PIXELS	(0x0b)		/* 11 lines */
+#define NTSC_224_BBORDER_Y_PIXELS	(0x08)		/* 8 lines */
+#define PAL_192_TBORDER_Y_PIXELS	(0x36)		/* 54 lines */
+#define PAL_192_BBORDER_Y_PIXELS	(0x30)		/* 48 lines */
+#define PAL_224_TBORDER_Y_PIXELS	(0x26)		/* 38 lines */
+#define PAL_224_BBORDER_Y_PIXELS	(0x20)		/* 32 lines */
+#define PAL_240_TBORDER_Y_PIXELS	(0x1e)		/* 30 lines */
+#define PAL_240_BBORDER_Y_PIXELS	(0x18)		/* 24 lines */
+
+
+/***************************************************************************
+    TYPE DEFINITIONS
+***************************************************************************/
+
+typedef void (*smsvdp_int_cb)( running_machine &machine, int state );
+typedef void (*smsvdp_pause_cb)( running_machine &machine );
+
+typedef struct _smsvdp_interface smsvdp_interface;
+struct _smsvdp_interface
+{
+	UINT32             model;                /* Select model/features for the emulation */
+	smsvdp_int_cb      int_callback;         /* Interrupt callback function */
+	smsvdp_pause_cb    pause_callback;       /* Pause callback function */
+};
+
+/***************************************************************************
+    DEVICE CONFIGURATION MACROS
+***************************************************************************/
+
+DECLARE_LEGACY_DEVICE(SMSVDP, smsvdp);
+
+#define MCFG_SMSVDP_ADD(_tag, _interface) \
+	MCFG_DEVICE_ADD(_tag, SMSVDP, 0) \
+	MCFG_DEVICE_CONFIG(_interface)
+
+
+/***************************************************************************
+    DEVICE I/O FUNCTIONS
+***************************************************************************/
+
+/* prototypes */
+
+UINT32 sms_vdp_update( device_t *device, bitmap_t *bitmap, const rectangle *cliprect );
+READ8_DEVICE_HANDLER( sms_vdp_vcount_r );
+READ8_DEVICE_HANDLER( sms_vdp_hcount_latch_r );
+WRITE8_DEVICE_HANDLER( sms_vdp_hcount_latch_w );
+READ8_DEVICE_HANDLER( sms_vdp_data_r );
+WRITE8_DEVICE_HANDLER( sms_vdp_data_w );
+READ8_DEVICE_HANDLER( sms_vdp_ctrl_r );
+WRITE8_DEVICE_HANDLER( sms_vdp_ctrl_w );
+void sms_vdp_set_ggsmsmode( device_t *device, int mode );
+int sms_vdp_check_brightness( device_t *device, int x, int y );
+
+#endif /* __SMSVDP_H__ */