trunk/src/emu/webengine.c
| r250110 | r250111 | |
|---|
| 1 | | // license:BSD-3-Clause |
| 2 | | // copyright-holders:Miodrag Milanovic |
| 3 | | /*************************************************************************** |
| 4 | | |
| 5 | | webengine.c |
| 6 | | |
| 7 | | Handle MAME internal web server. |
| 8 | | |
| 9 | | ***************************************************************************/ |
| 10 | | |
| 11 | | #include "mongoose/mongoose.h" |
| 12 | | #include "jsoncpp/include/json/json.h" |
| 13 | | #include "emu.h" |
| 14 | | #include "emuopts.h" |
| 15 | | #include "ui/ui.h" |
| 16 | | #include "webengine.h" |
| 17 | | #include "lua.hpp" |
| 18 | | |
| 19 | | #include "osdepend.h" |
| 20 | | |
| 21 | | //************************************************************************** |
| 22 | | // WEB ENGINE |
| 23 | | //************************************************************************** |
| 24 | | |
| 25 | | char* websanitize_statefilename ( char* unsanitized ) |
| 26 | | { |
| 27 | | // It's important that we remove any dangerous characters from any filename |
| 28 | | // we receive from a web client. This can be a serious security hole. |
| 29 | | // As MAME/MESS policy is lowercase filenames, also lowercase it. |
| 30 | | |
| 31 | | char* sanitized = new char[64]; |
| 32 | | int insertpoint =0; |
| 33 | | char charcompare; |
| 34 | | |
| 35 | | while (*unsanitized != 0) |
| 36 | | { |
| 37 | | charcompare = *unsanitized; |
| 38 | | // ASCII 48-57 are 0-9 |
| 39 | | // ASCII 97-122 are lowercase A-Z |
| 40 | | |
| 41 | | if ((charcompare >= 48 && charcompare <= 57) || (charcompare >= 97 && charcompare <= 122)) |
| 42 | | { |
| 43 | | sanitized[insertpoint] = charcompare; |
| 44 | | insertpoint++; |
| 45 | | sanitized[insertpoint] = '\0'; // Make sure we're null-terminated. |
| 46 | | } |
| 47 | | // ASCII 65-90 are uppercase A-Z. These need to be lowercased. |
| 48 | | if (charcompare >= 65 && charcompare <= 90) |
| 49 | | { |
| 50 | | sanitized[insertpoint] = tolower(charcompare); // Lowercase it |
| 51 | | insertpoint++; |
| 52 | | sanitized[insertpoint] = '\0'; // Make sure we're null-terminated. |
| 53 | | } |
| 54 | | unsanitized++; |
| 55 | | } |
| 56 | | return (sanitized); |
| 57 | | } |
| 58 | | |
| 59 | | int web_engine::json_game_handler(struct mg_connection *conn) |
| 60 | | { |
| 61 | | Json::Value data; |
| 62 | | data["name"] = m_machine->system().name; |
| 63 | | data["description"] = m_machine->system().description; |
| 64 | | data["year"] = m_machine->system().year; |
| 65 | | data["manufacturer"] = m_machine->system().manufacturer; |
| 66 | | data["parent"] = m_machine->system().parent; |
| 67 | | data["source_file"] = m_machine->system().source_file; |
| 68 | | data["flags"] = m_machine->system().flags; |
| 69 | | data["ispaused"] = m_machine->paused(); |
| 70 | | |
| 71 | | Json::FastWriter writer; |
| 72 | | std::string json = writer.write(data); |
| 73 | | // Send HTTP reply to the client |
| 74 | | mg_printf(conn, |
| 75 | | "HTTP/1.1 200 OK\r\n" |
| 76 | | "Content-Type: application/json\r\n" |
| 77 | | "Content-Length: %d\r\n" // Always set Content-Length |
| 78 | | "\r\n" |
| 79 | | "%s", |
| 80 | | (int)json.length(), json.c_str()); |
| 81 | | |
| 82 | | // Returning non-zero tells mongoose that our function has replied to |
| 83 | | // the client, and mongoose should not send client any more data. |
| 84 | | |
| 85 | | return MG_TRUE; |
| 86 | | } |
| 87 | | |
| 88 | | int web_engine::json_slider_handler(struct mg_connection *conn) |
| 89 | | { |
| 90 | | const slider_state *curslider; |
| 91 | | std::string tempstring; |
| 92 | | Json::Value array(Json::arrayValue); |
| 93 | | |
| 94 | | // add all sliders |
| 95 | | for (curslider = machine().ui().get_slider_list(); curslider != NULL; curslider = curslider->next) |
| 96 | | { |
| 97 | | INT32 curval = (*curslider->update)(machine(), curslider->arg, &tempstring, SLIDER_NOCHANGE); |
| 98 | | Json::Value data; |
| 99 | | data["description"] = curslider->description; |
| 100 | | data["minval"] = curslider->minval; |
| 101 | | data["maxval"] = curslider->maxval; |
| 102 | | data["defval"] = curslider->defval; |
| 103 | | data["incval"] = curslider->incval; |
| 104 | | data["curval"] = curval; |
| 105 | | array.append(data); |
| 106 | | } |
| 107 | | |
| 108 | | // add all sliders |
| 109 | | for (curslider = (slider_state*)machine().osd().get_slider_list(); curslider != NULL; curslider = curslider->next) |
| 110 | | { |
| 111 | | INT32 curval = (*curslider->update)(machine(), curslider->arg, &tempstring, SLIDER_NOCHANGE); |
| 112 | | Json::Value data; |
| 113 | | data["description"] = curslider->description; |
| 114 | | data["minval"] = curslider->minval; |
| 115 | | data["maxval"] = curslider->maxval; |
| 116 | | data["defval"] = curslider->defval; |
| 117 | | data["incval"] = curslider->incval; |
| 118 | | data["curval"] = curval; |
| 119 | | array.append(data); |
| 120 | | } |
| 121 | | Json::FastWriter writer; |
| 122 | | std::string json = writer.write(array); |
| 123 | | // Send HTTP reply to the client |
| 124 | | mg_printf(conn, |
| 125 | | "HTTP/1.1 200 OK\r\n" |
| 126 | | "Content-Type: application/json\r\n" |
| 127 | | "Content-Length: %d\r\n" // Always set Content-Length |
| 128 | | "\r\n" |
| 129 | | "%s", |
| 130 | | (int)json.length(), json.c_str()); |
| 131 | | |
| 132 | | return MG_TRUE; |
| 133 | | } |
| 134 | | |
| 135 | | void reg_string(struct lua_State *L, const char *name, const char *val) { |
| 136 | | lua_pushstring(L, name); |
| 137 | | lua_pushstring(L, val); |
| 138 | | lua_rawset(L, -3); |
| 139 | | } |
| 140 | | |
| 141 | | void reg_int(struct lua_State *L, const char *name, int val) { |
| 142 | | lua_pushstring(L, name); |
| 143 | | lua_pushinteger(L, val); |
| 144 | | lua_rawset(L, -3); |
| 145 | | } |
| 146 | | |
| 147 | | void reg_function(struct lua_State *L, const char *name, |
| 148 | | lua_CFunction func, struct mg_connection *conn) { |
| 149 | | lua_pushstring(L, name); |
| 150 | | lua_pushlightuserdata(L, conn); |
| 151 | | lua_pushcclosure(L, func, 1); |
| 152 | | lua_rawset(L, -3); |
| 153 | | } |
| 154 | | |
| 155 | | static int lua_write(lua_State *L) { |
| 156 | | int i, num_args; |
| 157 | | const char *str; |
| 158 | | size_t size; |
| 159 | | struct mg_connection *conn = (struct mg_connection *) |
| 160 | | lua_touserdata(L, lua_upvalueindex(1)); |
| 161 | | |
| 162 | | num_args = lua_gettop(L); |
| 163 | | for (i = 1; i <= num_args; i++) { |
| 164 | | if (lua_isstring(L, i)) { |
| 165 | | str = lua_tolstring(L, i, &size); |
| 166 | | mg_send_data(conn, str, size); |
| 167 | | } |
| 168 | | } |
| 169 | | |
| 170 | | return 0; |
| 171 | | } |
| 172 | | |
| 173 | | static int lua_header(lua_State *L) { |
| 174 | | struct mg_connection *conn = (struct mg_connection *) |
| 175 | | lua_touserdata(L, lua_upvalueindex(1)); |
| 176 | | |
| 177 | | const char *header = luaL_checkstring(L,1); |
| 178 | | const char *value = luaL_checkstring(L,2); |
| 179 | | |
| 180 | | mg_send_header(conn, header, value); |
| 181 | | |
| 182 | | return 0; |
| 183 | | } |
| 184 | | |
| 185 | | |
| 186 | | static void prepare_lua_environment(struct mg_connection *ri, lua_State *L) { |
| 187 | | extern void luaL_openlibs(lua_State *); |
| 188 | | int i; |
| 189 | | |
| 190 | | luaL_openlibs(L); |
| 191 | | |
| 192 | | if (ri == NULL) return; |
| 193 | | |
| 194 | | // Register mg module |
| 195 | | lua_newtable(L); |
| 196 | | reg_function(L, "write", lua_write, ri); |
| 197 | | reg_function(L, "header", lua_header, ri); |
| 198 | | |
| 199 | | // Export request_info |
| 200 | | lua_pushstring(L, "request_info"); |
| 201 | | lua_newtable(L); |
| 202 | | reg_string(L, "request_method", ri->request_method); |
| 203 | | reg_string(L, "uri", ri->uri); |
| 204 | | reg_string(L, "http_version", ri->http_version); |
| 205 | | reg_string(L, "query_string", ri->query_string); |
| 206 | | reg_string(L, "remote_ip", ri->remote_ip); |
| 207 | | reg_int(L, "remote_port", ri->remote_port); |
| 208 | | reg_string(L, "local_ip", ri->local_ip); |
| 209 | | reg_int(L, "local_port", ri->local_port); |
| 210 | | lua_pushstring(L, "content"); |
| 211 | | lua_pushlstring(L, ri->content == NULL ? "" : ri->content, ri->content_len); |
| 212 | | lua_rawset(L, -3); |
| 213 | | reg_int(L, "num_headers", ri->num_headers); |
| 214 | | lua_pushstring(L, "http_headers"); |
| 215 | | lua_newtable(L); |
| 216 | | for (i = 0; i < ri->num_headers; i++) { |
| 217 | | reg_string(L, ri->http_headers[i].name, ri->http_headers[i].value); |
| 218 | | } |
| 219 | | lua_rawset(L, -3); |
| 220 | | lua_rawset(L, -3); |
| 221 | | |
| 222 | | lua_setglobal(L, "mg"); |
| 223 | | |
| 224 | | } |
| 225 | | |
| 226 | | |
| 227 | | static void lsp(struct mg_connection *conn, const char *p, int len, lua_State *L) { |
| 228 | | int i, j, pos = 0; |
| 229 | | for (i = 0; i < len; i++) { |
| 230 | | if (p[i] == '<' && p[i + 1] == '?') { |
| 231 | | for (j = i + 1; j < len ; j++) { |
| 232 | | if (p[j] == '?' && p[j + 1] == '>') { |
| 233 | | if (i-pos!=0) mg_send_data(conn, p + pos, i - pos); |
| 234 | | if (luaL_loadbuffer(L, p + (i + 2), j - (i + 2), "") == 0) { |
| 235 | | lua_pcall(L, 0, LUA_MULTRET, 0); |
| 236 | | } |
| 237 | | pos = j + 2; |
| 238 | | i = pos - 1; |
| 239 | | break; |
| 240 | | } |
| 241 | | } |
| 242 | | } |
| 243 | | } |
| 244 | | if (i > pos) { |
| 245 | | mg_send_data(conn, p + pos, i - pos); |
| 246 | | } |
| 247 | | } |
| 248 | | |
| 249 | | static int filename_endswith(const char *str, const char *suffix) |
| 250 | | { |
| 251 | | if (!str || !suffix) |
| 252 | | return 0; |
| 253 | | size_t lenstr = strlen(str); |
| 254 | | size_t lensuffix = strlen(suffix); |
| 255 | | if (lensuffix > lenstr) |
| 256 | | return 0; |
| 257 | | return strncmp(str + lenstr - lensuffix, suffix, lensuffix) == 0; |
| 258 | | } |
| 259 | | |
| 260 | | // This function will be called by mongoose on every new request. |
| 261 | | int web_engine::begin_request_handler(struct mg_connection *conn) |
| 262 | | { |
| 263 | | std::string file_path = std::string(mg_get_option(m_server, "document_root")).append(PATH_SEPARATOR).append(conn->uri); |
| 264 | | if (filename_endswith(file_path.c_str(), ".lp")) |
| 265 | | { |
| 266 | | FILE *fp = NULL; |
| 267 | | if ((fp = fopen(file_path.c_str(), "rb")) != NULL) { |
| 268 | | fseek (fp, 0, SEEK_END); |
| 269 | | size_t size = ftell(fp); |
| 270 | | fseek (fp, 0, SEEK_SET); |
| 271 | | char *data = (char*)mg_mmap(fp,size); |
| 272 | | |
| 273 | | lua_State *L = luaL_newstate(); |
| 274 | | prepare_lua_environment(conn, L); |
| 275 | | lsp(conn, data, (int) size, L); |
| 276 | | if (L != NULL) lua_close(L); |
| 277 | | mg_munmap(data,size); |
| 278 | | fclose(fp); |
| 279 | | return MG_TRUE; |
| 280 | | } else { |
| 281 | | return MG_FALSE; |
| 282 | | } |
| 283 | | } |
| 284 | | else if (!strncmp(conn->uri, "/json/",6)) |
| 285 | | { |
| 286 | | if (!strcmp(conn->uri, "/json/game")) |
| 287 | | { |
| 288 | | return json_game_handler(conn); |
| 289 | | } |
| 290 | | if (!strcmp(conn->uri, "/json/slider")) |
| 291 | | { |
| 292 | | return json_slider_handler(conn); |
| 293 | | } |
| 294 | | } |
| 295 | | else if (!strncmp(conn->uri, "/keypost",8)) |
| 296 | | { |
| 297 | | // Is there any sane way to determine the length of the buffer before getting it? |
| 298 | | // A request for a way was previously filed with the mongoose devs, |
| 299 | | // but it looks like it was never implemented. |
| 300 | | |
| 301 | | // For now, we'll allow a paste buffer of 32k. |
| 302 | | // To-do: Send an error if the paste is too big? |
| 303 | | char cmd_val[32768]; |
| 304 | | |
| 305 | | int pastelength = mg_get_var(conn, "val", cmd_val, sizeof(cmd_val)); |
| 306 | | if (pastelength > 0) { |
| 307 | | machine().ioport().natkeyboard().post_utf8(cmd_val); |
| 308 | | } |
| 309 | | // Send HTTP reply to the client |
| 310 | | mg_printf(conn, |
| 311 | | "HTTP/1.1 200 OK\r\n" |
| 312 | | "Content-Type: text/plain\r\n" |
| 313 | | "Content-Length: 2\r\n" // Always set Content-Length |
| 314 | | "\r\n" |
| 315 | | "OK"); |
| 316 | | |
| 317 | | // Returning non-zero tells mongoose that our function has replied to |
| 318 | | // the client, and mongoose should not send client any more data. |
| 319 | | return MG_TRUE; |
| 320 | | } |
| 321 | | else if (!strncmp(conn->uri, "/keyupload",8)) |
| 322 | | { |
| 323 | | char *upload_data; |
| 324 | | int data_length, ofs = 0; |
| 325 | | char var_name[100], file_name[255]; |
| 326 | | while ((ofs = mg_parse_multipart(conn->content + ofs, conn->content_len - ofs, var_name, sizeof(var_name), file_name, sizeof(file_name), (const char **)&upload_data, &data_length)) > 0) { |
| 327 | | mg_printf_data(conn, "File: %s, size: %d bytes", file_name, data_length); |
| 328 | | } |
| 329 | | |
| 330 | | // That upload_data contains more than we need. It also has the headers. |
| 331 | | // We'll need to strip it down to just what we want. |
| 332 | | |
| 333 | | if ((&data_length > 0) && (sizeof(file_name) > 0)) |
| 334 | | { |
| 335 | | // MSVC doesn't yet support variable-length arrays, so chop the string the old-fashioned way |
| 336 | | upload_data[data_length] = '\0'; |
| 337 | | |
| 338 | | // Now paste the stripped down paste_data.. |
| 339 | | machine().ioport().natkeyboard().post_utf8(upload_data); |
| 340 | | } |
| 341 | | return MG_TRUE; |
| 342 | | } |
| 343 | | else if (!strncmp(conn->uri, "/cmd",4)) |
| 344 | | { |
| 345 | | char cmd_name[64]; |
| 346 | | mg_get_var(conn, "name", cmd_name, sizeof(cmd_name)); |
| 347 | | |
| 348 | | if(!strcmp(cmd_name,"softreset")) |
| 349 | | { |
| 350 | | m_machine->schedule_soft_reset(); |
| 351 | | } |
| 352 | | else if(!strcmp(cmd_name,"hardreset")) |
| 353 | | { |
| 354 | | m_machine->schedule_hard_reset(); |
| 355 | | } |
| 356 | | else if(!strcmp(cmd_name,"exit")) |
| 357 | | { |
| 358 | | m_machine->schedule_exit(); |
| 359 | | } |
| 360 | | else if(!strcmp(cmd_name,"togglepause")) |
| 361 | | { |
| 362 | | if (m_machine->paused()) |
| 363 | | m_machine->resume(); |
| 364 | | else |
| 365 | | m_machine->pause(); |
| 366 | | } |
| 367 | | else if(!strcmp(cmd_name,"savestate")) |
| 368 | | { |
| 369 | | char cmd_val[64]; |
| 370 | | mg_get_var(conn, "val", cmd_val, sizeof(cmd_val)); |
| 371 | | char *filename = websanitize_statefilename(cmd_val); |
| 372 | | m_machine->schedule_save(filename); |
| 373 | | } |
| 374 | | else if(!strcmp(cmd_name,"loadstate")) |
| 375 | | { |
| 376 | | char cmd_val[64]; |
| 377 | | mg_get_var(conn, "val", cmd_val, sizeof(cmd_val)); |
| 378 | | char *filename = cmd_val; |
| 379 | | m_machine->schedule_load(filename); |
| 380 | | } |
| 381 | | else if(!strcmp(cmd_name,"loadauto")) |
| 382 | | { |
| 383 | | // This is here to just load the autosave and only the autosave. |
| 384 | | m_machine->schedule_load("auto"); |
| 385 | | } |
| 386 | | |
| 387 | | // Send HTTP reply to the client |
| 388 | | mg_printf(conn, |
| 389 | | "HTTP/1.1 200 OK\r\n" |
| 390 | | "Content-Type: text/plain\r\n" |
| 391 | | "Content-Length: 2\r\n" // Always set Content-Length |
| 392 | | "\r\n" |
| 393 | | "OK"); |
| 394 | | |
| 395 | | // Returning non-zero tells mongoose that our function has replied to |
| 396 | | // the client, and mongoose should not send client any more data. |
| 397 | | return MG_TRUE; |
| 398 | | } |
| 399 | | else if (!strncmp(conn->uri, "/slider",7)) |
| 400 | | { |
| 401 | | char cmd_id[64]; |
| 402 | | char cmd_val[64]; |
| 403 | | mg_get_var(conn, "id", cmd_id, sizeof(cmd_id)); |
| 404 | | mg_get_var(conn, "val", cmd_val, sizeof(cmd_val)); |
| 405 | | int cnt = 0; |
| 406 | | int id = atoi(cmd_id); |
| 407 | | const slider_state *curslider; |
| 408 | | for (curslider = machine().ui().get_slider_list(); curslider != NULL; curslider = curslider->next) |
| 409 | | { |
| 410 | | if (cnt==id) |
| 411 | | (*curslider->update)(machine(), curslider->arg, NULL, atoi(cmd_val)); |
| 412 | | cnt++; |
| 413 | | } |
| 414 | | for (curslider = (slider_state*)machine().osd().get_slider_list(); curslider != NULL; curslider = curslider->next) |
| 415 | | { |
| 416 | | if (cnt==id) |
| 417 | | (*curslider->update)(machine(), curslider->arg, NULL, atoi(cmd_val)); |
| 418 | | cnt++; |
| 419 | | } |
| 420 | | |
| 421 | | // Send HTTP reply to the client |
| 422 | | mg_printf(conn, |
| 423 | | "HTTP/1.1 200 OK\r\n" |
| 424 | | "Content-Type: text/plain\r\n" |
| 425 | | "Content-Length: 2\r\n" // Always set Content-Length |
| 426 | | "\r\n" |
| 427 | | "OK"); |
| 428 | | |
| 429 | | // Returning non-zero tells mongoose that our function has replied to |
| 430 | | // the client, and mongoose should not send client any more data. |
| 431 | | return MG_TRUE; |
| 432 | | } |
| 433 | | else if (!strncmp(conn->uri, "/screenshot.png",15)) |
| 434 | | { |
| 435 | | screen_device_iterator iter(m_machine->root_device()); |
| 436 | | screen_device *screen = iter.first(); |
| 437 | | |
| 438 | | if (screen == NULL) |
| 439 | | { |
| 440 | | return 0; |
| 441 | | } |
| 442 | | |
| 443 | | std::string fname("screenshot.png"); |
| 444 | | emu_file file(m_machine->options().snapshot_directory(), OPEN_FLAG_WRITE | OPEN_FLAG_CREATE | OPEN_FLAG_CREATE_PATHS); |
| 445 | | file_error filerr = file.open(fname.c_str()); |
| 446 | | |
| 447 | | if (filerr != FILERR_NONE) |
| 448 | | { |
| 449 | | return 0; |
| 450 | | } |
| 451 | | |
| 452 | | m_machine->video().save_snapshot(screen, file); |
| 453 | | std::string fullpath(file.fullpath()); |
| 454 | | file.close(); |
| 455 | | mg_send_header(conn, "Cache-Control", "no-cache, no-store, must-revalidate"); |
| 456 | | mg_send_header(conn, "Pragma", "no-cache"); |
| 457 | | mg_send_header(conn, "Expires", "0"); |
| 458 | | mg_send_file(conn, fullpath.c_str(), NULL); |
| 459 | | return MG_MORE; // It is important to return MG_MORE after mg_send_file! |
| 460 | | } |
| 461 | | return 0; |
| 462 | | } |
| 463 | | |
| 464 | | static int ev_handler(struct mg_connection *conn, enum mg_event ev) { |
| 465 | | if (ev == MG_REQUEST) { |
| 466 | | if (conn->is_websocket) { |
| 467 | | // This handler is called for each incoming websocket frame, one or more |
| 468 | | // times for connection lifetime. |
| 469 | | // Echo websocket data back to the client. |
| 470 | | return conn->content_len == 4 && !memcmp(conn->content, "exit", 4) ? MG_FALSE : MG_TRUE; |
| 471 | | } else { |
| 472 | | web_engine *engine = static_cast<web_engine *>(conn->server_param); |
| 473 | | return engine->begin_request_handler(conn); |
| 474 | | } |
| 475 | | } else if (ev== MG_WS_CONNECT) { |
| 476 | | // New websocket connection. Send connection ID back to the client. |
| 477 | | mg_websocket_printf(conn, WEBSOCKET_OPCODE_TEXT, "update_machine"); |
| 478 | | return MG_FALSE; |
| 479 | | } else if (ev == MG_AUTH) { |
| 480 | | return MG_TRUE; |
| 481 | | } else { |
| 482 | | return MG_FALSE; |
| 483 | | } |
| 484 | | } |
| 485 | | |
| 486 | | //------------------------------------------------- |
| 487 | | // web_engine - constructor |
| 488 | | //------------------------------------------------- |
| 489 | | |
| 490 | | web_engine::web_engine(emu_options &options) |
| 491 | | : m_options(options), |
| 492 | | m_machine(NULL), |
| 493 | | m_server(NULL), |
| 494 | | //m_lastupdatetime(0), |
| 495 | | m_exiting_core(false), |
| 496 | | m_http(m_options.http()) |
| 497 | | |
| 498 | | { |
| 499 | | if (m_http) { |
| 500 | | m_server = mg_create_server(this, ev_handler); |
| 501 | | |
| 502 | | mg_set_option(m_server, "listening_port", options.http_port()); |
| 503 | | mg_set_option(m_server, "document_root", options.http_path()); |
| 504 | | } |
| 505 | | |
| 506 | | } |
| 507 | | |
| 508 | | //------------------------------------------------- |
| 509 | | // ~web_engine - destructor |
| 510 | | //------------------------------------------------- |
| 511 | | |
| 512 | | web_engine::~web_engine() |
| 513 | | { |
| 514 | | if (m_http) |
| 515 | | close(); |
| 516 | | } |
| 517 | | |
| 518 | | //------------------------------------------------- |
| 519 | | // close - close and cleanup of lua engine |
| 520 | | //------------------------------------------------- |
| 521 | | |
| 522 | | void web_engine::close() |
| 523 | | { |
| 524 | | m_exiting_core = 1; |
| 525 | | // Cleanup, and free server instance |
| 526 | | mg_destroy_server(&m_server); |
| 527 | | } |
| 528 | | |
| 529 | | void web_engine::serve() |
| 530 | | { |
| 531 | | if (m_http) mg_poll_server(m_server, 0); |
| 532 | | } |
| 533 | | |
| 534 | | void web_engine::push_message(const char *message) |
| 535 | | { |
| 536 | | struct mg_connection *c; |
| 537 | | if (m_server!=NULL) { |
| 538 | | // Iterate over all connections, and push current time message to websocket ones. |
| 539 | | for (c = mg_next(m_server, NULL); c != NULL; c = mg_next(m_server, c)) { |
| 540 | | if (c->is_websocket) { |
| 541 | | mg_websocket_write(c, 1, message, strlen(message)); |
| 542 | | } |
| 543 | | } |
| 544 | | } |
| 545 | | } |
trunk/src/mame/drivers/a2600.c
| r250110 | r250111 | |
|---|
| 10 | 10 | |
| 11 | 11 | ***************************************************************************/ |
| 12 | 12 | |
| 13 | // the new RIOT does not work with the SuperCharger |
| 14 | // for example "mame64 a2600 scharger -cass offifrog" fails to load after playing the tape |
| 15 | #define USE_NEW_RIOT 0 |
| 16 | |
| 17 | |
| 13 | 18 | #include "emu.h" |
| 14 | | #include "machine/mos6530n.h" |
| 19 | |
| 15 | 20 | #include "cpu/m6502/m6507.h" |
| 16 | 21 | #include "sound/tiaintf.h" |
| 17 | 22 | #include "video/tia.h" |
| r250110 | r250111 | |
|---|
| 23 | 28 | #include "bus/vcs/compumat.h" |
| 24 | 29 | #include "bus/vcs_ctrl/ctrl.h" |
| 25 | 30 | |
| 31 | |
| 32 | |
| 33 | #if USE_NEW_RIOT |
| 34 | #include "machine/mos6530n.h" |
| 35 | #else |
| 36 | #include "machine/6532riot.h" |
| 37 | #endif |
| 38 | |
| 39 | |
| 26 | 40 | #define CONTROL1_TAG "joyport1" |
| 27 | 41 | #define CONTROL2_TAG "joyport2" |
| 28 | 42 | |
| 29 | 43 | |
| 44 | |
| 30 | 45 | class a2600_state : public driver_device |
| 31 | 46 | { |
| 32 | 47 | public: |
| r250110 | r250111 | |
|---|
| 73 | 88 | required_device<m6507_device> m_maincpu; |
| 74 | 89 | required_device<screen_device> m_screen; |
| 75 | 90 | required_ioport m_swb; |
| 91 | #if USE_NEW_RIOT |
| 76 | 92 | required_device<mos6532_t> m_riot; |
| 93 | #else |
| 94 | required_device<riot6532_device> m_riot; |
| 95 | #endif |
| 96 | |
| 77 | 97 | }; |
| 78 | 98 | |
| 79 | 99 | |
| r250110 | r250111 | |
|---|
| 88 | 108 | static ADDRESS_MAP_START(a2600_mem, AS_PROGRAM, 8, a2600_state ) // 6507 has 13-bit address space, 0x0000 - 0x1fff |
| 89 | 109 | AM_RANGE(0x0000, 0x007f) AM_MIRROR(0x0f00) AM_DEVREADWRITE("tia_video", tia_video_device, read, write) |
| 90 | 110 | AM_RANGE(0x0080, 0x00ff) AM_MIRROR(0x0d00) AM_RAM AM_SHARE("riot_ram") |
| 111 | #if USE_NEW_RIOT |
| 91 | 112 | AM_RANGE(0x0280, 0x029f) AM_MIRROR(0x0d00) AM_DEVICE("riot", mos6532_t, io_map) |
| 113 | #else |
| 114 | AM_RANGE(0x0280, 0x029f) AM_MIRROR(0x0d00) AM_DEVREADWRITE("riot", riot6532_device, read, write) |
| 115 | #endif |
| 92 | 116 | // AM_RANGE(0x1000, 0x1fff) is cart data and it is configured at reset time, depending on the mounted cart! |
| 93 | 117 | ADDRESS_MAP_END |
| 94 | 118 | |
| r250110 | r250111 | |
|---|
| 116 | 140 | } |
| 117 | 141 | else if (masked_offset < 0x2a0) |
| 118 | 142 | { |
| 143 | #if USE_NEW_RIOT |
| 119 | 144 | ret = m_riot->io_r(space, masked_offset); |
| 145 | #else |
| 146 | ret = m_riot->read(space, masked_offset); |
| 147 | #endif |
| 120 | 148 | } |
| 121 | 149 | else if (masked_offset < 0x300) |
| 122 | 150 | { |
| r250110 | r250111 | |
|---|
| 148 | 176 | } |
| 149 | 177 | else if (masked_offset < 0x2a0) |
| 150 | 178 | { |
| 179 | #if USE_NEW_RIOT |
| 151 | 180 | m_riot->io_w(space, masked_offset, data); |
| 181 | #else |
| 182 | m_riot->write(space, masked_offset, data); |
| 183 | #endif |
| 152 | 184 | } |
| 153 | 185 | else if (masked_offset < 0x300) |
| 154 | 186 | { |
| r250110 | r250111 | |
|---|
| 563 | 595 | MCFG_SOUND_ROUTE(ALL_OUTPUTS, "mono", 0.90) |
| 564 | 596 | |
| 565 | 597 | /* devices */ |
| 598 | #if USE_NEW_RIOT |
| 566 | 599 | MCFG_DEVICE_ADD("riot", MOS6532n, MASTER_CLOCK_NTSC / 3) |
| 567 | | MCFG_MOS6530n_IN_PA_CB(READ8(a2600_state, switch_A_r)) |
| 568 | | MCFG_MOS6530n_OUT_PA_CB(WRITE8(a2600_state, switch_A_w)) |
| 569 | | MCFG_MOS6530n_IN_PB_CB(READ8(a2600_state, riot_input_port_8_r)) |
| 570 | | MCFG_MOS6530n_OUT_PB_CB(WRITE8(a2600_state, switch_B_w)) |
| 571 | | MCFG_MOS6530n_IRQ_CB(WRITELINE(a2600_state, irq_callback)) |
| 600 | MCFG_MOS6530n_IN_PA_CB(READ8(a2600_state, switch_A_r)) |
| 601 | MCFG_MOS6530n_OUT_PA_CB(WRITE8(a2600_state, switch_A_w)) |
| 602 | MCFG_MOS6530n_IN_PB_CB(READ8(a2600_state, riot_input_port_8_r)) |
| 603 | MCFG_MOS6530n_OUT_PB_CB(WRITE8(a2600_state, switch_B_w)) |
| 604 | MCFG_MOS6530n_IRQ_CB(WRITELINE(a2600_state, irq_callback)) |
| 605 | #else |
| 606 | MCFG_DEVICE_ADD("riot", RIOT6532, MASTER_CLOCK_NTSC / 3) |
| 607 | MCFG_RIOT6532_IN_PA_CB(READ8(a2600_state, switch_A_r)) |
| 608 | MCFG_RIOT6532_OUT_PA_CB(WRITE8(a2600_state, switch_A_w)) |
| 609 | MCFG_RIOT6532_IN_PB_CB(READ8(a2600_state, riot_input_port_8_r)) |
| 610 | MCFG_RIOT6532_OUT_PB_CB(WRITE8(a2600_state, switch_B_w)) |
| 611 | MCFG_RIOT6532_IRQ_CB(WRITELINE(a2600_state, irq_callback)) |
| 612 | #endif |
| 572 | 613 | |
| 573 | 614 | MCFG_VCS_CONTROL_PORT_ADD(CONTROL1_TAG, vcs_control_port_devices, "joy") |
| 574 | 615 | MCFG_VCS_CONTROL_PORT_ADD(CONTROL2_TAG, vcs_control_port_devices, NULL) |
| r250110 | r250111 | |
|---|
| 604 | 645 | MCFG_SOUND_ROUTE(ALL_OUTPUTS, "mono", 0.90) |
| 605 | 646 | |
| 606 | 647 | /* devices */ |
| 607 | | MCFG_DEVICE_ADD("riot", MOS6532n, MASTER_CLOCK_PAL / 3) |
| 608 | | MCFG_MOS6530n_IN_PA_CB(READ8(a2600_state, switch_A_r)) |
| 609 | | MCFG_MOS6530n_OUT_PA_CB(WRITE8(a2600_state, switch_A_w)) |
| 610 | | MCFG_MOS6530n_IN_PB_CB(READ8(a2600_state, riot_input_port_8_r)) |
| 611 | | MCFG_MOS6530n_OUT_PB_CB(WRITE8(a2600_state, switch_B_w)) |
| 612 | | MCFG_MOS6530n_IRQ_CB(WRITELINE(a2600_state, irq_callback)) |
| 648 | #if USE_NEW_RIOT |
| 649 | MCFG_DEVICE_ADD("riot", MOS6532n, MASTER_CLOCK_PAL / 3) |
| 650 | MCFG_MOS6530n_IN_PA_CB(READ8(a2600_state, switch_A_r)) |
| 651 | MCFG_MOS6530n_OUT_PA_CB(WRITE8(a2600_state, switch_A_w)) |
| 652 | MCFG_MOS6530n_IN_PB_CB(READ8(a2600_state, riot_input_port_8_r)) |
| 653 | MCFG_MOS6530n_OUT_PB_CB(WRITE8(a2600_state, switch_B_w)) |
| 654 | MCFG_MOS6530n_IRQ_CB(WRITELINE(a2600_state, irq_callback)) |
| 655 | #else |
| 656 | MCFG_DEVICE_ADD("riot", RIOT6532, MASTER_CLOCK_PAL / 3) |
| 657 | MCFG_RIOT6532_IN_PA_CB(READ8(a2600_state, switch_A_r)) |
| 658 | MCFG_RIOT6532_OUT_PA_CB(WRITE8(a2600_state, switch_A_w)) |
| 659 | MCFG_RIOT6532_IN_PB_CB(READ8(a2600_state, riot_input_port_8_r)) |
| 660 | MCFG_RIOT6532_OUT_PB_CB(WRITE8(a2600_state, switch_B_w)) |
| 661 | MCFG_RIOT6532_IRQ_CB(WRITELINE(a2600_state, irq_callback)) |
| 662 | #endif |
| 613 | 663 | |
| 614 | 664 | MCFG_VCS_CONTROL_PORT_ADD(CONTROL1_TAG, vcs_control_port_devices, "joy") |
| 615 | 665 | MCFG_VCS_CONTROL_PORT_ADD(CONTROL2_TAG, vcs_control_port_devices, NULL) |
trunk/src/mame/drivers/aristmk5.c
| r250110 | r250111 | |
|---|
| 1115 | 1115 | ROM_REGION( 0x20000*4, "sram", ROMREGION_ERASE00 ) |
| 1116 | 1116 | ROM_END |
| 1117 | 1117 | |
| 1118 | // MV4084/1 - 10 Credit Multiplier / 9 Line Multiline. |
| 1119 | // THE GAMBLER - Export A - 30/10/98. |
| 1120 | // Marked as EHG0916 and 92.268%. |
| 1121 | // All devices are 27c4002 instead of 27c4096. |
| 1122 | ROM_START( thgamblr ) |
| 1123 | ARISTOCRAT_MK5_BIOS |
| 1124 | ROM_REGION( 0x400000, "game_prg", ROMREGION_ERASEFF ) |
| 1125 | ROM_LOAD32_WORD( "ehg0916_the_gambler.u7", 0x000000, 0x80000, CRC(7524c954) SHA1(0a895d1e2d09a2c873bbbbeb37bc59c25f3c577c) ) // 92.268% |
| 1126 | ROM_LOAD32_WORD( "ehg0916_the_gambler.u11", 0x000002, 0x80000, CRC(f29a6932) SHA1(17761218a04d36a599c987b4e13c0e3f46b7793f) ) // 92.268% |
| 1127 | ROM_LOAD32_WORD( "ehg0916_the_gambler.u8", 0x100000, 0x80000, CRC(e2221fdf) SHA1(8a7b2d5de68ae66fe1915a6faac6277249e3fb53) ) // base |
| 1128 | ROM_LOAD32_WORD( "ehg0916_the_gambler.u12", 0x100002, 0x80000, CRC(ebe957f9) SHA1(539945ec9beafe2c83051208370588fce2334f16) ) // base |
| 1129 | |
| 1130 | ROM_REGION( 0x800000, "maincpu", ROMREGION_ERASE00 ) /* ARM Code */ |
| 1131 | |
| 1132 | ROM_REGION( 0x200000, "vram", ROMREGION_ERASE00 ) |
| 1133 | |
| 1134 | ROM_REGION( 0x20000*4, "sram", ROMREGION_ERASE00 ) |
| 1135 | ROM_END |
| 1136 | |
| 1118 | 1137 | // MV4098 - 10 Credit Multiplier / 9 Line Multiline. |
| 1119 | 1138 | // BOOT SCOOTIN' - Export A - 25/08/99. |
| 1120 | 1139 | // All devices are 27c4002 instead of 27c4096. |
| r250110 | r250111 | |
|---|
| 1258 | 1277 | ROM_REGION( 0x20000*4, "sram", ROMREGION_ERASE00 ) |
| 1259 | 1278 | ROM_END |
| 1260 | 1279 | |
| 1280 | // MV4115/3 - 20 Line Multiline / 3,5,10,20,25,50 Credit Multiplier. |
| 1281 | // Party Gras - Export B - 06/02/2001. |
| 1282 | // Marked as BHG1284 and touch. |
| 1283 | ROM_START( prtygras ) |
| 1284 | ARISTOCRAT_MK5_BIOS |
| 1285 | ROM_REGION( 0x400000, "game_prg", ROMREGION_ERASEFF ) |
| 1286 | ROM_LOAD32_WORD( "bhg1284_party_grass.u7", 0x000000, 0x80000, CRC(02ed0631) SHA1(ae2c89c876a030d325ec94490d293deba772630e) ) |
| 1287 | ROM_LOAD32_WORD( "bhg1284_party_grass.u11", 0x000002, 0x80000, CRC(7ac80cd9) SHA1(70e910784a1e1ea8820005082e76223a85a3c346) ) |
| 1288 | ROM_LOAD32_WORD( "bhg1284_party_grass.u8", 0x100000, 0x80000, CRC(28774b9a) SHA1(ebdd738a73ffa7c5238640f4d7956751f7bb6243) ) |
| 1289 | ROM_LOAD32_WORD( "bhg1284_party_grass.u12", 0x100002, 0x80000, CRC(942835c1) SHA1(fefc509311716559ac6b836a56b2c981907d499b) ) |
| 1290 | |
| 1291 | ROM_REGION( 0x800000, "maincpu", ROMREGION_ERASE00 ) /* ARM Code */ |
| 1292 | |
| 1293 | ROM_REGION( 0x200000, "vram", ROMREGION_ERASE00 ) |
| 1294 | |
| 1295 | ROM_REGION( 0x20000*4, "sram", ROMREGION_ERASE00 ) |
| 1296 | ROM_END |
| 1297 | |
| 1261 | 1298 | // MV4115/6 - 9/20 Line Multiline Multiplier. |
| 1262 | 1299 | // Party Gras [Reel Game] - Export A - 10/11/2001. |
| 1263 | 1300 | // All devices are 27c4002 instead of 27c4096. |
| r250110 | r250111 | |
|---|
| 1307 | 1344 | GAME( 1998, adonisa, adonis, aristmk5, aristmk5, aristmk5_state, aristmk5, ROT0, "Aristocrat", "Adonis (0100751V, NSW/ACT)", MACHINE_NOT_WORKING|MACHINE_IMPERFECT_SOUND ) // 602/9, A - 25/05/98, Rev 9 |
| 1308 | 1345 | GAME( 1998, swheart2, aristmk5, aristmk5_usa, aristmk5, aristmk5_state, aristmk5, ROT0, "Aristocrat", "Sweet Hearts II (PHG0742, Export, 92.252%)", MACHINE_NOT_WORKING|MACHINE_IMPERFECT_SOUND ) // MV4061, A - 29/06/98 |
| 1309 | 1346 | GAME( 1998, reelrock, 0, aristmk5, aristmk5, aristmk5_state, aristmk5, ROT0, "Aristocrat", "Reelin-n-Rockin (0100779V, Local)", MACHINE_NOT_WORKING|MACHINE_IMPERFECT_SOUND ) // 628, A - 13/07/98 |
| 1347 | GAME( 1998, thgamblr, aristmk5, aristmk5_usa, aristmk5, aristmk5_state, aristmk5, ROT0, "Aristocrat", "The Gambler (EHG0916, Export, 92.268%)", MACHINE_NOT_WORKING|MACHINE_IMPERFECT_SOUND ) // MV4084/1, A - 30/10/98 |
| 1310 | 1348 | GAME( 1998, indiandr, 0, aristmk5, aristmk5, aristmk5_state, aristmk5, ROT0, "Aristocrat", "Indian Dreaming (0100845V, Local)", MACHINE_NOT_WORKING|MACHINE_IMPERFECT_SOUND ) // 628/1, B - 15/12/98 |
| 1311 | 1349 | GAME( 1998, chariotc, 0, aristmk5, aristmk5, aristmk5_state, aristmk5, ROT0, "Aristocrat", "The Chariot Challenge (04J00714, NSW/ACT)", MACHINE_NOT_WORKING|MACHINE_IMPERFECT_SOUND ) // 630, A - 10/08/98, Rev 12 |
| 1312 | 1350 | GAME( 1999, wtiger, 0, aristmk5, aristmk5, aristmk5_state, aristmk5, ROT0, "Aristocrat", "White Tiger Classic (0200954V, NSW/ACT)", MACHINE_NOT_WORKING|MACHINE_IMPERFECT_SOUND ) // 638/1, B - 08/07/99 |
| r250110 | r250111 | |
|---|
| 1316 | 1354 | GAME( 2000, magicmska, magicmsk, aristmk5_usa, aristmk5, aristmk5_state, aristmk5, ROT0, "Aristocrat", "Magic Mask (MV4115, Export, set 2)", MACHINE_NOT_WORKING|MACHINE_IMPERFECT_SOUND ) // MV4115, A - 09/05/00 |
| 1317 | 1355 | GAME( 2000, margmgc, 0, aristmk5, aristmk5, aristmk5_state, aristmk5, ROT0, "Aristocrat", "Margarita Magic (01J00101, NSW/ACT)", MACHINE_NOT_WORKING|MACHINE_IMPERFECT_SOUND ) // JB005, A - 07/07/00 |
| 1318 | 1356 | GAME( 2000, marmagic, aristmk5, aristmk5_usa, aristmk5, aristmk5_state, aristmk5, ROT0, "Aristocrat", "Margarita Magic (EHG1559, NSW/ACT)", MACHINE_NOT_WORKING|MACHINE_IMPERFECT_SOUND ) // US003, A - 07/07/00 |
| 1357 | GAME( 2001, prtygras, aristmk5, aristmk5_usa, aristmk5, aristmk5_state, aristmk5, ROT0, "Aristocrat", "Party Gras (MV4115/3, Export, touch)", MACHINE_NOT_WORKING|MACHINE_IMPERFECT_SOUND ) // MV4115/3, B - 06/02/01 |
| 1319 | 1358 | GAME( 2001, geishanz, 0, aristmk5, aristmk5, aristmk5_state, aristmk5, ROT0, "Aristocrat", "Geisha (0101408V, New Zealand)", MACHINE_NOT_WORKING|MACHINE_IMPERFECT_SOUND ) // MV4127, A - 05/03/01 |
| 1320 | 1359 | GAME( 2001, adonise, aristmk5, aristmk5_usa, aristmk5, aristmk5_state, aristmk5, ROT0, "Aristocrat", "Adonis (MV4124/1, Export)", MACHINE_NOT_WORKING|MACHINE_IMPERFECT_SOUND ) // MV4124/1, B - 31/07/01 |
| 1321 | 1360 | GAME( 2001, koalamnt, aristmk5, aristmk5_usa, aristmk5, aristmk5_state, aristmk5, ROT0, "Aristocrat", "Koala Mint (MV4137, Export)", MACHINE_NOT_WORKING|MACHINE_IMPERFECT_SOUND ) // MV4137, A - 12/09/01 |
trunk/src/mame/drivers/atarittl.c
| r250110 | r250111 | |
|---|
| 5 | 5 | Atari / Kee Games Driver - Discrete Games made in the 1970's |
| 6 | 6 | |
| 7 | 7 | |
| 8 | | Atari / Kee Games List and Data based, in part from: |
| 8 | Atari / Kee Games List (except for most Pong games) - Data based, in part from: |
| 9 | 9 | |
| 10 | 10 | - Andy's collection of Bronzeage Atari Video Arcade PCB's" |
| 11 | 11 | http://www.andysarcade.net/personal/bronzeage/index.htm |
| r250110 | r250111 | |
|---|
| 19 | 19 | Technical Manual #s Game Name(s) Atari Part #'s Data PROM/ROM Chip Numbers |
| 20 | 20 | -------------------+----------------------------------------------------------+----------------------------------+---------+--------------------------------------- |
| 21 | 21 | TM-025 Anti-Aircraft (1975) A000951 YES 003127 |
| 22 | | TM-058 Breakout/Breakout Cocktail/Consolette (1976) A004533 NO |
| 23 | | TM-015 Cocktail Pong/Coup Franc (1974) ??????? NO |
| 24 | 22 | TM-048 Crash 'N Score/Stock Car (1975) A004256 YES 003186(x2), 003187(x2), 004248, 004247 |
| 25 | | TM-030 Crossfire (1975) ??????? NO |
| 26 | | TM-0?? Dr. Pong/Puppy Pong/Snoopy Pong (1974) ??????? NO |
| 27 | | TM-035 Goal IV/Goal/4 (1975) A000823 NO |
| 23 | TM-030 Crossfire (1975) ??????? NO? |
| 24 | TM-022 Elimination! (1973) A000845 NO |
| 25 | TM-035 Goal IV (1975) A000823 NO |
| 28 | 26 | TM-016 Gotcha/Gotcha Color? (1973) A000816 NO |
| 29 | 27 | TM-003,005,011,020 Gran Trak 10/Trak 10/Formula K (1974) A000872,A000872 K3RT YES 74186 Racetrack Prom (K5) |
| 30 | 28 | TM-004,021 Gran Trak 20/Trak 20/Twin Racer (1974) A001791(RT20),A001793(A20-K4DRTA) YES 74186 Racetrack prom (K5) |
| 31 | | TM-028 Highway/Hi-Way (1975) A003211 NO |
| 29 | TM-028 Hi-Way/Highway (1975) A003211 NO |
| 32 | 30 | TM-055 Indy 4 (1976) A003000,A006268,A006270 YES 003186, 003187, 005502-01, 05503-01 |
| 33 | 31 | TM-026 Indy 800 (1975) A003000,A003170,A003182 YES 003186-003189 (4) |
| 34 | 32 | A003184,A003191,A003198,A003199 |
| 35 | 33 | TM-027,052 Jet Fighter/Jet Fighter Cocktail/Launch Aircraft (1975) A004254,A004255 YES 004250-004252, 004253-01 to 03 (3) |
| 36 | | TM-077 LeMans (1976) A005844,A005845 YES 005837-01, 005838-01, 005839-01 |
| 34 | TM-077 Le Mans (1976) A005844,A005845 YES 005837-01, 005838-01, 005839-01 |
| 37 | 35 | TM-040 Outlaw (1976) A003213 YES 003323 - ROM (8205 @ J4) |
| 38 | 36 | TM-007 Pin Pong (1974) A001660 NO |
| 39 | | TM-013 Pong (1972) A001433 NO |
| 40 | | TM-014 Pong Doubles/Coupe Davis (1974) A000785 NO |
| 41 | | TM-019 Pursuit (1975) K8P-B 90128 YES |
| 42 | | TM-012,022,034 Quadrapong/Elimination (1974) A000845 NO |
| 37 | TM-019 Pursuit (1975) K8P-B 90128 NO |
| 38 | TM-012,034 Quadrapong (1974) A000845 NO |
| 43 | 39 | TM-009 Qwak!/Quack (1974) A000937,A000953 YES 72074/37-2530N (K9) |
| 44 | | TM-001,032 Rebound/Volleyball (1974) A000517,A000846 NO |
| 45 | | TM-047 Shark Jaws (1975) A003806 YES 004182, 004183 |
| 46 | | TM-008 Space Race (1974) A000803 NO |
| 47 | | TM-023 Spike (1974) SPIKE-(A or B) NO |
| 40 | TM-001,023,032 Rebound/Spike/Volleyball (1974) A000517,A000846,SPIKE-(A or B) NO |
| 41 | TM-047 Shark JAWS (1975) A003806 YES 004182, 004183 |
| 42 | TM-008 Space Race (1973) A000803 NO |
| 48 | 43 | TM-046 Steeplechase/Astroturf (1975) A003750 YES 003774 ROM Bugle (C8), 003773-01 "A" Horse (C4), 003773-02 "B" Horse (D4) |
| 49 | 44 | TM-057 Stunt Cycle (1976) A004128 YES 004275 ROM Motorcycle/Bus (1F), 004811 ROM Score Translator (D7) |
| 50 | | 422 Superpong (1974) A000423 NO |
| 51 | | TM-010,036,049 Tank/Tank Cocktail/Tank II (1974/1975) A003111 (K5T-F 90124) YES 90-2006 |
| 52 | | TM-002 Touch Me (1974) ??????? NO |
| 45 | TM-010,036 Tank/Tank Cocktail (1974) A003111 (K5T-F 90124) YES 90-2006 004800SD Tank Rom (K10) |
| 46 | TM-049 Tank II (1975) K5T-F 90124 YES 90-2006 |
| 47 | TM-002 Touch-Me (1974) ??????? NO |
| 53 | 48 | TM-006,017 World Cup/World Cup Football/Coupe du Monde (1974) A000823 NO |
| 54 | 49 | |
| 55 | 50 | - Not Known to be released or produced, but at least announced. |
| 56 | 51 | |
| 57 | 52 | TM-0?? Arcade Driver/Driver First Person (Not Produced/Released) (197?) |
| 58 | 53 | TM-018 Dodgeball/Dodgem (Not Produced/Released) (1975) |
| 59 | | TM-024 Qwakers (Not Produced/Released) (1974?) |
| 54 | TM-024 Qwakers (Not Produced/Released) (1974?) (Kee Games clone of Qwak!?) |
| 60 | 55 | |
| 61 | 56 | |
| 62 | 57 | ***************************************************************************/ |
| r250110 | r250111 | |
|---|
| 309 | 304 | ROM_LOAD( "90-2006.k10" ,0x0000, 0x0801, CRC(c25f6014) SHA1(7bd3fca5f64c928a645ca27c643b736667cef216) ) |
| 310 | 305 | ROM_END |
| 311 | 306 | |
| 307 | ROM_START( tankii ) |
| 308 | ROM_REGION( 0x10000, "maincpu", ROMREGION_ERASE00 ) |
| 312 | 309 | |
| 310 | /* The "custom" 24-pin ROM used in Atari/Kee Games "Tank" is known as a MOSTEK MK28000P. */ |
| 311 | ROM_REGION( 0x0801, "gfx", ROMREGION_ERASE00 ) // 2049 Byte Size? |
| 312 | ROM_LOAD( "90-2006.k10" ,0x0000, 0x0801, CRC(c25f6014) SHA1(7bd3fca5f64c928a645ca27c643b736667cef216) ) |
| 313 | ROM_END |
| 314 | |
| 313 | 315 | /* // NO DUMPED ROMS |
| 314 | 316 | |
| 315 | | // Astroturf (1975) |
| 316 | 317 | ROM_START( astrotrf ) |
| 317 | 318 | ROM_REGION( 0x10000, "maincpu", ROMREGION_ERASE00 ) |
| 318 | 319 | |
| r250110 | r250111 | |
|---|
| 321 | 322 | ROM_LOAD( "003773-02.c4", 0x0100, 0x0100, NO_DUMP ) // Graphics (Astroturf - Rev.A) |
| 322 | 323 | ROM_END |
| 323 | 324 | |
| 324 | | // Gran Trak 10 / Trak 10 / Formula K / Race Circuit (1974) |
| 325 | 325 | ROM_START( gtrak10 ) // Unknown size, assumed 2K Bytes |
| 326 | 326 | ROM_REGION( 0x10000, "maincpu", ROMREGION_ERASE00 ) |
| 327 | 327 | |
| r250110 | r250111 | |
|---|
| 329 | 329 | ROM_LOAD( "74168.k5", 0x0000, 0x0800, NO_DUMP) // Racetrack |
| 330 | 330 | ROM_END |
| 331 | 331 | |
| 332 | | // Gran Trak 20 / Trak 20 / Twin Racer (1974) |
| 333 | 332 | ROM_START( gtrak20 ) // Unknown size, assumed 2K Bytes |
| 334 | 333 | ROM_REGION( 0x10000, "maincpu", ROMREGION_ERASE00 ) |
| 335 | 334 | |
| r250110 | r250111 | |
|---|
| 337 | 336 | ROM_LOAD( "74168.k5", 0x0000, 0x0800, NO_DUMP) // Racetrack |
| 338 | 337 | ROM_END |
| 339 | 338 | |
| 340 | | // LeMans (1976) |
| 341 | 339 | ROM_START( lemans ) |
| 342 | 340 | ROM_REGION( 0x10000, "maincpu", ROMREGION_ERASE00 ) |
| 343 | 341 | |
| r250110 | r250111 | |
|---|
| 347 | 345 | ROM_LOAD( "005839-01.n6", 0x0200, 0x0100, NO_DUMP ) // Rom 3 |
| 348 | 346 | ROM_END |
| 349 | 347 | |
| 350 | | // Qwak! / Quack (1974) |
| 351 | 348 | ROM_START( qwak ) |
| 352 | 349 | ROM_REGION( 0x10000, "maincpu", ROMREGION_ERASE00 ) |
| 353 | 350 | |
| r250110 | r250111 | |
|---|
| 370 | 367 | ROM_REGION( 0x10000, "maincpu", ROMREGION_ERASE00 ) |
| 371 | 368 | ROM_END |
| 372 | 369 | |
| 373 | | ROM_START( goal4 ) |
| 370 | ROM_START( eliminat ) |
| 374 | 371 | ROM_REGION( 0x10000, "maincpu", ROMREGION_ERASE00 ) |
| 375 | 372 | ROM_END |
| 376 | 373 | |
| 377 | | ROM_START( gotcha ) |
| 374 | ROM_START( goaliv ) |
| 378 | 375 | ROM_REGION( 0x10000, "maincpu", ROMREGION_ERASE00 ) |
| 379 | 376 | ROM_END |
| 380 | 377 | |
| 381 | | ROM_START( gotchac ) |
| 378 | ROM_START( gotchaat ) |
| 382 | 379 | ROM_REGION( 0x10000, "maincpu", ROMREGION_ERASE00 ) |
| 383 | 380 | ROM_END |
| 384 | 381 | |
| 385 | | ROM_START( highway ) |
| 382 | ROM_START( gotchaatc ) |
| 386 | 383 | ROM_REGION( 0x10000, "maincpu", ROMREGION_ERASE00 ) |
| 387 | 384 | ROM_END |
| 388 | 385 | |
| 386 | ROM_START( hiway ) |
| 387 | ROM_REGION( 0x10000, "maincpu", ROMREGION_ERASE00 ) |
| 388 | ROM_END |
| 389 | |
| 389 | 390 | ROM_START( pinpong ) |
| 390 | 391 | ROM_REGION( 0x10000, "maincpu", ROMREGION_ERASE00 ) |
| 391 | 392 | ROM_END |
| r250110 | r250111 | |
|---|
| 414 | 415 | ROM_REGION( 0x10000, "maincpu", ROMREGION_ERASE00 ) |
| 415 | 416 | ROM_END |
| 416 | 417 | |
| 418 | ROM_START( worldcup ) |
| 419 | ROM_REGION( 0x10000, "maincpu", ROMREGION_ERASE00 ) |
| 420 | ROM_END |
| 421 | |
| 417 | 422 | */ |
| 418 | 423 | |
| 419 | 424 | |
| 420 | 425 | |
| 421 | 426 | GAME(1975, antiairc, 0, atarikee, 0, driver_device, 0, ROT0, "Atari", "Anti-Aircraft [TTL]", MACHINE_IS_SKELETON) |
| 422 | 427 | GAME(1975, crashnsc, 0, atarikee, 0, driver_device, 0, ROT0, "Atari", "Crash 'n Score/Stock Car [TTL]", MACHINE_IS_SKELETON) |
| 423 | | GAME(1976, indy4, 0, atarikee, 0, driver_device, 0, ROT0, "Atari", "Indy 4 [TTL]", MACHINE_IS_SKELETON) |
| 428 | GAME(1976, indy4, 0, atarikee, 0, driver_device, 0, ROT0, "Atari/Kee", "Indy 4 [TTL]", MACHINE_IS_SKELETON) |
| 424 | 429 | GAME(1975, indy800, 0, atarikee, 0, driver_device, 0, ROT90, "Atari/Kee", "Indy 800 [TTL]", MACHINE_IS_SKELETON) |
| 425 | 430 | GAME(1975, jetfight, 0, atarikee, 0, driver_device, 0, ROT0, "Atari", "Jet Fighter/Jet Fighter Cocktail/Launch Aircraft (set 1) [TTL]", MACHINE_IS_SKELETON) |
| 426 | 431 | GAME(1975, jetfighta, jetfight, atarikee, 0, driver_device, 0, ROT0, "Atari", "Jet Fighter/Jet Fighter Cocktail/Launch Aircraft (set 2) [TTL]", MACHINE_IS_SKELETON) |
| 427 | 432 | GAME(1976, outlaw, 0, atarikee, 0, driver_device, 0, ROT0, "Atari", "Outlaw [TTL]", MACHINE_IS_SKELETON) |
| 428 | | GAME(1975, sharkjaw, 0, atarikee, 0, driver_device, 0, ROT0, "Atari/Horror Games", "Shark JAWS [TTL]",MACHINE_IS_SKELETON) |
| 433 | GAME(1975, sharkjaw, 0, atarikee, 0, driver_device, 0, ROT0, "Atari/Horror Games", "Shark JAWS [TTL]", MACHINE_IS_SKELETON) |
| 429 | 434 | GAME(1975, steeplec, 0, atarikee, 0, driver_device, 0, ROT0, "Atari", "Steeplechase [TTL]", MACHINE_IS_SKELETON) |
| 430 | 435 | GAME(1976, stuntcyc, 0, atarikee, 0, driver_device, 0, ROT0, "Atari", "Stunt Cycle [TTL]", MACHINE_IS_SKELETON) |
| 431 | | GAME(1974, tank, 0, atarikee, 0, driver_device, 0, ROT0, "Atari/Kee", "Tank/Tank Cocktail/Tank II [TTL]", MACHINE_IS_SKELETON) |
| 436 | GAME(1974, tank, 0, atarikee, 0, driver_device, 0, ROT0, "Atari/Kee", "Tank/Tank Cocktail [TTL]", MACHINE_IS_SKELETON) |
| 437 | GAME(1975, tankii, 0, atarikee, 0, driver_device, 0, ROT0, "Atari/Kee", "Tank II [TTL]", MACHINE_IS_SKELETON) |
| 432 | 438 | |
| 433 | 439 | // MISSING ROM DUMPS |
| 434 | 440 | //GAME(1975, astrotrf, steeplec, atarikee, 0, driver_device, 0, ROT0, "Atari", "Astroturf [TTL]", MACHINE_IS_SKELETON) |
| 435 | 441 | //GAME(1974, gtrak10, 0, atarikee, 0, driver_device, 0, ROT0, "Atari/Kee", "Gran Trak 10/Trak 10/Formula K [TTL]", MACHINE_IS_SKELETON) //? |
| 436 | | //GAME(1974, gtrak20, 0, atarikee, 0, driver_device, 0, ROT0, "Atari/Kee", "Gran Trak 20/Trak 20/Twin Racer [TTL]", MACHINE_IS_SKELETON) //? |
| 437 | | //GAME(1976, lemans, 0, atarikee, 0, driver_device, 0, ROT0, "Atari", "LeMans [TTL]", MACHINE_IS_SKELETON) |
| 438 | | //GAME(1974, quack, 0, atarikee, 0, driver_device, 0, ROT0, "Atari", "Qwak!/Quack [TTL]", MACHINE_IS_SKELETON) |
| 442 | //GAME(1974, gtrak20, 0, atarikee, 0, driver_device, 0, ROT0, "Atari/Kee", "Gran Trak 20/Trak 20/Twin Racer [TTL]", MACHINE_IS_SKELETON) //? |
| 443 | //GAME(1976, lemans, 0, atarikee, 0, driver_device, 0, ROT0, "Atari", "Le Mans [TTL]", MACHINE_IS_SKELETON) |
| 444 | //GAME(1974, qwak, 0, atarikee, 0, driver_device, 0, ROT0, "Atari", "Qwak!/Quack [TTL]", MACHINE_IS_SKELETON) |
| 439 | 445 | |
| 440 | 446 | // 100% TTL |
| 441 | | //GAME(1974, coupedem, 0, atarikee, 0, driver_device, 0, ROT0, "Atari", "Coupe De Monde [TTL]", MACHINE_IS_SKELETON) |
| 442 | | //GAME(1975, crossfir, 0, atarikee, 0, driver_device, 0, ROT0, "Atari", "Crossfire [TTL]", MACHINE_IS_SKELETON) |
| 443 | | //GAME(1975, goal4, 0, atarikee, 0, driver_device, 0, ROT0, "Atari", "Goal 4/World Cup/Coupe De Monde [TTL]", MACHINE_IS_SKELETON) |
| 447 | //GAME(1975, crossfir, 0, atarikee, 0, driver_device, 0, ROT0, "Atari/Kee", "Crossfire [TTL]", MACHINE_IS_SKELETON) |
| 448 | //GAME(1973, eliminat, 0, atarikee, 0, driver_device, 0, ROT0, "Atari/Kee", "Elimination! [TTL]", MACHINE_IS_SKELETON) |
| 449 | //GAME(1975, goaliv, 0, atarikee, 0, driver_device, 0, ROT0, "Atari", "Goal IV [TTL]", MACHINE_IS_SKELETON) |
| 444 | 450 | //GAME(1973, gotchaat, 0, atarikee, 0, driver_device, 0, ROT0, "Atari", "Gotcha [TTL]", MACHINE_IS_SKELETON) //? |
| 445 | 451 | //GAME(1973, gotchaatc, 0, atarikee, 0, driver_device, 0, ROT0, "Atari", "Gotcha Color [TTL]", MACHINE_IS_SKELETON) //? |
| 446 | | //GAME(1975, highway, 0, atarikee, 0, driver_device, 0, ROT0, "Atari", "Highway/Hiway [TTL]", MACHINE_IS_SKELETON) |
| 452 | //GAME(1975, hiway, 0, atarikee, 0, driver_device, 0, ROT0, "Atari", "Hi-Way/Highway [TTL]", MACHINE_IS_SKELETON) |
| 447 | 453 | //GAME(1974, pinpong, 0, atarikee, 0, driver_device, 0, ROT0, "Atari", "Pin Pong [TTL]", MACHINE_IS_SKELETON) |
| 448 | 454 | //GAME(1975, pursuit, 0, atarikee, 0, driver_device, 0, ROT0, "Atari", "Pursuit [TTL]", MACHINE_IS_SKELETON) |
| 449 | | //GAME(1973, quadpong, 0, atarikee, 0, driver_device, 0, ROT0, "Atari/Kee", "Quadrapong/Elimination [TTL]", MACHINE_IS_SKELETON) |
| 450 | | //GAME(1974, rebound, 0, atarikee, 0, driver_device, 0, ROT0, "Atari/Kee", "Rebound/Spike/Volleyball [TTL]", MACHINE_IS_SKELETON) |
| 451 | | //GAME(1974, spacrace, 0, atarikee, 0, driver_device, 0, ROT0, "Atari", "Space Race [TTL]", MACHINE_IS_SKELETON) |
| 452 | | //GAME(1974, touchme, 0, atarikee, 0, driver_device, 0, ROT0, "Atari", "Touch Me [TTL]", MACHINE_IS_SKELETON) //? |
| 455 | //GAME(1974, quadpong, eliminat, atarikee, 0, driver_device, 0, ROT0, "Atari", "Quadrapong [TTL]", MACHINE_IS_SKELETON) |
| 456 | //GAME(1974, rebound, 0, atarikee, 0, driver_device, 0, ROT0, "Atari/Kee", "Rebound/Spike/Volleyball [TTL]", MACHINE_IS_SKELETON) |
| 457 | //GAME(1973, spacrace, 0, atarikee, 0, driver_device, 0, ROT0, "Atari", "Space Race [TTL]", MACHINE_IS_SKELETON) |
| 458 | //GAME(1974, touchme, 0, atarikee, 0, driver_device, 0, ROT0, "Atari", "Touch-Me [TTL]", MACHINE_IS_SKELETON) //? |
| 459 | //GAME(1974, worldcup, 0, atarikee, 0, driver_device, 0, ROT0, "Atari", "World Cup/World Cup Football/Coupe du Monde [TTL]", MACHINE_IS_SKELETON) |
trunk/src/mame/drivers/champbas.c
| r250110 | r250111 | |
|---|
| 36 | 36 | 7000 8910 write |
| 37 | 37 | 7001 8910 control |
| 38 | 38 | 8ff0-8fff sprites |
| 39 | | a000 ? |
| 39 | a000 irq enable |
| 40 | 40 | a006 MCU HALT control |
| 41 | 41 | a007 NOP (MCU shared RAM switch) |
| 42 | 42 | a060-a06f sprites |
| r250110 | r250111 | |
|---|
| 191 | 191 | |
| 192 | 192 | AM_RANGE(0xa000, 0xa000) AM_READ_PORT("P1") |
| 193 | 193 | AM_RANGE(0xa040, 0xa040) AM_READ_PORT("P2") |
| 194 | | AM_RANGE(0xa080, 0xa080) AM_READ_PORT("DSW") |
| 194 | AM_RANGE(0xa080, 0xa080) AM_MIRROR(0x0020) AM_READ_PORT("DSW") |
| 195 | 195 | AM_RANGE(0xa0c0, 0xa0c0) AM_READ_PORT("SYSTEM") |
| 196 | 196 | |
| 197 | 197 | AM_RANGE(0xa000, 0xa000) AM_WRITE(irq_enable_w) |
| r250110 | r250111 | |
|---|
| 218 | 218 | |
| 219 | 219 | // different protection for champbasja |
| 220 | 220 | static ADDRESS_MAP_START( champbasja_map, AS_PROGRAM, 8, champbas_state ) |
| 221 | AM_RANGE(0x6000, 0x63ff) AM_RAM |
| 221 | 222 | AM_RANGE(0x6800, 0x68ff) AM_READ(champbja_protection_r) |
| 222 | 223 | AM_IMPORT_FROM( champbas_map ) |
| 223 | 224 | ADDRESS_MAP_END |
| r250110 | r250111 | |
|---|
| 1199 | 1200 | /* YEAR NAME PARENT MACHINE INPUT INIT MONITOR, COMPANY, FULLNAME, FLAGS */ |
| 1200 | 1201 | GAME( 1982, talbot, 0, talbot, talbot, driver_device, 0, ROT270, "Alpha Denshi Co. (Volt Electronics license)", "Talbot", MACHINE_SUPPORTS_SAVE ) |
| 1201 | 1202 | |
| 1202 | | GAME( 1983, champbas, 0, champbas, champbas, champbas_state, champbas, ROT0, "Alpha Denshi Co. (Sega license)", "Champion Base Ball", MACHINE_SUPPORTS_SAVE ) |
| 1203 | GAME( 1983, champbas, 0, champbas, champbas, champbas_state, champbas, ROT0, "Alpha Denshi Co. (Sega license)", "Champion Base Ball", MACHINE_SUPPORTS_SAVE ) // no protection |
| 1203 | 1204 | GAME( 1983, champbasj, champbas, champbasj, champbas, champbas_state, champbas, ROT0, "Alpha Denshi Co.", "Champion Base Ball (Japan set 1)", MACHINE_SUPPORTS_SAVE ) |
| 1204 | | GAME( 1983, champbasja, champbas, champbasja, champbas, champbas_state, champbas, ROT0, "Alpha Denshi Co.", "Champion Base Ball (Japan set 2)", MACHINE_SUPPORTS_SAVE ) |
| 1205 | GAME( 1983, champbasja, champbas, champbasja, champbas, champbas_state, champbas, ROT0, "Alpha Denshi Co.", "Champion Base Ball (Japan set 2)", MACHINE_SUPPORTS_SAVE ) // simplified protection, no mcu |
| 1205 | 1206 | GAME( 1983, champbb2, 0, champbb2, champbas, champbas_state, champbas, ROT0, "Alpha Denshi Co. (Sega license)", "Champion Base Ball Part-2 (set 1)", MACHINE_SUPPORTS_SAVE ) |
| 1206 | 1207 | GAME( 1983, champbb2a, champbb2, champbb2, champbas, champbas_state, champbas, ROT0, "Alpha Denshi Co.", "Champion Base Ball Part-2 (set 2)", MACHINE_NOT_WORKING | MACHINE_SUPPORTS_SAVE ) // incomplete dump |
| 1207 | 1208 | GAME( 1983, champbb2j, champbb2, champbb2, champbas, champbas_state, champbas, ROT0, "Alpha Denshi Co.", "Champion Base Ball Part-2 (Japan)", MACHINE_SUPPORTS_SAVE ) |
| r250110 | r250111 | |
|---|
| 1211 | 1212 | GAME( 1983, exctsccra, exctsccr, exctsccr, exctsccr, champbas_state, exctsccr, ROT270, "Alpha Denshi Co.", "Exciting Soccer (alternate music)", MACHINE_SUPPORTS_SAVE ) |
| 1212 | 1213 | GAME( 1983, exctsccrj, exctsccr, exctsccr, exctsccr, champbas_state, exctsccr, ROT270, "Alpha Denshi Co.", "Exciting Soccer (Japan)", MACHINE_SUPPORTS_SAVE ) |
| 1213 | 1214 | GAME( 1983, exctsccrjo, exctsccr, exctsccr, exctsccr, champbas_state, exctsccr, ROT270, "Alpha Denshi Co.", "Exciting Soccer (Japan, older)", MACHINE_SUPPORTS_SAVE ) |
| 1214 | | GAME( 1983, exctsccrb, exctsccr, exctsccrb, exctsccr, champbas_state, exctsccr, ROT270, "bootleg (Kazutomi)", "Exciting Soccer (bootleg)", MACHINE_SUPPORTS_SAVE ) |
| 1215 | GAME( 1983, exctsccrb, exctsccr, exctsccrb, exctsccr, champbas_state, exctsccr, ROT270, "bootleg (Kazutomi)", "Exciting Soccer (bootleg)", MACHINE_SUPPORTS_SAVE ) // on champbasj hardware |
| 1215 | 1216 | GAME( 1984, exctscc2, 0, exctsccr, exctsccr, champbas_state, exctsccr, ROT270, "Alpha Denshi Co.", "Exciting Soccer II", MACHINE_SUPPORTS_SAVE ) |
trunk/src/mame/drivers/dorachan.c
| r250110 | r250111 | |
|---|
| 19 | 19 | public: |
| 20 | 20 | dorachan_state(const machine_config &mconfig, device_type type, const char *tag) |
| 21 | 21 | : driver_device(mconfig, type, tag), |
| 22 | | m_videoram(*this, "videoram"), |
| 23 | 22 | m_maincpu(*this, "maincpu"), |
| 24 | 23 | m_screen(*this, "screen"), |
| 25 | 24 | m_palette(*this, "palette"), |
| 26 | | m_colors(*this, "colors") { } |
| 25 | m_videoram(*this, "videoram"), |
| 26 | m_colors(*this, "colors") |
| 27 | { } |
| 27 | 28 | |
| 28 | | /* memory pointers */ |
| 29 | | required_shared_ptr<UINT8> m_videoram; |
| 30 | | |
| 31 | | /* video-related */ |
| 32 | | UINT8 m_flip_screen; |
| 33 | | |
| 34 | | /* devices */ |
| 35 | | DECLARE_WRITE8_MEMBER(dorachan_ctrl_w); |
| 36 | | DECLARE_CUSTOM_INPUT_MEMBER(dorachan_protection_r); |
| 37 | | DECLARE_CUSTOM_INPUT_MEMBER(dorachan_v128_r); |
| 38 | | virtual void machine_start(); |
| 39 | | virtual void machine_reset(); |
| 40 | | UINT32 screen_update_dorachan(screen_device &screen, bitmap_rgb32 &bitmap, const rectangle &cliprect); |
| 29 | // devices, memory pointers |
| 41 | 30 | required_device<cpu_device> m_maincpu; |
| 42 | 31 | required_device<screen_device> m_screen; |
| 43 | 32 | required_device<palette_device> m_palette; |
| 33 | |
| 34 | required_shared_ptr<UINT8> m_videoram; |
| 44 | 35 | required_region_ptr<UINT8> m_colors; |
| 45 | | }; |
| 46 | 36 | |
| 37 | // internal state |
| 38 | UINT8 m_flip_screen; |
| 47 | 39 | |
| 48 | | /************************************* |
| 49 | | * |
| 50 | | * Protection handling |
| 51 | | * |
| 52 | | *************************************/ |
| 40 | DECLARE_WRITE8_MEMBER(control_w); |
| 41 | DECLARE_READ8_MEMBER(protection_r); |
| 42 | DECLARE_READ8_MEMBER(v128_r); |
| 43 | UINT32 screen_update_dorachan(screen_device &screen, bitmap_rgb32 &bitmap, const rectangle &cliprect); |
| 53 | 44 | |
| 54 | | CUSTOM_INPUT_MEMBER(dorachan_state::dorachan_protection_r) |
| 55 | | { |
| 56 | | UINT8 ret = 0; |
| 45 | virtual void machine_start(); |
| 46 | virtual void machine_reset(); |
| 47 | }; |
| 57 | 48 | |
| 58 | | switch (m_maincpu->pcbase()) |
| 59 | | { |
| 60 | | case 0x70ce: ret = 0xf2; break; |
| 61 | | case 0x72a2: ret = 0xd5; break; |
| 62 | | case 0x72b5: ret = 0xcb; break; |
| 63 | 49 | |
| 64 | | default: |
| 65 | | osd_printf_debug("unhandled $2400 read @ %x\n", m_maincpu->pcbase()); |
| 66 | | break; |
| 67 | | } |
| 68 | 50 | |
| 69 | | return ret; |
| 70 | | } |
| 71 | | |
| 72 | | |
| 73 | | |
| 74 | 51 | /************************************* |
| 75 | 52 | * |
| 76 | 53 | * Video system |
| r250110 | r250111 | |
|---|
| 110 | 87 | } |
| 111 | 88 | |
| 112 | 89 | |
| 113 | | WRITE8_MEMBER(dorachan_state::dorachan_ctrl_w) |
| 90 | |
| 91 | /************************************* |
| 92 | * |
| 93 | * I/O handlers |
| 94 | * |
| 95 | *************************************/ |
| 96 | |
| 97 | READ8_MEMBER(dorachan_state::protection_r) |
| 114 | 98 | { |
| 115 | | m_flip_screen = (data >> 6) & 0x01; |
| 99 | UINT8 ret = 0; |
| 100 | |
| 101 | switch (m_maincpu->pcbase()) |
| 102 | { |
| 103 | case 0x70ce: ret = 0xf2; break; |
| 104 | case 0x72a2: ret = 0xd5; break; |
| 105 | case 0x72b5: ret = 0xcb; break; |
| 106 | |
| 107 | default: |
| 108 | osd_printf_debug("unhandled $2400 read @ %x\n", m_maincpu->pcbase()); |
| 109 | break; |
| 110 | } |
| 111 | |
| 112 | return ret; |
| 116 | 113 | } |
| 117 | 114 | |
| 115 | READ8_MEMBER(dorachan_state::v128_r) |
| 116 | { |
| 117 | // to avoid resetting (when player 2 starts) bit 0 need to be inverted when screen is flipped |
| 118 | return 0xfe | ((m_screen->vpos() >> 7 & 1) ^ m_flip_screen); |
| 119 | } |
| 118 | 120 | |
| 119 | | CUSTOM_INPUT_MEMBER(dorachan_state::dorachan_v128_r) |
| 121 | WRITE8_MEMBER(dorachan_state::control_w) |
| 120 | 122 | { |
| 121 | | /* to avoid resetting (when player 2 starts) bit 0 need to be inverted when screen is flipped */ |
| 122 | | return ((m_screen->vpos() >> 7) & 0x01) ^ m_flip_screen; |
| 123 | // d6: flip screen |
| 124 | // other: ? |
| 125 | m_flip_screen = data >> 6 & 1; |
| 123 | 126 | } |
| 124 | 127 | |
| 125 | 128 | |
| 126 | | |
| 127 | | /************************************* |
| 128 | | * |
| 129 | | * Memory handlers |
| 130 | | * |
| 131 | | *************************************/ |
| 132 | | |
| 133 | 129 | static ADDRESS_MAP_START( dorachan_map, AS_PROGRAM, 8, dorachan_state ) |
| 134 | 130 | AM_RANGE(0x0000, 0x17ff) AM_ROM |
| 135 | 131 | AM_RANGE(0x1800, 0x1fff) AM_RAM |
| 136 | 132 | AM_RANGE(0x2000, 0x23ff) AM_ROM |
| 137 | | AM_RANGE(0x2400, 0x2400) AM_MIRROR(0x03ff) AM_READ_PORT("PROT") |
| 138 | | AM_RANGE(0x2800, 0x2800) AM_MIRROR(0x03ff) AM_READ_PORT("SYSTEM") |
| 139 | | AM_RANGE(0x2c00, 0x2c00) AM_MIRROR(0x03ff) AM_READ_PORT("JOY") |
| 140 | | AM_RANGE(0x3800, 0x3800) AM_MIRROR(0x03ff) AM_READ_PORT("V128") |
| 133 | AM_RANGE(0x2400, 0x2400) AM_MIRROR(0x03ff) AM_READ(protection_r) |
| 134 | AM_RANGE(0x2800, 0x2800) AM_MIRROR(0x03ff) AM_READ_PORT("IN0") |
| 135 | AM_RANGE(0x2c00, 0x2c00) AM_MIRROR(0x03ff) AM_READ_PORT("IN1") |
| 136 | AM_RANGE(0x3800, 0x3800) AM_MIRROR(0x03ff) AM_READ(v128_r) |
| 141 | 137 | AM_RANGE(0x4000, 0x5fff) AM_RAM AM_SHARE("videoram") |
| 142 | 138 | AM_RANGE(0x6000, 0x77ff) AM_ROM |
| 143 | 139 | ADDRESS_MAP_END |
| 144 | 140 | |
| 145 | | |
| 146 | | |
| 147 | | /************************************* |
| 148 | | * |
| 149 | | * Port handlers |
| 150 | | * |
| 151 | | *************************************/ |
| 152 | | |
| 153 | 141 | static ADDRESS_MAP_START( dorachan_io_map, AS_IO, 8, dorachan_state ) |
| 154 | 142 | ADDRESS_MAP_GLOBAL_MASK(0xff) |
| 155 | 143 | AM_RANGE(0x01, 0x01) AM_WRITENOP |
| 156 | 144 | AM_RANGE(0x02, 0x02) AM_WRITENOP |
| 157 | | AM_RANGE(0x03, 0x03) AM_WRITE(dorachan_ctrl_w) |
| 145 | AM_RANGE(0x03, 0x03) AM_WRITE(control_w) |
| 158 | 146 | ADDRESS_MAP_END |
| 159 | 147 | |
| 160 | 148 | |
| r250110 | r250111 | |
|---|
| 166 | 154 | *************************************/ |
| 167 | 155 | |
| 168 | 156 | static INPUT_PORTS_START( dorachan ) |
| 169 | | PORT_START("PROT") |
| 170 | | PORT_BIT( 0xff, IP_ACTIVE_HIGH, IPT_SPECIAL ) PORT_CUSTOM_MEMBER(DEVICE_SELF, dorachan_state,dorachan_protection_r, NULL) |
| 171 | | |
| 172 | | PORT_START("SYSTEM") |
| 157 | PORT_START("IN0") |
| 173 | 158 | PORT_BIT( 0x01, IP_ACTIVE_LOW, IPT_COIN1 ) |
| 174 | 159 | PORT_BIT( 0x02, IP_ACTIVE_LOW, IPT_START1 ) |
| 175 | 160 | PORT_BIT( 0x04, IP_ACTIVE_LOW, IPT_START2 ) |
| r250110 | r250111 | |
|---|
| 185 | 170 | PORT_DIPSETTING( 0x80, DEF_STR( Off ) ) |
| 186 | 171 | PORT_DIPSETTING( 0x00, DEF_STR( On ) ) |
| 187 | 172 | |
| 188 | | PORT_START("JOY") |
| 173 | PORT_START("IN1") |
| 189 | 174 | PORT_BIT( 0x01, IP_ACTIVE_LOW, IPT_JOYSTICK_DOWN ) PORT_COCKTAIL |
| 190 | 175 | PORT_BIT( 0x02, IP_ACTIVE_LOW, IPT_JOYSTICK_UP ) PORT_COCKTAIL |
| 191 | 176 | PORT_BIT( 0x04, IP_ACTIVE_LOW, IPT_JOYSTICK_LEFT ) PORT_COCKTAIL |
| r250110 | r250111 | |
|---|
| 194 | 179 | PORT_BIT( 0x20, IP_ACTIVE_LOW, IPT_JOYSTICK_UP ) |
| 195 | 180 | PORT_BIT( 0x40, IP_ACTIVE_LOW, IPT_JOYSTICK_LEFT ) |
| 196 | 181 | PORT_BIT( 0x80, IP_ACTIVE_LOW, IPT_JOYSTICK_RIGHT ) |
| 197 | | |
| 198 | | PORT_START("V128") |
| 199 | | PORT_BIT( 0x01, IP_ACTIVE_HIGH, IPT_SPECIAL ) PORT_CUSTOM_MEMBER(DEVICE_SELF, dorachan_state,dorachan_v128_r, NULL) |
| 200 | | PORT_BIT( 0xfe, IP_ACTIVE_LOW, IPT_UNUSED ) |
| 201 | 182 | INPUT_PORTS_END |
| 202 | 183 | |
| 203 | 184 | |
| r250110 | r250111 | |
|---|
| 219 | 200 | } |
| 220 | 201 | |
| 221 | 202 | static MACHINE_CONFIG_START( dorachan, dorachan_state ) |
| 203 | |
| 222 | 204 | /* basic machine hardware */ |
| 223 | 205 | MCFG_CPU_ADD("maincpu", Z80, 2000000) |
| 224 | 206 | MCFG_CPU_PROGRAM_MAP(dorachan_map) |
| r250110 | r250111 | |
|---|
| 228 | 210 | /* video hardware */ |
| 229 | 211 | MCFG_SCREEN_ADD("screen", RASTER) |
| 230 | 212 | MCFG_SCREEN_SIZE(32*8, 32*8) |
| 231 | | MCFG_SCREEN_VISIBLE_AREA(1*8, 31*8-1, 1*8, 31*8-1) |
| 213 | MCFG_SCREEN_VISIBLE_AREA(0*8, 32*8-1, 1*8, 31*8-1) |
| 232 | 214 | MCFG_SCREEN_REFRESH_RATE(60) |
| 233 | 215 | MCFG_SCREEN_UPDATE_DRIVER(dorachan_state, screen_update_dorachan) |
| 234 | 216 | |
| r250110 | r250111 | |
|---|
| 271 | 253 | * |
| 272 | 254 | *************************************/ |
| 273 | 255 | |
| 274 | | GAME( 1980, dorachan, 0, dorachan, dorachan, driver_device, 0, ROT270, "Craul Denshi", "Dorachan", MACHINE_NO_SOUND | MACHINE_SUPPORTS_SAVE ) |
| 256 | GAME( 1980, dorachan, 0, dorachan, dorachan, driver_device, 0, ROT270, "Alpha Denshi Co. / Craul Denshi", "Dora-chan (Japan)", MACHINE_NO_SOUND | MACHINE_SUPPORTS_SAVE ) |
trunk/src/mame/drivers/equites.c
| r250110 | r250111 | |
|---|
| 2 | 2 | // copyright-holders:Acho A. Tang, Nicola Salmoria |
| 3 | 3 | /******************************************************************************* |
| 4 | 4 | |
| 5 | | Equites (c) 1984 Alpha Denshi Co./Sega 8303 |
| 6 | | Bull Fighter (c) 1984 Alpha Denshi Co./Sega 8303 |
| 7 | | Gekisou (c) 1985 Eastern Corp. 8304 |
| 8 | | Violent Run (c) 1985 Eastern Corp. 8304? (probably on Equites HW) |
| 9 | | The Koukouyakyuh (c) 1985 Alpha Denshi Co. 8304 |
| 10 | | Splendor Blast (c) 1985 Alpha Denshi Co. 8303 |
| 11 | | High Voltage (c) 1985 Alpha Denshi Co. 8304 (POST says 8404) |
| 5 | Equites (c) 1984 Alpha Denshi Co./Sega |
| 6 | Bull Fighter (c) 1984 Alpha Denshi Co./Sega |
| 7 | Gekisou (c) 1985 Eastern Corp. |
| 8 | The Koukouyakyuh (c) 1985 Alpha Denshi Co. |
| 9 | Splendor Blast (c) 1985 Alpha Denshi Co. |
| 10 | High Voltage (c) 1985 Alpha Denshi Co. |
| 12 | 11 | |
| 12 | The following are not dumped yet: |
| 13 | Champion Croquet (c) 1984 Alpha Denshi Co. (sports) |
| 14 | Violent Run (c) 1985 Eastern Corp. (export version of Gekisou) |
| 15 | Tune Pit(?) (c) 1985 Alpha Denshi Co. |
| 16 | Perfect Janputer (c) 1984 Alpha Denshi Co. (4-player Mahjong) |
| 17 | |
| 18 | |
| 13 | 19 | Driver by Acho A. Tang, Nicola Salmoria |
| 14 | 20 | Many thanks to Corrado Tomaselli for precious hardware info. |
| 15 | 21 | |
| r250110 | r250111 | |
|---|
| 176 | 182 | Yasuhiro Ogawa for the correct Equites ROM information |
| 177 | 183 | |
| 178 | 184 | |
| 179 | | Other unemulated Alpha Denshi and SNK games that may use similar hardware: |
| 180 | | ----------------------------------------------------------- |
| 181 | | Maker Year Genre Name Japanese Name |
| 182 | | ----------------------------------------------------------- |
| 183 | | Alpha Denshi 1984 (SPT) Champion Croquet ?`?????s?I???N???b?P?[ |
| 184 | | Alpha Denshi 1985 (???) Tune Pit(?) ?`?F?[???s?b?g |
| 185 | | Alpha Denshi 1985 (MAJ) Perfect Janputer ?p?[?t?F?N?g?W?????s???[?^?[ |
| 186 | | |
| 187 | | |
| 188 | 185 | ******************************************************************************* |
| 189 | 186 | |
| 190 | 187 | Bull Fighter |
| r250110 | r250111 | |
|---|
| 261 | 258 | -----------------------------------------------------------------------| |
| 262 | 259 | |
| 263 | 260 | |
| 264 | | |
| 265 | | |
| 266 | 261 | -----------------------------------------------------------------------------------| |
| 267 | 262 | |ALPHA DENSHI CO, LTD. MAIN CONNECTOR BOARD | |
| 268 | 263 | | | |
| r250110 | r250111 | |
|---|
| 314 | 309 | |----------------------------------------------------------------------------------| |
| 315 | 310 | |
| 316 | 311 | |
| 317 | | |
| 318 | | |
| 319 | 312 | -------------------------------------------------------------------------------------| |
| 320 | 313 | |ALPHA DENSHI CO, LTD. LOWER BOARD | |
| 321 | 314 | | | |
| r250110 | r250111 | |
|---|
| 364 | 357 | |
| 365 | 358 | |
| 366 | 359 | *******************************************************************************/ |
| 367 | | // Directives |
| 368 | 360 | |
| 369 | 361 | #include "emu.h" |
| 370 | 362 | #include "cpu/m68000/m68000.h" |
| r250110 | r250111 | |
|---|
| 1909 | 1901 | GAME( 1984, equitess, equites, equites, equites, equites_state, equites, ROT90, "Alpha Denshi Co. (Sega license)", "Equites (Sega)", MACHINE_IMPERFECT_SOUND | MACHINE_SUPPORTS_SAVE ) |
| 1910 | 1902 | GAME( 1984, bullfgtr, 0, equites, bullfgtr, equites_state, bullfgtr, ROT90, "Alpha Denshi Co.", "Bull Fighter", MACHINE_IMPERFECT_SOUND | MACHINE_SUPPORTS_SAVE ) |
| 1911 | 1903 | GAME( 1984, bullfgtrs,bullfgtr, equites, bullfgtr, equites_state, bullfgtr, ROT90, "Alpha Denshi Co. (Sega license)", "Bull Fighter (Sega)", MACHINE_IMPERFECT_SOUND | MACHINE_SUPPORTS_SAVE ) |
| 1912 | | GAME( 1985, kouyakyu, 0, equites, kouyakyu, equites_state, kouyakyu, ROT0, "Alpha Denshi Co.", "The Koukouyakyuh", MACHINE_IMPERFECT_SOUND | MACHINE_SUPPORTS_SAVE ) |
| 1904 | GAME( 1985, kouyakyu, 0, equites, kouyakyu, equites_state, kouyakyu, ROT0, "Alpha Denshi Co.", "The Koukou Yakyuu", MACHINE_IMPERFECT_SOUND | MACHINE_SUPPORTS_SAVE ) |
| 1913 | 1905 | GAME( 1985, gekisou, 0, gekisou, gekisou, equites_state, gekisou, ROT90, "Eastern Corp.", "Gekisou (Japan)", MACHINE_UNEMULATED_PROTECTION | MACHINE_IMPERFECT_SOUND | MACHINE_IMPERFECT_GRAPHICS | MACHINE_SUPPORTS_SAVE ) |
| 1914 | 1906 | |
| 1915 | 1907 | // Splendor Blast Hardware |
trunk/src/mame/drivers/mz700.c
| r250110 | r250111 | |
|---|
| 59 | 59 | * D000-DFFF videoram or RAM |
| 60 | 60 | * E000-FFFF memory mapped IO or RAM |
| 61 | 61 | * |
| 62 | * ToDo: |
| 63 | - slows down while making sound |
| 64 | - MZ800: |
| 65 | - Had to patch the rom to load cassettes |
| 66 | - Port CF not done. |
| 67 | - Dips not connected. |
| 68 | - MZ800-mode display not working /Hi-res not coded. |
| 69 | - The CRTC is a very complex custom device, mostly unemulated. |
| 70 | - MZ1500: |
| 71 | - Various ports not done. |
| 72 | - Floppy disk and quick disk not done. |
| 73 | - F4 display is blank. |
| 74 | - Need manuals. |
| 75 | |
| 76 | Note: MZ800 hardware starts in memory map (mode A), but switches to MZ700 |
| 77 | compatibility mode (mode B) as soon as it starts up. We start in Mode B |
| 78 | because it helps MZ1500 get started and it doesn't break anything. |
| 79 | |
| 80 | * |
| 62 | 81 | *****************************************************************************/ |
| 63 | 82 | |
| 64 | 83 | #include "emu.h" |
| r250110 | r250111 | |
|---|
| 97 | 116 | ***************************************************************************/ |
| 98 | 117 | |
| 99 | 118 | static ADDRESS_MAP_START( mz700_mem, AS_PROGRAM, 8, mz_state ) |
| 119 | AM_RANGE(0x0000, 0x0fff) AM_READ_BANK("bankr0") AM_WRITE_BANK("bankw0") |
| 120 | AM_RANGE(0x1000, 0xcfff) AM_RAM |
| 121 | AM_RANGE(0xd000, 0xdfff) AM_RAMBANK("bankd") |
| 122 | AM_RANGE(0xe000, 0xffff) AM_DEVICE("banke", address_map_bank_device, amap8) |
| 100 | 123 | ADDRESS_MAP_END |
| 101 | 124 | |
| 125 | static ADDRESS_MAP_START( mz700_banke, AS_PROGRAM, 8, mz_state ) |
| 126 | // bank 0: ram (mz700_bank1) |
| 127 | AM_RANGE(0x0000, 0x1fff) AM_RAM |
| 128 | // bank 1: devices (mz700_bank3) |
| 129 | AM_RANGE(0x2000, 0x2003) AM_MIRROR(0x1ff0) AM_DEVREADWRITE("ppi8255", i8255_device, read, write) |
| 130 | AM_RANGE(0x2004, 0x2007) AM_MIRROR(0x1ff0) AM_DEVREADWRITE("pit8253", pit8253_device, read, write) |
| 131 | AM_RANGE(0x2008, 0x200b) AM_MIRROR(0x1ff0) AM_READWRITE(mz700_e008_r,mz700_e008_w) |
| 132 | AM_RANGE(0x200c, 0x200f) AM_MIRROR(0x1ff0) AM_NOP |
| 133 | // bank 2: switched out (mz700_bank5) |
| 134 | AM_RANGE(0x4000, 0x5fff) AM_NOP |
| 135 | ADDRESS_MAP_END |
| 136 | |
| 102 | 137 | static ADDRESS_MAP_START( mz700_io, AS_IO, 8, mz_state ) |
| 103 | 138 | ADDRESS_MAP_GLOBAL_MASK(0xff) |
| 104 | 139 | AM_RANGE(0xe0, 0xe0) AM_WRITE(mz700_bank_0_w) |
| r250110 | r250111 | |
|---|
| 111 | 146 | ADDRESS_MAP_END |
| 112 | 147 | |
| 113 | 148 | static ADDRESS_MAP_START( mz800_mem, AS_PROGRAM, 8, mz_state ) |
| 149 | AM_RANGE(0x0000, 0x0fff) AM_READ_BANK("bankr0") AM_WRITE_BANK("bankw0") |
| 150 | AM_RANGE(0x1000, 0x1fff) AM_RAMBANK("bank1") |
| 151 | AM_RANGE(0x2000, 0x7fff) AM_RAM |
| 152 | AM_RANGE(0x8000, 0xbfff) AM_RAMBANK("banka") |
| 153 | AM_RANGE(0xc000, 0xcfff) AM_RAMBANK("bankc") |
| 154 | AM_RANGE(0xd000, 0xdfff) AM_RAMBANK("bankd") |
| 155 | AM_RANGE(0xe000, 0xffff) AM_DEVICE("bankf", address_map_bank_device, amap8) |
| 114 | 156 | ADDRESS_MAP_END |
| 115 | 157 | |
| 158 | static ADDRESS_MAP_START( mz800_bankf, AS_PROGRAM, 8, mz_state ) |
| 159 | // bank 0: ram (mz700_bank1) |
| 160 | AM_RANGE(0x0000, 0x1fff) AM_RAM |
| 161 | // bank 1: devices (mz700_bank3) |
| 162 | AM_RANGE(0x2000, 0x2003) AM_DEVREADWRITE("ppi8255", i8255_device, read, write) |
| 163 | AM_RANGE(0x2004, 0x2007) AM_DEVREADWRITE("pit8253", pit8253_device, read, write) |
| 164 | AM_RANGE(0x2008, 0x200b) AM_READWRITE(mz700_e008_r,mz700_e008_w) |
| 165 | AM_RANGE(0x200c, 0x200f) AM_NOP |
| 166 | AM_RANGE(0x2010, 0x3fff) AM_ROM AM_REGION("monitor", 0x2010) |
| 167 | // bank 2: switched out (mz700_bank5) |
| 168 | AM_RANGE(0x4000, 0x5fff) AM_NOP |
| 169 | ADDRESS_MAP_END |
| 170 | |
| 116 | 171 | static ADDRESS_MAP_START( mz800_io, AS_IO, 8, mz_state ) |
| 117 | 172 | ADDRESS_MAP_GLOBAL_MASK(0xff) |
| 118 | 173 | AM_RANGE(0xcc, 0xcc) AM_WRITE(mz800_write_format_w ) |
| r250110 | r250111 | |
|---|
| 303 | 358 | }; |
| 304 | 359 | |
| 305 | 360 | static GFXDECODE_START( mz700 ) |
| 306 | | GFXDECODE_ENTRY("cgrom", 0, mz700_layout, 0, 256) |
| 361 | GFXDECODE_ENTRY("cgrom", 0, mz700_layout, 0, 4) |
| 307 | 362 | GFXDECODE_END |
| 308 | 363 | |
| 309 | 364 | static GFXDECODE_START( mz800 ) |
| 310 | | GFXDECODE_ENTRY(NULL, 0, mz700_layout, 0, 256) |
| 311 | | GFXDECODE_ENTRY("monitor", 0x1000, mz700_layout, 0, 256) // for mz800 viewer only |
| 365 | GFXDECODE_ENTRY("monitor", 0x1000, mz700_layout, 0, 4) // for mz800 viewer only |
| 312 | 366 | GFXDECODE_END |
| 313 | 367 | |
| 314 | 368 | |
| r250110 | r250111 | |
|---|
| 321 | 375 | MCFG_CPU_ADD("maincpu", Z80, XTAL_17_73447MHz/5) |
| 322 | 376 | MCFG_CPU_PROGRAM_MAP(mz700_mem) |
| 323 | 377 | MCFG_CPU_IO_MAP(mz700_io) |
| 378 | MCFG_DEVICE_ADD("banke", ADDRESS_MAP_BANK, 0) |
| 379 | MCFG_DEVICE_PROGRAM_MAP(mz700_banke) |
| 380 | MCFG_ADDRESS_MAP_BANK_ENDIANNESS(ENDIANNESS_LITTLE) |
| 381 | MCFG_ADDRESS_MAP_BANK_DATABUS_WIDTH(8) |
| 382 | MCFG_ADDRESS_MAP_BANK_ADDRBUS_WIDTH(16) |
| 383 | MCFG_ADDRESS_MAP_BANK_STRIDE(0x2000) |
| 324 | 384 | |
| 385 | MCFG_MACHINE_RESET_OVERRIDE(mz_state, mz700) |
| 325 | 386 | |
| 326 | 387 | /* video hardware */ |
| 327 | 388 | MCFG_SCREEN_ADD("screen", RASTER) |
| 328 | 389 | MCFG_SCREEN_RAW_PARAMS(XTAL_17_73447MHz/2, 568, 0, 40*8, 312, 0, 25*8) |
| 329 | 390 | MCFG_SCREEN_UPDATE_DRIVER(mz_state, screen_update_mz700) |
| 330 | 391 | MCFG_SCREEN_PALETTE("palette") |
| 392 | MCFG_PALETTE_ADD_3BIT_RGB("palette") |
| 331 | 393 | |
| 332 | 394 | MCFG_GFXDECODE_ADD("gfxdecode", "palette", mz700) |
| 333 | | MCFG_PALETTE_ADD("palette", 256*2) |
| 334 | | MCFG_PALETTE_INDIRECT_ENTRIES(8) |
| 335 | | MCFG_PALETTE_INIT_OWNER(mz_state, mz) |
| 336 | 395 | |
| 337 | 396 | /* sound hardware */ |
| 338 | 397 | MCFG_SPEAKER_STANDARD_MONO("mono") |
| 339 | 398 | MCFG_SOUND_WAVE_ADD(WAVE_TAG, "cassette") |
| 340 | | MCFG_SOUND_ROUTE(ALL_OUTPUTS, "mono", 0.25) |
| 399 | MCFG_SOUND_ROUTE(ALL_OUTPUTS, "mono", 0.05) |
| 341 | 400 | MCFG_SOUND_ADD("speaker", SPEAKER_SOUND, 0) |
| 342 | 401 | MCFG_SOUND_ROUTE(ALL_OUTPUTS, "mono", 0.50) |
| 343 | 402 | |
| r250110 | r250111 | |
|---|
| 376 | 435 | |
| 377 | 436 | |
| 378 | 437 | static MACHINE_CONFIG_DERIVED( mz800, mz700 ) |
| 438 | MCFG_DEVICE_REMOVE("banke") |
| 379 | 439 | |
| 380 | 440 | /* basic machine hardware */ |
| 381 | 441 | MCFG_CPU_MODIFY("maincpu") |
| 382 | 442 | MCFG_CPU_PROGRAM_MAP(mz800_mem) |
| 383 | 443 | MCFG_CPU_IO_MAP(mz800_io) |
| 444 | MCFG_DEVICE_ADD("bankf", ADDRESS_MAP_BANK, 0) |
| 445 | MCFG_DEVICE_PROGRAM_MAP(mz800_bankf) |
| 446 | MCFG_ADDRESS_MAP_BANK_ENDIANNESS(ENDIANNESS_LITTLE) |
| 447 | MCFG_ADDRESS_MAP_BANK_DATABUS_WIDTH(8) |
| 448 | MCFG_ADDRESS_MAP_BANK_ADDRBUS_WIDTH(16) |
| 449 | MCFG_ADDRESS_MAP_BANK_STRIDE(0x2000) |
| 384 | 450 | |
| 451 | MCFG_MACHINE_RESET_OVERRIDE(mz_state, mz800) |
| 385 | 452 | MCFG_GFXDECODE_MODIFY("gfxdecode",mz800) |
| 386 | 453 | |
| 387 | | MCFG_VIDEO_START_OVERRIDE(mz_state,mz800) |
| 388 | | |
| 389 | 454 | MCFG_SCREEN_MODIFY("screen") |
| 390 | 455 | MCFG_SCREEN_UPDATE_DRIVER(mz_state, screen_update_mz800) |
| 391 | 456 | |
| r250110 | r250111 | |
|---|
| 435 | 500 | ROM_START( mz800 ) |
| 436 | 501 | ROM_REGION( 0x4000, "monitor", 0 ) |
| 437 | 502 | ROM_LOAD( "mz800.rom", 0x0000, 0x4000, CRC(600d17e1) SHA1(950ce4b51429916f8036e41ba6130fac149b36e4) ) |
| 503 | // fix cassette loading |
| 504 | ROM_FILL(0x761,1,0x13) |
| 505 | ROM_FILL(0xA4B,1,0x45) |
| 506 | |
| 507 | ROM_REGION( 0x10000, "user1", ROMREGION_ERASE00 ) // ramdisk |
| 438 | 508 | ROM_END |
| 439 | 509 | |
| 440 | 510 | ROM_START( mz1500 ) |
| 441 | 511 | ROM_REGION( 0x4000, "monitor", 0 ) |
| 442 | | ROM_LOAD( "9z-502m.rom", 0x0000, 0x2800, CRC(643db428) SHA1(c2ad8af2ef00db32afde54d5741b07de5d4da16a)) |
| 512 | ROM_LOAD( "9z-502m.rom", 0x0000, 0x1000, CRC(643db428) SHA1(c2ad8af2ef00db32afde54d5741b07de5d4da16a)) |
| 513 | ROM_CONTINUE(0x2800, 0x1800) |
| 514 | |
| 443 | 515 | ROM_REGION( 0x1000, "cgrom", 0 ) |
| 444 | 516 | //ROM_LOAD( "mz700fon.jp", 0x0000, 0x1000, CRC(697ec121) SHA1(5eb1d42d273b1fd2cab120486279ab8ff6c85dc7)) |
| 445 | 517 | ROM_LOAD( "mz700fon.jpn", 0x0000, 0x1000, CRC(425eedf5) SHA1(bd2cc750f2d2f63e50a59786668509e81a276e32) ) |
| 518 | |
| 519 | ROM_REGION( 0x10000, "user1", ROMREGION_ERASE00 ) // ramdisk |
| 446 | 520 | ROM_END |
| 447 | 521 | |
| 448 | 522 | /*************************************************************************** |
trunk/src/mame/drivers/pong.c
| r250110 | r250111 | |
|---|
| 3 | 3 | /*************************************************************************** |
| 4 | 4 | |
| 5 | 5 | Pong (c) 1972 Atari |
| 6 | Pong Doubles (c) 1973 Atari |
| 7 | Breakout (c) 1976 Atari |
| 6 | 8 | |
| 7 | 9 | driver by Couriersud |
| 8 | 10 | |
| 11 | |
| 12 | Atari Pong Games List - Data based, in part from: |
| 13 | |
| 14 | - "Andy's collection of Bronzeage Atari Video Arcade PCBs" |
| 15 | http://www.andysarcade.net/personal/bronzeage/index.htm |
| 16 | |
| 17 | - "Atari's Technical Manual Log" |
| 18 | http://www.atarigames.com/manuals.txt |
| 19 | |
| 20 | Suspected "same games" are grouped together. These are usually the exact same game but different cabinet/name. |
| 21 | |
| 22 | Technical Manual #s Game Name(s) Atari Part #'s Data |
| 23 | -------------------+----------------------------------------------------------+----------------------------------+---------+ |
| 24 | TM-058 Breakout/Breakout Cocktail/Consolette (1976) A004533 NO |
| 25 | TM-015 Cocktail Pong/Coup Franc (1974) A001433? NO |
| 26 | TM-0?? Dr. Pong/Puppy Pong/Snoopy Pong (1974) A001433? NO |
| 27 | TM-013 Pong (1972) A001433 NO |
| 28 | TM-014 Pong Doubles/Coupe Davis (1973) A000785 NO |
| 29 | 422 Superpong (1974) A000423 NO |
| 30 | |
| 9 | 31 | Notes: |
| 10 | 32 | |
| 11 | | TODO: please see netlist include files |
| 33 | TODO: Please see netlist include files |
| 34 | TODO: Breakout Cocktail and Consolette are believed to use the Breakout PCB with different cabinet designs, this needs to be verified. |
| 35 | TODO: Coupe Davis is believed to use the Pong Doubles PCB, just a different cabinet design, this needs to be verified. |
| 36 | TODO: Dr. Pong, Puppy Pong, Snoopy Pong, Cocktail Pong and Coup Franc are all believed to use the Pong (Rev E) PCB, but |
| 37 | different cabinet designs; this needs to be verified. |
| 38 | TODO: Superpong is believed to use the Pong (Rev E) PCB with some minor modifications, this needs to be verified. |
| 12 | 39 | |
| 13 | 40 | ***************************************************************************/ |
| 14 | 41 | |
| r250110 | r250111 | |
|---|
| 490 | 517 | ROM_REGION( 0x10000, "maincpu", ROMREGION_ERASE00 ) |
| 491 | 518 | ROM_END |
| 492 | 519 | |
| 520 | /* // 100% TTL - NO ROMS |
| 521 | |
| 522 | ROM_START( coupedav ) // dummy to satisfy game entry |
| 523 | ROM_REGION( 0x10000, "maincpu", ROMREGION_ERASE00 ) |
| 524 | ROM_END |
| 525 | |
| 526 | ROM_START( coupfran ) // dummy to satisfy game entry |
| 527 | ROM_REGION( 0x10000, "maincpu", ROMREGION_ERASE00 ) |
| 528 | ROM_END |
| 529 | |
| 530 | ROM_START( cktpong ) // dummy to satisfy game entry |
| 531 | ROM_REGION( 0x10000, "maincpu", ROMREGION_ERASE00 ) |
| 532 | ROM_END |
| 533 | |
| 534 | ROM_START( drpong ) // dummy to satisfy game entry |
| 535 | ROM_REGION( 0x10000, "maincpu", ROMREGION_ERASE00 ) |
| 536 | ROM_END |
| 537 | |
| 538 | ROM_START( pupppong ) // dummy to satisfy game entry |
| 539 | ROM_REGION( 0x10000, "maincpu", ROMREGION_ERASE00 ) |
| 540 | ROM_END |
| 541 | |
| 542 | ROM_START( snoopong ) // dummy to satisfy game entry |
| 543 | ROM_REGION( 0x10000, "maincpu", ROMREGION_ERASE00 ) |
| 544 | ROM_END |
| 545 | |
| 546 | ROM_START( suprpong ) // dummy to satisfy game entry |
| 547 | ROM_REGION( 0x10000, "maincpu", ROMREGION_ERASE00 ) |
| 548 | ROM_END |
| 549 | |
| 550 | ROM_START( breakckt ) // dummy to satisfy game entry |
| 551 | ROM_REGION( 0x10000, "maincpu", ROMREGION_ERASE00 ) |
| 552 | ROM_END |
| 553 | |
| 554 | ROM_START( consolet ) // dummy to satisfy game entry |
| 555 | ROM_REGION( 0x10000, "maincpu", ROMREGION_ERASE00 ) |
| 556 | ROM_END |
| 557 | */ |
| 558 | |
| 493 | 559 | GAME( 1972, pong, 0, pong, pong, driver_device, 0, ROT0, "Atari", "Pong (Rev E) external [TTL]", MACHINE_SUPPORTS_SAVE) |
| 494 | | GAME( 1972, pongf, 0, pongf, pong, driver_device, 0, ROT0, "Atari", "Pong (Rev E) [TTL]", MACHINE_SUPPORTS_SAVE ) |
| 495 | | GAME( 1974, pongd, 0, pongd, pongd, driver_device, 0, ROT0, "Atari", "Pong Doubles [TTL]", MACHINE_SUPPORTS_SAVE ) |
| 560 | GAME( 1972, pongf, 0, pongf, pong, driver_device, 0, ROT0, "Atari", "Pong (Rev E) [TTL]", MACHINE_SUPPORTS_SAVE) |
| 561 | GAME( 1973, pongd, 0, pongd, pongd, driver_device, 0, ROT0, "Atari", "Pong Doubles [TTL]", MACHINE_SUPPORTS_SAVE) |
| 496 | 562 | GAMEL( 1976, breakout, 0, breakout, breakout, driver_device, 0, ROT90, "Atari", "Breakout [TTL]", MACHINE_SUPPORTS_SAVE, layout_breakout) |
| 563 | |
| 564 | // 100% TTL |
| 565 | //GAME( 1973, coupedav, pongd, pongd, pongd, driver_device, 0, ROT0, "Atari France", "Coupe Davis [TTL]", MACHINE_SUPPORTS_SAVE) |
| 566 | //GAME( 1974, coupfran, pong, pong, pong, driver_device, 0, ROT0, "Atari Europe", "Coup Franc [TTL]", MACHINE_SUPPORTS_SAVE) |
| 567 | //GAME( 1974, cktpong, pong, pong, pong, driver_device, 0, ROT0, "Atari / National Entertainment Co.", "Cocktail Pong [TTL]", MACHINE_SUPPORTS_SAVE) |
| 568 | //GAME( 1974, drpong, pong, pong, pong, driver_device, 0, ROT0, "Atari", "Dr. Pong [TTL]", MACHINE_SUPPORTS_SAVE) |
| 569 | //GAME( 1974, pupppong, pong, pong, pong, driver_device, 0, ROT0, "Atari", "Puppy Pong [TTL]", MACHINE_SUPPORTS_SAVE) |
| 570 | //GAME( 1974, snoopong, pong, pong, pong, driver_device, 0, ROT0, "Atari", "Snoopy Pong [TTL]", MACHINE_SUPPORTS_SAVE) |
| 571 | //GAME( 1974, suprpong, 0, suprpong, pong, driver_device, 0, ROT0, "Atari", "Superpong [TTL]", MACHINE_SUPPORTS_SAVE) |
| 572 | //GAMEL( 1976, breakckt, breakout, breakout, breakout, driver_device, 0, ROT90, "Atari", "Breakout Cocktail [TTL]", MACHINE_SUPPORTS_SAVE, layout_breakckt) |
| 573 | //GAMEL( 1976, consolet, breakout, breakout, breakout, driver_device, 0, ROT90, "Atari Europe", "Consolette [TTL]", MACHINE_SUPPORTS_SAVE, layout_consolet) |
trunk/src/mame/includes/mz700.h
| r250110 | r250111 | |
|---|
| 16 | 16 | #include "sound/speaker.h" |
| 17 | 17 | #include "imagedev/cassette.h" |
| 18 | 18 | #include "bus/centronics/ctronics.h" |
| 19 | #include "machine/bankdev.h" |
| 19 | 20 | #include "machine/ram.h" |
| 20 | 21 | |
| 21 | 22 | class mz_state : public driver_device |
| 22 | 23 | { |
| 23 | 24 | public: |
| 24 | 25 | mz_state(const machine_config &mconfig, device_type type, const char *tag) |
| 25 | | : driver_device(mconfig, type, tag), |
| 26 | | m_maincpu(*this, "maincpu"), |
| 27 | | m_speaker(*this, "speaker"), |
| 28 | | m_pit(*this, "pit8253"), |
| 29 | | m_ppi(*this, "ppi8255"), |
| 30 | | m_cassette(*this, "cassette"), |
| 31 | | m_centronics(*this, "centronics"), |
| 32 | | m_ram(*this, RAM_TAG), |
| 33 | | m_gfxdecode(*this, "gfxdecode"), |
| 34 | | m_palette(*this, "palette") { } |
| 26 | : driver_device(mconfig, type, tag) |
| 27 | , m_maincpu(*this, "maincpu") |
| 28 | , m_speaker(*this, "speaker") |
| 29 | , m_pit(*this, "pit8253") |
| 30 | , m_ppi(*this, "ppi8255") |
| 31 | , m_cassette(*this, "cassette") |
| 32 | , m_centronics(*this, "centronics") |
| 33 | , m_ram(*this, RAM_TAG) |
| 34 | , m_palette(*this, "palette") |
| 35 | , m_banke(*this, "banke") |
| 36 | , m_bankf(*this, "bankf") |
| 37 | { } |
| 35 | 38 | |
| 36 | | int m_mz700; /* 1 if running on an mz700 */ |
| 37 | | |
| 38 | | int m_cursor_timer; |
| 39 | | int m_other_timer; |
| 40 | | |
| 41 | | int m_intmsk; /* PPI8255 pin PC2 */ |
| 42 | | |
| 43 | | int m_mz700_ram_lock; /* 1 if ram lock is active */ |
| 44 | | int m_mz700_ram_vram; /* 1 if vram is banked in */ |
| 45 | | |
| 46 | | /* mz800 specific */ |
| 47 | | UINT8 *m_cgram; |
| 48 | | |
| 49 | | int m_mz700_mode; /* 1 if in mz700 mode */ |
| 50 | | int m_mz800_ram_lock; /* 1 if lock is active */ |
| 51 | | int m_mz800_ram_monitor; /* 1 if monitor rom banked in */ |
| 52 | | |
| 53 | | int m_hires_mode; /* 1 if in 640x200 mode */ |
| 54 | | int m_screennum; /* screen designation */ |
| 55 | | |
| 56 | | int m_centronics_busy; |
| 57 | | int m_centronics_perror; |
| 58 | | |
| 59 | | UINT8 *m_colorram; |
| 60 | | UINT8 *m_videoram; |
| 61 | | UINT8 m_speaker_level; |
| 62 | | UINT8 m_prev_state; |
| 63 | | UINT16 m_mz800_ramaddr; |
| 64 | | UINT8 m_mz800_palette[4]; |
| 65 | | UINT8 m_mz800_palette_bank; |
| 66 | 39 | DECLARE_READ8_MEMBER(mz700_e008_r); |
| 67 | 40 | DECLARE_WRITE8_MEMBER(mz700_e008_w); |
| 68 | 41 | DECLARE_READ8_MEMBER(mz800_bank_0_r); |
| r250110 | r250111 | |
|---|
| 87 | 60 | DECLARE_WRITE8_MEMBER(mz800_cgram_w); |
| 88 | 61 | DECLARE_DRIVER_INIT(mz800); |
| 89 | 62 | DECLARE_DRIVER_INIT(mz700); |
| 63 | DECLARE_MACHINE_RESET(mz700); |
| 64 | DECLARE_MACHINE_RESET(mz800); |
| 90 | 65 | virtual void machine_start(); |
| 91 | | DECLARE_PALETTE_INIT(mz); |
| 92 | | DECLARE_VIDEO_START(mz800); |
| 93 | 66 | UINT32 screen_update_mz700(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect); |
| 94 | 67 | UINT32 screen_update_mz800(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect); |
| 95 | 68 | TIMER_DEVICE_CALLBACK_MEMBER(ne556_cursor_callback); |
| r250110 | r250111 | |
|---|
| 105 | 78 | DECLARE_WRITE8_MEMBER(mz800_z80pio_port_a_w); |
| 106 | 79 | DECLARE_WRITE_LINE_MEMBER(write_centronics_busy); |
| 107 | 80 | DECLARE_WRITE_LINE_MEMBER(write_centronics_perror); |
| 81 | |
| 82 | private: |
| 83 | int m_mz700; /* 1 if running on an mz700 */ |
| 84 | |
| 85 | int m_cursor_timer; |
| 86 | int m_other_timer; |
| 87 | |
| 88 | int m_intmsk; /* PPI8255 pin PC2 */ |
| 89 | |
| 90 | int m_mz700_ram_lock; /* 1 if ram lock is active */ |
| 91 | int m_mz700_ram_vram; /* 1 if vram is banked in */ |
| 92 | |
| 93 | /* mz800 specific */ |
| 94 | UINT8 *m_cgram; |
| 95 | UINT8 *m_p_chargen; |
| 96 | |
| 97 | int m_mz700_mode; /* 1 if in mz700 mode */ |
| 98 | int m_mz800_ram_lock; /* 1 if lock is active */ |
| 99 | int m_mz800_ram_monitor; /* 1 if monitor rom banked in */ |
| 100 | |
| 101 | int m_hires_mode; /* 1 if in 640x200 mode */ |
| 102 | int m_screennum; /* screen designation */ |
| 103 | |
| 104 | int m_centronics_busy; |
| 105 | int m_centronics_perror; |
| 106 | |
| 107 | UINT8 *m_colorram; |
| 108 | UINT8 *m_videoram; |
| 109 | UINT8 m_speaker_level; |
| 110 | UINT8 m_prev_state; |
| 111 | UINT16 m_mz800_ramaddr; |
| 112 | UINT8 m_mz800_palette[4]; |
| 113 | UINT8 m_mz800_palette_bank; |
| 114 | |
| 108 | 115 | required_device<cpu_device> m_maincpu; |
| 109 | 116 | required_device<speaker_sound_device> m_speaker; |
| 110 | 117 | required_device<pit8253_device> m_pit; |
| r250110 | r250111 | |
|---|
| 112 | 119 | required_device<cassette_image_device> m_cassette; |
| 113 | 120 | optional_device<centronics_device> m_centronics; |
| 114 | 121 | required_device<ram_device> m_ram; |
| 115 | | required_device<gfxdecode_device> m_gfxdecode; |
| 116 | 122 | required_device<palette_device> m_palette; |
| 123 | optional_device<address_map_bank_device> m_banke; |
| 124 | optional_device<address_map_bank_device> m_bankf; |
| 117 | 125 | }; |
| 118 | 126 | |
| 119 | 127 | #endif /* MZ700_H_ */ |
trunk/src/mame/machine/mz700.c
| r250110 | r250111 | |
|---|
| 42 | 42 | m_mz700 = TRUE; |
| 43 | 43 | m_mz700_mode = TRUE; |
| 44 | 44 | |
| 45 | | m_videoram = auto_alloc_array(machine(), UINT8, 0x800); |
| 46 | | memset(m_videoram, 0, sizeof(UINT8) * 0x800); |
| 47 | | m_colorram = auto_alloc_array(machine(), UINT8, 0x800); |
| 48 | | memset(m_colorram, 0, sizeof(UINT8) * 0x800); |
| 45 | m_videoram = auto_alloc_array(machine(), UINT8, 0x1000); |
| 46 | memset(m_videoram, 0, sizeof(UINT8) * 0x1000); |
| 47 | m_colorram = m_videoram + 0x800; |
| 48 | |
| 49 | m_p_chargen = memregion("cgrom")->base(); |
| 50 | UINT8 *rom = memregion("monitor")->base(); |
| 51 | UINT8 *ram = m_ram->pointer(); |
| 52 | membank("bankr0")->configure_entry(0, &ram[0]); // ram |
| 53 | membank("bankr0")->configure_entry(1, &rom[0]); // rom |
| 54 | membank("bankw0")->configure_entry(0, &ram[0]); // ram |
| 55 | membank("bankd")->configure_entry(0, &ram[0xd000]); // ram |
| 56 | membank("bankd")->configure_entry(1, m_videoram); // vram |
| 49 | 57 | } |
| 50 | 58 | |
| 51 | 59 | DRIVER_INIT_MEMBER(mz_state,mz800) |
| 52 | 60 | { |
| 53 | 61 | m_mz700 = FALSE; |
| 54 | | m_mz700_mode = FALSE; |
| 62 | m_mz700_mode = true;//FALSE; |
| 55 | 63 | |
| 56 | 64 | /* video ram */ |
| 57 | 65 | m_videoram = auto_alloc_array(machine(), UINT8, 0x4000); |
| r250110 | r250111 | |
|---|
| 61 | 69 | /* character generator ram */ |
| 62 | 70 | m_cgram = auto_alloc_array(machine(), UINT8, 0x1000); |
| 63 | 71 | memset(m_cgram, 0, sizeof(UINT8) * 0x1000); |
| 72 | |
| 73 | m_p_chargen = memregion("cgrom")->base(); |
| 74 | if (!m_p_chargen) |
| 75 | m_p_chargen = m_cgram; |
| 76 | UINT8 *rom = memregion("monitor")->base(); |
| 77 | UINT8 *ram = m_ram->pointer(); |
| 78 | // configure banks (0 = RAM in all cases) |
| 79 | membank("bankr0")->configure_entry(0, &ram[0]); // ram |
| 80 | membank("bankr0")->configure_entry(1, &rom[0]); // rom |
| 81 | membank("bankw0")->configure_entry(0, &ram[0]); // ram |
| 82 | membank("bank1")->configure_entry(0, &ram[0x1000]); // ram |
| 83 | membank("bank1")->configure_entry(1, &rom[0x1000]); // chargen |
| 84 | membank("banka")->configure_entry(0, &ram[0x8000]); // ram |
| 85 | membank("banka")->configure_entry(1, m_videoram); // vram in mz800 mode |
| 86 | membank("bankc")->configure_entry(0, &ram[0xc000]); // ram |
| 87 | membank("bankc")->configure_entry(1, m_cgram); // cgram in mz800 mode |
| 88 | membank("bankd")->configure_entry(0, &ram[0xd000]); // ram |
| 89 | membank("bankd")->configure_entry(1, m_videoram); // vram in mz700 mode |
| 64 | 90 | } |
| 65 | 91 | |
| 66 | 92 | void mz_state::machine_start() |
| 67 | 93 | { |
| 68 | 94 | /* reset memory map to defaults */ |
| 69 | | mz700_bank_4_w(m_maincpu->space(AS_PROGRAM), 0, 0); |
| 95 | mz700_bank_4_w(m_maincpu->space(AS_IO), 0, 0); |
| 70 | 96 | } |
| 71 | 97 | |
| 98 | MACHINE_RESET_MEMBER( mz_state, mz700 ) |
| 99 | { |
| 100 | membank("bankr0")->set_entry(1); //rom |
| 101 | membank("bankw0")->set_entry(0); //ram |
| 102 | membank("bankd")->set_entry(1); //vram |
| 103 | m_banke->set_bank(1); //devices |
| 104 | } |
| 72 | 105 | |
| 106 | MACHINE_RESET_MEMBER( mz_state, mz800 ) |
| 107 | { |
| 108 | // default to mz700 mode or mz1500 won't start. |
| 109 | membank("bankr0")->set_entry(1); //rom |
| 110 | membank("bankw0")->set_entry(0); //ram |
| 111 | membank("bank1")->set_entry(0); //ram |
| 112 | membank("banka")->set_entry(0); //ram |
| 113 | membank("bankc")->set_entry(0); //ram |
| 114 | membank("bankd")->set_entry(1); //vram |
| 115 | m_bankf->set_bank(1); //devices |
| 116 | } |
| 117 | |
| 118 | |
| 73 | 119 | /*************************************************************************** |
| 74 | 120 | MMIO |
| 75 | 121 | ***************************************************************************/ |
| r250110 | r250111 | |
|---|
| 99 | 145 | |
| 100 | 146 | READ8_MEMBER(mz_state::mz800_bank_0_r) |
| 101 | 147 | { |
| 102 | | UINT8 *videoram = m_videoram; |
| 103 | | address_space &spc = m_maincpu->space(AS_PROGRAM); |
| 148 | //address_space &spc = m_maincpu->space(AS_PROGRAM); |
| 104 | 149 | |
| 105 | 150 | /* switch in cgrom */ |
| 106 | | spc.install_read_bank(0x1000, 0x1fff, "bank2"); |
| 107 | | spc.nop_write(0x1000, 0x1fff); |
| 108 | | membank("bank2")->set_base(memregion("monitor")->base() + 0x1000); |
| 151 | //spc.install_read_bank(0x1000, 0x1fff, "bank2"); |
| 152 | //spc.nop_write(0x1000, 0x1fff); |
| 153 | //membank("bank2")->set_base(memregion("monitor")->base() + 0x1000); |
| 154 | membank("bank1")->set_entry(1); |
| 109 | 155 | |
| 110 | 156 | if (m_mz700_mode) |
| 111 | 157 | { |
| 112 | 158 | /* cgram from 0xc000 to 0xcfff */ |
| 113 | | spc.install_read_bank(0xc000, 0xcfff, "bank6"); |
| 114 | | spc.install_write_handler(0xc000, 0xcfff, write8_delegate(FUNC(mz_state::mz800_cgram_w),this)); |
| 115 | | membank("bank6")->set_base(m_cgram); |
| 159 | //spc.install_read_bank(0xc000, 0xcfff, "bank6"); |
| 160 | //spc.install_write_handler(0xc000, 0xcfff, write8_delegate(FUNC(mz_state::mz800_cgram_w),this)); |
| 161 | //membank("bank6")->set_base(m_cgram); |
| 162 | membank("bankc")->set_entry(1); |
| 116 | 163 | } |
| 117 | 164 | else |
| 118 | 165 | { |
| 119 | 166 | if (m_hires_mode) |
| 120 | 167 | { |
| 121 | 168 | /* vram from 0x8000 to 0xbfff */ |
| 122 | | spc.install_readwrite_bank(0x8000, 0xbfff, "bank4"); |
| 123 | | membank("bank4")->set_base(videoram); |
| 169 | //spc.install_readwrite_bank(0x8000, 0xbfff, "bank4"); |
| 170 | //membank("bank4")->set_base(m_videoram); |
| 171 | membank("banka")->set_entry(1); |
| 124 | 172 | } |
| 125 | 173 | else |
| 126 | 174 | { |
| 127 | 175 | /* vram from 0x8000 to 0x9fff */ |
| 128 | | spc.install_readwrite_bank(0x8000, 0x9fff, "bank4"); |
| 129 | | membank("bank4")->set_base(videoram); |
| 176 | //spc.install_readwrite_bank(0x8000, 0x9fff, "bank4"); |
| 177 | //membank("bank4")->set_base(m_videoram); |
| 130 | 178 | |
| 131 | 179 | /* ram from 0xa000 to 0xbfff */ |
| 132 | | spc.install_readwrite_bank(0xa000, 0xbfff, "bank5"); |
| 133 | | membank("bank5")->set_base(m_ram->pointer() + 0xa000); |
| 180 | //spc.install_readwrite_bank(0xa000, 0xbfff, "bank5"); |
| 181 | //membank("bank5")->set_base(m_ram->pointer() + 0xa000); |
| 182 | membank("bank1")->set_entry(1); |
| 134 | 183 | } |
| 135 | 184 | } |
| 136 | 185 | |
| r250110 | r250111 | |
|---|
| 139 | 188 | |
| 140 | 189 | WRITE8_MEMBER(mz_state::mz700_bank_0_w) |
| 141 | 190 | { |
| 142 | | address_space &spc = m_maincpu->space(AS_PROGRAM); |
| 191 | //address_space &spc = m_maincpu->space(AS_PROGRAM); |
| 143 | 192 | |
| 144 | | spc.install_readwrite_bank(0x0000, 0x0fff, "bank1"); |
| 145 | | membank("bank1")->set_base(m_ram->pointer()); |
| 193 | //spc.install_readwrite_bank(0x0000, 0x0fff, "bank1a"); |
| 194 | //membank("bank1a")->set_base(m_ram->pointer()); |
| 195 | membank("bankr0")->set_entry(0); // ram |
| 146 | 196 | } |
| 147 | 197 | |
| 148 | 198 | WRITE8_MEMBER(mz_state::mz800_bank_0_w) |
| 149 | 199 | { |
| 150 | | address_space &spc = m_maincpu->space(AS_PROGRAM); |
| 200 | //address_space &spc = m_maincpu->space(AS_PROGRAM); |
| 151 | 201 | |
| 152 | | spc.install_readwrite_bank(0x0000, 0x7fff, "bank1"); |
| 153 | | membank("bank1")->set_base(m_ram->pointer()); |
| 202 | //spc.install_readwrite_bank(0x0000, 0x7fff, "bank1a"); |
| 203 | //membank("bank1a")->set_base(m_ram->pointer()); |
| 204 | membank("bank1")->set_entry(0); // ram |
| 205 | membank("bankr0")->set_entry(0); // ram |
| 154 | 206 | } |
| 155 | 207 | |
| 156 | 208 | READ8_MEMBER(mz_state::mz800_bank_1_r) |
| 157 | 209 | { |
| 158 | | address_space &spc = m_maincpu->space(AS_PROGRAM); |
| 210 | //address_space &spc = m_maincpu->space(AS_PROGRAM); |
| 159 | 211 | |
| 160 | 212 | /* switch in ram from 0x1000 to 0x1fff */ |
| 161 | | spc.install_readwrite_bank(0x1000, 0x1fff, "bank2"); |
| 162 | | membank("bank2")->set_base(m_ram->pointer() + 0x1000); |
| 213 | //spc.install_readwrite_bank(0x1000, 0x1fff, "bank2"); |
| 214 | //membank("bank2")->set_base(m_ram->pointer() + 0x1000); |
| 215 | membank("bank1")->set_entry(0); // ram |
| 163 | 216 | |
| 164 | 217 | if (m_mz700_mode) |
| 165 | 218 | { |
| 166 | 219 | /* ram from 0xc000 to 0xcfff */ |
| 167 | | spc.install_readwrite_bank(0xc000, 0xcfff, "bank6"); |
| 168 | | membank("bank6")->set_base(m_ram->pointer() + 0xc000); |
| 220 | //spc.install_readwrite_bank(0xc000, 0xcfff, "bank6"); |
| 221 | //membank("bank6")->set_base(m_ram->pointer() + 0xc000); |
| 222 | membank("bankc")->set_entry(0); // ram |
| 169 | 223 | } |
| 170 | 224 | else |
| 171 | 225 | { |
| 172 | 226 | /* ram from 0x8000 to 0xbfff */ |
| 173 | | spc.install_readwrite_bank(0x8000, 0xbfff, "bank4"); |
| 174 | | membank("bank4")->set_base(m_ram->pointer() + 0x8000); |
| 227 | //spc.install_readwrite_bank(0x8000, 0xbfff, "bank4"); |
| 228 | //membank("bank4")->set_base(m_ram->pointer() + 0x8000); |
| 229 | membank("banka")->set_entry(0); // ram |
| 175 | 230 | } |
| 176 | 231 | |
| 177 | 232 | return 0xff; |
| r250110 | r250111 | |
|---|
| 179 | 234 | |
| 180 | 235 | WRITE8_MEMBER(mz_state::mz700_bank_1_w) |
| 181 | 236 | { |
| 182 | | address_space &spc = m_maincpu->space(AS_PROGRAM); |
| 237 | //address_space &spc = m_maincpu->space(AS_PROGRAM); |
| 238 | membank("bankd")->set_entry(0); // ram |
| 183 | 239 | |
| 184 | 240 | if (m_mz700_mode) |
| 185 | 241 | { |
| 186 | 242 | /* switch in ram when not locked */ |
| 187 | 243 | if (!m_mz700_ram_lock) |
| 188 | 244 | { |
| 189 | | spc.install_readwrite_bank(0xd000, 0xffff, "bank7"); |
| 190 | | membank("bank7")->set_base(m_ram->pointer() + 0xd000); |
| 245 | if (m_mz700) |
| 246 | { |
| 247 | //membank("bankd")->set_entry(0); // ram |
| 248 | m_banke->set_bank(0); //ram |
| 249 | } |
| 250 | else |
| 251 | { |
| 252 | //spc.install_readwrite_bank(0xd000, 0xffff, "bank7"); |
| 253 | //spc.install_readwrite_bank(0xd000, 0xdfff, "bank7"); |
| 254 | //membank("bank7")->set_base(m_ram->pointer() + 0xd000); |
| 255 | m_bankf->set_bank(0); //ram |
| 256 | } |
| 191 | 257 | m_mz700_ram_vram = FALSE; |
| 192 | 258 | } |
| 193 | 259 | } |
| r250110 | r250111 | |
|---|
| 196 | 262 | /* switch in ram when not locked */ |
| 197 | 263 | if (!m_mz800_ram_lock) |
| 198 | 264 | { |
| 199 | | spc.install_readwrite_bank(0xe000, 0xffff, "bank8"); |
| 200 | | membank("bank8")->set_base(m_ram->pointer() + 0xe000); |
| 265 | //spc.install_readwrite_bank(0xe000, 0xffff, "bank8"); |
| 266 | //membank("bank8")->set_base(m_ram->pointer() + 0xe000); |
| 267 | m_bankf->set_bank(0); //ram |
| 201 | 268 | m_mz800_ram_monitor = FALSE; |
| 202 | 269 | } |
| 203 | 270 | } |
| r250110 | r250111 | |
|---|
| 205 | 272 | |
| 206 | 273 | WRITE8_MEMBER(mz_state::mz700_bank_2_w) |
| 207 | 274 | { |
| 208 | | address_space &spc = m_maincpu->space(AS_PROGRAM); |
| 275 | //address_space &spc = m_maincpu->space(AS_PROGRAM); |
| 209 | 276 | |
| 210 | | spc.install_read_bank(0x0000, 0x0fff, "bank1"); |
| 211 | | spc.nop_write(0x0000, 0x0fff); |
| 212 | | membank("bank1")->set_base(memregion("monitor")->base()); |
| 277 | //spc.install_read_bank(0x0000, 0x0fff, "bank1a"); |
| 278 | //spc.nop_write(0x0000, 0x0fff); |
| 279 | //membank("bank1a")->set_base(memregion("monitor")->base()); |
| 280 | membank("bankr0")->set_entry(1); // rom |
| 281 | |
| 213 | 282 | } |
| 214 | 283 | |
| 215 | 284 | WRITE8_MEMBER(mz_state::mz700_bank_3_w) |
| 216 | 285 | { |
| 217 | | UINT8 *videoram = m_videoram; |
| 218 | | address_space &spc = m_maincpu->space(AS_PROGRAM); |
| 286 | //address_space &spc = m_maincpu->space(AS_PROGRAM); |
| 219 | 287 | |
| 220 | 288 | if (m_mz700_mode) |
| 221 | 289 | { |
| 222 | 290 | if (!m_mz700_ram_lock) |
| 223 | 291 | { |
| 224 | | /* switch in videoram */ |
| 225 | | spc.install_readwrite_bank(0xd000, 0xd7ff, "bank7"); |
| 226 | | membank("bank7")->set_base(videoram); |
| 292 | if (m_mz700) |
| 293 | membank("bankd")->set_entry(1); |
| 294 | else |
| 295 | { |
| 296 | /* switch in videoram */ |
| 297 | //spc.install_readwrite_bank(0xd000, 0xd7ff, "bank7"); |
| 298 | //membank("bank7")->set_base(m_videoram); |
| 227 | 299 | |
| 228 | | /* switch in colorram */ |
| 229 | | spc.install_readwrite_bank(0xd800, 0xdfff, "bank9"); |
| 230 | | membank("bank9")->set_base(m_colorram); |
| 231 | | |
| 300 | /* switch in colorram */ |
| 301 | //spc.install_readwrite_bank(0xd800, 0xdfff, "bank9"); |
| 302 | //membank("bank9")->set_base(m_colorram); |
| 303 | membank("bankd")->set_entry(1); |
| 304 | } |
| 232 | 305 | m_mz700_ram_vram = TRUE; |
| 233 | 306 | |
| 234 | 307 | /* switch in memory mapped i/o devices */ |
| 235 | 308 | if (m_mz700) |
| 236 | 309 | { |
| 237 | | spc.install_readwrite_handler(0xe000, 0xfff3, 0, 0x1ff0, read8_delegate(FUNC(i8255_device::read), (i8255_device*)m_ppi), write8_delegate(FUNC(i8255_device::write), (i8255_device*)m_ppi)); |
| 238 | | spc.install_readwrite_handler(0xe004, 0xfff7, 0, 0x1ff0, read8_delegate(FUNC(pit8253_device::read), (pit8253_device*)m_pit), write8_delegate(FUNC(pit8253_device::write), (pit8253_device*)m_pit)); |
| 239 | | spc.install_readwrite_handler(0xe008, 0xfff8, 0, 0x1ff0, read8_delegate(FUNC(mz_state::mz700_e008_r),this), write8_delegate(FUNC(mz_state::mz700_e008_w),this)); |
| 310 | m_banke->set_bank(1); //devices |
| 240 | 311 | } |
| 241 | 312 | else |
| 242 | 313 | { |
| 243 | | spc.install_readwrite_handler(0xe000, 0xe003, read8_delegate(FUNC(i8255_device::read), (i8255_device*)m_ppi), write8_delegate(FUNC(i8255_device::write), (i8255_device*)m_ppi)); |
| 244 | | spc.install_readwrite_handler(0xe004, 0xe007, read8_delegate(FUNC(pit8253_device::read), (pit8253_device*)m_pit), write8_delegate(FUNC(pit8253_device::write), (pit8253_device*)m_pit)); |
| 245 | | spc.install_readwrite_handler(0xe008, 0xe008, read8_delegate(FUNC(mz_state::mz700_e008_r),this), write8_delegate(FUNC(mz_state::mz700_e008_w),this)); |
| 314 | m_bankf->set_bank(1); //devices |
| 246 | 315 | } |
| 247 | 316 | } |
| 248 | 317 | } |
| r250110 | r250111 | |
|---|
| 251 | 320 | if (!m_mz800_ram_lock) |
| 252 | 321 | { |
| 253 | 322 | /* switch in mz800 monitor rom if not locked */ |
| 254 | | spc.install_read_bank(0xe000, 0xffff, "bank8"); |
| 255 | | spc.nop_write(0xe000, 0xffff); |
| 256 | | membank("bank8")->set_base(memregion("monitor")->base() + 0x2000); |
| 323 | //spc.install_read_bank(0xe000, 0xffff, "bank8"); |
| 324 | //spc.nop_write(0xe000, 0xffff); |
| 325 | //membank("bank8")->set_base(memregion("monitor")->base() + 0x2000); |
| 326 | m_bankf->set_bank(1); // devices + rom |
| 257 | 327 | m_mz800_ram_monitor = TRUE; |
| 258 | 328 | } |
| 259 | 329 | } |
| r250110 | r250111 | |
|---|
| 261 | 331 | |
| 262 | 332 | WRITE8_MEMBER(mz_state::mz700_bank_4_w) |
| 263 | 333 | { |
| 264 | | UINT8 *videoram = m_videoram; |
| 265 | | address_space &spc = m_maincpu->space(AS_PROGRAM); |
| 334 | //address_space &spc = m_maincpu->space(AS_PROGRAM); |
| 266 | 335 | |
| 267 | 336 | if (m_mz700_mode) |
| 268 | 337 | { |
| r250110 | r250111 | |
|---|
| 270 | 339 | mz700_bank_2_w(space, 0, 0); /* switch in monitor rom */ |
| 271 | 340 | mz700_bank_3_w(space, 0, 0); /* switch in videoram, colorram, and mmio */ |
| 272 | 341 | |
| 273 | | /* rest is ram is always ram in mz700 mode */ |
| 274 | | spc.install_readwrite_bank(0x1000, 0xcfff, "bank2"); |
| 275 | | membank("bank2")->set_base(m_ram->pointer() + 0x1000); |
| 342 | if (!m_mz700) |
| 343 | { |
| 344 | /* rest is ram is always ram in mz700 mode */ |
| 345 | //spc.install_readwrite_bank(0x1000, 0xcfff, "bank2"); |
| 346 | //membank("bank2")->set_base(m_ram->pointer() + 0x1000); |
| 347 | membank("bankr0")->set_entry(1); // rom |
| 348 | membank("bank1")->set_entry(0); // ram |
| 349 | membank("bankc")->set_entry(0); // ram |
| 350 | } |
| 276 | 351 | } |
| 277 | 352 | else |
| 278 | 353 | { |
| 279 | 354 | /* monitor rom and cgrom */ |
| 280 | | spc.install_read_bank(0x0000, 0x1fff, "bank1"); |
| 281 | | spc.nop_write(0x0000, 0x1fff); |
| 282 | | membank("bank1")->set_base(memregion("monitor")->base()); |
| 355 | //spc.install_read_bank(0x0000, 0x1fff, "bank1a"); |
| 356 | //spc.nop_write(0x0000, 0x1fff); |
| 357 | //membank("bank1a")->set_base(memregion("monitor")->base()); |
| 358 | membank("bankr0")->set_entry(1); // rom |
| 359 | membank("bank1")->set_entry(1); // rom |
| 283 | 360 | |
| 284 | 361 | /* ram from 0x2000 to 0x7fff */ |
| 285 | | spc.install_readwrite_bank(0x2000, 0x7fff, "bank3"); |
| 286 | | membank("bank3")->set_base(m_ram->pointer()); |
| 362 | //spc.install_readwrite_bank(0x2000, 0x7fff, "bank3"); |
| 363 | //membank("bank3")->set_base(m_ram->pointer()); |
| 287 | 364 | |
| 288 | 365 | if (m_hires_mode) |
| 289 | 366 | { |
| 290 | 367 | /* vram from 0x8000 to 0xbfff */ |
| 291 | | spc.install_readwrite_bank(0x8000, 0xbfff, "bank4"); |
| 292 | | membank("bank4")->set_base(videoram); |
| 368 | //spc.install_readwrite_bank(0x8000, 0xbfff, "bank4"); |
| 369 | //membank("bank4")->set_base(m_videoram); |
| 370 | membank("banka")->set_entry(1); // vram |
| 293 | 371 | } |
| 294 | 372 | else |
| 295 | 373 | { |
| 296 | 374 | /* vram from 0x8000 to 0x9fff */ |
| 297 | | spc.install_readwrite_bank(0x8000, 0x9fff, "bank4"); |
| 298 | | membank("bank4")->set_base(videoram); |
| 375 | //spc.install_readwrite_bank(0x8000, 0x9fff, "bank4"); |
| 376 | //membank("bank4")->set_base(m_videoram); |
| 377 | membank("banka")->set_entry(1); // vram |
| 299 | 378 | |
| 300 | 379 | /* ram from 0xa000 to 0xbfff */ |
| 301 | | spc.install_readwrite_bank(0xa000, 0xbfff, "bank5"); |
| 302 | | membank("bank5")->set_base(m_ram->pointer() + 0xa000); |
| 380 | //spc.install_readwrite_bank(0xa000, 0xbfff, "bank5"); |
| 381 | //membank("bank5")->set_base(m_ram->pointer() + 0xa000); |
| 303 | 382 | } |
| 304 | 383 | |
| 305 | 384 | /* ram from 0xc000 to 0xdfff */ |
| 306 | | spc.install_readwrite_bank(0xc000, 0xdfff, "bank6"); |
| 307 | | membank("bank6")->set_base(m_ram->pointer() + 0xc000); |
| 385 | //spc.install_readwrite_bank(0xc000, 0xdfff, "bank6"); |
| 386 | //membank("bank6")->set_base(m_ram->pointer() + 0xc000); |
| 387 | membank("bankd")->set_entry(0); // ram |
| 308 | 388 | |
| 309 | 389 | /* mz800 monitor rom from 0xe000 to 0xffff */ |
| 310 | | spc.install_read_bank(0xe000, 0xffff, "bank8"); |
| 311 | | spc.nop_write(0xe000, 0xffff); |
| 312 | | membank("bank8")->set_base(memregion("monitor")->base() + 0x2000); |
| 390 | //spc.install_read_bank(0xe000, 0xffff, "bank8"); |
| 391 | //spc.nop_write(0xe000, 0xffff); |
| 392 | //membank("bank8")->set_base(memregion("monitor")->base() + 0x2000); |
| 393 | m_bankf->set_bank(1); // devices + rom |
| 313 | 394 | m_mz800_ram_monitor = TRUE; |
| 314 | 395 | |
| 315 | 396 | m_mz800_ram_lock = FALSE; /* reset lock? */ |
| r250110 | r250111 | |
|---|
| 318 | 399 | |
| 319 | 400 | WRITE8_MEMBER(mz_state::mz700_bank_5_w) |
| 320 | 401 | { |
| 321 | | address_space &spc = m_maincpu->space(AS_PROGRAM); |
| 402 | //address_space &spc = m_maincpu->space(AS_PROGRAM); |
| 322 | 403 | |
| 323 | 404 | if (m_mz700_mode) |
| 324 | 405 | { |
| 325 | 406 | /* prevent access from 0xd000 to 0xffff */ |
| 326 | 407 | m_mz700_ram_lock = TRUE; |
| 327 | | spc.nop_readwrite(0xd000, 0xffff); |
| 408 | if (m_mz700) |
| 409 | m_banke->set_bank(2); |
| 410 | else |
| 411 | //spc.nop_readwrite(0xd000, 0xdfff); |
| 412 | //spc.nop_readwrite(0xd000, 0xffff); |
| 413 | m_bankf->set_bank(2); |
| 328 | 414 | } |
| 329 | 415 | else |
| 330 | 416 | { |
| 331 | 417 | /* prevent access from 0xe000 to 0xffff */ |
| 332 | 418 | m_mz800_ram_lock = TRUE; |
| 333 | | spc.nop_readwrite(0xe000, 0xffff); |
| 419 | //spc.nop_readwrite(0xe000, 0xffff); |
| 420 | m_bankf->set_bank(2); |
| 334 | 421 | } |
| 335 | 422 | } |
| 336 | 423 | |
| r250110 | r250111 | |
|---|
| 435 | 522 | LOG(2,"mz700_pio_port_a_w",("%02X\n", data),machine()); |
| 436 | 523 | |
| 437 | 524 | /* the ls145 is connected to PA0-PA3 */ |
| 438 | | dynamic_cast<ttl74145_device *>(device)->write(data & 0x07); |
| 525 | dynamic_cast<ttl74145_device *>(device)->write(data & 0x0f); |
| 439 | 526 | |
| 440 | 527 | /* ne556 reset is connected to PA7 */ |
| 441 | 528 | timer->enable(BIT(data, 7)); |
trunk/src/mame/video/mz700.c
| r250110 | r250111 | |
|---|
| 15 | 15 | #include "includes/mz700.h" |
| 16 | 16 | |
| 17 | 17 | |
| 18 | | #ifndef VERBOSE |
| 19 | | #define VERBOSE 1 |
| 20 | | #endif |
| 21 | | |
| 22 | | #define LOG(N,M,A) \ |
| 23 | | do { \ |
| 24 | | if(VERBOSE>=N) \ |
| 25 | | { \ |
| 26 | | if( M ) \ |
| 27 | | logerror("%11.6f: %-24s",machine.time().as_double(),(char*)M ); \ |
| 28 | | logerror A; \ |
| 29 | | } \ |
| 30 | | } while (0) |
| 31 | | |
| 32 | | |
| 33 | | PALETTE_INIT_MEMBER(mz_state, mz) |
| 34 | | { |
| 35 | | int i; |
| 36 | | |
| 37 | | for (i = 0; i < 8; i++) |
| 38 | | m_palette->set_indirect_color(i, rgb_t((i & 2) ? 0xff : 0x00, (i & 4) ? 0xff : 0x00, (i & 1) ? 0xff : 0x00)); |
| 39 | | |
| 40 | | for (i = 0; i < 256; i++) |
| 41 | | { |
| 42 | | m_palette->set_pen_indirect(i*2, i & 7); |
| 43 | | m_palette->set_pen_indirect(i*2+1, (i >> 4) & 7); |
| 44 | | } |
| 45 | | } |
| 46 | | |
| 47 | | |
| 48 | 18 | UINT32 mz_state::screen_update_mz700(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect) |
| 49 | 19 | { |
| 50 | | UINT8 *videoram = m_videoram; |
| 51 | | int offs; |
| 20 | UINT8 y,ra,gfx,col,bg=0,fg=0,oldcol=0x7e; |
| 21 | UINT16 sy=0,ma=0,x,chr; |
| 52 | 22 | |
| 53 | | bitmap.fill(m_palette->black_pen(), cliprect); |
| 54 | | |
| 55 | | for(offs = 0; offs < 40*25; offs++) |
| 23 | for (y = 0; y < 25; y++) |
| 56 | 24 | { |
| 57 | | int sx, sy, code, color; |
| 25 | for (ra = 0; ra < 8; ra++) |
| 26 | { |
| 27 | UINT16 *p = &bitmap.pix16(sy++); |
| 58 | 28 | |
| 59 | | sy = (offs / 40) * 8; |
| 60 | | sx = (offs % 40) * 8; |
| 29 | for (x = ma; x < ma + 40; x++) |
| 30 | { |
| 31 | col = m_colorram[x]; |
| 32 | if (col != oldcol) |
| 33 | { |
| 34 | oldcol = col; |
| 35 | col = BITSWAP8(col, 7, 3, 4, 6, 5, 0, 2, 1); // turn BRG into RGB |
| 36 | bg = col & 7; |
| 37 | fg = (col >> 3) & 7; |
| 38 | } |
| 39 | chr = m_videoram[x] | (BIT(col, 7)<<8); |
| 40 | gfx = m_p_chargen[(chr<<3) | ra ]; |
| 61 | 41 | |
| 62 | | color = m_colorram[offs]; |
| 63 | | code = videoram[offs] | (color & 0x80) << 1; |
| 64 | | |
| 65 | | m_gfxdecode->gfx(0)->opaque(bitmap,cliprect, code, color, 0, 0, sx, sy); |
| 42 | /* Display a scanline of a character */ |
| 43 | *p++ = BIT(gfx, 0) ? fg : bg; |
| 44 | *p++ = BIT(gfx, 1) ? fg : bg; |
| 45 | *p++ = BIT(gfx, 2) ? fg : bg; |
| 46 | *p++ = BIT(gfx, 3) ? fg : bg; |
| 47 | *p++ = BIT(gfx, 4) ? fg : bg; |
| 48 | *p++ = BIT(gfx, 5) ? fg : bg; |
| 49 | *p++ = BIT(gfx, 6) ? fg : bg; |
| 50 | *p++ = BIT(gfx, 7) ? fg : bg; |
| 51 | } |
| 52 | } |
| 53 | ma+=40; |
| 66 | 54 | } |
| 67 | | |
| 68 | 55 | return 0; |
| 69 | 56 | } |
| 70 | 57 | |
| 71 | 58 | |
| 72 | 59 | /*************************************************************************** |
| 73 | 60 | MZ-800 |
| 61 | Not working. |
| 74 | 62 | ***************************************************************************/ |
| 75 | 63 | |
| 76 | | VIDEO_START_MEMBER(mz_state,mz800) |
| 77 | | { |
| 78 | | m_gfxdecode->gfx(0)->set_source(m_cgram); |
| 79 | | } |
| 80 | | |
| 81 | 64 | UINT32 mz_state::screen_update_mz800(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect) |
| 82 | 65 | { |
| 83 | | UINT8 *videoram = m_videoram; |
| 84 | | |
| 85 | | bitmap.fill(m_palette->black_pen(), cliprect); |
| 86 | | |
| 87 | 66 | if (m_mz700_mode) |
| 88 | 67 | return screen_update_mz700(screen, bitmap, cliprect); |
| 89 | 68 | else |
| r250110 | r250111 | |
|---|
| 94 | 73 | else |
| 95 | 74 | { |
| 96 | 75 | int x, y; |
| 97 | | UINT8 *start_addr = videoram; |
| 98 | 76 | |
| 99 | 77 | for (x = 0; x < 40; x++) |
| 100 | 78 | { |
| 101 | 79 | for (y = 0; y < 200; y++) |
| 102 | 80 | { |
| 103 | | bitmap.pix16(y, x * 8 + 0) = BIT(start_addr[x * 8 + y], 0); |
| 104 | | bitmap.pix16(y, x * 8 + 1) = BIT(start_addr[x * 8 + y], 1); |
| 105 | | bitmap.pix16(y, x * 8 + 2) = BIT(start_addr[x * 8 + y], 2); |
| 106 | | bitmap.pix16(y, x * 8 + 3) = BIT(start_addr[x * 8 + y], 3); |
| 107 | | bitmap.pix16(y, x * 8 + 4) = BIT(start_addr[x * 8 + y], 4); |
| 108 | | bitmap.pix16(y, x * 8 + 5) = BIT(start_addr[x * 8 + y], 5); |
| 109 | | bitmap.pix16(y, x * 8 + 6) = BIT(start_addr[x * 8 + y], 6); |
| 110 | | bitmap.pix16(y, x * 8 + 7) = BIT(start_addr[x * 8 + y], 7); |
| 81 | bitmap.pix16(y, x * 8 + 0) = BIT(m_videoram[x * 8 + y], 0) ? 7 : 0; |
| 82 | bitmap.pix16(y, x * 8 + 1) = BIT(m_videoram[x * 8 + y], 1) ? 7 : 0; |
| 83 | bitmap.pix16(y, x * 8 + 2) = BIT(m_videoram[x * 8 + y], 2) ? 7 : 0; |
| 84 | bitmap.pix16(y, x * 8 + 3) = BIT(m_videoram[x * 8 + y], 3) ? 7 : 0; |
| 85 | bitmap.pix16(y, x * 8 + 4) = BIT(m_videoram[x * 8 + y], 4) ? 7 : 0; |
| 86 | bitmap.pix16(y, x * 8 + 5) = BIT(m_videoram[x * 8 + y], 5) ? 7 : 0; |
| 87 | bitmap.pix16(y, x * 8 + 6) = BIT(m_videoram[x * 8 + y], 6) ? 7 : 0; |
| 88 | bitmap.pix16(y, x * 8 + 7) = BIT(m_videoram[x * 8 + y], 7) ? 7 : 0; |
| 111 | 89 | } |
| 112 | 90 | } |
| 113 | 91 | } |
| r250110 | r250111 | |
|---|
| 123 | 101 | WRITE8_MEMBER(mz_state::mz800_cgram_w) |
| 124 | 102 | { |
| 125 | 103 | m_cgram[offset] = data; |
| 126 | | |
| 127 | | m_gfxdecode->gfx(0)->mark_dirty(offset/8); |
| 128 | 104 | } |