trunk/src/mame/drivers/attckufo.c
| r17658 | r17659 | |
| 66 | 66 | |
| 67 | 67 | DECLARE_READ8_MEMBER(attckufo_io_r); |
| 68 | 68 | DECLARE_WRITE8_MEMBER(attckufo_io_w); |
| 69 | | }; |
| 70 | 69 | |
| 71 | | |
| 72 | | |
| 73 | | static const rgb_t attckufo_palette[] = |
| 74 | | { |
| 75 | | /* ripped from vice, a very excellent emulator */ |
| 76 | | MAKE_RGB(0x00, 0x00, 0x00), |
| 77 | | MAKE_RGB(0xff, 0xff, 0xff), |
| 78 | | MAKE_RGB(0xf0, 0x00, 0x00), |
| 79 | | MAKE_RGB(0x00, 0xf0, 0xf0), |
| 80 | | |
| 81 | | MAKE_RGB(0x60, 0x00, 0x60), |
| 82 | | MAKE_RGB(0x00, 0xa0, 0x00), |
| 83 | | MAKE_RGB(0x00, 0x00, 0xf0), |
| 84 | | MAKE_RGB(0xd0, 0xd0, 0x00), |
| 85 | | |
| 86 | | MAKE_RGB(0xc0, 0xa0, 0x00), |
| 87 | | MAKE_RGB(0xff, 0xa0, 0x00), |
| 88 | | MAKE_RGB(0xf0, 0x80, 0x80), |
| 89 | | MAKE_RGB(0x00, 0xff, 0xff), |
| 90 | | |
| 91 | | MAKE_RGB(0xff, 0x00, 0xff), |
| 92 | | MAKE_RGB(0x00, 0xff, 0x00), |
| 93 | | MAKE_RGB(0x00, 0xa0, 0xff), |
| 94 | | MAKE_RGB(0xff, 0xff, 0x00) |
| 70 | DECLARE_READ8_MEMBER(dma_read); |
| 71 | DECLARE_READ8_MEMBER(dma_read_color); |
| 95 | 72 | }; |
| 96 | 73 | |
| 97 | | static PALETTE_INIT( attckufo ) |
| 98 | | { |
| 99 | | palette_set_colors(machine, 0, attckufo_palette, ARRAY_LENGTH(attckufo_palette)); |
| 100 | | } |
| 101 | | |
| 102 | | |
| 103 | 74 | READ8_MEMBER(attckufo_state::attckufo_io_r) |
| 104 | 75 | { |
| 105 | 76 | switch(offset) |
| r17658 | r17659 | |
| 172 | 143 | return 0; |
| 173 | 144 | } |
| 174 | 145 | |
| 175 | | static int attckufo_dma_read( running_machine &machine, int offset ) |
| 146 | READ8_MEMBER(attckufo_state::dma_read) |
| 176 | 147 | { |
| 177 | | attckufo_state *state = machine.driver_data<attckufo_state>(); |
| 178 | | return state->m_maincpu->space(AS_PROGRAM)->read_byte(offset); |
| 148 | return m_maincpu->space(AS_PROGRAM)->read_byte(offset); |
| 179 | 149 | } |
| 180 | 150 | |
| 181 | | static int attckufo_dma_read_color( running_machine &machine, int offset ) |
| 151 | READ8_MEMBER(attckufo_state::dma_read_color) |
| 182 | 152 | { |
| 183 | | attckufo_state *state = machine.driver_data<attckufo_state>(); |
| 184 | | return state->m_maincpu->space(AS_PROGRAM)->read_byte(offset + 0x400); |
| 153 | return m_maincpu->space(AS_PROGRAM)->read_byte(offset + 0x400); |
| 185 | 154 | } |
| 186 | 155 | |
| 187 | 156 | static const mos6560_interface attckufo_6560_intf = |
| 188 | 157 | { |
| 189 | 158 | "screen", /* screen */ |
| 190 | 159 | MOS6560_ATTACKUFO, |
| 191 | | NULL, NULL, NULL, /* lightgun cb */ |
| 192 | | NULL, NULL, /* paddle cb */ |
| 193 | | attckufo_dma_read, attckufo_dma_read_color /* DMA */ |
| 160 | DEVCB_NULL, DEVCB_NULL, DEVCB_NULL, /* lightgun cb */ |
| 161 | DEVCB_NULL, DEVCB_NULL, /* paddle cb */ |
| 162 | DEVCB_DRIVER_MEMBER(attckufo_state, dma_read), |
| 163 | DEVCB_DRIVER_MEMBER(attckufo_state, dma_read_color) /* DMA */ |
| 194 | 164 | }; |
| 195 | 165 | |
| 196 | 166 | |
| r17658 | r17659 | |
| 209 | 179 | MCFG_SCREEN_VISIBLE_AREA(0, 23*8 - 1, 0, 22*8 - 1) |
| 210 | 180 | MCFG_SCREEN_UPDATE_STATIC(attckufo) |
| 211 | 181 | |
| 212 | | MCFG_PALETTE_LENGTH(ARRAY_LENGTH(attckufo_palette)) |
| 213 | | MCFG_PALETTE_INIT(attckufo) |
| 182 | MCFG_PALETTE_LENGTH(16) |
| 183 | MCFG_PALETTE_INIT(mos6560) |
| 214 | 184 | |
| 215 | 185 | /* sound hardware */ |
| 216 | 186 | MCFG_SPEAKER_STANDARD_MONO("mono") |
trunk/src/emu/sound/mos6560.c
| r17658 | r17659 | |
| 92 | 92 | int total_xsize, total_ysize, total_lines, total_vretracerate; |
| 93 | 93 | |
| 94 | 94 | /* DMA */ |
| 95 | | mos6560_dma_read dma_read; |
| 96 | | mos6560_dma_read_color dma_read_color; |
| 95 | devcb_resolved_read8 dma_read; |
| 96 | devcb_resolved_read8 dma_read_color; |
| 97 | 97 | UINT8 last_data; |
| 98 | 98 | |
| 99 | 99 | /* lightpen */ |
| 100 | | mos6560_lightpen_button_callback lightpen_button_cb; |
| 101 | | mos6560_lightpen_x_callback lightpen_x_cb; |
| 102 | | mos6560_lightpen_y_callback lightpen_y_cb; |
| 100 | devcb_resolved_read8 lightpen_button_cb; |
| 101 | devcb_resolved_read8 lightpen_x_cb; |
| 102 | devcb_resolved_read8 lightpen_y_cb; |
| 103 | 103 | |
| 104 | 104 | /* paddles */ |
| 105 | | mos6560_paddle_callback paddle_cb[2]; |
| 105 | devcb_resolved_read8 paddle_cb[2]; |
| 106 | 106 | |
| 107 | 107 | /* sound part */ |
| 108 | 108 | int tone1pos, tone2pos, tone3pos, |
| r17658 | r17659 | |
| 154 | 154 | |
| 155 | 155 | /* 2008-05 FP: lightpen code needs to read input port from vc20.c */ |
| 156 | 156 | |
| 157 | | #define LIGHTPEN_BUTTON ((mos6560->lightpen_button_cb != NULL) ? mos6560->lightpen_button_cb(device->machine()) : 0) |
| 158 | | #define LIGHTPEN_X_VALUE ((mos6560->lightpen_x_cb != NULL) ? mos6560->lightpen_x_cb(device->machine()) : 0) |
| 159 | | #define LIGHTPEN_Y_VALUE ((mos6560->lightpen_y_cb != NULL) ? mos6560->lightpen_y_cb(device->machine()) : 0) |
| 157 | #define LIGHTPEN_BUTTON ((!mos6560->lightpen_button_cb.isnull()) ? mos6560->lightpen_button_cb(0) : 0) |
| 158 | #define LIGHTPEN_X_VALUE ((!mos6560->lightpen_x_cb.isnull()) ? mos6560->lightpen_x_cb(0) : 0) |
| 159 | #define LIGHTPEN_Y_VALUE ((!mos6560->lightpen_y_cb.isnull()) ? mos6560->lightpen_y_cb(0) : 0) |
| 160 | 160 | |
| 161 | 161 | /* lightpen delivers values from internal counters |
| 162 | 162 | * they do not start with the visual area or frame area */ |
| r17658 | r17659 | |
| 198 | 198 | #define BACKGROUNDCOLOR (mos6560->reg[0x0f] >> 4) |
| 199 | 199 | #define FRAMECOLOR (mos6560->reg[0x0f] & 0x07) |
| 200 | 200 | |
| 201 | |
| 202 | static const rgb_t PALETTE[] = |
| 203 | { |
| 204 | /* ripped from vice, a very excellent emulator */ |
| 205 | MAKE_RGB(0x00, 0x00, 0x00), |
| 206 | MAKE_RGB(0xff, 0xff, 0xff), |
| 207 | MAKE_RGB(0xf0, 0x00, 0x00), |
| 208 | MAKE_RGB(0x00, 0xf0, 0xf0), |
| 209 | |
| 210 | MAKE_RGB(0x60, 0x00, 0x60), |
| 211 | MAKE_RGB(0x00, 0xa0, 0x00), |
| 212 | MAKE_RGB(0x00, 0x00, 0xf0), |
| 213 | MAKE_RGB(0xd0, 0xd0, 0x00), |
| 214 | |
| 215 | MAKE_RGB(0xc0, 0xa0, 0x00), |
| 216 | MAKE_RGB(0xff, 0xa0, 0x00), |
| 217 | MAKE_RGB(0xf0, 0x80, 0x80), |
| 218 | MAKE_RGB(0x00, 0xff, 0xff), |
| 219 | |
| 220 | MAKE_RGB(0xff, 0x00, 0xff), |
| 221 | MAKE_RGB(0x00, 0xff, 0x00), |
| 222 | MAKE_RGB(0x00, 0xa0, 0xff), |
| 223 | MAKE_RGB(0xff, 0xff, 0x00) |
| 224 | }; |
| 225 | |
| 226 | PALETTE_INIT( mos6560 ) |
| 227 | { |
| 228 | palette_set_colors(machine, 0, PALETTE, ARRAY_LENGTH(PALETTE)); |
| 229 | } |
| 230 | |
| 231 | |
| 201 | 232 | /***************************************************************************** |
| 202 | 233 | IMPLEMENTATION |
| 203 | 234 | *****************************************************************************/ |
| r17658 | r17659 | |
| 215 | 246 | |
| 216 | 247 | for (y = ybegin; y <= yend; y++) |
| 217 | 248 | { |
| 218 | | code = mos6560->dma_read(device->machine(), (mos6560->chargenaddr + ch * mos6560->charheight + y) & 0x3fff); |
| 249 | code = mos6560->dma_read((mos6560->chargenaddr + ch * mos6560->charheight + y) & 0x3fff); |
| 219 | 250 | mos6560->last_data = code; |
| 220 | 251 | mos6560->bitmap->pix16(y + yoff, xoff + 0) = color[code >> 7]; |
| 221 | 252 | mos6560->bitmap->pix16(y + yoff, xoff + 1) = color[(code >> 6) & 1]; |
| r17658 | r17659 | |
| 240 | 271 | |
| 241 | 272 | for (y = ybegin; y <= yend; y++) |
| 242 | 273 | { |
| 243 | | code = mos6560->dma_read(device->machine(), (mos6560->chargenaddr + ch * mos6560->charheight + y) & 0x3fff); |
| 274 | code = mos6560->dma_read((mos6560->chargenaddr + ch * mos6560->charheight + y) & 0x3fff); |
| 244 | 275 | mos6560->last_data = code; |
| 245 | 276 | mos6560->bitmap->pix16(y + yoff, xoff + 0) = |
| 246 | 277 | mos6560->bitmap->pix16(y + yoff, xoff + 1) = color[code >> 6]; |
| r17658 | r17659 | |
| 301 | 332 | |
| 302 | 333 | for (xoff = mos6560->xpos; (xoff < mos6560->xpos + mos6560->xsize) && (xoff < mos6560->total_xsize); xoff += 8, offs++) |
| 303 | 334 | { |
| 304 | | ch = mos6560->dma_read(device->machine(), (mos6560->videoaddr + offs) & 0x3fff); |
| 335 | ch = mos6560->dma_read((mos6560->videoaddr + offs) & 0x3fff); |
| 305 | 336 | mos6560->last_data = ch; |
| 306 | | attr = (mos6560->dma_read_color(device->machine(), (mos6560->videoaddr + offs) & 0x3fff)) & 0xf; |
| 337 | attr = (mos6560->dma_read_color((mos6560->videoaddr + offs) & 0x3fff)) & 0xf; |
| 307 | 338 | |
| 308 | 339 | if (mos6560->type == MOS6560_ATTACKUFO) |
| 309 | 340 | { |
| r17658 | r17659 | |
| 479 | 510 | break; |
| 480 | 511 | case 8: /* poti 1 */ |
| 481 | 512 | case 9: /* poti 2 */ |
| 482 | | val = (mos6560->paddle_cb != NULL) ? mos6560->paddle_cb[offset - 8](device->machine()) : mos6560->reg[offset]; |
| 513 | val = (!mos6560->paddle_cb->isnull()) ? mos6560->paddle_cb[offset - 8](0) : mos6560->reg[offset]; |
| 483 | 514 | break; |
| 484 | 515 | default: |
| 485 | 516 | val = mos6560->reg[offset]; |
| r17658 | r17659 | |
| 489 | 520 | return val; |
| 490 | 521 | } |
| 491 | 522 | |
| 492 | | UINT8 mos6560_bus_r( device_t *device ) |
| 523 | UINT8 mos6560_device::bus_r() |
| 493 | 524 | { |
| 494 | | mos6560_state *mos6560 = get_safe_token(device); |
| 525 | mos6560_state *mos6560 = get_safe_token(this); |
| 495 | 526 | |
| 496 | 527 | return mos6560->last_data; |
| 497 | 528 | } |
| r17658 | r17659 | |
| 527 | 558 | return 0; |
| 528 | 559 | } |
| 529 | 560 | |
| 561 | UINT32 mos6560_device::screen_update(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect) |
| 562 | { |
| 563 | return mos6560_video_update(this, bitmap, cliprect); |
| 564 | } |
| 565 | |
| 530 | 566 | /***************************************************************************** |
| 531 | 567 | SOUND IMPLEMENTATION |
| 532 | 568 | *****************************************************************************/ |
| r17658 | r17659 | |
| 820 | 856 | |
| 821 | 857 | mos6560->bitmap = auto_bitmap_ind16_alloc(device->machine(), width, height); |
| 822 | 858 | |
| 823 | | assert(intf->dma_read != NULL); |
| 824 | | assert(intf->dma_read_color != NULL); |
| 859 | // resolve callbacks |
| 860 | mos6560->dma_read.resolve(intf->dma_read, *device); |
| 861 | mos6560->dma_read_color.resolve(intf->dma_read_color, *device); |
| 862 | mos6560->lightpen_button_cb.resolve(intf->button_cb, *device); |
| 863 | mos6560->lightpen_x_cb.resolve(intf->x_cb, *device); |
| 864 | mos6560->lightpen_y_cb.resolve(intf->y_cb, *device); |
| 865 | mos6560->paddle_cb[0].resolve(intf->paddle0_cb, *device); |
| 866 | mos6560->paddle_cb[1].resolve(intf->paddle1_cb, *device); |
| 825 | 867 | |
| 826 | | mos6560->dma_read = intf->dma_read; |
| 827 | | mos6560->dma_read_color = intf->dma_read_color; |
| 828 | | |
| 829 | | mos6560->lightpen_button_cb = intf->button_cb; |
| 830 | | mos6560->lightpen_x_cb = intf->x_cb; |
| 831 | | mos6560->lightpen_y_cb = intf->y_cb; |
| 832 | | |
| 833 | | mos6560->paddle_cb[0] = intf->paddle0_cb; |
| 834 | | mos6560->paddle_cb[1] = intf->paddle1_cb; |
| 835 | | |
| 836 | 868 | switch (mos6560->type) |
| 837 | 869 | { |
| 838 | 870 | case MOS6560: |
trunk/src/emu/sound/mos6560.h
| r17658 | r17659 | |
| 15 | 15 | TYPE DEFINITIONS |
| 16 | 16 | ***************************************************************************/ |
| 17 | 17 | |
| 18 | | typedef UINT8 (*mos6560_lightpen_x_callback)(running_machine &machine); |
| 19 | | typedef UINT8 (*mos6560_lightpen_y_callback)(running_machine &machine); |
| 20 | | typedef UINT8 (*mos6560_lightpen_button_callback)(running_machine &machine); |
| 21 | | typedef UINT8 (*mos6560_paddle_callback)(running_machine &machine); |
| 22 | | |
| 23 | | typedef int (*mos6560_dma_read)(running_machine &machine, int); |
| 24 | | typedef int (*mos6560_dma_read_color)(running_machine &machine, int); |
| 25 | | |
| 26 | | |
| 27 | 18 | typedef enum |
| 28 | 19 | { |
| 29 | 20 | MOS6560_ATTACKUFO, // this is a 6560VIC derivative, missing some of the features |
| r17658 | r17659 | |
| 34 | 25 | typedef struct _mos6560_interface mos6560_interface; |
| 35 | 26 | struct _mos6560_interface |
| 36 | 27 | { |
| 37 | | const char *screen; |
| 28 | const char *screen; |
| 38 | 29 | |
| 39 | | mos6560_type type; |
| 30 | mos6560_type type; |
| 40 | 31 | |
| 41 | | mos6560_lightpen_x_callback x_cb; |
| 42 | | mos6560_lightpen_y_callback y_cb; |
| 43 | | mos6560_lightpen_button_callback button_cb; |
| 32 | devcb_read8 x_cb; |
| 33 | devcb_read8 y_cb; |
| 34 | devcb_read8 button_cb; |
| 44 | 35 | |
| 45 | | mos6560_paddle_callback paddle0_cb, paddle1_cb; |
| 36 | devcb_read8 paddle0_cb, paddle1_cb; |
| 46 | 37 | |
| 47 | | mos6560_dma_read dma_read; |
| 48 | | mos6560_dma_read_color dma_read_color; |
| 38 | devcb_read8 dma_read; |
| 39 | devcb_read8 dma_read_color; |
| 49 | 40 | }; |
| 50 | 41 | |
| 51 | 42 | /*************************************************************************** |
| r17658 | r17659 | |
| 97 | 88 | |
| 98 | 89 | // access to legacy token |
| 99 | 90 | void *token() const { assert(m_token != NULL); return m_token; } |
| 91 | |
| 92 | UINT8 bus_r(); |
| 93 | |
| 94 | UINT32 screen_update(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect); |
| 95 | |
| 100 | 96 | protected: |
| 101 | 97 | // device-level overrides |
| 102 | 98 | virtual void device_config_complete(); |
| r17658 | r17659 | |
| 121 | 117 | MCFG_SOUND_ADD(_tag, MOS656X, 0) \ |
| 122 | 118 | MCFG_DEVICE_CONFIG(_interface) |
| 123 | 119 | |
| 120 | #define MCFG_MOS6560_ADD(_tag, _screen_tag, _clock, _config) \ |
| 121 | MCFG_SCREEN_ADD(_screen_tag, RASTER) \ |
| 122 | MCFG_SCREEN_REFRESH_RATE(MOS6560_VRETRACERATE) \ |
| 123 | MCFG_SCREEN_VBLANK_TIME(ATTOSECONDS_IN_USEC(2500)) \ |
| 124 | MCFG_SCREEN_SIZE((MOS6560_XSIZE + 7) & ~7, MOS6560_YSIZE) \ |
| 125 | MCFG_SCREEN_VISIBLE_AREA(MOS6560_MAME_XPOS, MOS6560_MAME_XPOS + MOS6560_MAME_XSIZE - 1, MOS6560_MAME_YPOS, MOS6560_MAME_YPOS + MOS6560_MAME_YSIZE - 1) \ |
| 126 | MCFG_SCREEN_UPDATE_DEVICE(_tag, mos6560_device, screen_update) \ |
| 127 | MCFG_PALETTE_LENGTH(16) \ |
| 128 | MCFG_PALETTE_INIT(mos6560) \ |
| 129 | MCFG_SOUND_ADD(_tag, MOS656X, _clock) \ |
| 130 | MCFG_DEVICE_CONFIG(_config) |
| 124 | 131 | |
| 132 | #define MCFG_MOS6561_ADD(_tag, _screen_tag, _clock, _config) \ |
| 133 | MCFG_SCREEN_ADD(_screen_tag, RASTER) \ |
| 134 | MCFG_SCREEN_REFRESH_RATE(MOS6561_VRETRACERATE) \ |
| 135 | MCFG_SCREEN_VBLANK_TIME(ATTOSECONDS_IN_USEC(2500)) \ |
| 136 | MCFG_SCREEN_SIZE((MOS6561_XSIZE + 7) & ~7, MOS6561_YSIZE) \ |
| 137 | MCFG_SCREEN_VISIBLE_AREA(MOS6561_MAME_XPOS, MOS6561_MAME_XPOS + MOS6561_MAME_XSIZE - 1, MOS6561_MAME_YPOS, MOS6561_MAME_YPOS + MOS6561_MAME_YSIZE - 1) \ |
| 138 | MCFG_SCREEN_UPDATE_DEVICE(_tag, mos6560_device, screen_update) \ |
| 139 | MCFG_PALETTE_LENGTH(16) \ |
| 140 | MCFG_PALETTE_INIT(mos6560) \ |
| 141 | MCFG_SOUND_ADD(_tag, MOS656X, _clock) \ |
| 142 | MCFG_DEVICE_CONFIG(_config) |
| 143 | |
| 125 | 144 | /*************************************************************************** |
| 126 | 145 | I/O PROTOTYPES |
| 127 | 146 | ***************************************************************************/ |
| r17658 | r17659 | |
| 129 | 148 | WRITE8_DEVICE_HANDLER( mos6560_port_w ); |
| 130 | 149 | READ8_DEVICE_HANDLER( mos6560_port_r ); |
| 131 | 150 | |
| 132 | | UINT8 mos6560_bus_r( device_t *device ); |
| 133 | 151 | void mos6560_raster_interrupt_gen( device_t *device ); |
| 134 | 152 | UINT32 mos6560_video_update( device_t *device, bitmap_ind16 &bitmap, const rectangle &cliprect ); |
| 135 | 153 | |
| 154 | extern PALETTE_INIT( mos6560 ); |
| 136 | 155 | |
| 137 | 156 | #endif /* __MOS6560_H__ */ |
trunk/src/mess/drivers/vic20.c
| r17658 | r17659 | |
| 123 | 123 | |
| 124 | 124 | READ8_MEMBER( vic20_state::read ) |
| 125 | 125 | { |
| 126 | | UINT8 data = mos6560_bus_r(m_vic); |
| 126 | UINT8 data = m_vic->bus_r(); |
| 127 | 127 | |
| 128 | 128 | int ram1 = 1, ram2 = 1, ram3 = 1; |
| 129 | 129 | int blk1 = 1, blk2 = 1, blk3 = 1, blk5 = 1; |
| r17658 | r17659 | |
| 250 | 250 | break; |
| 251 | 251 | |
| 252 | 252 | case COLOR: |
| 253 | | m_color_ram[offset & 0x3ff] = data; |
| 253 | m_color_ram[offset & 0x3ff] = data & 0x0f; |
| 254 | 254 | break; |
| 255 | 255 | |
| 256 | 256 | case IO2: io2 = 0; break; |
| r17658 | r17659 | |
| 270 | 270 | // VIDEO |
| 271 | 271 | //************************************************************************** |
| 272 | 272 | |
| 273 | | static const unsigned char mos6560_palette[] = |
| 274 | | { |
| 275 | | // ripped from vice, a very excellent emulator |
| 276 | | // black, white, red, cyan |
| 277 | | 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xf0, 0x00, 0x00, 0x00, 0xf0, 0xf0, |
| 278 | | // purple, green, blue, yellow |
| 279 | | 0x60, 0x00, 0x60, 0x00, 0xa0, 0x00, 0x00, 0x00, 0xf0, 0xd0, 0xd0, 0x00, |
| 280 | | // orange, light orange, pink, light cyan, |
| 281 | | 0xc0, 0xa0, 0x00, 0xff, 0xa0, 0x00, 0xf0, 0x80, 0x80, 0x00, 0xff, 0xff, |
| 282 | | // light violett, light green, light blue, light yellow |
| 283 | | 0xff, 0x00, 0xff, 0x00, 0xff, 0x00, 0x00, 0xa0, 0xff, 0xff, 0xff, 0x00 |
| 284 | | }; |
| 285 | | |
| 286 | | static PALETTE_INIT( vic20 ) |
| 287 | | { |
| 288 | | int i; |
| 289 | | |
| 290 | | for (i = 0; i < sizeof(mos6560_palette) / 3; i++) |
| 291 | | { |
| 292 | | palette_set_color_rgb(machine, i, mos6560_palette[i * 3], mos6560_palette[i * 3 + 1], mos6560_palette[i * 3 + 2]); |
| 293 | | } |
| 294 | | } |
| 295 | | |
| 296 | | static SCREEN_UPDATE_IND16( vic20 ) |
| 297 | | { |
| 298 | | vic20_state *state = screen.machine().driver_data<vic20_state>(); |
| 299 | | mos6560_video_update(state->m_vic, bitmap, cliprect); |
| 300 | | return 0; |
| 301 | | } |
| 302 | | |
| 303 | 273 | static INTERRUPT_GEN( vic20_raster_interrupt ) |
| 304 | 274 | { |
| 305 | 275 | vic20_state *state = device->machine().driver_data<vic20_state>(); |
| r17658 | r17659 | |
| 644 | 614 | #define VC20ADDR2MOS6560ADDR(a) (((a) > 0x8000) ? ((a) & 0x1fff) : ((a) | 0x2000)) |
| 645 | 615 | #define MOS6560ADDR2VC20ADDR(a) (((a) > 0x2000) ? ((a) & 0x1fff) : ((a) | 0x8000)) |
| 646 | 616 | |
| 647 | | static int vic20_dma_read_color( running_machine &machine, int offset ) |
| 617 | READ8_MEMBER( vic20_state::vic_dma_read_color ) |
| 648 | 618 | { |
| 649 | | vic20_state *state = machine.driver_data<vic20_state>(); |
| 650 | | |
| 651 | | return state->m_color_ram[offset & 0x3ff]; |
| 619 | return m_color_ram[offset & 0x3ff]; |
| 652 | 620 | } |
| 653 | 621 | |
| 654 | | static int vic20_dma_read( running_machine &machine, int offset ) |
| 622 | READ8_MEMBER( vic20_state::vic_dma_read ) |
| 655 | 623 | { |
| 656 | | address_space *program = machine.device(M6502_TAG)->memory().space(AS_PROGRAM); |
| 624 | address_space *program = m_maincpu->memory().space(AS_PROGRAM); |
| 657 | 625 | |
| 658 | 626 | return program->read_byte(MOS6560ADDR2VC20ADDR(offset)); |
| 659 | 627 | } |
| 660 | 628 | |
| 661 | | static UINT8 vic20_lightx_cb( running_machine &machine ) |
| 629 | READ8_MEMBER( vic20_state::vic_lightx_cb ) |
| 662 | 630 | { |
| 663 | | return (machine.root_device().ioport("LIGHTX")->read_safe(0) & ~0x01); |
| 631 | return (ioport("LIGHTX")->read_safe(0) & ~0x01); |
| 664 | 632 | } |
| 665 | 633 | |
| 666 | | static UINT8 vic20_lighty_cb( running_machine &machine ) |
| 634 | READ8_MEMBER( vic20_state::vic_lighty_cb ) |
| 667 | 635 | { |
| 668 | | return (machine.root_device().ioport("LIGHTY")->read_safe(0) & ~0x01); |
| 636 | return (ioport("LIGHTY")->read_safe(0) & ~0x01); |
| 669 | 637 | } |
| 670 | 638 | |
| 671 | | static UINT8 vic20_lightbut_cb( running_machine &machine ) |
| 639 | READ8_MEMBER( vic20_state::vic_lightbut_cb ) |
| 672 | 640 | { |
| 673 | | return (((machine.root_device().ioport("CTRLSEL")->read() & 0xf0) == 0x20) && (machine.root_device().ioport("JOY")->read() & 0x40)); |
| 641 | return (((ioport("CTRLSEL")->read() & 0xf0) == 0x20) && (ioport("JOY")->read() & 0x40)); |
| 674 | 642 | } |
| 675 | 643 | |
| 676 | | static UINT8 vic20_paddle0_cb( running_machine &machine ) |
| 677 | | { |
| 678 | | return machine.root_device().ioport("PADDLE0")->read(); |
| 679 | | } |
| 680 | | |
| 681 | | static UINT8 vic20_paddle1_cb( running_machine &machine ) |
| 682 | | { |
| 683 | | return machine.root_device().ioport("PADDLE1")->read(); |
| 684 | | } |
| 685 | | |
| 686 | 644 | static const mos6560_interface vic_ntsc_intf = |
| 687 | 645 | { |
| 688 | 646 | SCREEN_TAG, |
| 689 | 647 | MOS6560, |
| 690 | | vic20_lightx_cb, vic20_lighty_cb, vic20_lightbut_cb, // lightgun cb |
| 691 | | vic20_paddle0_cb, vic20_paddle1_cb, // paddle cb |
| 692 | | vic20_dma_read, vic20_dma_read_color // DMA |
| 648 | DEVCB_DRIVER_MEMBER(vic20_state, vic_lightx_cb), |
| 649 | DEVCB_DRIVER_MEMBER(vic20_state, vic_lighty_cb), |
| 650 | DEVCB_DRIVER_MEMBER(vic20_state, vic_lightbut_cb), |
| 651 | DEVCB_INPUT_PORT("PADDLE0"), |
| 652 | DEVCB_INPUT_PORT("PADDLE1"), |
| 653 | DEVCB_DRIVER_MEMBER(vic20_state, vic_dma_read), |
| 654 | DEVCB_DRIVER_MEMBER(vic20_state, vic_dma_read_color) |
| 693 | 655 | }; |
| 694 | 656 | |
| 695 | 657 | |
| r17658 | r17659 | |
| 701 | 663 | { |
| 702 | 664 | SCREEN_TAG, |
| 703 | 665 | MOS6561, |
| 704 | | vic20_lightx_cb, vic20_lighty_cb, vic20_lightbut_cb, // lightgun cb |
| 705 | | vic20_paddle0_cb, vic20_paddle1_cb, // paddle cb |
| 706 | | vic20_dma_read, vic20_dma_read_color // DMA |
| 666 | DEVCB_DRIVER_MEMBER(vic20_state, vic_lightx_cb), |
| 667 | DEVCB_DRIVER_MEMBER(vic20_state, vic_lighty_cb), |
| 668 | DEVCB_DRIVER_MEMBER(vic20_state, vic_lightbut_cb), |
| 669 | DEVCB_INPUT_PORT("PADDLE0"), |
| 670 | DEVCB_INPUT_PORT("PADDLE1"), |
| 671 | DEVCB_DRIVER_MEMBER(vic20_state, vic_dma_read), |
| 672 | DEVCB_DRIVER_MEMBER(vic20_state, vic_dma_read_color) |
| 707 | 673 | }; |
| 708 | 674 | |
| 709 | 675 | |
| r17658 | r17659 | |
| 820 | 786 | MCFG_CPU_PROGRAM_MAP(vic20_mem) |
| 821 | 787 | MCFG_CPU_PERIODIC_INT(vic20_raster_interrupt, MOS656X_HRETRACERATE) |
| 822 | 788 | |
| 823 | | // video hardware |
| 824 | | MCFG_SCREEN_ADD(SCREEN_TAG, RASTER) |
| 825 | | MCFG_SCREEN_REFRESH_RATE(MOS6560_VRETRACERATE) |
| 826 | | MCFG_SCREEN_VBLANK_TIME(ATTOSECONDS_IN_USEC(2500)) // not accurate |
| 827 | | MCFG_SCREEN_SIZE((MOS6560_XSIZE + 7) & ~7, MOS6560_YSIZE) |
| 828 | | MCFG_SCREEN_VISIBLE_AREA(MOS6560_MAME_XPOS, MOS6560_MAME_XPOS + MOS6560_MAME_XSIZE - 1, MOS6560_MAME_YPOS, MOS6560_MAME_YPOS + MOS6560_MAME_YSIZE - 1) |
| 829 | | MCFG_SCREEN_UPDATE_STATIC( vic20 ) |
| 830 | | |
| 831 | | MCFG_PALETTE_LENGTH(16) |
| 832 | | MCFG_PALETTE_INIT( vic20 ) |
| 833 | | |
| 834 | | // sound hardware |
| 789 | // video/sound hardware |
| 835 | 790 | MCFG_SPEAKER_STANDARD_MONO("mono") |
| 836 | | MCFG_MOS656X_ADD(M6560_TAG, vic_ntsc_intf) |
| 791 | MCFG_MOS6560_ADD(M6560_TAG, SCREEN_TAG, MOS6560_CLOCK, vic_ntsc_intf) |
| 837 | 792 | MCFG_SOUND_ROUTE(ALL_OUTPUTS, "mono", 0.25) |
| 838 | 793 | MCFG_SOUND_ADD("dac", DAC, 0) |
| 839 | 794 | MCFG_SOUND_ROUTE(ALL_OUTPUTS, "mono", 0.25) |
| r17658 | r17659 | |
| 857 | 812 | MCFG_CPU_PROGRAM_MAP(vic20_mem) |
| 858 | 813 | MCFG_CPU_PERIODIC_INT(vic20_raster_interrupt, MOS656X_HRETRACERATE) |
| 859 | 814 | |
| 860 | | // video hardware |
| 861 | | MCFG_SCREEN_ADD(SCREEN_TAG, RASTER) |
| 862 | | MCFG_SCREEN_REFRESH_RATE(MOS6561_VRETRACERATE) |
| 863 | | MCFG_SCREEN_VBLANK_TIME(ATTOSECONDS_IN_USEC(2500)) // not accurate |
| 864 | | MCFG_SCREEN_SIZE((MOS6561_XSIZE + 7) & ~7, MOS6561_YSIZE) |
| 865 | | MCFG_SCREEN_VISIBLE_AREA(MOS6561_MAME_XPOS, MOS6561_MAME_XPOS + MOS6561_MAME_XSIZE - 1, MOS6561_MAME_YPOS, MOS6561_MAME_YPOS + MOS6561_MAME_YSIZE - 1) |
| 866 | | MCFG_SCREEN_UPDATE_STATIC( vic20 ) |
| 867 | | |
| 868 | | MCFG_PALETTE_LENGTH(16) |
| 869 | | MCFG_PALETTE_INIT( vic20 ) |
| 870 | | |
| 871 | | // devices |
| 872 | | MCFG_VIC20_EXPANSION_SLOT_ADD(VIC20_EXPANSION_SLOT_TAG, MOS6561_CLOCK, expansion_intf, vic20_expansion_cards, NULL, NULL) |
| 873 | | |
| 874 | | // sound hardware |
| 815 | // video/sound hardware |
| 875 | 816 | MCFG_SPEAKER_STANDARD_MONO("mono") |
| 876 | | MCFG_MOS656X_ADD(M6560_TAG, vic_pal_intf) |
| 817 | MCFG_MOS6561_ADD(M6560_TAG, SCREEN_TAG, MOS6561_CLOCK, vic_pal_intf) |
| 877 | 818 | MCFG_SOUND_ROUTE(ALL_OUTPUTS, "mono", 0.25) |
| 878 | 819 | MCFG_SOUND_ADD("dac", DAC, 0) |
| 879 | 820 | MCFG_SOUND_ROUTE(ALL_OUTPUTS, "mono", 0.25) |
| 880 | 821 | |
| 822 | // devices |
| 823 | MCFG_VIC20_EXPANSION_SLOT_ADD(VIC20_EXPANSION_SLOT_TAG, MOS6561_CLOCK, expansion_intf, vic20_expansion_cards, NULL, NULL) |
| 824 | |
| 881 | 825 | // software lists |
| 882 | 826 | MCFG_SOFTWARE_LIST_FILTER("cart_list", "PAL") |
| 883 | 827 | MCFG_SOFTWARE_LIST_FILTER("disk_list", "PAL") |