Return to cpuz80-mame.c CVS log

Up to [Generator SEGA Genesis emulator] / generator / extra

Annotation of generator/extra/cpuz80-mame.c, revision 1.1.1.1

1.1       root        1: /*****************************************************************************/
                      2: /*     Generator - Sega Genesis emulation - (c) James Ponder 1997-1998       */
                      3: /*****************************************************************************/
                      4: /*                                                                           */
                      5: /* z80.c                                                                     */
                      6: /*                                                                           */
                      7: /*****************************************************************************/
                      8: 
                      9: #include <stdlib.h>
                     10: #include <stdio.h>
                     11: #include <string.h>
                     12: 
                     13: #include <generator.h>
                     14: #include <cpuz80.h>
                     15: #include <cpu68k.h>
                     16: #include <memz80.h>
                     17: #include <ui.h>
                     18: 
                     19: #include <z80/z80.h>
                     20: 
                     21: /*** variables externed ***/
                     22: 
                     23: uint8 *cpuz80_ram = NULL;
                     24: uint32 cpuz80_bank = 0;
                     25: unsigned int cpuz80_active = 0;
                     26: 
                     27: /*** global variables ***/
                     28: 
                     29: static unsigned int cpuz80_lastsync = 0;
                     30: static unsigned int cpuz80_resetting = 0;
                     31: 
                     32: /*** cpuz80_init - initialise this sub-unit ***/
                     33: 
                     34: int cpuz80_init(void)
                     35: {
                     36:   cpuz80_reset();
                     37:   ui_log(LOG_CRITICAL, "z80 init");
                     38:   return 0;
                     39: }
                     40: 
                     41: /*** cpuz80_callback - callback ***/
                     42: 
                     43: int cpuz80_callback(int val) {
                     44:   (void)val;
                     45:   return 0;
                     46: }
                     47: 
                     48: /*** cpuz80_reset - reset z80 sub-unit ***/
                     49: 
                     50: void cpuz80_reset(void)
                     51: {
                     52:   if (!cpuz80_ram) {
                     53:     if ((cpuz80_ram = malloc(LEN_SRAM)) == NULL) {
                     54:       fprintf(stderr, "Out of memory\n");
                     55:       exit(1);
                     56:     }
                     57:   }
                     58:   memset(cpuz80_ram, 0, LEN_SRAM);
                     59:   cpuz80_resetcpu();
                     60:   cpuz80_bank = 0;
                     61:   cpuz80_active = 0;
                     62:   cpuz80_lastsync = 0;
                     63:   cpuz80_resetting = 0;
                     64:   z80_reset(NULL);
                     65:   z80_set_irq_callback(cpuz80_callback);
                     66: }
                     67: 
                     68: /*** cpuz80_resetcpu - reset z80 cpu ***/
                     69: 
                     70: void cpuz80_resetcpu(void)
                     71: {
                     72:   z80_reset(NULL);
                     73:   z80_set_irq_callback(cpuz80_callback);
                     74:   cpuz80_resetting = 1; /* suspends execution */
                     75: }
                     76: 
                     77: /*** cpuz80_unresetcpu - unreset z80 cpu ***/
                     78: 
                     79: void cpuz80_unresetcpu(void)
                     80: {
                     81:   cpuz80_resetting = 0; /* un-suspends execution */
                     82: }
                     83: 
                     84: /*** cpuz80_bankwrite - data is being written to latch ***/
                     85: 
                     86: void cpuz80_bankwrite(uint8 data)
                     87: {
                     88:   cpuz80_bank  = (((cpuz80_bank >> 1) | ((data & 1) <<23)) & 0xff8000);
                     89:   /*
                     90:   if (gen_debug)
                     91:     printf("BANK WRITE: %d --> %08X\n", data, cpuz80_bank);
                     92:   */
                     93: }
                     94: 
                     95: /*** cpuz80_stop - stop the processor ***/
                     96: 
                     97: void cpuz80_stop(void)
                     98: {
                     99:   cpuz80_sync();
                    100:   cpuz80_active = 0;
                    101: }
                    102: 
                    103: /*** cpuz80_start - start the processor ***/
                    104: 
                    105: void cpuz80_start(void)
                    106: {
                    107:   cpuz80_sync();
                    108:   cpuz80_active = 1;
                    109: }
                    110: 
                    111: /*** cpuz80_endfield - reset counters ***/
                    112: 
                    113: void cpuz80_endfield(void)
                    114: {
                    115:   cpuz80_lastsync = 0;
                    116: }
                    117: 
                    118: /*** cpuz80_sync - synchronise ***/
                    119: 
                    120: void cpuz80_sync(void)
                    121: {
                    122:   int cpu68k_wanted = cpu68k_clocks - cpuz80_lastsync;
                    123:   int wanted = (cpu68k_wanted<0?0:cpu68k_wanted)*7/16;
                    124:   int acheived;
                    125: 
                    126:   if (cpuz80_active && !cpuz80_resetting)
                    127:     acheived = z80_execute(wanted);
                    128:   cpuz80_lastsync = cpu68k_clocks;
                    129: }
                    130: 
                    131: /*** cpuz80_interrupt - cause an interrupt on the z80 */
                    132: 
                    133: void cpuz80_interrupt(void)
                    134: {
                    135:   if (!cpuz80_resetting)
                    136:     z80_set_irq_line(0, 1);
                    137: }
                    138: 
                    139: /*** cpuz80_portread - port read from z80 */
                    140: 
                    141: uint8 cpuz80_portread(uint8 port)
                    142: {
                    143:   printf("[Z80] Port read to %X\n", port);
                    144:   return 0;
                    145: }
                    146: 
                    147: /*** cpuz80_portwrite - z80 write to port */
                    148: 
                    149: void cpuz80_portwrite(uint8 port, uint8 value)
                    150: {
                    151:   printf("[Z80] Port write to %X of %X\n", port, value);
                    152: }

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.