| Previous | 15994 Revisions | Next |
| r3219 Wednesday 10th September, 2008 at 19:13:52 UTC by Wilbert Pol |
|---|
| Changed the cassette implementation into a mame device. |
| [docs] | messnew.txt |
| [src/emu/sound] | wave.c |
| [src/mess] | tapectrl.c uimess.c |
| [src/mess/devices] | cassette.c cassette.h |
| [src/mess/drivers] | a2600.c abc80.c abc80x.c amstrad.c apf.c apogee.c apple1.c aquarius.c atom.c bbc.c bk.c c128.c c16.c c64.c coco.c comx35.c crvision.c dai.c electron.c exidy.c galaxy.c kc.c lviv.c mbee.c mc10.c microtan.c mikro80.c mikrosha.c msx.c mz700.c newbrain.c orao.c oric.c orion.c partner.c pc.c pet.c pmd85.c primo.c radio86.c sg1000.c sord.c special.c specpls3.c spectrum.c super80.c svi318.c thomson.c ti99_4p.c ti99_4x.c ti99_8.c timex.c tm990189.c tmc1800.c tmc2000e.c tmc600.c tutor.c ut88.c vc20.c vip.c vtech1.c vtech2.c zx.c |
| [src/mess/formats] | thom_cas.c thom_cas.h |
| [src/mess/includes] | cbm.h spectrum.h |
| [src/mess/machine] | apple1.c atom.c bbc.c bk.c c128.c c16.c c64.c cbm.c coco.c dai.c electron.c galaxy.c kc.c lviv.c mbee.c mc10.c microtan.c mikro80.c msx.c mz700.c orao.c oric.c pc.c pet.c pmd85.c primo.c radio86.c special.c svi318.c ti99_4x.c ut88.c vc20.c vtech1.c vtech2.c zx.c |
| r3218 | r3219 | |
|---|---|---|
| 26 | 26 | static void wave_sound_update(void *param,stream_sample_t **inputs, stream_sample_t **_buffer,int length) |
| 27 | 27 | { |
| 28 | 28 | #ifdef MESS |
| 29 | const device_config *image; | |
| 29 | const device_config *image = param; | |
| 30 | 30 | cassette_image *cassette; |
| 31 | 31 | cassette_state state; |
| 32 | 32 | double time_index; |
| 33 | 33 | double duration; |
| 34 | int num = ((FPTR)param) & ~WAVE_TOKEN_MASK; | |
| 35 | 34 | stream_sample_t *buffer = _buffer[0]; |
| 36 | 35 | int i; |
| 37 | 36 | |
| 38 | image = image_from_devtype_and_index(IO_CASSETTE, num); | |
| 39 | 37 | state = cassette_get_state(image); |
| 40 | 38 | |
| 41 | 39 | state &= CASSETTE_MASK_UISTATE | CASSETTE_MASK_MOTOR | CASSETTE_MASK_SPEAKER; |
| r3218 | r3219 | |
| 61 | 59 | |
| 62 | 60 | static void *wave_start(const char *tag, int sndindex, int clock, const void *config) |
| 63 | 61 | { |
| 64 | stream_create(0, 1, Machine->sample_rate, (void *) (FPTR)sndindex, wave_sound_update); | |
| 62 | const device_config *image = NULL; | |
| 63 | ||
| 64 | #ifdef MESS | |
| 65 | image = device_list_find_by_tag( Machine->config->devicelist, CASSETTE, tag ); | |
| 66 | #endif MESS | |
| 67 | stream_create(0, 1, Machine->sample_rate, (void *)image, wave_sound_update); | |
| 65 | 68 | return (void *) (FPTR)(sndindex | WAVE_TOKEN_MASK); |
| 66 | 69 | } |
| 67 | 70 |
| r3218 | r3219 | |
|---|---|---|
| 12 | 12 | #include "uimess.h" |
| 13 | 13 | #include "uiinput.h" |
| 14 | 14 | #include "input.h" |
| 15 | #include "devices/cassette.h" | |
| 15 | 16 | |
| 16 | 17 | |
| 17 | 18 | /*************************************************************************** |
| r3218 | r3219 | |
| 448 | 449 | |
| 449 | 450 | #if HAS_WAVE |
| 450 | 451 | /* add tape control menu */ |
| 451 | if (device_ | |
| 452 | if (device_list_first(m | |
| 452 | 453 | ui_menu_item_append(menu, "Tape Control", NULL, 0, ui_mess_menu_tape_control); |
| 453 | 454 | #endif /* HAS_WAVE */ |
| 454 | 455 |
| r3218 | r3219 | |
|---|---|---|
| 46 | 46 | ***************************************************************************/ |
| 47 | 47 | |
| 48 | 48 | /*------------------------------------------------- |
| 49 | cassette_count - returns the number of cassette | |
| 50 | devices in the machine | |
| 51 | -------------------------------------------------*/ | |
| 52 | ||
| 53 | INLINE int cassette_count( running_machine *machine ) | |
| 54 | { | |
| 55 | int count = 0; | |
| 56 | const device_config *device = device_list_first( machine->config->devicelist, CASSETTE ); | |
| 57 | ||
| 58 | while ( device ) | |
| 59 | { | |
| 60 | count++; | |
| 61 | device = device_list_next ( device, CASSETTE ); | |
| 62 | } | |
| 63 | return count; | |
| 64 | } | |
| 65 | ||
| 66 | /*------------------------------------------------- | |
| 49 | 67 | tapecontrol_gettime - returns a textual |
| 50 | 68 | representation of the time |
| 51 | 69 | -------------------------------------------------*/ |
| r3218 | r3219 | |
| 81 | 99 | { |
| 82 | 100 | astring *timepos = astring_alloc(); |
| 83 | 101 | cassette_state state; |
| 84 | int count = | |
| 102 | int count = | |
| 85 | 103 | UINT32 flags = 0; |
| 86 | 104 | |
| 87 | 105 | if( count > 0 ) |
| r3218 | r3219 | |
| 155 | 173 | /* do we have to load the device? */ |
| 156 | 174 | if (menustate->device == NULL) |
| 157 | 175 | { |
| 158 | menustate->device = image_from_devtype_and_index(IO_CASSETTE, menustate->index); | |
| 176 | int index = menustate->index; | |
| 177 | const device_config *device = device_list_first( machine->config->devicelist, CASSETTE ); | |
| 178 | ||
| 179 | while ( index > 0 && device ) | |
| 180 | { | |
| 181 | device = device_list_next ( device, CASSETTE ); | |
| 182 | index--; | |
| 183 | } | |
| 184 | menustate->device = device; | |
| 159 | 185 | ui_menu_reset(menu, 0); |
| 160 | 186 | } |
| 161 | 187 | |
| r3218 | r3219 | |
| 174 | 200 | if (menustate->index > 0) |
| 175 | 201 | menustate->index--; |
| 176 | 202 | else |
| 177 | menustate->index = | |
| 203 | menustate->index = | |
| 178 | 204 | menustate->device = NULL; |
| 179 | 205 | break; |
| 180 | 206 | |
| 181 | 207 | case IPT_UI_RIGHT: |
| 182 | 208 | /* right arrow - rotate right through cassette devices */ |
| 183 | if (menustate->index < | |
| 209 | if (menustate->index < | |
| 184 | 210 | menustate->index++; |
| 185 | 211 | else |
| 186 | 212 | menustate->index = 0; |
| r3218 | r3219 | |
|---|---|---|
| 8 | 8 | #define CBM_H_ |
| 9 | 9 | |
| 10 | 10 | #include "devices/snapquik.h" |
| 11 | #include "devices/cassette.h" | |
| 11 | 12 | |
| 12 | 13 | |
| 13 | 14 | /* global header file for c16, c64, c65, c128, vc20 */ |
| r3218 | r3219 | |
| 69 | 70 | |
| 70 | 71 | ***********************************************/ |
| 71 | 72 | |
| 72 | ||
| 73 | ||
| 73 | 74 | |
| 74 | 75 | |
| 75 | 76 | #endif /* CBM_H_ */ |
| r3218 | r3219 | |
|---|---|---|
| 74 | 74 | INPUT_PORTS_EXTERN( spectrum ); |
| 75 | 75 | MACHINE_DRIVER_EXTERN( spectrum ); |
| 76 | 76 | SYSTEM_CONFIG_EXTERN(spectrum) |
| 77 | SYSTEM_CONFIG_EXTERN(spectrum_common) | |
| 78 | 77 | |
| 79 | 78 | extern READ8_HANDLER(spectrum_port_1f_r); |
| 80 | 79 | extern READ8_HANDLER(spectrum_port_7f_r); |
| r3218 | r3219 | |
|---|---|---|
| 190 | 190 | data |= 0x08; // serial ready |
| 191 | 191 | if (mame_rand(machine)&0x01) |
| 192 | 192 | data |= 0x40; // random number generator |
| 193 | if (cassette_input( | |
| 193 | if (cassette_input( | |
| 194 | 194 | data |= 0x80; // tape input |
| 195 | 195 | break; |
| 196 | 196 | |
| r3218 | r3219 | |
| 225 | 225 | dai_paddle_enable = (data&0x08)>>3; |
| 226 | 226 | dai_cassette_motor[0] = (data&0x10)>>4; |
| 227 | 227 | dai_cassette_motor[1] = (data&0x20)>>5; |
| 228 | cassette_change_state(image_from_devtype_and_index(IO_CASSETTE, 0), dai_cassette_motor[0]?CASSETTE_MOTOR_DISABLED:CASSETTE_MOTOR_ENABLED, CASSETTE_MASK_MOTOR); | |
| 229 | cassette_output(image_from_devtype_and_index(IO_CASSETTE, 0), (data & 0x01) ? -1.0 : 1.0); | |
| 228 | cassette_change_state(device_list_find_by_tag( machine->config->devicelist, CASSETTE, "cassette" ), dai_cassette_motor[0]?CASSETTE_MOTOR_DISABLED:CASSETTE_MOTOR_ENABLED, CASSETTE_MASK_MOTOR); | |
| 229 | cassette_output(device_list_find_by_tag( machine->config->devicelist, CASSETTE, "cassette" ), (data & 0x01) ? -1.0 : 1.0); | |
| 230 | 230 | dai_update_memory ((data&0xc0)>>6); |
| 231 | 231 | LOG_DAI_PORT_W (offset, (data&0x06)>>2, "discrete devices - paddle select"); |
| 232 | 232 | LOG_DAI_PORT_W (offset, (data&0x08)>>3, "discrete devices - paddle enable"); |
| r3218 | r3219 | |
|---|---|---|
| 74 | 74 | wd17xx_init(machine, WD_TYPE_179X,mbee_fdc_callback, NULL); |
| 75 | 75 | } |
| 76 | 76 | |
| 77 | static const device_config *cassette_device_image( | |
| 77 | static const device_config *cassette_device_image(running_machine *machine) | |
| 78 | 78 | { |
| 79 | return | |
| 79 | return | |
| 80 | 80 | } |
| 81 | 81 | |
| 82 | 82 | /* PIO B data bits |
| r3218 | r3219 | |
| 96 | 96 | if (offset == 1) return z80pio_c_r(0,0); |
| 97 | 97 | if (offset == 3) return z80pio_c_r(0,1); |
| 98 | 98 | data = z80pio_d_r(machine,0,1) | 1; |
| 99 | if (cassette_input(cassette_device_image()) > 0.03) | |
| 99 | if (cassette_input(cassette_device_image(machine)) > 0.03) | |
| 100 | 100 | data &= ~1; |
| 101 | 101 | return data; |
| 102 | 102 | } |
| r3218 | r3219 | |
| 111 | 111 | { |
| 112 | 112 | z80pio_d_w(machine, 0,1,data); |
| 113 | 113 | data = z80pio_p_r(machine,0,1); |
| 114 | cassette_output(cassette_device_image(), (data & 0x02) ? -1.0 : +1.0); | |
| 114 | cassette_output(cassette_device_image(machine), (data & 0x02) ? -1.0 : +1.0); | |
| 115 | 115 | speaker_level_w(0, (data & 0x40) ? 1 : 0); |
| 116 | 116 | } |
| 117 | 117 | } |
| r3218 | r3219 | |
|---|---|---|
| 1133 | 1133 | return image_from_devtype_and_index(IO_CARTSLOT, 0); |
| 1134 | 1134 | } |
| 1135 | 1135 | |
| 1136 | static const device_config *cassette_device_image( | |
| 1136 | static const device_config *cassette_device_image(running_machine *machine) | |
| 1137 | 1137 | { |
| 1138 | return | |
| 1138 | return | |
| 1139 | 1139 | } |
| 1140 | 1140 | |
| 1141 | 1141 | static const device_config *bitbanger_image(running_machine *machine) |
| r3218 | r3219 | |
| 1160 | 1160 | return soundmux_status; |
| 1161 | 1161 | } |
| 1162 | 1162 | |
| 1163 | static void soundmux_update( | |
| 1163 | static void soundmux_update(running_machine *machine) | |
| 1164 | 1164 | { |
| 1165 | 1165 | /* This function is called whenever the MUX (selector switch) is changed |
| 1166 | 1166 | * It mainly turns on and off the cassette audio depending on the switch. |
| r3218 | r3219 | |
| 1181 | 1181 | } |
| 1182 | 1182 | |
| 1183 | 1183 | cococart_enable_sound(coco_cart, soundmux_status == (SOUNDMUX_STATUS_ENABLE|SOUNDMUX_STATUS_SEL2)); |
| 1184 | cassette_change_state(cassette_device_image(), new_state, CASSETTE_MASK_SPEAKER); | |
| 1184 | cassette_change_state(cassette_device_image(machine), new_state, CASSETTE_MASK_SPEAKER); | |
| 1185 | 1185 | } |
| 1186 | 1186 | |
| 1187 | 1187 | static void coco_sound_update(void) |
| r3218 | r3219 | |
| 1265 | 1265 | { |
| 1266 | 1266 | mux_sel1 = param; |
| 1267 | 1267 | (*update_keyboard)(machine); |
| 1268 | soundmux_update(); | |
| 1268 | soundmux_update(machine); | |
| 1269 | 1269 | } |
| 1270 | 1270 | |
| 1271 | 1271 | static WRITE8_HANDLER ( d_pia0_cb2_w ) |
| r3218 | r3219 | |
| 1277 | 1277 | { |
| 1278 | 1278 | mux_sel2 = param; |
| 1279 | 1279 | (*update_keyboard)(machine); |
| 1280 | soundmux_update(); | |
| 1280 | soundmux_update(machine); | |
| 1281 | 1281 | } |
| 1282 | 1282 | |
| 1283 | 1283 | |
| r3218 | r3219 | |
| 1447 | 1447 | |
| 1448 | 1448 | static WRITE8_HANDLER ( d_pia1_cb2_w ) |
| 1449 | 1449 | { |
| 1450 | soundmux_update(); | |
| 1450 | soundmux_update(machine); | |
| 1451 | 1451 | } |
| 1452 | 1452 | |
| 1453 | 1453 | /* Printer output functions used by d_pia1_pa_w */ |
| r3218 | r3219 | |
| 1526 | 1526 | } |
| 1527 | 1527 | else |
| 1528 | 1528 | { |
| 1529 | cassette_output(cassette_device_image(), ((int) dac - 0x80) / 128.0); | |
| 1529 | cassette_output(cassette_device_image(machine), ((int) dac - 0x80) / 128.0); | |
| 1530 | 1530 | } |
| 1531 | 1531 | |
| 1532 | 1532 | (*update_keyboard)(machine); |
| r3218 | r3219 | |
| 1727 | 1727 | static WRITE8_HANDLER ( d_pia1_ca2_w ) |
| 1728 | 1728 | { |
| 1729 | 1729 | cassette_change_state( |
| 1730 | cassette_device_image(), | |
| 1730 | cassette_device_image(machine), | |
| 1731 | 1731 | data ? CASSETTE_MOTOR_ENABLED : CASSETTE_MOTOR_DISABLED, |
| 1732 | 1732 | CASSETTE_MASK_MOTOR); |
| 1733 | 1733 | } |
| r3218 | r3219 | |
| 1736 | 1736 | |
| 1737 | 1737 | static READ8_HANDLER ( d_pia1_pa_r ) |
| 1738 | 1738 | { |
| 1739 | return (cassette_input(cassette_device_image()) >= 0) ? 1 : 0; | |
| 1739 | return (cassette_input(cassette_device_image(machine)) >= 0) ? 1 : 0; | |
| 1740 | 1740 | } |
| 1741 | 1741 | |
| 1742 | 1742 |
| r3218 | r3219 | |
|---|---|---|
| 59 | 59 | |
| 60 | 60 | static READ8_HANDLER (radio86_8255_portc_r2 ) |
| 61 | 61 | { |
| 62 | double level = cassette_input( | |
| 62 | double level = cassette_input( | |
| 63 | 63 | UINT8 dat = input_port_read(machine,"LINE8"); |
| 64 | 64 | if (level < 0) { |
| 65 | 65 | dat ^= radio86_tape_value; |
| r3218 | r3219 | |
| 74 | 74 | |
| 75 | 75 | static WRITE8_HANDLER (radio86_8255_portc_w2 ) |
| 76 | 76 | { |
| 77 | cassette_output( | |
| 77 | cassette_output( | |
| 78 | 78 | } |
| 79 | 79 | |
| 80 | 80 | |
| r3218 | r3219 | |
| 102 | 102 | |
| 103 | 103 | static READ8_HANDLER (rk7007_8255_portc_r ) |
| 104 | 104 | { |
| 105 | double level = cassette_input( | |
| 105 | double level = cassette_input( | |
| 106 | 106 | UINT8 key = 0xff; |
| 107 | 107 | if ((radio86_keyboard_mask & 0x01)!=0) { key &= input_port_read(machine,"CLINE0"); } |
| 108 | 108 | if ((radio86_keyboard_mask & 0x02)!=0) { key &= input_port_read(machine,"CLINE1"); } |
| r3218 | r3219 | |
|---|---|---|
| 775 | 775 | if (!(input_port_read(machine, "DSW0") & 0x02)) /* V.24 / Tape Switch */ |
| 776 | 776 | { |
| 777 | 777 | /* tape reading */ |
| 778 | if (cassette_get_state( | |
| 778 | if (cassette_get_state( | |
| 779 | 779 | { |
| 780 | 780 | switch (pmd85_model) |
| 781 | 781 | { |
| 782 | 782 | case PMD85_1: |
| 783 | 783 | if (clk_level_tape) |
| 784 | 784 | { |
| 785 | previous_level = (cassette_input( | |
| 785 | previous_level = (cassette_input( | |
| 786 | 786 | clk_level_tape = 0; |
| 787 | 787 | } |
| 788 | 788 | else |
| 789 | 789 | { |
| 790 | current_level = (cassette_input( | |
| 790 | current_level = (cassette_input( | |
| 791 | 791 | |
| 792 | 792 | if (previous_level!=current_level) |
| 793 | 793 | { |
| r3218 | r3219 | |
| 812 | 812 | } |
| 813 | 813 | |
| 814 | 814 | /* tape writing */ |
| 815 | if (cassette_get_state( | |
| 815 | if (cassette_get_state( | |
| 816 | 816 | { |
| 817 | 817 | data = get_in_data_bit(pmd85_cassette_serial_connection.input_state); |
| 818 | 818 | data ^= clk_level_tape; |
| 819 | cassette_output( | |
| 819 | cassette_output( | |
| 820 | 820 | |
| 821 | 821 | if (!clk_level_tape) |
| 822 | 822 | msm8251_transmit_clock(); |
| r3218 | r3219 | |
|---|---|---|
| 815 | 815 | |
| 816 | 816 | static void c128_m6510_port_write(UINT8 direction, UINT8 data) |
| 817 | 817 | { |
| 818 | running_machine *machine = Machine; | |
| 819 | ||
| 818 | 820 | /* if line is marked as input then keep current value */ |
| 819 | 821 | data = (c64_port_data & ~direction) | (data & direction); |
| 820 | 822 | |
| r3218 | r3219 | |
| 834 | 836 | { |
| 835 | 837 | if (direction & 0x08) |
| 836 | 838 | { |
| 837 | cassette_output( | |
| 839 | cassette_output( | |
| 838 | 840 | } |
| 839 | 841 | |
| 840 | 842 | if (direction & 0x20) |
| 841 | 843 | { |
| 842 | 844 | if(!(data & 0x20)) |
| 843 | 845 | { |
| 844 | cassette_change_state( | |
| 846 | cassette_change_state( | |
| 845 | 847 | timer_adjust_periodic(datasette_timer, attotime_zero, 0, ATTOTIME_IN_HZ(44100)); |
| 846 | 848 | } |
| 847 | 849 | else |
| 848 | 850 | { |
| 849 | cassette_change_state( | |
| 851 | cassette_change_state( | |
| 850 | 852 | timer_reset(datasette_timer, attotime_never); |
| 851 | 853 | } |
| 852 | 854 | } |
| r3218 | r3219 | |
| 863 | 865 | running_machine *machine = Machine; |
| 864 | 866 | UINT8 data = c64_port_data; |
| 865 | 867 | |
| 866 | if ((cassette_get_state( | |
| 868 | if ((cassette_get_state( | |
| 867 | 869 | data &= ~0x10; |
| 868 | 870 | else |
| 869 | 871 | data |= 0x10; |
| r3218 | r3219 | |
|---|---|---|
| 82 | 82 | { |
| 83 | 83 | int data = 0xf0 | pet_keyline_select; |
| 84 | 84 | |
| 85 | if ((cassette_get_state( | |
| 85 | if ((cassette_get_state( | |
| 86 | 86 | data &= ~0x10; |
| 87 | 87 | |
| 88 | if ((cassette_get_state( | |
| 88 | if ((cassette_get_state( | |
| 89 | 89 | data &= ~0x20; |
| 90 | 90 | |
| 91 | 91 | if (!cbm_ieee_eoi_r()) |
| r3218 | r3219 | |
| 147 | 147 | static READ8_HANDLER( pet_pia0_ca1_in ) |
| 148 | 148 | { |
| 149 | 149 | // cassette 1 read |
| 150 | return (cassette_input( | |
| 150 | return (cassette_input( | |
| 151 | 151 | } |
| 152 | 152 | |
| 153 | 153 | |
| r3218 | r3219 | |
| 160 | 160 | { |
| 161 | 161 | if (!data) |
| 162 | 162 | { |
| 163 | cassette_change_state( | |
| 163 | cassette_change_state( | |
| 164 | 164 | timer_adjust_periodic(datasette1_timer, attotime_zero, 0, ATTOTIME_IN_HZ(48000)); // I put 48000 because I was given some .wav with this freq |
| 165 | 165 | } |
| 166 | 166 | else |
| 167 | 167 | { |
| 168 | cassette_change_state( | |
| 168 | cassette_change_state( | |
| 169 | 169 | timer_reset(datasette1_timer, attotime_never); |
| 170 | 170 | } |
| 171 | 171 | } |
| r3218 | r3219 | |
| 303 | 303 | |
| 304 | 304 | if (!(data & 0x10)) |
| 305 | 305 | { |
| 306 | cassette_change_state( | |
| 306 | cassette_change_state( | |
| 307 | 307 | timer_adjust_periodic(datasette2_timer, attotime_zero, 0, ATTOTIME_IN_HZ(48000)); // I put 48000 because I was given some .wav with this freq |
| 308 | 308 | } |
| 309 | 309 | else |
| 310 | 310 | { |
| 311 | cassette_change_state( | |
| 311 | cassette_change_state( | |
| 312 | 312 | timer_reset(datasette2_timer, attotime_never); |
| 313 | 313 | } |
| 314 | 314 | |
| r3218 | r3219 | |
| 323 | 323 | static READ8_HANDLER( pet_via_cb1_r ) |
| 324 | 324 | { |
| 325 | 325 | // cassette 2 read |
| 326 | return (cassette_input( | |
| 326 | return (cassette_input( | |
| 327 | 327 | } |
| 328 | 328 | |
| 329 | 329 | |
| r3218 | r3219 | |
| 560 | 560 | static TIMER_CALLBACK( pet_tape1_timer ) |
| 561 | 561 | { |
| 562 | 562 | // cassette 1 |
| 563 | UINT8 data = (cassette_input( | |
| 563 | UINT8 data = (cassette_input( | |
| 564 | 564 | pia_0_ca1_w(machine, 0, data); |
| 565 | 565 | } |
| 566 | 566 | |
| r3218 | r3219 | |
| 568 | 568 | static TIMER_CALLBACK( pet_tape2_timer ) |
| 569 | 569 | { |
| 570 | 570 | // cassette 2 |
| 571 | UINT8 data = (cassette_input( | |
| 571 | UINT8 data = (cassette_input( | |
| 572 | 572 | via_0_cb1_w(machine, 0, data); |
| 573 | 573 | } |
| 574 | 574 |
| r3218 | r3219 | |
|---|---|---|
| 23 | 23 | #include "devices/cassette.h" |
| 24 | 24 | #include "devices/cartslot.h" |
| 25 | 25 | |
| 26 | #include "deprecat.h" | |
| 26 | 27 | |
| 28 | ||
| 27 | 29 | #define VERBOSE_LEVEL 0 |
| 28 | 30 | #define DBG_LOG(N,M,A) \ |
| 29 | 31 | { \ |
| r3218 | r3219 | |
| 138 | 140 | |
| 139 | 141 | UINT8 c16_m7501_port_read(void) |
| 140 | 142 | { |
| 143 | running_machine *machine = Machine; | |
| 141 | 144 | UINT8 data = 0xff; |
| 142 | 145 | UINT8 c16_port7501 = (UINT8) cpunum_get_info_int(0, CPUINFO_INT_M6510_PORT); |
| 143 | 146 | |
| r3218 | r3219 | |
| 149 | 152 | |
| 150 | 153 | // data &= ~0x20; // port bit not in pinout |
| 151 | 154 | |
| 152 | if (cassette_input( | |
| 155 | if (cassette_input( | |
| 153 | 156 | data |= 0x10; |
| 154 | 157 | else |
| 155 | 158 | data &= ~0x10; |
| 156 | 159 | |
| 157 | cassette_change_state( | |
| 160 | cassette_change_state( | |
| 158 | 161 | |
| 159 | 162 | return data; |
| 160 | 163 | } |
| r3218 | r3219 | |
| 317 | 320 | { |
| 318 | 321 | int data = 0x00; |
| 319 | 322 | |
| 320 | if (!((cassette_get_state( | |
| 323 | if (!((cassette_get_state( | |
| 321 | 324 | data |= 0x04; |
| 322 | 325 | return data; |
| 323 | 326 | } |
| r3218 | r3219 | |
| 326 | 329 | { |
| 327 | 330 | int data = 0x00; |
| 328 | 331 | |
| 329 | if (!((cassette_get_state( | |
| 332 | if (!((cassette_get_state( | |
| 330 | 333 | data |= 0x04; |
| 331 | 334 | return data; |
| 332 | 335 | } |
| r3218 | r3219 | |
|---|---|---|
| 269 | 269 | */ |
| 270 | 270 | |
| 271 | 271 | |
| 272 | static const device_config *cassette_device_image( | |
| 272 | static const device_config *cassette_device_image(running_machine *machine) | |
| 273 | 273 | { |
| 274 | return | |
| 274 | return | |
| 275 | 275 | } |
| 276 | 276 | |
| 277 | 277 | /* not called yet - this will update the via with the state of the tape data. |
| r3218 | r3219 | |
| 283 | 283 | |
| 284 | 284 | data = 0; |
| 285 | 285 | |
| 286 | if (cassette_input(cassette_device_image()) > 0.0038) | |
| 286 | if (cassette_input(cassette_device_image(machine)) > 0.0038) | |
| 287 | 287 | data |= 1; |
| 288 | 288 | |
| 289 | 289 | /* "A simple cable to catch the vertical retrace signal ! |
| r3218 | r3219 | |
| 319 | 319 | } |
| 320 | 320 | |
| 321 | 321 | cassette_change_state( |
| 322 | cassette_device_image(), | |
| 322 | cassette_device_image(machine), | |
| 323 | 323 | (data & 0x40) ? CASSETTE_MOTOR_ENABLED : CASSETTE_MOTOR_DISABLED, |
| 324 | 324 | CASSETTE_MOTOR_DISABLED); |
| 325 | 325 | |
| 326 | 326 | /* cassette data out */ |
| 327 | cassette_output(cassette_device_image(), (data & (1<<7)) ? -1.0 : +1.0); | |
| 327 | cassette_output(cassette_device_image(machine), (data & (1<<7)) ? -1.0 : +1.0); | |
| 328 | 328 | |
| 329 | 329 | |
| 330 | 330 | /* PRINTER STROBE */ |
| r3218 | r3219 | |
|---|---|---|
| 57 | 57 | case 0x03FF : return input_port_read(machine, "LINE19"); break; |
| 58 | 58 | /* Tape */ |
| 59 | 59 | case 0x07FF : |
| 60 | level = cassette_input( | |
| 60 | level = cassette_input( | |
| 61 | 61 | if (level < 0) { |
| 62 | 62 | return 0x00; |
| 63 | 63 | } |
| r3218 | r3219 | |
|---|---|---|
| 15 | 15 | ULA ula; |
| 16 | 16 | static emu_timer *electron_tape_timer; |
| 17 | 17 | |
| 18 | static const device_config *cassette_device_image( void ) { | |
| 19 | return image_from_devtype_and_index( IO_CASSETTE, 0 ); | |
| 18 | static const device_config *cassette_device_image( running_machine *machine ) { | |
| 19 | return device_list_find_by_tag( machine->config->devicelist, CASSETTE, "cassette" ); | |
| 20 | 20 | } |
| 21 | 21 | |
| 22 | 22 | static void electron_tape_start( void ) { |
| r3218 | r3219 | |
| 43 | 43 | { |
| 44 | 44 | if ( ula.cassette_motor_mode ) { |
| 45 | 45 | double tap_val; |
| 46 | tap_val = cassette_input( cassette_device_image() ); | |
| 46 | tap_val = cassette_input( cassette_device_image( machine ) ); | |
| 47 | 47 | if ( tap_val < -0.5 ) { |
| 48 | 48 | ula.tape_value = ( ula.tape_value << 8 ) | TAPE_LOW; |
| 49 | 49 | ula.tape_steps++; |
| r3218 | r3219 | |
| 227 | 227 | ula.vram = memory_get_read_ptr( 0, ADDRESS_SPACE_PROGRAM, ula.screen_base ); |
| 228 | 228 | logerror( "ULA: screen mode set to %d\n", ula.screen_mode ); |
| 229 | 229 | ula.cassette_motor_mode = ( data >> 6 ) & 0x01; |
| 230 | cassette_change_state( cassette_device_image(), ula.cassette_motor_mode ? CASSETTE_MOTOR_ENABLED : CASSETTE_MOTOR_DISABLED, CASSETTE_MOTOR_DISABLED ); | |
| 230 | cassette_change_state( cassette_device_image( machine ), ula.cassette_motor_mode ? CASSETTE_MOTOR_ENABLED : CASSETTE_MOTOR_DISABLED, CASSETTE_MOTOR_DISABLED ); | |
| 231 | 231 | ula.capslock_mode = ( data >> 7 ) & 0x01; |
| 232 | 232 | break; |
| 233 | 233 | case 0x08: case 0x0A: case 0x0C: case 0x0E: |
| r3218 | r3219 | |
|---|---|---|
| 102 | 102 | } |
| 103 | 103 | |
| 104 | 104 | READ16_HANDLER (bk_key_press_r) { |
| 105 | double level = cassette_input( | |
| 105 | double level = cassette_input( | |
| 106 | 106 | UINT16 cas; |
| 107 | 107 | if (level < 0) { |
| 108 | 108 | cas = 0x00; |
| r3218 | r3219 | |
|---|---|---|
| 159 | 159 | cpunum_set_input_line(machine, 0, 0, via_0_irq_line | via_1_irq_line | kbd_irq_line); |
| 160 | 160 | } |
| 161 | 161 | |
| 162 | static const device_config *cassette_device_image( | |
| 162 | static const device_config *cassette_device_image(running_machine *machine) | |
| 163 | 163 | { |
| 164 | return | |
| 164 | return | |
| 165 | 165 | } |
| 166 | 166 | |
| 167 | 167 | /************************************************************** |
| r3218 | r3219 | |
| 218 | 218 | { |
| 219 | 219 | LOG(("microtan_via_0_out_b %02X\n", data)); |
| 220 | 220 | /* bit #7 is the cassette output signal */ |
| 221 | cassette_output(cassette_device_image(), data & 0x80 ? +1.0 : -1.0); | |
| 221 | cassette_output(cassette_device_image(machine), data & 0x80 ? +1.0 : -1.0); | |
| 222 | 222 | } |
| 223 | 223 | |
| 224 | 224 | static WRITE8_HANDLER ( via_0_out_ca2 ) |
| r3218 | r3219 | |
| 337 | 337 | |
| 338 | 338 | static TIMER_CALLBACK(microtan_read_cassette) |
| 339 | 339 | { |
| 340 | double level = cassette_input(cassette_device_image()); | |
| 340 | double level = cassette_input(cassette_device_image(machine)); | |
| 341 | 341 | |
| 342 | 342 | LOG(("microtan_read_cassette: %g\n", level)); |
| 343 | 343 | if (level < -0.07) |
| r3218 | r3219 | |
|---|---|---|
| 165 | 165 | Cassette Handling |
| 166 | 166 | ******************************************************************************/ |
| 167 | 167 | |
| 168 | static const device_config *cassette_device_image( | |
| 168 | static const device_config *cassette_device_image(running_machine *machine) | |
| 169 | 169 | { |
| 170 | return | |
| 170 | return | |
| 171 | 171 | } |
| 172 | 172 | |
| 173 | 173 | |
| r3218 | r3219 | |
| 498 | 498 | data &= ~0x80; |
| 499 | 499 | |
| 500 | 500 | /* cassette input is bit 5 (0x40) */ |
| 501 | level = cassette_input(cassette_device_image()); | |
| 501 | level = cassette_input(cassette_device_image(machine)); | |
| 502 | 502 | if (level < -0.008) |
| 503 | 503 | cassette_bit = 0x00; |
| 504 | 504 | if (level > +0.008) |
| r3218 | r3219 | |
| 529 | 529 | if ((vtech1_latch ^ data ) & 0x06) |
| 530 | 530 | { |
| 531 | 531 | static double amp[4] = { +1.0, +0.5, -0.5, -1.0 }; |
| 532 | cassette_output(cassette_device_image(), amp[(data >> 1) & 3]); | |
| 532 | cassette_output(cassette_device_image(machine), amp[(data >> 1) & 3]); | |
| 533 | 533 | } |
| 534 | 534 | |
| 535 | 535 | /* speaker data bits toggle? */ |
| r3218 | r3219 | |
|---|---|---|
| 91 | 91 | // bit 3 - I3 (external bus) |
| 92 | 92 | |
| 93 | 93 | // bit 2 - cassette |
| 94 | data |= (cassette_input( | |
| 94 | data |= (cassette_input( | |
| 95 | 95 | |
| 96 | 96 | // bit 1 - reset button |
| 97 | 97 | data |= (input_port_read(machine, "RESET")) ? 0x02 : 0x00; |
| r3218 | r3219 | |
| 155 | 155 | switch (data & 0x03) |
| 156 | 156 | { |
| 157 | 157 | case 0: |
| 158 | cassette_output( | |
| 158 | cassette_output( | |
| 159 | 159 | break; |
| 160 | 160 | case 1: |
| 161 | 161 | case 2: |
| 162 | cassette_output( | |
| 162 | cassette_output( | |
| 163 | 163 | break; |
| 164 | 164 | case 3: |
| 165 | cassette_output( | |
| 165 | cassette_output( | |
| 166 | 166 | break; |
| 167 | 167 | } |
| 168 | 168 | } |
| r3218 | r3219 | |
|---|---|---|
| 22 | 22 | #include "formats/svi_cas.h" |
| 23 | 23 | #include "sound/dac.h" |
| 24 | 24 | #include "sound/ay8910.h" |
| 25 | #include "deprecat.h" | |
| 25 | 26 | |
| 26 | 27 | enum { |
| 27 | 28 | SVI_INTERNAL = 0, |
| r3218 | r3219 | |
| 167 | 168 | { |
| 168 | 169 | int data = 0x0f; |
| 169 | 170 | |
| 170 | if (cassette_input( | |
| 171 | if (cassette_input( | |
| 171 | 172 | data |= 0x80; |
| 172 | 173 | if (!svi318_cassette_present(0)) |
| 173 | 174 | data |= 0x40; |
| r3218 | r3219 | |
| 228 | 229 | if (svi318_cassette_present(0)) |
| 229 | 230 | { |
| 230 | 231 | cassette_change_state( |
| 231 | | |
| 232 | | |
| 232 | 233 | (data & 0x10) ? CASSETTE_MOTOR_DISABLED : CASSETTE_MOTOR_ENABLED, |
| 233 | 234 | CASSETTE_MOTOR_DISABLED); |
| 234 | 235 | } |
| 235 | 236 | |
| 236 | 237 | /* cassette signal write */ |
| 237 | cassette_output( | |
| 238 | cassette_output( | |
| 238 | 239 | |
| 239 | 240 | svi.keyboard_row = data & 0x0F; |
| 240 | 241 | } |
| r3218 | r3219 | |
| 808 | 809 | |
| 809 | 810 | int svi318_cassette_present(int id) |
| 810 | 811 | { |
| 811 | return image_exists(image_from_devtype_and_index(IO_CASSETTE, id)); | |
| 812 | const device_config *img = device_list_find_by_tag( Machine->config->devicelist, CASSETTE, "cassette" ); | |
| 813 | ||
| 814 | if ( img == NULL ) | |
| 815 | return FALSE; | |
| 816 | return image_exists(img); | |
| 812 | 817 | } |
| 813 | 818 | |
| 814 | 819 | /* External I/O */ |
| r3218 | r3219 | |
|---|---|---|
| 22 | 22 | |
| 23 | 23 | if (offset == 0) |
| 24 | 24 | { |
| 25 | double level = cassette_input( | |
| 25 | double level = cassette_input( | |
| 26 | 26 | return (level > 0) ? 0xfe : 0xff; |
| 27 | 27 | } |
| 28 | 28 | else |
| r3218 | r3219 | |
| 37 | 37 | { |
| 38 | 38 | double val = (((data >>6) & 1 ) + ((data >> 2) & 1) - 1) * 32000; |
| 39 | 39 | gal_latch_value = data; |
| 40 | cassette_output( | |
| 40 | cassette_output( | |
| 41 | 41 | } |
| 42 | 42 | |
| 43 | 43 |
| r3218 | r3219 | |
|---|---|---|
| 196 | 196 | } |
| 197 | 197 | } |
| 198 | 198 | |
| 199 | static const device_config *vtech2_cassette_image( | |
| 199 | static const device_config *vtech2_cassette_image(running_machine *machine) | |
| 200 | 200 | { |
| 201 | return | |
| 201 | return | |
| 202 | 202 | } |
| 203 | 203 | |
| 204 | 204 | /************************************************* |
| r3218 | r3219 | |
| 277 | 277 | } |
| 278 | 278 | |
| 279 | 279 | /* what's bit 7 good for? tape input maybe? */ |
| 280 | level = cassette_input(vtech2_cassette_image()) * 65536.0; | |
| 280 | level = cassette_input(vtech2_cassette_image(machine)) * 65536.0; | |
| 281 | 281 | if( level < level_old - 511 ) |
| 282 | 282 | cassette_bit = 0x00; |
| 283 | 283 | if( level > level_old + 511 ) |
| r3218 | r3219 | |
|---|---|---|
| 190 | 190 | |
| 191 | 191 | ***********************************************/ |
| 192 | 192 | |
| 193 | ||
| 193 | const ca | |
| 194 | 194 | { |
| 195 | /* cassette */ | |
| 196 | switch(state) | |
| 197 | { | |
| 198 | case MESS_DEVINFO_INT_COUNT: info->i = 1; break; | |
| 199 | ||
| 200 | case MESS_DEVINFO_INT_CASSETTE_DEFAULT_STATE: info->i = CASSETTE_STOPPED | CASSETTE_MOTOR_DISABLED | CASSETTE_SPEAKER_ENABLED; break; | |
| 201 | case MESS_DEVINFO_PTR_CASSETTE_FORMATS: info->p = (void *)cbm_cassette_formats; break; | |
| 202 | ||
| 203 | default: cassette_device_getinfo(devclass, state, info); break; | |
| 204 | } | |
| 205 | } | |
| 195 | cbm_cassette_formats, | |
| 196 | NULL, | |
| 197 | CASSETTE_STOPPED | CASSETTE_MOTOR_DISABLED | CASSETTE_SPEAKER_ENABLED | |
| 198 | }; |
| r3218 | r3219 | |
|---|---|---|
| 180 | 180 | } |
| 181 | 181 | else |
| 182 | 182 | { |
| 183 | if ((cassette_input( | |
| 183 | if ((cassette_input( | |
| 184 | 184 | { |
| 185 | 185 | zx_tape_bit = 0x00; |
| 186 | 186 | timer_set(ATTOTIME_IN_USEC(362), NULL, 0, zx_tape_pulse); |
| r3218 | r3219 | |
| 245 | 245 | } |
| 246 | 246 | else |
| 247 | 247 | { |
| 248 | if ((cassette_input( | |
| 248 | if ((cassette_input( | |
| 249 | 249 | { |
| 250 | 250 | zx_tape_bit = 0x00; |
| 251 | 251 | timer_set(ATTOTIME_IN_USEC(362), NULL, 0, zx_tape_pulse); |
| r3218 | r3219 | |
|---|---|---|
| 438 | 438 | ay8910_control_port_0_w (machine, offset, data); |
| 439 | 439 | } |
| 440 | 440 | |
| 441 | static const device_config *cassette_device_image( | |
| 441 | static const device_config *cassette_device_image(running_machine *machine) | |
| 442 | 442 | { |
| 443 | return | |
| 443 | return | |
| 444 | 444 | } |
| 445 | 445 | |
| 446 | 446 | static const device_config *printer_image(running_machine *machine) |
| r3218 | r3219 | |
| 452 | 452 | { |
| 453 | 453 | int data, inp; |
| 454 | 454 | |
| 455 | data = (cassette_input(cassette_device_image()) > 0.0038 ? 0x80 : 0); | |
| 455 | data = (cassette_input(cassette_device_image(machine)) > 0.0038 ? 0x80 : 0); | |
| 456 | 456 | |
| 457 | 457 | if ( (msx1.psg_b ^ input_port_read(machine, "DSW") ) & 0x40) |
| 458 | 458 | { |
| r3218 | r3219 | |
| 714 | 714 | |
| 715 | 715 | /* cassette motor on/off */ |
| 716 | 716 | if ( (old_val ^ data) & 0x10) |
| 717 | cassette_change_state(cassette_device_image(), | |
| 717 | cassette_change_state(cassette_device_image(machine), | |
| 718 | 718 | (data & 0x10) ? CASSETTE_MOTOR_DISABLED : |
| 719 | 719 | CASSETTE_MOTOR_ENABLED, |
| 720 | 720 | CASSETTE_MASK_MOTOR); |
| 721 | 721 | |
| 722 | 722 | /* cassette signal write */ |
| 723 | 723 | if ( (old_val ^ data) & 0x20) |
| 724 | cassette_output(cassette_device_image(), (data & 0x20) ? -1.0 : 1.0); | |
| 724 | cassette_output(cassette_device_image(machine), (data & 0x20) ? -1.0 : 1.0); | |
| 725 | 725 | |
| 726 | 726 | old_val = data; |
| 727 | 727 | } |
| r3218 | r3219 | |
|---|---|---|
| 161 | 161 | if (mz700_motor_on) |
| 162 | 162 | data |= 0x10; |
| 163 | 163 | |
| 164 | if (cassette_input( | |
| 164 | if (cassette_input( | |
| 165 | 165 | data |= 0x20; /* set the RDATA status */ |
| 166 | 166 | |
| 167 | 167 | if (ne556_out[0]) |
| r3218 | r3219 | |
| 210 | 210 | pio_port_c_output = data; |
| 211 | 211 | |
| 212 | 212 | cassette_change_state( |
| 213 | | |
| 213 | | |
| 214 | 214 | ((data & 0x08) && mz700_motor_on) ? CASSETTE_MOTOR_ENABLED : CASSETTE_MOTOR_DISABLED, |
| 215 | 215 | CASSETTE_MOTOR_DISABLED); |
| 216 | 216 | |
| 217 | cassette_output( | |
| 217 | cassette_output( | |
| 218 | 218 | } |
| 219 | 219 | |
| 220 | 220 | /************************ MMIO ***********************************************/ |
| r3218 | r3219 | |
|---|---|---|
| 66 | 66 | static READ8_HANDLER ( lviv_ppi_0_portc_r ) |
| 67 | 67 | { |
| 68 | 68 | UINT8 data = lviv_ppi_port_outputs[0][2] & 0x0f; |
| 69 | if (cassette_input( | |
| 69 | if (cassette_input( | |
| 70 | 70 | data |= 0x10; |
| 71 | 71 | if (lviv_ppi_port_outputs[0][0] & input_port_read(machine, "JOY")) |
| 72 | 72 | data |= 0x80; |
| r3218 | r3219 | |
| 89 | 89 | lviv_ppi_port_outputs[0][2] = data; |
| 90 | 90 | if (lviv_ppi_port_outputs[0][1]&0x80) |
| 91 | 91 | speaker_level_w(0, data&0x01); |
| 92 | cassette_output( | |
| 92 | cassette_output( | |
| 93 | 93 | lviv_update_memory(); |
| 94 | 94 | } |
| 95 | 95 |
| r3218 | r3219 | |
|---|---|---|
| 135 | 135 | * BIT 4 CASSETTE TAPE INPUT |
| 136 | 136 | */ |
| 137 | 137 | |
| 138 | const device_config *img = | |
| 138 | const device_config *img = | |
| 139 | 139 | int val = 0xed; |
| 140 | 140 | |
| 141 | 141 | if ((input_port_read(machine, "LINE6") | mc10_keyboard_strobe) == 0xff) |
| r3218 | r3219 | |
| 150 | 150 | |
| 151 | 151 | WRITE8_HANDLER ( mc10_port2_w ) |
| 152 | 152 | { |
| 153 | const device_config *img = | |
| 153 | const device_config *img = | |
| 154 | 154 | |
| 155 | 155 | /* BIT 0 PRINTER OUTFUT & CASS OUTPUT |
| 156 | 156 | */ |
| r3218 | r3219 | |
|---|---|---|
| 52 | 52 | } |
| 53 | 53 | } |
| 54 | 54 | |
| 55 | static const device_config *cassette_device_image( | |
| 55 | static const device_config *cassette_device_image(running_machine *machine) | |
| 56 | 56 | { |
| 57 | return | |
| 57 | return | |
| 58 | 58 | } |
| 59 | 59 | |
| 60 | 60 | static const device_config *printer_image(running_machine *machine) |
| r3218 | r3219 | |
| 215 | 215 | result = (~(B & atom_8255_portc)) & 0x01; |
| 216 | 216 | |
| 217 | 217 | /* tape output */ |
| 218 | cassette_output(cassette_device_image(), (result & 0x01) ? -1.0 : +1.0); | |
| 218 | cassette_output(cassette_device_image(machine), (result & 0x01) ? -1.0 : +1.0); | |
| 219 | 219 | } |
| 220 | 220 | } |
| 221 | 221 | |
| r3218 | r3219 | |
| 370 | 370 | atom_8255_portc &= 0x0f; |
| 371 | 371 | |
| 372 | 372 | /* cassette input */ |
| 373 | if (cassette_input(cassette_device_image()) > 0.0) | |
| 373 | if (cassette_input(cassette_device_image(machine)) > 0.0) | |
| 374 | 374 | { |
| 375 | 375 | atom_8255_portc |= (1<<5); |
| 376 | 376 | } |
| r3218 | r3219 | |
|---|---|---|
| 92 | 92 | |
| 93 | 93 | if(via0_ca2) |
| 94 | 94 | { |
| 95 | cassette_change_state( | |
| 95 | cassette_change_state( | |
| 96 | 96 | timer_adjust_periodic(datasette_timer, attotime_zero, 0, ATTOTIME_IN_HZ(44100)); |
| 97 | 97 | } |
| 98 | 98 | else |
| 99 | 99 | { |
| 100 | cassette_change_state( | |
| 100 | cassette_change_state( | |
| 101 | 101 | timer_reset(datasette_timer, attotime_never); |
| 102 | 102 | } |
| 103 | 103 | } |
| r3218 | r3219 | |
| 117 | 117 | if (!serial_data || !cbm_serial_data_read ()) |
| 118 | 118 | value &= ~0x02; |
| 119 | 119 | |
| 120 | if ((cassette_get_state( | |
| 120 | if ((cassette_get_state( | |
| 121 | 121 | value &= ~0x40; |
| 122 | 122 | else |
| 123 | 123 | value |= 0x40; |
| r3218 | r3219 | |
| 180 | 180 | |
| 181 | 181 | static READ8_HANDLER( vc20_via1_read_ca1 ) |
| 182 | 182 | { |
| 183 | UINT8 data = (cassette_input( | |
| 183 | UINT8 data = (cassette_input( | |
| 184 | 184 | return data; |
| 185 | 185 | } |
| 186 | 186 | |
| r3218 | r3219 | |
| 319 | 319 | static WRITE8_HANDLER( vc20_via1_write_portb ) |
| 320 | 320 | { |
| 321 | 321 | /* logerror("via1_write_portb: $%02X\n", data); */ |
| 322 | cassette_output( | |
| 322 | cassette_output( | |
| 323 | 323 | via1_portb = data; |
| 324 | 324 | } |
| 325 | 325 | |
| r3218 | r3219 | |
| 549 | 549 | |
| 550 | 550 | static TIMER_CALLBACK( vic20_tape_timer ) |
| 551 | 551 | { |
| 552 | UINT8 data = (cassette_input( | |
| 552 | UINT8 data = (cassette_input( | |
| 553 | 553 | via_1_ca1_w(machine, 0, data); |
| 554 | 554 | } |
| 555 | 555 |
| r3218 | r3219 | |
|---|---|---|
| 489 | 489 | ** could be placed on a single tape. |
| 490 | 490 | *****************************************************************************/ |
| 491 | 491 | |
| 492 | static const device_config *cassette_device_image( | |
| 492 | static const device_config *cassette_device_image(running_machine *machine) | |
| 493 | 493 | { |
| 494 | return | |
| 494 | return | |
| 495 | 495 | } |
| 496 | 496 | |
| 497 | 497 | /* The cassette output signal for writing tapes is generated by a |
| 498 | 498 | flip-flop which is toggled to produce the output waveform. Any |
| 499 | 499 | access to the cassette I/O range, whether a read or a write, |
| 500 | 500 | toggles this flip-flop. */ |
| 501 | static void cassette_toggle_output( | |
| 501 | static void cassette_toggle_output(running_machine *machine) | |
| 502 | 502 | { |
| 503 | 503 | static int cassette_output_flipflop = 0; |
| 504 | 504 | |
| 505 | 505 | cassette_output_flipflop = !cassette_output_flipflop; |
| 506 | cassette_output(cassette_device_image(), | |
| 506 | cassette_output(cassette_device_image(machine), | |
| 507 | 507 | cassette_output_flipflop ? 1.0 : -1.0); |
| 508 | 508 | } |
| 509 | 509 | |
| 510 | 510 | READ8_HANDLER( apple1_cassette_r ) |
| 511 | 511 | { |
| 512 | cassette_toggle_output(); | |
| 512 | cassette_toggle_output(machine); | |
| 513 | 513 | |
| 514 | 514 | if (offset <= 0x7f) |
| 515 | 515 | { |
| r3218 | r3219 | |
| 535 | 535 | /* (Don't try putting a non-zero "noise threshhold" here, |
| 536 | 536 | because it can cause tape header bits on real cassette |
| 537 | 537 | images to be misread as data bits.) */ |
| 538 | if (cassette_input(cassette_device_image()) > 0.0) | |
| 538 | if (cassette_input(cassette_device_image(machine)) > 0.0) | |
| 539 | 539 | return program_read_byte(0xc100 + (offset & ~1)); |
| 540 | 540 | else |
| 541 | 541 | return program_read_byte(0xc100 + offset); |
| r3218 | r3219 | |
| 551 | 551 | However, we still have to handle writes, since they may be done |
| 552 | 552 | by user code. */ |
| 553 | 553 | |
| 554 | cassette_toggle_output(); | |
| 554 | cassette_toggle_output(machine); | |
| 555 | 555 | } |
| r3218 | r3219 | |
|---|---|---|
| 70 | 70 | dat = (dat << 2) ^0xff; |
| 71 | 71 | if (input_port_read(machine, "LINE12")!=0xff) dat ^= 0x02; |
| 72 | 72 | |
| 73 | level = cassette_input( | |
| 73 | level = cassette_input( | |
| 74 | 74 | if (level >= 0) { |
| 75 | 75 | dat ^= 0x01; |
| 76 | 76 | } |
| r3218 | r3219 | |
| 99 | 99 | { |
| 100 | 100 | specialist_8255_portc = data; |
| 101 | 101 | |
| 102 | cassette_output( | |
| 102 | cassette_output( | |
| 103 | 103 | |
| 104 | 104 | dac_data_w(0,data & 0x20); //beeper |
| 105 | 105 |
| r3218 | r3219 | |
|---|---|---|
| 97 | 97 | |
| 98 | 98 | WRITE8_HANDLER( mikro80_tape_w ) |
| 99 | 99 | { |
| 100 | cassette_output( | |
| 100 | cassette_output( | |
| 101 | 101 | } |
| 102 | 102 | |
| 103 | 103 | |
| 104 | 104 | READ8_HANDLER( mikro80_tape_r ) |
| 105 | 105 | { |
| 106 | double level = cassette_input( | |
| 106 | double level = cassette_input( | |
| 107 | 107 | if (level < 0) { |
| 108 | 108 | return 0x00; |
| 109 | 109 | } |
| r3218 | r3219 | |
|---|---|---|
| 87 | 87 | WRITE8_HANDLER( ut88_sound_w ) |
| 88 | 88 | { |
| 89 | 89 | dac_data_w(0,data); //beeper |
| 90 | cassette_output( | |
| 90 | cassette_output( | |
| 91 | 91 | } |
| 92 | 92 | |
| 93 | 93 | |
| 94 | 94 | READ8_HANDLER( ut88_tape_r ) |
| 95 | 95 | { |
| 96 | double level = cassette_input( | |
| 96 | double level = cassette_input( | |
| 97 | 97 | if (level < 0) { |
| 98 | 98 | return 0x00; |
| 99 | 99 | } |
| r3218 | r3219 | |
|---|---|---|
| 747 | 747 | |
| 748 | 748 | void c64_m6510_port_write(UINT8 direction, UINT8 data) |
| 749 | 749 | { |
| 750 | running_machine *machine = Machine; | |
| 751 | ||
| 750 | 752 | /* if line is marked as input then keep current value */ |
| 751 | 753 | data = (c64_port_data & ~direction) | (data & direction); |
| 752 | 754 | |
| r3218 | r3219 | |
| 766 | 768 | { |
| 767 | 769 | if (direction & 0x08) |
| 768 | 770 | { |
| 769 | cassette_output( | |
| 771 | cassette_output( | |
| 770 | 772 | } |
| 771 | 773 | |
| 772 | 774 | if (direction & 0x20) |
| 773 | 775 | { |
| 774 | 776 | if(!(data & 0x20)) |
| 775 | 777 | { |
| 776 | cassette_change_state( | |
| 778 | cassette_change_state( | |
| 777 | 779 | timer_adjust_periodic(datasette_timer, attotime_zero, 0, ATTOTIME_IN_HZ(44100)); |
| 778 | 780 | } |
| 779 | 781 | else |
| 780 | 782 | { |
| 781 | cassette_change_state( | |
| 783 | cassette_change_state( | |
| 782 | 784 | timer_reset(datasette_timer, attotime_never); |
| 783 | 785 | } |
| 784 | 786 | } |
| r3218 | r3219 | |
| 804 | 806 | |
| 805 | 807 | if (c64_tape_on) |
| 806 | 808 | { |
| 807 | if ((cassette_get_state( | |
| 809 | if ((cassette_get_state( | |
| 808 | 810 | data &= ~0x10; |
| 809 | 811 | else |
| 810 | 812 | data |= 0x10; |
| r3218 | r3219 | |
| 965 | 967 | |
| 966 | 968 | TIMER_CALLBACK( c64_tape_timer ) |
| 967 | 969 | { |
| 968 | double tmp = cassette_input( | |
| 970 | double tmp = cassette_input( | |
| 969 | 971 | |
| 970 | 972 | if((last > +0.0) && (tmp < +0.0)) |
| 971 | 973 | cia_issue_index(machine, 0); |
| r3218 | r3219 | |
|---|---|---|
| 689 | 689 | |
| 690 | 690 | if ( ! ( pc_ppi.portb & 0x08 ) ) |
| 691 | 691 | { |
| 692 | double tap_val = cassette_input( | |
| 692 | double tap_val = cassette_input( | |
| 693 | 693 | |
| 694 | 694 | if ( tap_val < 0 ) |
| 695 | 695 | { |
| r3218 | r3219 | |
| 730 | 730 | pit8253_gate_w( pc_devices.pit8253, 2, data & 1); |
| 731 | 731 | pc_speaker_set_spkrdata( data & 0x02 ); |
| 732 | 732 | |
| 733 | cassette_change_state( | |
| 733 | cassette_change_state( | |
| 734 | 734 | |
| 735 | 735 | pc_ppi.clock_signal = ( pc_ppi.keyb_clock ) ? 1 : 0; |
| 736 | 736 | |
| r3218 | r3219 | |
| 908 | 908 | pit8253_gate_w( device_list_find_by_tag( machine->config->devicelist, PIT8253, "pit8253" ), 2, data & 1); |
| 909 | 909 | pc_speaker_set_spkrdata( data & 0x02 ); |
| 910 | 910 | |
| 911 | cassette_change_state( | |
| 911 | cassette_change_state( | |
| 912 | 912 | } |
| 913 | 913 | |
| 914 | 914 | |
| r3218 | r3219 | |
| 946 | 946 | data = ( data & ~0x01 ) | ( pcjr_keyb.latch ? 0x01: 0x00 ); |
| 947 | 947 | if ( ! ( pc_ppi.portb & 0x08 ) ) |
| 948 | 948 | { |
| 949 | double tap_val = cassette_input( | |
| 949 | double tap_val = cassette_input( | |
| 950 | 950 | |
| 951 | 951 | if ( tap_val < 0 ) |
| 952 | 952 | { |
| r3218 | r3219 | |
|---|---|---|
| 2313 | 2313 | } |
| 2314 | 2314 | |
| 2315 | 2315 | /* we don't take CS2 into account, as CS2 is a write-only unit */ |
| 2316 | /*if (cassette_input( | |
| 2316 | /*if (cassette_input( | |
| 2317 | 2317 | answer |= 8;*/ |
| 2318 | 2318 | |
| 2319 | 2319 | return answer; |
| r3218 | r3219 | |
| 2337 | 2337 | */ |
| 2338 | 2338 | static int ti99_R9901_3(int offset) |
| 2339 | 2339 | { |
| 2340 | running_machine *machine = Machine; | |
| 2340 | 2341 | int answer; |
| 2341 | 2342 | |
| 2342 | 2343 | if (has_handset && (handset_buflen == 3)) |
| r3218 | r3219 | |
| 2345 | 2346 | answer = 4; /* on systems without handset, the pin is pulled up to avoid spurious interrupts */ |
| 2346 | 2347 | |
| 2347 | 2348 | /* we don't take CS2 into account, as CS2 is a write-only unit */ |
| 2348 | if (cassette_input( | |
| 2349 | if (cassette_input( | |
| 2349 | 2350 | answer |= 8; |
| 2350 | 2351 | |
| 2351 | 2352 | return answer; |
| r3218 | r3219 | |
| 2443 | 2444 | } |
| 2444 | 2445 | |
| 2445 | 2446 | /* we don't take CS2 into account, as CS2 is a write-only unit */ |
| 2446 | /*if (cassette_input( | |
| 2447 | /*if (cassette_input( | |
| 2447 | 2448 | answer |= 8;*/ |
| 2448 | 2449 | |
| 2449 | 2450 | return answer; |
| r3218 | r3219 | |
| 2478 | 2479 | */ |
| 2479 | 2480 | static void ti99_CS_motor(int offset, int data) |
| 2480 | 2481 | { |
| 2481 | const device_config *img = image_from_devtype_and_index(IO_CASSETTE, offset-6); | |
| 2482 | running_machine *machine = Machine; | |
| 2483 | ||
| 2484 | const device_config *img = device_list_find_by_tag( machine->config->devicelist, CASSETTE, ( offset-6 ) ? "cassette2" : "cassette1" ); | |
| 2482 | 2485 | cassette_change_state(img, data ? CASSETTE_MOTOR_ENABLED : CASSETTE_MOTOR_DISABLED, CASSETTE_MASK_MOTOR); |
| 2483 | 2486 | } |
| 2484 | 2487 | |
| r3218 | r3219 | |
| 2501 | 2504 | */ |
| 2502 | 2505 | static void ti99_CS_output(int offset, int data) |
| 2503 | 2506 | { |
| 2504 | cassette_output(image_from_devtype_and_index(IO_CASSETTE, 0), data ? +1 : -1); | |
| 2507 | running_machine *machine = Machine; | |
| 2508 | ||
| 2505 | 2509 | if (ti99_model != model_99_8) /* 99/8 only has one tape port!!! */ |
| 2506 | cassette_output(image_from_devtype_and_index(IO_CASSETTE, 1), data ? +1 : -1); | |
| 2510 | { | |
| 2511 | cassette_output(device_list_find_by_tag( machine->config->devicelist, CASSETTE, "cassette1" ), data ? +1 : -1); | |
| 2512 | cassette_output(device_list_find_by_tag( machine->config->devicelist, CASSETTE, "cassette2" ), data ? +1 : -1); | |
| 2513 | } | |
| 2514 | else | |
| 2515 | { | |
| 2516 | cassette_output(device_list_find_by_tag( machine->config->devicelist, CASSETTE, "cassette" ), data ? +1 : -1); | |
| 2517 | } | |
| 2507 | 2518 | } |
| 2508 | 2519 | |
| 2509 | 2520 |
| r3218 | r3219 | |
|---|---|---|
| 1407 | 1407 | { |
| 1408 | 1408 | |
| 1409 | 1409 | double dev_val; |
| 1410 | dev_val=cassette_input( | |
| 1410 | dev_val=cassette_input( | |
| 1411 | 1411 | |
| 1412 | 1412 | // look for rising edges on the cassette wave |
| 1413 | 1413 | if (((dev_val>=0.0) && (last_dev_val<0.0)) || ((dev_val<0.0) && (last_dev_val>=0.0))) |
| r3218 | r3219 | |
| 1463 | 1463 | |
| 1464 | 1464 | } |
| 1465 | 1465 | |
| 1466 | static void BBC_Cassette_motor(unsigned char status) | |
| 1466 | static void BBC_Cassette_motor(running_machine *machine, unsigned char status) | |
| 1467 | 1467 | { |
| 1468 | 1468 | if (status) |
| 1469 | 1469 | { |
| 1470 | cassette_change_state( | |
| 1470 | cassette_change_state( | |
| 1471 | 1471 | timer_adjust_periodic(bbc_tape_timer, attotime_zero, 0, ATTOTIME_IN_HZ(44100)); |
| 1472 | 1472 | } else { |
| 1473 | cassette_change_state( | |
| 1473 | cassette_change_state( | |
| 1474 | 1474 | timer_reset(bbc_tape_timer, attotime_never); |
| 1475 | 1475 | MC6850_Reset(wav_len); |
| 1476 | 1476 | len0=0; |
| r3218 | r3219 | |
| 1485 | 1485 | |
| 1486 | 1486 | WRITE8_HANDLER ( BBC_SerialULA_w ) |
| 1487 | 1487 | { |
| 1488 | BBC_Cassette_motor((data & 0x80) >> 7); | |
| 1488 | BBC_Cassette_motor(machine, (data & 0x80) >> 7); | |
| 1489 | 1489 | } |
| 1490 | 1490 | |
| 1491 | 1491 |
| r3218 | r3219 | |
|---|---|---|
| 406 | 406 | bit = 0; |
| 407 | 407 | |
| 408 | 408 | /* get data from cassette */ |
| 409 | if (cassette_input( | |
| 409 | if (cassette_input( | |
| 410 | 410 | bit = 1; |
| 411 | 411 | |
| 412 | 412 | /* update astb with bit */ |
| r3218 | r3219 | |
| 418 | 418 | kc_cassette_timer = timer_alloc(kc_cassette_timer_callback, NULL); |
| 419 | 419 | } |
| 420 | 420 | |
| 421 | static void kc_cassette_set_motor(int motor_state) | |
| 421 | static void kc_cassette_set_motor(running_machine *machine, int motor_state) | |
| 422 | 422 | { |
| 423 | 423 | /* state changed? */ |
| 424 | 424 | if (((kc_cassette_motor_state^motor_state)&0x01)!=0) |
| 425 | 425 | { |
| 426 | 426 | /* set new motor state in cassette device */ |
| 427 | cassette_change_state( | |
| 427 | cassette_change_state( | |
| 428 | 428 | motor_state ? CASSETTE_MOTOR_ENABLED : CASSETTE_MOTOR_DISABLED, |
| 429 | 429 | CASSETTE_MASK_MOTOR); |
| 430 | 430 | |
| r3218 | r3219 | |
| 1389 | 1389 | kc85_4_update_0x08000(machine); |
| 1390 | 1390 | kc85_4_update_0x00000(machine); |
| 1391 | 1391 | |
| 1392 | kc_cassette_set_motor((data>>6) & 0x01); | |
| 1392 | kc_cassette_set_motor(machine, (data>>6) & 0x01); | |
| 1393 | 1393 | } |
| 1394 | 1394 | break; |
| 1395 | 1395 | |
| r3218 | r3219 | |
| 1630 | 1630 | kc85_3_update_0x0e000(machine); |
| 1631 | 1631 | kc85_3_update_0x00000(machine); |
| 1632 | 1632 | |
| 1633 | kc_cassette_set_motor((data>>6) & 0x01); | |
| 1633 | kc_cassette_set_motor(machine, (data>>6) & 0x01); | |
| 1634 | 1634 | } |
| 1635 | 1635 | break; |
| 1636 | 1636 |
| r3218 | r3219 | |
|---|---|---|
| 6 | 6 | |
| 7 | 7 | *********************************************************************/ |
| 8 | 8 | |
| 9 | #include "driver.h" | |
| 9 | 10 | #include "mame.h" |
| 10 | 11 | #include "cassette.h" |
| 11 | 12 | #include "formats/cassimg.h" |
| r3218 | r3219 | |
| 24 | 25 | extern struct io_procs mess_ioprocs; |
| 25 | 26 | |
| 26 | 27 | |
| 27 | struct mess_cassetteimg | |
| 28 | typedef struct _dev_cassette_t dev_cassette_t; | |
| 29 | struct _dev_cassette_t | |
| 28 | 30 | { |
| 29 | cassette_image *cassette; | |
| 30 | cassette_state state; | |
| 31 | double position; | |
| 32 | double position_time; | |
| 33 | INT32 value; | |
| 31 | const cassette_config *config; | |
| 32 | cassette_image *cassette; | |
| 33 | cassette_state state; | |
| 34 | double position; | |
| 35 | double position_time; | |
| 36 | INT32 value; | |
| 34 | 37 | }; |
| 35 | 38 | |
| 36 | 39 | |
| 37 | static struct mess_cassetteimg *get_cassimg(const device_config *image) | |
| 40 | /* Default cassette_config for drivers only wav files */ | |
| 41 | const cassette_config default_cassette_config = | |
| 38 | 42 | { |
| 39 | return image_lookuptag(image, CASSETTE_TAG); | |
| 40 | } | |
| 43 | cassette_default_formats, | |
| 44 | NULL, | |
| 45 | CASSETTE_PLAY | |
| 46 | }; | |
| 41 | 47 | |
| 42 | 48 | |
| 43 | ||
| 44 | static cassette_state get_default_state(const device_config *dev) | |
| 49 | INLINE dev_cassette_t *get_safe_token(const device_config *device) | |
| 45 | 50 | { |
| 46 | return (cassette_state) (int) mess_device_get_info_int(mess_devclass_from_core_device(dev), MESS_DEVINFO_INT_CASSETTE_DEFAULT_STATE); | |
| 51 | assert( device != NULL ); | |
| 52 | assert( device->token != NULL ); | |
| 53 | assert( device->type == DEVICE_GET_INFO_NAME(cassette) ); | |
| 54 | return (dev_cassette_t *) device->token; | |
| 47 | 55 | } |
| 48 | 56 | |
| 49 | 57 | |
| 50 | ||
| 51 | 58 | /********************************************************************* |
| 52 | 59 | cassette IO |
| 53 | 60 | *********************************************************************/ |
| 54 | 61 | |
| 55 | ||
| 62 | INLINE int cassette_is_motor_on(const device_config *d | |
| 56 | 63 | { |
| 57 | cassette_state state; | |
| 58 | state = cassette_get_state(cassette); | |
| 59 | if ((state & CASSETTE_MASK_UISTATE) == CASSETTE_STOPPED) | |
| 64 | dev_cassette_t *cassette = get_safe_token( device ); | |
| 65 | ||
| 66 | if ((cassette->state & CASSETTE_MASK_UISTATE) == CASSETTE_STOPPED) | |
| 60 | 67 | return FALSE; |
| 61 | if ((state & CASSETTE_MASK_MOTOR) != CASSETTE_MOTOR_ENABLED) | |
| 68 | if ((cassette->state & CASSETTE_MASK_MOTOR) != CASSETTE_MOTOR_ENABLED) | |
| 62 | 69 | return FALSE; |
| 63 | 70 | return TRUE; |
| 64 | 71 | } |
| 65 | 72 | |
| 66 | 73 | |
| 67 | 74 | |
| 68 | static void cassette_update(const device_config * | |
| 75 | static void cassette_update(const device_config *d | |
| 69 | 76 | { |
| 70 | st | |
| 77 | dev_casset | |
| 71 | 78 | double cur_time; |
| 72 | double new_position; | |
| 73 | 79 | |
| 74 | 80 | cur_time = attotime_to_double(timer_get_time()); |
| 75 | tag = get_cassimg(cassette); | |
| 76 | 81 | |
| 77 | if (cassette_is_motor_on( | |
| 82 | if (cassette_is_motor_on(d | |
| 78 | 83 | { |
| 79 | new_position = | |
| 84 | double new_position = cassette->position + (cur_time - cassette->position_time); | |
| 80 | 85 | |
| 81 | switch( | |
| 86 | switch(cassette->state & CASSETTE_MASK_UISTATE) { | |
| 82 | 87 | case CASSETTE_RECORD: |
| 83 | cassette_put_sample( | |
| 88 | cassette_put_sample(cassette->cassette, 0, cassette->position, new_position - cassette->position, cassette->value); | |
| 84 | 89 | break; |
| 85 | 90 | |
| 86 | 91 | case CASSETTE_PLAY: |
| 87 | cassette_get_sample(tag->cassette, 0, new_position, 0.0, &tag->value); | |
| 92 | if ( cassette->cassette ) | |
| 93 | cassette_get_sample(cassette->cassette, 0, new_position, 0.0, &cassette->value); | |
| 88 | 94 | break; |
| 89 | 95 | } |
| 90 | | |
| 96 | cassette->position = new_position; | |
| 91 | 97 | } |
| 92 | | |
| 98 | cassette->position_time = cur_time; | |
| 93 | 99 | } |
| 94 | 100 | |
| 95 | 101 | |
| 96 | 102 | |
| 97 | cassette_state cassette_get_state(const device_config * | |
| 103 | cassette_state cassette_get_state(const device_config *d | |
| 98 | 104 | { |
| 99 | return get_cassimg(cassette)->state; | |
| 105 | dev_cassette_t *cassette = get_safe_token( device ); | |
| 106 | return cassette->state; | |
| 100 | 107 | } |
| 101 | 108 | |
| 102 | 109 | |
| 103 | 110 | |
| 104 | void cassette_change_state(const device_config * | |
| 111 | void cassette_change_state(const device_config *d | |
| 105 | 112 | { |
| 106 | st | |
| 113 | dev_casset | |
| 107 | 114 | cassette_state new_state; |
| 108 | 115 | |
| 109 | tag = get_cassimg(cassette); | |
| 110 | new_state = tag->state; | |
| 116 | new_state = cassette->state; | |
| 111 | 117 | new_state &= ~mask; |
| 112 | 118 | new_state |= (state & mask); |
| 113 | 119 | |
| 114 | if (new_state != | |
| 120 | if (new_state != cassette->state) | |
| 115 | 121 | { |
| 116 | cassette_update(cassette); | |
| 117 | tag->state = new_state; | |
| 122 | cassette_update(device); | |
| 123 | cassette->state = new_state; | |
| 118 | 124 | } |
| 119 | 125 | } |
| 120 | 126 | |
| 121 | 127 | |
| 122 | 128 | |
| 123 | void cassette_set_state(const device_config * | |
| 129 | void cassette_set_state(const device_config *d | |
| 124 | 130 | { |
| 125 | cassette_change_state( | |
| 131 | cassette_change_state(d | |
| 126 | 132 | } |
| 127 | 133 | |
| 128 | 134 | |
| 129 | 135 | |
| 130 | double cassette_input(const device_config * | |
| 136 | double cassette_input(const device_config *d | |
| 131 | 137 | { |
| 138 | dev_cassette_t *cassette = get_safe_token( device ); | |
| 132 | 139 | INT32 sample; |
| 133 | 140 | double double_value; |
| 134 | struct mess_cassetteimg *tag; | |
| 135 | 141 | |
| 136 | cassette_update(cassette); | |
| 137 | tag = get_cassimg(cassette); | |
| 138 | sample = tag->value; | |
| 142 | cassette_update(device); | |
| 143 | sample = cassette->value; | |
| 139 | 144 | double_value = sample / ((double) 0x7FFFFFFF); |
| 140 | 145 | |
| 141 | LOG(("cassette_input(): time_index=%g value=%g\n", | |
| 146 | LOG(("cassette_input(): time_index=%g value=%g\n", cassette->position, double_value)); | |
| 142 | 147 | |
| 143 | 148 | return double_value; |
| 144 | 149 | } |
| 145 | 150 | |
| 146 | 151 | |
| 147 | 152 | |
| 148 | void cassette_output(const device_config * | |
| 153 | void cassette_output(const device_config *d | |
| 149 | 154 | { |
| 150 | struct mess_cassetteimg *tag; | |
| 151 | tag = get_cassimg(cassette); | |
| 152 | if (((tag->state & CASSETTE_MASK_UISTATE) == CASSETTE_RECORD) && (tag->value != value)) | |
| 155 | dev_cassette_t *cassette = get_safe_token( device ); | |
| 156 | ||
| 157 | if (((cassette->state & CASSETTE_MASK_UISTATE) == CASSETTE_RECORD) && (cassette->value != value)) | |
| 153 | 158 | { |
| 154 | cassette_update( | |
| 159 | cassette_update(d | |
| 155 | 160 | |
| 156 | 161 | value = MIN(value, 1.0); |
| 157 | 162 | value = MAX(value, -1.0); |
| 158 | 163 | |
| 159 | | |
| 164 | cassette->value = (INT32) (value * 0x7FFFFFFF); | |
| 160 | 165 | } |
| 161 | 166 | } |
| 162 | 167 | |
| 163 | 168 | |
| 164 | 169 | |
| 165 | cassette_image *cassette_get_image(const device_config * | |
| 170 | cassette_image *cassette_get_image(const device_config *d | |
| 166 | 171 | { |
| 167 | struct mess_cassetteimg *tag; | |
| 168 | tag = get_cassimg(cassette); | |
| 169 | return tag->cassette; | |
| 172 | dev_cassette_t *cassette = get_safe_token( device ); | |
| 173 | ||
| 174 | return cassette->cassette; | |
| 170 | 175 | } |
| 171 | 176 | |
| 172 | 177 | |
| 173 | 178 | |
| 174 | double cassette_get_position(const device_config * | |
| 179 | double cassette_get_position(const device_config *d | |
| 175 | 180 | { |
| 181 | dev_cassette_t *cassette = get_safe_token( device ); | |
| 176 | 182 | double position; |
| 177 | struct mess_cassetteimg *tag; | |
| 178 | 183 | |
| 179 | tag = get_cassimg(cassette); | |
| 180 | position = tag->position; | |
| 184 | position = cassette->position; | |
| 181 | 185 | |
| 182 | if (cassette_is_motor_on(cassette)) | |
| 183 | position += attotime_to_double(timer_get_time()) - tag->position_time; | |
| 186 | if (cassette_is_motor_on(device)) | |
| 187 | position += attotime_to_double(timer_get_time()) - cassette->position_time; | |
| 184 | 188 | return position; |
| 185 | 189 | } |
| 186 | 190 | |
| 187 | 191 | |
| 188 | 192 | |
| 189 | double cassette_get_length(const device_config * | |
| 193 | double cassette_get_length(const device_config *d | |
| 190 | 194 | { |
| 191 | st | |
| 195 | dev_casset | |
| 192 | 196 | struct CassetteInfo info; |
| 193 | 197 | |
| 194 | tag = get_cassimg(cassette); | |
| 195 | cassette_get_info(tag->cassette, &info); | |
| 198 | cassette_get_info(cassette->cassette, &info); | |
| 196 | 199 | return ((double) info.sample_count) / info.sample_frequency; |
| 197 | 200 | } |
| 198 | 201 | |
| 199 | 202 | |
| 200 | 203 | |
| 201 | void cassette_seek(const device_config * | |
| 204 | void cassette_seek(const device_config *d | |
| 202 | 205 | { |
| 203 | st | |
| 206 | dev_casset | |
| 204 | 207 | |
| 205 | cassette_update( | |
| 208 | cassette_update(d | |
| 206 | 209 | |
| 207 | 210 | switch(origin) { |
| 208 | 211 | case SEEK_SET: |
| 209 | 212 | break; |
| 210 | 213 | |
| 211 | 214 | case SEEK_END: |
| 212 | time += cassette_get_length( | |
| 215 | time += cassette_get_length(d | |
| 213 | 216 | break; |
| 214 | 217 | |
| 215 | 218 | case SEEK_CUR: |
| 216 | time += cassette_get_position( | |
| 219 | time += cassette_get_position(d | |
| 217 | 220 | break; |
| 218 | 221 | } |
| 219 | 222 | |
| 220 | 223 | /* clip position into legal bounds */ |
| 221 | tag = get_cassimg(cassette); | |
| 222 | tag->position = time; | |
| 224 | cassette->position = time; | |
| 223 | 225 | } |
| 224 | 226 | |
| 225 | 227 | |
| r3218 | r3219 | |
| 230 | 232 | |
| 231 | 233 | static DEVICE_START( cassette ) |
| 232 | 234 | { |
| 233 | | |
| 235 | | |
| 234 | 236 | |
| 235 | 237 | /* set to default state */ |
| 236 | get_cassimg(device)->state = get_default_state(device); | |
| 238 | cassette->config = device->static_config; | |
| 239 | cassette->cassette = NULL; | |
| 240 | cassette->state = cassette->config->default_state; | |
| 237 | 241 | } |
| 238 | 242 | |
| 239 | 243 | |
| 240 | 244 | |
| 241 | 245 | static DEVICE_IMAGE_LOAD( cassette ) |
| 242 | 246 | { |
| 247 | dev_cassette_t *cassette = get_safe_token( image ); | |
| 243 | 248 | casserr_t err; |
| 244 | 249 | int cassette_flags; |
| 245 | struct mess_cassetteimg *tag; | |
| 246 | const mess_device_class *devclass; | |
| 247 | const struct CassetteFormat **formats; | |
| 250 | const struct CassetteFormat * const *formats; | |
| 248 | 251 | const struct CassetteOptions *create_opts; |
| 249 | 252 | const char *extension; |
| 250 | 253 | int is_writable; |
| 251 | 254 | |
| 252 | tag = get_cassimg(image); | |
| 253 | ||
| 254 | 255 | /* figure out the cassette format */ |
| 255 | devclass = mess_devclass_from_core_device(image); | |
| 256 | formats = mess_device_get_info_ptr(devclass, MESS_DEVINFO_PTR_CASSETTE_FORMATS); | |
| 256 | formats = cassette->config->formats; | |
| 257 | 257 | |
| 258 | 258 | if (image_has_been_created(image)) |
| 259 | 259 | { |
| 260 | 260 | /* creating an image */ |
| 261 | create_opts = (const struct CassetteOptions *) mess_device_get_info_ptr(devclass, MESS_DEVINFO_PTR_CASSETTE_OPTIONS); | |
| 262 | err = cassette_create((void *) image, &mess_ioprocs, &wavfile_format, create_opts, CASSETTE_FLAG_READWRITE|CASSETTE_FLAG_SAVEONEXIT, &tag->cassette); | |
| 261 | create_opts = cassette->config->create_opts; | |
| 262 | err = cassette_create((void *) image, &mess_ioprocs, &wavfile_format, create_opts, CASSETTE_FLAG_READWRITE|CASSETTE_FLAG_SAVEONEXIT, &cassette->cassette); | |
| 263 | 263 | if (err) |
| 264 | 264 | goto error; |
| 265 | 265 | } |
| r3218 | r3219 | |
| 271 | 271 | is_writable = image_is_writable(image); |
| 272 | 272 | cassette_flags = is_writable ? (CASSETTE_FLAG_READWRITE|CASSETTE_FLAG_SAVEONEXIT) : CASSETTE_FLAG_READONLY; |
| 273 | 273 | extension = image_filetype(image); |
| 274 | err = cassette_open_choices((void *) image, &mess_ioprocs, extension, formats, cassette_flags, & | |
| 274 | err = cassette_open_choices((void *) image, &mess_ioprocs, extension, formats, cassette_flags, &cassette->cassette); | |
| 275 | 275 | |
| 276 | 276 | /* this is kind of a hack */ |
| 277 | 277 | if (err && is_writable) |
| r3218 | r3219 | |
| 284 | 284 | } |
| 285 | 285 | |
| 286 | 286 | /* set to default state, but only change the UI state */ |
| 287 | cassette_change_state(image, | |
| 287 | cassette_change_state(image, cassette->config->default_state | |
| 288 | 288 | |
| 289 | 289 | /* reset the position */ |
| 290 | tag->position = 0.0; | |
| 291 | tag->position_time = attotime_to_double(timer_get_time()); | |
| 290 | cassette->position = 0.0; | |
| 291 | cassette->position_time = attotime_to_double(timer_get_time()); | |
| 292 | 292 | |
| 293 | 293 | return INIT_PASS; |
| 294 | 294 | |
| r3218 | r3219 | |
| 300 | 300 | |
| 301 | 301 | static DEVICE_IMAGE_UNLOAD( cassette ) |
| 302 | 302 | { |
| 303 | st | |
| 303 | dev_casset | |
| 304 | 304 | |
| 305 | tag = get_cassimg(image); | |
| 306 | ||
| 307 | 305 | /* if we are recording, write the value to the image */ |
| 308 | if (( | |
| 306 | if ((cassette->state & CASSETTE_MASK_UISTATE) == CASSETTE_RECORD) | |
| 309 | 307 | cassette_update(image); |
| 310 | 308 | |
| 311 | 309 | /* close out the cassette */ |
| 312 | cassette_close(tag->cassette); | |
| 313 | tag->cassette = NULL; | |
| 310 | cassette_close(cassette->cassette); | |
| 311 | cassette->cassette = NULL; | |
| 314 | 312 | |
| 315 | 313 | /* set to default state, but only change the UI state */ |
| 316 | 314 | cassette_change_state(image, CASSETTE_STOPPED, CASSETTE_MASK_UISTATE); |
| r3218 | r3219 | |
| 328 | 326 | int n; |
| 329 | 327 | double position, length; |
| 330 | 328 | cassette_state uistate; |
| 329 | const device_config *device; | |
| 331 | 330 | |
| 332 | 331 | /* abort if we should not be showing the image */ |
| 333 | 332 | if (!image_exists(image)) |
| r3218 | r3219 | |
| 342 | 341 | |
| 343 | 342 | /* choose a location on the screen */ |
| 344 | 343 | x = 0.0f; |
| 345 | y = | |
| 344 | y = 0 | |
| 346 | 345 | |
| 346 | device = device_list_first( image->machine->config->devicelist, CASSETTE ); | |
| 347 | ||
| 348 | while ( device && strcmp( device->tag, image->tag ) ) | |
| 349 | { | |
| 350 | y += 1; | |
| 351 | device = device_list_next( device, CASSETTE ); | |
| 352 | } | |
| 353 | ||
| 354 | y *= ui_get_line_height(); | |
| 347 | 355 | /* choose which frame of the animation we are at */ |
| 348 | 356 | n = ((int) position / ANIMATION_FPS) % ANIMATION_FRAMES; |
| 349 | 357 | |
| r3218 | r3219 | |
| 364 | 372 | } |
| 365 | 373 | |
| 366 | 374 | |
| 367 | ||
| 368 | void cassette_device_getinfo(const mess_device_class *devclass, UINT32 state, union devinfo *info) | |
| 375 | DEVICE_GET_INFO(cassette) | |
| 369 | 376 | { |
| 370 | char *s; | |
| 371 | int i; | |
| 372 | const struct CassetteFormat **formats; | |
| 373 | ||
| 374 | switch(state) | |
| 377 | switch( state ) | |
| 375 | 378 | { |
| 376 | 379 | /* --- the following bits of info are returned as 64-bit signed integers --- */ |
| 377 | case MESS_DEVINFO_INT_TYPE: info->i = IO_CASSETTE; break; | |
| 378 | case MESS_DEVINFO_INT_READABLE: info->i = 1; break; | |
| 379 | case MESS_DEVINFO_INT_WRITEABLE: info->i = 1; break; | |
| 380 | case MESS_DEVINFO_INT_CREATABLE: info->i = 1; break; | |
| 381 | case MESS_DEVINFO_INT_CASSETTE_DEFAULT_STATE: info->i = CASSETTE_PLAY; break; | |
| 380 | case DEVINFO_INT_TOKEN_BYTES: info->i = sizeof(dev_cassette_t); break; | |
| 381 | case DEVINFO_INT_INLINE_CONFIG_BYTES: info->i = 0; break; | |
| 382 | case DEVINFO_INT_CLASS: info->i = DEVICE_CLASS_PERIPHERAL; break; | |
| 383 | case DEVINFO_INT_IMAGE_TYPE: info->i = IO_CASSETTE; break; | |
| 384 | case DEVINFO_INT_IMAGE_READABLE: info->i = 1; break; | |
| 385 | case DEVINFO_INT_IMAGE_WRITEABLE: info->i = 1; break; | |
| 386 | case DEVINFO_INT_IMAGE_CREATABLE: info->i = 1; break; | |
| 382 | 387 | |
| 383 | 388 | /* --- the following bits of info are returned as pointers to data or functions --- */ |
| 384 | case MESS_DEVINFO_PTR_START: info->start = DEVICE_START_NAME(cassette); break; | |
| 385 | case MESS_DEVINFO_PTR_LOAD: info->load = DEVICE_IMAGE_LOAD_NAME(cassette); break; | |
| 386 | case MESS_DEVINFO_PTR_UNLOAD: info->unload = DEVICE_IMAGE_UNLOAD_NAME(cassette); break; | |
| 387 | case MESS_DEVINFO_PTR_DISPLAY: info->display = device_display_cassette; break; | |
| 388 | case MESS_DEVINFO_PTR_CASSETTE_FORMATS: info->p = (void *) cassette_default_formats; break; | |
| 389 | case DEVINFO_FCT_START: info->start = DEVICE_START_NAME(cassette); break; | |
| 390 | case DEVINFO_FCT_IMAGE_LOAD: info->f = (genf *) DEVICE_IMAGE_LOAD_NAME(cassette); break; | |
| 391 | case DEVINFO_FCT_IMAGE_UNLOAD: info->f = (genf *) DEVICE_IMAGE_UNLOAD_NAME(cassette); break; | |
| 392 | case DEVINFO_FCT_DISPLAY: info->f = (genf *) device_display_cassette; break; | |
| 389 | 393 | |
| 390 | 394 | /* --- the following bits of info are returned as NULL-terminated strings --- */ |
| 391 | case MESS_DEVINFO_STR_DEV_FILE: strcpy(info->s = device_temp_str(), __FILE__); break; | |
| 392 | case MESS_DEVINFO_STR_FILE_EXTENSIONS: | |
| 393 | formats = mess_device_get_info_ptr(devclass, MESS_DEVINFO_PTR_CASSETTE_FORMATS); | |
| 395 | case DEVINFO_STR_NAME: info->s = "Cassette"; break; | |
| 396 | case DEVINFO_STR_FAMILY: info->s = "Cassette"; break; | |
| 397 | case DEVINFO_STR_SOURCE_FILE: info->s = __FILE__; break; | |
| 398 | case DEVINFO_STR_IMAGE_FILE_EXTENSIONS: | |
| 399 | if ( device && device->static_config ) | |
| 400 | { | |
| 401 | const struct CassetteFormat * const *formats = ((cassette_config *)device->static_config)->formats; | |
| 402 | char *s; | |
| 403 | int i; | |
| 394 | 404 | |
| 395 | /* set up a temporary string */ | |
| 396 | s = device_temp_str(); | |
| 397 | info->s = s; | |
| 398 | s[0] = '\0'; | |
| 405 | /* set up a temporary string */ | |
| 406 | s = device_temp_str(); | |
| 407 | info->s = s; | |
| 408 | s[0] = '\0'; | |
| 399 | 409 | |
| 400 | /* append each of the extensions */ | |
| 401 | for (i = 0; formats[i]; i++) | |
| 402 | specify_extension(s, 256, formats[i]->extensions); | |
| 410 | for ( i = 0; formats[i]; i++ ) | |
| 411 | specify_extension( s, 256, formats[i]->extensions ); | |
| 412 | } | |
| 403 | 413 | break; |
| 404 | 414 | } |
| 405 | 415 | } |
| 416 |
| r3218 | r3219 | |
|---|---|---|
| 14 | 14 | #include "formats/cassimg.h" |
| 15 | 15 | |
| 16 | 16 | |
| 17 | enum | |
| 18 | { | |
| 19 | MESS_DEVINFO_INT_CASSETTE_DEFAULT_STATE = MESS_DEVINFO_INT_DEV_SPECIFIC, | |
| 20 | ||
| 21 | MESS_DEVINFO_PTR_CASSETTE_FORMATS = MESS_DEVINFO_PTR_DEV_SPECIFIC, | |
| 22 | MESS_DEVINFO_PTR_CASSETTE_OPTIONS | |
| 23 | }; | |
| 24 | ||
| 25 | 17 | typedef enum |
| 26 | 18 | { |
| 27 | 19 | /* this part of the state is controlled by the UI */ |
| r3218 | r3219 | |
| 42 | 34 | CASSETTE_MASK_DRVSTATE = 12 |
| 43 | 35 | } cassette_state; |
| 44 | 36 | |
| 45 | /* cassette prototypes */ | |
| 37 | ||
| 38 | /*************************************************************************** | |
| 39 | TYPE DEFINITIONS | |
| 40 | ***************************************************************************/ | |
| 41 | ||
| 42 | typedef struct cassette_config_t cassette_config; | |
| 43 | struct cassette_config_t | |
| 44 | { | |
| 45 | const struct CassetteFormat* const *formats; | |
| 46 | const struct CassetteOptions *create_opts; | |
| 47 | const cassette_state default_state; | |
| 48 | }; | |
| 49 | ||
| 50 | ||
| 51 | /*************************************************************************** | |
| 52 | FUNCTION PROTOTYPES | |
| 53 | ***************************************************************************/ | |
| 54 | ||
| 46 | 55 | cassette_state cassette_get_state(const device_config *cassette); |
| 47 | 56 | void cassette_set_state(const device_config *cassette, cassette_state state); |
| 48 | 57 | void cassette_change_state(const device_config *cassette, cassette_state state, cassette_state mask); |
| r3218 | r3219 | |
| 55 | 64 | double cassette_get_length(const device_config *cassette); |
| 56 | 65 | void cassette_seek(const device_config *cassette, double time, int origin); |
| 57 | 66 | |
| 58 | /* device specification */ | |
| 59 | void cassette_device_getinfo(const mess_device_class *devclass, UINT32 state, union devinfo *info); | |
| 67 | #define CASSETTE DEVICE_GET_INFO_NAME(cassette) | |
| 68 | DEVICE_GET_INFO(cassette); | |
| 60 | 69 | |
| 70 | /*************************************************************************** | |
| 71 | DEVICE CONFIGURATION MACROS | |
| 72 | ***************************************************************************/ | |
| 61 | 73 | |
| 74 | #define MDRV_CASSETTE_ADD(_tag, _config) \ | |
| 75 | MDRV_DEVICE_ADD(_tag, CASSETTE) \ | |
| 76 | MDRV_DEVICE_CONFIG(_config) | |
| 77 | ||
| 78 | #define MDRV_CASSETTE_REMOVE(_tag) \ | |
| 79 | MDRV_DEVICE_REMOVE(_tag, CASSETTE) | |
| 80 | ||
| 81 | #define MDRV_CASSETTE_MODIFY(_tag, _config) \ | |
| 82 | MDRV_DEVICE_MODIFY(_tag, CASSETTE) \ | |
| 83 | MDRV_DEVICE_CONFIG(_config) | |
| 84 | ||
| 85 | extern const cassette_config default_cassette_config; | |
| 86 | ||
| 62 | 87 | #endif /* CASSETTE_H */ |
| r3218 | r3219 | |
|---|---|---|
| 24 | 24 | |
| 25 | 25 | CASSETTE_FORMATLIST_EXTERN( to7_cassette_formats ); |
| 26 | 26 | |
| 27 | extern void to7_cassette_getinfo( const mess_device_class *devclass, | |
| 28 | UINT32 state, union devinfo *info ); | |
| 27 | extern const cassette_config to7_cassette_config; | |
| 29 | 28 | |
| 30 | 29 | |
| 31 | 30 | /******************** MO5 ************************/ |
| r3218 | r3219 | |
| 40 | 39 | |
| 41 | 40 | CASSETTE_FORMATLIST_EXTERN( mo5_cassette_formats ); |
| 42 | 41 | |
| 43 | extern void mo5_cassette_getinfo( const mess_device_class *devclass, | |
| 44 | UINT32 state, union devinfo *info ); | |
| 42 | extern const cassette_config mo5_cassette_config; | |
| 45 | 43 | |
| 46 | 44 | #endif |
| r3218 | r3219 | |
|---|---|---|
| 986 | 986 | |
| 987 | 987 | /********************* devices ************************/ |
| 988 | 988 | |
| 989 | ||
| 989 | cons | |
| 990 | 990 | { |
| 991 | switch ( state ) | |
| 992 | { | |
| 993 | case MESS_DEVINFO_INT_COUNT: | |
| 994 | info->i = 1; | |
| 995 | break; | |
| 996 | case MESS_DEVINFO_PTR_CASSETTE_FORMATS: | |
| 997 | info->p = (void *) to7_cassette_formats; | |
| 998 | break; | |
| 999 | case MESS_DEVINFO_INT_CASSETTE_DEFAULT_STATE: | |
| 1000 | info->i = | |
| 1001 | CASSETTE_PLAY | CASSETTE_MOTOR_DISABLED | CASSETTE_SPEAKER_ENABLED; | |
| 1002 | break; | |
| 1003 | case MESS_DEVINFO_STR_DEV_FILE: | |
| 1004 | strcpy( info->s = device_temp_str(), __FILE__ ); | |
| 1005 | break; | |
| 1006 | default: | |
| 1007 | cassette_device_getinfo( devclass, state, info ); | |
| 1008 | break; | |
| 1009 | } | |
| 1010 | } | |
| 991 | to7_cassette_formats, | |
| 992 | NULL, | |
| 993 | CASSETTE_PLAY | CASSETTE_MOTOR_DISABLED | CASSETTE_SPEAKER_ENABLED | |
| 994 | }; | |
| 1011 | 995 | |
| 1012 | ||
| 1013 | void mo5_cassette_getinfo( const mess_device_class *devclass, UINT32 state, union devinfo *info ) | |
| 996 | const cassette_config mo5_cassette_config = | |
| 1014 | 997 | { |
| 1015 | switch ( state ) | |
| 1016 | { | |
| 1017 | case MESS_DEVINFO_INT_COUNT: | |
| 1018 | info->i = 1; | |
| 1019 | break; | |
| 1020 | case MESS_DEVINFO_PTR_CASSETTE_FORMATS: | |
| 1021 | info->p = (void *) mo5_cassette_formats; | |
| 1022 | break; | |
| 1023 | case MESS_DEVINFO_INT_CASSETTE_DEFAULT_STATE: | |
| 1024 | info->i = | |
| 1025 | CASSETTE_PLAY | CASSETTE_MOTOR_DISABLED | CASSETTE_SPEAKER_ENABLED; | |
| 1026 | break; | |
| 1027 | case MESS_DEVINFO_STR_DEV_FILE: | |
| 1028 | strcpy( info->s = device_temp_str(), __FILE__ ); | |
| 1029 | break; | |
| 1030 | default: | |
| 1031 | cassette_device_getinfo( devclass, state, info ); | |
| 1032 | } | |
| 1033 | } | |
| 998 | mo5_cassette_formats, | |
| 999 | NULL, | |
| 1000 | CASSETTE_PLAY | CASSETTE_MOTOR_DISABLED | CASSETTE_SPEAKER_ENABLED | |
| 1001 | }; | |
| 1002 |
| r3218 | r3219 | |
|---|---|---|
| 38 | 38 | |
| 39 | 39 | /* Cassette Image */ |
| 40 | 40 | |
| 41 | static const device_config *cassette_device_image( | |
| 41 | static const device_config *cassette_device_image(running_machine *machine) | |
| 42 | 42 | { |
| 43 | return | |
| 43 | return | |
| 44 | 44 | } |
| 45 | 45 | |
| 46 | 46 | /* Discrete Sound */ |
| r3218 | r3219 | |
| 211 | 211 | if (state->cdp1861_efx) flags -= EF1; |
| 212 | 212 | |
| 213 | 213 | /* tape input */ |
| 214 | if (cassette_input(cassette_device_image()) < 0) flags -= EF2; | |
| 214 | if (cassette_input(cassette_device_image(machine)) < 0) flags -= EF2; | |
| 215 | 215 | |
| 216 | 216 | /* keyboard */ |
| 217 | 217 | if (input_port_read(machine, "KEYPAD") & (1 << state->keylatch)) flags -= EF3; |
| r3218 | r3219 | |
| 228 | 228 | set_led_status(1, level); |
| 229 | 229 | |
| 230 | 230 | /* tape output */ |
| 231 | cassette_output(cassette_device_image(), level ? 1.0 : -1.0); | |
| 231 | cassette_output(cassette_device_image(machine), level ? 1.0 : -1.0); | |
| 232 | 232 | } |
| 233 | 233 | |
| 234 | 234 | static CDP1802_DMA_WRITE( vip_dma_w ) |
| r3218 | r3219 | |
| 300 | 300 | |
| 301 | 301 | /* Machine Drivers */ |
| 302 | 302 | |
| 303 | static const cassette_config vip_cassette_config = | |
| 304 | { | |
| 305 | cassette_default_formats, | |
| 306 | NULL, | |
| 307 | CASSETTE_STOPPED | CASSETTE_MOTOR_ENABLED | CASSETTE_SPEAKER_MUTED | |
| 308 | }; | |
| 309 | ||
| 303 | 310 | static MACHINE_DRIVER_START( vip ) |
| 304 | 311 | MDRV_DRIVER_DATA(vip_state) |
| 305 | 312 | |
| r3218 | r3219 | |
| 332 | 339 | |
| 333 | 340 | /* devices */ |
| 334 | 341 | MDRV_QUICKLOAD_ADD(vip, "bin,c8", 0) |
| 342 | ||
| 343 | MDRV_CASSETTE_ADD( "cassette", vip_cassette_config ) | |
| 335 | 344 | MACHINE_DRIVER_END |
| 336 | 345 | |
| 337 | 346 | /* ROMs */ |
| r3218 | r3219 | |
| 386 | 395 | return INIT_PASS; |
| 387 | 396 | } |
| 388 | 397 | |
| 389 | static void vip_cassette_getinfo(const mess_device_class *devclass, UINT32 state, union devinfo *info) | |
| 390 | { | |
| 391 | /* cassette */ | |
| 392 | switch(state) | |
| 393 | { | |
| 394 | /* --- the following bits of info are returned as 64-bit signed integers --- */ | |
| 395 | case MESS_DEVINFO_INT_COUNT: info->i = 1; break; | |
| 396 | case MESS_DEVINFO_INT_CASSETTE_DEFAULT_STATE: info->i = CASSETTE_STOPPED | CASSETTE_MOTOR_ENABLED | CASSETTE_SPEAKER_MUTED; break; | |
| 397 | ||
| 398 | default: cassette_device_getinfo(devclass, state, info); break; | |
| 399 | } | |
| 400 | } | |
| 401 | ||
| 402 | 398 | static SYSTEM_CONFIG_START( vip ) |
| 403 | 399 | CONFIG_RAM ( 1 * 1024) |
| 404 | 400 | CONFIG_RAM ( 2 * 1024) |
| 405 | 401 | CONFIG_RAM_DEFAULT ( 4 * 1024) |
| 406 | CONFIG_DEVICE(vip_cassette_getinfo) | |
| 407 | 402 | SYSTEM_CONFIG_END |
| 408 | 403 | |
| 409 | 404 | /* System Drivers */ |
| r3218 | r3219 | |
|---|---|---|
| 370 | 370 | |
| 371 | 371 | /* Machine Drivers */ |
| 372 | 372 | |
| 373 | static const struct CassetteOptions zx81_cassette_options = { | |
| 374 | 1, /* channels */ | |
| 375 | 16, /* bits per sample */ | |
| 376 | 44100 /* sample frequency */ | |
| 377 | }; | |
| 378 | ||
| 379 | static const cassette_config zx80_cassette_config = | |
| 380 | { | |
| 381 | zx80_o_format, | |
| 382 | &zx81_cassette_options, | |
| 383 | CASSETTE_STOPPED | CASSETTE_SPEAKER_ENABLED | |
| 384 | }; | |
| 385 | ||
| 386 | static const cassette_config zx81_cassette_config = | |
| 387 | { | |
| 388 | zx81_p_format, | |
| 389 | &zx81_cassette_options, | |
| 390 | CASSETTE_STOPPED | CASSETTE_SPEAKER_ENABLED | |
| 391 | }; | |
| 392 | ||
| 393 | ||
| 373 | 394 | static MACHINE_DRIVER_START( zx80 ) |
| 374 | 395 | // basic machine hardware |
| 375 | 396 | MDRV_CPU_ADD("main", Z80, ZX81_CPU_CLOCK) |
| r3218 | r3219 | |
| 397 | 418 | MDRV_SPEAKER_STANDARD_MONO("mono") |
| 398 | 419 | MDRV_SOUND_ADD("dac", DAC, 0) |
| 399 | 420 | MDRV_SOUND_ROUTE(ALL_OUTPUTS, "mono", 0.50) |
| 400 | MDRV_SOUND_ADD(" | |
| 421 | MDRV_SOUND_ADD("cassette", WAVE, 0) | |
| 401 | 422 | MDRV_SOUND_ROUTE(ALL_OUTPUTS, "mono", 0.50) |
| 423 | ||
| 424 | MDRV_CASSETTE_ADD( "cassette", zx80_cassette_config ) | |
| 402 | 425 | MACHINE_DRIVER_END |
| 403 | 426 | |
| 404 | 427 | static MACHINE_DRIVER_START( zx81 ) |
| r3218 | r3219 | |
| 410 | 433 | MDRV_MACHINE_RESET(zx81) |
| 411 | 434 | |
| 412 | 435 | MDRV_GFXDECODE(zx81) |
| 436 | ||
| 437 | MDRV_CASSETTE_MODIFY( "cassette", zx81_cassette_config ) | |
| 413 | 438 | MACHINE_DRIVER_END |
| 414 | 439 | |
| 415 | 440 | static MACHINE_DRIVER_START( ts1000 ) |
| r3218 | r3219 | |
| 500 | 525 | |
| 501 | 526 | /* System Configuration */ |
| 502 | 527 | |
| 503 | static const struct CassetteOptions zx81_cassette_options = { | |
| 504 | 1, /* channels */ | |
| 505 | 16, /* bits per sample */ | |
| 506 | 44100 /* sample frequency */ | |
| 507 | }; | |
| 508 | ||
| 509 | static void zx80_cassette_getinfo(const mess_device_class *devclass, UINT32 state, union devinfo *info) | |
| 510 | { | |
| 511 | /* cassette */ | |
| 512 | switch(state) | |
| 513 | { | |
| 514 | /* --- the following bits of info are returned as 64-bit signed integers --- */ | |
| 515 | case MESS_DEVINFO_INT_COUNT: info->i = 1; break; | |
| 516 | ||
| 517 | /* --- the following bits of info are returned as pointers to data or functions --- */ | |
| 518 | case MESS_DEVINFO_PTR_CASSETTE_FORMATS: info->p = (void *) zx80_o_format; break; | |
| 519 | case MESS_DEVINFO_PTR_CASSETTE_OPTIONS: info->p = (void *) &zx81_cassette_options; break; | |
| 520 | ||
| 521 | /* --- the following bits of info are returned as 64-bit signed integers --- */ | |
| 522 | case MESS_DEVINFO_INT_CASSETTE_DEFAULT_STATE: info->i = CASSETTE_STOPPED | CASSETTE_SPEAKER_ENABLED; break; | |
| 523 | ||
| 524 | default: cassette_device_getinfo(devclass, state, info); break; | |
| 525 | } | |
| 526 | } | |
| 527 | ||
| 528 | 528 | static SYSTEM_CONFIG_START(zx80) |
| 529 | CONFIG_DEVICE(zx80_cassette_getinfo) | |
| 530 | 529 | CONFIG_RAM_DEFAULT(1 * 1024) |
| 531 | 530 | CONFIG_RAM(16 * 1024) |
| 532 | 531 | SYSTEM_CONFIG_END |
| 533 | 532 | |
| 534 | static void zx81_cassette_getinfo(const mess_device_class *devclass, UINT32 state, union devinfo *info) | |
| 535 | { | |
| 536 | /* cassette */ | |
| 537 | switch(state) | |
| 538 | { | |
| 539 | /* --- the following bits of info are returned as 64-bit signed integers --- */ | |
| 540 | case MESS_DEVINFO_INT_COUNT: info->i = 1; break; | |
| 541 | ||
| 542 | /* --- the following bits of info are returned as pointers to data or functions --- */ | |
| 543 | case MESS_DEVINFO_PTR_CASSETTE_FORMATS: info->p = (void *) zx81_p_format; break; | |
| 544 | case MESS_DEVINFO_PTR_CASSETTE_OPTIONS: info->p = (void *) &zx81_cassette_options; break; | |
| 545 | ||
| 546 | /* --- the following bits of info are returned as 64-bit signed integers --- */ | |
| 547 | case MESS_DEVINFO_INT_CASSETTE_DEFAULT_STATE: info->i = CASSETTE_STOPPED | CASSETTE_SPEAKER_ENABLED; break; | |
| 548 | ||
| 549 | default: cassette_device_getinfo(devclass, state, info); break; | |
| 550 | } | |
| 551 | } | |
| 552 | ||
| 553 | 533 | static SYSTEM_CONFIG_START(zx81) |
| 554 | CONFIG_DEVICE(zx81_cassette_getinfo) | |
| 555 | 534 | CONFIG_RAM_DEFAULT(1 * 1024) |
| 556 | 535 | CONFIG_RAM(16 * 1024) |
| 557 | 536 | SYSTEM_CONFIG_END |
| 558 | 537 | |
| 559 | 538 | static SYSTEM_CONFIG_START(pc8300) |
| 560 | CONFIG_DEVICE(zx81_cassette_getinfo) | |
| 561 | 539 | CONFIG_RAM_DEFAULT(16 * 1024) |
| 562 | 540 | SYSTEM_CONFIG_END |
| 563 | 541 |
| r3218 | r3219 | |
|---|---|---|
| 173 | 173 | 44100 /* sample frequency */ |
| 174 | 174 | }; |
| 175 | 175 | |
| 176 | static const cassette_config dai_cassette_config = | |
| 177 | { | |
| 178 | cassette_default_formats, | |
| 179 | &dai_cassette_options, | |
| 180 | CASSETTE_PLAY | CASSETTE_MOTOR_DISABLED | CASSETTE_SPEAKER_ENABLED | |
| 181 | }; | |
| 182 | ||
| 176 | 183 | /* machine definition */ |
| 177 | 184 | static MACHINE_DRIVER_START( dai ) |
| 178 | 185 | /* basic machine hardware */ |
| r3218 | r3219 | |
| 204 | 211 | |
| 205 | 212 | /* sound hardware */ |
| 206 | 213 | MDRV_SPEAKER_STANDARD_MONO("mono") |
| 207 | MDRV_SOUND_ADD(" | |
| 214 | MDRV_SOUND_ADD("cassette", WAVE, 0) | |
| 208 | 215 | MDRV_SOUND_ROUTE(ALL_OUTPUTS, "mono", 0.50) |
| 209 | 216 | MDRV_SPEAKER_STANDARD_STEREO("left", "right") |
| 210 | 217 | MDRV_SOUND_ADD("custom", CUSTOM, 0) |
| 211 | 218 | MDRV_SOUND_CONFIG(dai_sound_interface) |
| 212 | 219 | MDRV_SOUND_ROUTE(0, "left", 0.50) |
| 213 | 220 | MDRV_SOUND_ROUTE(1, "right", 0.50) |
| 221 | ||
| 222 | MDRV_CASSETTE_ADD( "cassette", dai_cassette_config ) | |
| 214 | 223 | MACHINE_DRIVER_END |
| 215 | 224 | |
| 216 | 225 | #define io_dai io_NULL |
| r3218 | r3219 | |
| 227 | 236 | ROM_END |
| 228 | 237 | |
| 229 | 238 | |
| 230 | static void dai_cassette_getinfo(const mess_device_class *devclass, UINT32 state, union devinfo *info) | |
| 231 | { | |
| 232 | /* cassette */ | |
| 233 | switch(state) | |
| 234 | { | |
| 235 | /* --- the following bits of info are returned as 64-bit signed integers --- */ | |
| 236 | case MESS_DEVINFO_INT_COUNT: info->i = 1; break; | |
| 237 | ||
| 238 | /* --- the following bits of info are returned as pointers to data or functions --- */ | |
| 239 | case MESS_DEVINFO_PTR_CASSETTE_OPTIONS: info->p = (void *) &dai_cassette_options; break; | |
| 240 | ||
| 241 | /* --- the following bits of info are returned as 64-bit signed integers --- */ | |
| 242 | case MESS_DEVINFO_INT_CASSETTE_DEFAULT_STATE: info->i = CASSETTE_PLAY | CASSETTE_MOTOR_DISABLED | CASSETTE_SPEAKER_ENABLED; break; | |
| 243 | ||
| 244 | default: cassette_device_getinfo(devclass, state, info); break; | |
| 245 | } | |
| 246 | } | |
| 247 | ||
| 248 | 239 | static SYSTEM_CONFIG_START(dai) |
| 249 | 240 | CONFIG_RAM_DEFAULT(48 * 1024) |
| 250 | CONFIG_DEVICE(dai_cassette_getinfo) | |
| 251 | 241 | SYSTEM_CONFIG_END |
| 252 | 242 | |
| 253 | 243 |
| r3218 | r3219 | |
|---|---|---|
| 186 | 186 | } |
| 187 | 187 | |
| 188 | 188 | |
| 189 | static const device_config *cassette_device_image( | |
| 189 | static const device_config *cassette_device_image(running_machine *machine) | |
| 190 | 190 | { |
| 191 | return | |
| 191 | return | |
| 192 | 192 | } |
| 193 | 193 | |
| 194 | 194 | /*********************************************************************************************/ |
| r3218 | r3219 | |
| 352 | 352 | data = 0; |
| 353 | 353 | |
| 354 | 354 | /* cassette read */ |
| 355 | if (cassette_input(cassette_device_image()) >=0) | |
| 355 | if (cassette_input(cassette_device_image(machine)) >=0) | |
| 356 | 356 | data |=(1<<0); |
| 357 | 357 | |
| 358 | 358 | printer_handshake = centronics_read_handshake(0); |
| r3218 | r3219 | |
| 390 | 390 | |
| 391 | 391 | /* cassette remote */ |
| 392 | 392 | cassette_change_state( |
| 393 | cassette_device_image(), | |
| 393 | cassette_device_image(machine), | |
| 394 | 394 | (data & 0x02) ? CASSETTE_MOTOR_ENABLED : CASSETTE_MOTOR_DISABLED, |
| 395 | 395 | CASSETTE_MASK_MOTOR); |
| 396 | 396 | |
| 397 | 397 | /* cassette data */ |
| 398 | cassette_output(cassette_device_image(), (data & (1<<0)) ? -1.0 : 1.0); | |
| 398 | cassette_output(cassette_device_image(machine), (data & (1<<0)) ? -1.0 : 1.0); | |
| 399 | 399 | |
| 400 | 400 | /* assumption: select is tied low */ |
| 401 | 401 | centronics_write_handshake(0, CENTRONICS_SELECT | CENTRONICS_NO_RESET, CENTRONICS_SELECT| CENTRONICS_NO_RESET); |
| r3218 | r3219 | |
| 618 | 618 | cpunum_set_input_line(machine, 0, 0, HOLD_LINE); |
| 619 | 619 | } |
| 620 | 620 | |
| 621 | static const cassette_config sordm5_cassette_config = | |
| 622 | { | |
| 623 | sordm5_cassette_formats, | |
| 624 | NULL, | |
| 625 | CASSETTE_PLAY | |
| 626 | }; | |
| 627 | ||
| 621 | 628 | static MACHINE_DRIVER_START( sord_m5 ) |
| 622 | 629 | /* basic machine hardware */ |
| 623 | 630 | MDRV_CPU_ADD("main", Z80, 3800000) |
| r3218 | r3219 | |
| 646 | 653 | |
| 647 | 654 | /* printer */ |
| 648 | 655 | MDRV_DEVICE_ADD("printer", PRINTER) |
| 656 | ||
| 657 | MDRV_CASSETTE_ADD( "cassette", sordm5_cassette_config ) | |
| 649 | 658 | MACHINE_DRIVER_END |
| 650 | 659 | |
| 651 | 660 | |
| r3218 | r3219 | |
| 696 | 705 | FIRST_SECTOR_ID([1])) |
| 697 | 706 | FLOPPY_OPTIONS_END |
| 698 | 707 | |
| 699 | static void sordm5_cassette_getinfo(const mess_device_class *devclass, UINT32 state, union devinfo *info) | |
| 700 | { | |
| 701 | /* cassette */ | |
| 702 | switch(state) | |
| 703 | { | |
| 704 | /* --- the following bits of info are returned as 64-bit signed integers --- */ | |
| 705 | case MESS_DEVINFO_INT_COUNT: info->i = 1; break; | |
| 706 | 708 | |
| 707 | /* --- the following bits of info are returned as pointers to data or functions --- */ | |
| 708 | case MESS_DEVINFO_PTR_CASSETTE_FORMATS: info->p = (void *) sordm5_cassette_formats; break; | |
| 709 | ||
| 710 | default: cassette_device_getinfo(devclass, state, info); break; | |
| 711 | } | |
| 712 | } | |
| 713 | ||
| 714 | 709 | static SYSTEM_CONFIG_START(sordm5) |
| 715 | 710 | CONFIG_RAM_DEFAULT(64 * 1024) |
| 716 | CONFIG_DEVICE(sordm5_cassette_getinfo) | |
| 717 | 711 | CONFIG_DEVICE(cartslot_device_getinfo) |
| 718 | 712 | SYSTEM_CONFIG_END |
| 719 | 713 |
| r3218 | r3219 | |
|---|---|---|
| 312 | 312 | |
| 313 | 313 | /* sound hardware */ |
| 314 | 314 | MDRV_SPEAKER_STANDARD_MONO("mono") |
| 315 | MDRV_SOUND_ADD(" | |
| 315 | MDRV_SOUND_ADD("cassette", WAVE, 0) | |
| 316 | 316 | MDRV_SOUND_ROUTE(ALL_OUTPUTS, "mono", 0.25) |
| 317 | 317 | MDRV_SOUND_ADD("speaker", SPEAKER, 0) |
| 318 | 318 | MDRV_SOUND_ROUTE(ALL_OUTPUTS, "mono", 0.50) |
| r3218 | r3219 | |
| 320 | 320 | /* devices */ |
| 321 | 321 | MDRV_QUICKLOAD_ADD(mbee, "mwb,com", 2) |
| 322 | 322 | MDRV_Z80BIN_QUICKLOAD_ADD(mbee, 2) |
| 323 | ||
| 324 | MDRV_CASSETTE_ADD( "cassette", default_cassette_config ) | |
| 323 | 325 | MACHINE_DRIVER_END |
| 324 | 326 | |
| 325 | 327 | |
| r3218 | r3219 | |
| 349 | 351 | |
| 350 | 352 | /* sound hardware */ |
| 351 | 353 | MDRV_SPEAKER_STANDARD_MONO("mono") |
| 352 | MDRV_SOUND_ADD(" | |
| 354 | MDRV_SOUND_ADD("cassette", WAVE, 0) | |
| 353 | 355 | MDRV_SOUND_ROUTE(ALL_OUTPUTS, "mono", 0.25) |
| 354 | 356 | MDRV_SOUND_ADD("speaker", SPEAKER, 0) |
| 355 | 357 | MDRV_SOUND_ROUTE(ALL_OUTPUTS, "mono", 0.50) |
| r3218 | r3219 | |
| 357 | 359 | /* devices */ |
| 358 | 360 | MDRV_QUICKLOAD_ADD(mbee, "mwb,com", 2) |
| 359 | 361 | MDRV_Z80BIN_QUICKLOAD_ADD(mbee, 2) |
| 362 | ||
| 363 | MDRV_CASSETTE_ADD( "cassette", default_cassette_config ) | |
| 360 | 364 | MACHINE_DRIVER_END |
| 361 | 365 | |
| 362 | 366 | |
| r3218 | r3219 | |
| 526 | 530 | } |
| 527 | 531 | |
| 528 | 532 | |
| 529 | static void mbee_cassette_getinfo(const mess_device_class *devclass, UINT32 state, union devinfo *info) | |
| 530 | { | |
| 531 | /* cassette */ | |
| 532 | switch(state) | |
| 533 | { | |
| 534 | /* --- the following bits of info are returned as 64-bit signed integers --- */ | |
| 535 | case MESS_DEVINFO_INT_COUNT: info->i = 1; break; | |
| 536 | ||
| 537 | default: cassette_device_getinfo(devclass, state, info); break; | |
| 538 | } | |
| 539 | } | |
| 540 | ||
| 541 | 533 | static void mbee_cartslot_getinfo(const mess_device_class *devclass, UINT32 state, union devinfo *info) |
| 542 | 534 | { |
| 543 | 535 | /* cartslot */ |
| r3218 | r3219 | |
| 576 | 568 | |
| 577 | 569 | |
| 578 | 570 | static SYSTEM_CONFIG_START(mbee) |
| 579 | CONFIG_DEVICE(mbee_cassette_getinfo) | |
| 580 | 571 | CONFIG_DEVICE(mbee_cartslot_getinfo) |
| 581 | 572 | SYSTEM_CONFIG_END |
| 582 | 573 | |
| 583 | 574 | static SYSTEM_CONFIG_START(mbeeic) |
| 584 | CONFIG_DEVICE(mbee_cassette_getinfo) | |
| 585 | 575 | CONFIG_DEVICE(mbee_cartslot_getinfo) |
| 586 | 576 | CONFIG_DEVICE(mbee_floppy_getinfo) |
| 587 | 577 | SYSTEM_CONFIG_END |
| r3218 | r3219 | |
|---|---|---|
| 629 | 629 | MDRV_SPEAKER_STANDARD_MONO("mono") |
| 630 | 630 | MDRV_SOUND_ADD("dac", DAC, 0) |
| 631 | 631 | MDRV_SOUND_ROUTE(ALL_OUTPUTS, "mono", 0.25) |
| 632 | MDRV_SOUND_ADD(" | |
| 632 | MDRV_SOUND_ADD("cassette", WAVE, 0) | |
| 633 | 633 | MDRV_SOUND_ROUTE(ALL_OUTPUTS, "mono", 0.25) |
| 634 | 634 | MACHINE_DRIVER_END |
| 635 | 635 | |
| 636 | static const cassette_config coco_cassette_config = | |
| 637 | { | |
| 638 | coco_cassette_formats, | |
| 639 | NULL, | |
| 640 | CASSETTE_PLAY | CASSETTE_MOTOR_DISABLED | CASSETTE_SPEAKER_MUTED | |
| 641 | }; | |
| 642 | ||
| 636 | 643 | static MACHINE_DRIVER_START( dragon32 ) |
| 637 | 644 | /* basic machine hardware */ |
| 638 | 645 | MDRV_CPU_ADD("main", M6809E, COCO_CPU_SPEED_HZ * 4) /* 0,894886 Mhz */ |
| r3218 | r3219 | |
| 657 | 664 | |
| 658 | 665 | /* snapshot/quickload */ |
| 659 | 666 | MDRV_SNAPSHOT_ADD(coco_pak, "pak", 0) |
| 667 | ||
| 668 | MDRV_CASSETTE_ADD( "cassette", coco_cassette_config ) | |
| 660 | 669 | MACHINE_DRIVER_END |
| 661 | 670 | |
| 662 | 671 | static MACHINE_DRIVER_START( dragon64 ) |
| r3218 | r3219 | |
| 683 | 692 | |
| 684 | 693 | /* snapshot/quickload */ |
| 685 | 694 | MDRV_SNAPSHOT_ADD(coco_pak, "pak", 0) |
| 695 | ||
| 696 | MDRV_CASSETTE_ADD( "cassette", coco_cassette_config ) | |
| 686 | 697 | MACHINE_DRIVER_END |
| 687 | 698 | |
| 688 | 699 | static MACHINE_DRIVER_START( d64plus ) |
| r3218 | r3219 | |
| 709 | 720 | |
| 710 | 721 | /* snapshot/quickload */ |
| 711 | 722 | MDRV_SNAPSHOT_ADD(coco_pak, "pak", 0) |
| 723 | ||
| 724 | MDRV_CASSETTE_ADD( "cassette", coco_cassette_config ) | |
| 712 | 725 | MACHINE_DRIVER_END |
| 713 | 726 | |
| 714 | 727 | static MACHINE_DRIVER_START( dgnalpha ) |
| r3218 | r3219 | |
| 738 | 751 | |
| 739 | 752 | /* snapshot/quickload */ |
| 740 | 753 | MDRV_SNAPSHOT_ADD(coco_pak, "pak", 0) |
| 754 | ||
| 755 | MDRV_CASSETTE_ADD( "cassette", coco_cassette_config ) | |
| 741 | 756 | MACHINE_DRIVER_END |
| 742 | 757 | |
| 743 | 758 | static MACHINE_DRIVER_START( tanodr64 ) |
| r3218 | r3219 | |
| 764 | 779 | |
| 765 | 780 | /* snapshot/quickload */ |
| 766 | 781 | MDRV_SNAPSHOT_ADD(coco_pak, "pak", 0) |
| 782 | ||
| 783 | MDRV_CASSETTE_ADD( "cassette", coco_cassette_config ) | |
| 767 | 784 | MACHINE_DRIVER_END |
| 768 | 785 | |
| 769 | 786 | static MACHINE_DRIVER_START( coco ) |
| r3218 | r3219 | |
| 794 | 811 | |
| 795 | 812 | /* devices */ |
| 796 | 813 | MDRV_DEVICE_ADD("disto", MSM6242) |
| 814 | ||
| 815 | MDRV_CASSETTE_ADD( "cassette", coco_cassette_config ) | |
| 797 | 816 | MACHINE_DRIVER_END |
| 798 | 817 | |
| 799 | 818 | static MACHINE_DRIVER_START( coco2 ) |
| r3218 | r3219 | |
| 824 | 843 | |
| 825 | 844 | /* devices */ |
| 826 | 845 | MDRV_DEVICE_ADD("disto", MSM6242) |
| 846 | ||
| 847 | MDRV_CASSETTE_ADD( "cassette", coco_cassette_config ) | |
| 827 | 848 | MACHINE_DRIVER_END |
| 828 | 849 | |
| 829 | 850 | static MACHINE_DRIVER_START( coco2b ) |
| r3218 | r3219 | |
| 854 | 875 | |
| 855 | 876 | /* devices */ |
| 856 | 877 | MDRV_DEVICE_ADD("disto", MSM6242) |
| 878 | ||
| 879 | MDRV_CASSETTE_ADD( "cassette", coco_cassette_config ) | |
| 857 | 880 | MACHINE_DRIVER_END |
| 858 | 881 | |
| 859 | 882 | static MACHINE_DRIVER_START( coco3 ) |
| r3218 | r3219 | |
| 894 | 917 | /* devices */ |
| 895 | 918 | MDRV_DEVICE_ADD("vhd", COCO_VHD) |
| 896 | 919 | MDRV_DEVICE_ADD("disto", MSM6242) |
| 920 | ||
| 921 | MDRV_CASSETTE_ADD( "cassette", coco_cassette_config ) | |
| 897 | 922 | MACHINE_DRIVER_END |
| 898 | 923 | |
| 899 | 924 | static MACHINE_DRIVER_START( coco3p ) |
| r3218 | r3219 | |
| 1006 | 1031 | * |
| 1007 | 1032 | *************************************/ |
| 1008 | 1033 | |
| 1009 | static void coco_cassette_getinfo(const mess_device_class *devclass, UINT32 state, union devinfo *info) | |
| 1010 | { | |
| 1011 | /* cassette */ | |
| 1012 | switch(state) | |
| 1013 | { | |
| 1014 | /* --- the following bits of info are returned as 64-bit signed integers --- */ | |
| 1015 | case MESS_DEVINFO_INT_COUNT: info->i = 1; break; | |
| 1016 | ||
| 1017 | /* --- the following bits of info are returned as pointers to data or functions --- */ | |
| 1018 | case MESS_DEVINFO_PTR_CASSETTE_FORMATS: info->p = (void *) coco_cassette_formats; break; | |
| 1019 | ||
| 1020 | /* --- the following bits of info are returned as 64-bit signed integers --- */ | |
| 1021 | case MESS_DEVINFO_INT_CASSETTE_DEFAULT_STATE: info->i = CASSETTE_PLAY | CASSETTE_MOTOR_DISABLED | CASSETTE_SPEAKER_MUTED; break; | |
| 1022 | ||
| 1023 | default: cassette_device_getinfo(devclass, state, info); break; | |
| 1024 | } | |
| 1025 | } | |
| 1026 | ||
| 1027 | ||
| 1028 | ||
| 1029 | 1034 | static void coco_floppy_getinfo(const mess_device_class *devclass, UINT32 state, union devinfo *info) |
| 1030 | 1035 | { |
| 1031 | 1036 | /* floppy */ |
| r3218 | r3219 | |
| 1105 | 1110 | |
| 1106 | 1111 | |
| 1107 | 1112 | static SYSTEM_CONFIG_START( generic_coco ) |
| 1108 | CONFIG_DEVICE( coco_cassette_getinfo ) | |
| 1109 | 1113 | CONFIG_DEVICE( coco_floppy_getinfo ) |
| 1110 | 1114 | SYSTEM_CONFIG_END |
| 1111 | 1115 | |
| r3218 | r3219 | |
| 1117 | 1121 | /* These have to be split up, as the CoCo has a bitbanger */ |
| 1118 | 1122 | /* where the Dragon has a paralell printer port */ |
| 1119 | 1123 | static SYSTEM_CONFIG_START( generic_dragon ) |
| 1120 | CONFIG_DEVICE( coco_cassette_getinfo ) | |
| 1121 | 1124 | CONFIG_DEVICE( coco_floppy_getinfo ) |
| 1122 | 1125 | CONFIG_DEVICE( coco_cartslot_getinfo ) |
| 1123 | 1126 | SYSTEM_CONFIG_END |
| r3218 | r3219 | |
|---|---|---|
| 417 | 417 | |
| 418 | 418 | /* sound hardware */ |
| 419 | 419 | MDRV_SPEAKER_STANDARD_MONO("mono") |
| 420 | MDRV_SOUND_ADD(" | |
| 420 | MDRV_SOUND_ADD("cassette", WAVE, 0) | |
| 421 | 421 | MDRV_SOUND_ROUTE(ALL_OUTPUTS, "mono", 0.20) |
| 422 | 422 | MDRV_SOUND_ADD("sn76496", SN76496, 3579545) /* 3.579545 MHz */ |
| 423 | 423 | MDRV_SOUND_ROUTE(ALL_OUTPUTS, "mono", 0.75) |
| r3218 | r3219 | |
| 433 | 433 | MDRV_DEVICE_ADD( "harddisk3", HARDDISK ) |
| 434 | 434 | |
| 435 | 435 | MDRV_DEVICE_ADD( "ide_harddisk", IDE_HARDDISK ) |
| 436 | ||
| 437 | MDRV_CASSETTE_ADD( "cassette", default_cassette_config ) | |
| 436 | 438 | MACHINE_DRIVER_END |
| 437 | 439 | |
| 438 | 440 | |
| r3218 | r3219 | |
| 461 | 463 | MDRV_SOUND_ADD("tms5220", TMS5220, 680000L) |
| 462 | 464 | MDRV_SOUND_CONFIG(ti99_8_tms5220interface) |
| 463 | 465 | MDRV_SOUND_ROUTE(ALL_OUTPUTS, "mono", 0.50) |
| 464 | MDRV_SOUND_ADD(" | |
| 466 | MDRV_SOUND_ADD("cassette", WAVE, 0) | |
| 465 | 467 | MDRV_SOUND_ROUTE(ALL_OUTPUTS, "mono", 0.20) |
| 466 | 468 | |
| 467 | 469 | /* devices */ |
| r3218 | r3219 | |
| 472 | 474 | MDRV_DEVICE_ADD( "harddisk3", HARDDISK ) |
| 473 | 475 | |
| 474 | 476 | MDRV_DEVICE_ADD( "ide_harddisk", IDE_HARDDISK ) |
| 477 | ||
| 478 | MDRV_CASSETTE_ADD( "cassette", default_cassette_config ) | |
| 475 | 479 | MACHINE_DRIVER_END |
| 476 | 480 | |
| 477 | 481 | /* |
| r3218 | r3219 | |
| 507 | 511 | |
| 508 | 512 | #define rom_ti99_8e rom_ti99_8 |
| 509 | 513 | |
| 510 | static void ti99_8_cassette_getinfo(const mess_device_class *devclass, UINT32 state, union devinfo *info) | |
| 511 | { | |
| 512 | /* cassette */ | |
| 513 | switch(state) | |
| 514 | { | |
| 515 | /* --- the following bits of info are returned as 64-bit signed integers --- */ | |
| 516 | case MESS_DEVINFO_INT_COUNT: info->i = 1; break; | |
| 517 | ||
| 518 | default: cassette_device_getinfo(devclass, state, info); break; | |
| 519 | } | |
| 520 | } | |
| 521 | ||
| 522 | 514 | static void ti99_8_cartslot_getinfo(const mess_device_class *devclass, UINT32 state, union devinfo *info) |
| 523 | 515 | { |
| 524 | 516 | /* cartslot */ |
| r3218 | r3219 | |
| 625 | 617 | /* Hex-bus disk controller: supports up to 4 floppy disk drives */ |
| 626 | 618 | /* expansion port (similar to 99/4(a) - yet slightly different) */ |
| 627 | 619 | |
| 628 | CONFIG_DEVICE(ti99_8_cassette_getinfo) | |
| 629 | 620 | CONFIG_DEVICE(ti99_8_cartslot_getinfo) |
| 630 | 621 | #if 1 |
| 631 | 622 | CONFIG_DEVICE(ti99_8_floppy_getinfo) |
| r3218 | r3219 | |
|---|---|---|
| 748 | 748 | #define MSX_VISIBLE_XBORDER_PIXELS 8 |
| 749 | 749 | #define MSX_VISIBLE_YBORDER_PIXELS 24 |
| 750 | 750 | |
| 751 | static const cassette_config msx_cassette_config = | |
| 752 | { | |
| 753 | fmsx_cassette_formats, | |
| 754 | NULL, | |
| 755 | CASSETTE_PLAY | |
| 756 | }; | |
| 757 | ||
| 758 | ||
| 751 | 759 | static MACHINE_DRIVER_START( msx ) |
| 752 | 760 | /* basic machine hardware */ |
| 753 | 761 | MDRV_CPU_ADD("main", Z80, 3579545) /* 3.579545 Mhz */ |
| r3218 | r3219 | |
| 774 | 782 | MDRV_SPEAKER_STANDARD_MONO("mono") |
| 775 | 783 | MDRV_SOUND_ADD("dac", DAC, 0) |
| 776 | 784 | MDRV_SOUND_ROUTE(ALL_OUTPUTS, "mono", 0.10) |
| 777 | MDRV_SOUND_ADD(" | |
| 785 | MDRV_SOUND_ADD("cassette", WAVE, 0) | |
| 778 | 786 | MDRV_SOUND_ROUTE(ALL_OUTPUTS, "mono", 0.25) |
| 779 | 787 | MDRV_SOUND_ADD("ay8910", AY8910, 1789773) |
| 780 | 788 | MDRV_SOUND_CONFIG(msx_ay8910_interface) |
| r3218 | r3219 | |
| 786 | 794 | |
| 787 | 795 | /* printer */ |
| 788 | 796 | MDRV_DEVICE_ADD("printer", PRINTER) |
| 797 | ||
| 798 | MDRV_CASSETTE_ADD( "cassette", msx_cassette_config ) | |
| 789 | 799 | MACHINE_DRIVER_END |
| 790 | 800 | |
| 791 | 801 | |
| r3218 | r3219 | |
| 834 | 844 | MDRV_SPEAKER_STANDARD_MONO("mono") |
| 835 | 845 | MDRV_SOUND_ADD("dac", DAC, 0) |
| 836 | 846 | MDRV_SOUND_ROUTE(ALL_OUTPUTS, "mono", 0.10) |
| 837 | MDRV_SOUND_ADD(" | |
| 847 | MDRV_SOUND_ADD("cassette", WAVE, 0) | |
| 838 | 848 | MDRV_SOUND_ROUTE(ALL_OUTPUTS, "mono", 0.25) |
| 839 | 849 | MDRV_SOUND_ADD("ay8910", AY8910, 1789773) |
| 840 | 850 | MDRV_SOUND_CONFIG(msx_ay8910_interface) |
| r3218 | r3219 | |
| 848 | 858 | |
| 849 | 859 | /* printer */ |
| 850 | 860 | MDRV_DEVICE_ADD("printer", PRINTER) |
| 861 | ||
| 862 | MDRV_CASSETTE_ADD( "cassette", msx_cassette_config ) | |
| 851 | 863 | MACHINE_DRIVER_END |
| 852 | 864 | |
| 853 | 865 | |
| r3218 | r3219 | |
| 2209 | 2221 | } |
| 2210 | 2222 | } |
| 2211 | 2223 | |
| 2212 | static void msx_cassette_getinfo(const mess_device_class *devclass, UINT32 state, union devinfo *info) | |
| 2213 | { | |
| 2214 | /* cassette */ | |
| 2215 | switch(state) | |
| 2216 | { | |
| 2217 | /* --- the following bits of info are returned as 64-bit signed integers --- */ | |
| 2218 | case MESS_DEVINFO_INT_COUNT: info->i = 1; break; | |
| 2219 | 2224 | |
| 2220 | /* --- the following bits of info are returned as pointers to data or functions --- */ | |
| 2221 | case MESS_DEVINFO_PTR_CASSETTE_FORMATS: info->p = (void *) fmsx_cassette_formats; break; | |
| 2222 | ||
| 2223 | default: cassette_device_getinfo(devclass, state, info); break; | |
| 2224 | } | |
| 2225 | } | |
| 2226 | ||
| 2227 | 2225 | static SYSTEM_CONFIG_START(msx) |
| 2228 | 2226 | CONFIG_DEVICE(msx_floppy_getinfo) |
| 2229 | 2227 | CONFIG_DEVICE(msx_cartslot_getinfo) |
| 2230 | CONFIG_DEVICE(msx_cassette_getinfo) | |
| 2231 | 2228 | SYSTEM_CONFIG_END |
| 2232 | 2229 | |
| 2233 | 2230 | MSX_DRIVER_LIST |
| r3218 | r3219 | |
|---|---|---|
| 92 | 92 | |
| 93 | 93 | static QUICKLOAD_LOAD( tmc600 ); |
| 94 | 94 | |
| 95 | static const device_config *cassette_device_image( | |
| 95 | static const device_config *cassette_device_image(running_machine *machine) | |
| 96 | 96 | { |
| 97 | return | |
| 97 | return | |
| 98 | 98 | } |
| 99 | 99 | |
| 100 | 100 | /* Read/Write Handlers */ |
| r3218 | r3219 | |
| 254 | 254 | |
| 255 | 255 | // tape in |
| 256 | 256 | |
| 257 | if (cassette_input(cassette_device_image()) < +0.0) flags -= EF2; | |
| 257 | if (cassette_input(cassette_device_image(machine)) < +0.0) flags -= EF2; | |
| 258 | 258 | |
| 259 | 259 | // keyboard |
| 260 | 260 | |
| r3218 | r3219 | |
| 265 | 265 | |
| 266 | 266 | static CDP1802_Q_WRITE( tmc600_q_w ) |
| 267 | 267 | { |
| 268 | cassette_output(cassette_device_image(), level ? +1.0 : -1.0); | |
| 268 | cassette_output(cassette_device_image(machine), level ? +1.0 : -1.0); | |
| 269 | 269 | } |
| 270 | 270 | |
| 271 | 271 | static CDP1802_INTERFACE( tmc600_cdp1802_config ) |
| r3218 | r3219 | |
| 312 | 312 | |
| 313 | 313 | /* Machine Drivers */ |
| 314 | 314 | |
| 315 | static const cassette_config tmc600_cassette_config = | |
| 316 | { | |
| 317 | cassette_default_formats, | |
| 318 | NULL, | |
| 319 | CASSETTE_STOPPED | CASSETTE_MOTOR_ENABLED | CASSETTE_SPEAKER_MUTED | |
| 320 | }; | |
| 321 | ||
| 315 | 322 | static MACHINE_DRIVER_START( tmc600 ) |
| 316 | 323 | // basic system hardware |
| 317 | 324 | |
| r3218 | r3219 | |
| 339 | 346 | |
| 340 | 347 | /* quickload */ |
| 341 | 348 | MDRV_QUICKLOAD_ADD(tmc600, "sbp", 0) |
| 349 | ||
| 350 | MDRV_CASSETTE_ADD( "cassette", tmc600_cassette_config ) | |
| 342 | 351 | MACHINE_DRIVER_END |
| 343 | 352 | |
| 344 | 353 | /* ROMs */ |
| r3218 | r3219 | |
| 376 | 385 | return INIT_PASS; |
| 377 | 386 | } |
| 378 | 387 | |
| 379 | static void tmc600_cassette_getinfo(const mess_device_class *devclass, UINT32 state, union devinfo *info) | |
| 380 | { | |
| 381 | /* cassette */ | |
| 382 | switch(state) | |
| 383 | { | |
| 384 | /* --- the following bits of info are returned as 64-bit signed integers --- */ | |
| 385 | case MESS_DEVINFO_INT_COUNT: info->i = 1; break; | |
| 386 | case MESS_DEVINFO_INT_CASSETTE_DEFAULT_STATE: info->i = CASSETTE_STOPPED | CASSETTE_MOTOR_ENABLED | CASSETTE_SPEAKER_MUTED; break; | |
| 387 | ||
| 388 | default: cassette_device_getinfo(devclass, state, info); break; | |
| 389 | } | |
| 390 | } | |
| 391 | ||
| 392 | 388 | static void tmc600_floppy_getinfo(const mess_device_class *devclass, UINT32 state, union devinfo *info) |
| 393 | 389 | { |
| 394 | 390 | /* floppy */ |
| r3218 | r3219 | |
| 411 | 407 | CONFIG_RAM_DEFAULT ( 8 * 1024) |
| 412 | 408 | CONFIG_RAM (16 * 1024) |
| 413 | 409 | CONFIG_RAM (24 * 1024) |
| 414 | CONFIG_DEVICE(tmc600_cassette_getinfo) | |
| 415 | 410 | CONFIG_DEVICE(tmc600_floppy_getinfo) |
| 416 | 411 | SYSTEM_CONFIG_END |
| 417 | 412 |
| r3218 | r3219 | |
|---|---|---|
| 264 | 264 | PORT_BIT(0x80, IP_ACTIVE_LOW, IPT_KEYBOARD) PORT_NAME("Num 2") PORT_CODE(KEYCODE_2_PAD) |
| 265 | 265 | INPUT_PORTS_END |
| 266 | 266 | |
| 267 | static const cassette_config radio86_cassette_config = | |
| 268 | { | |
| 269 | rkr_cassette_formats, | |
| 270 | NULL, | |
| 271 | CASSETTE_STOPPED | CASSETTE_SPEAKER_ENABLED | CASSETTE_MOTOR_ENABLED | |
| 272 | }; | |
| 273 | ||
| 274 | ||
| 267 | 275 | /* Machine driver */ |
| 268 | 276 | static MACHINE_DRIVER_START( radio86 ) |
| 269 | 277 | /* basic machine hardware */ |
| r3218 | r3219 | |
| 290 | 298 | MDRV_VIDEO_UPDATE(radio86) |
| 291 | 299 | |
| 292 | 300 | MDRV_SPEAKER_STANDARD_MONO("mono") |
| 293 | MDRV_SOUND_ADD(" | |
| 301 | MDRV_SOUND_ADD("cassette", WAVE, 0) | |
| 294 | 302 | MDRV_SOUND_ROUTE(ALL_OUTPUTS, "mono", 0.25) |
| 295 | 303 | |
| 296 | 304 | MDRV_DEVICE_ADD("dma8257", DMA8257) |
| 297 | 305 | MDRV_DEVICE_CONFIG(radio86_dma) |
| 306 | ||
| 307 | MDRV_CASSETTE_ADD( "cassette", radio86_cassette_config ) | |
| 298 | 308 | MACHINE_DRIVER_END |
| 299 | 309 | |
| 300 | 310 | static MACHINE_DRIVER_START( radio16 ) |
| r3218 | r3219 | |
| 344 | 354 | MDRV_DEVICE_CONFIG( rk7007_ppi8255_interface ) |
| 345 | 355 | MACHINE_DRIVER_END |
| 346 | 356 | |
| 347 | static void radio86_cassette_getinfo(const mess_device_class *devclass, UINT32 state, union devinfo *info) | |
| 348 | { | |
| 349 | /* cassette */ | |
| 350 | switch(state) | |
| 351 | { | |
| 352 | /* --- the following bits of info are returned as 64-bit signed integers --- */ | |
| 353 | case MESS_DEVINFO_INT_COUNT: info->i = 1; break; | |
| 354 | case MESS_DEVINFO_INT_CASSETTE_DEFAULT_STATE: info->i = CASSETTE_STOPPED | CASSETTE_SPEAKER_ENABLED | CASSETTE_MOTOR_ENABLED; break; | |
| 355 | case MESS_DEVINFO_PTR_CASSETTE_FORMATS: info->p = (void *)rkr_cassette_formats; break; | |
| 356 | 357 | |
| 357 | default: cassette_device_getinfo(devclass, state, info); break; | |
| 358 | } | |
| 359 | } | |
| 360 | ||
| 361 | 358 | /* ROM definition */ |
| 362 | 359 | ROM_START( radio86 ) |
| 363 | 360 | ROM_REGION( 0x10000, "main", ROMREGION_ERASEFF ) |
| r3218 | r3219 | |
| 424 | 421 | ROM_LOAD ("radio86.fnt", 0x0000, 0x0400, CRC(7666bd5e) SHA1(8652787603bee9b4da204745e3b2aa07a4783dfc)) |
| 425 | 422 | ROM_END |
| 426 | 423 | |
| 427 | static SYSTEM_CONFIG_START(radio86) | |
| 428 | CONFIG_DEVICE(radio86_cassette_getinfo); | |
| 429 | SYSTEM_CONFIG_END | |
| 430 | 424 | |
| 431 | 425 | /* Driver */ |
| 432 | 426 | |
| 433 | 427 | /* YEAR NAME PARENT COMPAT MACHINE INPUT INIT CONFIG COMPANY FULLNAME FLAGS */ |
| 434 | COMP( 1986, radio86, 0, 0, radio86, radio86,radio86, radio86, "", "Radio-86RK", 0) | |
| 435 | COMP( 1986, radio16, radio86, 0, radio16, radio86,radio86, radio86, "", "Radio-86RK (16K RAM)", 0) | |
| 436 | COMP( 1986, radio4k, radio86, 0, radio86, radio86,radio86, radio86, "", "Radio-86RK (4K ROM)", 0) | |
| 437 | COMP( 1986, radiorom,radio86, 0, radiorom, radio86,radio86, radio86, "", "Radio-86RK (ROM-Disk)", 0) | |
| 438 | COMP( 1986, radioram, radio86, 0, radioram, radio86,radioram, radio86, "", "Radio-86RK (ROM/RAM Disk)", 0) | |
| 439 | COMP( 1986, spektr01,radio86, 0, radio86, radio86,radio86, radio86, "", "Spektr-001", 0) | |
| 440 | COMP( 1986, rk7007, radio86, 0, rk7007, ms7007,radio86, radio86, "", "Radio-86RK (MS7007)", 0) | |
| 441 | COMP( 1986, rk700716, radio86, 0, rk700716, ms7007,radio86, radio86, "", "Radio-86RK (MS7007 16K RAM)", 0) | |
| 428 | COMP( 1986, radio86, 0, 0, radio86, radio86,radio86, 0, "", "Radio-86RK", 0) | |
| 429 | COMP( 1986, radio16, radio86, 0, radio16, radio86,radio86, 0, "", "Radio-86RK (16K RAM)", 0) | |
| 430 | COMP( 1986, radio4k, radio86, 0, radio86, radio86,radio86, 0, "", "Radio-86RK (4K ROM)", 0) | |
| 431 | COMP( 1986, radiorom,radio86, 0, radiorom, radio86,radio86, 0, "", "Radio-86RK (ROM-Disk)", 0) | |
| 432 | COMP( 1986, radioram, radio86, 0, radioram, radio86,radioram, 0, "", "Radio-86RK (ROM/RAM Disk)", 0) | |
| 433 | COMP( 1986, spektr01,radio86, 0, radio86, radio86,radio86, 0, "", "Spektr-001", 0) | |
| 434 | COMP( 1986, rk7007, radio86, 0, rk7007, ms7007,radio86, 0, "", "Radio-86RK (MS7007)", 0) | |
| 435 | COMP( 1986, rk700716, radio86, 0, rk700716, ms7007,radio86, 0, "", "Radio-86RK (MS7007 16K RAM)", 0) |
| r3218 | r3219 | |
|---|---|---|
| 254 | 254 | GFXDECODE_END |
| 255 | 255 | |
| 256 | 256 | |
| 257 | static const cassette_config mz700_cassette_config = | |
| 258 | { | |
| 259 | mz700_cassette_formats, | |
| 260 | NULL, | |
| 261 | CASSETTE_PLAY | |
| 262 | }; | |
| 257 | 263 | |
| 264 | ||
| 258 | 265 | static MACHINE_DRIVER_START(mz700) |
| 259 | 266 | /* basic machine hardware */ |
| 260 | 267 | MDRV_CPU_ADD("main", Z80, 3500000) |
| r3218 | r3219 | |
| 284 | 291 | MDRV_VIDEO_UPDATE(mz700) |
| 285 | 292 | |
| 286 | 293 | MDRV_SPEAKER_STANDARD_MONO("mono") |
| 287 | MDRV_SOUND_ADD(" | |
| 294 | MDRV_SOUND_ADD("cassette", WAVE, 0) | |
| 288 | 295 | MDRV_SOUND_ROUTE(ALL_OUTPUTS, "mono", 0.50) |
| 289 | 296 | MDRV_SOUND_ADD("speaker", SPEAKER, 0) |
| 290 | 297 | MDRV_SOUND_ROUTE(ALL_OUTPUTS, "mono", 0.50) |
| 298 | ||
| 299 | MDRV_CASSETTE_ADD( "cassette", mz700_cassette_config ) | |
| 291 | 300 | MACHINE_DRIVER_END |
| 292 | 301 | |
| 293 | 302 | static MACHINE_DRIVER_START(mz800) |
| r3218 | r3219 | |
| 319 | 328 | MDRV_VIDEO_UPDATE(mz700) |
| 320 | 329 | |
| 321 | 330 | MDRV_SPEAKER_STANDARD_MONO("mono") |
| 322 | MDRV_SOUND_ADD(" | |
| 331 | MDRV_SOUND_ADD("cassette", WAVE, 0) | |
| 323 | 332 | MDRV_SOUND_ROUTE(ALL_OUTPUTS, "mono", 0.50) |
| 324 | 333 | MDRV_SOUND_ADD("speaker", SPEAKER, 0) |
| 325 | 334 | MDRV_SOUND_ROUTE(ALL_OUTPUTS, "mono", 0.50) |
| 335 | ||
| 336 | MDRV_CASSETTE_ADD( "cassette", mz700_cassette_config ) | |
| 326 | 337 | MACHINE_DRIVER_END |
| 327 | 338 | |
| 328 | 339 | |
| r3218 | r3219 | |
| 350 | 361 | ROM_LOAD("mz700fon.int",0x00000, 0x1000, CRC(42b9e8fb) SHA1(5128ad179a702f8e0bd9910a58bad8fbe4c20167)) |
| 351 | 362 | ROM_END |
| 352 | 363 | |
| 353 | static void mz700_cassette_getinfo(const mess_device_class *devclass, UINT32 state, union devinfo *info) | |
| 354 | { | |
| 355 | /* cassette */ | |
| 356 | switch(state) | |
| 357 | { | |
| 358 | /* --- the following bits of info are returned as 64-bit signed integers --- */ | |
| 359 | case MESS_DEVINFO_INT_COUNT: info->i = 1; break; | |
| 360 | 364 | |
| 361 | /* --- the following bits of info are returned as pointers to data or functions --- */ | |
| 362 | case MESS_DEVINFO_PTR_CASSETTE_FORMATS: info->p = (void *) mz700_cassette_formats; break; | |
| 363 | ||
| 364 | default: cassette_device_getinfo(devclass, state, info); break; | |
| 365 | } | |
| 366 | } | |
| 367 | ||
| 368 | static SYSTEM_CONFIG_START(mz700) | |
| 369 | CONFIG_DEVICE(mz700_cassette_getinfo) | |
| 370 | SYSTEM_CONFIG_END | |
| 371 | ||
| 372 | 365 | /* YEAR NAME PARENT COMPAT MACHINE INPUT INIT CONFIG COMPANY FULLNAME */ |
| 373 | COMP( 1982, mz700, 0, 0, mz700, mz700, mz700, mz700, "Sharp", "MZ-700" , 0) | |
| 374 | COMP( 1982, mz700j, mz700, 0, mz700, mz700, mz700, mz700, "Sharp", "MZ-700 (Japan)" , 0) | |
| 375 | COMP( 1982, mz800, mz700, 0, mz800, mz700, mz800, mz700, "Sharp", "MZ-800" , GAME_NOT_WORKING ) | |
| 366 | COMP( 1982, mz700, 0, 0, mz700, mz700, mz700, 0, "Sharp", "MZ-700" , 0) | |
| 367 | COMP( 1982, mz700j, mz700, 0, mz700, mz700, mz700, 0, "Sharp", "MZ-700 (Japan)" , 0) | |
| 368 | COMP( 1982, mz800, mz700, 0, mz800, mz700, mz800, 0, "Sharp", "MZ-800" , GAME_NOT_WORKING ) | |
| 376 | 369 | |
| 377 | 370 |
| r3218 | r3219 | |
|---|---|---|
| 413 | 413 | reply |= input_port_read(Machine, keynames[digitsel]) << 1; |
| 414 | 414 | |
| 415 | 415 | /* tape input */ |
| 416 | if (cassette_input( | |
| 416 | if (cassette_input( | |
| 417 | 417 | reply |= 0x40; |
| 418 | 418 | |
| 419 | 419 | return reply; |
| r3218 | r3219 | |
| 463 | 463 | |
| 464 | 464 | static void sys9901_tapewdata_w(int offset, int data) |
| 465 | 465 | { |
| 466 | cassette_output( | |
| 466 | cassette_output( | |
| 467 | 467 | } |
| 468 | 468 | |
| 469 | 469 | /* |
| r3218 | r3219 | |
| 553 | 553 | case 5: /* CKON: set DECKCONTROL */ |
| 554 | 554 | LED_state |= 0x20; |
| 555 | 555 | { |
| 556 | const device_config *img = | |
| 556 | const device_config *img = | |
| 557 | 557 | cassette_change_state(img, CASSETTE_MOTOR_ENABLED, CASSETTE_MASK_MOTOR); |
| 558 | 558 | } |
| 559 | 559 | break; |
| r3218 | r3219 | |
| 561 | 561 | case 6: /* CKOF: clear DECKCONTROL */ |
| 562 | 562 | LED_state &= ~0x20; |
| 563 | 563 | { |
| 564 | const device_config *img = | |
| 564 | const device_config *img = | |
| 565 | 565 | cassette_change_state(img, CASSETTE_MOTOR_DISABLED, CASSETTE_MASK_MOTOR); |
| 566 | 566 | } |
| 567 | 567 | break; |
| r3218 | r3219 | |
| 815 | 815 | /* sound hardware */ |
| 816 | 816 | /* one two-level buzzer */ |
| 817 | 817 | MDRV_SPEAKER_STANDARD_MONO("mono") |
| 818 | MDRV_SOUND_ADD(" | |
| 818 | MDRV_SOUND_ADD("cassette", WAVE, 0) | |
| 819 | 819 | MDRV_SOUND_ROUTE(ALL_OUTPUTS, "mono", 0.50) |
| 820 | 820 | MDRV_SOUND_ADD("speaker", SPEAKER, 0) |
| 821 | 821 | MDRV_SOUND_ROUTE(ALL_OUTPUTS, "mono", 0.50) |
| 822 | ||
| 823 | MDRV_CASSETTE_ADD( "cassette", default_cassette_config ) | |
| 822 | 824 | MACHINE_DRIVER_END |
| 823 | 825 | |
| 824 | 826 | #define LEFT_BORDER 15 |
| r3218 | r3219 | |
| 851 | 853 | /* sound hardware */ |
| 852 | 854 | /* one two-level buzzer */ |
| 853 | 855 | MDRV_SPEAKER_STANDARD_MONO("mono") |
| 854 | MDRV_SOUND_ADD(" | |
| 856 | MDRV_SOUND_ADD("cassette", WAVE, 0) | |
| 855 | 857 | MDRV_SOUND_ROUTE(ALL_OUTPUTS, "mono", 0.50) |
| 856 | 858 | MDRV_SOUND_ADD("speaker", SPEAKER, 0) |
| 857 | 859 | MDRV_SOUND_ROUTE(ALL_OUTPUTS, "mono", 0.50) |
| 860 | ||
| 861 | MDRV_CASSETTE_ADD( "cassette", default_cassette_config ) | |
| 858 | 862 | MACHINE_DRIVER_END |
| 859 | 863 | |
| 860 | 864 | |
| r3218 | r3219 | |
| 983 | 987 | |
| 984 | 988 | INPUT_PORTS_END |
| 985 | 989 | |
| 986 | static void tm990_189_cassette_getinfo(const mess_device_class *devclass, UINT32 state, union devinfo *info) | |
| 987 | { | |
| 988 | /* cassette */ | |
| 989 | switch(state) | |
| 990 | { | |
| 991 | /* --- the following bits of info are returned as 64-bit signed integers --- */ | |
| 992 | case MESS_DEVINFO_INT_COUNT: info->i = 1; break; | |
| 993 | ||
| 994 | default: cassette_device_getinfo(devclass, state, info); break; | |
| 995 | } | |
| 996 | } | |
| 997 | ||
| 998 | 990 | static void tm990_189_serial_getinfo(const mess_device_class *devclass, UINT32 state, union devinfo *info) |
| 999 | 991 | { |
| 1000 | 992 | /* serial */ |
| r3218 | r3219 | |
| 1018 | 1010 | |
| 1019 | 1011 | static SYSTEM_CONFIG_START(tm990_189) |
| 1020 | 1012 | /* a tape interface and a rs232 interface... */ |
| 1021 | CONFIG_DEVICE(tm990_189_cassette_getinfo) | |
| 1022 | 1013 | CONFIG_DEVICE(tm990_189_serial_getinfo) |
| 1023 | 1014 | SYSTEM_CONFIG_END |
| 1024 | 1015 |
| r3218 | r3219 | |
|---|---|---|
| 697 | 697 | |
| 698 | 698 | static SYSTEM_CONFIG_START ( to ) |
| 699 | 699 | CONFIG_DEVICE ( to7_cartridge_getinfo ) |
| 700 | CONFIG_DEVICE ( to7_cassette_getinfo ) | |
| 701 | 700 | CONFIG_DEVICE ( thom_floppy_getinfo ) |
| 702 | 701 | CONFIG_DEVICE ( thom_serial_getinfo ) |
| 703 | 702 | SYSTEM_CONFIG_END |
| r3218 | r3219 | |
| 756 | 755 | /* printer */ |
| 757 | 756 | MDRV_DEVICE_ADD("printer", PRINTER) |
| 758 | 757 | |
| 758 | MDRV_CASSETTE_ADD( "cassette", to7_cassette_config ) | |
| 759 | 759 | MACHINE_DRIVER_END |
| 760 | 760 | |
| 761 | 761 | static MACHINE_DRIVER_START ( t9000 ) |
| r3218 | r3219 | |
| 1117 | 1117 | |
| 1118 | 1118 | static SYSTEM_CONFIG_START ( mo ) |
| 1119 | 1119 | CONFIG_DEVICE ( mo5_cartridge_getinfo ) |
| 1120 | CONFIG_DEVICE ( mo5_cassette_getinfo ) | |
| 1121 | 1120 | CONFIG_DEVICE ( thom_floppy_getinfo ) |
| 1122 | 1121 | CONFIG_DEVICE ( thom_serial_getinfo ) |
| 1123 | 1122 | SYSTEM_CONFIG_END |
| r3218 | r3219 | |
| 1140 | 1139 | MDRV_MACHINE_RESET ( mo5 ) |
| 1141 | 1140 | MDRV_CPU_MODIFY( "main" ) |
| 1142 | 1141 | MDRV_CPU_PROGRAM_MAP ( mo5, 0 ) |
| 1142 | ||
| 1143 | MDRV_CASSETTE_MODIFY( "cassette", mo5_cassette_config ) | |
| 1143 | 1144 | MACHINE_DRIVER_END |
| 1144 | 1145 | |
| 1145 | 1146 | static MACHINE_DRIVER_START ( mo5e ) |
| r3218 | r3219 | |
|---|---|---|
| 27 | 27 | #include "sound/ay8910.h" |
| 28 | 28 | #include "sound/speaker.h" |
| 29 | 29 | |
| 30 | static const device_config *cassette_device_image( | |
| 30 | static const device_config *cassette_device_image(running_machine *machine) | |
| 31 | 31 | { |
| 32 | return | |
| 32 | return | |
| 33 | 33 | } |
| 34 | 34 | |
| 35 | 35 | /* Read/Write Handlers */ |
| r3218 | r3219 | |
| 53 | 53 | |
| 54 | 54 | */ |
| 55 | 55 | |
| 56 | return (cassette_input(cassette_device_image()) < +0.0) ? 0 : 1; | |
| 56 | return (cassette_input(cassette_device_image(machine)) < +0.0) ? 0 : 1; | |
| 57 | 57 | } |
| 58 | 58 | |
| 59 | 59 | static WRITE8_HANDLER( cassette_w ) |
| r3218 | r3219 | |
| 68 | 68 | |
| 69 | 69 | speaker_level_w(0, data & 0x01); |
| 70 | 70 | |
| 71 | cassette_output(cassette_device_image(), (data & 0x01) ? +1.0 : -1.0); | |
| 71 | cassette_output(cassette_device_image(machine), (data & 0x01) ? +1.0 : -1.0); | |
| 72 | 72 | } |
| 73 | 73 | |
| 74 | 74 | static READ8_HANDLER( vsync_r ) |
| r3218 | r3219 | |
| 395 | 395 | } |
| 396 | 396 | |
| 397 | 397 | /* Machine Driver */ |
| 398 | static const cassette_config aquarius_cassette_config = | |
| 399 | { | |
| 400 | cassette_default_formats, | |
| 401 | NULL, | |
| 402 | CASSETTE_STOPPED | CASSETTE_MOTOR_ENABLED | CASSETTE_SPEAKER_MUTED | |
| 403 | }; | |
| 398 | 404 | |
| 405 | ||
| 399 | 406 | static MACHINE_DRIVER_START( aquarius ) |
| 400 | 407 | /* basic machine hardware */ |
| 401 | 408 | MDRV_CPU_ADD("main", Z80, XTAL_3_579545MHz) // ??? |
| r3218 | r3219 | |
| 431 | 438 | |
| 432 | 439 | /* printer */ |
| 433 | 440 | MDRV_DEVICE_ADD("printer", PRINTER) |
| 441 | ||
| 442 | MDRV_CASSETTE_ADD( "cassette", aquarius_cassette_config ) | |
| 434 | 443 | MACHINE_DRIVER_END |
| 435 | 444 | |
| 436 | 445 | /* ROMs */ |
| r3218 | r3219 | |
| 487 | 496 | } |
| 488 | 497 | } |
| 489 | 498 | |
| 490 | static void aquarius_cassette_getinfo(const mess_device_class *devclass, UINT32 state, union devinfo *info) | |
| 491 | { | |
| 492 | // cassette | |
| 493 | switch(state) | |
| 494 | { | |
| 495 | /* --- the following bits of info are returned as 64-bit signed integers --- */ | |
| 496 | case MESS_DEVINFO_INT_COUNT: info->i = 1; break; | |
| 497 | case MESS_DEVINFO_INT_CASSETTE_DEFAULT_STATE: info->i = CASSETTE_STOPPED | CASSETTE_MOTOR_ENABLED | CASSETTE_SPEAKER_MUTED; break; | |
| 498 | ||
| 499 | default: cassette_device_getinfo(devclass, state, info); break; | |
| 500 | } | |
| 501 | } | |
| 502 | ||
| 503 | 499 | static DEVICE_IMAGE_LOAD( aquarius_floppy ) |
| 504 | 500 | { |
| 505 | 501 | // 128K images, 64K/side |
| r3218 | r3219 | |
| 530 | 526 | CONFIG_RAM (20 * 1024) |
| 531 | 527 | CONFIG_RAM (36 * 1024) |
| 532 | 528 | CONFIG_DEVICE(aquarius_cartslot_getinfo) |
| 533 | CONFIG_DEVICE(aquarius_cassette_getinfo) | |
| 534 | 529 | CONFIG_DEVICE(aquarius_floppy_getinfo) |
| 535 | 530 | SYSTEM_CONFIG_END |
| 536 | 531 |
| r3218 | r3219 | |
|---|---|---|
| 424 | 424 | } |
| 425 | 425 | |
| 426 | 426 | static SYSTEM_CONFIG_START(specpls3) |
| 427 | CONFIG_IMPORT_FROM(spectrum_common) | |
| 428 | 427 | CONFIG_DEVICE(specpls3_floppy_getinfo) |
| 429 | 428 | CONFIG_RAM_DEFAULT(128 * 1024) |
| 430 | 429 | SYSTEM_CONFIG_END |
| r3218 | r3219 | |
|---|---|---|
| 523 | 523 | |
| 524 | 524 | |
| 525 | 525 | |
| 526 | static const struct CassetteOptions pmd85_cassette_options = | |
| 527 | { | |
| 528 | 1, /* channels */ | |
| 529 | 16, /* bits per sample */ | |
| 530 | 7200 /* sample frequency */ | |
| 531 | }; | |
| 532 | ||
| 533 | static const cassette_config pmd85_cassette_config = | |
| 534 | { | |
| 535 | pmd85_pmd_format, | |
| 536 | &pmd85_cassette_options, | |
| 537 | CASSETTE_STOPPED | CASSETTE_SPEAKER_ENABLED | |
| 538 | }; | |
| 539 | ||
| 540 | ||
| 526 | 541 | /* machine definition */ |
| 527 | 542 | static MACHINE_DRIVER_START( pmd85 ) |
| 528 | 543 | /* basic machine hardware */ |
| r3218 | r3219 | |
| 551 | 566 | |
| 552 | 567 | /* sound hardware */ |
| 553 | 568 | MDRV_SPEAKER_STANDARD_MONO("mono") |
| 554 | MDRV_SOUND_ADD(" | |
| 569 | MDRV_SOUND_ADD("cassette", WAVE, 0) | |
| 555 | 570 | MDRV_SOUND_ROUTE(ALL_OUTPUTS, "mono", 0.50) |
| 571 | ||
| 572 | MDRV_CASSETTE_ADD( "cassette", pmd85_cassette_config ) | |
| 556 | 573 | MACHINE_DRIVER_END |
| 557 | 574 | |
| 558 | 575 | static MACHINE_DRIVER_START( pmd851 ) |
| r3218 | r3219 | |
| 681 | 698 | ROM_LOAD("c2717.rom", 0x10000, 0x4000, CRC(da1703b1) SHA1(9fb93e6cae8b551064c7175bf3b4e3113429ce73)) |
| 682 | 699 | ROM_END |
| 683 | 700 | |
| 684 | static const struct CassetteOptions pmd85_cassette_options = { | |
| 685 | 1, /* channels */ | |
| 686 | 16, /* bits per sample */ | |
| 687 | 7200 /* sample frequency */ | |
| 688 | }; | |
| 689 | 701 | |
| 690 | static void pmd85_cassette_getinfo(const mess_device_class *devclass, UINT32 state, union devinfo *info) | |
| 691 | { | |
| 692 | /* cassette */ | |
| 693 | switch(state) | |
| 694 | { | |
| 695 | /* --- the following bits of info are returned as 64-bit signed integers --- */ | |
| 696 | case MESS_DEVINFO_INT_COUNT: info->i = 1; break; | |
| 697 | ||
| 698 | /* --- the following bits of info are returned as pointers to data or functions --- */ | |
| 699 | case MESS_DEVINFO_PTR_CASSETTE_FORMATS: info->p = (void *) pmd85_pmd_format; break; | |
| 700 | case MESS_DEVINFO_PTR_CASSETTE_OPTIONS: info->p = (void *) &pmd85_cassette_options; break; | |
| 701 | ||
| 702 | /* --- the following bits of info are returned as 64-bit signed integers --- */ | |
| 703 | case MESS_DEVINFO_INT_CASSETTE_DEFAULT_STATE: info->i = CASSETTE_STOPPED | CASSETTE_SPEAKER_ENABLED; break; | |
| 704 | ||
| 705 | default: cassette_device_getinfo(devclass, state, info); break; | |
| 706 | } | |
| 707 | } | |
| 708 | ||
| 709 | 702 | static SYSTEM_CONFIG_START(pmd85) |
| 710 | 703 | CONFIG_RAM_DEFAULT(64 * 1024) |
| 711 | CONFIG_DEVICE(pmd85_cassette_getinfo) | |
| 712 | 704 | SYSTEM_CONFIG_END |
| 713 | 705 | |
| 714 | 706 |
| r3218 | r3219 | |
|---|---|---|
| 92 | 92 | |
| 93 | 93 | static emu_timer *abc80_keyboard_timer; |
| 94 | 94 | |
| 95 | static const device_config *cassette_device_image( | |
| 95 | static const device_config *cassette_device_image(running_machine *machine) | |
| 96 | 96 | { |
| 97 | return | |
| 97 | return | |
| 98 | 98 | } |
| 99 | 99 | |
| 100 | 100 | /* Read/Write Handlers */ |
| r3218 | r3219 | |
| 468 | 468 | |
| 469 | 469 | */ |
| 470 | 470 | |
| 471 | UINT8 data = (cassette_input(cassette_device_image()) > +1.0) ? 0x80 : 0; | |
| 471 | UINT8 data = (cassette_input(cassette_device_image(machine)) > +1.0) ? 0x80 : 0; | |
| 472 | 472 | |
| 473 | 473 | return data; |
| 474 | 474 | }; |
| r3218 | r3219 | |
| 490 | 490 | |
| 491 | 491 | */ |
| 492 | 492 | |
| 493 | cassette_change_state(cassette_device_image(), BIT(data, 5) ? CASSETTE_MOTOR_ENABLED : CASSETTE_MOTOR_DISABLED, CASSETTE_MASK_MOTOR); | |
| 493 | cassette_change_state(cassette_device_image(machine), BIT(data, 5) ? CASSETTE_MOTOR_ENABLED : CASSETTE_MOTOR_DISABLED, CASSETTE_MASK_MOTOR); | |
| 494 | 494 | |
| 495 | cassette_output(cassette_device_image(), BIT(data, 7) ? -1.0 : +1.0); | |
| 495 | cassette_output(cassette_device_image(machine), BIT(data, 7) ? -1.0 : +1.0); | |
| 496 | 496 | }; |
| 497 | 497 | |
| 498 | 498 | static const z80pio_interface abc80_pio_intf = |
| r3218 | r3219 | |
| 574 | 574 | |
| 575 | 575 | // printer device |
| 576 | 576 | MDRV_DEVICE_ADD("printer", PRINTER) |
| 577 | ||
| 578 | MDRV_CASSETTE_ADD( "cassette", default_cassette_config ) | |
| 577 | 579 | MACHINE_DRIVER_END |
| 578 | 580 | |
| 579 | 581 | /* ROMs */ |
| r3218 | r3219 | |
| 610 | 612 | |
| 611 | 613 | /* System Configuration */ |
| 612 | 614 | |
| 613 | static void abc80_cassette_getinfo(const mess_device_class *devclass, UINT32 state, union devinfo *info) | |
| 614 | { | |
| 615 | // cassette | |
| 616 | switch(state) | |
| 617 | { | |
| 618 | /* --- the following bits of info are returned as 64-bit signed integers --- */ | |
| 619 | case MESS_DEVINFO_INT_COUNT: info->i = 1; break; | |
| 620 | ||
| 621 | default: cassette_device_getinfo(devclass, state, info); break; | |
| 622 | } | |
| 623 | } | |
| 624 | ||
| 625 | 615 | static void abc80_floppy_getinfo(const mess_device_class *devclass, UINT32 state, union devinfo *info) |
| 626 | 616 | { |
| 627 | 617 | /* floppy */ |
| r3218 | r3219 | |
| 643 | 633 | static SYSTEM_CONFIG_START( abc80 ) |
| 644 | 634 | CONFIG_RAM_DEFAULT(16 * 1024) |
| 645 | 635 | CONFIG_RAM (32 * 1024) |
| 646 | CONFIG_DEVICE(abc80_cassette_getinfo) | |
| 647 | 636 | CONFIG_DEVICE(abc80_floppy_getinfo) |
| 648 | 637 | SYSTEM_CONFIG_END |
| 649 | 638 |
| r3218 | r3219 | |
|---|---|---|
| 189 | 189 | if ((Changed & (1<<3))!=0) |
| 190 | 190 | { |
| 191 | 191 | /* write cassette data */ |
| 192 | cassette_output( | |
| 192 | cassette_output( | |
| 193 | 193 | } |
| 194 | 194 | |
| 195 | 195 | PreviousFE = data; |
| r3218 | r3219 | |
| 260 | 260 | data |= (0xe0); /* Set bits 5-7 - as reset above */ |
| 261 | 261 | |
| 262 | 262 | /* cassette input from wav */ |
| 263 | if (cassette_input( | |
| 263 | if (cassette_input( | |
| 264 | 264 | { |
| 265 | 265 | data &= ~0x40; |
| 266 | 266 | } |
| r3218 | r3219 | |
| 446 | 446 | cpunum_set_input_line(machine, 0, 0, HOLD_LINE); |
| 447 | 447 | } |
| 448 | 448 | |
| 449 | static const cassette_config spectrum_cassette_config = | |
| 450 | { | |
| 451 | tzx_cassette_formats, | |
| 452 | NULL, | |
| 453 | CASSETTE_STOPPED | CASSETTE_SPEAKER_ENABLED | CASSETTE_MOTOR_ENABLED | |
| 454 | }; | |
| 455 | ||
| 449 | 456 | MACHINE_DRIVER_START( spectrum ) |
| 450 | 457 | /* basic machine hardware */ |
| 451 | 458 | MDRV_CPU_ADD("main", Z80, 3500000) /* 3.5 Mhz */ |
| r3218 | r3219 | |
| 473 | 480 | |
| 474 | 481 | /* sound hardware */ |
| 475 | 482 | MDRV_SPEAKER_STANDARD_MONO("mono") |
| 476 | MDRV_SOUND_ADD(" | |
| 483 | MDRV_SOUND_ADD("cassette", WAVE, 0) | |
| 477 | 484 | MDRV_SOUND_ROUTE(ALL_OUTPUTS, "mono", 0.25) |
| 478 | 485 | MDRV_SOUND_ADD("speaker", SPEAKER, 0) |
| 479 | 486 | MDRV_SOUND_ROUTE(ALL_OUTPUTS, "mono", 0.50) |
| r3218 | r3219 | |
| 481 | 488 | /* devices */ |
| 482 | 489 | MDRV_SNAPSHOT_ADD(spectrum, "sna,z80,sp", 0) |
| 483 | 490 | MDRV_QUICKLOAD_ADD(spectrum, "scr", 0) |
| 491 | ||
| 492 | MDRV_CASSETTE_ADD( "cassette", spectrum_cassette_config ) | |
| 484 | 493 | MACHINE_DRIVER_END |
| 485 | 494 | |
| 486 | 495 | /*************************************************************************** |
| r3218 | r3219 | |
| 526 | 535 | ROM_CART_LOAD(0, "rom", 0x0000, 0x4000, ROM_NOCLEAR | ROM_NOMIRROR | ROM_OPTIONAL) |
| 527 | 536 | ROM_END |
| 528 | 537 | |
| 529 | static void spectrum_common_cassette_getinfo(const mess_device_class *devclass, UINT32 state, union devinfo *info) | |
| 530 | { | |
| 531 | /* cassette */ | |
| 532 | switch(state) | |
| 533 | { | |
| 534 | /* --- the following bits of info are returned as 64-bit signed integers --- */ | |
| 535 | case MESS_DEVINFO_INT_COUNT: info->i = 1; break; | |
| 536 | case MESS_DEVINFO_INT_CASSETTE_DEFAULT_STATE: info->i = CASSETTE_STOPPED | CASSETTE_SPEAKER_ENABLED | CASSETTE_MOTOR_ENABLED; break; | |
| 537 | case MESS_DEVINFO_PTR_CASSETTE_FORMATS: info->p = (void *)tzx_cassette_formats; break; | |
| 538 | default: cassette_device_getinfo(devclass, state, info); break; | |
| 539 | } | |
| 540 | } | |
| 541 | ||
| 542 | SYSTEM_CONFIG_START(spectrum_common) | |
| 543 | CONFIG_DEVICE(spectrum_common_cassette_getinfo) | |
| 544 | SYSTEM_CONFIG_END | |
| 545 | ||
| 546 | 538 | SYSTEM_CONFIG_START(spectrum) |
| 547 | CONFIG_IMPORT_FROM(spectrum_common) | |
| 548 | 539 | CONFIG_DEVICE(cartslot_device_getinfo) |
| 549 | 540 | SYSTEM_CONFIG_END |
| 550 | 541 |
| r3218 | r3219 | |
|---|---|---|
| 365 | 365 | |
| 366 | 366 | /**************************** CASSETTE ROUTINES *****************************************************************/ |
| 367 | 367 | |
| 368 | static const device_config *cassette_device_image( | |
| 368 | static const device_config *cassette_device_image(running_machine *machine) | |
| 369 | 369 | { |
| 370 | return | |
| 370 | return | |
| 371 | 371 | } |
| 372 | 372 | |
| 373 | 373 | static void cassette_motor( running_machine *machine, UINT8 data ) |
| 374 | 374 | { |
| 375 | 375 | if (data) |
| 376 | cassette_change_state( | |
| 376 | cassette_change_state(c | |
| 377 | 377 | else |
| 378 | cassette_change_state( | |
| 378 | cassette_change_state(c | |
| 379 | 379 | |
| 380 | 380 | /* does user want to hear the sound? */ |
| 381 | 381 | if (input_port_read(machine, "CONFIG") & 8) |
| 382 | cassette_change_state( | |
| 382 | cassette_change_state(c | |
| 383 | 383 | else |
| 384 | cassette_change_state( | |
| 384 | cassette_change_state(c | |
| 385 | 385 | } |
| 386 | 386 | |
| 387 | 387 | /********************************************* TIMER ************************************************/ |
| r3218 | r3219 | |
| 413 | 413 | z80pio_p_w(machine,0,1,in_fa); |
| 414 | 414 | |
| 415 | 415 | cass_data[1]++; |
| 416 | cass_ws = (cassette_input(cassette_device_image()) > +0.03) ? 4 : 0; | |
| 416 | cass_ws = (cassette_input(cassette_device_image(machine)) > +0.03) ? 4 : 0; | |
| 417 | 417 | |
| 418 | 418 | if (cass_ws != cass_data[0]) |
| 419 | 419 | { |
| r3218 | r3219 | |
| 464 | 464 | speaker_level_w(0, (data & 8) ? 0 : 1); /* bit 3 - speaker */ |
| 465 | 465 | super80_mhz = (data & 4) ? 1 : 2; /* bit 2 - video on/off */ |
| 466 | 466 | if (bits & 0x02) cassette_motor( machine, data & 2 ? 1 : 0); /* bit 1 - cassette motor */ |
| 467 | if (bits & 0x01) cassette_output(cassette_device_image(), (data & 1) ? -1.0 : +1.0); /* bit 0 - cass out */ | |
| 467 | if (bits & 0x01) cassette_output(cassette_device_image(machine), (data & 1) ? -1.0 : +1.0); /* bit 0 - cass out */ | |
| 468 | 468 | |
| 469 | 469 | last_data = data; |
| 470 | 470 | } |
| r3218 | r3219 | |
| 476 | 476 | if (bits & 0x20) set_led_status(2,(data & 32) ? 0 : 1); /* bit 5 - LED - scroll lock led is used */ |
| 477 | 477 | speaker_level_w(0, (data & 8) ? 0 : 1); /* bit 3 - speaker */ |
| 478 | 478 | if (bits & 0x02) cassette_motor( machine, data & 2 ? 1 : 0); /* bit 1 - cassette motor */ |
| 479 | if (bits & 0x01) cassette_output(cassette_device_image(), (data & 1) ? -1.0 : +1.0); /* bit 0 - cass out */ | |
| 479 | if (bits & 0x01) cassette_output(cassette_device_image(machine), (data & 1) ? -1.0 : +1.0); /* bit 0 - cass out */ | |
| 480 | 480 | |
| 481 | 481 | last_data = data; |
| 482 | 482 | } |
| r3218 | r3219 | |
| 490 | 490 | speaker_level_w(0, (data & 8) ? 0 : 1); /* bit 3 - speaker */ |
| 491 | 491 | super80v_vid_col = data & 4; /* bit 2 - bankswitch video or colour ram */ |
| 492 | 492 | if (bits & 0x02) cassette_motor( machine, data & 2 ? 1 : 0); /* bit 1 - cassette motor */ |
| 493 | if (bits & 0x01) cassette_output(cassette_device_image(), (data & 1) ? -1.0 : +1.0); /* bit 0 - cass out */ | |
| 493 | if (bits & 0x01) cassette_output(cassette_device_image(machine), (data & 1) ? -1.0 : +1.0); /* bit 0 - cass out */ | |
| 494 | 494 | |
| 495 | 495 | last_data = data; |
| 496 | 496 | } |
| r3218 | r3219 | |
| 926 | 926 | memory_set_bank(1, 1); |
| 927 | 927 | } |
| 928 | 928 | |
| 929 | static const cassette_config super80_cassette_config = | |
| 930 | { | |
| 931 | cassette_default_formats, | |
| 932 | NULL, | |
| 933 | CASSETTE_STOPPED | CASSETTE_MOTOR_DISABLED | CASSETTE_SPEAKER_ENABLED | |
| 934 | }; | |
| 935 | ||
| 929 | 936 | static MACHINE_DRIVER_START( super80 ) |
| 930 | 937 | /* basic machine hardware */ |
| 931 | 938 | MDRV_CPU_ADD("main", Z80, MASTER_CLOCK/6) /* 2 Mhz */ |
| r3218 | r3219 | |
| 947 | 954 | |
| 948 | 955 | /* sound hardware */ |
| 949 | 956 | MDRV_SPEAKER_STANDARD_MONO("mono") |
| 950 | MDRV_SOUND_ADD(" | |
| 957 | MDRV_SOUND_ADD("cassette", WAVE, 0) | |
| 951 | 958 | MDRV_SOUND_ROUTE(ALL_OUTPUTS, "mono", 0.25) |
| 952 | 959 | MDRV_SOUND_ADD("speaker", SPEAKER, 0) |
| 953 | 960 | MDRV_SOUND_ROUTE(ALL_OUTPUTS, "mono", 0.50) |
| 954 | 961 | |
| 955 | 962 | /* quickload */ |
| 956 | 963 | MDRV_Z80BIN_QUICKLOAD_ADD(default, 1) |
| 964 | ||
| 965 | MDRV_CASSETTE_ADD( "cassette", super80_cassette_config ) | |
| 957 | 966 | MACHINE_DRIVER_END |
| 958 | 967 | |
| 959 | 968 | static MACHINE_DRIVER_START( super80d ) |
| r3218 | r3219 | |
| 996 | 1005 | |
| 997 | 1006 | /* sound hardware */ |
| 998 | 1007 | MDRV_SPEAKER_STANDARD_MONO("mono") |
| 999 | MDRV_SOUND_ADD(" | |
| 1008 | MDRV_SOUND_ADD("cassette", WAVE, 0) | |
| 1000 | 1009 | MDRV_SOUND_ROUTE(ALL_OUTPUTS, "mono", 0.25) |
| 1001 | 1010 | MDRV_SOUND_ADD("speaker", SPEAKER, 0) |
| 1002 | 1011 | MDRV_SOUND_ROUTE(ALL_OUTPUTS, "mono", 0.50) |
| 1003 | 1012 | |
| 1004 | 1013 | /* quickload */ |
| 1005 | 1014 | MDRV_Z80BIN_QUICKLOAD_ADD(default, 1) |
| 1015 | ||
| 1016 | MDRV_CASSETTE_ADD( "cassette", super80_cassette_config ) | |
| 1006 | 1017 | MACHINE_DRIVER_END |
| 1007 | 1018 | |
| 1008 | 1019 | static MACHINE_DRIVER_START( super80r ) |
| r3218 | r3219 | |
| 1140 | 1151 | } |
| 1141 | 1152 | } |
| 1142 | 1153 | |
| 1143 | static void super80_cassette_getinfo(const mess_device_class *devclass, UINT32 state, union devinfo *info) | |
| 1144 | { | |
| 1145 | /* cassette */ | |
| 1146 | switch(state) | |
| 1147 | { | |
| 1148 | /* --- the following bits of info are returned as 64-bit signed integers --- */ | |
| 1149 | case MESS_DEVINFO_INT_COUNT: info->i = 1; break; | |
| 1150 | case MESS_DEVINFO_INT_CASSETTE_DEFAULT_STATE:info->i = CASSETTE_STOPPED | CASSETTE_MOTOR_DISABLED | CASSETTE_SPEAKER_ENABLED; break; | |
| 1151 | ||
| 1152 | default: cassette_device_getinfo(devclass, state, info); break; | |
| 1153 | } | |
| 1154 | } | |
| 1155 | ||
| 1156 | 1154 | static SYSTEM_CONFIG_START(super80) |
| 1157 | CONFIG_DEVICE(super80_cassette_getinfo) | |
| 1158 | 1155 | CONFIG_DEVICE(super80_cartslot_getinfo) |
| 1159 | 1156 | SYSTEM_CONFIG_END |
| 1160 | 1157 |
| r3218 | r3219 | |
|---|---|---|
| 21 | 21 | |
| 22 | 22 | */ |
| 23 | 23 | |
| 24 | static const device_config *cassette_device_image( | |
| 24 | static const device_config *cassette_device_image(running_machine *machine) | |
| 25 | 25 | { |
| 26 | return | |
| 26 | return | |
| 27 | 27 | } |
| 28 | 28 | |
| 29 | 29 | /* Terebi Oekaki (TV Draw) */ |
| r3218 | r3219 | |
| 398 | 398 | |
| 399 | 399 | /* cassette */ |
| 400 | 400 | |
| 401 | if (cassette_input(cassette_device_image()) > +0.0) data |= 0x80; | |
| 401 | if (cassette_input(cassette_device_image(machine)) > +0.0) data |= 0x80; | |
| 402 | 402 | |
| 403 | 403 | return data; |
| 404 | 404 | } |
| r3218 | r3219 | |
| 424 | 424 | |
| 425 | 425 | /* cassette */ |
| 426 | 426 | |
| 427 | cassette_output(cassette_device_image(), BIT(data, 4) ? +1.0 : -1.0); | |
| 427 | cassette_output(cassette_device_image(machine), BIT(data, 4) ? +1.0 : -1.0); | |
| 428 | 428 | |
| 429 | 429 | /* printer */ |
| 430 | 430 | } |
| r3218 | r3219 | |
| 616 | 616 | MDRV_SOUND_ROUTE(ALL_OUTPUTS, "mono", 1.00) |
| 617 | 617 | MACHINE_DRIVER_END |
| 618 | 618 | |
| 619 | static const cassette_config sc3000_cassette_config = | |
| 620 | { | |
| 621 | cassette_default_formats, | |
| 622 | NULL, | |
| 623 | CASSETTE_STOPPED | CASSETTE_MOTOR_ENABLED | CASSETTE_SPEAKER_ENABLED | |
| 624 | }; | |
| 625 | ||
| 619 | 626 | static MACHINE_DRIVER_START( sc3000 ) |
| 620 | 627 | // basic machine hardware |
| 621 | 628 | MDRV_CPU_ADD("main", Z80, XTAL_10_738635MHz/3) |
| r3218 | r3219 | |
| 641 | 648 | |
| 642 | 649 | /* printer */ |
| 643 | 650 | MDRV_DEVICE_ADD("printer", PRINTER) |
| 651 | ||
| 652 | MDRV_CASSETTE_ADD( "cassette", sc3000_cassette_config ) | |
| 644 | 653 | MACHINE_DRIVER_END |
| 645 | 654 | |
| 646 | 655 | static MACHINE_DRIVER_START( sf7000 ) |
| r3218 | r3219 | |
| 673 | 682 | /* printer */ |
| 674 | 683 | MDRV_DEVICE_ADD("printer", PRINTER) |
| 675 | 684 | MDRV_DEVICE_ADD("sp400", PRINTER) |
| 685 | ||
| 686 | MDRV_CASSETTE_ADD( "cassette", sc3000_cassette_config ) | |
| 676 | 687 | MACHINE_DRIVER_END |
| 677 | 688 | |
| 678 | 689 | /* ROMs */ |
| r3218 | r3219 | |
| 812 | 823 | } |
| 813 | 824 | } |
| 814 | 825 | |
| 815 | static void sc3000_cassette_getinfo(const mess_device_class *devclass, UINT32 state, union devinfo *info) | |
| 816 | { | |
| 817 | switch(state) | |
| 818 | { | |
| 819 | case MESS_DEVINFO_INT_COUNT: info->i = 1; break; | |
| 820 | case MESS_DEVINFO_INT_CASSETTE_DEFAULT_STATE: info->i = CASSETTE_STOPPED | CASSETTE_MOTOR_ENABLED | CASSETTE_SPEAKER_ENABLED; break; | |
| 821 | ||
| 822 | default: cassette_device_getinfo(devclass, state, info); break; | |
| 823 | } | |
| 824 | } | |
| 825 | ||
| 826 | 826 | static DEVICE_IMAGE_LOAD( sf7000_floppy ) |
| 827 | 827 | { |
| 828 | 828 | if (image_has_been_created(image)) |
| r3218 | r3219 | |
| 901 | 901 | |
| 902 | 902 | static SYSTEM_CONFIG_START( sc3000 ) |
| 903 | 903 | CONFIG_DEVICE(sc3000_cartslot_getinfo) |
| 904 | CONFIG_DEVICE(sc3000_cassette_getinfo) | |
| 905 | 904 | SYSTEM_CONFIG_END |
| 906 | 905 | |
| 907 | 906 | static SYSTEM_CONFIG_START( sf7000 ) |
| 908 | 907 | CONFIG_RAM_DEFAULT (64 * 1024) |
| 909 | CONFIG_DEVICE(sc3000_cassette_getinfo) | |
| 910 | 908 | CONFIG_DEVICE(sf7000_floppy_getinfo) |
| 911 | 909 | CONFIG_DEVICE(sf7000_serial_getinfo) |
| 912 | 910 | SYSTEM_CONFIG_END |
| r3218 | r3219 | |
|---|---|---|
| 597 | 597 | |
| 598 | 598 | /* devices */ |
| 599 | 599 | MDRV_QUICKLOAD_ADD(cbm_c64, "p00,prg", CBM_QUICKLOAD_DELAY_SECONDS) |
| 600 | ||
| 601 | MDRV_CASSETTE_ADD( "cassette", cbm_cassette_config ) | |
| 600 | 602 | MACHINE_DRIVER_END |
| 601 | 603 | |
| 602 | 604 | |
| r3218 | r3219 | |
| 834 | 836 | static SYSTEM_CONFIG_START(c128) |
| 835 | 837 | CONFIG_DEVICE(c64_cartslot_getinfo) |
| 836 | 838 | CONFIG_DEVICE(cbmfloppy_device_getinfo) |
| 837 | CONFIG_DEVICE(datasette_device_getinfo) | |
| 838 | 839 | SYSTEM_CONFIG_END |
| 839 | 840 | |
| 840 | 841 | static SYSTEM_CONFIG_START(c128d) |
| 841 | 842 | CONFIG_DEVICE(c64_cartslot_getinfo) |
| 842 | 843 | CONFIG_DEVICE(c1571_device_getinfo) |
| 843 | CONFIG_DEVICE(datasette_device_getinfo) | |
| 844 | 844 | SYSTEM_CONFIG_END |
| 845 | 845 | |
| 846 | 846 |
| r3218 | r3219 | |
|---|---|---|
| 412 | 412 | INPUT_PORTS_END |
| 413 | 413 | |
| 414 | 414 | |
| 415 | static const cassette_config lviv_cassette_config = | |
| 416 | { | |
| 417 | lviv_lvt_format, | |
| 418 | NULL, | |
| 419 | CASSETTE_STOPPED | CASSETTE_SPEAKER_ENABLED | |
| 420 | }; | |
| 415 | 421 | |
| 422 | ||
| 416 | 423 | /* machine definition */ |
| 417 | 424 | static MACHINE_DRIVER_START( lviv ) |
| 418 | 425 | /* basic machine hardware */ |
| r3218 | r3219 | |
| 445 | 452 | |
| 446 | 453 | /* sound hardware */ |
| 447 | 454 | MDRV_SPEAKER_STANDARD_MONO("mono") |
| 448 | MDRV_SOUND_ADD(" | |
| 455 | MDRV_SOUND_ADD("cassette", WAVE, 0) | |
| 449 | 456 | MDRV_SOUND_ROUTE(ALL_OUTPUTS, "mono", 0.50) |
| 450 | 457 | MDRV_SOUND_ADD("speaker", SPEAKER, 0) |
| 451 | 458 | MDRV_SOUND_ROUTE(ALL_OUTPUTS, "mono", 0.50) |
| 452 | 459 | |
| 453 | 460 | /* snapshot */ |
| 454 | 461 | MDRV_SNAPSHOT_ADD(lviv, "sav", 0) |
| 462 | ||
| 463 | MDRV_CASSETTE_ADD( "cassette", lviv_cassette_config ) | |
| 455 | 464 | MACHINE_DRIVER_END |
| 456 | 465 | |
| 457 | 466 | |
| 458 | static void lviv_cassette_getinfo(const mess_device_class *devclass, UINT32 state, union devinfo *info) | |
| 459 | { | |
| 460 | /* cassette */ | |
| 461 | switch(state) | |
| 462 | { | |
| 463 | /* --- the following bits of info are returned as 64-bit signed integers --- */ | |
| 464 | case MESS_DEVINFO_INT_COUNT: info->i = 1; break; | |
| 465 | ||
| 466 | /* --- the following bits of info are returned as pointers to data or functions --- */ | |
| 467 | case MESS_DEVINFO_PTR_CASSETTE_FORMATS: info->p = (void *) lviv_lvt_format; break; | |
| 468 | ||
| 469 | /* --- the following bits of info are returned as 64-bit signed integers --- */ | |
| 470 | case MESS_DEVINFO_INT_CASSETTE_DEFAULT_STATE: info->i = CASSETTE_STOPPED | CASSETTE_SPEAKER_ENABLED; break; | |
| 471 | ||
| 472 | default: cassette_device_getinfo(devclass, state, info); break; | |
| 473 | } | |
| 474 | } | |
| 475 | ||
| 476 | 467 | ROM_START(lviv) |
| 477 | 468 | ROM_REGION(0x14000,"main",0) |
| 478 | 469 | ROM_SYSTEM_BIOS( 0, "lviv", "Lviv/L'vov" ) |
| r3218 | r3219 | |
| 485 | 476 | |
| 486 | 477 | static SYSTEM_CONFIG_START(lviv) |
| 487 | 478 | CONFIG_RAM_DEFAULT(64 * 1024) |
| 488 | /* 9-Oct-2003 - Changed to lvt because lv? is an invalid file extension */ | |
| 489 | CONFIG_DEVICE(lviv_cassette_getinfo) | |
| 490 | 479 | SYSTEM_CONFIG_END |
| 491 | 480 | |
| 492 | 481 |
| r3218 | r3219 | |
|---|---|---|
| 195 | 195 | static emu_timer *cassette_timer; |
| 196 | 196 | |
| 197 | 197 | |
| 198 | static const device_config *cassette_device_image( | |
| 198 | static const device_config *cassette_device_image(running_machine *machine) | |
| 199 | 199 | { |
| 200 | 200 | if (exidy_fe & 0x20) |
| 201 | return | |
| 201 | return | |
| 202 | 202 | else |
| 203 | return | |
| 203 | return | |
| 204 | 204 | } |
| 205 | 205 | |
| 206 | 206 | static UINT8 cass_data[]={ 0, 0, 0, 0, 0, 0, 0 }; |
| r3218 | r3219 | |
| 217 | 217 | |
| 218 | 218 | cass_data[1]++; |
| 219 | 219 | |
| 220 | cass_ws = (cassette_input(cassette_device_image()) > +0.02) ? 1 : 0; | |
| 220 | cass_ws = (cassette_input(cassette_device_image(machine)) > +0.02) ? 1 : 0; | |
| 221 | 221 | |
| 222 | 222 | if (cass_ws != cass_data[0]) |
| 223 | 223 | { |
| r3218 | r3219 | |
| 250 | 250 | if (!((cass_data[4] == 0) && (cass_data[5] & 4))) |
| 251 | 251 | { |
| 252 | 252 | cass_data[6] ^= 1; // toggle output state, except on 2nd half of low bit |
| 253 | cassette_output(cassette_device_image(), cass_data[6] ? -1.0 : +1.0); | |
| 253 | cassette_output(cassette_device_image(machine), cass_data[6] ? -1.0 : +1.0); | |
| 254 | 254 | } |
| 255 | 255 | } |
| 256 | 256 | return; |
| r3218 | r3219 | |
| 259 | 259 | /* loading a tape */ |
| 260 | 260 | cass_data[1]++; |
| 261 | 261 | |
| 262 | cass_ws = (cassette_input(cassette_device_image()) > +0.02) ? 1 : 0; | |
| 262 | cass_ws = (cassette_input(cassette_device_image(machine)) > +0.02) ? 1 : 0; | |
| 263 | 263 | |
| 264 | 264 | if (cass_ws != cass_data[0]) |
| 265 | 265 | { |
| r3218 | r3219 | |
| 292 | 292 | if (!((cass_data[4] == 0) && (cass_data[5] & 8))) |
| 293 | 293 | { |
| 294 | 294 | cass_data[6] ^= 1; // toggle output state, except on 2nd half of low bit |
| 295 | cassette_output(cassette_device_image(), cass_data[6] ? -1.0 : +1.0); | |
| 295 | cassette_output(cassette_device_image(machine), cass_data[6] ? -1.0 : +1.0); | |
| 296 | 296 | } |
| 297 | 297 | } |
| 298 | 298 | return; |
| r3218 | r3219 | |
| 424 | 424 | { |
| 425 | 425 | if (data & 0x20) |
| 426 | 426 | { |
| 427 | cassette_change_state(image_from_devtype_and_index(IO_CASSETTE, 0), CASSETTE_SPEAKER_MUTED, CASSETTE_MASK_SPEAKER); | |
| 428 | cassette_change_state(image_from_devtype_and_index(IO_CASSETTE, 1), CASSETTE_SPEAKER_ENABLED, CASSETTE_MASK_SPEAKER); | |
| 427 | cassette_change_state(device_list_find_by_tag( machine->config->devicelist, CASSETTE, "cassette1" ), CASSETTE_SPEAKER_MUTED, CASSETTE_MASK_SPEAKER); | |
| 428 | cassette_change_state(device_list_find_by_tag( machine->config->devicelist, CASSETTE, "cassette2" ), CASSETTE_SPEAKER_ENABLED, CASSETTE_MASK_SPEAKER); | |
| 429 | 429 | } |
| 430 | 430 | else |
| 431 | 431 | { |
| 432 | cassette_change_state(image_from_devtype_and_index(IO_CASSETTE, 1), CASSETTE_SPEAKER_MUTED, CASSETTE_MASK_SPEAKER); | |
| 433 | cassette_change_state(image_from_devtype_and_index(IO_CASSETTE, 0), CASSETTE_SPEAKER_ENABLED, CASSETTE_MASK_SPEAKER); | |
| 432 | cassette_change_state(device_list_find_by_tag( machine->config->devicelist, CASSETTE, "cassette2" ), CASSETTE_SPEAKER_MUTED, CASSETTE_MASK_SPEAKER); | |
| 433 | cassette_change_state(device_list_find_by_tag( machine->config->devicelist, CASSETTE, "cassette1" ), CASSETTE_SPEAKER_ENABLED, CASSETTE_MASK_SPEAKER); | |
| 434 | 434 | } |
| 435 | 435 | } |
| 436 | 436 | else |
| 437 | 437 | { |
| 438 | cassette_change_state(image_from_devtype_and_index(IO_CASSETTE, 1), CASSETTE_SPEAKER_MUTED, CASSETTE_MASK_SPEAKER); | |
| 439 | cassette_change_state(image_from_devtype_and_index(IO_CASSETTE, 0), CASSETTE_SPEAKER_MUTED, CASSETTE_MASK_SPEAKER); | |
| 438 | cassette_change_state(device_list_find_by_tag( machine->config->devicelist, CASSETTE, "cassette2" ), CASSETTE_SPEAKER_MUTED, CASSETTE_MASK_SPEAKER); | |
| 439 | cassette_change_state(device_list_find_by_tag( machine->config->devicelist, CASSETTE, "cassette1" ), CASSETTE_SPEAKER_MUTED, CASSETTE_MASK_SPEAKER); | |
| 440 | 440 | } |
| 441 | 441 | |
| 442 | 442 | /* cassette 1 motor */ |
| 443 | cassette_change_state( | |
| 443 | cassette_change_state( | |
| 444 | 444 | (data & 0x10) ? CASSETTE_MOTOR_ENABLED : CASSETTE_MOTOR_DISABLED, CASSETTE_MASK_MOTOR); |
| 445 | 445 | |
| 446 | 446 | /* cassette 2 motor */ |
| 447 | cassette_change_state( | |
| 447 | cassette_change_state( | |
| 448 | 448 | (data & 0x20) ? CASSETTE_MOTOR_ENABLED : CASSETTE_MOTOR_DISABLED, CASSETTE_MASK_MOTOR); |
| 449 | 449 | |
| 450 | 450 | if ((data & EXIDY_CASSETTE_MOTOR_MASK) && (~data & 0x80)) |
| r3218 | r3219 | |
| 720 | 720 | |
| 721 | 721 | /**********************************************************************************************************/ |
| 722 | 722 | |
| 723 | static const cassette_config exidy_cassette_config = | |
| 724 | { | |
| 725 | cassette_default_formats, | |
| 726 | NULL, | |
| 727 | CASSETTE_STOPPED | CASSETTE_MOTOR_DISABLED | CASSETTE_SPEAKER_ENABLED | |
| 728 | }; | |
| 729 | ||
| 730 | ||
| 723 | 731 | static MACHINE_DRIVER_START( exidy ) |
| 724 | 732 | /* basic machine hardware */ |
| 725 | 733 | MDRV_CPU_ADD("main", Z80, 12638000/6) |
| r3218 | r3219 | |
| 743 | 751 | |
| 744 | 752 | /* sound hardware */ |
| 745 | 753 | MDRV_SPEAKER_STANDARD_MONO("mono") |
| 746 | MDRV_SOUND_ADD("cass1", WAVE, 0) | |
| 754 | MDRV_SOUND_ADD("cassette1", WAVE, 0) | |
| 747 | 755 | MDRV_SOUND_ROUTE(ALL_OUTPUTS, "mono", 0.25) // cass1 speaker |
| 748 | MDRV_SOUND_ADD("cass2", WAVE, 1) | |
| 756 | MDRV_SOUND_ADD("cassette2", WAVE, 1) | |
| 749 | 757 | MDRV_SOUND_ROUTE(ALL_OUTPUTS, "mono", 0.25) // cass2 speaker |
| 750 | 758 | MDRV_SOUND_ADD("speaker", SPEAKER, 0) |
| 751 | 759 | MDRV_SOUND_ROUTE(ALL_OUTPUTS, "mono", 0.50) // speaker on parallel port |
| r3218 | r3219 | |
| 755 | 763 | |
| 756 | 764 | /* quickload */ |
| 757 | 765 | MDRV_Z80BIN_QUICKLOAD_ADD(exidy, 3) |
| 766 | ||
| 767 | MDRV_CASSETTE_ADD( "cassette1", exidy_cassette_config ) | |
| 768 | MDRV_CASSETTE_ADD( "cassette2", exidy_cassette_config ) | |
| 758 | 769 | MACHINE_DRIVER_END |
| 759 | 770 | |
| 760 | 771 | static MACHINE_DRIVER_START( exidyd ) |
| r3218 | r3219 | |
| 863 | 874 | } |
| 864 | 875 | } |
| 865 | 876 | |
| 866 | static void exidy_cassette_getinfo(const mess_device_class *devclass, UINT32 state, union devinfo *info) | |
| 867 | { | |
| 868 | /* cassette */ | |
| 869 | switch(state) | |
| 870 | { | |
| 871 | /* --- the following bits of info are returned as 64-bit signed integers --- */ | |
| 872 | case MESS_DEVINFO_INT_COUNT: info->i = 2; break; | |
| 873 | case MESS_DEVINFO_INT_CASSETTE_DEFAULT_STATE: info->i = CASSETTE_STOPPED | CASSETTE_MOTOR_DISABLED | CASSETTE_SPEAKER_ENABLED; break; | |
| 874 | 877 | |
| 875 | default: cassette_device_getinfo(devclass, state, info); break; | |
| 876 | } | |
| 877 | } | |
| 878 | ||
| 879 | 878 | static SYSTEM_CONFIG_START(exidy) |
| 880 | 879 | CONFIG_DEVICE(exidy_floppy_getinfo) |
| 881 | 880 | CONFIG_DEVICE(cartslot_device_getinfo) |
| 882 | CONFIG_DEVICE(exidy_cassette_getinfo) | |
| 883 | 881 | SYSTEM_CONFIG_END |
| 884 | 882 | |
| 885 | 883 | static SYSTEM_CONFIG_START(exidyd) |
| 886 | 884 | CONFIG_DEVICE(cartslot_device_getinfo) |
| 887 | CONFIG_DEVICE(exidy_cassette_getinfo) | |
| 888 | 885 | SYSTEM_CONFIG_END |
| 889 | 886 | |
| 890 | 887 |
| r3218 | r3219 | |
|---|---|---|
| 692 | 692 | } |
| 693 | 693 | |
| 694 | 694 | static SYSTEM_CONFIG_START(ts2068) |
| 695 | CONFIG_IMPORT_FROM(spectrum_common) | |
| 696 | 695 | CONFIG_DEVICE(ts2068_cartslot_getinfo) |
| 697 | 696 | CONFIG_RAM_DEFAULT(48 * 1024) |
| 698 | 697 | SYSTEM_CONFIG_END |
| r3218 | r3219 | |
|---|---|---|
| 663 | 663 | MDRV_PALETTE_INIT( pet ) |
| 664 | 664 | |
| 665 | 665 | MDRV_VIDEO_UPDATE( pet ) |
| 666 | ||
| 667 | MDRV_CASSETTE_ADD( "cassette1", default_cassette_config ) | |
| 668 | MDRV_CASSETTE_ADD( "cassette2", default_cassette_config ) | |
| 666 | 669 | MACHINE_DRIVER_END |
| 667 | 670 | |
| 668 | 671 | |
| r3218 | r3219 | |
| 1079 | 1082 | * |
| 1080 | 1083 | *************************************/ |
| 1081 | 1084 | |
| 1082 | void pet_datasette_getinfo(const mess_device_class *devclass, UINT32 state, union devinfo *info) | |
| 1083 | { | |
| 1084 | switch(state) | |
| 1085 | { | |
| 1086 | /* --- the following bits of info are returned as 64-bit signed integers --- */ | |
| 1087 | case MESS_DEVINFO_INT_COUNT: info->i = 2; break; | |
| 1088 | ||
| 1089 | default: datasette_device_getinfo(devclass, state, info); | |
| 1090 | } | |
| 1091 | } | |
| 1092 | ||
| 1093 | 1085 | /* Original PET 2001 - Basic 1 - RAM: 4k, 8k */ |
| 1094 | 1086 | static SYSTEM_CONFIG_START( pet2001 ) |
| 1095 | 1087 | CONFIG_DEVICE(pet_cartslot_getinfo) |
| 1096 | CONFIG_DEVICE(pet_datasette_getinfo) | |
| 1097 | 1088 | CONFIG_DEVICE(cbmfloppy_device_getinfo) |
| 1098 | 1089 | CONFIG_RAM(4 * 1024) |
| 1099 | 1090 | CONFIG_RAM_DEFAULT(8 * 1024) |
| r3218 | r3219 | |
| 1102 | 1093 | /* Later PET 2001 - Basic "2" - RAM: 8k, 16k, 32k */ |
| 1103 | 1094 | static SYSTEM_CONFIG_START( pet2 ) |
| 1104 | 1095 | CONFIG_DEVICE(pet_cartslot_getinfo) |
| 1105 | CONFIG_DEVICE(pet_datasette_getinfo) | |
| 1106 | 1096 | CONFIG_DEVICE(cbmfloppy_device_getinfo) |
| 1107 | 1097 | CONFIG_RAM(8 * 1024) |
| 1108 | 1098 | CONFIG_RAM(16 * 1024) |
| r3218 | r3219 | |
| 1112 | 1102 | /* Early PET 4000 - Basic 4 - RAM: 8k, 16k, 32k */ |
| 1113 | 1103 | static SYSTEM_CONFIG_START( pet4o ) |
| 1114 | 1104 | CONFIG_DEVICE(pet4_cartslot_getinfo) |
| 1115 | CONFIG_DEVICE(pet_datasette_getinfo) | |
| 1116 | 1105 | CONFIG_DEVICE(cbmfloppy_device_getinfo) |
| 1117 | 1106 | CONFIG_RAM(8 * 1024) |
| 1118 | 1107 | CONFIG_RAM(16 * 1024) |
| r3218 | r3219 | |
| 1122 | 1111 | /* Later PET 4000 / PET 8000 - Basic 4 - RAM: 32k expandable (expansion through DIPs currently) */ |
| 1123 | 1112 | static SYSTEM_CONFIG_START( pet4 ) |
| 1124 | 1113 | CONFIG_DEVICE(pet4_cartslot_getinfo) |
| 1125 | CONFIG_DEVICE(pet_datasette_getinfo) | |
| 1126 | 1114 | CONFIG_DEVICE(cbmfloppy_device_getinfo) |
| 1127 | 1115 | CONFIG_RAM_DEFAULT(32 * 1024) |
| 1128 | 1116 | SYSTEM_CONFIG_END |
| r3218 | r3219 | |
|---|---|---|
| 809 | 809 | |
| 810 | 810 | /* Check if we should stop the tape */ |
| 811 | 811 | if ( cpu_getactivecpu() >= 0 && activecpu_get_pc() == 0x00FD ) { |
| 812 | const device_config *img = | |
| 812 | const device_config *img = | |
| 813 | 813 | if ( img ) { |
| 814 | 814 | cassette_change_state(img, CASSETTE_MOTOR_DISABLED, CASSETTE_MASK_MOTOR); |
| 815 | 815 | } |
| 816 | 816 | } |
| 817 | 817 | } else if ( offset == 0xFF9 ) { |
| 818 | 818 | /* Cassette port read */ |
| 819 | double tap_val = cassette_input( | |
| 819 | double tap_val = cassette_input( | |
| 820 | 820 | //logerror("%04X: Cassette port read, tap_val = %f\n", activecpu_get_pc(), tap_val); |
| 821 | 821 | if ( tap_val < 0 ) { |
| 822 | 822 | data = 0x00; |
| r3218 | r3219 | |
| 1100 | 1100 | keypad_right_column = data & 0x0F; |
| 1101 | 1101 | break; |
| 1102 | 1102 | case 0x0a: /* KidVid voice module */ |
| 1103 | cassette_change_state( | |
| 1103 | cassette_change_state( | |
| 1104 | 1104 | break; |
| 1105 | 1105 | } |
| 1106 | 1106 | } |
| r3218 | r3219 | |
| 1746 | 1746 | modeSS_byte_started = 0; |
| 1747 | 1747 | memory_set_opbase_handler( 0, modeSS_opbase ); |
| 1748 | 1748 | /* Already start the motor of the cassette for the user */ |
| 1749 | cassette_change_state( | |
| 1749 | cassette_change_state( | |
| 1750 | 1750 | break; |
| 1751 | 1751 | |
| 1752 | 1752 | case modeFV: |
| r3218 | r3219 | |
| 1963 | 1963 | INPUT_PORTS_END |
| 1964 | 1964 | |
| 1965 | 1965 | |
| 1966 | static const cassette_config a2600_cassette_config = | |
| 1967 | { | |
| 1968 | a26_cassette_formats, | |
| 1969 | NULL, | |
| 1970 | CASSETTE_PLAY | CASSETTE_MOTOR_DISABLED | CASSETTE_SPEAKER_ENABLED | |
| 1971 | }; | |
| 1972 | ||
| 1973 | ||
| 1966 | 1974 | static MACHINE_DRIVER_START( a2600 ) |
| 1967 | 1975 | /* basic machine hardware */ |
| 1968 | 1976 | MDRV_CPU_ADD("main", M6502, MASTER_CLOCK_NTSC / 3) /* actually M6507 */ |
| r3218 | r3219 | |
| 1985 | 1993 | MDRV_SPEAKER_STANDARD_MONO("mono") |
| 1986 | 1994 | MDRV_SOUND_ADD("tia", TIA, MASTER_CLOCK_NTSC/114) |
| 1987 | 1995 | MDRV_SOUND_ROUTE(ALL_OUTPUTS, "mono", 0.90) |
| 1988 | MDRV_SOUND_ADD(" | |
| 1996 | MDRV_SOUND_ADD("cassette", WAVE, 0) | |
| 1989 | 1997 | MDRV_SOUND_ROUTE(ALL_OUTPUTS, "mono", 0.10) |
| 1990 | 1998 | |
| 1991 | 1999 | /* devices */ |
| 1992 | 2000 | MDRV_RIOT6532_ADD("riot", MASTER_CLOCK_NTSC / 3, r6532_interface) |
| 2001 | ||
| 2002 | MDRV_CASSETTE_ADD( "cassette", a2600_cassette_config ) | |
| 1993 | 2003 | MACHINE_DRIVER_END |
| 1994 | 2004 | |
| 2005 | ||
| 1995 | 2006 | static MACHINE_DRIVER_START( a2600p ) |
| 1996 | 2007 | /* basic machine hardware */ |
| 1997 | 2008 | MDRV_CPU_ADD("main", M6502, MASTER_CLOCK_PAL / 3) /* actually M6507 */ |
| r3218 | r3219 | |
| 2014 | 2025 | MDRV_SPEAKER_STANDARD_MONO("mono") |
| 2015 | 2026 | MDRV_SOUND_ADD("tia", TIA, MASTER_CLOCK_PAL/114) |
| 2016 | 2027 | MDRV_SOUND_ROUTE(ALL_OUTPUTS, "mono", 0.90) |
| 2017 | MDRV_SOUND_ADD(" | |
| 2028 | MDRV_SOUND_ADD("cassette", WAVE, 0) | |
| 2018 | 2029 | MDRV_SOUND_ROUTE(ALL_OUTPUTS, "mono", 0.10) |
| 2019 | 2030 | |
| 2020 | 2031 | /* devices */ |
| 2021 | 2032 | MDRV_RIOT6532_ADD("riot", MASTER_CLOCK_PAL / 3, r6532_interface) |
| 2033 | ||
| 2034 | MDRV_CASSETTE_ADD( "cassette", a2600_cassette_config ) | |
| 2022 | 2035 | MACHINE_DRIVER_END |
| 2023 | 2036 | |
| 2024 | 2037 | |
| r3218 | r3219 | |
| 2051 | 2064 | } |
| 2052 | 2065 | } |
| 2053 | 2066 | |
| 2054 | static void a2600_cassette_getinfo( const mess_device_class *devclass, UINT32 state, union devinfo *info ) { | |
| 2055 | switch( state ) { | |
| 2056 | case MESS_DEVINFO_INT_COUNT: | |
| 2057 | info->i = 1; | |
| 2058 | break; | |
| 2059 | case MESS_DEVINFO_INT_WRITEABLE: | |
| 2060 | info->i = 0; | |
| 2061 | break; | |
| 2062 | case MESS_DEVINFO_INT_CREATABLE: | |
| 2063 | info->i = 0; | |
| 2064 | break; | |
| 2065 | case MESS_DEVINFO_INT_CASSETTE_DEFAULT_STATE: | |
| 2066 | info->i = CASSETTE_PLAY | CASSETTE_MOTOR_DISABLED | CASSETTE_SPEAKER_ENABLED; | |
| 2067 | break; | |
| 2068 | case MESS_DEVINFO_PTR_CASSETTE_FORMATS: | |
| 2069 | info->p = (void *)a26_cassette_formats; | |
| 2070 | break; | |
| 2071 | default: | |
| 2072 | cassette_device_getinfo( devclass, state, info ); | |
| 2073 | break; | |
| 2074 | } | |
| 2075 | } | |
| 2076 | 2067 | |
| 2077 | 2068 | static SYSTEM_CONFIG_START(a2600) |
| 2078 | 2069 | CONFIG_DEVICE(a2600_cartslot_getinfo) |
| 2079 | CONFIG_DEVICE(a2600_cassette_getinfo) | |
| 2080 | 2070 | SYSTEM_CONFIG_END |
| 2081 | 2071 | |
| 2082 | 2072 |
| r3218 | r3219 | |
|---|---|---|
| 437 | 437 | |
| 438 | 438 | /* devices */ |
| 439 | 439 | MDRV_QUICKLOAD_ADD(cbm_c16, "p00,prg", CBM_QUICKLOAD_DELAY_SECONDS) |
| 440 | ||
| 441 | MDRV_CASSETTE_ADD( "cassette", cbm_cassette_config ) | |
| 440 | 442 | MACHINE_DRIVER_END |
| 441 | 443 | |
| 442 | 444 | |
| r3218 | r3219 | |
| 657 | 659 | static SYSTEM_CONFIG_START(c16) |
| 658 | 660 | CONFIG_DEVICE(c16_cartslot_getinfo) |
| 659 | 661 | CONFIG_DEVICE(cbmfloppy_device_getinfo) |
| 660 | CONFIG_DEVICE(datasette_device_getinfo) | |
| 661 | 662 | CONFIG_RAM(16 * 1024) |
| 662 | 663 | CONFIG_RAM(32 * 1024) |
| 663 | 664 | CONFIG_RAM_DEFAULT(64 * 1024) |
| r3218 | r3219 | |
| 665 | 666 | |
| 666 | 667 | static SYSTEM_CONFIG_START(c16c) |
| 667 | 668 | CONFIG_DEVICE(c16_cartslot_getinfo) |
| 668 | CONFIG_DEVICE(datasette_device_getinfo) | |
| 669 | 669 | CONFIG_DEVICE(c1551_device_getinfo) |
| 670 | 670 | CONFIG_RAM(16 * 1024) |
| 671 | 671 | CONFIG_RAM(32 * 1024) |
| r3218 | r3219 | |
| 674 | 674 | |
| 675 | 675 | static SYSTEM_CONFIG_START(c16v) |
| 676 | 676 | CONFIG_DEVICE(c16_cartslot_getinfo) |
| 677 | CONFIG_DEVICE(datasette_device_getinfo) | |
| 678 | 677 | CONFIG_DEVICE(vc1541_device_getinfo) |
| 679 | 678 | CONFIG_RAM(16 * 1024) |
| 680 | 679 | CONFIG_RAM(32 * 1024) |
| r3218 | r3219 | |
| 684 | 683 | static SYSTEM_CONFIG_START(plus) |
| 685 | 684 | CONFIG_DEVICE(c16_cartslot_getinfo) |
| 686 | 685 | CONFIG_DEVICE(cbmfloppy_device_getinfo) |
| 687 | CONFIG_DEVICE(datasette_device_getinfo) | |
| 688 | 686 | CONFIG_RAM_DEFAULT(64 * 1024) |
| 689 | 687 | SYSTEM_CONFIG_END |
| 690 | 688 | |
| 691 | 689 | static SYSTEM_CONFIG_START(plusc) |
| 692 | 690 | CONFIG_DEVICE(c16_cartslot_getinfo) |
| 693 | CONFIG_DEVICE(datasette_device_getinfo) | |
| 694 | 691 | CONFIG_DEVICE(c1551_device_getinfo) |
| 695 | 692 | CONFIG_RAM_DEFAULT(64 * 1024) |
| 696 | 693 | SYSTEM_CONFIG_END |
| 697 | 694 | |
| 698 | 695 | static SYSTEM_CONFIG_START(plusv) |
| 699 | 696 | CONFIG_DEVICE(c16_cartslot_getinfo) |
| 700 | CONFIG_DEVICE(datasette_device_getinfo) | |
| 701 | 697 | CONFIG_DEVICE(vc1541_device_getinfo) |
| 702 | 698 | CONFIG_RAM_DEFAULT(64 * 1024) |
| 703 | 699 | SYSTEM_CONFIG_END |
| r3218 | r3219 | |
|---|---|---|
| 343 | 343 | }; |
| 344 | 344 | |
| 345 | 345 | |
| 346 | static const cassette_config oric_cassette_config = | |
| 347 | { | |
| 348 | oric_cassette_formats, | |
| 349 | NULL, | |
| 350 | CASSETTE_PLAY | CASSETTE_MOTOR_DISABLED | |
| 351 | }; | |
| 352 | ||
| 346 | 353 | static MACHINE_DRIVER_START( oric ) |
| 347 | 354 | /* basic machine hardware */ |
| 348 | 355 | MDRV_CPU_ADD("main", M6502, 1000000) |
| r3218 | r3219 | |
| 367 | 374 | |
| 368 | 375 | /* sound hardware */ |
| 369 | 376 | MDRV_SPEAKER_STANDARD_MONO("mono") |
| 370 | MDRV_SOUND_ADD(" | |
| 377 | MDRV_SOUND_ADD("cassette", WAVE, 0) | |
| 371 | 378 | MDRV_SOUND_ROUTE(ALL_OUTPUTS, "mono", 0.50) |
| 372 | 379 | MDRV_SOUND_ADD("ay8912", AY8912, 1000000) |
| 373 | 380 | MDRV_SOUND_CONFIG(oric_ay_interface) |
| r3218 | r3219 | |
| 375 | 382 | |
| 376 | 383 | /* printer */ |
| 377 | 384 | MDRV_DEVICE_ADD("printer", PRINTER) |
| 385 | ||
| 386 | MDRV_CASSETTE_ADD( "cassette", oric_cassette_config ) | |
| 378 | 387 | MACHINE_DRIVER_END |
| 379 | 388 | |
| 380 | 389 | |
| r3218 | r3219 | |
| 427 | 436 | ROM_LOAD_OPTIONAL( "8ddoshi.rom", 0x014100, 0x0200, CRC(66309641) SHA1(9c2e82b3c4d385ade6215fcb89f8b92e6fd2bf4b) ) |
| 428 | 437 | ROM_END |
| 429 | 438 | |
| 430 | static void oric_common_cassette_getinfo(const mess_device_class *devclass, UINT32 state, union devinfo *info) | |
| 431 | { | |
| 432 | /* cassette */ | |
| 433 | switch(state) | |
| 434 | { | |
| 435 | /* --- the following bits of info are returned as 64-bit signed integers --- */ | |
| 436 | case MESS_DEVINFO_INT_COUNT: info->i = 1; break; | |
| 437 | case MESS_DEVINFO_INT_CASSETTE_DEFAULT_STATE: info->i = CASSETTE_PLAY | CASSETTE_MOTOR_DISABLED; break; | |
| 438 | 439 | |
| 439 | /* --- the following bits of info are returned as pointers to data or functions --- */ | |
| 440 | case MESS_DEVINFO_PTR_CASSETTE_FORMATS: info->p = (void *) oric_cassette_formats; break; | |
| 441 | ||
| 442 | default: cassette_device_getinfo(devclass, state, info); break; | |
| 443 | } | |
| 444 | } | |
| 445 | ||
| 446 | static SYSTEM_CONFIG_START(oric_common) | |
| 447 | CONFIG_DEVICE(oric_common_cassette_getinfo) | |
| 448 | SYSTEM_CONFIG_END | |
| 449 | ||
| 450 | 440 | static void oric1_floppy_getinfo(const mess_device_class *devclass, UINT32 state, union devinfo *info) |
| 451 | 441 | { |
| 452 | 442 | /* floppy */ |
| r3218 | r3219 | |
| 469 | 459 | } |
| 470 | 460 | |
| 471 | 461 | static SYSTEM_CONFIG_START(oric1) |
| 472 | CONFIG_IMPORT_FROM(oric_common) | |
| 473 | 462 | CONFIG_DEVICE(oric1_floppy_getinfo) |
| 474 | 463 | SYSTEM_CONFIG_END |
| 475 | 464 | |
| r3218 | r3219 | |
| 489 | 478 | } |
| 490 | 479 | |
| 491 | 480 | static SYSTEM_CONFIG_START(prav8) |
| 492 | CONFIG_IMPORT_FROM(oric_common) | |
| 493 | 481 | CONFIG_DEVICE(prav8_floppy_getinfo) |
| 494 | 482 | SYSTEM_CONFIG_END |
| 495 | 483 |
| r3218 | r3219 | |
|---|---|---|
| 142 | 142 | INPUT_PORTS_END |
| 143 | 143 | |
| 144 | 144 | /* Machine driver */ |
| 145 | static const cassette_config orao_cassette_config = | |
| 146 | { | |
| 147 | orao_cassette_formats, | |
| 148 | NULL, | |
| 149 | CASSETTE_STOPPED | CASSETTE_SPEAKER_ENABLED | CASSETTE_MOTOR_ENABLED | |
| 150 | }; | |
| 151 | ||
| 152 | ||
| 145 | 153 | static MACHINE_DRIVER_START( orao ) |
| 146 | 154 | /* basic machine hardware */ |
| 147 | 155 | MDRV_CPU_ADD("main", M6502, 1000000) |
| r3218 | r3219 | |
| 165 | 173 | MDRV_SPEAKER_STANDARD_MONO("mono") |
| 166 | 174 | MDRV_SOUND_ADD("dac", DAC, 0) |
| 167 | 175 | MDRV_SOUND_ROUTE(ALL_OUTPUTS, "mono", 8.00) |
| 168 | MDRV_SOUND_ADD(" | |
| 176 | MDRV_SOUND_ADD("cassette", WAVE, 0) | |
| 169 | 177 | MDRV_SOUND_ROUTE(ALL_OUTPUTS, "mono", 1.00) |
| 178 | ||
| 179 | MDRV_CASSETTE_ADD( "cassette", orao_cassette_config ) | |
| 170 | 180 | MACHINE_DRIVER_END |
| 171 | 181 | |
| 172 | 182 | /* ROM definition */ |
| r3218 | r3219 | |
| 182 | 192 | ROM_LOAD( "crt13.rom", 0xe000, 0x2000, CRC(e7076014) SHA1(0e213287b0b520440af6a2a6297788a9356818c2) ) |
| 183 | 193 | ROM_END |
| 184 | 194 | |
| 185 | static void orao_cassette_getinfo(const mess_device_class *devclass, UINT32 state, union devinfo *info) | |
| 186 | { | |
| 187 | /* cassette */ | |
| 188 | switch(state) | |
| 189 | { | |
| 190 | /* --- the following bits of info are returned as 64-bit signed integers --- */ | |
| 191 | case MESS_DEVINFO_INT_COUNT: info->i = 1; break; | |
| 192 | case MESS_DEVINFO_INT_CASSETTE_DEFAULT_STATE: info->i = CASSETTE_STOPPED | CASSETTE_SPEAKER_ENABLED | CASSETTE_MOTOR_ENABLED; break; | |
| 193 | case MESS_DEVINFO_PTR_CASSETTE_FORMATS: info->p = (void *)orao_cassette_formats; break; | |
| 194 | ||
| 195 | default: cassette_device_getinfo(devclass, state, info); break; | |
| 196 | } | |
| 197 | } | |
| 198 | ||
| 199 | static SYSTEM_CONFIG_START(orao) | |
| 200 | CONFIG_DEVICE(orao_cassette_getinfo) | |
| 201 | SYSTEM_CONFIG_END | |
| 202 | 195 | /* Driver */ |
| 203 | 196 | |
| 204 | 197 | /* YEAR NAME PARENT COMPAT MACHINE INPUT INIT CONFIG COMPANY FULLNAME FLAGS */ |
| 205 | COMP( 1984, orao, 0, 0, orao, orao, orao, orao, "PEL Varazdin", "Orao 102", 0) | |
| 206 | COMP( 1985, orao103, orao, 0, orao, orao, orao103, orao, "PEL Varazdin", "Orao 103", 0) | |
| 198 | COMP( 1984, orao, 0, 0, orao, orao, orao, 0, "PEL Varazdin", "Orao 102", 0) | |
| 199 | COMP( 1985, orao103, orao, 0, orao, orao, orao103, 0, "PEL Varazdin", "Orao 103", 0) | |
| 207 | 200 |
| r3218 | r3219 | |
|---|---|---|
| 204 | 204 | *****************************************************************************/ |
| 205 | 205 | |
| 206 | 206 | |
| 207 | static const cassette_config mc10_cassette_config = | |
| 208 | { | |
| 209 | coco_cassette_formats, | |
| 210 | NULL, | |
| 211 | CASSETTE_PLAY | |
| 212 | }; | |
| 213 | ||
| 214 | ||
| 207 | 215 | static MACHINE_DRIVER_START( mc10 ) |
| 208 | 216 | /* basic machine hardware */ |
| 209 | 217 | MDRV_CPU_ADD("main", M6803, XTAL_3_579545MHz) /* 0,894886 Mhz */ |
| r3218 | r3219 | |
| 225 | 233 | MDRV_SPEAKER_STANDARD_MONO("mono") |
| 226 | 234 | MDRV_SOUND_ADD("dac", DAC, 0) |
| 227 | 235 | MDRV_SOUND_ROUTE(ALL_OUTPUTS, "mono", 1.00) |
| 236 | ||
| 237 | MDRV_CASSETTE_ADD( "cassette", mc10_cassette_config ) | |
| 228 | 238 | MACHINE_DRIVER_END |
| 229 | 239 | |
| 230 | 240 | |
| r3218 | r3219 | |
| 248 | 258 | |
| 249 | 259 | |
| 250 | 260 | /***************************************************************************** |
| 251 | Devices | |
| 252 | *****************************************************************************/ | |
| 253 | ||
| 254 | ||
| 255 | static void mc10_cassette_getinfo(const mess_device_class *devclass, UINT32 state, union devinfo *info) | |
| 256 | { | |
| 257 | /* cassette */ | |
| 258 | switch(state) | |
| 259 | { | |
| 260 | /* --- the following bits of info are returned as 64-bit signed integers --- */ | |
| 261 | case MESS_DEVINFO_INT_COUNT: info->i = 1; break; | |
| 262 | ||
| 263 | /* --- the following bits of info are returned as pointers to data or functions --- */ | |
| 264 | case MESS_DEVINFO_PTR_CASSETTE_FORMATS: info->p = (void *) coco_cassette_formats; break; | |
| 265 | ||
| 266 | /* --- the following bits of info are returned as 64-bit signed integers --- */ | |
| 267 | case MESS_DEVINFO_INT_CASSETTE_DEFAULT_STATE: info->i = CASSETTE_PLAY; break; | |
| 268 | ||
| 269 | default: cassette_device_getinfo(devclass, state, info); break; | |
| 270 | } | |
| 271 | } | |
| 272 | ||
| 273 | ||
| 274 | ||
| 275 | /***************************************************************************** | |
| 276 | 261 | System config |
| 277 | 262 | *****************************************************************************/ |
| 278 | 263 | |
| 279 | 264 | |
| 280 | 265 | static SYSTEM_CONFIG_START(mc10) |
| 281 | CONFIG_DEVICE( mc10_cassette_getinfo ) | |
| 282 | 266 | CONFIG_RAM ( 4 * 1024 ) /* standard */ |
| 283 | 267 | CONFIG_RAM_DEFAULT( 20 * 1024 ) /* with 16K memory expansion */ |
| 284 | 268 | SYSTEM_CONFIG_END |
| r3218 | r3219 | |
|---|---|---|
| 279 | 279 | |
| 280 | 280 | /* quickload */ |
| 281 | 281 | MDRV_QUICKLOAD_ADD(atom, "atm", 0) |
| 282 | ||
| 283 | MDRV_CASSETTE_ADD( "cassette", default_cassette_config ) | |
| 282 | 284 | MACHINE_DRIVER_END |
| 283 | 285 | |
| 284 | 286 | |
| r3218 | r3219 | |
| 317 | 319 | ROM_LOAD ("atomicw.rom",0x018000,0x1000, CRC(a3fd737d) SHA1(d418d9322c69c49106ed2c268ad0864c0f2c4c1b)) |
| 318 | 320 | ROM_END |
| 319 | 321 | |
| 320 | static void atom_cassette_getinfo(const mess_device_class *devclass, UINT32 state, union devinfo *info) | |
| 321 | { | |
| 322 | /* cassette */ | |
| 323 | switch(state) | |
| 324 | { | |
| 325 | /* --- the following bits of info are returned as 64-bit signed integers --- */ | |
| 326 | case MESS_DEVINFO_INT_COUNT: info->i = 1; break; | |
| 327 | 322 | |
| 328 | default: cassette_device_getinfo(devclass, state, info); break; | |
| 329 | } | |
| 330 | } | |
| 331 | ||
| 332 | 323 | static void atom_floppy_getinfo(const mess_device_class *devclass, UINT32 state, union devinfo *info) |
| 333 | 324 | { |
| 334 | 325 | /* floppy */ |
| r3218 | r3219 | |
| 348 | 339 | } |
| 349 | 340 | |
| 350 | 341 | static SYSTEM_CONFIG_START(atom) |
| 351 | CONFIG_DEVICE(atom_cassette_getinfo) | |
| 352 | 342 | CONFIG_DEVICE(atom_floppy_getinfo) |
| 353 | 343 | SYSTEM_CONFIG_END |
| 354 | 344 |
| r3218 | r3219 | |
|---|---|---|
| 207 | 207 | |
| 208 | 208 | data = 0x000; |
| 209 | 209 | |
| 210 | if (cassette_input( | |
| 210 | if (cassette_input( | |
| 211 | 211 | data =(1<<7); |
| 212 | 212 | |
| 213 | 213 | return data; |
| r3218 | r3219 | |
| 254 | 254 | keyboard_data = input_port_read(machine, keynames[keyboard_line]); |
| 255 | 255 | |
| 256 | 256 | /* bit 4: cassette motor control */ |
| 257 | cassette_change_state( | |
| 257 | cassette_change_state( | |
| 258 | 258 | (data & 0x10) ? CASSETTE_MOTOR_ENABLED : CASSETTE_MOTOR_DISABLED, |
| 259 | 259 | CASSETTE_MASK_MOTOR); |
| 260 | 260 | |
| 261 | 261 | /* bit 6: cassette write */ |
| 262 | cassette_output( | |
| 262 | cassette_output( | |
| 263 | 263 | (data & 0x40) ? -1.0 : 1.0); |
| 264 | 264 | } |
| 265 | 265 | |
| r3218 | r3219 | |
| 625 | 625 | |
| 626 | 626 | |
| 627 | 627 | |
| 628 | static const cassette_config apf_cassette_config = | |
| 629 | { | |
| 630 | apf_cassette_formats, | |
| 631 | NULL, | |
| 632 | CASSETTE_PLAY | |
| 633 | }; | |
| 634 | ||
| 635 | ||
| 628 | 636 | static MACHINE_DRIVER_START( apf_imagination ) |
| 629 | 637 | /* basic machine hardware */ |
| 630 | 638 | // MDRV_CPU_ADD("main", M6800, 3750000) /* 7.8336 Mhz, only 6800p type used 1mhz max*/ |
| r3218 | r3219 | |
| 648 | 656 | MDRV_SPEAKER_STANDARD_MONO("mono") |
| 649 | 657 | MDRV_SOUND_ADD("speaker", SPEAKER, 0) |
| 650 | 658 | MDRV_SOUND_ROUTE(ALL_OUTPUTS, "mono", 1.00) |
| 659 | ||
| 660 | MDRV_CASSETTE_ADD( "cassette", apf_cassette_config ) | |
| 651 | 661 | MACHINE_DRIVER_END |
| 652 | 662 | |
| 653 | 663 | |
| r3218 | r3219 | |
| 656 | 666 | MDRV_CPU_MODIFY( "main" ) |
| 657 | 667 | MDRV_CPU_PROGRAM_MAP( apf_m1000_map, 0 ) |
| 658 | 668 | MDRV_MACHINE_START( apf_m1000 ) |
| 669 | ||
| 670 | MDRV_CASSETTE_REMOVE( "cassette" ) | |
| 659 | 671 | MACHINE_DRIVER_END |
| 660 | 672 | |
| 661 | 673 | |
| r3218 | r3219 | |
| 679 | 691 | ROM_CART_LOAD(0, "bin", 0x8000, 0x2000, ROM_OPTIONAL) |
| 680 | 692 | ROM_END |
| 681 | 693 | |
| 682 | static void apfimag_cassette_getinfo(const mess_device_class *devclass, UINT32 state, union devinfo *info) | |
| 683 | { | |
| 684 | /* cassette */ | |
| 685 | switch(state) | |
| 686 | { | |
| 687 | /* --- the following bits of info are returned as 64-bit signed integers --- */ | |
| 688 | case MESS_DEVINFO_INT_COUNT: info->i = 1; break; | |
| 689 | 694 | |
| 690 | /* --- the following bits of info are returned as pointers to data or functions --- */ | |
| 691 | case MESS_DEVINFO_PTR_CASSETTE_FORMATS: info->p = (void *) apf_cassette_formats; break; | |
| 692 | ||
| 693 | default: cassette_device_getinfo(devclass, state, info); break; | |
| 694 | } | |
| 695 | } | |
| 696 | ||
| 697 | 695 | static void apfimag_floppy_getinfo(const mess_device_class *devclass, UINT32 state, union devinfo *info) |
| 698 | 696 | { |
| 699 | 697 | /* floppy */ |
| r3218 | r3219 | |
| 714 | 712 | |
| 715 | 713 | |
| 716 | 714 | static SYSTEM_CONFIG_START( apfimag ) |
| 717 | CONFIG_DEVICE(apfimag_cassette_getinfo) | |
| 718 | 715 | CONFIG_DEVICE(apfimag_floppy_getinfo) |
| 719 | 716 | SYSTEM_CONFIG_END |
| 720 | 717 |
| r3218 | r3219 | |
|---|---|---|
| 303 | 303 | |
| 304 | 304 | /* devices */ |
| 305 | 305 | MDRV_QUICKLOAD_ADD(cbm_vc20, "p00,prg", CBM_QUICKLOAD_DELAY_SECONDS) |
| 306 | ||
| 307 | MDRV_CASSETTE_ADD( "cassette", cbm_cassette_config ) | |
| 306 | 308 | MACHINE_DRIVER_END |
| 307 | 309 | |
| 308 | 310 | |
| r3218 | r3219 | |
| 454 | 456 | static SYSTEM_CONFIG_START(vic20) |
| 455 | 457 | CONFIG_DEVICE(vic20_cartslot_getinfo) |
| 456 | 458 | CONFIG_DEVICE(cbmfloppy_device_getinfo) |
| 457 | CONFIG_DEVICE(datasette_device_getinfo) | |
| 458 | 459 | CONFIG_RAM_DEFAULT(5 * 1024) |
| 459 | 460 | CONFIG_RAM(8 * 1024) |
| 460 | 461 | CONFIG_RAM(16 * 1024) |
| r3218 | r3219 | |
| 464 | 465 | |
| 465 | 466 | static SYSTEM_CONFIG_START(vic20v) |
| 466 | 467 | CONFIG_DEVICE(vic20_cartslot_getinfo) |
| 467 | CONFIG_DEVICE(datasette_device_getinfo) | |
| 468 | 468 | CONFIG_DEVICE(vc1541_device_getinfo) |
| 469 | 469 | CONFIG_RAM_DEFAULT(5 * 1024) |
| 470 | 470 | CONFIG_RAM(8 * 1024) |
| r3218 | r3219 | |
|---|---|---|
| 126 | 126 | INPUT_PORTS_END |
| 127 | 127 | |
| 128 | 128 | /* Machine driver */ |
| 129 | static const cassette_config partner_cassette_config = | |
| 130 | { | |
| 131 | rkp_cassette_formats, | |
| 132 | NULL, | |
| 133 | CASSETTE_STOPPED | CASSETTE_SPEAKER_ENABLED | CASSETTE_MOTOR_ENABLED | |
| 134 | }; | |
| 135 | ||
| 136 | ||
| 129 | 137 | static MACHINE_DRIVER_START( partner ) |
| 130 | 138 | /* basic machine hardware */ |
| 131 | 139 | MDRV_CPU_ADD("main", 8080, XTAL_16MHz / 9) |
| r3218 | r3219 | |
| 153 | 161 | MDRV_VIDEO_UPDATE(radio86) |
| 154 | 162 | |
| 155 | 163 | MDRV_SPEAKER_STANDARD_MONO("mono") |
| 156 | MDRV_SOUND_ADD(" | |
| 164 | MDRV_SOUND_ADD("cassette", WAVE, 0) | |
| 157 | 165 | MDRV_SOUND_ROUTE(ALL_OUTPUTS, "mono", 0.25) |
| 158 | 166 | |
| 159 | 167 | MDRV_DEVICE_ADD("dma8257", DMA8257) |
| 160 | 168 | MDRV_DEVICE_CONFIG(partner_dma) |
| 169 | ||
| 170 | MDRV_CASSETTE_ADD( "cassette", partner_cassette_config ) | |
| 161 | 171 | MACHINE_DRIVER_END |
| 162 | 172 | |
| 163 | static void partner_cassette_getinfo(const mess_device_class *devclass, UINT32 state, union devinfo *info) | |
| 164 | { | |
| 165 | /* cassette */ | |
| 166 | switch(state) | |
| 167 | { | |
| 168 | /* --- the following bits of info are returned as 64-bit signed integers --- */ | |
| 169 | case MESS_DEVINFO_INT_COUNT: info->i = 1; break; | |
| 170 | case MESS_DEVINFO_INT_CASSETTE_DEFAULT_STATE: info->i = CASSETTE_STOPPED | CASSETTE_SPEAKER_ENABLED | CASSETTE_MOTOR_ENABLED; break; | |
| 171 | case MESS_DEVINFO_PTR_CASSETTE_FORMATS: info->p = (void *)rkp_cassette_formats; break; | |
| 172 | 173 | |
| 173 | default: cassette_device_getinfo(devclass, state, info); break; | |
| 174 | } | |
| 175 | } | |
| 176 | ||
| 177 | 174 | static void partner_floppy_getinfo(const mess_device_class *devclass, UINT32 state, union devinfo *info) |
| 178 | 175 | { |
| 179 | 176 | /* floppy */ |
| r3218 | r3219 | |
| 206 | 203 | |
| 207 | 204 | static SYSTEM_CONFIG_START(partner) |
| 208 | 205 | CONFIG_RAM_DEFAULT(64 * 1024) |
| 209 | CONFIG_DEVICE(partner_cassette_getinfo); | |
| 210 | 206 | CONFIG_DEVICE(partner_floppy_getinfo); |
| 211 | 207 | SYSTEM_CONFIG_END |
| 212 | 208 |
| r3218 | r3219 | |
|---|---|---|
| 166 | 166 | /* 3c000 15 */ |
| 167 | 167 | ROM_END |
| 168 | 168 | |
| 169 | static const cassette_config electron_cassette_config = | |
| 170 | { | |
| 171 | uef_cassette_formats, | |
| 172 | NULL, | |
| 173 | CASSETTE_PLAY | |
| 174 | }; | |
| 175 | ||
| 169 | 176 | static MACHINE_DRIVER_START( electron ) |
| 170 | 177 | MDRV_CPU_ADD( "main", M6502, 2000000 ) |
| 171 | 178 | MDRV_CPU_PROGRAM_MAP( electron_mem, 0 ) |
| r3218 | r3219 | |
| 188 | 195 | MDRV_SPEAKER_STANDARD_MONO( "mono" ) |
| 189 | 196 | MDRV_SOUND_ADD( "beep", BEEP, 0 ) |
| 190 | 197 | MDRV_SOUND_ROUTE( ALL_OUTPUTS, "mono", 1.00 ) |
| 198 | ||
| 199 | MDRV_CASSETTE_ADD( "cassette", electron_cassette_config ) | |
| 191 | 200 | MACHINE_DRIVER_END |
| 192 | 201 | |
| 193 | static void electron_cassette_getinfo( const mess_device_class *devclass, UINT32 state, union devinfo *info ) { | |
| 194 | switch( state ) { | |
| 195 | case MESS_DEVINFO_INT_COUNT: | |
| 196 | info->i = 1; | |
| 197 | break; | |
| 198 | case MESS_DEVINFO_PTR_CASSETTE_FORMATS: | |
| 199 | info->p = (void *)uef_cassette_formats; | |
| 200 | break; | |
| 201 | default: | |
| 202 | cassette_device_getinfo( devclass, state, info ); | |
| 203 | break; | |
| 204 | } | |
| 205 | } | |
| 206 | 202 | |
| 207 | static SYSTEM_CONFIG_START(electron) | |
| 208 | CONFIG_DEVICE(electron_cassette_getinfo) | |
| 209 | SYSTEM_CONFIG_END | |
| 210 | ||
| 211 | 203 | /* YEAR NAME PARENT COMPAT MACHINE INPUT INIT CONFIG COMPANY FULLNAME */ |
| 212 | COMP ( 1983, electron, 0, 0, electron, electron, 0, | |
| 204 | COMP ( 1983, electron, 0, 0, electron, electron, 0, 0 |
| r3218 | r3219 | |
|---|---|---|
| 114 | 114 | INPUT_PORTS_END |
| 115 | 115 | |
| 116 | 116 | /* Machine driver */ |
| 117 | static const cassette_config mikrosha_cassette_config = | |
| 118 | { | |
| 119 | rkm_cassette_formats, | |
| 120 | NULL, | |
| 121 | CASSETTE_STOPPED | CASSETTE_SPEAKER_ENABLED | CASSETTE_MOTOR_ENABLED | |
| 122 | }; | |
| 123 | ||
| 124 | ||
| 117 | 125 | static MACHINE_DRIVER_START( mikrosha ) |
| 118 | 126 | /* basic machine hardware */ |
| 119 | 127 | MDRV_CPU_ADD("main", 8080, XTAL_16MHz / 9) |
| r3218 | r3219 | |
| 142 | 150 | MDRV_VIDEO_UPDATE(radio86) |
| 143 | 151 | |
| 144 | 152 | MDRV_SPEAKER_STANDARD_MONO("mono") |
| 145 | MDRV_SOUND_ADD(" | |
| 153 | MDRV_SOUND_ADD("cassette", WAVE, 0) | |
| 146 | 154 | MDRV_SOUND_ROUTE(ALL_OUTPUTS, "mono", 0.25) |
| 147 | 155 | |
| 148 | 156 | MDRV_DEVICE_ADD("dma8257", DMA8257) |
| 149 | 157 | MDRV_DEVICE_CONFIG(radio86_dma) |
| 158 | ||
| 159 | MDRV_CASSETTE_ADD( "cassette", mikrosha_cassette_config ) | |
| 150 | 160 | MACHINE_DRIVER_END |
| 151 | 161 | |
| 152 | static void mikrosha_cassette_getinfo(const mess_device_class *devclass, UINT32 state, union devinfo *info) | |
| 153 | { | |
| 154 | /* cassette */ | |
| 155 | switch(state) | |
| 156 | { | |
| 157 | /* --- the following bits of info are returned as 64-bit signed integers --- */ | |
| 158 | case MESS_DEVINFO_INT_COUNT: info->i = 1; break; | |
| 159 | case MESS_DEVINFO_INT_CASSETTE_DEFAULT_STATE: info->i = CASSETTE_STOPPED | CASSETTE_SPEAKER_ENABLED | CASSETTE_MOTOR_ENABLED; break; | |
| 160 | case MESS_DEVINFO_PTR_CASSETTE_FORMATS: info->p = (void *)rkm_cassette_formats; break; | |
| 161 | 162 | |
| 162 | default: cassette_device_getinfo(devclass, state, info); break; | |
| 163 | } | |
| 164 | } | |
| 165 | ||
| 166 | 163 | /* ROM definition */ |
| 167 | 164 | ROM_START( mikrosha ) |
| 168 | 165 | ROM_REGION( 0x10000, "main", ROMREGION_ERASEFF ) |
| r3218 | r3219 | |
| 171 | 168 | ROM_LOAD ("mikrosha.fnt", 0x0000, 0x0800, CRC(B315DA1C) SHA1(b5bf9abc0fff75b1aba709a7f08b23d4a89bb04b)) |
| 172 | 169 | ROM_END |
| 173 | 170 | |
| 174 | static SYSTEM_CONFIG_START(mikrosha) | |
| 175 | CONFIG_DEVICE(mikrosha_cassette_getinfo); | |
| 176 | SYSTEM_CONFIG_END | |
| 177 | 171 | |
| 178 | 172 | /* Driver */ |
| 179 | 173 | |
| 180 | 174 | /* YEAR NAME PARENT COMPAT MACHINE INPUT INIT CONFIG COMPANY FULLNAME FLAGS */ |
| 181 | COMP( 1987, mikrosha, radio86,0, mikrosha, mikrosha, radio86, | |
| 175 | COMP( 1987, mikrosha, radio86,0, mikrosha, mikrosha, radio86, 0 |
| r3218 | r3219 | |
|---|---|---|
| 209 | 209 | |
| 210 | 210 | /* sound output */ |
| 211 | 211 | |
| 212 | static const cassette_config apple1_cassette_config = | |
| 213 | { | |
| 214 | cassette_default_formats, | |
| 215 | NULL, | |
| 216 | CASSETTE_STOPPED | |
| 217 | }; | |
| 218 | ||
| 212 | 219 | /* machine definition */ |
| 213 | 220 | static MACHINE_DRIVER_START( apple1 ) |
| 214 | 221 | /* basic machine hardware */ |
| r3218 | r3219 | |
| 242 | 249 | |
| 243 | 250 | /* snapshot */ |
| 244 | 251 | MDRV_SNAPSHOT_ADD(apple1, "snp", 0) |
| 252 | ||
| 253 | MDRV_CASSETTE_ADD( "cassette", apple1_cassette_config ) | |
| 245 | 254 | MACHINE_DRIVER_END |
| 246 | 255 | |
| 247 | 256 | ROM_START(apple1) |
| r3218 | r3219 | |
| 254 | 263 | ROM_LOAD("apple1.vid", 0x0000, 0x0200, CRC(a7e567fc) SHA1(b18aae0a2d4f92f5a7e22640719bbc4652f3f4ee)) |
| 255 | 264 | ROM_END |
| 256 | 265 | |
| 257 | static void apple1_cassette_getinfo(const mess_device_class *devclass, UINT32 state, union devinfo *info) | |
| 258 | { | |
| 259 | /* cassette */ | |
| 260 | switch(state) | |
| 261 | { | |
| 262 | /* --- the following bits of info are returned as 64-bit signed integers --- */ | |
| 263 | case MESS_DEVINFO_INT_COUNT: info->i = 1; break; | |
| 264 | case MESS_DEVINFO_INT_CASSETTE_DEFAULT_STATE: info->i = CASSETTE_STOPPED; break; | |
| 265 | ||
| 266 | default: cassette_device_getinfo(devclass, state, info); break; | |
| 267 | } | |
| 268 | } | |
| 269 | ||
| 270 | 266 | static SYSTEM_CONFIG_START(apple1) |
| 271 | CONFIG_DEVICE(apple1_cassette_getinfo) | |
| 272 | 267 | /* Note that because we always include 4K of RAM at $E000-$EFFF, |
| 273 | 268 | the RAM amounts listed here will be 4K below the actual RAM |
| 274 | 269 | total. */ |
| r3218 | r3219 | |
|---|---|---|
| 801 | 801 | MDRV_IMPORT_FROM(abc800m_video) |
| 802 | 802 | |
| 803 | 803 | MDRV_DEVICE_ADD("printer", PRINTER) |
| 804 | ||
| 805 | MDRV_CASSETTE_ADD( "cassette", default_cassette_config ) | |
| 804 | 806 | MACHINE_DRIVER_END |
| 805 | 807 | |
| 806 | 808 | static MACHINE_DRIVER_START( abc800c ) |
| r3218 | r3219 | |
| 820 | 822 | MDRV_IMPORT_FROM(abc800c_video) |
| 821 | 823 | |
| 822 | 824 | MDRV_DEVICE_ADD("printer", PRINTER) |
| 825 | ||
| 826 | MDRV_CASSETTE_ADD( "cassette", default_cassette_config ) | |
| 823 | 827 | MACHINE_DRIVER_END |
| 824 | 828 | |
| 825 | 829 | static MACHINE_DRIVER_START( abc802 ) |
| r3218 | r3219 | |
| 840 | 844 | MDRV_IMPORT_FROM(abc802_video) |
| 841 | 845 | |
| 842 | 846 | MDRV_DEVICE_ADD("printer", PRINTER) |
| 847 | ||
| 848 | MDRV_CASSETTE_ADD( "cassette", default_cassette_config ) | |
| 843 | 849 | MACHINE_DRIVER_END |
| 844 | 850 | |
| 845 | 851 | static MACHINE_DRIVER_START( abc806 ) |
| r3218 | r3219 | |
| 863 | 869 | |
| 864 | 870 | MDRV_DEVICE_ADD(E0516_TAG, E0516) |
| 865 | 871 | MDRV_DEVICE_CONFIG(abc806_e0516_intf) |
| 872 | ||
| 873 | MDRV_CASSETTE_ADD( "cassette", default_cassette_config ) | |
| 866 | 874 | MACHINE_DRIVER_END |
| 867 | 875 | |
| 868 | 876 | /* ROMs */ |
| r3218 | r3219 | |
| 1018 | 1026 | |
| 1019 | 1027 | /* System Configuration */ |
| 1020 | 1028 | |
| 1021 | static void abc800_cassette_getinfo(const mess_device_class *devclass, UINT32 state, union devinfo *info) | |
| 1022 | { | |
| 1023 | /* cassette */ | |
| 1024 | switch(state) | |
| 1025 | { | |
| 1026 | /* --- the following bits of info are returned as 64-bit signed integers --- */ | |
| 1027 | case MESS_DEVINFO_INT_COUNT: info->i = 1; break; | |
| 1028 | ||
| 1029 | default: cassette_device_getinfo(devclass, state, info); break; | |
| 1030 | } | |
| 1031 | } | |
| 1032 | ||
| 1033 | 1029 | static void abc800_floppy_getinfo(const mess_device_class *devclass, UINT32 state, union devinfo *info) |
| 1034 | 1030 | { |
| 1035 | 1031 | /* floppy */ |
| r3218 | r3219 | |
| 1089 | 1085 | static SYSTEM_CONFIG_START( abc800 ) |
| 1090 | 1086 | CONFIG_RAM_DEFAULT(16 * 1024) |
| 1091 | 1087 | CONFIG_RAM (32 * 1024) |
| 1092 | CONFIG_DEVICE(abc800_cassette_getinfo) | |
| 1093 | 1088 | CONFIG_DEVICE(abc800_floppy_getinfo) |
| 1094 | 1089 | CONFIG_DEVICE(abc800_serial_getinfo) |
| 1095 | 1090 | SYSTEM_CONFIG_END |
| 1096 | 1091 | |
| 1097 | 1092 | static SYSTEM_CONFIG_START( abc802 ) |
| 1098 | 1093 | CONFIG_RAM_DEFAULT(64 * 1024) |
| 1099 | CONFIG_DEVICE(abc800_cassette_getinfo) | |
| 1100 | 1094 | CONFIG_DEVICE(abc800_floppy_getinfo) |
| 1101 | 1095 | CONFIG_DEVICE(abc800_serial_getinfo) |
| 1102 | 1096 | SYSTEM_CONFIG_END |
| 1103 | 1097 | |
| 1104 | 1098 | static SYSTEM_CONFIG_START( abc806 ) |
| 1105 | 1099 | CONFIG_RAM_DEFAULT(128 * 1024) |
| 1106 | CONFIG_DEVICE(abc800_cassette_getinfo) | |
| 1107 | 1100 | CONFIG_DEVICE(abc800_floppy_getinfo) |
| 1108 | 1101 | CONFIG_DEVICE(abc800_serial_getinfo) |
| 1109 | 1102 | SYSTEM_CONFIG_END |
| r3218 | r3219 | |
|---|---|---|
| 79 | 79 | INPUT_PORTS_EXTERN( radio86 ); |
| 80 | 80 | INPUT_PORTS_EXTERN( ms7007 ); |
| 81 | 81 | |
| 82 | static const cassette_config orion_cassette_config = | |
| 83 | { | |
| 84 | rko_cassette_formats, | |
| 85 | NULL, | |
| 86 | CASSETTE_STOPPED | CASSETTE_SPEAKER_ENABLED | CASSETTE_MOTOR_ENABLED | |
| 87 | }; | |
| 88 | ||
| 89 | ||
| 82 | 90 | /* Machine driver */ |
| 83 | 91 | static MACHINE_DRIVER_START( orion128 ) |
| 84 | 92 | MDRV_CPU_ADD("main", 8080, 2000000) |
| r3218 | r3219 | |
| 110 | 118 | MDRV_VIDEO_UPDATE(orion128) |
| 111 | 119 | |
| 112 | 120 | MDRV_SPEAKER_STANDARD_MONO("mono") |
| 113 | MDRV_SOUND_ADD(" | |
| 121 | MDRV_SOUND_ADD("cassette", WAVE, 0) | |
| 114 | 122 | MDRV_SOUND_ROUTE(ALL_OUTPUTS, "mono", 0.25) |
| 123 | ||
| 124 | MDRV_CASSETTE_ADD( "cassette", orion_cassette_config ) | |
| 115 | 125 | MACHINE_DRIVER_END |
| 116 | 126 | |
| 117 | 127 | static MACHINE_DRIVER_START( orion128ms ) |
| r3218 | r3219 | |
| 163 | 173 | MDRV_SPEAKER_STANDARD_MONO("mono") |
| 164 | 174 | MDRV_SOUND_ADD("speaker", SPEAKER, 0) |
| 165 | 175 | MDRV_SOUND_ROUTE(ALL_OUTPUTS, "mono", 1.0) |
| 166 | MDRV_SOUND_ADD(" | |
| 176 | MDRV_SOUND_ADD("cassette", WAVE, 0) | |
| 167 | 177 | MDRV_SOUND_ROUTE(ALL_OUTPUTS, "mono", 0.25) |
| 168 | 178 | MDRV_SOUND_ADD("ay8912", AY8912, 1773400) |
| 169 | 179 | MDRV_SOUND_CONFIG(orionz80_ay_interface) |
| 170 | 180 | MDRV_SOUND_ROUTE(ALL_OUTPUTS, "mono", 1.00) |
| 181 | ||
| 182 | MDRV_CASSETTE_ADD( "cassette", orion_cassette_config ) | |
| 171 | 183 | MACHINE_DRIVER_END |
| 172 | 184 | |
| 173 | 185 | static MACHINE_DRIVER_START( orionz80ms ) |
| r3218 | r3219 | |
| 209 | 221 | MDRV_SPEAKER_STANDARD_MONO("mono") |
| 210 | 222 | MDRV_SOUND_ADD("speaker", SPEAKER, 0) |
| 211 | 223 | MDRV_SOUND_ROUTE(ALL_OUTPUTS, "mono", 1.0) |
| 212 | MDRV_SOUND_ADD(" | |
| 224 | MDRV_SOUND_ADD("cassette", WAVE, 0) | |
| 213 | 225 | MDRV_SOUND_ROUTE(ALL_OUTPUTS, "mono", 0.25) |
| 214 | 226 | MDRV_SOUND_ADD("ay8912", AY8912, 1773400) |
| 215 | 227 | MDRV_SOUND_CONFIG(orionz80_ay_interface) |
| 216 | 228 | MDRV_SOUND_ROUTE(ALL_OUTPUTS, "mono", 1.00) |
| 229 | ||
| 230 | MDRV_CASSETTE_ADD( "cassette", orion_cassette_config ) | |
| 217 | 231 | MACHINE_DRIVER_END |
| 218 | 232 | |
| 219 | static void orion_cassette_getinfo(const mess_device_class *devclass, UINT32 state, union devinfo *info) | |
| 220 | { | |
| 221 | /* cassette */ | |
| 222 | switch(state) | |
| 223 | { | |
| 224 | /* --- the following bits of info are returned as 64-bit signed integers --- */ | |
| 225 | case MESS_DEVINFO_INT_COUNT: info->i = 1; break; | |
| 226 | case MESS_DEVINFO_INT_CASSETTE_DEFAULT_STATE: info->i = CASSETTE_STOPPED | CASSETTE_SPEAKER_ENABLED | CASSETTE_MOTOR_ENABLED; break; | |
| 227 | case MESS_DEVINFO_PTR_CASSETTE_FORMATS: info->p = (void *)rko_cassette_formats; break; | |
| 228 | 233 | |
| 229 | default: cassette_device_getinfo(devclass, state, info); break; | |
| 230 | } | |
| 231 | } | |
| 232 | ||
| 233 | 234 | static void orion_floppy_getinfo(const mess_device_class *devclass, UINT32 state, union devinfo *info) |
| 234 | 235 | { |
| 235 | 236 | /* floppy */ |
| r3218 | r3219 | |
| 251 | 252 | static SYSTEM_CONFIG_START(orion128) |
| 252 | 253 | CONFIG_RAM_DEFAULT(256 * 1024) |
| 253 | 254 | CONFIG_DEVICE(cartslot_device_getinfo) |
| 254 | CONFIG_DEVICE(orion_cassette_getinfo); | |
| 255 | 255 | CONFIG_DEVICE(orion_floppy_getinfo); |
| 256 | 256 | SYSTEM_CONFIG_END |
| 257 | 257 | |
| 258 | 258 | static SYSTEM_CONFIG_START(orionz80) |
| 259 | 259 | CONFIG_RAM_DEFAULT(512 * 1024) |
| 260 | 260 | CONFIG_DEVICE(cartslot_device_getinfo) |
| 261 | CONFIG_DEVICE(orion_cassette_getinfo); | |
| 262 | 261 | CONFIG_DEVICE(orion_floppy_getinfo); |
| 263 | 262 | SYSTEM_CONFIG_END |
| 264 | 263 | |
| 265 | 264 | static SYSTEM_CONFIG_START(orionpro) |
| 266 | 265 | CONFIG_RAM_DEFAULT(512 * 1024) |
| 267 | 266 | CONFIG_DEVICE(cartslot_device_getinfo) |
| 268 | CONFIG_DEVICE(orion_cassette_getinfo); | |
| 269 | 267 | CONFIG_DEVICE(orion_floppy_getinfo); |
| 270 | 268 | SYSTEM_CONFIG_END |
| 271 | 269 |
| r3218 | r3219 | |
|---|---|---|
| 41 | 41 | #define SCREEN_TAG "main" |
| 42 | 42 | #define CDP1864_TAG "cdp1864" |
| 43 | 43 | |
| 44 | static const device_config *cassette_device_image( | |
| 44 | static const device_config *cassette_device_image(running_machine *machine) | |
| 45 | 45 | { |
| 46 | return | |
| 46 | return | |
| 47 | 47 | } |
| 48 | 48 | |
| 49 | 49 | /* Read/Write Handlers */ |
| r3218 | r3219 | |
| 204 | 204 | |
| 205 | 205 | // tape in |
| 206 | 206 | |
| 207 | if (cassette_input(cassette_device_image()) > +1.0) flags -= EF2; | |
| 207 | if (cassette_input(cassette_device_image(machine)) > +1.0) flags -= EF2; | |
| 208 | 208 | |
| 209 | 209 | // keyboard |
| 210 | 210 | |
| r3218 | r3219 | |
| 227 | 227 | |
| 228 | 228 | // tape out |
| 229 | 229 | |
| 230 | cassette_output(cassette_device_image(), level ? -1.0 : +1.0); | |
| 230 | cassette_output(cassette_device_image(machine), level ? -1.0 : +1.0); | |
| 231 | 231 | |
| 232 | 232 | // floppy control (FDC-6) |
| 233 | 233 | } |
| r3218 | r3219 | |
| 274 | 274 | |
| 275 | 275 | /* Machine Drivers */ |
| 276 | 276 | |
| 277 | static const cassette_config tmc2000_cassette_config = | |
| 278 | { | |
| 279 | cassette_default_formats, | |
| 280 | NULL, | |
| 281 | CASSETTE_STOPPED | CASSETTE_MOTOR_ENABLED | CASSETTE_SPEAKER_MUTED | |
| 282 | }; | |
| 283 | ||
| 277 | 284 | static MACHINE_DRIVER_START( tmc2000e ) |
| 278 | 285 | // basic system hardware |
| 279 | 286 | |
| r3218 | r3219 | |
| 305 | 312 | |
| 306 | 313 | /* printer */ |
| 307 | 314 | MDRV_DEVICE_ADD("printer", PRINTER) |
| 315 | ||
| 316 | MDRV_CASSETTE_ADD( "cassette", tmc2000_cassette_config ) | |
| 308 | 317 | MACHINE_DRIVER_END |
| 309 | 318 | |
| 310 | 319 | /* ROMs */ |
| r3218 | r3219 | |
| 319 | 328 | |
| 320 | 329 | /* System Configuration */ |
| 321 | 330 | |
| 322 | static void tmc2000e_cassette_getinfo(const mess_device_class *devclass, UINT32 state, union devinfo *info) | |
| 323 | { | |
| 324 | /* cassette */ | |
| 325 | switch(state) | |
| 326 | { | |
| 327 | /* --- the following bits of info are returned as 64-bit signed integers --- */ | |
| 328 | case MESS_DEVINFO_INT_COUNT: info->i = 1; break; | |
| 329 | case MESS_DEVINFO_INT_CASSETTE_DEFAULT_STATE: info->i = CASSETTE_STOPPED | CASSETTE_MOTOR_ENABLED | CASSETTE_SPEAKER_MUTED; break; | |
| 330 | ||
| 331 | default: cassette_device_getinfo(devclass, state, info); break; | |
| 332 | } | |
| 333 | } | |
| 334 | ||
| 335 | 331 | static void tmc2000e_floppy_getinfo(const mess_device_class *devclass, UINT32 state, union devinfo *info) |
| 336 | 332 | { |
| 337 | 333 | /* floppy */ |
| r3218 | r3219 | |
| 353 | 349 | static SYSTEM_CONFIG_START( tmc2000e ) |
| 354 | 350 | CONFIG_RAM_DEFAULT ( 8 * 1024) |
| 355 | 351 | CONFIG_RAM (40 * 1024) |
| 356 | CONFIG_DEVICE(tmc2000e_cassette_getinfo) | |
| 357 | 352 | CONFIG_DEVICE(tmc2000e_floppy_getinfo) |
| 358 | 353 | SYSTEM_CONFIG_END |
| 359 | 354 |
| r3218 | r3219 | |
|---|---|---|
| 148 | 148 | }; |
| 149 | 149 | |
| 150 | 150 | /* Machine driver */ |
| 151 | static const cassette_config bk0010_cassette_config = | |
| 152 | { | |
| 153 | /*rk8_cassette_formats*/cassette_default_formats, | |
| 154 | NULL, | |
| 155 | CASSETTE_STOPPED | CASSETTE_SPEAKER_ENABLED | CASSETTE_MOTOR_ENABLED | |
| 156 | }; | |
| 157 | ||
| 158 | ||
| 151 | 159 | static MACHINE_DRIVER_START( bk0010 ) |
| 152 | 160 | /* basic machine hardware */ |
| 153 | 161 | MDRV_CPU_ADD("main", T11, 3000000) |
| r3218 | r3219 | |
| 169 | 177 | MDRV_VIDEO_UPDATE(bk0010) |
| 170 | 178 | |
| 171 | 179 | MDRV_SPEAKER_STANDARD_MONO("mono") |
| 172 | MDRV_SOUND_ADD(" | |
| 180 | MDRV_SOUND_ADD("cassette", WAVE, 0) | |
| 173 | 181 | MDRV_SOUND_ROUTE(ALL_OUTPUTS, "mono", 1.00) |
| 182 | ||
| 183 | MDRV_CASSETTE_ADD( "cassette", bk0010_cassette_config ) | |
| 174 | 184 | MACHINE_DRIVER_END |
| 175 | 185 | |
| 176 | 186 | static MACHINE_DRIVER_START( bk0010fd ) |
| r3218 | r3219 | |
| 194 | 204 | MDRV_VIDEO_UPDATE(bk0010) |
| 195 | 205 | |
| 196 | 206 | MDRV_SPEAKER_STANDARD_MONO("mono") |
| 197 | MDRV_SOUND_ADD(" | |
| 207 | MDRV_SOUND_ADD("cassette", WAVE, 0) | |
| 198 | 208 | MDRV_SOUND_ROUTE(ALL_OUTPUTS, "mono", 1.00) |
| 209 | ||
| 210 | MDRV_CASSETTE_ADD( "cassette", bk0010_cassette_config ) | |
| 199 | 211 | MACHINE_DRIVER_END |
| 200 | 212 | |
| 201 | 213 | |
| 202 | static void bk_cassette_getinfo(const mess_device_class *devclass, UINT32 state, union devinfo *info) | |
| 203 | { | |
| 204 | /* cassette */ | |
| 205 | switch(state) | |
| 206 | { | |
| 207 | /* --- the following bits of info are returned as 64-bit signed integers --- */ | |
| 208 | case MESS_DEVINFO_INT_COUNT: info->i = 1; break; | |
| 209 | case MESS_DEVINFO_INT_CASSETTE_DEFAULT_STATE: info->i = CASSETTE_STOPPED | CASSETTE_SPEAKER_ENABLED | CASSETTE_MOTOR_ENABLED; break; | |
| 210 | //case MESS_DEVINFO_PTR_CASSETTE_FORMATS: info->p = (void *)rk8_cassette_formats; break; | |
| 211 | ||
| 212 | default: cassette_device_getinfo(devclass, state, info); break; | |
| 213 | } | |
| 214 | } | |
| 215 | ||
| 216 | static SYSTEM_CONFIG_START(bk) | |
| 217 | CONFIG_DEVICE(bk_cassette_getinfo) | |
| 218 | SYSTEM_CONFIG_END | |
| 219 | ||
| 220 | 214 | /* ROM definition */ |
| 221 | 215 | |
| 222 | 216 | ROM_START( bk0010 ) |
| r3218 | r3219 | |
| 243 | 237 | /* Driver */ |
| 244 | 238 | |
| 245 | 239 | /* YEAR NAME PARENT COMPAT MACHINE INPUT INIT CONFIG COMPANY FULLNAME FLAGS */ |
| 246 | COMP( 1985, bk0010, 0, 0, bk0010, bk0010, bk0010, bk, "Elektronika", "BK-0010", 0) | |
| 247 | COMP( 1986, bk001001, bk0010, 0, bk0010, bk0010, bk0010, bk, "Elektronika", "BK-0010.01", 0) | |
| 248 | COMP( 1986, bk0010fd, bk0010, 0, bk0010fd, bk0010, bk0010, bk, "Elektronika", "BK-0010 FDD", GAME_NOT_WORKING) | |
| 240 | COMP( 1985, bk0010, 0, 0, bk0010, bk0010, bk0010, 0, "Elektronika", "BK-0010", 0) | |
| 241 | COMP( 1986, bk001001, bk0010, 0, bk0010, bk0010, bk0010, 0, "Elektronika", "BK-0010.01", 0) | |
| 242 | COMP( 1986, bk0010fd, bk0010, 0, bk0010fd, bk0010, bk0010, 0, "Elektronika", "BK-0010 FDD", GAME_NOT_WORKING) | |
| 249 | 243 | |
| 250 | 244 |
| r3218 | r3219 | |
|---|---|---|
| 429 | 429 | MDRV_SPEAKER_STANDARD_MONO("mono") |
| 430 | 430 | MDRV_SOUND_ADD("sn76489", SN76489, 2000000) |
| 431 | 431 | MDRV_SOUND_ROUTE(ALL_OUTPUTS, "mono", 1.00) |
| 432 | ||
| 433 | MDRV_CASSETTE_ADD( "cassette", default_cassette_config ) | |
| 432 | 434 | MACHINE_DRIVER_END |
| 433 | 435 | |
| 434 | 436 | static MACHINE_DRIVER_START( fnvision ) |
| r3218 | r3219 | |
| 436 | 438 | MDRV_MACHINE_START( fnvision ) |
| 437 | 439 | MDRV_SCREEN_MODIFY("main") |
| 438 | 440 | MDRV_SCREEN_REFRESH_RATE(10738635.0/2/342/313) |
| 441 | ||
| 442 | MDRV_CASSETTE_REMOVE( "cassette" ) | |
| 439 | 443 | MACHINE_DRIVER_END |
| 440 | 444 | |
| 441 | 445 | /* ROMs */ |
| r3218 | r3219 | |
| 536 | 540 | } |
| 537 | 541 | } |
| 538 | 542 | |
| 539 | static void crvision_cassette_getinfo(const mess_device_class *devclass, UINT32 state, union devinfo *info) | |
| 540 | { | |
| 541 | /* cassette */ | |
| 542 | switch(state) | |
| 543 | { | |
| 544 | /* --- the following bits of info are returned as 64-bit signed integers --- */ | |
| 545 | case MESS_DEVINFO_INT_COUNT: info->i = 1; break; | |
| 546 | ||
| 547 | default: cassette_device_getinfo(devclass, state, info); break; | |
| 548 | } | |
| 549 | } | |
| 550 | ||
| 551 | 543 | static SYSTEM_CONFIG_START( crvision ) |
| 552 | 544 | CONFIG_DEVICE(crvision_cartslot_getinfo) |
| 553 | CONFIG_DEVICE(crvision_cassette_getinfo) | |
| 554 | 545 | SYSTEM_CONFIG_END |
| 555 | 546 | |
| 556 | 547 | static SYSTEM_CONFIG_START( fnvision ) |
| r3218 | r3219 | |
|---|---|---|
| 136 | 136 | static MACHINE_RESET( tmc2000 ); |
| 137 | 137 | static MACHINE_RESET( oscnano ); |
| 138 | 138 | |
| 139 | static const device_config *cassette_device_image( | |
| 139 | static const device_config *cassette_device_image(running_machine *machine) | |
| 140 | 140 | { |
| 141 | return | |
| 141 | return | |
| 142 | 142 | } |
| 143 | 143 | |
| 144 | 144 | /* Read/Write Handlers */ |
| r3218 | r3219 | |
| 467 | 467 | if (state->cdp1861_efx) flags -= EF1; |
| 468 | 468 | |
| 469 | 469 | /* tape input */ |
| 470 | if (cassette_input(cassette_device_image()) < 0) flags -= EF2; | |
| 470 | if (cassette_input(cassette_device_image(machine)) < 0) flags -= EF2; | |
| 471 | 471 | |
| 472 | 472 | /* keyboard */ |
| 473 | 473 | if (~input_port_read(machine, keynames[state->keylatch / 8]) & (1 << (state->keylatch % 8))) flags -= EF3; |
| r3218 | r3219 | |
| 478 | 478 | static CDP1802_Q_WRITE( tmc1800_q_w ) |
| 479 | 479 | { |
| 480 | 480 | /* tape output */ |
| 481 | cassette_output(cassette_device_image(), level ? 1.0 : -1.0); | |
| 481 | cassette_output(cassette_device_image(machine), level ? 1.0 : -1.0); | |
| 482 | 482 | } |
| 483 | 483 | |
| 484 | 484 | static CDP1802_DMA_WRITE( tmc1800_dma_w ) |
| r3218 | r3219 | |
| 551 | 551 | if (state->cdp1864_efx) flags -= EF1; |
| 552 | 552 | |
| 553 | 553 | /* tape input */ |
| 554 | if (cassette_input(cassette_device_image()) < 0) flags -= EF2; | |
| 554 | if (cassette_input(cassette_device_image(machine)) < 0) flags -= EF2; | |
| 555 | 555 | |
| 556 | 556 | /* keyboard */ |
| 557 | 557 | if (~input_port_read(machine, keynames[state->keylatch / 8]) & (1 << (state->keylatch % 8))) flags -= EF3; |
| r3218 | r3219 | |
| 570 | 570 | set_led_status(1, level); |
| 571 | 571 | |
| 572 | 572 | /* tape output */ |
| 573 | cassette_output(cassette_device_image(), level ? 1.0 : -1.0); | |
| 573 | cassette_output(cassette_device_image(machine), level ? 1.0 : -1.0); | |
| 574 | 574 | } |
| 575 | 575 | |
| 576 | 576 | static CDP1802_DMA_WRITE( tmc2000_dma_w ) |
| r3218 | r3219 | |
| 665 | 665 | if (state->cdp1864_efx) flags -= EF1; |
| 666 | 666 | |
| 667 | 667 | /* tape input */ |
| 668 | if (cassette_input(cassette_device_image()) < 0) flags -= EF2; | |
| 668 | if (cassette_input(cassette_device_image(machine)) < 0) flags -= EF2; | |
| 669 | 669 | |
| 670 | 670 | /* keyboard */ |
| 671 | 671 | if (~input_port_read(machine, keynames[state->keylatch / 8]) & (1 << (state->keylatch % 8))) flags -= EF3; |
| r3218 | r3219 | |
| 687 | 687 | set_led_status(1, level); |
| 688 | 688 | |
| 689 | 689 | /* tape output */ |
| 690 | cassette_output(cassette_device_image(), level ? 1.0 : -1.0); | |
| 690 | cassette_output(cassette_device_image(machine), level ? 1.0 : -1.0); | |
| 691 | 691 | } |
| 692 | 692 | |
| 693 | 693 | static CDP1802_DMA_WRITE( oscnano_dma_w ) |
| r3218 | r3219 | |
| 843 | 843 | |
| 844 | 844 | /* Machine Drivers */ |
| 845 | 845 | |
| 846 | static const cassette_config tmc1800_cassette_config = | |
| 847 | { | |
| 848 | cassette_default_formats, | |
| 849 | NULL, | |
| 850 | CASSETTE_STOPPED | CASSETTE_MOTOR_ENABLED | CASSETTE_SPEAKER_MUTED | |
| 851 | }; | |
| 852 | ||
| 846 | 853 | static MACHINE_DRIVER_START( tmc1800 ) |
| 847 | 854 | MDRV_DRIVER_DATA(tmc1800_state) |
| 848 | 855 | |
| r3218 | r3219 | |
| 863 | 870 | // quickload |
| 864 | 871 | |
| 865 | 872 | MDRV_QUICKLOAD_ADD(tmc1800, "bin", 0) |
| 873 | ||
| 874 | MDRV_CASSETTE_ADD( "cassette", tmc1800_cassette_config ) | |
| 866 | 875 | MACHINE_DRIVER_END |
| 867 | 876 | |
| 868 | 877 | static MACHINE_DRIVER_START( osc1000b ) |
| r3218 | r3219 | |
| 885 | 894 | // quickload |
| 886 | 895 | |
| 887 | 896 | MDRV_QUICKLOAD_ADD(tmc1800, "bin", 0) |
| 897 | ||
| 898 | MDRV_CASSETTE_ADD( "cassette", tmc1800_cassette_config ) | |
| 888 | 899 | MACHINE_DRIVER_END |
| 889 | 900 | |
| 890 | 901 | static MACHINE_DRIVER_START( tmc2000 ) |
| r3218 | r3219 | |
| 914 | 925 | // quickload |
| 915 | 926 | |
| 916 | 927 | MDRV_QUICKLOAD_ADD(tmc1800, "bin", 0) |
| 928 | ||
| 929 | MDRV_CASSETTE_ADD( "cassette", tmc1800_cassette_config ) | |
| 917 | 930 | MACHINE_DRIVER_END |
| 918 | 931 | |
| 919 | 932 | static MACHINE_DRIVER_START( oscnano ) |
| r3218 | r3219 | |
| 943 | 956 | // quickload |
| 944 | 957 | |
| 945 | 958 | MDRV_QUICKLOAD_ADD(tmc1800, "bin", 0) |
| 959 | ||
| 960 | MDRV_CASSETTE_ADD( "cassette", tmc1800_cassette_config ) | |
| 946 | 961 | MACHINE_DRIVER_END |
| 947 | 962 | |
| 948 | 963 | /* ROMs */ |
| r3218 | r3219 | |
| 993 | 1008 | return INIT_PASS; |
| 994 | 1009 | } |
| 995 | 1010 | |
| 996 | static void tmc1800_cassette_getinfo(const mess_device_class *devclass, UINT32 state, union devinfo *info) | |
| 997 | { | |
| 998 | /* cassette */ | |
| 999 | switch(state) | |
| 1000 | { | |
| 1001 | /* --- the following bits of info are returned as 64-bit signed integers --- */ | |
| 1002 | case MESS_DEVINFO_INT_COUNT: info->i = 1; break; | |
| 1003 | case MESS_DEVINFO_INT_CASSETTE_DEFAULT_STATE: info->i = CASSETTE_STOPPED | CASSETTE_MOTOR_ENABLED | CASSETTE_SPEAKER_MUTED; break; | |
| 1004 | ||
| 1005 | default: cassette_device_getinfo(devclass, state, info); break; | |
| 1006 | } | |
| 1007 | } | |
| 1008 | ||
| 1009 | 1011 | static SYSTEM_CONFIG_START( tmc1800 ) |
| 1010 | 1012 | CONFIG_RAM_DEFAULT ( 2 * 1024) |
| 1011 | 1013 | CONFIG_RAM ( 4 * 1024) |
| 1012 | CONFIG_DEVICE(tmc1800_cassette_getinfo) | |
| 1013 | 1014 | SYSTEM_CONFIG_END |
| 1014 | 1015 | |
| 1015 | 1016 | static SYSTEM_CONFIG_START( osc1000b ) |
| 1016 | 1017 | CONFIG_RAM_DEFAULT ( 2 * 1024) |
| 1017 | 1018 | CONFIG_RAM ( 4 * 1024) |
| 1018 | CONFIG_DEVICE(tmc1800_cassette_getinfo) | |
| 1019 | 1019 | SYSTEM_CONFIG_END |
| 1020 | 1020 | |
| 1021 | 1021 | static SYSTEM_CONFIG_START( tmc2000 ) |
| 1022 | 1022 | CONFIG_RAM_DEFAULT ( 4 * 1024) |
| 1023 | 1023 | CONFIG_RAM (16 * 1024) |
| 1024 | 1024 | CONFIG_RAM (32 * 1024) |
| 1025 | CONFIG_DEVICE(tmc1800_cassette_getinfo) | |
| 1026 | 1025 | SYSTEM_CONFIG_END |
| 1027 | 1026 | |
| 1028 | 1027 | static SYSTEM_CONFIG_START( oscnano ) |
| 1029 | 1028 | CONFIG_RAM_DEFAULT (4 * 1024) |
| 1030 | CONFIG_DEVICE(tmc1800_cassette_getinfo) | |
| 1031 | 1029 | SYSTEM_CONFIG_END |
| 1032 | 1030 | |
| 1033 | 1031 | /* Driver Initialization */ |
| r3218 | r3219 | |
|---|---|---|
| 113 | 113 | PORT_BIT(0x80, IP_ACTIVE_LOW, IPT_KEYBOARD) PORT_NAME("Rus/Lat") PORT_CODE(KEYCODE_LALT) PORT_CODE(KEYCODE_RALT) |
| 114 | 114 | INPUT_PORTS_END |
| 115 | 115 | |
| 116 | static const cassette_config apogee_cassette_config = | |
| 117 | { | |
| 118 | rka_cassette_formats, | |
| 119 | NULL, | |
| 120 | CASSETTE_STOPPED | CASSETTE_SPEAKER_ENABLED | CASSETTE_MOTOR_ENABLED | |
| 121 | }; | |
| 122 | ||
| 123 | ||
| 116 | 124 | /* Machine driver */ |
| 117 | 125 | static MACHINE_DRIVER_START( apogee ) |
| 118 | 126 | /* basic machine hardware */ |
| r3218 | r3219 | |
| 142 | 150 | MDRV_VIDEO_UPDATE(radio86) |
| 143 | 151 | |
| 144 | 152 | MDRV_SPEAKER_STANDARD_MONO("mono") |
| 145 | MDRV_SOUND_ADD(" | |
| 153 | MDRV_SOUND_ADD("cassette", WAVE, 0) | |
| 146 | 154 | MDRV_SOUND_ROUTE(ALL_OUTPUTS, "mono", 0.25) |
| 147 | 155 | |
| 148 | 156 | MDRV_DEVICE_ADD("dma8257", DMA8257) |
| 149 | 157 | MDRV_DEVICE_CONFIG(radio86_dma) |
| 158 | ||
| 159 | MDRV_CASSETTE_ADD( "cassette", apogee_cassette_config ) | |
| 150 | 160 | MACHINE_DRIVER_END |
| 151 | 161 | |
| 152 | static void apogee_cassette_getinfo(const mess_device_class *devclass, UINT32 state, union devinfo *info) | |
| 153 | { | |
| 154 | /* cassette */ | |
| 155 | switch(state) | |
| 156 | { | |
| 157 | /* --- the following bits of info are returned as 64-bit signed integers --- */ | |
| 158 | case MESS_DEVINFO_INT_COUNT: info->i = 1; break; | |
| 159 | case MESS_DEVINFO_INT_CASSETTE_DEFAULT_STATE: info->i = CASSETTE_STOPPED | CASSETTE_SPEAKER_ENABLED | CASSETTE_MOTOR_ENABLED; break; | |
| 160 | case MESS_DEVINFO_PTR_CASSETTE_FORMATS: info->p = (void *)rka_cassette_formats; break; | |
| 161 | ||
| 162 | default: cassette_device_getinfo(devclass, state, info); break; | |
| 163 | } | |
| 164 | } | |
| 165 | ||
| 166 | 162 | /* ROM definition */ |
| 167 | 163 | ROM_START( apogee ) |
| 168 | 164 | ROM_REGION( 0x10000, "main", ROMREGION_ERASEFF ) |
| r3218 | r3219 | |
| 171 | 167 | ROM_LOAD ("apogee.fnt", 0x0000, 0x0800, CRC(fe5867f0) SHA1(82c5aca63ada5e4533eb0516384aaa7b77a1f8e2)) |
| 172 | 168 | ROM_END |
| 173 | 169 | |
| 174 | static SYSTEM_CONFIG_START(apogee) | |
| 175 | CONFIG_DEVICE(apogee_cassette_getinfo); | |
| 176 | SYSTEM_CONFIG_END | |
| 177 | ||
| 178 | 170 | /* Driver */ |
| 179 | 171 | |
| 180 | 172 | /* YEAR NAME PARENT COMPAT MACHINE INPUT INIT CONFIG COMPANY FULLNAME FLAGS */ |
| 181 | COMP( 1989, apogee, radio86,0, apogee, apogee,radio86, | |
| 173 | COMP( 1989, apogee, radio86,0, apogee, apogee,radio86, 0 |
| r3218 | r3219 | |
|---|---|---|
| 60 | 60 | |
| 61 | 61 | static UINT8 acia_rxd = 1, acia_txd = 1; |
| 62 | 62 | |
| 63 | static const device_config *cassette_device_image(int index) | |
| 63 | static const device_config *cassette_device_image(running_machine *machine, int index) | |
| 64 | 64 | { |
| 65 | return image_from_devtype_and_index(IO_CASSETTE, index); | |
| 65 | if ( index ) | |
| 66 | return device_list_find_by_tag( machine->config->devicelist, CASSETTE, "cassette2" ); | |
| 67 | else | |
| 68 | return device_list_find_by_tag( machine->config->devicelist, CASSETTE, "cassette1" ); | |
| 66 | 69 | } |
| 67 | 70 | |
| 68 | 71 | /* Enable/Status */ |
| r3218 | r3219 | |
| 332 | 335 | |
| 333 | 336 | /* tape motor enable */ |
| 334 | 337 | |
| 335 | cassette_change_state(cassette_device_image(0), BIT(data, 1) ? CASSETTE_MOTOR_DISABLED : CASSETTE_MOTOR_ENABLED, CASSETTE_MASK_MOTOR); | |
| 336 | cassette_change_state(cassette_device_image(1), BIT(data, 3) ? CASSETTE_MOTOR_DISABLED : CASSETTE_MOTOR_ENABLED, CASSETTE_MASK_MOTOR); | |
| 338 | cassette_change_state(cassette_device_image(machine, 0), BIT(data, 1) ? CASSETTE_MOTOR_DISABLED : CASSETTE_MOTOR_ENABLED, CASSETTE_MASK_MOTOR); | |
| 339 | cassette_change_state(cassette_device_image(machine, 1), BIT(data, 3) ? CASSETTE_MOTOR_DISABLED : CASSETTE_MOTOR_ENABLED, CASSETTE_MASK_MOTOR); | |
| 337 | 340 | } |
| 338 | 341 | |
| 339 | 342 | static READ8_HANDLER( newbrain_cop_g_r ) |
| r3218 | r3219 | |
| 382 | 385 | |
| 383 | 386 | state->cop_tdo = BIT(data, 1); |
| 384 | 387 | |
| 385 | cassette_output(cassette_device_image(0), state->cop_tdo ? -1.0 : +1.0); | |
| 386 | cassette_output(cassette_device_image(1), state->cop_tdo ? -1.0 : +1.0); | |
| 388 | cassette_output(cassette_device_image(machine, 0), state->cop_tdo ? -1.0 : +1.0); | |
| 389 | cassette_output(cassette_device_image(machine, 1), state->cop_tdo ? -1.0 : +1.0); | |
| 387 | 390 | |
| 388 | 391 | /* keyboard and display clock */ |
| 389 | 392 | |
| r3218 | r3219 | |
| 445 | 448 | |
| 446 | 449 | newbrain_state *state = machine->driver_data; |
| 447 | 450 | |
| 448 | state->cop_tdi = ((cassette_input(cassette_device_image(0)) > +1.0) || (cassette_input(cassette_device_image(1)) > +1.0)) ^ state->cop_tdo; | |
| 451 | state->cop_tdi = ((cassette_input(cassette_device_image(machine, 0)) > +1.0) || (cassette_input(cassette_device_image(machine, 1)) > +1.0)) ^ state->cop_tdo; | |
| 449 | 452 | |
| 450 | 453 | return state->cop_tdi; |
| 451 | 454 | } |
| r3218 | r3219 | |
| 1227 | 1230 | |
| 1228 | 1231 | /* Machine Drivers */ |
| 1229 | 1232 | |
| 1233 | static const cassette_config newbrain_cassette_config = | |
| 1234 | { | |
| 1235 | cassette_default_formats, | |
| 1236 | NULL, | |
| 1237 | CASSETTE_STOPPED | CASSETTE_MOTOR_ENABLED | CASSETTE_SPEAKER_MUTED | |
| 1238 | }; | |
| 1239 | ||
| 1240 | ||
| 1230 | 1241 | static MACHINE_DRIVER_START( newbrain ) |
| 1231 | 1242 | MDRV_DRIVER_DATA(newbrain_state) |
| 1232 | 1243 | |
| r3218 | r3219 | |
| 1257 | 1268 | // video hardware |
| 1258 | 1269 | |
| 1259 | 1270 | MDRV_IMPORT_FROM(newbrain_video) |
| 1271 | ||
| 1272 | MDRV_CASSETTE_ADD( "cassette1", newbrain_cassette_config ) | |
| 1273 | MDRV_CASSETTE_ADD( "cassette2", newbrain_cassette_config ) | |
| 1260 | 1274 | MACHINE_DRIVER_END |
| 1261 | 1275 | |
| 1262 | 1276 | static MACHINE_DRIVER_START( newbraim ) |
| r3218 | r3219 | |
| 1280 | 1294 | // video hardware |
| 1281 | 1295 | |
| 1282 | 1296 | MDRV_IMPORT_FROM(newbrain_video) |
| 1297 | ||
| 1298 | MDRV_CASSETTE_ADD( "cassette1", newbrain_cassette_config ) | |
| 1299 | MDRV_CASSETTE_ADD( "cassette2", newbrain_cassette_config ) | |
| 1283 | 1300 | MACHINE_DRIVER_END |
| 1284 | 1301 | |
| 1285 | 1302 | static MACHINE_DRIVER_START( newbraia ) |
| r3218 | r3219 | |
| 1303 | 1320 | // video hardware |
| 1304 | 1321 | |
| 1305 | 1322 | MDRV_IMPORT_FROM(newbrain_video) |
| 1323 | ||
| 1324 | MDRV_CASSETTE_ADD( "cassette1", newbrain_cassette_config ) | |
| 1325 | MDRV_CASSETTE_ADD( "cassette2", newbrain_cassette_config ) | |
| 1306 | 1326 | MACHINE_DRIVER_END |
| 1307 | 1327 | |
| 1308 | 1328 | static MACHINE_DRIVER_START( newbraiv ) |
| r3218 | r3219 | |
| 1326 | 1346 | // video hardware |
| 1327 | 1347 | |
| 1328 | 1348 | MDRV_IMPORT_FROM(newbrain_video) |
| 1349 | ||
| 1350 | MDRV_CASSETTE_ADD( "cassette1", newbrain_cassette_config ) | |
| 1351 | MDRV_CASSETTE_ADD( "cassette2", newbrain_cassette_config ) | |
| 1329 | 1352 | MACHINE_DRIVER_END |
| 1330 | 1353 | |
| 1331 | 1354 | /* ROMs */ |
| r3218 | r3219 | |
| 1397 | 1420 | |
| 1398 | 1421 | /* System Configuration */ |
| 1399 | 1422 | |
| 1400 | static void newbrain_cassette_getinfo(const mess_device_class *devclass, UINT32 state, union devinfo *info) | |
| 1401 | { | |
| 1402 | /* cassette */ | |
| 1403 | switch(state) | |
| 1404 | { | |
| 1405 | /* --- the following bits of info are returned as 64-bit signed integers --- */ | |
| 1406 | case MESS_DEVINFO_INT_COUNT: info->i = 2; break; | |
| 1407 | case MESS_DEVINFO_INT_CASSETTE_DEFAULT_STATE: info->i = CASSETTE_STOPPED | CASSETTE_MOTOR_ENABLED | CASSETTE_SPEAKER_MUTED; break; | |
| 1408 | ||
| 1409 | default: cassette_device_getinfo(devclass, state, info); break; | |
| 1410 | } | |
| 1411 | } | |
| 1412 | ||
| 1413 | 1423 | static DEVICE_IMAGE_LOAD( newbrain_floppy ) |
| 1414 | 1424 | { |
| 1415 | 1425 | if (image_has_been_created(image)) |
| r3218 | r3219 | |
| 1481 | 1491 | |
| 1482 | 1492 | static SYSTEM_CONFIG_START( newbrain ) |
| 1483 | 1493 | CONFIG_RAM_DEFAULT (32 * 1024) |
| 1484 | CONFIG_DEVICE(newbrain_cassette_getinfo) | |
| 1485 | 1494 | CONFIG_DEVICE(newbrain_floppy_getinfo) |
| 1486 | 1495 | CONFIG_DEVICE(newbrain_serial_getinfo) |
| 1487 | 1496 | SYSTEM_CONFIG_END |
| 1488 | 1497 | |
| 1489 | 1498 | static SYSTEM_CONFIG_START( newbraim ) |
| 1490 | 1499 | CONFIG_RAM_DEFAULT (32 * 1024) |
| 1491 | CONFIG_DEVICE(newbrain_cassette_getinfo) | |
| 1492 | 1500 | CONFIG_DEVICE(newbrain_serial_getinfo) |
| 1493 | 1501 | SYSTEM_CONFIG_END |
| 1494 | 1502 | |
| 1495 | 1503 | static SYSTEM_CONFIG_START( newbraia ) |
| 1496 | 1504 | CONFIG_RAM_DEFAULT (32 * 1024) |
| 1497 | CONFIG_DEVICE(newbrain_cassette_getinfo) | |
| 1498 | 1505 | CONFIG_DEVICE(newbrain_serial_getinfo) |
| 1499 | 1506 | SYSTEM_CONFIG_END |
| 1500 | 1507 | |
| 1501 | 1508 | static SYSTEM_CONFIG_START( newbraiv ) |
| 1502 | 1509 | CONFIG_RAM_DEFAULT (32 * 1024) |
| 1503 | CONFIG_DEVICE(newbrain_cassette_getinfo) | |
| 1504 | 1510 | CONFIG_DEVICE(newbrain_serial_getinfo) |
| 1505 | 1511 | SYSTEM_CONFIG_END |
| 1506 | 1512 |
| r3218 | r3219 | |
|---|---|---|
| 237 | 237 | MDRV_SPEAKER_STANDARD_MONO("mono") |
| 238 | 238 | MDRV_SOUND_ADD("dac", DAC, 0) |
| 239 | 239 | MDRV_SOUND_ROUTE(ALL_OUTPUTS, "mono", 1.00) |
| 240 | MDRV_SOUND_ADD(" | |
| 240 | MDRV_SOUND_ADD("cassette", WAVE, 0) | |
| 241 | 241 | MDRV_SOUND_ROUTE(ALL_OUTPUTS, "mono", 0.25) |
| 242 | 242 | MDRV_SOUND_ADD("ay8910.1", AY8910, 1000000) |
| 243 | 243 | MDRV_SOUND_CONFIG(microtan_ay8910_interface) |
| r3218 | r3219 | |
| 249 | 249 | // snapshot/quickload |
| 250 | 250 | MDRV_SNAPSHOT_ADD(microtan, "m65", 0.5) |
| 251 | 251 | MDRV_QUICKLOAD_ADD(microtan_hexfile, "hex", 0.5) |
| 252 | ||
| 253 | MDRV_CASSETTE_ADD( "cassette", default_cassette_config ) | |
| 252 | 254 | MACHINE_DRIVER_END |
| 253 | 255 | |
| 254 | 256 | ROM_START( microtan ) |
| r3218 | r3219 | |
| 268 | 270 | // initialized in init_microtan |
| 269 | 271 | ROM_END |
| 270 | 272 | |
| 271 | static void microtan_cassette_getinfo(const mess_device_class *devclass, UINT32 state, union devinfo *info) | |
| 272 | { | |
| 273 | /* cassette */ | |
| 274 | switch(state) | |
| 275 | { | |
| 276 | /* --- the following bits of info are returned as 64-bit signed integers --- */ | |
| 277 | case MESS_DEVINFO_INT_COUNT: info->i = 1; break; | |
| 278 | 273 | |
| 279 | default: cassette_device_getinfo(devclass, state, info); break; | |
| 280 | } | |
| 281 | } | |
| 282 | ||
| 283 | static SYSTEM_CONFIG_START( microtan ) | |
| 284 | CONFIG_DEVICE(microtan_cassette_getinfo) | |
| 285 | SYSTEM_CONFIG_END | |
| 286 | ||
| 287 | 274 | // YEAR NAME PARENT COMPAT MACHINE INPUT INIT CONFIG COMPANY FULLNAME |
| 288 | COMP( 1979, microtan, 0, 0, microtan, microtan, microtan, | |
| 275 | COMP( 1979, microtan, 0, 0, microtan, microtan, microtan, 0 |
| r3218 | r3219 | |
|---|---|---|
| 305 | 305 | PORT_BIT(0xFE, IP_ACTIVE_LOW, IPT_UNUSED) |
| 306 | 306 | INPUT_PORTS_END |
| 307 | 307 | |
| 308 | static const cassette_config special_cassette_config = | |
| 309 | { | |
| 310 | rks_cassette_formats, | |
| 311 | NULL, | |
| 312 | CASSETTE_STOPPED | CASSETTE_SPEAKER_ENABLED | CASSETTE_MOTOR_ENABLED | |
| 313 | }; | |
| 314 | ||
| 315 | ||
| 308 | 316 | /* Machine driver */ |
| 309 | 317 | static MACHINE_DRIVER_START( special ) |
| 310 | 318 | /* basic machine hardware */ |
| r3218 | r3219 | |
| 335 | 343 | MDRV_SPEAKER_STANDARD_MONO("mono") |
| 336 | 344 | MDRV_SOUND_ADD("dac", DAC, 0) |
| 337 | 345 | MDRV_SOUND_ROUTE(ALL_OUTPUTS, "mono", 1.00) |
| 338 | MDRV_SOUND_ADD(" | |
| 346 | MDRV_SOUND_ADD("cassette", WAVE, 0) | |
| 339 | 347 | MDRV_SOUND_ROUTE(ALL_OUTPUTS, "mono", 1.00) |
| 348 | ||
| 349 | MDRV_CASSETTE_ADD( "cassette", special_cassette_config ) | |
| 340 | 350 | MACHINE_DRIVER_END |
| 341 | 351 | |
| 342 | 352 | static MACHINE_DRIVER_START( specialp ) |
| r3218 | r3219 | |
| 402 | 412 | MDRV_SPEAKER_STANDARD_MONO("mono") |
| 403 | 413 | MDRV_SOUND_ADD("dac", DAC, 0) |
| 404 | 414 | MDRV_SOUND_ROUTE(ALL_OUTPUTS, "mono", 1.00) |
| 405 | MDRV_SOUND_ADD(" | |
| 415 | MDRV_SOUND_ADD("cassette", WAVE, 0) | |
| 406 | 416 | MDRV_SOUND_ROUTE(ALL_OUTPUTS, "mono", 1.00) |
| 417 | ||
| 418 | MDRV_CASSETTE_ADD( "cassette", special_cassette_config ) | |
| 407 | 419 | MACHINE_DRIVER_END |
| 408 | 420 | |
| 409 | 421 | /* ROM definition */ |
| r3218 | r3219 | |
| 445 | 457 | ROM_LOAD( "erik.bin", 0x10000, 0x10000, CRC(6F3208F4) SHA1(41f6e2763ef60d3c7214c98893e580d25346fa2d)) |
| 446 | 458 | ROM_END |
| 447 | 459 | |
| 448 | static void special_cassette_getinfo(const mess_device_class *devclass, UINT32 state, union devinfo *info) | |
| 449 | { | |
| 450 | /* cassette */ | |
| 451 | switch(state) | |
| 452 | { | |
| 453 | /* --- the following bits of info are returned as 64-bit signed integers --- */ | |
| 454 | case MESS_DEVINFO_INT_COUNT: info->i = 1; break; | |
| 455 | case MESS_DEVINFO_INT_CASSETTE_DEFAULT_STATE: info->i = CASSETTE_STOPPED | CASSETTE_SPEAKER_ENABLED | CASSETTE_MOTOR_ENABLED; break; | |
| 456 | case MESS_DEVINFO_PTR_CASSETTE_FORMATS: info->p = (void *)rks_cassette_formats; break; | |
| 457 | ||
| 458 | default: cassette_device_getinfo(devclass, state, info); break; | |
| 459 | } | |
| 460 | } | |
| 461 | ||
| 462 | 460 | static void specimx_floppy_getinfo(const mess_device_class *devclass, UINT32 state, union devinfo *info) |
| 463 | 461 | { |
| 464 | 462 | /* floppy */ |
| r3218 | r3219 | |
| 476 | 474 | default: legacybasicdsk_device_getinfo(devclass, state, info); break; |
| 477 | 475 | } |
| 478 | 476 | } |
| 479 | static SYSTEM_CONFIG_START(special) | |
| 480 | CONFIG_DEVICE(special_cassette_getinfo) | |
| 481 | SYSTEM_CONFIG_END | |
| 482 | 477 | |
| 483 | 478 | static SYSTEM_CONFIG_START(specimx) |
| 484 | 479 | CONFIG_RAM_DEFAULT(128 * 1024) |
| 485 | CONFIG_DEVICE(special_cassette_getinfo) | |
| 486 | 480 | CONFIG_DEVICE(specimx_floppy_getinfo); |
| 487 | 481 | SYSTEM_CONFIG_END |
| 488 | 482 | |
| 489 | 483 | static SYSTEM_CONFIG_START(erik) |
| 490 | 484 | CONFIG_RAM_DEFAULT(192 * 1024) |
| 491 | CONFIG_DEVICE(special_cassette_getinfo) | |
| 492 | 485 | CONFIG_DEVICE(specimx_floppy_getinfo); |
| 493 | 486 | SYSTEM_CONFIG_END |
| 494 | 487 | |
| 495 | 488 | /* Driver */ |
| 496 | 489 | |
| 497 | 490 | /* YEAR NAME PARENT COMPAT MACHINE INPUT INIT CONFIG COMPANY FULLNAME FLAGS */ |
| 498 | COMP( 1985, special, 0, 0, special, special, special, special, "", "Specialist", 0) | |
| 499 | COMP( 1985, specialp, special,0, specialp, special, special, special, "", "Specialist + hires graph", 0) | |
| 500 | COMP( 1985, lik, special,0, special, special, special, special, "", "Lik", 0) | |
| 501 | COMP( 1985, specimx, special,0, specimx, specimx, specimx, specimx, "", "Specialist MX", 0) | |
| 502 | COMP( 1994, erik, special,0, erik, special, erik, erik, "", "Erik", 0) | |
| 491 | COMP( 1985, special, 0, 0, special, special, special, 0, "", "Specialist", 0) | |
| 492 | COMP( 1985, specialp, special,0, specialp, special, special, 0, "", "Specialist + hires graph", 0) | |
| 493 | COMP( 1985, lik, special,0, special, special, special, 0, "", "Lik", 0) | |
| 494 | COMP( 1985, specimx, special,0, specimx, specimx, specimx, specimx, "", "Specialist MX", 0) | |
| 495 | COMP( 1994, erik, special,0, erik, special, erik, erik, "", "Erik", 0) | |
| 503 | 496 | |
| 504 | 497 |
| r3218 | r3219 | |
|---|---|---|
| 127 | 127 | INPUT_PORTS_END |
| 128 | 128 | |
| 129 | 129 | /* Machine driver */ |
| 130 | static const cassette_config mikro80_cassette_config = | |
| 131 | { | |
| 132 | rk8_cassette_formats, | |
| 133 | NULL, | |
| 134 | CASSETTE_STOPPED | CASSETTE_SPEAKER_ENABLED | CASSETTE_MOTOR_ENABLED | |
| 135 | }; | |
| 136 | ||
| 137 | ||
| 130 | 138 | static MACHINE_DRIVER_START( mikro80 ) |
| 131 | 139 | /* basic machine hardware */ |
| 132 | 140 | MDRV_CPU_ADD("main",8080, 2000000) |
| r3218 | r3219 | |
| 151 | 159 | MDRV_VIDEO_UPDATE(mikro80) |
| 152 | 160 | |
| 153 | 161 | MDRV_SPEAKER_STANDARD_MONO("mono") |
| 154 | MDRV_SOUND_ADD(" | |
| 162 | MDRV_SOUND_ADD("cassette", WAVE, 0) | |
| 155 | 163 | MDRV_SOUND_ROUTE(ALL_OUTPUTS, "mono", 1.00) |
| 156 | 164 | |
| 165 | MDRV_CASSETTE_ADD( "cassette", mikro80_cassette_config ) | |
| 157 | 166 | MACHINE_DRIVER_END |
| 158 | 167 | |
| 159 | 168 | static MACHINE_DRIVER_START( radio99 ) |
| r3218 | r3219 | |
| 166 | 175 | MDRV_SOUND_ROUTE(ALL_OUTPUTS, "mono", 16.00) |
| 167 | 176 | MACHINE_DRIVER_END |
| 168 | 177 | |
| 169 | static void mikro80_cassette_getinfo(const mess_device_class *devclass, UINT32 state, union devinfo *info) | |
| 170 | { | |
| 171 | /* cassette */ | |
| 172 | switch(state) | |
| 173 | { | |
| 174 | /* --- the following bits of info are returned as 64-bit signed integers --- */ | |
| 175 | case MESS_DEVINFO_INT_COUNT: info->i = 1; break; | |
| 176 | case MESS_DEVINFO_INT_CASSETTE_DEFAULT_STATE: info->i = CASSETTE_STOPPED | CASSETTE_SPEAKER_ENABLED | CASSETTE_MOTOR_ENABLED; break; | |
| 177 | case MESS_DEVINFO_PTR_CASSETTE_FORMATS: info->p = (void *)rk8_cassette_formats; break; | |
| 178 | 178 | |
| 179 | default: cassette_device_getinfo(devclass, state, info); break; | |
| 180 | } | |
| 181 | } | |
| 182 | ||
| 183 | static SYSTEM_CONFIG_START(mikro80) | |
| 184 | CONFIG_DEVICE(mikro80_cassette_getinfo) | |
| 185 | SYSTEM_CONFIG_END | |
| 186 | ||
| 187 | 179 | /* ROM definition */ |
| 188 | 180 | |
| 189 | 181 | ROM_START( mikro80 ) |
| r3218 | r3219 | |
| 204 | 196 | /* Driver */ |
| 205 | 197 | |
| 206 | 198 | /* YEAR NAME PARENT COMPAT MACHINE INPUT INIT CONFIG COMPANY FULLNAME FLAGS */ |
| 207 | COMP( 1983, mikro80, 0, 0, mikro80, mikro80, mikro80, mikro80, "", "Mikro-80", 0) | |
| 208 | COMP( 1993, radio99, mikro80, 0, radio99, mikro80, radio99, mikro80, "", "Radio-99DM", 0) | |
| 199 | COMP( 1983, mikro80, 0, 0, mikro80, mikro80, mikro80, 0, "", "Mikro-80", 0) | |
| 200 | COMP( 1993, radio99, mikro80, 0, radio99, mikro80, radio99, 0, "", "Radio-99DM", 0) |
| r3218 | r3219 | |
|---|---|---|
| 301 | 301 | Machine Drivers |
| 302 | 302 | ******************************************************************************/ |
| 303 | 303 | |
| 304 | static const cassette_config laser_cassette_config = | |
| 305 | { | |
| 306 | vtech1_cassette_formats, | |
| 307 | NULL, | |
| 308 | CASSETTE_PLAY | |
| 309 | }; | |
| 310 | ||
| 304 | 311 | static MACHINE_DRIVER_START(laser110) |
| 305 | 312 | /* basic machine hardware */ |
| 306 | 313 | MDRV_CPU_ADD("main", Z80, VTECH1_CLK) /* 3.57950 Mhz */ |
| r3218 | r3219 | |
| 321 | 328 | |
| 322 | 329 | /* sound hardware */ |
| 323 | 330 | MDRV_SPEAKER_STANDARD_MONO("mono") |
| 324 | MDRV_SOUND_ADD(" | |
| 331 | MDRV_SOUND_ADD("cassette", WAVE, 0) | |
| 325 | 332 | MDRV_SOUND_ROUTE(ALL_OUTPUTS, "mono", 0.25) |
| 326 | 333 | MDRV_SOUND_ADD("speaker", SPEAKER, 0) |
| 327 | 334 | MDRV_SOUND_CONFIG(vtech1_speaker_interface) |
| r3218 | r3219 | |
| 333 | 340 | /* snapshot/quickload */ |
| 334 | 341 | MDRV_SNAPSHOT_ADD(vtech1, "vz", 1.5) |
| 335 | 342 | MDRV_Z80BIN_QUICKLOAD_ADD(vtech1, 1.5) |
| 343 | ||
| 344 | MDRV_CASSETTE_ADD( "cassette", laser_cassette_config ) | |
| 336 | 345 | MACHINE_DRIVER_END |
| 337 | 346 | |
| 338 | 347 | static MACHINE_DRIVER_START(laser200) |
| r3218 | r3219 | |
| 450 | 459 | } |
| 451 | 460 | } |
| 452 | 461 | |
| 453 | static void vtech1_cassette_getinfo(const mess_device_class *devclass, UINT32 state, union devinfo *info) | |
| 454 | { | |
| 455 | /* cassette */ | |
| 456 | switch(state) | |
| 457 | { | |
| 458 | /* --- the following bits of info are returned as 64-bit signed integers --- */ | |
| 459 | case MESS_DEVINFO_INT_COUNT: info->i = 1; break; | |
| 460 | 462 | |
| 461 | /* --- the following bits of info are returned as pointers to data or functions --- */ | |
| 462 | case MESS_DEVINFO_PTR_CASSETTE_FORMATS: info->p = (void *) vtech1_cassette_formats; break; | |
| 463 | ||
| 464 | default: cassette_device_getinfo(devclass, state, info); break; | |
| 465 | } | |
| 466 | } | |
| 467 | ||
| 468 | 463 | static void vtech1_floppy_getinfo(const mess_device_class *devclass, UINT32 state, union devinfo *info) |
| 469 | 464 | { |
| 470 | 465 | /* floppy */ |
| r3218 | r3219 | |
| 499 | 494 | |
| 500 | 495 | static SYSTEM_CONFIG_START(vtech1) |
| 501 | 496 | CONFIG_DEVICE(cartslot_device_getinfo) |
| 502 | CONFIG_DEVICE(vtech1_cassette_getinfo) | |
| 503 | 497 | CONFIG_DEVICE(vtech1_floppy_getinfo) |
| 504 | 498 | CONFIG_RAM_DEFAULT (66 * 1024) /* with 64K memory expansion */ |
| 505 | 499 | CONFIG_RAM (4098 * 1024) /* with 4MB memory expansion */ |
| r3218 | r3219 | |
|---|---|---|
| 328 | 328 | /* Set b7 with cassette tape input */ |
| 329 | 329 | if(amstrad_system_type != SYSTEM_GX4000) |
| 330 | 330 | { |
| 331 | if (cassette_input( | |
| 331 | if (cassette_input( | |
| 332 | 332 | data |= (1<<7); |
| 333 | 333 | } |
| 334 | 334 | } |
| r3218 | r3219 | |
| 394 | 394 | if(amstrad_system_type != SYSTEM_GX4000) |
| 395 | 395 | { |
| 396 | 396 | if ((changed_data & 0x20) != 0) { |
| 397 | cassette_output( | |
| 397 | cassette_output( | |
| 398 | 398 | ((data & 0x20) ? -1.0 : +1.0)); |
| 399 | 399 | } |
| 400 | 400 | } |
| r3218 | r3219 | |
| 403 | 403 | if(amstrad_system_type != SYSTEM_GX4000) |
| 404 | 404 | { |
| 405 | 405 | if ((changed_data & 0x10) != 0) { |
| 406 | cassette_change_state( | |
| 406 | cassette_change_state( | |
| 407 | 407 | ((data & 0x10) ? CASSETTE_MOTOR_ENABLED : CASSETTE_MOTOR_DISABLED), |
| 408 | 408 | CASSETTE_MASK_MOTOR); |
| 409 | 409 | } |
| r3218 | r3219 | |
| 2908 | 2908 | This is the reason why the displayed area is not the same as the visible area. |
| 2909 | 2909 | */ |
| 2910 | 2910 | |
| 2911 | static const cassette_config amstrad_cassette_config = | |
| 2912 | { | |
| 2913 | cdt_cassette_formats, | |
| 2914 | NULL, | |
| 2915 | CASSETTE_STOPPED | CASSETTE_SPEAKER_ENABLED | |
| 2916 | }; | |
| 2917 | ||
| 2918 | ||
| 2911 | 2919 | static MACHINE_DRIVER_START( amstrad ) |
| 2912 | 2920 | /* Machine hardware */ |
| 2913 | 2921 | MDRV_CPU_ADD("main", Z80, 4000000) |
| r3218 | r3219 | |
| 2938 | 2946 | |
| 2939 | 2947 | /* sound hardware */ |
| 2940 | 2948 | MDRV_SPEAKER_STANDARD_MONO("mono") |
| 2941 | MDRV_SOUND_ADD(" | |
| 2949 | MDRV_SOUND_ADD("cassette", WAVE, 0) | |
| 2942 | 2950 | MDRV_SOUND_ROUTE(ALL_OUTPUTS, "mono", 0.50) |
| 2943 | 2951 | MDRV_SOUND_ADD("ay", AY8912, 1000000) |
| 2944 | 2952 | MDRV_SOUND_CONFIG(ay8912_interface) |
| r3218 | r3219 | |
| 2949 | 2957 | |
| 2950 | 2958 | /* snapshot */ |
| 2951 | 2959 | MDRV_SNAPSHOT_ADD(amstrad, "sna", 0) |
| 2960 | ||
| 2961 | MDRV_CASSETTE_ADD( "cassette", amstrad_cassette_config ) | |
| 2952 | 2962 | MACHINE_DRIVER_END |
| 2953 | 2963 | |
| 2954 | 2964 | |
| r3218 | r3219 | |
| 2976 | 2986 | |
| 2977 | 2987 | MDRV_PALETTE_LENGTH(4096+48) // extended 12-bit palette, and standard 32 colour palette |
| 2978 | 2988 | MDRV_PALETTE_INIT(amstrad_plus) |
| 2989 | ||
| 2990 | MDRV_CASSETTE_REMOVE( "cassette" ) | |
| 2979 | 2991 | MACHINE_DRIVER_END |
| 2980 | 2992 | |
| 2981 | 2993 | |
| 2982 | 2994 | static MACHINE_DRIVER_START( gx4000 ) |
| 2983 | 2995 | MDRV_IMPORT_FROM(amstrad) |
| 2984 | MDRV_SOUND_REMOVE(" | |
| 2996 | MDRV_SOUND_REMOVE("cassette") | |
| 2985 | 2997 | MDRV_GFXDECODE(asic_sprite) |
| 2986 | 2998 | MDRV_MACHINE_START(plus) |
| 2987 | 2999 | MDRV_MACHINE_RESET(gx4000) |
| r3218 | r3219 | |
| 2995 | 3007 | |
| 2996 | 3008 | /* printer not present in the gx4000 */ |
| 2997 | 3009 | MDRV_DEVICE_REMOVE("printer", PRINTER) |
| 3010 | ||
| 3011 | MDRV_CASSETTE_REMOVE( "cassette" ) | |
| 2998 | 3012 | MACHINE_DRIVER_END |
| 2999 | 3013 | |
| 3000 | 3014 | |
| r3218 | r3219 | |
| 3131 | 3145 | } |
| 3132 | 3146 | |
| 3133 | 3147 | |
| 3134 | static void cpc6128_cassette_getinfo(const mess_device_class *devclass, UINT32 state, union devinfo *info) | |
| 3135 | { | |
| 3136 | /* cassette */ | |
| 3137 | switch(state) | |
| 3138 | { | |
| 3139 | /* --- the following bits of info are returned as 64-bit signed integers --- */ | |
| 3140 | case MESS_DEVINFO_INT_COUNT: info->i = 1; break; | |
| 3141 | case MESS_DEVINFO_INT_CASSETTE_DEFAULT_STATE: info->i = CASSETTE_STOPPED | CASSETTE_SPEAKER_ENABLED; break; | |
| 3142 | case MESS_DEVINFO_PTR_CASSETTE_FORMATS: info->p = (void *)cdt_cassette_formats; break; | |
| 3143 | ||
| 3144 | default: cassette_device_getinfo(devclass, state, info); break; | |
| 3145 | } | |
| 3146 | } | |
| 3147 | ||
| 3148 | ||
| 3149 | 3148 | static void cpcplus_cartslot_getinfo(const mess_device_class *devclass, UINT32 state, union devinfo *info) |
| 3150 | 3149 | { |
| 3151 | 3150 | /* cartslot */ |
| r3218 | r3219 | |
| 3184 | 3183 | static SYSTEM_CONFIG_START( cpc6128 ) |
| 3185 | 3184 | CONFIG_RAM_DEFAULT(128 * 1024) |
| 3186 | 3185 | CONFIG_DEVICE(cpc6128_floppy_getinfo) |
| 3187 | CONFIG_DEVICE(cpc6128_cassette_getinfo) | |
| 3188 | 3186 | SYSTEM_CONFIG_END |
| 3189 | 3187 | |
| 3190 | 3188 | |
| r3218 | r3219 | |
| 3202 | 3200 | |
| 3203 | 3201 | static SYSTEM_CONFIG_START( aleste ) |
| 3204 | 3202 | CONFIG_DEVICE(aleste_floppy_getinfo) |
| 3205 | CONFIG_DEVICE(cpc6128_cassette_getinfo) | |
| 3206 | 3203 | CONFIG_RAM_DEFAULT(2048 * 1024) // has 2048k RAM |
| 3207 | 3204 | SYSTEM_CONFIG_END |
| 3208 | 3205 |
| r3218 | r3219 | |
|---|---|---|
| 155 | 155 | PORT_BIT(0x80, IP_ACTIVE_LOW, IPT_KEYBOARD) PORT_NAME("Backspace") PORT_CODE(KEYCODE_BACKSPACE) |
| 156 | 156 | INPUT_PORTS_END |
| 157 | 157 | |
| 158 | static const cassette_config ut88_cassette_config = | |
| 159 | { | |
| 160 | rku_cassette_formats, | |
| 161 | NULL, | |
| 162 | CASSETTE_STOPPED | CASSETTE_SPEAKER_ENABLED | CASSETTE_MOTOR_ENABLED | |
| 163 | }; | |
| 164 | ||
| 158 | 165 | /* Machine driver */ |
| 159 | 166 | static MACHINE_DRIVER_START( ut88 ) |
| 160 | 167 | /* basic machine hardware */ |
| r3218 | r3219 | |
| 184 | 191 | MDRV_SPEAKER_STANDARD_MONO("mono") |
| 185 | 192 | MDRV_SOUND_ADD("dac", DAC, 0) |
| 186 | 193 | MDRV_SOUND_ROUTE(ALL_OUTPUTS, "mono", 0.25) |
| 187 | MDRV_SOUND_ADD(" | |
| 194 | MDRV_SOUND_ADD("cassette", WAVE, 0) | |
| 188 | 195 | MDRV_SOUND_ROUTE(ALL_OUTPUTS, "mono", 1.00) |
| 196 | ||
| 197 | MDRV_CASSETTE_ADD( "cassette", ut88_cassette_config ) | |
| 189 | 198 | MACHINE_DRIVER_END |
| 190 | 199 | |
| 191 | 200 | static MACHINE_DRIVER_START( ut88mini ) |
| r3218 | r3219 | |
| 198 | 207 | |
| 199 | 208 | /* video hardware */ |
| 200 | 209 | MDRV_DEFAULT_LAYOUT(layout_ut88mini) |
| 210 | ||
| 211 | MDRV_CASSETTE_ADD( "cassette", ut88_cassette_config ) | |
| 201 | 212 | MACHINE_DRIVER_END |
| 202 | 213 | |
| 203 | static void ut88_cassette_getinfo(const mess_device_class *devclass, UINT32 state, union devinfo *info) | |
| 204 | { | |
| 205 | /* cassette */ | |
| 206 | switch(state) | |
| 207 | { | |
| 208 | /* --- the following bits of info are returned as 64-bit signed integers --- */ | |
| 209 | case MESS_DEVINFO_INT_COUNT: info->i = 1; break; | |
| 210 | case MESS_DEVINFO_INT_CASSETTE_DEFAULT_STATE: info->i = CASSETTE_STOPPED | CASSETTE_SPEAKER_ENABLED | CASSETTE_MOTOR_ENABLED; break; | |
| 211 | case MESS_DEVINFO_PTR_CASSETTE_FORMATS: info->p = (void *)rku_cassette_formats; break; | |
| 212 | ||
| 213 | default: cassette_device_getinfo(devclass, state, info); break; | |
| 214 | } | |
| 215 | } | |
| 216 | ||
| 217 | static SYSTEM_CONFIG_START(ut88) | |
| 218 | CONFIG_DEVICE(ut88_cassette_getinfo) | |
| 219 | SYSTEM_CONFIG_END | |
| 220 | ||
| 221 | 214 | /* ROM definition */ |
| 222 | 215 | ROM_START( ut88 ) |
| 223 | 216 | ROM_REGION( 0x10000, "main", ROMREGION_ERASEFF ) |
| r3218 | r3219 | |
| 236 | 229 | /* Driver */ |
| 237 | 230 | |
| 238 | 231 | /* YEAR NAME PARENT COMPAT MACHINE INPUT INIT CONFIG COMPANY FULLNAME FLAGS */ |
| 239 | COMP( 1989, ut88mini, 0, 0, ut88mini, ut88mini, ut88mini, ut88, "", "UT-88 mini", 0) | |
| 240 | COMP( 1989, ut88, ut88mini,0, ut88, ut88, ut88, ut88, "", "UT-88", 0) | |
| 232 | COMP( 1989, ut88mini, 0, 0, ut88mini, ut88mini, ut88mini, 0, "", "UT-88 mini", 0) | |
| 233 | COMP( 1989, ut88, ut88mini,0, ut88, ut88, ut88, 0, "", "UT-88", 0) | |
| 241 | 234 |
| r3218 | r3219 | |
|---|---|---|
| 270 | 270 | static TIMER_CALLBACK(tape_interrupt_handler) |
| 271 | 271 | { |
| 272 | 272 | //assert(tape_interrupt_enable); |
| 273 | cpunum_set_input_line(machine, 0, 1, (cassette_input( | |
| 273 | cpunum_set_input_line(machine, 0, 1, (cassette_input( | |
| 274 | 274 | } |
| 275 | 275 | |
| 276 | 276 | /* CRU handler */ |
| 277 | 277 | static READ8_HANDLER(tutor_cassette_r) |
| 278 | 278 | { |
| 279 | return (cassette_input( | |
| 279 | return (cassette_input( | |
| 280 | 280 | } |
| 281 | 281 | |
| 282 | 282 | /* memory handler */ |
| r3218 | r3219 | |
| 293 | 293 | { |
| 294 | 294 | case 0: |
| 295 | 295 | /* data out */ |
| 296 | cassette_output( | |
| 296 | cassette_output( | |
| 297 | 297 | break; |
| 298 | 298 | case 1: |
| 299 | 299 | /* interrupt control??? */ |
| r3218 | r3219 | |
| 593 | 593 | MDRV_SPEAKER_STANDARD_MONO("mono") |
| 594 | 594 | MDRV_SOUND_ADD("sn76489a", SN76489A, 3579545) /* 3.579545 MHz */ |
| 595 | 595 | MDRV_SOUND_ROUTE(ALL_OUTPUTS, "mono", 0.75) |
| 596 | MDRV_SOUND_ADD(" | |
| 596 | MDRV_SOUND_ADD("cassette", WAVE, 0) | |
| 597 | 597 | MDRV_SOUND_ROUTE(ALL_OUTPUTS, "mono", 0.20) |
| 598 | ||
| 599 | MDRV_CASSETTE_ADD( "cassette", default_cassette_config ) | |
| 598 | 600 | MACHINE_DRIVER_END |
| 599 | 601 | |
| 600 | 602 | |
| r3218 | r3219 | |
| 627 | 629 | } |
| 628 | 630 | } |
| 629 | 631 | |
| 630 | static void tutor_cassette_getinfo(const mess_device_class *devclass, UINT32 state, union devinfo *info) | |
| 631 | { | |
| 632 | /* cassette */ | |
| 633 | switch(state) | |
| 634 | { | |
| 635 | /* --- the following bits of info are returned as 64-bit signed integers --- */ | |
| 636 | case MESS_DEVINFO_INT_COUNT: info->i = 1; break; | |
| 637 | ||
| 638 | default: cassette_device_getinfo(devclass, state, info); break; | |
| 639 | } | |
| 640 | } | |
| 641 | ||
| 642 | 632 | static void tutor_parallel_getinfo(const mess_device_class *devclass, UINT32 state, union devinfo *info) |
| 643 | 633 | { |
| 644 | 634 | /* parallel */ |
| r3218 | r3219 | |
| 660 | 650 | |
| 661 | 651 | /* cartridge port is not emulated */ |
| 662 | 652 | CONFIG_DEVICE(tutor_cartslot_getinfo) |
| 663 | CONFIG_DEVICE(tutor_cassette_getinfo) | |
| 664 | 653 | CONFIG_DEVICE(tutor_parallel_getinfo) |
| 665 | 654 | |
| 666 | 655 | SYSTEM_CONFIG_END |
| r3218 | r3219 | |
|---|---|---|
| 23 | 23 | #include "video/cdp1869.h" |
| 24 | 24 | #include "video/mc6845.h" |
| 25 | 25 | |
| 26 | static const device_config *cassette_device_image( | |
| 26 | static const device_config *cassette_device_image(running_machine *machine) | |
| 27 | 27 | { |
| 28 | return | |
| 28 | return | |
| 29 | 29 | } |
| 30 | 30 | |
| 31 | 31 | /* Memory Maps */ |
| r3218 | r3219 | |
| 241 | 241 | if (!state->cdp1871_efxa) flags -= EF3; |
| 242 | 242 | |
| 243 | 243 | // cassette input, expansion device flag |
| 244 | if ((cassette_input(cassette_device_image()) < +0.0) || !state->cdp1802_ef4) flags -= EF4; | |
| 244 | if ((cassette_input(cassette_device_image(machine)) < +0.0) || !state->cdp1802_ef4) flags -= EF4; | |
| 245 | 245 | |
| 246 | 246 | return flags; |
| 247 | 247 | } |
| r3218 | r3219 | |
| 298 | 298 | } |
| 299 | 299 | |
| 300 | 300 | // cassette output |
| 301 | cassette_output(cassette_device_image(), level ? +1.0 : -1.0); | |
| 301 | cassette_output(cassette_device_image(machine), level ? +1.0 : -1.0); | |
| 302 | 302 | } |
| 303 | 303 | |
| 304 | 304 | static CDP1802_INTERFACE( comx35_cdp1802_config ) |
| r3218 | r3219 | |
| 343 | 343 | |
| 344 | 344 | /* Machine Drivers */ |
| 345 | 345 | |
| 346 | static const cassette_config comx35_cassette_config = | |
| 347 | { | |
| 348 | cassette_default_formats, | |
| 349 | NULL, | |
| 350 | CASSETTE_STOPPED | CASSETTE_MOTOR_ENABLED | CASSETTE_SPEAKER_ENABLED | |
| 351 | }; | |
| 352 | ||
| 346 | 353 | static MACHINE_DRIVER_START( comx35p ) |
| 347 | 354 | MDRV_DRIVER_DATA(comx35_state) |
| 348 | 355 | |
| r3218 | r3219 | |
| 372 | 379 | MDRV_SOUND_ADD("cdp1869", CDP1869, CDP1869_DOT_CLK_PAL) |
| 373 | 380 | MDRV_SOUND_ROUTE(ALL_OUTPUTS, "mono", 0.25) |
| 374 | 381 | |
| 375 | MDRV_SOUND_ADD(" | |
| 382 | MDRV_SOUND_ADD("cassette", WAVE, 0) | |
| 376 | 383 | MDRV_SOUND_ROUTE(ALL_OUTPUTS, "mono", 0.25) |
| 377 | 384 | |
| 378 | 385 | // printer |
| r3218 | r3219 | |
| 382 | 389 | // quickload |
| 383 | 390 | |
| 384 | 391 | MDRV_QUICKLOAD_ADD(comx35, "comx", 0) |
| 392 | ||
| 393 | MDRV_CASSETTE_ADD( "cassette", comx35_cassette_config ) | |
| 385 | 394 | MACHINE_DRIVER_END |
| 386 | 395 | |
| 387 | 396 | static MACHINE_DRIVER_START( comx35n ) |
| r3218 | r3219 | |
| 413 | 422 | MDRV_SOUND_ADD("cdp1869", CDP1869, CDP1869_DOT_CLK_NTSC) |
| 414 | 423 | MDRV_SOUND_ROUTE(ALL_OUTPUTS, "mono", 0.25) |
| 415 | 424 | |
| 416 | MDRV_SOUND_ADD(" | |
| 425 | MDRV_SOUND_ADD("cassette", WAVE, 0) | |
| 417 | 426 | MDRV_SOUND_ROUTE(ALL_OUTPUTS, "mono", 0.25) |
| 418 | 427 | |
| 419 | 428 | // printer |
| r3218 | r3219 | |
| 423 | 432 | // quickload |
| 424 | 433 | |
| 425 | 434 | MDRV_QUICKLOAD_ADD(comx35, "comx", 0) |
| 435 | ||
| 436 | MDRV_CASSETTE_ADD( "cassette", comx35_cassette_config ) | |
| 426 | 437 | MACHINE_DRIVER_END |
| 427 | 438 | |
| 428 | 439 | /* ROMs */ |
| r3218 | r3219 | |
| 456 | 467 | |
| 457 | 468 | /* System Configuration */ |
| 458 | 469 | |
| 459 | static void comx35_cassette_getinfo(const mess_device_class *devclass, UINT32 state, union devinfo *info) | |
| 460 | { | |
| 461 | /* cassette */ | |
| 462 | switch(state) | |
| 463 | { | |
| 464 | /* --- the following bits of info are returned as 64-bit signed integers --- */ | |
| 465 | case MESS_DEVINFO_INT_COUNT: info->i = 1; break; | |
| 466 | case MESS_DEVINFO_INT_CASSETTE_DEFAULT_STATE: info->i = CASSETTE_STOPPED | CASSETTE_MOTOR_ENABLED | CASSETTE_SPEAKER_ENABLED; break; | |
| 467 | ||
| 468 | default: cassette_device_getinfo(devclass, state, info); break; | |
| 469 | } | |
| 470 | } | |
| 471 | ||
| 472 | 470 | static void comx35_floppy_getinfo(const mess_device_class *devclass, UINT32 state, union devinfo *info) |
| 473 | 471 | { |
| 474 | 472 | /* floppy */ |
| r3218 | r3219 | |
| 489 | 487 | |
| 490 | 488 | static SYSTEM_CONFIG_START( comx35 ) |
| 491 | 489 | CONFIG_RAM_DEFAULT (32 * 1024) |
| 492 | CONFIG_DEVICE(comx35_cassette_getinfo) | |
| 493 | 490 | CONFIG_DEVICE(comx35_floppy_getinfo) |
| 494 | 491 | SYSTEM_CONFIG_END |
| 495 | 492 |
| r3218 | r3219 | |
|---|---|---|
| 228 | 228 | PORT_CONFSETTING( 0x01, DEF_STR( Off ) ) |
| 229 | 229 | INPUT_PORTS_END |
| 230 | 230 | |
| 231 | static const struct CassetteOptions primo_cassette_options = { | |
| 232 | 1, /* channels */ | |
| 233 | 16, /* bits per sample */ | |
| 234 | 22050 /* sample frequency */ | |
| 235 | }; | |
| 236 | ||
| 237 | static const cassette_config primo_cassette_config = | |
| 238 | { | |
| 239 | primo_ptp_format, | |
| 240 | &primo_cassette_options, | |
| 241 | CASSETTE_STOPPED | CASSETTE_SPEAKER_ENABLED | |
| 242 | }; | |
| 243 | ||
| 244 | ||
| 231 | 245 | static MACHINE_DRIVER_START( primoa32 ) |
| 232 | 246 | /* basic machine hardware */ |
| 233 | 247 | MDRV_CPU_ADD( "main", Z80, 2500000 ) |
| r3218 | r3219 | |
| 251 | 265 | |
| 252 | 266 | /* sound hardware */ |
| 253 | 267 | MDRV_SPEAKER_STANDARD_MONO("mono") |
| 254 | MDRV_SOUND_ADD(" | |
| 268 | MDRV_SOUND_ADD("cassette", WAVE, 0) | |
| 255 | 269 | MDRV_SOUND_ROUTE(ALL_OUTPUTS, "mono", 0.50) |
| 256 | 270 | MDRV_SOUND_ADD("speaker", SPEAKER, 0) |
| 257 | 271 | MDRV_SOUND_ROUTE(ALL_OUTPUTS, "mono", 0.50) |
| r3218 | r3219 | |
| 259 | 273 | /* snapshot/quickload */ |
| 260 | 274 | MDRV_SNAPSHOT_ADD(primo, "pss", 0) |
| 261 | 275 | MDRV_QUICKLOAD_ADD(primo, "pp", 0) |
| 276 | ||
| 277 | MDRV_CASSETTE_ADD( "cassette", primo_cassette_config ) | |
| 262 | 278 | MACHINE_DRIVER_END |
| 263 | 279 | |
| 264 | 280 | static MACHINE_DRIVER_START( primoa48 ) |
| r3218 | r3219 | |
| 389 | 405 | ROM_CART_LOAD(0, "rom", 0x18000, 0x4000, ROM_FILL_FF | ROM_OPTIONAL) |
| 390 | 406 | ROM_END |
| 391 | 407 | |
| 392 | static const struct CassetteOptions primo_cassette_options = { | |
| 393 | 1, /* channels */ | |
| 394 | 16, /* bits per sample */ | |
| 395 | 22050 /* sample frequency */ | |
| 396 | }; | |
| 397 | 408 | |
| 398 | static void primo_cassette_getinfo(const mess_device_class *devclass, UINT32 state, union devinfo *info) | |
| 399 | { | |
| 400 | /* cassette */ | |
| 401 | switch(state) | |
| 402 | { | |
| 403 | /* --- the following bits of info are returned as 64-bit signed integers --- */ | |
| 404 | case MESS_DEVINFO_INT_COUNT: info->i = 1; break; | |
| 405 | ||
| 406 | /* --- the following bits of info are returned as pointers to data or functions --- */ | |
| 407 | case MESS_DEVINFO_PTR_CASSETTE_FORMATS: info->p = (void *) primo_ptp_format; break; | |
| 408 | case MESS_DEVINFO_PTR_CASSETTE_OPTIONS: info->p = (void *) &primo_cassette_options; break; | |
| 409 | ||
| 410 | /* --- the following bits of info are returned as 64-bit signed integers --- */ | |
| 411 | case MESS_DEVINFO_INT_CASSETTE_DEFAULT_STATE: info->i = CASSETTE_STOPPED | CASSETTE_SPEAKER_ENABLED; break; | |
| 412 | ||
| 413 | default: cassette_device_getinfo(devclass, state, info); break; | |
| 414 | } | |
| 415 | } | |
| 416 | ||
| 417 | 409 | static void primo_cartslot_getinfo(const mess_device_class *devclass, UINT32 state, union devinfo *info) |
| 418 | 410 | { |
| 419 | 411 | /* cartslot */ |
| r3218 | r3219 | |
| 430 | 422 | } |
| 431 | 423 | |
| 432 | 424 | static SYSTEM_CONFIG_START( primoa ) |
| 433 | CONFIG_DEVICE(primo_cassette_getinfo) | |
| 434 | 425 | CONFIG_DEVICE(primo_cartslot_getinfo) |
| 435 | 426 | SYSTEM_CONFIG_END |
| 436 | 427 |
| r3218 | r3219 | |
|---|---|---|
| 521 | 521 | |
| 522 | 522 | /* devices */ |
| 523 | 523 | MDRV_QUICKLOAD_ADD(cbm_c64, "p00,prg,t64", CBM_QUICKLOAD_DELAY_SECONDS) |
| 524 | ||
| 525 | MDRV_CASSETTE_ADD( "cassette", cbm_cassette_config ) | |
| 524 | 526 | MACHINE_DRIVER_END |
| 525 | 527 | |
| 526 | 528 | static MACHINE_DRIVER_START( c64pal ) |
| r3218 | r3219 | |
| 549 | 551 | |
| 550 | 552 | /* devices */ |
| 551 | 553 | MDRV_QUICKLOAD_ADD(cbm_c64, "p00,prg,t64", CBM_QUICKLOAD_DELAY_SECONDS) |
| 554 | ||
| 555 | MDRV_CASSETTE_ADD( "cassette", cbm_cassette_config ) | |
| 552 | 556 | MACHINE_DRIVER_END |
| 553 | 557 | |
| 554 | 558 | static MACHINE_DRIVER_START( ultimax ) |
| r3218 | r3219 | |
| 570 | 574 | static MACHINE_DRIVER_START( c64gs ) |
| 571 | 575 | MDRV_IMPORT_FROM( c64pal ) |
| 572 | 576 | MDRV_SOUND_REMOVE( "dac" ) |
| 577 | MDRV_CASSETTE_REMOVE( "cassette" ) | |
| 573 | 578 | MDRV_QUICKLOAD_REMOVE |
| 574 | 579 | MACHINE_DRIVER_END |
| 575 | 580 | |
| r3218 | r3219 | |
| 578 | 583 | MDRV_IMPORT_FROM( c64pal ) |
| 579 | 584 | // MDRV_IMPORT_FROM( cpu_vc1541 ) |
| 580 | 585 | MDRV_SOUND_REMOVE( "dac" ) |
| 586 | MDRV_CASSETTE_REMOVE( "cassette" ) | |
| 581 | 587 | #ifdef CPU_SYNC |
| 582 | 588 | MDRV_INTERLEAVE(1) |
| 583 | 589 | #else |
| r3218 | r3219 | |
| 699 | 705 | static SYSTEM_CONFIG_START(c64) |
| 700 | 706 | CONFIG_DEVICE(c64_cartslot_getinfo) |
| 701 | 707 | CONFIG_DEVICE(cbmfloppy_device_getinfo) |
| 702 | CONFIG_DEVICE(datasette_device_getinfo) | |
| 703 | 708 | SYSTEM_CONFIG_END |
| 704 | 709 | |
| 705 | 710 | static SYSTEM_CONFIG_START(sx64) |
| r3218 | r3219 | |
| 709 | 714 | |
| 710 | 715 | static SYSTEM_CONFIG_START(ultimax) |
| 711 | 716 | CONFIG_DEVICE(ultimax_cartslot_getinfo) |
| 712 | CONFIG_DEVICE(datasette_device_getinfo) | |
| 713 | 717 | SYSTEM_CONFIG_END |
| 714 | 718 | |
| 715 | 719 | static SYSTEM_CONFIG_START(c64gs) |
| r3218 | r3219 | |
|---|---|---|
| 260 | 260 | svi318_psg_port_b_w |
| 261 | 261 | }; |
| 262 | 262 | |
| 263 | static const cassette_config svi318_cassette_config = | |
| 264 | { | |
| 265 | svi_cassette_formats, | |
| 266 | NULL, | |
| 267 | CASSETTE_PLAY | |
| 268 | }; | |
| 269 | ||
| 263 | 270 | static MACHINE_DRIVER_START( svi318 ) |
| 264 | 271 | /* Basic machine hardware */ |
| 265 | 272 | MDRV_CPU_ADD( "main", Z80, 3579545 ) /* 3.579545 Mhz */ |
| r3218 | r3219 | |
| 287 | 294 | MDRV_SPEAKER_STANDARD_MONO("mono") |
| 288 | 295 | MDRV_SOUND_ADD("dac", DAC, 0) |
| 289 | 296 | MDRV_SOUND_ROUTE(ALL_OUTPUTS, "mono", 0.25) |
| 290 | MDRV_SOUND_ADD(" | |
| 297 | MDRV_SOUND_ADD("cassette", WAVE, 0) | |
| 291 | 298 | MDRV_SOUND_ROUTE(ALL_OUTPUTS, "mono", 0.25) |
| 292 | 299 | MDRV_SOUND_ADD("ay8910", AY8910, 1789773) |
| 293 | 300 | MDRV_SOUND_CONFIG(svi318_ay8910_interface) |
| r3218 | r3219 | |
| 295 | 302 | |
| 296 | 303 | /* printer */ |
| 297 | 304 | MDRV_DEVICE_ADD("printer", PRINTER) |
| 305 | ||
| 306 | MDRV_CASSETTE_ADD( "cassette", svi318_cassette_config ) | |
| 298 | 307 | MACHINE_DRIVER_END |
| 299 | 308 | |
| 300 | 309 | static MACHINE_DRIVER_START( svi318n ) |
| r3218 | r3219 | |
| 363 | 372 | MDRV_SPEAKER_STANDARD_MONO("mono") |
| 364 | 373 | MDRV_SOUND_ADD("dac", DAC, 0) |
| 365 | 374 | MDRV_SOUND_ROUTE(ALL_OUTPUTS, "mono", 0.25) |
| 366 | MDRV_SOUND_ADD(" | |
| 375 | MDRV_SOUND_ADD("cassette", WAVE, 0) | |
| 367 | 376 | MDRV_SOUND_ROUTE(ALL_OUTPUTS, "mono", 0.25) |
| 368 | 377 | MDRV_SOUND_ADD("ay8910", AY8910, 1789773) |
| 369 | 378 | MDRV_SOUND_CONFIG(svi318_ay8910_interface) |
| r3218 | r3219 | |
| 371 | 380 | |
| 372 | 381 | /* printer */ |
| 373 | 382 | MDRV_DEVICE_ADD("printer", PRINTER) |
| 383 | ||
| 384 | MDRV_CASSETTE_ADD( "cassette", svi318_cassette_config ) | |
| 374 | 385 | MACHINE_DRIVER_END |
| 375 | 386 | |
| 376 | 387 | static MACHINE_DRIVER_START( svi328n_806 ) |
| r3218 | r3219 | |
| 448 | 459 | ROMX_LOAD ("svi806se.rom", 0x0000, 0x1000, CRC(daea8956) SHA1(3f16d5513ad35692488ae7d864f660e76c6e8ed3), ROM_BIOS(2)) |
| 449 | 460 | ROM_END |
| 450 | 461 | |
| 451 | static void svi318_cassette_getinfo(const mess_device_class *devclass, UINT32 state, union devinfo *info) | |
| 452 | { | |
| 453 | /* cassette */ | |
| 454 | switch(state) | |
| 455 | { | |
| 456 | /* --- the following bits of info are returned as 64-bit signed integers --- */ | |
| 457 | case MESS_DEVINFO_INT_COUNT: | |
| 458 | info->i = 1; | |
| 459 | break; | |
| 460 | 462 | |
| 461 | /* --- the following bits of info are returned as pointers to data or functions --- */ | |
| 462 | case MESS_DEVINFO_PTR_CASSETTE_FORMATS: | |
| 463 | info->p = (void *) svi_cassette_formats; | |
| 464 | break; | |
| 465 | ||
| 466 | default: | |
| 467 | cassette_device_getinfo(devclass, state, info); | |
| 468 | break; | |
| 469 | } | |
| 470 | } | |
| 471 | ||
| 472 | 463 | static void svi318_cartslot_getinfo(const mess_device_class *devclass, UINT32 state, union devinfo *info) |
| 473 | 464 | { |
| 474 | 465 | /* cartslot */ |
| r3218 | r3219 | |
| 528 | 519 | } |
| 529 | 520 | |
| 530 | 521 | static SYSTEM_CONFIG_START( svi318_common ) |
| 531 | CONFIG_DEVICE(svi318_cassette_getinfo) | |
| 532 | 522 | CONFIG_DEVICE(svi318_cartslot_getinfo) |
| 533 | 523 | CONFIG_DEVICE(svi318_floppy_getinfo) |
| 534 | 524 | SYSTEM_CONFIG_END |
| r3218 | r3219 | |
|---|---|---|
| 268 | 268 | MDRV_SPEAKER_STANDARD_MONO("mono") |
| 269 | 269 | MDRV_SOUND_ADD("dac", DAC, 0) |
| 270 | 270 | MDRV_SOUND_ROUTE(ALL_OUTPUTS, "mono", 0.20) |
| 271 | MDRV_SOUND_ADD("wave.1", WAVE, 0) | |
| 272 | MDRV_SOUND_ROUTE(ALL_OUTPUTS, "mono", 0.20) | |
| 273 | MDRV_SOUND_ADD("wave.2", WAVE, 0) | |
| 274 | MDRV_SOUND_ROUTE(ALL_OUTPUTS, "mono", 0.20) | |
| 271 | // MDRV_SOUND_ADD("cassette, WAVE, 0) | |
| 272 | // MDRV_SOUND_ROUTE(ALL_OUTPUTS, "mono", 0.20) | |
| 275 | 273 | MDRV_SOUND_ADD("sn76496", SN76496, 3579545) /* 3.579545 MHz */ |
| 276 | 274 | MDRV_SOUND_ROUTE(ALL_OUTPUTS, "mono", 0.75) |
| 277 | 275 | MDRV_SOUND_ADD("tms5220", TMS5220, 680000L) |
| r3218 | r3219 | |
| 284 | 282 | MDRV_IMPORT_FROM( smc92x4_hd ) |
| 285 | 283 | |
| 286 | 284 | MDRV_DEVICE_ADD( "ide_harddisk", IDE_HARDDISK ) |
| 285 | ||
| 286 | /* MDRV_CASSETTE_ADD( "cassette", default_cassette_config ) */ | |
| 287 | 287 | MACHINE_DRIVER_END |
| 288 | 288 | |
| 289 | 289 | |
| r3218 | r3219 | |
| 312 | 312 | ROM_LOAD_OPTIONAL("spchrom.bin", 0x0000, 0x8000, CRC(58b155f7) SHA1(382292295c00dff348d7e17c5ce4da12a1d87763)) /* system speech ROM */ |
| 313 | 313 | ROM_END |
| 314 | 314 | |
| 315 | #ifdef UNUSED_FUNCTION | |
| 316 | static void ti99_4p_cassette_getinfo(const mess_device_class *devclass, UINT32 state, union devinfo *info) | |
| 317 | { | |
| 318 | /* cassette */ | |
| 319 | switch(state) | |
| 320 | { | |
| 321 | /* --- the following bits of info are returned as 64-bit signed integers --- */ | |
| 322 | case MESS_DEVINFO_INT_COUNT: info->i = 2; break; | |
| 323 | ||
| 324 | default: cassette_device_getinfo(devclass, state, info); break; | |
| 325 | } | |
| 326 | } | |
| 327 | #endif | |
| 328 | ||
| 329 | 315 | static void ti99_4p_floppy_getinfo(const mess_device_class *devclass, UINT32 state, union devinfo *info) |
| 330 | 316 | { |
| 331 | 317 | /* floppy */ |
| r3218 | r3219 | |
|---|---|---|
| 1432 | 1432 | MDRV_IMPORT_FROM( pc_hdc ) |
| 1433 | 1433 | MACHINE_DRIVER_END |
| 1434 | 1434 | |
| 1435 | static const cassette_config ibm5150_cassette_config = | |
| 1436 | { | |
| 1437 | cassette_default_formats, | |
| 1438 | NULL, | |
| 1439 | CASSETTE_PLAY | CASSETTE_MOTOR_DISABLED | CASSETTE_SPEAKER_ENABLED | |
| 1440 | }; | |
| 1441 | ||
| 1435 | 1442 | static MACHINE_DRIVER_START( ibm5150 ) |
| 1436 | 1443 | /* basic machine hardware */ |
| 1437 | 1444 | MDRV_CPU_ADD("main", I8088, XTAL_14_31818MHz/3) |
| r3218 | r3219 | |
| 1492 | 1499 | |
| 1493 | 1500 | /* harddisk */ |
| 1494 | 1501 | MDRV_IMPORT_FROM( pc_hdc ) |
| 1502 | ||
| 1503 | MDRV_CASSETTE_ADD( "cassette", ibm5150_cassette_config ) | |
| 1495 | 1504 | MACHINE_DRIVER_END |
| 1496 | 1505 | |
| 1497 | 1506 | static MACHINE_DRIVER_START( pccga ) |
| r3218 | r3219 | |
| 1948 | 1957 | MDRV_DEVICE_ADD("printer", PRINTER) |
| 1949 | 1958 | MDRV_DEVICE_ADD("printer2", PRINTER) |
| 1950 | 1959 | MDRV_DEVICE_ADD("printer3", PRINTER) |
| 1960 | ||
| 1961 | MDRV_CASSETTE_ADD( "cassette", ibm5150_cassette_config ) | |
| 1951 | 1962 | MACHINE_DRIVER_END |
| 1952 | 1963 | |
| 1953 | 1964 | #if 0 |
| r3218 | r3219 | |
| 2363 | 2374 | ROM_END |
| 2364 | 2375 | |
| 2365 | 2376 | |
| 2366 | static void ibmpc_cassette_getinfo(const mess_device_class *devclass, UINT32 state, union devinfo *info) { | |
| 2367 | switch( state ) { | |
| 2368 | case MESS_DEVINFO_INT_COUNT: info->i = 1; break; | |
| 2369 | case MESS_DEVINFO_INT_CASSETTE_DEFAULT_STATE: info->i = CASSETTE_PLAY | CASSETTE_MOTOR_DISABLED | CASSETTE_SPEAKER_ENABLED; break; | |
| 2370 | ||
| 2371 | default: cassette_device_getinfo(devclass, state, info); break; | |
| 2372 | } | |
| 2373 | } | |
| 2374 | ||
| 2375 | ||
| 2376 | 2377 | static void ibmpc_floppy_getinfo(const mess_device_class *devclass, UINT32 state, union devinfo *info) |
| 2377 | 2378 | { |
| 2378 | 2379 | /* floppy */ |
| r3218 | r3219 | |
| 2409 | 2410 | |
| 2410 | 2411 | static SYSTEM_CONFIG_START(ibm5150) |
| 2411 | 2412 | CONFIG_RAM_DEFAULT( 640 * 1024 ) |
| 2412 | CONFIG_DEVICE(ibmpc_cassette_getinfo) | |
| 2413 | 2413 | CONFIG_DEVICE(ibmpc_floppy_getinfo) |
| 2414 | 2414 | SYSTEM_CONFIG_END |
| 2415 | 2415 | |
| r3218 | r3219 | |
| 2422 | 2422 | |
| 2423 | 2423 | static SYSTEM_CONFIG_START(pcjr) |
| 2424 | 2424 | CONFIG_RAM_DEFAULT( 640 * 1024 ) |
| 2425 | CONFIG_DEVICE(ibmpc_cassette_getinfo) | |
| 2426 | 2425 | CONFIG_DEVICE(ibmpc_floppy_getinfo) |
| 2427 | 2426 | CONFIG_DEVICE(pcjr_cartslot_getinfo) |
| 2428 | 2427 | SYSTEM_CONFIG_END |
| r3218 | r3219 | |
|---|---|---|
| 499 | 499 | }; |
| 500 | 500 | |
| 501 | 501 | |
| 502 | ||
| 503 | 502 | static MACHINE_DRIVER_START(ti99_4_60hz) |
| 504 | 503 | /* basic machine hardware */ |
| 505 | 504 | /* TMS9900 CPU @ 3.0 MHz */ |
| r3218 | r3219 | |
| 519 | 518 | |
| 520 | 519 | /* sound hardware */ |
| 521 | 520 | MDRV_SPEAKER_STANDARD_MONO("mono") |
| 522 | MDRV_SOUND_ADD(" | |
| 521 | MDRV_SOUND_ADD("cassette1", WAVE, 0) | |
| 523 | 522 | MDRV_SOUND_ROUTE(ALL_OUTPUTS, "mono", 0.20) |
| 524 | MDRV_SOUND_ADD(" | |
| 523 | MDRV_SOUND_ADD("cassette2", WAVE, 0) | |
| 525 | 524 | MDRV_SOUND_ROUTE(ALL_OUTPUTS, "mono", 0.20) |
| 526 | 525 | MDRV_SOUND_ADD("sn76496", SN76496, 3579545) /* 3.579545 MHz */ |
| 527 | 526 | MDRV_SOUND_ROUTE(ALL_OUTPUTS, "mono", 0.75) |
| r3218 | r3219 | |
| 535 | 534 | MDRV_IMPORT_FROM( smc92x4_hd ) |
| 536 | 535 | |
| 537 | 536 | MDRV_DEVICE_ADD( "ide_harddisk", IDE_HARDDISK ) |
| 537 | ||
| 538 | MDRV_CASSETTE_ADD( "cassette1", default_cassette_config ) | |
| 539 | MDRV_CASSETTE_ADD( "cassette2", default_cassette_config ) | |
| 538 | 540 | MACHINE_DRIVER_END |
| 539 | 541 | |
| 540 | 542 | static MACHINE_DRIVER_START(ti99_4_50hz) |
| r3218 | r3219 | |
| 561 | 563 | MDRV_SOUND_ADD("tms5220", TMS5220, 680000L) |
| 562 | 564 | MDRV_SOUND_CONFIG(ti99_4x_tms5220interface) |
| 563 | 565 | MDRV_SOUND_ROUTE(ALL_OUTPUTS, "mono", 0.50) |
| 564 | MDRV_SOUND_ADD(" | |
| 566 | MDRV_SOUND_ADD("cassette1", WAVE, 0) | |
| 565 | 567 | MDRV_SOUND_ROUTE(ALL_OUTPUTS, "mono", 0.20) |
| 566 | 568 | |
| 567 | 569 | /* devices */ |
| r3218 | r3219 | |
| 570 | 572 | MDRV_IMPORT_FROM( smc92x4_hd ) |
| 571 | 573 | |
| 572 | 574 | MDRV_DEVICE_ADD( "ide_harddisk", IDE_HARDDISK ) |
| 575 | ||
| 576 | MDRV_CASSETTE_ADD( "cassette1", default_cassette_config ) | |
| 577 | MDRV_CASSETTE_ADD( "cassette2", default_cassette_config ) | |
| 573 | 578 | MACHINE_DRIVER_END |
| 574 | 579 | |
| 575 | 580 | static MACHINE_DRIVER_START(ti99_4a_60hz) |
| r3218 | r3219 | |
| 596 | 601 | MDRV_SOUND_ADD("tms5220", TMS5220, 680000L) |
| 597 | 602 | MDRV_SOUND_CONFIG(ti99_4x_tms5220interface) |
| 598 | 603 | MDRV_SOUND_ROUTE(ALL_OUTPUTS, "mono", 0.50) |
| 599 | MDRV_SOUND_ADD(" | |
| 604 | MDRV_SOUND_ADD("cassette1", WAVE, 0) | |
| 600 | 605 | MDRV_SOUND_ROUTE(ALL_OUTPUTS, "mono", 0.20) |
| 601 | 606 | |
| 602 | 607 | /* devices */ |
| r3218 | r3219 | |
| 605 | 610 | MDRV_IMPORT_FROM( smc92x4_hd ) |
| 606 | 611 | |
| 607 | 612 | MDRV_DEVICE_ADD( "ide_harddisk", IDE_HARDDISK ) |
| 613 | ||
| 614 | MDRV_CASSETTE_ADD( "cassette1", default_cassette_config ) | |
| 615 | MDRV_CASSETTE_ADD( "cassette2", default_cassette_config ) | |
| 608 | 616 | MACHINE_DRIVER_END |
| 609 | 617 | |
| 610 | 618 | |
| r3218 | r3219 | |
| 632 | 640 | MDRV_SOUND_ADD("tms5220", TMS5220, 680000L) |
| 633 | 641 | MDRV_SOUND_CONFIG(ti99_4x_tms5220interface) |
| 634 | 642 | MDRV_SOUND_ROUTE(ALL_OUTPUTS, "mono", 0.50) |
| 635 | MDRV_SOUND_ADD(" | |
| 643 | MDRV_SOUND_ADD("cassette1", WAVE, 0) | |
| 636 | 644 | MDRV_SOUND_ROUTE(ALL_OUTPUTS, "mono", 0.20) |
| 637 | 645 | |
| 638 | 646 | /* devices */ |
| r3218 | r3219 | |
| 641 | 649 | MDRV_IMPORT_FROM( smc92x4_hd ) |
| 642 | 650 | |
| 643 | 651 | MDRV_DEVICE_ADD( "ide_harddisk", IDE_HARDDISK ) |
| 652 | ||
| 653 | MDRV_CASSETTE_ADD( "cassette1", default_cassette_config ) | |
| 654 | MDRV_CASSETTE_ADD( "cassette2", default_cassette_config ) | |
| 644 | 655 | MACHINE_DRIVER_END |
| 645 | 656 | |
| 646 | 657 | |
| r3218 | r3219 | |
| 676 | 687 | MDRV_SOUND_ADD("tms5220", TMS5220, 680000L) |
| 677 | 688 | MDRV_SOUND_CONFIG(ti99_4x_tms5220interface) |
| 678 | 689 | MDRV_SOUND_ROUTE(ALL_OUTPUTS, "mono", 0.50) |
| 679 | MDRV_SOUND_ADD(" | |
| 690 | MDRV_SOUND_ADD("cassette1", WAVE, 0) | |
| 680 | 691 | MDRV_SOUND_ROUTE(ALL_OUTPUTS, "mono", 0.20) |
| 681 | 692 | |
| 682 | 693 | /* devices */ |
| r3218 | r3219 | |
| 685 | 696 | MDRV_IMPORT_FROM( smc92x4_hd ) |
| 686 | 697 | |
| 687 | 698 | MDRV_DEVICE_ADD( "ide_harddisk", IDE_HARDDISK ) |
| 699 | ||
| 700 | MDRV_CASSETTE_ADD( "cassette1", default_cassette_config ) | |
| 701 | MDRV_CASSETTE_ADD( "cassette2", default_cassette_config ) | |
| 688 | 702 | MACHINE_DRIVER_END |
| 689 | 703 | |
| 690 | 704 | |
| r3218 | r3219 | |
| 790 | 804 | * are emulated. |
| 791 | 805 | */ |
| 792 | 806 | |
| 793 | static void ti99_4_cassette_getinfo(const mess_device_class *devclass, UINT32 state, union devinfo *info) | |
| 794 | { | |
| 795 | /* cassette */ | |
| 796 | switch(state) | |
| 797 | { | |
| 798 | /* --- the following bits of info are returned as 64-bit signed integers --- */ | |
| 799 | case MESS_DEVINFO_INT_COUNT: info->i = 2; break; | |
| 800 | ||
| 801 | default: cassette_device_getinfo(devclass, state, info); break; | |
| 802 | } | |
| 803 | } | |
| 804 | ||
| 805 | 807 | static void ti99_4_cartslot_getinfo(const mess_device_class *devclass, UINT32 state, union devinfo *info) |
| 806 | 808 | { |
| 807 | 809 | /* cartslot */ |
| r3218 | r3219 | |
| 927 | 929 | } |
| 928 | 930 | |
| 929 | 931 | static SYSTEM_CONFIG_START(ti99_4) |
| 930 | CONFIG_DEVICE(ti99_4_cassette_getinfo) | |
| 931 | 932 | CONFIG_DEVICE(ti99_4_cartslot_getinfo) |
| 932 | 933 | CONFIG_DEVICE(ti99_4_floppy_getinfo) |
| 933 | 934 | CONFIG_DEVICE(ti99_4_parallel_getinfo) |
| r3218 | r3219 | |
|---|---|---|
| 152 | 152 | #define XTAL 6144000 |
| 153 | 153 | |
| 154 | 154 | |
| 155 | static const cassette_config galaxy_cassette_config = | |
| 156 | { | |
| 157 | gtp_cassette_formats, | |
| 158 | NULL, | |
| 159 | CASSETTE_STOPPED | CASSETTE_SPEAKER_ENABLED | CASSETTE_MOTOR_ENABLED | |
| 160 | }; | |
| 161 | ||
| 162 | ||
| 155 | 163 | static MACHINE_DRIVER_START( galaxy ) |
| 156 | 164 | /* basic machine hardware */ |
| 157 | 165 | MDRV_CPU_ADD("main", Z80, XTAL / 2) |
| r3218 | r3219 | |
| 176 | 184 | MDRV_SNAPSHOT_ADD(galaxy, "gal", 0) |
| 177 | 185 | |
| 178 | 186 | MDRV_SPEAKER_STANDARD_MONO("mono") |
| 179 | MDRV_SOUND_ADD(" | |
| 187 | MDRV_SOUND_ADD("cassette", WAVE, 0) | |
| 180 | 188 | MDRV_SOUND_ROUTE(ALL_OUTPUTS, "mono", 1.0) |
| 189 | ||
| 190 | MDRV_CASSETTE_ADD( "cassette", galaxy_cassette_config ) | |
| 181 | 191 | MACHINE_DRIVER_END |
| 182 | 192 | |
| 183 | 193 | static MACHINE_DRIVER_START( galaxyp ) |
| r3218 | r3219 | |
| 208 | 218 | MDRV_SPEAKER_STANDARD_MONO("mono") |
| 209 | 219 | MDRV_SOUND_ADD("ay8910", AY8910, XTAL/4) |
| 210 | 220 | MDRV_SOUND_CONFIG(galaxy_ay_interface) |
| 211 | MDRV_SOUND_ADD(" | |
| 221 | MDRV_SOUND_ADD("cassette", WAVE, 0) | |
| 212 | 222 | MDRV_SOUND_ROUTE(ALL_OUTPUTS, "mono", 1.00) |
| 223 | ||
| 224 | MDRV_CASSETTE_ADD( "cassette", galaxy_cassette_config ) | |
| 213 | 225 | MACHINE_DRIVER_END |
| 214 | 226 | |
| 215 | 227 | ROM_START (galaxy) |
| r3218 | r3219 | |
| 229 | 241 | ROM_LOAD ("galchr.bin", 0x0000, 0x0800, CRC(5c3b5bb5) SHA1(19429a61dc5e55ddec3242a8f695e06dd7961f88)) |
| 230 | 242 | ROM_END |
| 231 | 243 | |
| 232 | static void galaxy_common_cassette_getinfo(const mess_device_class *devclass, UINT32 state, union devinfo *info) | |
| 233 | { | |
| 234 | /* cassette */ | |
| 235 | switch(state) | |
| 236 | { | |
| 237 | /* --- the following bits of info are returned as 64-bit signed integers --- */ | |
| 238 | case MESS_DEVINFO_INT_COUNT: info->i = 1; break; | |
| 239 | case MESS_DEVINFO_INT_CASSETTE_DEFAULT_STATE: info->i = CASSETTE_STOPPED | CASSETTE_SPEAKER_ENABLED | CASSETTE_MOTOR_ENABLED; break; | |
| 240 | case MESS_DEVINFO_PTR_CASSETTE_FORMATS: info->p = (void *)gtp_cassette_formats; break; | |
| 241 | default: cassette_device_getinfo(devclass, state, info); break; | |
| 242 | } | |
| 243 | } | |
| 244 | 244 | |
| 245 | 245 | static SYSTEM_CONFIG_START(galaxy) |
| 246 | 246 | CONFIG_RAM(2 * 1024) |
| r3218 | r3219 | |
| 248 | 248 | CONFIG_RAM((6+16) * 1024) |
| 249 | 249 | CONFIG_RAM((6+32) * 1024) |
| 250 | 250 | CONFIG_RAM((6+48) * 1024) |
| 251 | CONFIG_DEVICE(galaxy_common_cassette_getinfo) | |
| 252 | 251 | SYSTEM_CONFIG_END |
| 253 | 252 | |
| 254 | 253 | static SYSTEM_CONFIG_START(galaxyp) |
| 255 | 254 | CONFIG_RAM_DEFAULT((6+32) * 1024) |
| 256 | CONFIG_DEVICE(galaxy_common_cassette_getinfo) | |
| 257 | 255 | SYSTEM_CONFIG_END |
| 258 | 256 | |
| 259 | 257 | /* YEAR NAME PARENT COMPAT MACHINE INPUT INIT CONFIG COMPANY FULLNAME */ |
| r3218 | r3219 | |
|---|---|---|
| 700 | 700 | //}; |
| 701 | 701 | |
| 702 | 702 | |
| 703 | static const cassette_config bbc_cassette_config = | |
| 704 | { | |
| 705 | bbc_cassette_formats, | |
| 706 | NULL, | |
| 707 | CASSETTE_PLAY | |
| 708 | }; | |
| 709 | ||
| 710 | ||
| 703 | 711 | static MACHINE_DRIVER_START( bbca ) |
| 704 | 712 | /* basic machine hardware */ |
| 705 | 713 | MDRV_CPU_ADD("main", M6502, 2000000) /* 2.00Mhz */ |
| r3218 | r3219 | |
| 729 | 737 | MDRV_SOUND_ADD("sn76489", SN76489, 4000000) /* 4 MHz */ |
| 730 | 738 | MDRV_SOUND_ROUTE(ALL_OUTPUTS, "mono", 1.00) |
| 731 | 739 | // MDRV_SOUND_ADD("tms5220", TMS5220, tms5220_interface) |
| 740 | ||
| 741 | MDRV_CASSETTE_ADD( "cassette", bbc_cassette_config ) | |
| 732 | 742 | MACHINE_DRIVER_END |
| 733 | 743 | |
| 734 | 744 | |
| r3218 | r3219 | |
| 796 | 806 | |
| 797 | 807 | /* printer */ |
| 798 | 808 | MDRV_DEVICE_ADD("printer", PRINTER) |
| 809 | ||
| 810 | MDRV_CASSETTE_ADD( "cassette", bbc_cassette_config ) | |
| 799 | 811 | MACHINE_DRIVER_END |
| 800 | 812 | |
| 801 | 813 | static void bbc_cartslot_getinfo(const mess_device_class *devclass, UINT32 state, union devinfo *info) |
| r3218 | r3219 | |
| 834 | 846 | } |
| 835 | 847 | } |
| 836 | 848 | |
| 837 | static void bbc_cassette_getinfo( const mess_device_class *devclass, UINT32 state, union devinfo *info ) { | |
| 838 | switch( state ) { | |
| 839 | case MESS_DEVINFO_INT_COUNT: | |
| 840 | info->i = 1; | |
| 841 | break; | |
| 842 | case MESS_DEVINFO_PTR_CASSETTE_FORMATS: | |
| 843 | info->p = (void *)bbc_cassette_formats; | |
| 844 | break; | |
| 845 | default: | |
| 846 | cassette_device_getinfo( devclass, state, info ); | |
| 847 | break; | |
| 848 | } | |
| 849 | } | |
| 850 | 849 | |
| 851 | static SYSTEM_CONFIG_START(bbca) | |
| 852 | CONFIG_DEVICE(bbc_cassette_getinfo) | |
| 853 | SYSTEM_CONFIG_END | |
| 854 | ||
| 855 | ||
| 856 | 850 | static SYSTEM_CONFIG_START(bbc) |
| 857 | 851 | CONFIG_DEVICE(bbc_cartslot_getinfo) |
| 858 | 852 | CONFIG_DEVICE(bbc_floppy_getinfo) |
| 859 | CONFIG_DEVICE(bbc_cassette_getinfo) | |
| 860 | 853 | SYSTEM_CONFIG_END |
| 861 | 854 | |
| 862 | 855 | |
| 863 | 856 | |
| 864 | 857 | /* YEAR NAME PARENT COMPAT MACHINE INPUT INIT CONFIG COMPANY FULLNAME */ |
| 865 | COMP ( 1981, bbca, 0, 0, bbca, bbca, bbc, | |
| 858 | COMP ( 1981, bbca, 0, 0, bbca, bbca, bbc, 0 | |
| 866 | 859 | COMP ( 1981, bbcb, bbca, 0, bbcb, bbca, bbc, bbc, "Acorn","BBC Micro Model B" , 0) |
| 867 | 860 | COMP ( 1985, bbcbp, bbca, 0, bbcbp, bbca, bbc, bbc, "Acorn","BBC Micro Model B+ 64K" , 0) |
| 868 | 861 | COMP ( 1985, bbcbp128, bbca, 0, bbcbp128, bbca, bbc, bbc, "Acorn","BBC Micro Model B+ 128k" , 0) |
| r3218 | r3219 | |
|---|---|---|
| 398 | 398 | cpunum_set_input_line(machine, 0, 0, HOLD_LINE); |
| 399 | 399 | } |
| 400 | 400 | |
| 401 | static const cassette_config laser_cassette_config = | |
| 402 | { | |
| 403 | vtech2_cassette_formats, | |
| 404 | NULL, | |
| 405 | CASSETTE_PLAY | |
| 406 | }; | |
| 407 | ||
| 401 | 408 | static MACHINE_DRIVER_START( laser350 ) |
| 402 | 409 | /* basic machine hardware */ |
| 403 | 410 | MDRV_CPU_ADD("main", Z80, 3694700) /* 3.694700 Mhz */ |
| r3218 | r3219 | |
| 424 | 431 | |
| 425 | 432 | /* sound hardware */ |
| 426 | 433 | MDRV_SPEAKER_STANDARD_MONO("mono") |
| 427 | MDRV_SOUND_ADD(" | |
| 434 | MDRV_SOUND_ADD("cassette", WAVE, 0) | |
| 428 | 435 | MDRV_SOUND_ROUTE(ALL_OUTPUTS, "mono", 0.50) |
| 429 | 436 | MDRV_SOUND_ADD("speaker", SPEAKER, 0) |
| 430 | 437 | MDRV_SOUND_ROUTE(ALL_OUTPUTS, "mono", 0.75) |
| 438 | ||
| 439 | MDRV_CASSETTE_ADD( "cassette", laser_cassette_config ) | |
| 431 | 440 | MACHINE_DRIVER_END |
| 432 | 441 | |
| 433 | 442 | |
| r3218 | r3219 | |
| 478 | 487 | |
| 479 | 488 | ***************************************************************************/ |
| 480 | 489 | |
| 481 | static void laser_cassette_getinfo(const mess_device_class *devclass, UINT32 state, union devinfo *info) | |
| 482 | { | |
| 483 | /* cassette */ | |
| 484 | switch(state) | |
| 485 | { | |
| 486 | /* --- the following bits of info are returned as 64-bit signed integers --- */ | |
| 487 | case MESS_DEVINFO_INT_COUNT: info->i = 1; break; | |
| 488 | ||
| 489 | /* --- the following bits of info are returned as pointers to data or functions --- */ | |
| 490 | case MESS_DEVINFO_PTR_CASSETTE_FORMATS: info->p = (void *) vtech2_cassette_formats; break; | |
| 491 | ||
| 492 | default: cassette_device_getinfo(devclass, state, info); break; | |
| 493 | } | |
| 494 | } | |
| 495 | ||
| 496 | 490 | static void laser_cartslot_getinfo(const mess_device_class *devclass, UINT32 state, union devinfo *info) |
| 497 | 491 | { |
| 498 | 492 | /* cartslot */ |
| r3218 | r3219 | |
| 533 | 527 | } |
| 534 | 528 | |
| 535 | 529 | static SYSTEM_CONFIG_START(laser) |
| 536 | CONFIG_DEVICE(laser_cassette_getinfo) | |
| 537 | 530 | CONFIG_DEVICE(laser_cartslot_getinfo) |
| 538 | 531 | CONFIG_DEVICE(laser_floppy_getinfo) |
| 539 | 532 | SYSTEM_CONFIG_END |
| r3218 | r3219 | |
|---|---|---|
| 362 | 362 | |
| 363 | 363 | /* sound hardware */ |
| 364 | 364 | MDRV_SPEAKER_STANDARD_MONO("mono") |
| 365 | MDRV_SOUND_ADD(" | |
| 365 | MDRV_SOUND_ADD("cassette", WAVE, 0) | |
| 366 | 366 | MDRV_SOUND_ROUTE(ALL_OUTPUTS, "mono", 0.25) |
| 367 | 367 | MDRV_SOUND_ADD("speaker", SPEAKER, 0) |
| 368 | 368 | MDRV_SOUND_ROUTE(ALL_OUTPUTS, "mono", 0.50) |
| 369 | 369 | |
| 370 | 370 | /* devices */ |
| 371 | 371 | MDRV_QUICKLOAD_ADD(kc, "kcc", 0) |
| 372 | ||
| 373 | MDRV_CASSETTE_ADD( "cassette", default_cassette_config ) | |
| 372 | 374 | MACHINE_DRIVER_END |
| 373 | 375 | |
| 374 | 376 | |
| r3218 | r3219 | |
| 419 | 421 | ROM_LOAD("caos__e0.853", 0x12000, 0x2000, CRC(52bc2199) SHA1(207d3e1c4ebf82ac7553ed0a0850b627b9796d4b)) |
| 420 | 422 | ROM_END |
| 421 | 423 | |
| 422 | static void kc85_cassette_getinfo(const mess_device_class *devclass, UINT32 state, union devinfo *info) | |
| 423 | { | |
| 424 | /* cassette */ | |
| 425 | switch(state) | |
| 426 | { | |
| 427 | /* --- the following bits of info are returned as 64-bit signed integers --- */ | |
| 428 | case MESS_DEVINFO_INT_COUNT: info->i = 1; break; | |
| 429 | 424 | |
| 430 | default: cassette_device_getinfo(devclass, state, info); break; | |
| 431 | } | |
| 432 | } | |
| 433 | ||
| 434 | 425 | static SYSTEM_CONFIG_START(kc85) |
| 435 | 426 | CONFIG_RAM_DEFAULT (64 * 1024) |
| 436 | CONFIG_DEVICE(kc85_cassette_getinfo) | |
| 437 | 427 | SYSTEM_CONFIG_END |
| 438 | 428 | |
| 439 | 429 | static void kc85d_floppy_getinfo(const mess_device_class *devclass, UINT32 state, union devinfo *info) |
| r3218 | r3219 | |
|---|---|---|
| 145 | 145 | - Removed MESS_DEBUG and the TESTDRIVER define and enabled a lot of |
| 146 | 146 | non-working drivers [Oliver Stöneberg] |
| 147 | 147 | |
| 148 | - Changed the cassette implementation into a regular mame device. [Wilbert Pol] | |
| 148 | 149 | |
| 149 | 150 | |
| 151 | ||
| 150 | 152 | 0.127 |
| 151 | 153 | |
| 152 | 154 | New System Drivers Supported (in no particular order): |
| Previous | 15994 Revisions | Next |