src/mess/drivers/cc10.c
| r9099 | r9100 | |
| 1 | | /*************************************************************************** |
| 2 | | |
| 3 | | Fidelity Chess Challenger 10 |
| 4 | | |
| 5 | | More data : |
| 6 | | http://home.germany.net/nils.eilers/cc10.htm |
| 7 | | |
| 8 | | 30/08/2010 Skeleton driver |
| 9 | | |
| 10 | | ****************************************************************************/ |
| 11 | | |
| 12 | | #include "emu.h" |
| 13 | | #include "cpu/z80/z80.h" |
| 14 | | #include "machine/i8255a.h" |
| 15 | | #include "debugger.h" |
| 16 | | #include "sound/beep.h" |
| 17 | | #include "cc10.lh" |
| 18 | | |
| 19 | | class cc10_state : public driver_device |
| 20 | | { |
| 21 | | public: |
| 22 | | cc10_state(running_machine &machine, const driver_device_config_base &config) |
| 23 | | : driver_device(machine, config) { } |
| 24 | | |
| 25 | | UINT8 kb_matrix; |
| 26 | | UINT8 out_index; |
| 27 | | UINT8 out_state; |
| 28 | | |
| 29 | | device_t *beep; |
| 30 | | }; |
| 31 | | |
| 32 | | static ADDRESS_MAP_START(cc10_mem, ADDRESS_SPACE_PROGRAM, 8) |
| 33 | | ADDRESS_MAP_UNMAP_HIGH |
| 34 | | AM_RANGE(0x0000, 0x0fff) AM_ROM |
| 35 | | AM_RANGE(0x3000, 0x31ff) AM_RAM |
| 36 | | ADDRESS_MAP_END |
| 37 | | |
| 38 | | static ADDRESS_MAP_START( cc10_io, ADDRESS_SPACE_IO, 8 ) |
| 39 | | ADDRESS_MAP_GLOBAL_MASK(0xff) |
| 40 | | AM_RANGE(0xf4, 0xf7) AM_DEVREADWRITE("i8255", i8255a_r, i8255a_w) |
| 41 | | ADDRESS_MAP_END |
| 42 | | |
| 43 | | /* Input ports */ |
| 44 | | INPUT_PORTS_START( cc10 ) |
| 45 | | PORT_START("LEVEL") |
| 46 | | PORT_CONFNAME( 0x80, 0x00, "Number of levels" ) |
| 47 | | PORT_CONFSETTING( 0x00, "10" ) |
| 48 | | PORT_CONFSETTING( 0x80, "3" ) |
| 49 | | |
| 50 | | PORT_START("LINE1") |
| 51 | | PORT_BIT(0x01, IP_ACTIVE_LOW, IPT_KEYPAD) PORT_NAME("RE") PORT_CODE(KEYCODE_R) |
| 52 | | PORT_BIT(0x02, IP_ACTIVE_LOW, IPT_KEYPAD) PORT_NAME("LV") PORT_CODE(KEYCODE_V) |
| 53 | | PORT_BIT(0x04, IP_ACTIVE_LOW, IPT_KEYPAD) PORT_NAME("A1") PORT_CODE(KEYCODE_1) |
| 54 | | PORT_BIT(0x08, IP_ACTIVE_LOW, IPT_KEYPAD) PORT_NAME("E5") PORT_CODE(KEYCODE_5) |
| 55 | | |
| 56 | | PORT_START("LINE2") |
| 57 | | PORT_BIT(0x01, IP_ACTIVE_LOW, IPT_KEYPAD) PORT_NAME("CB") PORT_CODE(KEYCODE_C) |
| 58 | | PORT_BIT(0x02, IP_ACTIVE_LOW, IPT_KEYPAD) PORT_NAME("DM") PORT_CODE(KEYCODE_D) |
| 59 | | PORT_BIT(0x04, IP_ACTIVE_LOW, IPT_KEYPAD) PORT_NAME("B2") PORT_CODE(KEYCODE_2) |
| 60 | | PORT_BIT(0x08, IP_ACTIVE_LOW, IPT_KEYPAD) PORT_NAME("F6") PORT_CODE(KEYCODE_6) |
| 61 | | |
| 62 | | PORT_START("LINE3") |
| 63 | | PORT_BIT(0x01, IP_ACTIVE_LOW, IPT_KEYPAD) PORT_NAME("CL") PORT_CODE(KEYCODE_L) |
| 64 | | PORT_BIT(0x02, IP_ACTIVE_LOW, IPT_KEYPAD) PORT_NAME("PB") PORT_CODE(KEYCODE_B) |
| 65 | | PORT_BIT(0x04, IP_ACTIVE_LOW, IPT_KEYPAD) PORT_NAME("C3") PORT_CODE(KEYCODE_3) |
| 66 | | PORT_BIT(0x08, IP_ACTIVE_LOW, IPT_KEYPAD) PORT_NAME("G7") PORT_CODE(KEYCODE_7) |
| 67 | | |
| 68 | | PORT_START("LINE4") |
| 69 | | PORT_BIT(0x01, IP_ACTIVE_LOW, IPT_KEYPAD) PORT_NAME("EN") PORT_CODE(KEYCODE_E) |
| 70 | | PORT_BIT(0x02, IP_ACTIVE_LOW, IPT_KEYPAD) PORT_NAME("PV") PORT_CODE(KEYCODE_O) |
| 71 | | PORT_BIT(0x04, IP_ACTIVE_LOW, IPT_KEYPAD) PORT_NAME("D4") PORT_CODE(KEYCODE_4) |
| 72 | | PORT_BIT(0x08, IP_ACTIVE_LOW, IPT_KEYPAD) PORT_NAME("H8") PORT_CODE(KEYCODE_8) |
| 73 | | INPUT_PORTS_END |
| 74 | | |
| 75 | | static MACHINE_START(cc10) |
| 76 | | { |
| 77 | | cc10_state *state = machine->driver_data<cc10_state>(); |
| 78 | | |
| 79 | | state->beep = machine->device("beep"); |
| 80 | | } |
| 81 | | |
| 82 | | static MACHINE_RESET(cc10) |
| 83 | | { |
| 84 | | cc10_state *state = machine->driver_data<cc10_state>(); |
| 85 | | |
| 86 | | state->kb_matrix = 0; |
| 87 | | state->out_index = 0; |
| 88 | | state->out_state = 0; |
| 89 | | } |
| 90 | | |
| 91 | | static WRITE8_DEVICE_HANDLER( cc10_out_data_w ) |
| 92 | | { |
| 93 | | cc10_state *state = device->machine->driver_data<cc10_state>(); |
| 94 | | UINT8 digit_value = BITSWAP8( data,7,0,1,2,3,4,5,6 ) & 0x7f; |
| 95 | | |
| 96 | | switch (state->out_index) |
| 97 | | { |
| 98 | | case 0x00: |
| 99 | | output_set_digit_value(0, digit_value); |
| 100 | | break; |
| 101 | | case 0x04: |
| 102 | | output_set_digit_value(1, digit_value); |
| 103 | | break; |
| 104 | | case 0x08: |
| 105 | | output_set_digit_value(2, digit_value); |
| 106 | | break; |
| 107 | | case 0x10: |
| 108 | | output_set_digit_value(3, digit_value); |
| 109 | | break; |
| 110 | | case 0x20: |
| 111 | | beep_set_state(state->beep, (data & 0x80) ? 0 : 1); |
| 112 | | break; |
| 113 | | case 0x01: |
| 114 | | case 0x02: |
| 115 | | case 0x40: |
| 116 | | case 0x80: |
| 117 | | // unknown, probably two bit are used for the LEDs |
| 118 | | break; |
| 119 | | } |
| 120 | | } |
| 121 | | |
| 122 | | static WRITE8_DEVICE_HANDLER( cc10_out_index_w ) |
| 123 | | { |
| 124 | | cc10_state *state = device->machine->driver_data<cc10_state>(); |
| 125 | | |
| 126 | | if (!state->out_state) |
| 127 | | state->out_index = data; |
| 128 | | |
| 129 | | state->out_state = data; |
| 130 | | } |
| 131 | | |
| 132 | | static READ8_DEVICE_HANDLER( cc10_kb_r ) |
| 133 | | { |
| 134 | | cc10_state *state = device->machine->driver_data<cc10_state>(); |
| 135 | | |
| 136 | | UINT8 data = 0; |
| 137 | | |
| 138 | | switch (state->kb_matrix & 0xf0) |
| 139 | | { |
| 140 | | case 0xe0: |
| 141 | | data = input_port_read(device->machine, "LINE1"); |
| 142 | | break; |
| 143 | | case 0xd0: |
| 144 | | data = input_port_read(device->machine, "LINE2"); |
| 145 | | break; |
| 146 | | case 0xb0: |
| 147 | | data = input_port_read(device->machine, "LINE3"); |
| 148 | | break; |
| 149 | | case 0x70: |
| 150 | | data = input_port_read(device->machine, "LINE4"); |
| 151 | | break; |
| 152 | | } |
| 153 | | |
| 154 | | return data; |
| 155 | | } |
| 156 | | |
| 157 | | static WRITE8_DEVICE_HANDLER( cc10_kb_matrix_w ) |
| 158 | | { |
| 159 | | cc10_state *state = device->machine->driver_data<cc10_state>(); |
| 160 | | |
| 161 | | state->kb_matrix = data; |
| 162 | | } |
| 163 | | |
| 164 | | static READ8_DEVICE_HANDLER( cc10_level_r ) |
| 165 | | { |
| 166 | | /* |
| 167 | | x--- ---- level select |
| 168 | | -xxx xxxx ?? |
| 169 | | */ |
| 170 | | return input_port_read(device->machine, "LEVEL"); |
| 171 | | } |
| 172 | | |
| 173 | | static const i8255a_interface cc10_i8255a_intf = |
| 174 | | { |
| 175 | | DEVCB_NULL, |
| 176 | | DEVCB_HANDLER(cc10_level_r), |
| 177 | | DEVCB_HANDLER(cc10_kb_r), |
| 178 | | DEVCB_HANDLER(cc10_out_data_w), |
| 179 | | DEVCB_HANDLER(cc10_out_index_w), |
| 180 | | DEVCB_HANDLER(cc10_kb_matrix_w) |
| 181 | | }; |
| 182 | | |
| 183 | | static MACHINE_CONFIG_START( cc10, cc10_state ) |
| 184 | | /* basic machine hardware */ |
| 185 | | MDRV_CPU_ADD("maincpu", Z80, XTAL_16MHz / 4) |
| 186 | | MDRV_CPU_PROGRAM_MAP(cc10_mem) |
| 187 | | MDRV_CPU_IO_MAP(cc10_io) |
| 188 | | |
| 189 | | MDRV_MACHINE_START(cc10) |
| 190 | | MDRV_MACHINE_RESET(cc10) |
| 191 | | |
| 192 | | MDRV_I8255A_ADD("i8255", cc10_i8255a_intf) |
| 193 | | |
| 194 | | /* video hardware */ |
| 195 | | MDRV_DEFAULT_LAYOUT(layout_cc10) |
| 196 | | |
| 197 | | /* sound hardware */ |
| 198 | | MDRV_SPEAKER_STANDARD_MONO( "mono" ) |
| 199 | | MDRV_SOUND_ADD( "beep", BEEP, 0 ) |
| 200 | | MDRV_SOUND_ROUTE( ALL_OUTPUTS, "mono", 1.00 ) |
| 201 | | MACHINE_CONFIG_END |
| 202 | | |
| 203 | | |
| 204 | | /* ROM definition */ |
| 205 | | ROM_START( cc10 ) |
| 206 | | ROM_REGION( 0x10000, "maincpu", ROMREGION_ERASEFF ) |
| 207 | | ROM_LOAD( "cc10.bin", 0x0000, 0x1000, CRC(bb9e6055) SHA1(18276e57cf56465a6352239781a828c5f3d5ba63)) |
| 208 | | ROM_END |
| 209 | | |
| 210 | | /* Driver */ |
| 211 | | |
| 212 | | /* YEAR NAME PARENT COMPAT MACHINE INPUT INIT COMPANY FULLNAME FLAGS */ |
| 213 | | COMP( 1978, cc10, 0, 0, cc10, cc10, 0, "Fidelity", "Chess Challenger 10", GAME_NOT_WORKING | GAME_NO_SOUND) |
src/mess/drivers/fidelz80.c
| r9099 | r9100 | |
| 113 | 113 | #include "emu.h" |
| 114 | 114 | #include "cpu/z80/z80.h" |
| 115 | 115 | #include "machine/i8255a.h" |
| 116 | #include "sound/beep.h" |
| 116 | 117 | #include "sound/s14001a.h" |
| 117 | | //#include "dectalk.lh" // hack to avoid screenless system crash |
| 118 | | #include "machine/terminal.h" |
| 118 | #include "fidelz80.lh" |
| 119 | 119 | |
| 120 | //#include "debugger.h" |
| 121 | |
| 120 | 122 | /* Defines */ |
| 121 | 123 | |
| 122 | | /* Components */ |
| 123 | | |
| 124 | | static struct |
| 124 | class fidelz80_state : public driver_device |
| 125 | 125 | { |
| 126 | | UINT8 data[8]; // what is this for? to suppress the scalar initializer warning? |
| 127 | | UINT8 led_7seg_data[4]; // data for the 4x 7seg leds, bits are 0bxABCDEFG |
| 128 | | UINT8 led_data; // data for the two individual leds, in 0bxxxx12xx format |
| 129 | | UINT8 led_selected; // 5 bit selects for 7 seg leds and for common other leds, bits are (7seg leds are 0 1 2 3, common other leds are C) 0bxx3210xc |
| 130 | | UINT8 columnlatch; |
| 131 | | } fidelz80={ {0}}; |
| 126 | public: |
| 127 | fidelz80_state(running_machine &machine, const driver_device_config_base &config) |
| 128 | : driver_device(machine, config) { } |
| 132 | 129 | |
| 130 | UINT8 kp_matrix; // keypad matrix |
| 131 | UINT8 led_7seg_data[4]; // data for the 4x 7seg leds, bits are 0bxABCDEFG |
| 132 | UINT8 led_data; // data for the two individual leds, in 0bxxxx12xx format |
| 133 | UINT8 led_selected; // 5 bit selects for 7 seg leds and for common other leds, bits are (7seg leds are 0 1 2 3, common other leds are C) 0bxx3210xc |
| 134 | UINT8 digit_data; // data for 7 seg leds |
| 135 | |
| 136 | device_t *beep; |
| 137 | device_t *speech; |
| 138 | }; |
| 139 | |
| 133 | 140 | /* Devices */ |
| 134 | 141 | |
| 135 | | /* I8255 Device */ |
| 142 | /****************************************************************************** |
| 143 | I8255 Device |
| 144 | ******************************************************************************/ |
| 136 | 145 | |
| 137 | | /*static READ8_DEVICE_HANDLER( vcc_porta_r ) |
| 146 | void update_display(running_machine *machine) |
| 138 | 147 | { |
| 139 | | return 0; |
| 140 | | };*/ |
| 148 | fidelz80_state *state = machine->driver_data<fidelz80_state>(); |
| 149 | UINT8 digit_data = BITSWAP8( state->digit_data,7,0,1,2,3,4,5,6 ) & 0x7f; |
| 141 | 150 | |
| 142 | | static READ8_DEVICE_HANDLER( vcc_portb_r ) |
| 151 | output_set_led_value(0, (state->led_data & 0x08) ? 1 : 0); |
| 152 | output_set_led_value(1, (state->led_data & 0x04) ? 1 : 0); |
| 153 | |
| 154 | if (state->led_selected&0x04) |
| 155 | { |
| 156 | output_set_digit_value(0, digit_data); |
| 157 | state->led_7seg_data[0] = digit_data; |
| 158 | } |
| 159 | if (state->led_selected&0x08) |
| 160 | { |
| 161 | output_set_digit_value(1, digit_data); |
| 162 | state->led_7seg_data[1] = digit_data; |
| 163 | } |
| 164 | if (state->led_selected&0x10) |
| 165 | { |
| 166 | output_set_digit_value(2, digit_data); |
| 167 | state->led_7seg_data[2] = digit_data; |
| 168 | } |
| 169 | if (state->led_selected&0x20) |
| 170 | { |
| 171 | output_set_digit_value(3, digit_data); |
| 172 | state->led_7seg_data[3] = digit_data; |
| 173 | } |
| 174 | } |
| 175 | |
| 176 | static READ8_DEVICE_HANDLER( fidelz80_portc_r ) |
| 143 | 177 | { |
| 144 | | device = device->machine->device("speech"); |
| 145 | | if (s14001a_bsy_r(device) != 0) |
| 146 | | return 0x80; |
| 147 | | else |
| 148 | | return 0; |
| 178 | fidelz80_state *state = device->machine->driver_data<fidelz80_state>(); |
| 179 | |
| 180 | UINT8 data = 0xff; |
| 181 | |
| 182 | switch (state->kp_matrix & 0xf0) |
| 183 | { |
| 184 | case 0xe0: |
| 185 | data = input_port_read(device->machine, "LINE1"); |
| 186 | break; |
| 187 | case 0xd0: |
| 188 | data = input_port_read(device->machine, "LINE2"); |
| 189 | break; |
| 190 | case 0xb0: |
| 191 | data = input_port_read(device->machine, "LINE3"); |
| 192 | break; |
| 193 | case 0x70: |
| 194 | data = input_port_read(device->machine, "LINE4"); |
| 195 | break; |
| 196 | } |
| 197 | |
| 198 | return data; |
| 199 | } |
| 200 | |
| 201 | static WRITE8_DEVICE_HANDLER( fidelz80_portb_w ) |
| 202 | { |
| 203 | fidelz80_state *state = device->machine->driver_data<fidelz80_state>(); |
| 204 | |
| 205 | if (!(data & 0x80)) |
| 206 | { |
| 207 | if (data&0x1) // common for two leds |
| 208 | state->led_data = (data&0xc); |
| 209 | |
| 210 | state->led_selected = data; |
| 211 | |
| 212 | update_display(device->machine); |
| 213 | } |
| 214 | |
| 215 | // ignoring the language switch enable for now, is bit 0x40 |
| 149 | 216 | }; |
| 150 | 217 | |
| 151 | | static READ8_DEVICE_HANDLER( vcc_portc_r ) |
| 218 | static WRITE8_DEVICE_HANDLER( fidelz80_portc_w ) |
| 152 | 219 | { |
| 153 | | return 0xFF; // TODO: emulate button input |
| 220 | fidelz80_state *state = device->machine->driver_data<fidelz80_state>(); |
| 221 | |
| 222 | state->kp_matrix = data; |
| 154 | 223 | }; |
| 155 | 224 | |
| 225 | static READ8_DEVICE_HANDLER( cc10_portb_r ) |
| 226 | { |
| 227 | /* |
| 228 | x--- ---- level select |
| 229 | -xxx xxxx ?? |
| 230 | */ |
| 231 | |
| 232 | return input_port_read(device->machine, "LEVEL"); |
| 233 | } |
| 234 | |
| 235 | static WRITE8_DEVICE_HANDLER( cc10_porta_w ) |
| 236 | { |
| 237 | fidelz80_state *state = device->machine->driver_data<fidelz80_state>(); |
| 238 | |
| 239 | beep_set_state(state->beep, (data & 0x80) ? 0 : 1); |
| 240 | |
| 241 | state->digit_data = data; |
| 242 | |
| 243 | update_display(device->machine); |
| 244 | } |
| 245 | |
| 246 | static READ8_DEVICE_HANDLER( vcc_portb_r ) |
| 247 | { |
| 248 | fidelz80_state *state = device->machine->driver_data<fidelz80_state>(); |
| 249 | |
| 250 | if (s14001a_bsy_r(state->speech) != 0) |
| 251 | return 0x80; |
| 252 | else |
| 253 | return 0x00; |
| 254 | } |
| 255 | |
| 156 | 256 | static WRITE8_DEVICE_HANDLER( vcc_porta_w ) |
| 157 | 257 | { |
| 158 | | device = device->machine->device("speech"); |
| 159 | | s14001a_set_volume(device, 15); // hack, s14001a core should assume a volume of 15 unless otherwise stated... |
| 160 | | s14001a_reg_w(device, data & 0x3f); |
| 161 | | s14001a_rst_w(device, (data & 0x80)>>7); |
| 162 | | /* handle digits below */ |
| 163 | | if (fidelz80.led_selected & 0x4) |
| 164 | | fidelz80.led_7seg_data[0] = data&0x7F; |
| 165 | | if (fidelz80.led_selected & 0x8) |
| 166 | | fidelz80.led_7seg_data[1] = data&0x7F; |
| 167 | | if (fidelz80.led_selected & 0x10) |
| 168 | | fidelz80.led_7seg_data[2] = data&0x7F; |
| 169 | | if (fidelz80.led_selected & 0x20) |
| 170 | | fidelz80.led_7seg_data[3] = data&0x7F; |
| 171 | | }; |
| 258 | fidelz80_state *state = device->machine->driver_data<fidelz80_state>(); |
| 172 | 259 | |
| 173 | | static WRITE8_DEVICE_HANDLER( vcc_portb_w ) |
| 174 | | { |
| 175 | | if (data&0x1) // common for two leds |
| 260 | s14001a_set_volume(state->speech, 15); // hack, s14001a core should assume a volume of 15 unless otherwise stated... |
| 261 | s14001a_reg_w(state->speech, data & 0x3f); |
| 262 | s14001a_rst_w(state->speech, (data & 0x80)>>7); |
| 263 | |
| 264 | if (!(data & 0x80)) |
| 176 | 265 | { |
| 177 | | fidelz80.led_data = (data&0xc); |
| 266 | state->digit_data = data; |
| 267 | |
| 268 | update_display(device->machine); |
| 178 | 269 | } |
| 179 | | fidelz80.led_selected = (data&0x3d); |
| 180 | | // ignoring the language switch enable for now, is bit 0x40 |
| 181 | | }; |
| 270 | } |
| 182 | 271 | |
| 183 | | static WRITE8_DEVICE_HANDLER( vcc_portc_w ) |
| 272 | static I8255A_INTERFACE( cc10_ppi8255_intf ) |
| 184 | 273 | { |
| 185 | | fidelz80.columnlatch = (data&0x80); |
| 274 | DEVCB_NULL, |
| 275 | DEVCB_HANDLER(cc10_portb_r), |
| 276 | DEVCB_HANDLER(fidelz80_portc_r), |
| 277 | DEVCB_HANDLER(cc10_porta_w), |
| 278 | DEVCB_HANDLER(fidelz80_portb_w), |
| 279 | DEVCB_HANDLER(fidelz80_portc_w) |
| 186 | 280 | }; |
| 187 | 281 | |
| 188 | 282 | static I8255A_INTERFACE( vcc_ppi8255_intf ) |
| 189 | 283 | { |
| 190 | 284 | DEVCB_NULL, // only bit 6 is readable (and only sometimes) and I'm not emulating the language latch unless needed |
| 191 | 285 | DEVCB_HANDLER(vcc_portb_r), // bit 7 is readable and is the done line from the s14001a |
| 192 | | DEVCB_HANDLER(vcc_portc_r), // bits 0,1,2,3 are readable, have to do with input |
| 286 | DEVCB_HANDLER(fidelz80_portc_r), // bits 0,1,2,3 are readable, have to do with input |
| 193 | 287 | DEVCB_HANDLER(vcc_porta_w), // display segments and s14001a lines |
| 194 | | DEVCB_HANDLER(vcc_portb_w), // display digits and led dots |
| 195 | | DEVCB_HANDLER(vcc_portc_w), // bits 4,5,6,7 are writable, have to do with input |
| 288 | DEVCB_HANDLER(fidelz80_portb_w), // display digits and led dots |
| 289 | DEVCB_HANDLER(fidelz80_portc_w), // bits 4,5,6,7 are writable, have to do with input |
| 196 | 290 | }; |
| 197 | 291 | |
| 292 | /****************************************************************************** |
| 293 | basic machine |
| 294 | ******************************************************************************/ |
| 295 | |
| 296 | static MACHINE_START(cc10) |
| 297 | { |
| 298 | fidelz80_state *state = machine->driver_data<fidelz80_state>(); |
| 299 | |
| 300 | state->beep = machine->device("beep"); |
| 301 | } |
| 302 | |
| 303 | static MACHINE_START(vcc) |
| 304 | { |
| 305 | fidelz80_state *state = machine->driver_data<fidelz80_state>(); |
| 306 | |
| 307 | state->speech = machine->device("speech"); |
| 308 | } |
| 309 | |
| 198 | 310 | static MACHINE_RESET( fidelz80 ) |
| 199 | 311 | { |
| 312 | fidelz80_state *state = machine->driver_data<fidelz80_state>(); |
| 313 | |
| 200 | 314 | // data for the 4x 7seg leds, bits are 0bxABCDEFG |
| 201 | | fidelz80.led_7seg_data[0] = 0; |
| 202 | | fidelz80.led_7seg_data[1] = 0; |
| 203 | | fidelz80.led_7seg_data[2] = 0; |
| 204 | | fidelz80.led_7seg_data[3] = 0; |
| 205 | | fidelz80.led_data = 0; |
| 206 | | fidelz80.led_selected = 0; |
| 207 | | fidelz80.columnlatch = 0; |
| 315 | memset(state->led_7seg_data, 0, ARRAY_LENGTH(state->led_7seg_data)); |
| 316 | state->led_data = 0; |
| 317 | state->led_selected = 0; |
| 318 | state->kp_matrix = 0; |
| 319 | state->digit_data = 0; |
| 208 | 320 | } |
| 209 | 321 | |
| 210 | | |
| 211 | | |
| 212 | 322 | /****************************************************************************** |
| 213 | | Address Maps |
| 323 | Address Maps |
| 214 | 324 | ******************************************************************************/ |
| 215 | 325 | |
| 326 | static ADDRESS_MAP_START(cc10_z80_mem, ADDRESS_SPACE_PROGRAM, 8) |
| 327 | ADDRESS_MAP_UNMAP_HIGH |
| 328 | AM_RANGE(0x0000, 0x0fff) AM_ROM |
| 329 | AM_RANGE(0x3000, 0x31ff) AM_RAM |
| 330 | ADDRESS_MAP_END |
| 331 | |
| 216 | 332 | static ADDRESS_MAP_START(vcc_z80_mem, ADDRESS_SPACE_PROGRAM, 8) |
| 217 | 333 | ADDRESS_MAP_UNMAP_HIGH |
| 218 | 334 | AM_RANGE(0x0000, 0x0fff) AM_ROM // 4k rom |
| r9099 | r9100 | |
| 221 | 337 | AM_RANGE(0x4000, 0x43ff) AM_RAM AM_MIRROR(0x1c00) // 1k ram (2114*2) mirrored 8 times |
| 222 | 338 | ADDRESS_MAP_END |
| 223 | 339 | |
| 224 | | static ADDRESS_MAP_START(vcc_z80_io, ADDRESS_SPACE_IO, 8) |
| 340 | static ADDRESS_MAP_START(fidel_z80_io, ADDRESS_SPACE_IO, 8) |
| 225 | 341 | ADDRESS_MAP_UNMAP_HIGH |
| 226 | 342 | ADDRESS_MAP_GLOBAL_MASK(0xff) |
| 227 | | AM_RANGE(0x00, 0x03) AM_MIRROR(0xFC) AM_DEVREADWRITE("vcc_ppi8255", i8255a_r, i8255a_w) // 8255 i/o chip |
| 343 | AM_RANGE(0x00, 0x03) AM_MIRROR(0xFC) AM_DEVREADWRITE("ppi8255", i8255a_r, i8255a_w) // 8255 i/o chip |
| 228 | 344 | ADDRESS_MAP_END |
| 229 | 345 | |
| 230 | 346 | |
| 231 | 347 | /****************************************************************************** |
| 232 | 348 | Input Ports |
| 233 | 349 | ******************************************************************************/ |
| 350 | |
| 234 | 351 | static INPUT_PORTS_START( fidelz80 ) |
| 235 | | PORT_INCLUDE(generic_terminal) |
| 352 | PORT_START("LEVEL") // cc10 only |
| 353 | PORT_CONFNAME( 0x80, 0x00, "Number of levels" ) |
| 354 | PORT_CONFSETTING( 0x00, "10" ) |
| 355 | PORT_CONFSETTING( 0x80, "3" ) |
| 356 | |
| 357 | PORT_START("LINE1") |
| 358 | PORT_BIT(0x01, IP_ACTIVE_LOW, IPT_KEYPAD) PORT_NAME("RE") PORT_CODE(KEYCODE_R) |
| 359 | PORT_BIT(0x02, IP_ACTIVE_LOW, IPT_KEYPAD) PORT_NAME("LV") PORT_CODE(KEYCODE_V) |
| 360 | PORT_BIT(0x04, IP_ACTIVE_LOW, IPT_KEYPAD) PORT_NAME("A1") PORT_CODE(KEYCODE_1) |
| 361 | PORT_BIT(0x08, IP_ACTIVE_LOW, IPT_KEYPAD) PORT_NAME("E5") PORT_CODE(KEYCODE_5) |
| 362 | |
| 363 | PORT_START("LINE2") |
| 364 | PORT_BIT(0x01, IP_ACTIVE_LOW, IPT_KEYPAD) PORT_NAME("CB") PORT_CODE(KEYCODE_C) |
| 365 | PORT_BIT(0x02, IP_ACTIVE_LOW, IPT_KEYPAD) PORT_NAME("DM") PORT_CODE(KEYCODE_D) |
| 366 | PORT_BIT(0x04, IP_ACTIVE_LOW, IPT_KEYPAD) PORT_NAME("B2") PORT_CODE(KEYCODE_2) |
| 367 | PORT_BIT(0x08, IP_ACTIVE_LOW, IPT_KEYPAD) PORT_NAME("F6") PORT_CODE(KEYCODE_6) |
| 368 | |
| 369 | PORT_START("LINE3") |
| 370 | PORT_BIT(0x01, IP_ACTIVE_LOW, IPT_KEYPAD) PORT_NAME("CL") PORT_CODE(KEYCODE_L) |
| 371 | PORT_BIT(0x02, IP_ACTIVE_LOW, IPT_KEYPAD) PORT_NAME("PB") PORT_CODE(KEYCODE_B) |
| 372 | PORT_BIT(0x04, IP_ACTIVE_LOW, IPT_KEYPAD) PORT_NAME("C3") PORT_CODE(KEYCODE_3) |
| 373 | PORT_BIT(0x08, IP_ACTIVE_LOW, IPT_KEYPAD) PORT_NAME("G7") PORT_CODE(KEYCODE_7) |
| 374 | |
| 375 | PORT_START("LINE4") |
| 376 | PORT_BIT(0x01, IP_ACTIVE_LOW, IPT_KEYPAD) PORT_NAME("EN") PORT_CODE(KEYCODE_E) |
| 377 | PORT_BIT(0x02, IP_ACTIVE_LOW, IPT_KEYPAD) PORT_NAME("PV") PORT_CODE(KEYCODE_O) |
| 378 | PORT_BIT(0x04, IP_ACTIVE_LOW, IPT_KEYPAD) PORT_NAME("D4") PORT_CODE(KEYCODE_4) |
| 379 | PORT_BIT(0x08, IP_ACTIVE_LOW, IPT_KEYPAD) PORT_NAME("H8") PORT_CODE(KEYCODE_8) |
| 236 | 380 | INPUT_PORTS_END |
| 237 | 381 | |
| 238 | 382 | /****************************************************************************** |
| 239 | 383 | Machine Drivers |
| 240 | 384 | ******************************************************************************/ |
| 241 | 385 | |
| 242 | | static WRITE8_DEVICE_HANDLER( null_kbd_put ) |
| 243 | | { |
| 244 | | } |
| 386 | static MACHINE_CONFIG_START( cc10, fidelz80_state ) |
| 387 | /* basic machine hardware */ |
| 388 | MDRV_CPU_ADD("maincpu", Z80, XTAL_4MHz) |
| 389 | MDRV_CPU_PROGRAM_MAP(cc10_z80_mem) |
| 390 | MDRV_CPU_IO_MAP(fidel_z80_io) |
| 391 | MDRV_QUANTUM_TIME(HZ(60)) |
| 245 | 392 | |
| 246 | | static GENERIC_TERMINAL_INTERFACE( dectalk_terminal_intf ) |
| 247 | | { |
| 248 | | DEVCB_HANDLER(null_kbd_put) |
| 249 | | }; |
| 393 | MDRV_MACHINE_START(cc10) |
| 394 | MDRV_MACHINE_RESET(fidelz80) |
| 250 | 395 | |
| 251 | | static MACHINE_CONFIG_START( vcc, driver_device ) |
| 396 | /* video hardware */ |
| 397 | MDRV_DEFAULT_LAYOUT(layout_fidelz80) |
| 398 | |
| 399 | /* other hardware */ |
| 400 | MDRV_I8255A_ADD("ppi8255", cc10_ppi8255_intf) |
| 401 | |
| 402 | /* sound hardware */ |
| 403 | MDRV_SPEAKER_STANDARD_MONO( "mono" ) |
| 404 | MDRV_SOUND_ADD( "beep", BEEP, 0 ) |
| 405 | MDRV_SOUND_ROUTE( ALL_OUTPUTS, "mono", 1.00 ) |
| 406 | MACHINE_CONFIG_END |
| 407 | |
| 408 | static MACHINE_CONFIG_START( vcc, fidelz80_state ) |
| 252 | 409 | /* basic machine hardware */ |
| 253 | 410 | MDRV_CPU_ADD("maincpu", Z80, XTAL_4MHz) |
| 254 | 411 | MDRV_CPU_PROGRAM_MAP(vcc_z80_mem) |
| 255 | | MDRV_CPU_IO_MAP(vcc_z80_io) |
| 412 | MDRV_CPU_IO_MAP(fidel_z80_io) |
| 256 | 413 | MDRV_QUANTUM_TIME(HZ(60)) |
| 414 | |
| 415 | MDRV_MACHINE_START(vcc) |
| 257 | 416 | MDRV_MACHINE_RESET(fidelz80) |
| 258 | 417 | |
| 259 | 418 | /* video hardware */ |
| 260 | | //MDRV_DEFAULT_LAYOUT(layout_dectalk) // hack to avoid screenless system crash |
| 261 | | MDRV_FRAGMENT_ADD( generic_terminal ) |
| 262 | | MDRV_GENERIC_TERMINAL_ADD(TERMINAL_TAG,dectalk_terminal_intf) |
| 419 | MDRV_DEFAULT_LAYOUT(layout_fidelz80) |
| 263 | 420 | |
| 264 | 421 | /* other hardware */ |
| 265 | | MDRV_I8255A_ADD("vcc_ppi8255", vcc_ppi8255_intf) |
| 422 | MDRV_I8255A_ADD("ppi8255", vcc_ppi8255_intf) |
| 266 | 423 | |
| 267 | 424 | /* sound hardware */ |
| 268 | 425 | MDRV_SPEAKER_STANDARD_MONO("mono") |
| 269 | 426 | MDRV_SOUND_ADD("speech", S14001A, 25000) // around 25khz |
| 270 | 427 | MDRV_SOUND_ROUTE(ALL_OUTPUTS, "mono", 0.25) |
| 271 | | |
| 272 | 428 | MACHINE_CONFIG_END |
| 273 | 429 | |
| 274 | 430 | |
| 275 | | |
| 276 | 431 | /****************************************************************************** |
| 277 | 432 | ROM Definitions |
| 278 | 433 | ******************************************************************************/ |
| 279 | 434 | |
| 435 | ROM_START( cc10 ) |
| 436 | ROM_REGION( 0x10000, "maincpu", 0 ) |
| 437 | ROM_LOAD( "cc10.bin", 0x0000, 0x1000, CRC(bb9e6055) SHA1(18276e57cf56465a6352239781a828c5f3d5ba63)) |
| 438 | ROM_END |
| 439 | |
| 280 | 440 | ROM_START(vcc) |
| 281 | | |
| 282 | 441 | ROM_REGION(0x10000, "maincpu", 0) |
| 283 | 442 | ROM_LOAD("101-32103.bin", 0x0000, 0x1000, CRC(257BB5AB) SHA1(F7589225BB8E5F3EAC55F23E2BD526BE780B38B5)) // 32014.VCC??? |
| 284 | 443 | ROM_LOAD("vcc2.bin", 0x1000, 0x1000, CRC(F33095E7) SHA1(692FCAB1B88C910B74D04FE4D0660367AEE3F4F0)) |
| r9099 | r9100 | |
| 295 | 454 | ******************************************************************************/ |
| 296 | 455 | |
| 297 | 456 | /* YEAR NAME PARENT COMPAT MACHINE INPUT INIT COMPANY FULLNAME FLAGS */ |
| 457 | COMP( 1978, cc10, 0, 0, cc10, fidelz80, 0, "Fidelity Electronics", "Chess Challenger 10", GAME_NOT_WORKING ) |
| 298 | 458 | COMP( 1982, vcc, 0, 0, vcc, fidelz80, 0, "Fidelity Electronics", "Talking Chess Challenger (model VCC)", GAME_NOT_WORKING ) |
| 299 | 459 | |