src/mess/video/vdc8563.c
| r7369 | r7370 | |
| 2 | 2 | |
| 3 | 3 | CBM Video Device Chip 8563 |
| 4 | 4 | |
| 5 | | copyright 2000 peter.trauner@jk.uni-linz.ac.at |
| 5 | Original code by PeT (peter.trauner@jk.uni-linz.ac.at) |
| 6 | 6 | |
| 7 | 2010-02: converted to be a device |
| 8 | |
| 9 | TODO: |
| 10 | - clean up the code |
| 11 | - add RAM with an internal address map |
| 12 | |
| 7 | 13 | ***************************************************************************/ |
| 8 | 14 | /* |
| 9 | 15 | several graphic problems |
| 10 | 16 | some are in the rastering engine and should be solved during its evalution |
| 11 | 17 | rare and short documentation, |
| 12 | 18 | registers and some words of description in the c128 user guide */ |
| 19 | /* seems to be a motorola m6845 variant */ |
| 13 | 20 | |
| 14 | | #include <math.h> |
| 15 | | #include <stdio.h> |
| 16 | | #include <assert.h> |
| 21 | |
| 17 | 22 | #include "emu.h" |
| 23 | #include "video/vdc8563.h" |
| 18 | 24 | |
| 19 | | #include "includes/crtc6845.h" // include only several register defines |
| 20 | | #include "vdc8563.h" |
| 21 | | |
| 22 | | #define VERBOSE 0 |
| 23 | | #define VERBOSE_DBG 0 |
| 24 | | |
| 25 | | #define DBG_LOG(N,M,A) \ |
| 26 | | do { \ |
| 27 | | if(VERBOSE>=N) \ |
| 28 | | { \ |
| 29 | | if( M ) \ |
| 30 | | logerror("%11.6f: %-24s",attotime_to_double(timer_get_time(machine)),(char*)M ); \ |
| 31 | | logerror A; \ |
| 32 | | } \ |
| 33 | | } while (0) |
| 34 | | |
| 35 | | /* seems to be a motorola m6845 variant */ |
| 36 | | |
| 37 | | /* permutation for c64/vic6567 conversion to vdc8563 |
| 38 | | 0 --> 0 black |
| 39 | | 1 --> 0xf white |
| 40 | | 2 --> 8 red |
| 41 | | 3 --> 7 cyan |
| 42 | | 4 --> 0xb violett |
| 43 | | 5 --> 4 green |
| 44 | | 6 --> 2 blue |
| 45 | | 7 --> 0xd yellow |
| 46 | | 8 --> 0xa orange |
| 47 | | 9 --> 0xc brown |
| 48 | | 0xa --> 9 light red |
| 49 | | 0xb --> 6 dark gray |
| 50 | | 0xc --> 1 gray |
| 51 | | 0xd --> 5 light green |
| 52 | | 0xe --> 3 light blue |
| 53 | | 0xf --> 0xf light gray |
| 54 | | */ |
| 55 | | |
| 56 | | /* x128 |
| 57 | | commodore assignment!? |
| 58 | | black gray orange yellow dardgrey vio red lgreen |
| 59 | | lred lgray brown blue white green cyan lblue |
| 60 | | */ |
| 61 | | const unsigned char vdc8563_palette[] = |
| 25 | typedef struct _vdc8563_state vdc8563_state; |
| 26 | struct _vdc8563_state |
| 62 | 27 | { |
| 63 | | #if 0 |
| 64 | | 0x00, 0x00, 0x00, /* black */ |
| 65 | | 0x70, 0x74, 0x6f, /* gray */ |
| 66 | | 0x21, 0x1b, 0xae, /* blue */ |
| 67 | | 0x5f, 0x53, 0xfe, /* light blue */ |
| 68 | | 0x1f, 0xd2, 0x1e, /* green */ |
| 69 | | 0x59, 0xfe, 0x59, /* light green */ |
| 70 | | 0x42, 0x45, 0x40, /* dark gray */ |
| 71 | | 0x30, 0xe6, 0xc6, /* cyan */ |
| 72 | | 0xbe, 0x1a, 0x24, /* red */ |
| 73 | | 0xfe, 0x4a, 0x57, /* light red */ |
| 74 | | 0xb8, 0x41, 0x04, /* orange */ |
| 75 | | 0xb4, 0x1a, 0xe2, /* purple */ |
| 76 | | 0x6a, 0x33, 0x04, /* brown */ |
| 77 | | 0xdf, 0xf6, 0x0a, /* yellow */ |
| 78 | | 0xa4, 0xa7, 0xa2, /* light gray */ |
| 79 | | 0xfd, 0xfe, 0xfc /* white */ |
| 80 | | #else |
| 81 | | /* vice */ |
| 82 | | 0,0,0, /* black */ |
| 83 | | 0x20,0x20,0x20, /* gray */ |
| 84 | | 0,0,0x80, /* blue */ |
| 85 | | 0,0,0xff, /* light blue */ |
| 86 | | 0,0x80,0, /* green */ |
| 87 | | 0,0xff,0, /* light green */ |
| 88 | | 0,0x80,0x80, /* cyan */ |
| 89 | | 0,0xff,0xff, /* light cyan */ |
| 90 | | 0x80,0,0, /* red */ |
| 91 | | 0xff,0,0, /* light red */ |
| 92 | | 0x80,0,0x80, /* purble */ |
| 93 | | 0xff,0,0xff, /* light purble */ |
| 94 | | 0x80,0x80,0, /* brown */ |
| 95 | | 0xff, 0xff, 0, /* yellow */ |
| 96 | | 0xc0,0xc0,0xc0, /* light gray */ |
| 97 | | 0xff, 0xff,0xff /* white */ |
| 98 | | #endif |
| 99 | | }; |
| 28 | running_device *screen; |
| 100 | 29 | |
| 101 | | |
| 102 | | static struct { |
| 103 | 30 | int state; |
| 104 | 31 | UINT8 reg[37]; |
| 105 | 32 | UINT8 index; |
| r7369 | r7370 | |
| 120 | 47 | int cursor_on; |
| 121 | 48 | |
| 122 | 49 | int changed; |
| 123 | | } vdc; |
| 50 | }; |
| 124 | 51 | |
| 52 | /***************************************************************************** |
| 53 | CONSTANTS |
| 54 | *****************************************************************************/ |
| 55 | |
| 56 | #define VERBOSE_LEVEL 0 |
| 57 | #define DBG_LOG(N, M, A) \ |
| 58 | do { \ |
| 59 | if (VERBOSE_LEVEL >= N) \ |
| 60 | { \ |
| 61 | if (M) \ |
| 62 | logerror("%11.6f: %-24s",attotime_to_double(timer_get_time(device->machine)),(char*)M ); \ |
| 63 | logerror A; \ |
| 64 | } \ |
| 65 | } while (0) |
| 66 | |
| 67 | |
| 125 | 68 | static const struct { |
| 126 | 69 | int stored, |
| 127 | 70 | read; |
| r7369 | r7370 | |
| 164 | 107 | { 0xff, -1 }, |
| 165 | 108 | { 0x0f, -1 }, |
| 166 | 109 | }; |
| 167 | | #define REG(x) (vdc.reg[x]®_mask[x].stored) |
| 110 | #define REG(x) (vdc8563->reg[x] & reg_mask[x].stored) |
| 168 | 111 | |
| 169 | | void vdc8563_init (int ram16konly) |
| 170 | | { |
| 171 | | memset(&vdc, 0, sizeof(vdc)); |
| 172 | | vdc.cursor_time=0.0; |
| 173 | | vdc.state=1; |
| 174 | 112 | |
| 175 | | if (ram16konly) { |
| 176 | | vdc.mask=0x3fff; |
| 177 | | vdc.fontmask=0x2000; |
| 178 | | } else { |
| 179 | | vdc.mask=0xffff; |
| 180 | | vdc.fontmask=0xe000; |
| 181 | | } |
| 113 | #define CHAR_WIDTH (((vdc8563->reg[0x16] & 0xf0) >> 4) + 1) |
| 114 | #define CHAR_WIDTH_VISIBLE ((vdc8563->reg[0x16] & 0x0f) + 1) |
| 182 | 115 | |
| 183 | | vdc.rastering=1; |
| 184 | | } |
| 116 | #define BLOCK_COPY (vdc8563->reg[0x18] & 0x80) |
| 185 | 117 | |
| 186 | | static void vdc_videoram_w(int offset, int data) |
| 187 | | { |
| 188 | | offset&=vdc.mask; |
| 189 | | if (vdc.ram[offset]!=data) { |
| 190 | | vdc.ram[offset] = data; |
| 191 | | vdc.dirty[offset] = 1; |
| 192 | | if ((vdc.fontram_start&vdc.fontmask)==(offset&vdc.fontmask)) |
| 193 | | vdc.fontdirty[(offset&0x1ff0)>>4]=1; |
| 194 | | } |
| 195 | | } |
| 118 | #define MONOTEXT ((vdc8563->reg[0x19] & 0xc0) == 0) |
| 119 | #define TEXT ((vdc8563->reg[0x19] & 0xc0) == 0x40) |
| 120 | #define GRAPHIC (vdc8563->reg[0x19] & 0x80) |
| 196 | 121 | |
| 197 | | INLINE int vdc_videoram_r(int offset) |
| 122 | #define FRAMECOLOR (vdc8563->reg[0x1a] & 0x0f) |
| 123 | #define MONOCOLOR (vdc8563->reg[0x1a] >> 4) |
| 124 | |
| 125 | #define LINEDIFF (vdc8563->reg[0x1b]) |
| 126 | #define FONT_START ((vdc8563->reg[0x1c] & 0xe0) << 8) |
| 127 | /* 0x1c 0x10 dram 0:4416, 1: 4164 */ |
| 128 | |
| 129 | /* 0x1d 0x1f counter for underlining */ |
| 130 | |
| 131 | #define FILLBYTE vdc8563->reg[0x1f] |
| 132 | |
| 133 | #define CLOCK_HALFING (vdc8563->reg[25] & 0x10) |
| 134 | |
| 135 | |
| 136 | /* the regs below corresponds to the ones used by 6845, hence we borrow the macros */ |
| 137 | #define CRTC6845_COLUMNS (REG(0) + 1) |
| 138 | #define CRTC6845_CHAR_COLUMNS (REG(1)) |
| 139 | #define CRTC6845_CHAR_LINES REG(6) |
| 140 | #define CRTC6845_CHAR_HEIGHT ((REG(9) & 0x1f) + 1) |
| 141 | #define CRTC6845_LINES (REG(4) * CRTC6845_CHAR_HEIGHT + REG(5)) |
| 142 | #define CRTC6845_VIDEO_START ((REG(0xc) << 8) | REG(0xd)) |
| 143 | #define CRTC6845_INTERLACE_MODE (REG(8) & 3) |
| 144 | #define CRTC6845_INTERLACE_SIGNAL 1 |
| 145 | #define CRTC6845_INTERLACE 3 |
| 146 | #define CRTC6845_CURSOR_MODE (REG(0xa) & 0x60) |
| 147 | #define CRTC6845_CURSOR_OFF 0x20 |
| 148 | #define CRTC6845_CURSOR_16FRAMES 0x40 |
| 149 | #define CRTC6845_CURSOR_32FRAMES 0x60 |
| 150 | #define CRTC6845_SKEW (REG(8) & 15) |
| 151 | #define CRTC6845_CURSOR_POS ((REG(0xe) << 8) | REG(0xf)) |
| 152 | #define CRTC6845_CURSOR_TOP (REG(0xa) & 0x1f) |
| 153 | #define CRTC6845_CURSOR_BOTTOM REG(0xb) |
| 154 | |
| 155 | |
| 156 | /***************************************************************************** |
| 157 | INLINE FUNCTIONS |
| 158 | *****************************************************************************/ |
| 159 | |
| 160 | INLINE vdc8563_state *get_safe_token( running_device *device ) |
| 198 | 161 | { |
| 199 | | return vdc.ram[offset&vdc.mask]; |
| 200 | | } |
| 162 | assert(device != NULL); |
| 163 | assert(device->token != NULL); |
| 164 | assert(device->type == VDC8563); |
| 201 | 165 | |
| 202 | | void vdc8563_set_rastering(int on) |
| 203 | | { |
| 204 | | vdc.rastering=on; |
| 205 | | vdc.changed|=1; |
| 166 | return (vdc8563_state *)device->token; |
| 206 | 167 | } |
| 207 | 168 | |
| 208 | | VIDEO_START( vdc8563 ) |
| 169 | INLINE const vdc8563_interface *get_interface( running_device *device ) |
| 209 | 170 | { |
| 210 | | vdc.ram = auto_alloc_array(machine, UINT8, 0x20000); |
| 211 | | vdc.dirty = vdc.ram + 0x10000; |
| 171 | assert(device != NULL); |
| 172 | assert((device->type == VDC8563)); |
| 173 | return (const vdc8563_interface *) device->baseconfig().static_config; |
| 212 | 174 | } |
| 213 | 175 | |
| 214 | | #define CHAR_WIDTH (((vdc.reg[0x16]&0xf0)>>4)+1) |
| 215 | | #define CHAR_WIDTH_VISIBLE ((vdc.reg[0x16]&0xf)+1) |
| 176 | /***************************************************************************** |
| 177 | IMPLEMENTATION |
| 178 | *****************************************************************************/ |
| 216 | 179 | |
| 217 | | #define BLOCK_COPY (vdc.reg[0x18]&0x80) |
| 180 | static void vdc_videoram_w( running_device *device, int offset, int data ) |
| 181 | { |
| 182 | vdc8563_state *vdc8563 = get_safe_token(device); |
| 218 | 183 | |
| 219 | | #define MONOTEXT ((vdc.reg[0x19]&0xc0)==0) |
| 220 | | #define TEXT ((vdc.reg[0x19]&0xc0)==0x40) |
| 221 | | #define GRAPHIC (vdc.reg[0x19]&0x80) |
| 184 | offset &= vdc8563->mask; |
| 222 | 185 | |
| 223 | | #define FRAMECOLOR (vdc.reg[0x1a]&0xf) |
| 224 | | #define MONOCOLOR (vdc.reg[0x1a]>>4) |
| 186 | if (vdc8563->ram[offset] != data) |
| 187 | { |
| 188 | vdc8563->ram[offset] = data; |
| 189 | vdc8563->dirty[offset] = 1; |
| 190 | if ((vdc8563->fontram_start & vdc8563->fontmask) == (offset & vdc8563->fontmask)) |
| 191 | vdc8563->fontdirty[(offset & 0x1ff0) >> 4] = 1; |
| 192 | } |
| 193 | } |
| 225 | 194 | |
| 226 | | #define LINEDIFF (vdc.reg[0x1b]) |
| 227 | | #define FONT_START ((vdc.reg[0x1c]&0xe0)<<8) |
| 228 | | /* 0x1c 0x10 dram 0:4416, 1: 4164 */ |
| 195 | INLINE int vdc_videoram_r( running_device *device, int offset ) |
| 196 | { |
| 197 | vdc8563_state *vdc8563 = get_safe_token(device); |
| 198 | return vdc8563->ram[offset & vdc8563->mask]; |
| 199 | } |
| 229 | 200 | |
| 230 | | /* 0x1d 0x1f counter for underlining */ |
| 201 | void vdc8563_set_rastering( running_device *device, int on ) |
| 202 | { |
| 203 | vdc8563_state *vdc8563 = get_safe_token(device); |
| 204 | vdc8563->rastering = on; |
| 205 | vdc8563->changed |= 1; |
| 206 | } |
| 231 | 207 | |
| 232 | | #define FILLBYTE vdc.reg[0x1f] |
| 233 | 208 | |
| 234 | | #define CLOCK_HALFING (vdc.reg[25]&0x10) |
| 235 | 209 | |
| 236 | 210 | /* 0x22 number of chars from start of line to positiv edge of display enable */ |
| 237 | 211 | /* 0x23 number of chars from start of line to negativ edge of display enable */ |
| 238 | 212 | /* 0x24 0xf number of refresh cycles per line */ |
| 239 | 213 | |
| 240 | | WRITE8_HANDLER ( vdc8563_port_w ) |
| 214 | WRITE8_DEVICE_HANDLER( vdc8563_port_w ) |
| 241 | 215 | { |
| 242 | | running_machine *machine = space->machine; |
| 216 | vdc8563_state *vdc8563 = get_safe_token(device); |
| 243 | 217 | UINT8 i; |
| 244 | 218 | |
| 245 | 219 | if (offset & 1) |
| 246 | 220 | { |
| 247 | | if ((vdc.index & 0x3f) < 37) |
| 221 | if ((vdc8563->index & 0x3f) < 37) |
| 248 | 222 | { |
| 249 | | switch (vdc.index & 0x3f) |
| 223 | switch (vdc8563->index & 0x3f) |
| 250 | 224 | { |
| 251 | 225 | case 1: case 4: case 0x1b: |
| 252 | | vdc.reg[vdc.index]=data; |
| 253 | | vdc.videoram_size=CRTC6845_CHAR_LINES*(CRTC6845_CHAR_COLUMNS+LINEDIFF); |
| 254 | | vdc.changed=1; |
| 226 | vdc8563->reg[vdc8563->index] = data; |
| 227 | vdc8563->videoram_size = CRTC6845_CHAR_LINES * (CRTC6845_CHAR_COLUMNS + LINEDIFF); |
| 228 | vdc8563->changed = 1; |
| 255 | 229 | break; |
| 256 | 230 | case 0xe: case 0xf: case 0xa: case 0xb: |
| 257 | | vdc.dirty[CRTC6845_CURSOR_POS&vdc.mask]=1; |
| 258 | | vdc.reg[vdc.index]=data; |
| 231 | vdc8563->dirty[CRTC6845_CURSOR_POS & vdc8563->mask] = 1; |
| 232 | vdc8563->reg[vdc8563->index] = data; |
| 259 | 233 | break; |
| 260 | 234 | case 0xc: case 0xd: |
| 261 | | vdc.reg[vdc.index]=data; |
| 262 | | vdc.videoram_start=CRTC6845_VIDEO_START; |
| 263 | | vdc.changed=1; |
| 235 | vdc8563->reg[vdc8563->index] = data; |
| 236 | vdc8563->videoram_start = CRTC6845_VIDEO_START; |
| 237 | vdc8563->changed = 1; |
| 264 | 238 | break; |
| 265 | 239 | case 0x12: |
| 266 | | vdc.addr=(vdc.addr&0xff)|(data<<8); |
| 240 | vdc8563->addr = (vdc8563->addr & 0x00ff) | (data << 8); |
| 267 | 241 | break; |
| 268 | 242 | case 0x13: |
| 269 | | vdc.addr=(vdc.addr&0xff00)|data; |
| 243 | vdc8563->addr = (vdc8563->addr & 0xff00) | data; |
| 270 | 244 | break; |
| 271 | 245 | case 0x20: |
| 272 | | vdc.src=(vdc.src&0xff)|(data<<8); |
| 246 | vdc8563->src = (vdc8563->src & 0x00ff) | (data << 8); |
| 273 | 247 | break; |
| 274 | 248 | case 0x21: |
| 275 | | vdc.src=(vdc.src&0xff00)|data; |
| 249 | vdc8563->src = (vdc8563->src & 0xff00) | data; |
| 276 | 250 | break; |
| 277 | 251 | case 0x14: case 0x15: |
| 278 | | vdc.reg[vdc.index]=data; |
| 279 | | vdc.colorram_start=(vdc.reg[0x14]<<8)|vdc.reg[0x15]; |
| 280 | | vdc.changed=1; |
| 252 | vdc8563->reg[vdc8563->index] = data; |
| 253 | vdc8563->colorram_start = (vdc8563->reg[0x14] << 8) | vdc8563->reg[0x15]; |
| 254 | vdc8563->changed = 1; |
| 281 | 255 | break; |
| 282 | 256 | case 0x1c: |
| 283 | | vdc.reg[vdc.index]=data; |
| 284 | | vdc.fontram_start=FONT_START; |
| 285 | | vdc.changed=1; |
| 257 | vdc8563->reg[vdc8563->index] = data; |
| 258 | vdc8563->fontram_start = FONT_START; |
| 259 | vdc8563->changed = 1; |
| 286 | 260 | break; |
| 287 | 261 | case 0x16: case 0x19: case 0x1a: |
| 288 | | vdc.reg[vdc.index]=data; |
| 289 | | vdc.changed=1; |
| 262 | vdc8563->reg[vdc8563->index] = data; |
| 263 | vdc8563->changed = 1; |
| 290 | 264 | break; |
| 291 | 265 | case 0x1e: |
| 292 | | vdc.reg[vdc.index]=data; |
| 293 | | if (BLOCK_COPY) { |
| 294 | | DBG_LOG (2, "vdc block copy", |
| 295 | | ("src:%.4x dst:%.4x size:%.2x\n", |
| 296 | | vdc.src, vdc.addr, data)); |
| 297 | | i=data;do { |
| 298 | | vdc_videoram_w(vdc.addr++, vdc_videoram_r(vdc.src++)); |
| 299 | | } while (--i!=0); |
| 300 | | } else { |
| 301 | | DBG_LOG (2, "vdc block set", |
| 302 | | ("dest:%.4x value:%.2x size:%.2x\n", |
| 303 | | vdc.addr, FILLBYTE, data)); |
| 304 | | i=data;do { |
| 305 | | vdc_videoram_w(vdc.addr++, FILLBYTE); |
| 306 | | } while (--i!=0); |
| 266 | vdc8563->reg[vdc8563->index] = data; |
| 267 | if (BLOCK_COPY) |
| 268 | { |
| 269 | DBG_LOG(2, "vdc block copy", ("src:%.4x dst:%.4x size:%.2x\n", vdc8563->src, vdc8563->addr, data)); |
| 270 | i = data; |
| 271 | do { |
| 272 | vdc_videoram_w(device, vdc8563->addr++, vdc_videoram_r(device, vdc8563->src++)); |
| 273 | } while (--i != 0); |
| 307 | 274 | } |
| 275 | else |
| 276 | { |
| 277 | DBG_LOG(2, "vdc block set", ("dest:%.4x value:%.2x size:%.2x\n", vdc8563->addr, FILLBYTE, data)); |
| 278 | i = data; |
| 279 | do { |
| 280 | vdc_videoram_w(device, vdc8563->addr++, FILLBYTE); |
| 281 | } while (--i != 0); |
| 282 | } |
| 308 | 283 | break; |
| 309 | 284 | case 0x1f: |
| 310 | | DBG_LOG (2, "vdc written", |
| 311 | | ("dest:%.4x size:%.2x\n", |
| 312 | | vdc.addr, data)); |
| 313 | | vdc.reg[vdc.index]=data; |
| 314 | | vdc_videoram_w(vdc.addr++, data); |
| 285 | DBG_LOG(2, "vdc written", ("dest:%.4x size:%.2x\n", vdc8563->addr, data)); |
| 286 | vdc8563->reg[vdc8563->index] = data; |
| 287 | vdc_videoram_w(device, vdc8563->addr++, data); |
| 315 | 288 | break; |
| 316 | 289 | default: |
| 317 | | vdc.reg[vdc.index]=data; |
| 318 | | DBG_LOG (2, "vdc8563_port_w", |
| 319 | | ("%.2x:%.2x\n", vdc.index, data)); |
| 290 | vdc8563->reg[vdc8563->index] = data; |
| 291 | DBG_LOG(2, "vdc8563_port_w", ("%.2x:%.2x\n", vdc8563->index, data)); |
| 320 | 292 | break; |
| 321 | 293 | } |
| 322 | 294 | } |
| 323 | | DBG_LOG (3, "vdc8563_port_w", |
| 324 | | ("%.2x:%.2x\n", vdc.index, data)); |
| 295 | DBG_LOG(3, "vdc8563_port_w", ("%.2x:%.2x\n", vdc8563->index, data)); |
| 325 | 296 | } |
| 326 | 297 | else |
| 327 | 298 | { |
| 328 | | vdc.index = data; |
| 299 | vdc8563->index = data; |
| 329 | 300 | } |
| 330 | 301 | } |
| 331 | 302 | |
| 332 | | READ8_HANDLER ( vdc8563_port_r ) |
| 303 | READ8_DEVICE_HANDLER( vdc8563_port_r ) |
| 333 | 304 | { |
| 334 | | running_machine *machine = space->machine; |
| 305 | vdc8563_state *vdc8563 = get_safe_token(device); |
| 335 | 306 | int val; |
| 336 | 307 | |
| 337 | 308 | val = 0xff; |
| 338 | 309 | if (offset & 1) |
| 339 | 310 | { |
| 340 | | if ((vdc.index & 0x3f) < 37) |
| 311 | if ((vdc8563->index & 0x3f) < 37) |
| 341 | 312 | { |
| 342 | | switch (vdc.index & 0x3f) |
| 313 | switch (vdc8563->index & 0x3f) |
| 343 | 314 | { |
| 344 | 315 | case 0x12: |
| 345 | | val=vdc.addr>>8; |
| 316 | val = vdc8563->addr >> 8; |
| 346 | 317 | break; |
| 347 | 318 | case 0x13: |
| 348 | | val=vdc.addr&0xff; |
| 319 | val = vdc8563->addr & 0xff; |
| 349 | 320 | break; |
| 350 | 321 | case 0x1e: |
| 351 | | val=0; |
| 322 | val = 0; |
| 352 | 323 | break; |
| 353 | 324 | case 0x1f: |
| 354 | | val=vdc_videoram_r(vdc.addr); |
| 355 | | DBG_LOG (2, "vdc read", ("%.4x %.2x\n", vdc.addr, val)); |
| 325 | val = vdc_videoram_r(device, vdc8563->addr); |
| 326 | DBG_LOG(2, "vdc read", ("%.4x %.2x\n", vdc8563->addr, val)); |
| 356 | 327 | break; |
| 357 | 328 | case 0x20: |
| 358 | | val=vdc.src>>8; |
| 329 | val = vdc8563->src >> 8; |
| 359 | 330 | break; |
| 360 | 331 | case 0x21: |
| 361 | | val=vdc.src&0xff; |
| 332 | val = vdc8563->src & 0xff; |
| 362 | 333 | break; |
| 363 | 334 | default: |
| 364 | | val=vdc.reg[vdc.index&0x3f]®_mask[vdc.index&0x3f].read; |
| 335 | val = vdc8563->reg[vdc8563->index & 0x3f] & reg_mask[vdc8563->index & 0x3f].read; |
| 365 | 336 | } |
| 366 | 337 | } |
| 367 | | DBG_LOG (2, "vdc8563_port_r", ("%.2x:%.2x\n", vdc.index, val)); |
| 338 | DBG_LOG(2, "vdc8563_port_r", ("%.2x:%.2x\n", vdc8563->index, val)); |
| 368 | 339 | } |
| 369 | 340 | else |
| 370 | 341 | { |
| 371 | | val = vdc.index; |
| 372 | | if (vdc.state) val|=0x80; |
| 342 | val = vdc8563->index; |
| 343 | if (vdc8563->state) |
| 344 | val |= 0x80; |
| 373 | 345 | } |
| 374 | 346 | return val; |
| 375 | 347 | } |
| 376 | 348 | |
| 377 | | static int vdc8563_clocks_in_frame(void) |
| 349 | static int vdc8563_clocks_in_frame( running_device *device ) |
| 378 | 350 | { |
| 379 | | int clocks=CRTC6845_COLUMNS*CRTC6845_LINES; |
| 380 | | switch (CRTC6845_INTERLACE_MODE) { |
| 351 | vdc8563_state *vdc8563 = get_safe_token(device); |
| 352 | int clocks = CRTC6845_COLUMNS * CRTC6845_LINES; |
| 353 | |
| 354 | switch (CRTC6845_INTERLACE_MODE) |
| 355 | { |
| 381 | 356 | case CRTC6845_INTERLACE_SIGNAL: // interlace generation of video signals only |
| 382 | 357 | case CRTC6845_INTERLACE: // interlace |
| 383 | | return clocks/2; |
| 358 | return clocks / 2; |
| 384 | 359 | default: |
| 385 | 360 | return clocks; |
| 386 | 361 | } |
| 387 | 362 | } |
| 388 | 363 | |
| 389 | | static void vdc8563_time(running_machine *machine) |
| 364 | static void vdc8563_time( running_device *device ) |
| 390 | 365 | { |
| 391 | | double neu, ftime; |
| 392 | | neu=attotime_to_double(timer_get_time(machine)); |
| 366 | vdc8563_state *vdc8563 = get_safe_token(device); |
| 367 | double newtime, ftime; |
| 368 | newtime = attotime_to_double(timer_get_time(device->machine)); |
| 393 | 369 | |
| 394 | | if (vdc8563_clocks_in_frame()==0.0) return; |
| 395 | | ftime=16*vdc8563_clocks_in_frame()/2000000.0; |
| 396 | | if (CLOCK_HALFING) ftime*=2; |
| 397 | | switch (CRTC6845_CURSOR_MODE) { |
| 398 | | case CRTC6845_CURSOR_OFF: vdc.cursor_on=0;break; |
| 370 | if (vdc8563_clocks_in_frame(device) == 0.0) |
| 371 | return; |
| 372 | |
| 373 | ftime = 16 * vdc8563_clocks_in_frame(device) / 2000000.0; |
| 374 | if (CLOCK_HALFING) |
| 375 | ftime *= 2; |
| 376 | switch (CRTC6845_CURSOR_MODE) |
| 377 | { |
| 378 | case CRTC6845_CURSOR_OFF: |
| 379 | vdc8563->cursor_on = 0; |
| 380 | break; |
| 399 | 381 | case CRTC6845_CURSOR_32FRAMES: |
| 400 | | ftime*=2; |
| 382 | ftime *= 2; |
| 401 | 383 | case CRTC6845_CURSOR_16FRAMES: |
| 402 | | if (neu-vdc.cursor_time>ftime) { |
| 403 | | vdc.cursor_time+=ftime; |
| 404 | | vdc.dirty[CRTC6845_CURSOR_POS&vdc.mask]=1; |
| 405 | | vdc.cursor_on^=1; |
| 384 | if (newtime - vdc8563->cursor_time > ftime) |
| 385 | { |
| 386 | vdc8563->cursor_time += ftime; |
| 387 | vdc8563->dirty[CRTC6845_CURSOR_POS & vdc8563->mask] = 1; |
| 388 | vdc8563->cursor_on ^= 1; |
| 406 | 389 | } |
| 407 | 390 | break; |
| 408 | 391 | default: |
| 409 | | vdc.cursor_on=1;break; |
| 392 | vdc8563->cursor_on = 1; |
| 393 | break; |
| 410 | 394 | } |
| 411 | 395 | } |
| 412 | 396 | |
| 413 | | static void vdc8563_monotext_screenrefresh (running_machine *machine, bitmap_t *bitmap, int full_refresh) |
| 397 | static void vdc8563_monotext_screenrefresh( running_device *device, bitmap_t *bitmap, int full_refresh ) |
| 414 | 398 | { |
| 399 | vdc8563_state *vdc8563 = get_safe_token(device); |
| 400 | running_machine *machine = device->machine; |
| 415 | 401 | int x, y, i; |
| 416 | 402 | rectangle rect; |
| 417 | | int w=CRTC6845_CHAR_COLUMNS; |
| 418 | | int h=CRTC6845_CHAR_LINES; |
| 419 | | int height=CRTC6845_CHAR_HEIGHT; |
| 420 | | running_device *screen = video_screen_first(machine); |
| 403 | int w = CRTC6845_CHAR_COLUMNS; |
| 404 | int h = CRTC6845_CHAR_LINES; |
| 405 | int height = CRTC6845_CHAR_HEIGHT; |
| 421 | 406 | |
| 422 | | rect.min_x = video_screen_get_visible_area(screen)->min_x; |
| 423 | | rect.max_x = video_screen_get_visible_area(screen)->max_x; |
| 407 | rect.min_x = video_screen_get_visible_area(vdc8563->screen)->min_x; |
| 408 | rect.max_x = video_screen_get_visible_area(vdc8563->screen)->max_x; |
| 424 | 409 | |
| 425 | 410 | if (full_refresh) |
| 426 | | memset(vdc.dirty+vdc.videoram_start, 1, vdc.videoram_size); |
| 411 | memset(vdc8563->dirty + vdc8563->videoram_start, 1, vdc8563->videoram_size); |
| 427 | 412 | |
| 428 | | for (y=0, rect.min_y=height, rect.max_y=rect.min_y+height-1, |
| 429 | | i=vdc.videoram_start&vdc.mask; y<h; |
| 430 | | y++, rect.min_y+=height, rect.max_y+=height) |
| 413 | for (y = 0, rect.min_y = height, rect.max_y = rect.min_y + height - 1, i = vdc8563->videoram_start & vdc8563->mask; y < h; |
| 414 | y++, rect.min_y += height, rect.max_y += height) |
| 431 | 415 | { |
| 432 | | for (x=0; x<w; x++, i=(i+1)&vdc.mask) |
| 416 | for (x = 0; x < w; x++, i = (i + 1) & vdc8563->mask) |
| 433 | 417 | { |
| 434 | | if (vdc.dirty[i]) |
| 418 | if (vdc8563->dirty[i]) |
| 435 | 419 | { |
| 436 | | drawgfx_opaque(bitmap,&rect,machine->gfx[0], |
| 437 | | vdc.ram[i], FRAMECOLOR|(MONOCOLOR<<4), 0, 0, |
| 438 | | machine->gfx[0]->width*x+8,height*y+height); |
| 439 | | if ((vdc.cursor_on)&&(i==(CRTC6845_CURSOR_POS&vdc.mask))) |
| 420 | drawgfx_opaque(bitmap,&rect,machine->gfx[0], vdc8563->ram[i], FRAMECOLOR | (MONOCOLOR << 4), 0, 0, |
| 421 | machine->gfx[0]->width * x + 8, height * y + height); |
| 422 | |
| 423 | if ((vdc8563->cursor_on) && (i == (CRTC6845_CURSOR_POS & vdc8563->mask))) |
| 440 | 424 | { |
| 441 | | int k=height-CRTC6845_CURSOR_TOP; |
| 442 | | if (CRTC6845_CURSOR_BOTTOM<height) k=CRTC6845_CURSOR_BOTTOM-CRTC6845_CURSOR_TOP+1; |
| 425 | int k = height - CRTC6845_CURSOR_TOP; |
| 426 | if (CRTC6845_CURSOR_BOTTOM < height) |
| 427 | k = CRTC6845_CURSOR_BOTTOM - CRTC6845_CURSOR_TOP + 1; |
| 443 | 428 | |
| 444 | | if (k>0) |
| 445 | | plot_box(bitmap, machine->gfx[0]->width*x+8, |
| 446 | | height*y+height+CRTC6845_CURSOR_TOP, |
| 447 | | machine->gfx[0]->width, k, FRAMECOLOR); |
| 429 | if (k > 0) |
| 430 | plot_box(bitmap, machine->gfx[0]->width * x + 8, height * y + height + CRTC6845_CURSOR_TOP, machine->gfx[0]->width, k, FRAMECOLOR); |
| 448 | 431 | } |
| 449 | 432 | |
| 450 | | vdc.dirty[i]=0; |
| 433 | vdc8563->dirty[i] = 0; |
| 451 | 434 | } |
| 452 | 435 | } |
| 453 | | i+=LINEDIFF; |
| 436 | i += LINEDIFF; |
| 454 | 437 | } |
| 455 | 438 | } |
| 456 | 439 | |
| 457 | | static void vdc8563_text_screenrefresh (running_machine *machine, bitmap_t *bitmap, int full_refresh) |
| 440 | static void vdc8563_text_screenrefresh( running_device *device, bitmap_t *bitmap, int full_refresh ) |
| 458 | 441 | { |
| 442 | vdc8563_state *vdc8563 = get_safe_token(device); |
| 443 | running_machine *machine = device->machine; |
| 459 | 444 | int x, y, i, j; |
| 460 | 445 | rectangle rect; |
| 461 | | int w=CRTC6845_CHAR_COLUMNS; |
| 462 | | int h=CRTC6845_CHAR_LINES; |
| 463 | | int height=CRTC6845_CHAR_HEIGHT; |
| 464 | | running_device *screen = video_screen_first(machine); |
| 446 | int w = CRTC6845_CHAR_COLUMNS; |
| 447 | int h = CRTC6845_CHAR_LINES; |
| 448 | int height = CRTC6845_CHAR_HEIGHT; |
| 465 | 449 | |
| 466 | | rect.min_x = video_screen_get_visible_area(screen)->min_x; |
| 467 | | rect.max_x = video_screen_get_visible_area(screen)->max_x; |
| 450 | rect.min_x = video_screen_get_visible_area(vdc8563->screen)->min_x; |
| 451 | rect.max_x = video_screen_get_visible_area(vdc8563->screen)->max_x; |
| 468 | 452 | |
| 469 | 453 | if (full_refresh) |
| 470 | | memset(vdc.dirty+vdc.videoram_start, 1, vdc.videoram_size); |
| 454 | memset(vdc8563->dirty + vdc8563->videoram_start, 1, vdc8563->videoram_size); |
| 471 | 455 | |
| 472 | | for (y=0, rect.min_y=height, rect.max_y=rect.min_y+height-1, |
| 473 | | i=vdc.videoram_start&vdc.mask, j=vdc.colorram_start&vdc.mask; y<h; |
| 474 | | y++, rect.min_y+=height, rect.max_y+=height) |
| 456 | for (y = 0, rect.min_y = height, rect.max_y = rect.min_y + height - 1, i = vdc8563->videoram_start & vdc8563->mask, |
| 457 | j = vdc8563->colorram_start & vdc8563->mask; y < h; y++, rect.min_y += height, rect.max_y += height) |
| 475 | 458 | { |
| 476 | | for (x=0; x<w; x++, i=(i+1)&vdc.mask, j=(j+1)&vdc.mask) |
| 459 | for (x = 0; x < w; x++, i = (i + 1) & vdc8563->mask, j = (j + 1) & vdc8563->mask) |
| 477 | 460 | { |
| 478 | | if (vdc.dirty[i]||vdc.dirty[j]) |
| 461 | if (vdc8563->dirty[i] || vdc8563->dirty[j]) |
| 479 | 462 | { |
| 480 | 463 | { |
| 481 | 464 | UINT16 ch, fg, bg; |
| r7369 | r7370 | |
| 483 | 466 | int v, h; |
| 484 | 467 | UINT16 *pixel; |
| 485 | 468 | |
| 486 | | ch = vdc.ram[i] | ((vdc.ram[j] & 0x80) ? 0x100 : 0); |
| 487 | | charptr = &vdc.ram[(vdc.fontram_start + (ch * 16)) & vdc.mask]; |
| 488 | | fg = ((vdc.ram[j] & 0x0F) >> 0) + 0x10; |
| 489 | | bg = ((vdc.ram[j] & 0x70) >> 4) + 0x10; |
| 469 | ch = vdc8563->ram[i] | ((vdc8563->ram[j] & 0x80) ? 0x100 : 0); |
| 470 | charptr = &vdc8563->ram[(vdc8563->fontram_start + (ch * 16)) & vdc8563->mask]; |
| 471 | fg = ((vdc8563->ram[j] & 0x0f) >> 0) + 0x10; |
| 472 | bg = ((vdc8563->ram[j] & 0x70) >> 4) + 0x10; |
| 490 | 473 | |
| 491 | 474 | for (v = 0; v < 16; v++) |
| 492 | 475 | { |
| r7369 | r7370 | |
| 498 | 481 | } |
| 499 | 482 | } |
| 500 | 483 | |
| 501 | | if ((vdc.cursor_on)&&(i==(CRTC6845_CURSOR_POS&vdc.mask))) |
| 484 | if ((vdc8563->cursor_on) && (i == (CRTC6845_CURSOR_POS & vdc8563->mask))) |
| 502 | 485 | { |
| 503 | | int k=height-CRTC6845_CURSOR_TOP; |
| 504 | | if (CRTC6845_CURSOR_BOTTOM<height) k=CRTC6845_CURSOR_BOTTOM-CRTC6845_CURSOR_TOP+1; |
| 486 | int k = height - CRTC6845_CURSOR_TOP; |
| 487 | if (CRTC6845_CURSOR_BOTTOM < height) |
| 488 | k = CRTC6845_CURSOR_BOTTOM - CRTC6845_CURSOR_TOP + 1; |
| 505 | 489 | |
| 506 | | if (k>0) |
| 507 | | plot_box(bitmap, machine->gfx[0]->width*x+8, |
| 508 | | height*y+height+CRTC6845_CURSOR_TOP, |
| 509 | | machine->gfx[0]->width, k, 0x10|(vdc.ram[j]&0xf)); |
| 490 | if (k > 0) |
| 491 | plot_box(bitmap, machine->gfx[0]->width * x + 8, height * y + height + CRTC6845_CURSOR_TOP, machine->gfx[0]->width, |
| 492 | k, 0x10 | (vdc8563->ram[j] & 0x0f)); |
| 510 | 493 | } |
| 511 | 494 | |
| 512 | | vdc.dirty[i]=0; |
| 513 | | vdc.dirty[j]=0; |
| 495 | vdc8563->dirty[i] = 0; |
| 496 | vdc8563->dirty[j] = 0; |
| 514 | 497 | } |
| 515 | 498 | } |
| 516 | | i+=LINEDIFF; |
| 517 | | j+=LINEDIFF; |
| 499 | i += LINEDIFF; |
| 500 | j += LINEDIFF; |
| 518 | 501 | } |
| 519 | 502 | } |
| 520 | 503 | |
| 521 | | static void vdc8563_graphic_screenrefresh (running_machine *machine, bitmap_t *bitmap, int full_refresh) |
| 504 | static void vdc8563_graphic_screenrefresh( running_device *device, bitmap_t *bitmap, int full_refresh ) |
| 522 | 505 | { |
| 506 | vdc8563_state *vdc8563 = get_safe_token(device); |
| 507 | running_machine *machine = device->machine; |
| 523 | 508 | int x, y, i, j, k; |
| 524 | 509 | rectangle rect; |
| 525 | | int w=CRTC6845_CHAR_COLUMNS; |
| 526 | | int h=CRTC6845_CHAR_LINES; |
| 527 | | int height=CRTC6845_CHAR_HEIGHT; |
| 528 | | running_device *screen = video_screen_first(machine); |
| 510 | int w = CRTC6845_CHAR_COLUMNS; |
| 511 | int h = CRTC6845_CHAR_LINES; |
| 512 | int height = CRTC6845_CHAR_HEIGHT; |
| 529 | 513 | |
| 530 | | rect.min_x = video_screen_get_visible_area(screen)->min_x; |
| 531 | | rect.max_x = video_screen_get_visible_area(screen)->max_x; |
| 514 | rect.min_x = video_screen_get_visible_area(vdc8563->screen)->min_x; |
| 515 | rect.max_x = video_screen_get_visible_area(vdc8563->screen)->max_x; |
| 532 | 516 | |
| 533 | 517 | if (full_refresh) |
| 534 | | memset(vdc.dirty, 1, vdc.mask+1); |
| 518 | memset(vdc8563->dirty, 1, vdc8563->mask + 1); |
| 535 | 519 | |
| 536 | | for (y=0, rect.min_y=height, rect.max_y=rect.min_y+height-1, |
| 537 | | i=vdc.videoram_start&vdc.mask; y<h; |
| 538 | | y++, rect.min_y+=height, rect.max_y+=height) |
| 520 | for (y = 0, rect.min_y = height, rect.max_y = rect.min_y + height - 1, i = vdc8563->videoram_start & vdc8563->mask; y < h; |
| 521 | y++, rect.min_y += height, rect.max_y += height) |
| 539 | 522 | { |
| 540 | | for (x=0; x<w; x++, i=(i+1)&vdc.mask) |
| 523 | for (x = 0; x < w; x++, i = (i + 1) & vdc8563->mask) |
| 541 | 524 | { |
| 542 | | for (j=0; j<height; j++) |
| 525 | for (j = 0; j < height; j++) |
| 543 | 526 | { |
| 544 | | k=((i<<4)+j)&vdc.mask; |
| 545 | | if (vdc.dirty[k]) |
| 527 | k = ((i << 4) + j) & vdc8563->mask; |
| 528 | if (vdc8563->dirty[k]) |
| 546 | 529 | { |
| 547 | | drawgfx_opaque(bitmap,&rect,machine->gfx[1], |
| 548 | | vdc.ram[k], FRAMECOLOR|(MONOCOLOR<<4), 0, 0, |
| 549 | | machine->gfx[0]->width*x+8,height*y+height+j); |
| 550 | | vdc.dirty[k]=0; |
| 530 | drawgfx_opaque(bitmap, &rect, machine->gfx[1], vdc8563->ram[k], FRAMECOLOR | (MONOCOLOR << 4), 0, 0, |
| 531 | machine->gfx[0]->width * x + 8, height * y + height + j); |
| 532 | vdc8563->dirty[k] = 0; |
| 551 | 533 | } |
| 552 | 534 | } |
| 553 | 535 | } |
| 554 | | i+=LINEDIFF; |
| 536 | i += LINEDIFF; |
| 555 | 537 | } |
| 556 | 538 | } |
| 557 | 539 | |
| 558 | | VIDEO_UPDATE( vdc8563 ) |
| 540 | UINT32 vdc8563_video_update( running_device *device, bitmap_t *bitmap, const rectangle *cliprect ) |
| 559 | 541 | { |
| 542 | vdc8563_state *vdc8563 = get_safe_token(device); |
| 560 | 543 | int i; |
| 561 | 544 | int full_refresh = 1; |
| 562 | 545 | |
| 563 | | if (!vdc.rastering) return 0; |
| 564 | | vdc8563_time(screen->machine); |
| 546 | if (!vdc8563->rastering) |
| 547 | return 0; |
| 565 | 548 | |
| 566 | | full_refresh|=vdc.changed; |
| 549 | vdc8563_time(device); |
| 550 | |
| 551 | full_refresh |= vdc8563->changed; |
| 552 | |
| 567 | 553 | if (GRAPHIC) |
| 568 | 554 | { |
| 569 | | vdc8563_graphic_screenrefresh(screen->machine, bitmap, full_refresh); |
| 555 | vdc8563_graphic_screenrefresh(device, bitmap, full_refresh); |
| 570 | 556 | } |
| 571 | 557 | else |
| 572 | 558 | { |
| 573 | | for (i=0; i<512; i++) |
| 559 | for (i = 0; i < 512; i++) |
| 574 | 560 | { |
| 575 | | if (full_refresh||vdc.fontdirty[i]) |
| 561 | if (full_refresh || vdc8563->fontdirty[i]) |
| 576 | 562 | { |
| 577 | | gfx_element_mark_dirty(screen->machine->gfx[0],i); |
| 578 | | vdc.fontdirty[i]=0; |
| 563 | gfx_element_mark_dirty(device->machine->gfx[0],i); |
| 564 | vdc8563->fontdirty[i] = 0; |
| 579 | 565 | } |
| 580 | 566 | } |
| 581 | | if (TEXT) vdc8563_text_screenrefresh(screen->machine, bitmap, full_refresh); |
| 582 | | else vdc8563_monotext_screenrefresh(screen->machine, bitmap, full_refresh); |
| 567 | if (TEXT) |
| 568 | vdc8563_text_screenrefresh(device, bitmap, full_refresh); |
| 569 | else |
| 570 | vdc8563_monotext_screenrefresh(device, bitmap, full_refresh); |
| 583 | 571 | } |
| 584 | 572 | |
| 585 | 573 | if (full_refresh) |
| 586 | 574 | { |
| 587 | | int w=CRTC6845_CHAR_COLUMNS; |
| 588 | | int h=CRTC6845_CHAR_LINES; |
| 589 | | int height=CRTC6845_CHAR_HEIGHT; |
| 575 | int w = CRTC6845_CHAR_COLUMNS; |
| 576 | int h = CRTC6845_CHAR_LINES; |
| 577 | int height = CRTC6845_CHAR_HEIGHT; |
| 590 | 578 | |
| 591 | | plot_box(bitmap, 0, 0, screen->machine->gfx[0]->width*(w+2), height, FRAMECOLOR); |
| 579 | plot_box(bitmap, 0, 0, device->machine->gfx[0]->width * (w + 2), height, FRAMECOLOR); |
| 592 | 580 | |
| 593 | | plot_box(bitmap, 0, height, screen->machine->gfx[0]->width, height*h, FRAMECOLOR); |
| 581 | plot_box(bitmap, 0, height, device->machine->gfx[0]->width, height * h, FRAMECOLOR); |
| 594 | 582 | |
| 595 | | plot_box(bitmap, screen->machine->gfx[0]->width*(w+1), height, screen->machine->gfx[0]->width, height*h, |
| 596 | | FRAMECOLOR); |
| 583 | plot_box(bitmap, device->machine->gfx[0]->width * (w + 1), height, device->machine->gfx[0]->width, height * h, FRAMECOLOR); |
| 597 | 584 | |
| 598 | | plot_box(bitmap, 0, height*(h+1), screen->machine->gfx[0]->width*(w+2), height, |
| 599 | | FRAMECOLOR); |
| 585 | plot_box(bitmap, 0, height * (h + 1), device->machine->gfx[0]->width * (w + 2), height, FRAMECOLOR); |
| 600 | 586 | } |
| 601 | 587 | |
| 602 | | vdc.changed=0; |
| 588 | vdc8563->changed = 0; |
| 603 | 589 | return 0; |
| 604 | 590 | } |
| 591 | |
| 592 | /***************************************************************************** |
| 593 | DEVICE INTERFACE |
| 594 | *****************************************************************************/ |
| 595 | |
| 596 | static DEVICE_START( vdc8563 ) |
| 597 | { |
| 598 | vdc8563_state *vdc8563 = get_safe_token(device); |
| 599 | const vdc8563_interface *intf = (vdc8563_interface *)device->baseconfig().static_config; |
| 600 | |
| 601 | vdc8563->screen = devtag_get_device(device->machine, intf->screen); |
| 602 | |
| 603 | vdc8563->ram = auto_alloc_array_clear(device->machine, UINT8, 0x20000); |
| 604 | vdc8563->dirty = vdc8563->ram + 0x10000; |
| 605 | |
| 606 | /* currently no driver uses 16k only */ |
| 607 | if (intf->ram16konly) |
| 608 | { |
| 609 | vdc8563->mask = 0x3fff; |
| 610 | vdc8563->fontmask = 0x2000; |
| 611 | } |
| 612 | else |
| 613 | { |
| 614 | vdc8563->mask = 0xffff; |
| 615 | vdc8563->fontmask = 0xe000; |
| 616 | } |
| 617 | |
| 618 | state_save_register_device_item_pointer(device, 0, vdc8563->ram, 0x20000); |
| 619 | |
| 620 | state_save_register_device_item_array(device, 0, vdc8563->reg); |
| 621 | state_save_register_device_item(device, 0, vdc8563->state); |
| 622 | state_save_register_device_item(device, 0, vdc8563->index); |
| 623 | |
| 624 | state_save_register_device_item(device, 0, vdc8563->addr); |
| 625 | state_save_register_device_item(device, 0, vdc8563->src); |
| 626 | |
| 627 | state_save_register_device_item(device, 0, vdc8563->videoram_start); |
| 628 | state_save_register_device_item(device, 0, vdc8563->colorram_start); |
| 629 | state_save_register_device_item(device, 0, vdc8563->fontram_start); |
| 630 | state_save_register_device_item(device, 0, vdc8563->videoram_size); |
| 631 | |
| 632 | state_save_register_device_item(device, 0, vdc8563->rastering); |
| 633 | |
| 634 | state_save_register_device_item_array(device, 0, vdc8563->fontdirty); |
| 635 | |
| 636 | state_save_register_device_item(device, 0, vdc8563->cursor_time); |
| 637 | state_save_register_device_item(device, 0, vdc8563->cursor_on); |
| 638 | |
| 639 | state_save_register_device_item(device, 0, vdc8563->changed); |
| 640 | } |
| 641 | |
| 642 | |
| 643 | static DEVICE_RESET( vdc8563 ) |
| 644 | { |
| 645 | vdc8563_state *vdc8563 = get_safe_token(device); |
| 646 | |
| 647 | memset(vdc8563->reg, 0, ARRAY_LENGTH(vdc8563->reg)); |
| 648 | memset(vdc8563->fontdirty, 0, ARRAY_LENGTH(vdc8563->fontdirty)); |
| 649 | |
| 650 | vdc8563->cursor_time = 0.0; |
| 651 | vdc8563->state = 1; |
| 652 | |
| 653 | vdc8563->index = 0; |
| 654 | vdc8563->addr = 0; |
| 655 | vdc8563->src = 0; |
| 656 | vdc8563->videoram_start = 0; |
| 657 | vdc8563->colorram_start = 0; |
| 658 | vdc8563->fontram_start = 0; |
| 659 | vdc8563->videoram_size = 0; |
| 660 | vdc8563->rastering = 1; |
| 661 | vdc8563->cursor_on = 0; |
| 662 | vdc8563->changed = 0; |
| 663 | } |
| 664 | |
| 665 | /*------------------------------------------------- |
| 666 | device definition |
| 667 | -------------------------------------------------*/ |
| 668 | |
| 669 | static const char DEVTEMPLATE_SOURCE[] = __FILE__; |
| 670 | |
| 671 | #define DEVTEMPLATE_ID(p,s) p##vdc8563##s |
| 672 | #define DEVTEMPLATE_FEATURES DT_HAS_START | DT_HAS_RESET |
| 673 | #define DEVTEMPLATE_NAME "8563 / 8568 VDC" |
| 674 | #define DEVTEMPLATE_FAMILY "8563 / 8568 VDC" |
| 675 | #include "devtempl.h" |