trunk/src/emu/video/pc_vga.c
| r18277 | r18278 | |
| 79 | 79 | #define VGA_START_ADDRESS (vga.crtc.start_addr) |
| 80 | 80 | #define VGA_LINE_LENGTH (vga.crtc.offset<<3) |
| 81 | 81 | |
| 82 | #define IBM8514_LINE_LENGTH (m_vga->vga.crtc.offset << 3) |
| 83 | |
| 82 | 84 | #define CHAR_WIDTH ((vga.sequencer.data[1]&1)?8:9) |
| 83 | 85 | |
| 84 | 86 | #define TEXT_COLUMNS (vga.crtc.horz_disp_end+1) |
| r18277 | r18278 | |
| 118 | 120 | const device_type GAMTOR_VGA = &device_creator<gamtor_vga_device>; |
| 119 | 121 | const device_type ATI_VGA = &device_creator<ati_vga_device>; |
| 120 | 122 | const device_type CIRRUS_VGA = &device_creator<cirrus_vga_device>; |
| 123 | const device_type IBM8514A = &device_creator<ibm8514a_device>; |
| 124 | const device_type MACH8 = &device_creator<mach8_device>; |
| 121 | 125 | |
| 122 | 126 | vga_device::vga_device(const machine_config &mconfig, device_type type, const char *name, const char *tag, device_t *owner, UINT32 clock) |
| 123 | 127 | : device_t(mconfig, type, name, tag, owner, clock) |
| r18277 | r18278 | |
| 169 | 173 | { |
| 170 | 174 | } |
| 171 | 175 | |
| 176 | ibm8514a_device::ibm8514a_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock) |
| 177 | : device_t(mconfig, IBM8514A, "IBM8514A", tag, owner, clock) |
| 178 | { |
| 179 | } |
| 172 | 180 | |
| 181 | ibm8514a_device::ibm8514a_device(const machine_config &mconfig, device_type type, const char *name, const char *tag, device_t *owner, UINT32 clock) |
| 182 | : device_t(mconfig, type, name, tag, owner, clock) |
| 183 | { |
| 184 | } |
| 185 | |
| 186 | mach8_device::mach8_device(const machine_config &mconfig, device_type type, const char *name, const char *tag, device_t *owner, UINT32 clock) |
| 187 | : ibm8514a_device(mconfig, type, name, tag, owner, clock) |
| 188 | { |
| 189 | } |
| 190 | |
| 191 | mach8_device::mach8_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock) |
| 192 | : ibm8514a_device(mconfig, MACH8, "MACH8", tag, owner, clock) |
| 193 | { |
| 194 | } |
| 195 | |
| 173 | 196 | void vga_device::device_start() |
| 174 | 197 | { |
| 175 | 198 | memset(&vga, 0, sizeof(vga)); |
| r18277 | r18278 | |
| 191 | 214 | vga.memory = auto_alloc_array_clear(machine(), UINT8, vga.svga_intf.vram_size); |
| 192 | 215 | } |
| 193 | 216 | |
| 217 | void svga_device::device_start() |
| 218 | { |
| 219 | vga_device::device_start(); |
| 220 | memset(&svga, 0, sizeof(svga)); |
| 221 | } |
| 222 | |
| 194 | 223 | void cirrus_vga_device::device_start() |
| 195 | 224 | { |
| 196 | 225 | memset(&vga, 0, sizeof(vga)); |
| 226 | memset(&svga, 0, sizeof(svga)); |
| 197 | 227 | |
| 198 | 228 | int i; |
| 199 | 229 | for (i = 0; i < 0x100; i++) |
| r18277 | r18278 | |
| 212 | 242 | vga.memory = auto_alloc_array_clear(machine(), UINT8, vga.svga_intf.vram_size); |
| 213 | 243 | } |
| 214 | 244 | |
| 245 | void ati_vga_device::device_start() |
| 246 | { |
| 247 | svga_device::device_start(); |
| 248 | memset(&ati, 0, sizeof(ati)); |
| 249 | m_8514 = subdevice<mach8_device>("8514a"); |
| 250 | } |
| 251 | |
| 215 | 252 | void s3_vga_device::device_start() |
| 216 | 253 | { |
| 217 | | vga_device::device_start(); |
| 254 | svga_device::device_start(); |
| 255 | memset(&s3, 0, sizeof(s3)); |
| 218 | 256 | int x; |
| 219 | 257 | // Initialise hardware graphics cursor colours, Windows 95 doesn't touch the registers for some reason |
| 220 | 258 | for(x=0;x<4;x++) |
| r18277 | r18278 | |
| 222 | 260 | s3.cursor_fg[x] = 0xff; |
| 223 | 261 | s3.cursor_bg[x] = 0x00; |
| 224 | 262 | } |
| 263 | m_8514 = subdevice<ibm8514a_device>("8514a"); |
| 225 | 264 | } |
| 226 | 265 | |
| 266 | void tseng_vga_device::device_start() |
| 267 | { |
| 268 | svga_device::device_start(); |
| 269 | memset(&et4k, 0, sizeof(et4k)); |
| 270 | } |
| 271 | |
| 272 | void ibm8514a_device::device_start() |
| 273 | { |
| 274 | memset(&ibm8514, 0, sizeof(ibm8514)); |
| 275 | } |
| 276 | |
| 277 | void ibm8514a_device::device_config_complete() |
| 278 | { |
| 279 | if(m_vga_tag.len() != 0) |
| 280 | { |
| 281 | m_vga = machine().device<vga_device>(m_vga_tag); |
| 282 | } |
| 283 | } |
| 284 | |
| 285 | void mach8_device::device_start() |
| 286 | { |
| 287 | ibm8514a_device::device_start(); |
| 288 | memset(&mach8, 0, sizeof(mach8)); |
| 289 | } |
| 290 | |
| 227 | 291 | void vga_device::vga_vh_text(bitmap_rgb32 &bitmap, const rectangle &cliprect) |
| 228 | 292 | { |
| 229 | 293 | UINT8 ch, attr; |
| r18277 | r18278 | |
| 2014 | 2078 | MACHINE_CONFIG_END |
| 2015 | 2079 | |
| 2016 | 2080 | static MACHINE_CONFIG_FRAGMENT( ati_vga ) |
| 2081 | MCFG_MACH8_ADD_OWNER("8514a") |
| 2017 | 2082 | MCFG_EEPROM_ADD("ati_eeprom",ati_eeprom_interface) |
| 2018 | 2083 | MACHINE_CONFIG_END |
| 2019 | 2084 | |
| 2085 | static MACHINE_CONFIG_FRAGMENT( s3_764 ) |
| 2086 | MCFG_8514A_ADD_OWNER("8514a") |
| 2087 | MACHINE_CONFIG_END |
| 2088 | |
| 2020 | 2089 | //------------------------------------------------- |
| 2021 | 2090 | // machine_config_additions - device-specific |
| 2022 | 2091 | // machine configurations |
| r18277 | r18278 | |
| 2027 | 2096 | return MACHINE_CONFIG_NAME( ati_vga ); |
| 2028 | 2097 | } |
| 2029 | 2098 | |
| 2099 | machine_config_constructor s3_vga_device::device_mconfig_additions() const |
| 2100 | { |
| 2101 | return MACHINE_CONFIG_NAME( s3_764 ); |
| 2102 | } |
| 2103 | |
| 2030 | 2104 | /****************************************** |
| 2031 | 2105 | |
| 2032 | 2106 | Tseng ET4000k implementation |
| r18277 | r18278 | |
| 2667 | 2741 | break; |
| 2668 | 2742 | case 0x40: |
| 2669 | 2743 | s3.enable_8514 = data & 0x01; // enable 8514/A registers (x2e8, x6e8, xae8, xee8) |
| 2670 | | if(data & 0x01) |
| 2671 | | { |
| 2672 | | ibm8514.state = IBM8514_IDLE; |
| 2673 | | ibm8514.gpbusy = false; |
| 2674 | | } |
| 2675 | 2744 | break; |
| 2676 | 2745 | /* |
| 2677 | 2746 | 3d4h index 45h (R/W): CR45 Hardware Graphics Cursor Mode |
| r18277 | r18278 | |
| 2972 | 3041 | |
| 2973 | 3042 | /* accelerated ports, TBD ... */ |
| 2974 | 3043 | |
| 2975 | | void ati_vga_device::ibm8514_write_fg(UINT32 offset) |
| 3044 | void ibm8514a_device::ibm8514_write_fg(UINT32 offset) |
| 2976 | 3045 | { |
| 2977 | | UINT8 dst = vga.memory[offset]; |
| 3046 | address_space& space = machine().device("maincpu")->memory().space(AS_PROGRAM); |
| 3047 | UINT8 dst = m_vga->mem_linear_r(space,offset,0xff); |
| 2978 | 3048 | UINT8 src = 0; |
| 2979 | 3049 | |
| 2980 | 3050 | // check clipping rectangle |
| r18277 | r18278 | |
| 2995 | 3065 | break; |
| 2996 | 3066 | case 0x0060: |
| 2997 | 3067 | // video memory - presume the memory is sourced from the current X/Y co-ords |
| 2998 | | src = vga.memory[((ibm8514.curr_y * VGA_LINE_LENGTH) + ibm8514.curr_x) % vga.svga_intf.vram_size]; |
| 3068 | src = m_vga->mem_linear_r(space,((ibm8514.curr_y * IBM8514_LINE_LENGTH) + ibm8514.curr_x),0xff); |
| 2999 | 3069 | break; |
| 3000 | 3070 | } |
| 3001 | 3071 | |
| r18277 | r18278 | |
| 3003 | 3073 | switch(ibm8514.fgmix & 0x000f) |
| 3004 | 3074 | { |
| 3005 | 3075 | case 0x0000: |
| 3006 | | vga.memory[offset] = ~dst; |
| 3076 | m_vga->mem_linear_w(space,offset,~dst,0xff); |
| 3007 | 3077 | break; |
| 3008 | 3078 | case 0x0001: |
| 3009 | | vga.memory[offset] = 0x00; |
| 3079 | m_vga->mem_linear_w(space,offset,0x00,0xff); |
| 3010 | 3080 | break; |
| 3011 | 3081 | case 0x0002: |
| 3012 | | vga.memory[offset] = 0xff; |
| 3082 | m_vga->mem_linear_w(space,offset,0xff,0xff); |
| 3013 | 3083 | break; |
| 3014 | 3084 | case 0x0003: |
| 3015 | 3085 | // change nothing, pixel is unchanged |
| 3016 | 3086 | break; |
| 3017 | 3087 | case 0x0004: |
| 3018 | | vga.memory[offset] = ~src; |
| 3088 | m_vga->mem_linear_w(space,offset,~src,0xff); |
| 3019 | 3089 | break; |
| 3020 | 3090 | case 0x0005: |
| 3021 | | vga.memory[offset] = src ^ dst; |
| 3091 | m_vga->mem_linear_w(space,offset,src ^ dst,0xff); |
| 3022 | 3092 | break; |
| 3023 | 3093 | case 0x0006: |
| 3024 | | vga.memory[offset] = ~(src ^ dst); |
| 3094 | m_vga->mem_linear_w(space,offset,~(src ^ dst),0xff); |
| 3025 | 3095 | break; |
| 3026 | 3096 | case 0x0007: |
| 3027 | | vga.memory[offset] = src; |
| 3097 | m_vga->mem_linear_w(space,offset,src,0xff); |
| 3028 | 3098 | break; |
| 3029 | 3099 | case 0x0008: |
| 3030 | | vga.memory[offset] = ~(src & dst); |
| 3100 | m_vga->mem_linear_w(space,offset,~(src & dst),0xff); |
| 3031 | 3101 | break; |
| 3032 | 3102 | case 0x0009: |
| 3033 | | vga.memory[offset] = (~src) | dst; |
| 3103 | m_vga->mem_linear_w(space,offset,(~src) | dst,0xff); |
| 3034 | 3104 | break; |
| 3035 | 3105 | case 0x000a: |
| 3036 | | vga.memory[offset] = src | (~dst); |
| 3106 | m_vga->mem_linear_w(space,offset,src | (~dst),0xff); |
| 3037 | 3107 | break; |
| 3038 | 3108 | case 0x000b: |
| 3039 | | vga.memory[offset] = src | dst; |
| 3109 | m_vga->mem_linear_w(space,offset,src | dst,0xff); |
| 3040 | 3110 | break; |
| 3041 | 3111 | case 0x000c: |
| 3042 | | vga.memory[offset] = src & dst; |
| 3112 | m_vga->mem_linear_w(space,offset,src & dst,0xff); |
| 3043 | 3113 | break; |
| 3044 | 3114 | case 0x000d: |
| 3045 | | vga.memory[offset] = src & (~dst); |
| 3115 | m_vga->mem_linear_w(space,offset,src & (~dst),0xff); |
| 3046 | 3116 | break; |
| 3047 | 3117 | case 0x000e: |
| 3048 | | vga.memory[offset] = (~src) & dst; |
| 3118 | m_vga->mem_linear_w(space,offset,(~src) & dst,0xff); |
| 3049 | 3119 | break; |
| 3050 | 3120 | case 0x000f: |
| 3051 | | vga.memory[offset] = ~(src | dst); |
| 3121 | m_vga->mem_linear_w(space,offset,~(src | dst),0xff); |
| 3052 | 3122 | break; |
| 3053 | 3123 | } |
| 3054 | 3124 | } |
| 3055 | 3125 | |
| 3056 | | void ati_vga_device::ibm8514_write_bg(UINT32 offset) |
| 3126 | void ibm8514a_device::ibm8514_write_bg(UINT32 offset) |
| 3057 | 3127 | { |
| 3058 | | UINT8 dst = vga.memory[offset]; |
| 3128 | address_space& space = machine().device("maincpu")->memory().space(AS_PROGRAM); |
| 3129 | UINT8 dst = m_vga->mem_linear_r(space,offset,0xff); |
| 3059 | 3130 | UINT8 src = 0; |
| 3060 | 3131 | |
| 3061 | 3132 | // check clipping rectangle |
| r18277 | r18278 | |
| 3076 | 3147 | break; |
| 3077 | 3148 | case 0x0060: |
| 3078 | 3149 | // video memory - presume the memory is sourced from the current X/Y co-ords |
| 3079 | | src = vga.memory[((ibm8514.curr_y * VGA_LINE_LENGTH) + ibm8514.curr_x) % vga.svga_intf.vram_size]; |
| 3150 | src = m_vga->mem_linear_r(space,((ibm8514.curr_y * IBM8514_LINE_LENGTH) + ibm8514.curr_x),0xff); |
| 3080 | 3151 | break; |
| 3081 | 3152 | } |
| 3082 | 3153 | |
| r18277 | r18278 | |
| 3084 | 3155 | switch(ibm8514.bgmix & 0x000f) |
| 3085 | 3156 | { |
| 3086 | 3157 | case 0x0000: |
| 3087 | | vga.memory[offset] = ~dst; |
| 3158 | m_vga->mem_linear_w(space,offset,~dst,0xff); |
| 3088 | 3159 | break; |
| 3089 | 3160 | case 0x0001: |
| 3090 | | vga.memory[offset] = 0x00; |
| 3161 | m_vga->mem_linear_w(space,offset,0x00,0xff); |
| 3091 | 3162 | break; |
| 3092 | 3163 | case 0x0002: |
| 3093 | | vga.memory[offset] = 0xff; |
| 3164 | m_vga->mem_linear_w(space,offset,0xff,0xff); |
| 3094 | 3165 | break; |
| 3095 | 3166 | case 0x0003: |
| 3096 | 3167 | // change nothing, pixel is unchanged |
| 3097 | 3168 | break; |
| 3098 | 3169 | case 0x0004: |
| 3099 | | vga.memory[offset] = ~src; |
| 3170 | m_vga->mem_linear_w(space,offset,~src,0xff); |
| 3100 | 3171 | break; |
| 3101 | 3172 | case 0x0005: |
| 3102 | | vga.memory[offset] = src ^ dst; |
| 3173 | m_vga->mem_linear_w(space,offset,src ^ dst,0xff); |
| 3103 | 3174 | break; |
| 3104 | 3175 | case 0x0006: |
| 3105 | | vga.memory[offset] = ~(src ^ dst); |
| 3176 | m_vga->mem_linear_w(space,offset,~(src ^ dst),0xff); |
| 3106 | 3177 | break; |
| 3107 | 3178 | case 0x0007: |
| 3108 | | vga.memory[offset] = src; |
| 3179 | m_vga->mem_linear_w(space,offset,src,0xff); |
| 3109 | 3180 | break; |
| 3110 | 3181 | case 0x0008: |
| 3111 | | vga.memory[offset] = ~(src & dst); |
| 3182 | m_vga->mem_linear_w(space,offset,~(src & dst),0xff); |
| 3112 | 3183 | break; |
| 3113 | 3184 | case 0x0009: |
| 3114 | | vga.memory[offset] = (~src) | dst; |
| 3185 | m_vga->mem_linear_w(space,offset,(~src) | dst,0xff); |
| 3115 | 3186 | break; |
| 3116 | 3187 | case 0x000a: |
| 3117 | | vga.memory[offset] = src | (~dst); |
| 3188 | m_vga->mem_linear_w(space,offset,src | (~dst),0xff); |
| 3118 | 3189 | break; |
| 3119 | 3190 | case 0x000b: |
| 3120 | | vga.memory[offset] = src | dst; |
| 3191 | m_vga->mem_linear_w(space,offset,src | dst,0xff); |
| 3121 | 3192 | break; |
| 3122 | 3193 | case 0x000c: |
| 3123 | | vga.memory[offset] = src & dst; |
| 3194 | m_vga->mem_linear_w(space,offset,src & dst,0xff); |
| 3124 | 3195 | break; |
| 3125 | 3196 | case 0x000d: |
| 3126 | | vga.memory[offset] = src & (~dst); |
| 3197 | m_vga->mem_linear_w(space,offset,src & (~dst),0xff); |
| 3127 | 3198 | break; |
| 3128 | 3199 | case 0x000e: |
| 3129 | | vga.memory[offset] = (~src) & dst; |
| 3200 | m_vga->mem_linear_w(space,offset,(~src) & dst,0xff); |
| 3130 | 3201 | break; |
| 3131 | 3202 | case 0x000f: |
| 3132 | | vga.memory[offset] = ~(src | dst); |
| 3203 | m_vga->mem_linear_w(space,offset,~(src | dst),0xff); |
| 3133 | 3204 | break; |
| 3134 | 3205 | } |
| 3135 | 3206 | } |
| 3136 | 3207 | |
| 3137 | | void ati_vga_device::ibm8514_write(UINT32 offset, UINT32 src) |
| 3208 | void ibm8514a_device::ibm8514_write(UINT32 offset, UINT32 src) |
| 3138 | 3209 | { |
| 3139 | 3210 | int data_size = 8; |
| 3140 | 3211 | UINT32 xfer = 0; |
| 3212 | address_space& space = machine().device("maincpu")->memory().space(AS_PROGRAM); |
| 3141 | 3213 | |
| 3142 | 3214 | switch(ibm8514.pixel_control & 0x00c0) |
| 3143 | 3215 | { |
| r18277 | r18278 | |
| 3180 | 3252 | ibm8514.src_x = 0; |
| 3181 | 3253 | break; |
| 3182 | 3254 | case 0x00c0: // use source plane |
| 3183 | | if(vga.memory[(src) % vga.svga_intf.vram_size] != 0x00) |
| 3255 | if(m_vga->mem_linear_r(space,src,0xff) != 0x00) |
| 3184 | 3256 | ibm8514_write_fg(offset); |
| 3185 | 3257 | else |
| 3186 | 3258 | ibm8514_write_bg(offset); |
| r18277 | r18278 | |
| 3198 | 3270 | the major or independent axis). |
| 3199 | 3271 | 0-13 (80x +) LINE PARAMETER/ERROR TERM. See above. |
| 3200 | 3272 | */ |
| 3201 | | READ16_MEMBER(ati_vga_device::ibm8514_line_error_r) |
| 3273 | READ16_MEMBER(ibm8514a_device::ibm8514_line_error_r) |
| 3202 | 3274 | { |
| 3203 | 3275 | return ibm8514.line_errorterm; |
| 3204 | 3276 | } |
| 3205 | 3277 | |
| 3206 | | WRITE16_MEMBER(ati_vga_device::ibm8514_line_error_w) |
| 3278 | WRITE16_MEMBER(ibm8514a_device::ibm8514_line_error_w) |
| 3207 | 3279 | { |
| 3208 | 3280 | ibm8514.line_errorterm = data; |
| 3209 | 3281 | if(LOG_8514) logerror("8514/A: Line Parameter/Error Term write %04x\n",data); |
| r18277 | r18278 | |
| 3230 | 3302 | available, Fh for 9 words, 7 for 10 words, 3 for 11 words, 1 for |
| 3231 | 3303 | 12 words and 0 for 13 words available. |
| 3232 | 3304 | */ |
| 3233 | | READ16_MEMBER(ati_vga_device::ibm8514_gpstatus_r) |
| 3305 | READ16_MEMBER(ibm8514a_device::ibm8514_gpstatus_r) |
| 3234 | 3306 | { |
| 3235 | 3307 | UINT16 ret = 0x0000; |
| 3236 | 3308 | |
| r18277 | r18278 | |
| 3242 | 3314 | return ret; |
| 3243 | 3315 | } |
| 3244 | 3316 | |
| 3245 | | void ati_vga_device::ibm8514_draw_vector(UINT8 len, UINT8 dir, bool draw) |
| 3317 | void ibm8514a_device::ibm8514_draw_vector(UINT8 len, UINT8 dir, bool draw) |
| 3246 | 3318 | { |
| 3247 | 3319 | UINT32 offset; |
| 3248 | 3320 | int x = 0; |
| 3249 | 3321 | |
| 3250 | 3322 | while(x <= len) |
| 3251 | 3323 | { |
| 3252 | | offset = (ibm8514.curr_y * VGA_LINE_LENGTH) + ibm8514.curr_x; |
| 3324 | offset = (ibm8514.curr_y * IBM8514_LINE_LENGTH) + ibm8514.curr_x; |
| 3253 | 3325 | if(draw) |
| 3254 | 3326 | ibm8514_write(offset,offset); |
| 3255 | 3327 | switch(dir) |
| r18277 | r18278 | |
| 3287 | 3359 | } |
| 3288 | 3360 | } |
| 3289 | 3361 | |
| 3290 | | READ16_MEMBER(s3_vga_device::s3_gpstatus_r) |
| 3291 | | { |
| 3292 | | UINT16 ret = 0x0000; |
| 3293 | | |
| 3294 | | //if(LOG_8514) logerror("S3: 9AE8 read\n"); |
| 3295 | | if(s3.enable_8514 != 0) |
| 3296 | | { |
| 3297 | | if(ibm8514.gpbusy == true) |
| 3298 | | ret |= 0x0200; |
| 3299 | | if(ibm8514.data_avail == true) |
| 3300 | | ret |= 0x0100; |
| 3301 | | return ret; |
| 3302 | | } |
| 3303 | | else |
| 3304 | | return 0xffff; |
| 3305 | | } |
| 3306 | | |
| 3307 | 3362 | /* |
| 3308 | 3363 | 9AE8h W(W): Drawing Command Register (CMD) |
| 3309 | 3364 | bit 0 (911-928) ~RD/WT. Read/Write Data. If set VRAM write operations are |
| r18277 | r18278 | |
| 3387 | 3442 | rectangle, which is copied repeatably to the destination |
| 3388 | 3443 | rectangle. |
| 3389 | 3444 | */ |
| 3390 | | WRITE16_MEMBER(ati_vga_device::ibm8514_cmd_w) |
| 3445 | WRITE16_MEMBER(ibm8514a_device::ibm8514_cmd_w) |
| 3391 | 3446 | { |
| 3392 | 3447 | int x,y; |
| 3393 | 3448 | int pattern_x,pattern_y; |
| r18277 | r18278 | |
| 3402 | 3457 | case 0x0000: // NOP (for "Short Stroke Vectors") |
| 3403 | 3458 | ibm8514.state = IBM8514_IDLE; |
| 3404 | 3459 | ibm8514.gpbusy = false; |
| 3405 | | if(LOG_8514) logerror("S3: Command (%04x) - NOP (Short Stroke Vector)\n",ibm8514.current_cmd); |
| 3460 | if(LOG_8514) logerror("8514/A: Command (%04x) - NOP (Short Stroke Vector)\n",ibm8514.current_cmd); |
| 3406 | 3461 | break; |
| 3407 | 3462 | case 0x2000: // Line |
| 3408 | 3463 | ibm8514.state = IBM8514_IDLE; |
| r18277 | r18278 | |
| 3413 | 3468 | { |
| 3414 | 3469 | ibm8514.state = IBM8514_DRAWING_LINE; |
| 3415 | 3470 | ibm8514.data_avail = true; |
| 3416 | | if(LOG_8514) logerror("S3: Command (%04x) - Vector Line (WAIT) %i,%i \n",ibm8514.current_cmd,ibm8514.curr_x,ibm8514.curr_y); |
| 3471 | if(LOG_8514) logerror("8514/A: Command (%04x) - Vector Line (WAIT) %i,%i \n",ibm8514.current_cmd,ibm8514.curr_x,ibm8514.curr_y); |
| 3417 | 3472 | } |
| 3418 | 3473 | else |
| 3419 | 3474 | { |
| 3420 | 3475 | ibm8514_draw_vector(ibm8514.rect_width,(data & 0x00e0) >> 5,(data & 0010) ? true : false); |
| 3421 | | if(LOG_8514) logerror("S3: Command (%04x) - Vector Line - %i,%i \n",ibm8514.current_cmd,ibm8514.curr_x,ibm8514.curr_y); |
| 3476 | if(LOG_8514) logerror("8514/A: Command (%04x) - Vector Line - %i,%i \n",ibm8514.current_cmd,ibm8514.curr_x,ibm8514.curr_y); |
| 3422 | 3477 | } |
| 3423 | 3478 | } |
| 3424 | 3479 | else |
| r18277 | r18278 | |
| 3432 | 3487 | int count = 0; |
| 3433 | 3488 | INT16 temp; |
| 3434 | 3489 | |
| 3435 | | if(LOG_8514) logerror("S3: Command (%04x) - Line (Bresenham) - %i,%i Axial %i, Diagonal %i, Error %i, Major Axis %i, Minor Axis %i\n",ibm8514.current_cmd, |
| 3490 | if(LOG_8514) logerror("8514/A: Command (%04x) - Line (Bresenham) - %i,%i Axial %i, Diagonal %i, Error %i, Major Axis %i, Minor Axis %i\n",ibm8514.current_cmd, |
| 3436 | 3491 | ibm8514.curr_x,ibm8514.curr_y,ibm8514.line_axial_step,ibm8514.line_diagonal_step,ibm8514.line_errorterm,ibm8514.rect_width,ibm8514.rect_height); |
| 3437 | 3492 | |
| 3438 | 3493 | if((data & 0x0040)) |
| r18277 | r18278 | |
| 3441 | 3496 | } |
| 3442 | 3497 | for(;;) |
| 3443 | 3498 | { |
| 3444 | | ibm8514_write(ibm8514.curr_x + (ibm8514.curr_y * VGA_LINE_LENGTH),ibm8514.curr_x + (ibm8514.curr_y * VGA_LINE_LENGTH)); |
| 3499 | ibm8514_write(ibm8514.curr_x + (ibm8514.curr_y * IBM8514_LINE_LENGTH),ibm8514.curr_x + (ibm8514.curr_y * IBM8514_LINE_LENGTH)); |
| 3445 | 3500 | if (count > ibm8514.rect_width) break; |
| 3446 | 3501 | count++; |
| 3447 | 3502 | if((err*2) > -dy) |
| r18277 | r18278 | |
| 3464 | 3519 | //ibm8514.gpbusy = true; // DirectX 5 keeps waiting for the busy bit to be clear... |
| 3465 | 3520 | ibm8514.bus_size = (data & 0x0600) >> 9; |
| 3466 | 3521 | ibm8514.data_avail = true; |
| 3467 | | if(LOG_8514) logerror("S3: Command (%04x) - Rectangle Fill (WAIT) %i,%i Width: %i Height: %i Colour: %08x\n",ibm8514.current_cmd,ibm8514.curr_x, |
| 3522 | if(LOG_8514) logerror("8514/A: Command (%04x) - Rectangle Fill (WAIT) %i,%i Width: %i Height: %i Colour: %08x\n",ibm8514.current_cmd,ibm8514.curr_x, |
| 3468 | 3523 | ibm8514.curr_y,ibm8514.rect_width,ibm8514.rect_height,ibm8514.fgcolour); |
| 3469 | 3524 | break; |
| 3470 | 3525 | } |
| 3471 | | if(LOG_8514) logerror("S3: Command (%04x) - Rectangle Fill %i,%i Width: %i Height: %i Colour: %08x\n",ibm8514.current_cmd,ibm8514.curr_x, |
| 3526 | if(LOG_8514) logerror("8514/A: Command (%04x) - Rectangle Fill %i,%i Width: %i Height: %i Colour: %08x\n",ibm8514.current_cmd,ibm8514.curr_x, |
| 3472 | 3527 | ibm8514.curr_y,ibm8514.rect_width,ibm8514.rect_height,ibm8514.fgcolour); |
| 3473 | 3528 | off = 0; |
| 3474 | | off += (VGA_LINE_LENGTH * ibm8514.curr_y); |
| 3529 | off += (IBM8514_LINE_LENGTH * ibm8514.curr_y); |
| 3475 | 3530 | off += ibm8514.curr_x; |
| 3476 | 3531 | for(y=0;y<=ibm8514.rect_height;y++) |
| 3477 | 3532 | { |
| 3478 | 3533 | for(x=0;x<=ibm8514.rect_width;x++) |
| 3479 | 3534 | { |
| 3480 | 3535 | if(data & 0x0020) // source pattern is always based on current X/Y? |
| 3481 | | ibm8514_write((off+x) % vga.svga_intf.vram_size,(off+x) % vga.svga_intf.vram_size); |
| 3536 | ibm8514_write((off+x) % m_vga->vga.svga_intf.vram_size,(off+x) % m_vga->vga.svga_intf.vram_size); |
| 3482 | 3537 | else |
| 3483 | | ibm8514_write((off-x) % vga.svga_intf.vram_size,(off-x) % vga.svga_intf.vram_size); |
| 3538 | ibm8514_write((off-x) % m_vga->vga.svga_intf.vram_size,(off-x) % m_vga->vga.svga_intf.vram_size); |
| 3484 | 3539 | if(ibm8514.current_cmd & 0x0020) |
| 3485 | 3540 | { |
| 3486 | 3541 | ibm8514.curr_x++; |
| r18277 | r18278 | |
| 3509 | 3564 | } |
| 3510 | 3565 | } |
| 3511 | 3566 | if(data & 0x0080) |
| 3512 | | off += VGA_LINE_LENGTH; |
| 3567 | off += IBM8514_LINE_LENGTH; |
| 3513 | 3568 | else |
| 3514 | | off -= VGA_LINE_LENGTH; |
| 3569 | off -= IBM8514_LINE_LENGTH; |
| 3515 | 3570 | } |
| 3516 | 3571 | ibm8514.state = IBM8514_IDLE; |
| 3517 | 3572 | ibm8514.gpbusy = false; |
| 3518 | 3573 | break; |
| 3519 | 3574 | case 0xc000: // BitBLT |
| 3520 | | if(LOG_8514) logerror("S3: Command (%04x) - BitBLT from %i,%i to %i,%i Width: %i Height: %i\n",ibm8514.current_cmd, |
| 3575 | if(LOG_8514) logerror("8514/A: Command (%04x) - BitBLT from %i,%i to %i,%i Width: %i Height: %i\n",ibm8514.current_cmd, |
| 3521 | 3576 | ibm8514.curr_x,ibm8514.curr_y,ibm8514.dest_x,ibm8514.dest_y,ibm8514.rect_width,ibm8514.rect_height); |
| 3522 | 3577 | off = 0; |
| 3523 | | off += (VGA_LINE_LENGTH * ibm8514.dest_y); |
| 3578 | off += (IBM8514_LINE_LENGTH * ibm8514.dest_y); |
| 3524 | 3579 | off += ibm8514.dest_x; |
| 3525 | 3580 | src = 0; |
| 3526 | | src += (VGA_LINE_LENGTH * ibm8514.curr_y); |
| 3581 | src += (IBM8514_LINE_LENGTH * ibm8514.curr_y); |
| 3527 | 3582 | src += ibm8514.curr_x; |
| 3528 | 3583 | for(y=0;y<=ibm8514.rect_height;y++) |
| 3529 | 3584 | { |
| 3530 | 3585 | for(x=0;x<=ibm8514.rect_width;x++) |
| 3531 | 3586 | { |
| 3532 | 3587 | if(data & 0x0020) |
| 3533 | | vga.memory[(off+x) % vga.svga_intf.vram_size] = vga.memory[(src+x) % vga.svga_intf.vram_size]; |
| 3588 | m_vga->mem_linear_w(space,(off+x),m_vga->mem_linear_r(space,(src+x),0xff),0xff); |
| 3534 | 3589 | else |
| 3535 | | vga.memory[(off-x) % vga.svga_intf.vram_size] = vga.memory[(src-x) % vga.svga_intf.vram_size]; |
| 3590 | m_vga->mem_linear_w(space,(off-x),m_vga->mem_linear_r(space,(src-x),0xff),0xff); |
| 3536 | 3591 | if(ibm8514.current_cmd & 0x0020) |
| 3537 | 3592 | { |
| 3538 | 3593 | ibm8514.curr_x++; |
| r18277 | r18278 | |
| 3562 | 3617 | } |
| 3563 | 3618 | if(data & 0x0080) |
| 3564 | 3619 | { |
| 3565 | | src += VGA_LINE_LENGTH; |
| 3566 | | off += VGA_LINE_LENGTH; |
| 3620 | src += IBM8514_LINE_LENGTH; |
| 3621 | off += IBM8514_LINE_LENGTH; |
| 3567 | 3622 | } |
| 3568 | 3623 | else |
| 3569 | 3624 | { |
| 3570 | | src -= VGA_LINE_LENGTH; |
| 3571 | | off -= VGA_LINE_LENGTH; |
| 3625 | src -= IBM8514_LINE_LENGTH; |
| 3626 | off -= IBM8514_LINE_LENGTH; |
| 3572 | 3627 | } |
| 3573 | 3628 | } |
| 3574 | 3629 | ibm8514.state = IBM8514_IDLE; |
| 3575 | 3630 | ibm8514.gpbusy = false; |
| 3576 | 3631 | break; |
| 3577 | 3632 | case 0xe000: // Pattern Fill |
| 3578 | | if(LOG_8514) logerror("S3: Command (%04x) - Pattern Fill - source %i,%i dest %i,%i Width: %i Height: %i\n",ibm8514.current_cmd, |
| 3633 | if(LOG_8514) logerror("8514/A: Command (%04x) - Pattern Fill - source %i,%i dest %i,%i Width: %i Height: %i\n",ibm8514.current_cmd, |
| 3579 | 3634 | ibm8514.curr_x,ibm8514.curr_y,ibm8514.dest_x,ibm8514.dest_y,ibm8514.rect_width,ibm8514.rect_height); |
| 3580 | 3635 | off = 0; |
| 3581 | | off += (VGA_LINE_LENGTH * ibm8514.dest_y); |
| 3636 | off += (IBM8514_LINE_LENGTH * ibm8514.dest_y); |
| 3582 | 3637 | off += ibm8514.dest_x; |
| 3583 | 3638 | src = 0; |
| 3584 | | src += (VGA_LINE_LENGTH * ibm8514.curr_y); |
| 3639 | src += (IBM8514_LINE_LENGTH * ibm8514.curr_y); |
| 3585 | 3640 | src += ibm8514.curr_x; |
| 3586 | 3641 | if(data & 0x0020) |
| 3587 | 3642 | pattern_x = 0; |
| r18277 | r18278 | |
| 3620 | 3675 | if(data & 0x0080) |
| 3621 | 3676 | { |
| 3622 | 3677 | pattern_y++; |
| 3623 | | src += VGA_LINE_LENGTH; |
| 3678 | src += IBM8514_LINE_LENGTH; |
| 3624 | 3679 | if(pattern_y >= 8) |
| 3625 | 3680 | { |
| 3626 | 3681 | pattern_y = 0; |
| 3627 | | src -= (VGA_LINE_LENGTH * 8); // move src pointer back to top of pattern |
| 3682 | src -= (IBM8514_LINE_LENGTH * 8); // move src pointer back to top of pattern |
| 3628 | 3683 | } |
| 3629 | | off += VGA_LINE_LENGTH; |
| 3684 | off += IBM8514_LINE_LENGTH; |
| 3630 | 3685 | } |
| 3631 | 3686 | else |
| 3632 | 3687 | { |
| 3633 | 3688 | pattern_y--; |
| 3634 | | src -= VGA_LINE_LENGTH; |
| 3689 | src -= IBM8514_LINE_LENGTH; |
| 3635 | 3690 | if(pattern_y < 0) |
| 3636 | 3691 | { |
| 3637 | 3692 | pattern_y = 7; |
| 3638 | | src += (VGA_LINE_LENGTH * 8); // move src pointer back to bottom of pattern |
| 3693 | src += (IBM8514_LINE_LENGTH * 8); // move src pointer back to bottom of pattern |
| 3639 | 3694 | } |
| 3640 | | off -= VGA_LINE_LENGTH; |
| 3695 | off -= IBM8514_LINE_LENGTH; |
| 3641 | 3696 | } |
| 3642 | 3697 | } |
| 3643 | 3698 | ibm8514.state = IBM8514_IDLE; |
| r18277 | r18278 | |
| 3646 | 3701 | default: |
| 3647 | 3702 | ibm8514.state = IBM8514_IDLE; |
| 3648 | 3703 | ibm8514.gpbusy = false; |
| 3649 | | if(LOG_8514) logerror("S3: Unknown command: %04x\n",data); |
| 3704 | if(LOG_8514) logerror("8514/A: Unknown command: %04x\n",data); |
| 3650 | 3705 | } |
| 3651 | 3706 | } |
| 3652 | 3707 | |
| 3653 | | WRITE16_MEMBER(s3_vga_device::s3_cmd_w) |
| 3654 | | { |
| 3655 | | if(s3.enable_8514 != 0) |
| 3656 | | ibm8514_cmd_w(space,offset,data,mem_mask); |
| 3657 | | } |
| 3658 | 3708 | /* |
| 3659 | 3709 | 8AE8h W(R/W): Destination Y Position & Axial Step Constant Register |
| 3660 | 3710 | (DESTY_AXSTP) |
| r18277 | r18278 | |
| 3667 | 3717 | 0-13 (80 x+) LINE PARAMETER AXIAL STEP CONSTANT. Se above |
| 3668 | 3718 | |
| 3669 | 3719 | */ |
| 3670 | | READ16_MEMBER(ati_vga_device::ibm8514_desty_r) |
| 3720 | READ16_MEMBER(ibm8514a_device::ibm8514_desty_r) |
| 3671 | 3721 | { |
| 3672 | 3722 | return ibm8514.line_axial_step; |
| 3673 | 3723 | } |
| 3674 | 3724 | |
| 3675 | | WRITE16_MEMBER(ati_vga_device::ibm8514_desty_w) |
| 3725 | WRITE16_MEMBER(ibm8514a_device::ibm8514_desty_w) |
| 3676 | 3726 | { |
| 3677 | 3727 | ibm8514.line_axial_step = data; |
| 3678 | 3728 | ibm8514.dest_y = data; |
| r18277 | r18278 | |
| 3692 | 3742 | 0-13 (80x +) LINE PARAMETER DIAGONAL STEP CONSTANT. Se above |
| 3693 | 3743 | |
| 3694 | 3744 | */ |
| 3695 | | READ16_MEMBER(ati_vga_device::ibm8514_destx_r) |
| 3745 | READ16_MEMBER(ibm8514a_device::ibm8514_destx_r) |
| 3696 | 3746 | { |
| 3697 | 3747 | return ibm8514.line_diagonal_step; |
| 3698 | 3748 | } |
| 3699 | 3749 | |
| 3700 | | WRITE16_MEMBER(ati_vga_device::ibm8514_destx_w) |
| 3750 | WRITE16_MEMBER(ibm8514a_device::ibm8514_destx_w) |
| 3701 | 3751 | { |
| 3702 | 3752 | ibm8514.line_diagonal_step = data; |
| 3703 | 3753 | ibm8514.dest_x = data; |
| r18277 | r18278 | |
| 3726 | 3776 | 9EE9h before execution starts. A single 16bit write will do. |
| 3727 | 3777 | If only one SSV is desired the other byte can be set to 0. |
| 3728 | 3778 | */ |
| 3729 | | void ati_vga_device::ibm8514_wait_draw_ssv() |
| 3779 | void ibm8514a_device::ibm8514_wait_draw_ssv() |
| 3730 | 3780 | { |
| 3731 | 3781 | UINT8 len = ibm8514.wait_vector_len; |
| 3732 | 3782 | UINT8 dir = ibm8514.wait_vector_dir; |
| r18277 | r18278 | |
| 3776 | 3826 | |
| 3777 | 3827 | if(ibm8514.state == IBM8514_DRAWING_SSV_1 || ibm8514.state == IBM8514_DRAWING_SSV_2) |
| 3778 | 3828 | { |
| 3779 | | offset = (ibm8514.curr_y * VGA_LINE_LENGTH) + ibm8514.curr_x; |
| 3829 | offset = (ibm8514.curr_y * IBM8514_LINE_LENGTH) + ibm8514.curr_x; |
| 3780 | 3830 | if(draw) |
| 3781 | 3831 | ibm8514_write(offset,offset); |
| 3782 | 3832 | switch(dir) |
| r18277 | r18278 | |
| 3814 | 3864 | } |
| 3815 | 3865 | } |
| 3816 | 3866 | |
| 3817 | | void ati_vga_device::ibm8514_draw_ssv(UINT8 data) |
| 3867 | void ibm8514a_device::ibm8514_draw_ssv(UINT8 data) |
| 3818 | 3868 | { |
| 3819 | 3869 | UINT8 len = data & 0x0f; |
| 3820 | 3870 | UINT8 dir = (data & 0xe0) >> 5; |
| r18277 | r18278 | |
| 3823 | 3873 | ibm8514_draw_vector(len,dir,draw); |
| 3824 | 3874 | } |
| 3825 | 3875 | |
| 3826 | | READ16_MEMBER(ati_vga_device::ibm8514_ssv_r) |
| 3876 | READ16_MEMBER(ibm8514a_device::ibm8514_ssv_r) |
| 3827 | 3877 | { |
| 3828 | 3878 | return ibm8514.ssv; |
| 3829 | 3879 | } |
| 3830 | 3880 | |
| 3831 | | WRITE16_MEMBER(ati_vga_device::ibm8514_ssv_w) |
| 3881 | WRITE16_MEMBER(ibm8514a_device::ibm8514_ssv_w) |
| 3832 | 3882 | { |
| 3833 | 3883 | ibm8514.ssv = data; |
| 3834 | 3884 | |
| r18277 | r18278 | |
| 3856 | 3906 | if(LOG_8514) logerror("8514/A: Short Stroke Vector write %04x\n",data); |
| 3857 | 3907 | } |
| 3858 | 3908 | |
| 3859 | | void ati_vga_device::ibm8514_wait_draw_vector() |
| 3909 | void ibm8514a_device::ibm8514_wait_draw_vector() |
| 3860 | 3910 | { |
| 3861 | 3911 | UINT8 len = ibm8514.wait_vector_len; |
| 3862 | 3912 | UINT8 dir = ibm8514.wait_vector_dir; |
| r18277 | r18278 | |
| 3888 | 3938 | |
| 3889 | 3939 | if(ibm8514.state == IBM8514_DRAWING_LINE) |
| 3890 | 3940 | { |
| 3891 | | offset = (ibm8514.curr_y * VGA_LINE_LENGTH) + ibm8514.curr_x; |
| 3941 | offset = (ibm8514.curr_y * IBM8514_LINE_LENGTH) + ibm8514.curr_x; |
| 3892 | 3942 | if(draw) |
| 3893 | 3943 | ibm8514_write(offset,offset); |
| 3894 | 3944 | switch(dir) |
| r18277 | r18278 | |
| 3935 | 3985 | independent axis). Must be positive. |
| 3936 | 3986 | 0-11 (80x +) RECTANGLE WIDTH/LINE PARAMETER MAX. See above |
| 3937 | 3987 | */ |
| 3938 | | READ16_MEMBER(ati_vga_device::ibm8514_width_r) |
| 3988 | READ16_MEMBER(ibm8514a_device::ibm8514_width_r) |
| 3939 | 3989 | { |
| 3940 | 3990 | return ibm8514.rect_width; |
| 3941 | 3991 | } |
| 3942 | 3992 | |
| 3943 | | WRITE16_MEMBER(ati_vga_device::ibm8514_width_w) |
| 3993 | WRITE16_MEMBER(ibm8514a_device::ibm8514_width_w) |
| 3944 | 3994 | { |
| 3945 | 3995 | ibm8514.rect_width = data & 0x1fff; |
| 3946 | | if(LOG_8514) logerror("S3: Major Axis Pixel Count / Rectangle Width write %04x\n",data); |
| 3996 | if(LOG_8514) logerror("8514/A: Major Axis Pixel Count / Rectangle Width write %04x\n",data); |
| 3947 | 3997 | } |
| 3948 | 3998 | |
| 3949 | | READ16_MEMBER(ati_vga_device::ibm8514_currentx_r) |
| 3999 | READ16_MEMBER(ibm8514a_device::ibm8514_currentx_r) |
| 3950 | 4000 | { |
| 3951 | 4001 | return ibm8514.curr_x; |
| 3952 | 4002 | } |
| 3953 | 4003 | |
| 3954 | | WRITE16_MEMBER(ati_vga_device::ibm8514_currentx_w) |
| 4004 | WRITE16_MEMBER(ibm8514a_device::ibm8514_currentx_w) |
| 3955 | 4005 | { |
| 3956 | 4006 | ibm8514.curr_x = data; |
| 3957 | 4007 | ibm8514.prev_x = data; |
| 3958 | 4008 | if(LOG_8514) logerror("8514/A: Current X set to %04x (%i)\n",data,ibm8514.curr_x); |
| 3959 | 4009 | } |
| 3960 | 4010 | |
| 3961 | | READ16_MEMBER(ati_vga_device::ibm8514_currenty_r) |
| 4011 | READ16_MEMBER(ibm8514a_device::ibm8514_currenty_r) |
| 3962 | 4012 | { |
| 3963 | 4013 | return ibm8514.curr_y; |
| 3964 | 4014 | } |
| 3965 | 4015 | |
| 3966 | | WRITE16_MEMBER(ati_vga_device::ibm8514_currenty_w) |
| 4016 | WRITE16_MEMBER(ibm8514a_device::ibm8514_currenty_w) |
| 3967 | 4017 | { |
| 3968 | 4018 | ibm8514.curr_y = data; |
| 3969 | 4019 | ibm8514.prev_y = data; |
| 3970 | 4020 | if(LOG_8514) logerror("8514/A: Current Y set to %04x (%i)\n",data,ibm8514.curr_y); |
| 3971 | 4021 | } |
| 3972 | 4022 | |
| 3973 | | READ16_MEMBER(ati_vga_device::ibm8514_fgcolour_r) |
| 4023 | READ16_MEMBER(ibm8514a_device::ibm8514_fgcolour_r) |
| 3974 | 4024 | { |
| 3975 | 4025 | return ibm8514.fgcolour; |
| 3976 | 4026 | } |
| 3977 | 4027 | |
| 3978 | | WRITE16_MEMBER(ati_vga_device::ibm8514_fgcolour_w) |
| 4028 | WRITE16_MEMBER(ibm8514a_device::ibm8514_fgcolour_w) |
| 3979 | 4029 | { |
| 3980 | 4030 | ibm8514.fgcolour = data; |
| 3981 | | if(LOG_8514) logerror("S3: Foreground Colour write %04x\n",data); |
| 4031 | if(LOG_8514) logerror("8514/A: Foreground Colour write %04x\n",data); |
| 3982 | 4032 | } |
| 3983 | 4033 | |
| 3984 | | READ16_MEMBER(ati_vga_device::ibm8514_bgcolour_r) |
| 4034 | READ16_MEMBER(ibm8514a_device::ibm8514_bgcolour_r) |
| 3985 | 4035 | { |
| 3986 | 4036 | return ibm8514.bgcolour; |
| 3987 | 4037 | } |
| 3988 | 4038 | |
| 3989 | | WRITE16_MEMBER(ati_vga_device::ibm8514_bgcolour_w) |
| 4039 | WRITE16_MEMBER(ibm8514a_device::ibm8514_bgcolour_w) |
| 3990 | 4040 | { |
| 3991 | 4041 | ibm8514.bgcolour = data; |
| 3992 | | if(LOG_8514) logerror("S3: Background Colour write %04x\n",data); |
| 4042 | if(LOG_8514) logerror("8514/A: Background Colour write %04x\n",data); |
| 3993 | 4043 | } |
| 3994 | 4044 | |
| 3995 | | READ16_MEMBER(ati_vga_device::ibm8514_multifunc_r ) |
| 4045 | READ16_MEMBER(ibm8514a_device::ibm8514_multifunc_r ) |
| 3996 | 4046 | { |
| 3997 | 4047 | switch(ibm8514.multifunc_sel) |
| 3998 | 4048 | { |
| r18277 | r18278 | |
| 4013 | 4063 | } |
| 4014 | 4064 | } |
| 4015 | 4065 | |
| 4016 | | WRITE16_MEMBER(ati_vga_device::ibm8514_multifunc_w ) |
| 4066 | WRITE16_MEMBER(ibm8514a_device::ibm8514_multifunc_w ) |
| 4017 | 4067 | { |
| 4018 | 4068 | switch(data & 0xf000) |
| 4019 | 4069 | { |
| r18277 | r18278 | |
| 4104 | 4154 | } |
| 4105 | 4155 | } |
| 4106 | 4156 | |
| 4107 | | void ati_vga_device::ibm8514_wait_draw() |
| 4157 | void ibm8514a_device::ibm8514_wait_draw() |
| 4108 | 4158 | { |
| 4109 | 4159 | int x, data_size = 8; |
| 4110 | 4160 | UINT32 off; |
| r18277 | r18278 | |
| 4117 | 4167 | if(ibm8514.bus_size == 2) // 32-bit |
| 4118 | 4168 | data_size = 32; |
| 4119 | 4169 | off = 0; |
| 4120 | | off += (VGA_LINE_LENGTH * ibm8514.curr_y); |
| 4170 | off += (IBM8514_LINE_LENGTH * ibm8514.curr_y); |
| 4121 | 4171 | off += ibm8514.curr_x; |
| 4122 | 4172 | if(ibm8514.current_cmd & 0x02) // "across plane mode" |
| 4123 | 4173 | { |
| 4124 | 4174 | for(x=0;x<data_size;x++) |
| 4125 | 4175 | { |
| 4126 | | ibm8514_write(off % vga.svga_intf.vram_size,off % vga.svga_intf.vram_size); |
| 4176 | ibm8514_write(off,off); |
| 4127 | 4177 | if(ibm8514.current_cmd & 0x0020) |
| 4128 | 4178 | { |
| 4129 | 4179 | off++; |
| r18277 | r18278 | |
| 4193 | 4243 | // "through plane" mode (single pixel) |
| 4194 | 4244 | for(x=0;x<data_size;x+=8) |
| 4195 | 4245 | { |
| 4196 | | ibm8514_write(off % vga.svga_intf.vram_size,off % vga.svga_intf.vram_size); |
| 4246 | ibm8514_write(off,off); |
| 4197 | 4247 | |
| 4198 | 4248 | if(ibm8514.current_cmd & 0x0020) |
| 4199 | 4249 | { |
| r18277 | r18278 | |
| 4288 | 4338 | 2 BSS is Pixel Data from the PIX_TRANS register (E2E8h) |
| 4289 | 4339 | 3 BSS is Bitmap Data (Source data from display buffer). |
| 4290 | 4340 | */ |
| 4291 | | READ16_MEMBER(ati_vga_device::ibm8514_backmix_r) |
| 4341 | READ16_MEMBER(ibm8514a_device::ibm8514_backmix_r) |
| 4292 | 4342 | { |
| 4293 | 4343 | return ibm8514.bgmix; |
| 4294 | 4344 | } |
| 4295 | 4345 | |
| 4296 | | WRITE16_MEMBER(ati_vga_device::ibm8514_backmix_w) |
| 4346 | WRITE16_MEMBER(ibm8514a_device::ibm8514_backmix_w) |
| 4297 | 4347 | { |
| 4298 | 4348 | ibm8514.bgmix = data; |
| 4299 | 4349 | if(LOG_8514) logerror("8514/A: BG Mix write %04x\n",data); |
| 4300 | 4350 | } |
| 4301 | 4351 | |
| 4302 | | READ16_MEMBER(ati_vga_device::ibm8514_foremix_r) |
| 4352 | READ16_MEMBER(ibm8514a_device::ibm8514_foremix_r) |
| 4303 | 4353 | { |
| 4304 | 4354 | return ibm8514.fgmix; |
| 4305 | 4355 | } |
| 4306 | 4356 | |
| 4307 | | WRITE16_MEMBER(ati_vga_device::ibm8514_foremix_w) |
| 4357 | WRITE16_MEMBER(ibm8514a_device::ibm8514_foremix_w) |
| 4308 | 4358 | { |
| 4309 | 4359 | ibm8514.fgmix = data; |
| 4310 | 4360 | if(LOG_8514) logerror("8514/A: FG Mix write %04x\n",data); |
| 4311 | 4361 | } |
| 4312 | 4362 | |
| 4313 | | READ16_MEMBER(ati_vga_device::ibm8514_pixel_xfer_r) |
| 4363 | READ16_MEMBER(ibm8514a_device::ibm8514_pixel_xfer_r) |
| 4314 | 4364 | { |
| 4315 | 4365 | if(offset == 1) |
| 4316 | 4366 | return (ibm8514.pixel_xfer & 0xffff0000) >> 16; |
| r18277 | r18278 | |
| 4318 | 4368 | return ibm8514.pixel_xfer & 0x0000ffff; |
| 4319 | 4369 | } |
| 4320 | 4370 | |
| 4321 | | WRITE16_MEMBER(ati_vga_device::ibm8514_pixel_xfer_w) |
| 4371 | WRITE16_MEMBER(ibm8514a_device::ibm8514_pixel_xfer_w) |
| 4322 | 4372 | { |
| 4323 | 4373 | if(offset == 1) |
| 4324 | 4374 | ibm8514.pixel_xfer = (ibm8514.pixel_xfer & 0x0000ffff) | (data << 16); |
| r18277 | r18278 | |
| 4364 | 4414 | |
| 4365 | 4415 | WRITE8_MEMBER(s3_vga_device::mem_w) |
| 4366 | 4416 | { |
| 4417 | ibm8514a_device* dev = get_8514(); |
| 4367 | 4418 | // bit 4 of CR53 enables memory-mapped I/O |
| 4368 | 4419 | // 0xA0000-0xA7ffff maps to port 0xE2E8 (pixel transfer) |
| 4369 | 4420 | if(s3.cr53 & 0x10) |
| r18277 | r18278 | |
| 4371 | 4422 | if(offset < 0x8000) |
| 4372 | 4423 | { |
| 4373 | 4424 | // pass through to the pixel transfer register (DirectX 5 wants this) |
| 4374 | | if(ibm8514.bus_size == 0) |
| 4425 | if(dev->ibm8514.bus_size == 0) |
| 4375 | 4426 | { |
| 4376 | | ibm8514.pixel_xfer = (ibm8514.pixel_xfer & 0xffffff00) | data; |
| 4377 | | ibm8514_wait_draw(); |
| 4427 | dev->ibm8514.pixel_xfer = (dev->ibm8514.pixel_xfer & 0xffffff00) | data; |
| 4428 | dev->ibm8514_wait_draw(); |
| 4378 | 4429 | } |
| 4379 | | if(ibm8514.bus_size == 1) |
| 4430 | if(dev->ibm8514.bus_size == 1) |
| 4380 | 4431 | { |
| 4381 | 4432 | switch(offset & 0x0001) |
| 4382 | 4433 | { |
| 4383 | 4434 | case 0: |
| 4384 | 4435 | default: |
| 4385 | | ibm8514.pixel_xfer = (ibm8514.pixel_xfer & 0xffffff00) | data; |
| 4436 | dev->ibm8514.pixel_xfer = (dev->ibm8514.pixel_xfer & 0xffffff00) | data; |
| 4386 | 4437 | break; |
| 4387 | 4438 | case 1: |
| 4388 | | ibm8514.pixel_xfer = (ibm8514.pixel_xfer & 0xffff00ff) | (data << 8); |
| 4389 | | ibm8514_wait_draw(); |
| 4439 | dev->ibm8514.pixel_xfer = (dev->ibm8514.pixel_xfer & 0xffff00ff) | (data << 8); |
| 4440 | dev->ibm8514_wait_draw(); |
| 4390 | 4441 | break; |
| 4391 | 4442 | } |
| 4392 | 4443 | } |
| 4393 | | if(ibm8514.bus_size == 2) |
| 4444 | if(dev->ibm8514.bus_size == 2) |
| 4394 | 4445 | { |
| 4395 | 4446 | switch(offset & 0x0003) |
| 4396 | 4447 | { |
| 4397 | 4448 | case 0: |
| 4398 | 4449 | default: |
| 4399 | | ibm8514.pixel_xfer = (ibm8514.pixel_xfer & 0xffffff00) | data; |
| 4450 | dev->ibm8514.pixel_xfer = (dev->ibm8514.pixel_xfer & 0xffffff00) | data; |
| 4400 | 4451 | break; |
| 4401 | 4452 | case 1: |
| 4402 | | ibm8514.pixel_xfer = (ibm8514.pixel_xfer & 0xffff00ff) | (data << 8); |
| 4453 | dev->ibm8514.pixel_xfer = (dev->ibm8514.pixel_xfer & 0xffff00ff) | (data << 8); |
| 4403 | 4454 | break; |
| 4404 | 4455 | case 2: |
| 4405 | | ibm8514.pixel_xfer = (ibm8514.pixel_xfer & 0xff00ffff) | (data << 16); |
| 4456 | dev->ibm8514.pixel_xfer = (dev->ibm8514.pixel_xfer & 0xff00ffff) | (data << 16); |
| 4406 | 4457 | break; |
| 4407 | 4458 | case 3: |
| 4408 | | ibm8514.pixel_xfer = (ibm8514.pixel_xfer & 0x00ffffff) | (data << 24); |
| 4409 | | ibm8514_wait_draw(); |
| 4459 | dev->ibm8514.pixel_xfer = (dev->ibm8514.pixel_xfer & 0x00ffffff) | (data << 24); |
| 4460 | dev->ibm8514_wait_draw(); |
| 4410 | 4461 | break; |
| 4411 | 4462 | } |
| 4412 | 4463 | } |
| r18277 | r18278 | |
| 4416 | 4467 | { |
| 4417 | 4468 | case 0x8100: |
| 4418 | 4469 | case 0x82e8: |
| 4419 | | ibm8514.curr_y = (ibm8514.curr_y & 0xff00) | data; |
| 4420 | | ibm8514.prev_y = (ibm8514.prev_y & 0xff00) | data; |
| 4470 | dev->ibm8514.curr_y = (dev->ibm8514.curr_y & 0xff00) | data; |
| 4471 | dev->ibm8514.prev_y = (dev->ibm8514.prev_y & 0xff00) | data; |
| 4421 | 4472 | break; |
| 4422 | 4473 | case 0x8101: |
| 4423 | 4474 | case 0x82e9: |
| 4424 | | ibm8514.curr_y = (ibm8514.curr_y & 0x00ff) | (data << 8); |
| 4425 | | ibm8514.prev_y = (ibm8514.prev_y & 0x00ff) | (data << 8); |
| 4475 | dev->ibm8514.curr_y = (dev->ibm8514.curr_y & 0x00ff) | (data << 8); |
| 4476 | dev->ibm8514.prev_y = (dev->ibm8514.prev_y & 0x00ff) | (data << 8); |
| 4426 | 4477 | break; |
| 4427 | 4478 | case 0x8102: |
| 4428 | 4479 | case 0x86e8: |
| 4429 | | ibm8514.curr_x = (ibm8514.curr_x & 0xff00) | data; |
| 4430 | | ibm8514.prev_x = (ibm8514.prev_x & 0xff00) | data; |
| 4480 | dev->ibm8514.curr_x = (dev->ibm8514.curr_x & 0xff00) | data; |
| 4481 | dev->ibm8514.prev_x = (dev->ibm8514.prev_x & 0xff00) | data; |
| 4431 | 4482 | break; |
| 4432 | 4483 | case 0x8103: |
| 4433 | 4484 | case 0x86e9: |
| 4434 | | ibm8514.curr_x = (ibm8514.curr_x & 0x00ff) | (data << 8); |
| 4435 | | ibm8514.prev_x = (ibm8514.prev_x & 0x00ff) | (data << 8); |
| 4485 | dev->ibm8514.curr_x = (dev->ibm8514.curr_x & 0x00ff) | (data << 8); |
| 4486 | dev->ibm8514.prev_x = (dev->ibm8514.prev_x & 0x00ff) | (data << 8); |
| 4436 | 4487 | break; |
| 4437 | 4488 | case 0x8108: |
| 4438 | 4489 | case 0x8ae8: |
| 4439 | | ibm8514.line_axial_step = (ibm8514.line_axial_step & 0xff00) | data; |
| 4440 | | ibm8514.dest_y = (ibm8514.dest_y & 0xff00) | data; |
| 4490 | dev->ibm8514.line_axial_step = (dev->ibm8514.line_axial_step & 0xff00) | data; |
| 4491 | dev->ibm8514.dest_y = (dev->ibm8514.dest_y & 0xff00) | data; |
| 4441 | 4492 | break; |
| 4442 | 4493 | case 0x8109: |
| 4443 | 4494 | case 0x8ae9: |
| 4444 | | ibm8514.line_axial_step = (ibm8514.line_axial_step & 0x00ff) | ((data & 0x3f) << 8); |
| 4445 | | ibm8514.dest_y = (ibm8514.dest_y & 0x00ff) | (data << 8); |
| 4495 | dev->ibm8514.line_axial_step = (dev->ibm8514.line_axial_step & 0x00ff) | ((data & 0x3f) << 8); |
| 4496 | dev->ibm8514.dest_y = (dev->ibm8514.dest_y & 0x00ff) | (data << 8); |
| 4446 | 4497 | break; |
| 4447 | 4498 | case 0x810a: |
| 4448 | 4499 | case 0x8ee8: |
| 4449 | | ibm8514.line_diagonal_step = (ibm8514.line_diagonal_step & 0xff00) | data; |
| 4450 | | ibm8514.dest_x = (ibm8514.dest_x & 0xff00) | data; |
| 4500 | dev->ibm8514.line_diagonal_step = (dev->ibm8514.line_diagonal_step & 0xff00) | data; |
| 4501 | dev->ibm8514.dest_x = (dev->ibm8514.dest_x & 0xff00) | data; |
| 4451 | 4502 | break; |
| 4452 | 4503 | case 0x810b: |
| 4453 | 4504 | case 0x8ee9: |
| 4454 | | ibm8514.line_diagonal_step = (ibm8514.line_diagonal_step & 0x00ff) | ((data & 0x3f) << 8); |
| 4455 | | ibm8514.dest_x = (ibm8514.dest_x & 0x00ff) | (data << 8); |
| 4505 | dev->ibm8514.line_diagonal_step = (dev->ibm8514.line_diagonal_step & 0x00ff) | ((data & 0x3f) << 8); |
| 4506 | dev->ibm8514.dest_x = (dev->ibm8514.dest_x & 0x00ff) | (data << 8); |
| 4456 | 4507 | break; |
| 4457 | 4508 | case 0x8118: |
| 4458 | 4509 | case 0x9ae8: |
| r18277 | r18278 | |
| 4461 | 4512 | case 0x8119: |
| 4462 | 4513 | case 0x9ae9: |
| 4463 | 4514 | s3.mmio_9ae8 = (s3.mmio_9ae8 & 0x00ff) | (data << 8); |
| 4464 | | s3_cmd_w(space,0,s3.mmio_9ae8,0xffff); |
| 4515 | dev->ibm8514_cmd_w(space,0,s3.mmio_9ae8,0xffff); |
| 4465 | 4516 | break; |
| 4466 | 4517 | case 0x8120: |
| 4467 | 4518 | case 0xa2e8: |
| 4468 | | ibm8514.bgcolour = (ibm8514.bgcolour & 0xff00) | data; |
| 4519 | dev->ibm8514.bgcolour = (dev->ibm8514.bgcolour & 0xff00) | data; |
| 4469 | 4520 | break; |
| 4470 | 4521 | case 0x8121: |
| 4471 | 4522 | case 0xa2e9: |
| 4472 | | ibm8514.bgcolour = (ibm8514.bgcolour & 0x00ff) | (data << 8); |
| 4523 | dev->ibm8514.bgcolour = (dev->ibm8514.bgcolour & 0x00ff) | (data << 8); |
| 4473 | 4524 | break; |
| 4474 | 4525 | case 0x8124: |
| 4475 | 4526 | case 0xa6e8: |
| 4476 | | ibm8514.fgcolour = (ibm8514.fgcolour & 0xff00) | data; |
| 4527 | dev->ibm8514.fgcolour = (dev->ibm8514.fgcolour & 0xff00) | data; |
| 4477 | 4528 | break; |
| 4478 | 4529 | case 0x8125: |
| 4479 | 4530 | case 0xa6e9: |
| 4480 | | ibm8514.fgcolour = (ibm8514.fgcolour & 0x00ff) | (data << 8); |
| 4531 | dev->ibm8514.fgcolour = (dev->ibm8514.fgcolour & 0x00ff) | (data << 8); |
| 4481 | 4532 | break; |
| 4482 | 4533 | case 0xb6e8: |
| 4483 | 4534 | case 0x8134: |
| 4484 | | ibm8514.bgmix = (ibm8514.bgmix & 0xff00) | data; |
| 4535 | dev->ibm8514.bgmix = (dev->ibm8514.bgmix & 0xff00) | data; |
| 4485 | 4536 | break; |
| 4486 | 4537 | case 0x8135: |
| 4487 | 4538 | case 0xb6e9: |
| 4488 | | ibm8514.bgmix = (ibm8514.bgmix & 0x00ff) | (data << 8); |
| 4539 | dev->ibm8514.bgmix = (dev->ibm8514.bgmix & 0x00ff) | (data << 8); |
| 4489 | 4540 | break; |
| 4490 | 4541 | case 0x8136: |
| 4491 | 4542 | case 0xbae8: |
| 4492 | | ibm8514.fgmix = (ibm8514.fgmix & 0xff00) | data; |
| 4543 | dev->ibm8514.fgmix = (dev->ibm8514.fgmix & 0xff00) | data; |
| 4493 | 4544 | break; |
| 4494 | 4545 | case 0x8137: |
| 4495 | 4546 | case 0xbae9: |
| 4496 | | ibm8514.fgmix = (ibm8514.fgmix & 0x00ff) | (data << 8); |
| 4547 | dev->ibm8514.fgmix = (dev->ibm8514.fgmix & 0x00ff) | (data << 8); |
| 4497 | 4548 | break; |
| 4498 | 4549 | case 0x8138: |
| 4499 | | ibm8514.scissors_top = (ibm8514.scissors_top & 0xff00) | data; |
| 4550 | dev->ibm8514.scissors_top = (dev->ibm8514.scissors_top & 0xff00) | data; |
| 4500 | 4551 | break; |
| 4501 | 4552 | case 0x8139: |
| 4502 | | ibm8514.scissors_top = (ibm8514.scissors_top & 0x00ff) | (data << 8); |
| 4553 | dev->ibm8514.scissors_top = (dev->ibm8514.scissors_top & 0x00ff) | (data << 8); |
| 4503 | 4554 | break; |
| 4504 | 4555 | case 0x813a: |
| 4505 | | ibm8514.scissors_left = (ibm8514.scissors_left & 0xff00) | data; |
| 4556 | dev->ibm8514.scissors_left = (dev->ibm8514.scissors_left & 0xff00) | data; |
| 4506 | 4557 | break; |
| 4507 | 4558 | case 0x813b: |
| 4508 | | ibm8514.scissors_left = (ibm8514.scissors_left & 0x00ff) | (data << 8); |
| 4559 | dev->ibm8514.scissors_left = (dev->ibm8514.scissors_left & 0x00ff) | (data << 8); |
| 4509 | 4560 | break; |
| 4510 | 4561 | case 0x813c: |
| 4511 | | ibm8514.scissors_bottom = (ibm8514.scissors_bottom & 0xff00) | data; |
| 4562 | dev->ibm8514.scissors_bottom = (dev->ibm8514.scissors_bottom & 0xff00) | data; |
| 4512 | 4563 | break; |
| 4513 | 4564 | case 0x813d: |
| 4514 | | ibm8514.scissors_bottom = (ibm8514.scissors_bottom & 0x00ff) | (data << 8); |
| 4565 | dev->ibm8514.scissors_bottom = (dev->ibm8514.scissors_bottom & 0x00ff) | (data << 8); |
| 4515 | 4566 | break; |
| 4516 | 4567 | case 0x813e: |
| 4517 | | ibm8514.scissors_right = (ibm8514.scissors_right & 0xff00) | data; |
| 4568 | dev->ibm8514.scissors_right = (dev->ibm8514.scissors_right & 0xff00) | data; |
| 4518 | 4569 | break; |
| 4519 | 4570 | case 0x813f: |
| 4520 | | ibm8514.scissors_right = (ibm8514.scissors_right & 0x00ff) | (data << 8); |
| 4571 | dev->ibm8514.scissors_right = (dev->ibm8514.scissors_right & 0x00ff) | (data << 8); |
| 4521 | 4572 | break; |
| 4522 | 4573 | case 0x8140: |
| 4523 | | ibm8514.pixel_control = (ibm8514.pixel_control & 0xff00) | data; |
| 4574 | dev->ibm8514.pixel_control = (dev->ibm8514.pixel_control & 0xff00) | data; |
| 4524 | 4575 | break; |
| 4525 | 4576 | case 0x8141: |
| 4526 | | ibm8514.pixel_control = (ibm8514.pixel_control & 0x00ff) | (data << 8); |
| 4577 | dev->ibm8514.pixel_control = (dev->ibm8514.pixel_control & 0x00ff) | (data << 8); |
| 4527 | 4578 | break; |
| 4528 | 4579 | case 0x8146: |
| 4529 | | ibm8514.multifunc_sel = (ibm8514.multifunc_sel & 0xff00) | data; |
| 4580 | dev->ibm8514.multifunc_sel = (dev->ibm8514.multifunc_sel & 0xff00) | data; |
| 4530 | 4581 | break; |
| 4531 | 4582 | case 0x8148: |
| 4532 | | ibm8514.rect_height = (ibm8514.rect_height & 0xff00) | data; |
| 4583 | dev->ibm8514.rect_height = (dev->ibm8514.rect_height & 0xff00) | data; |
| 4533 | 4584 | break; |
| 4534 | 4585 | case 0x8149: |
| 4535 | | ibm8514.rect_height = (ibm8514.rect_height & 0x00ff) | (data << 8); |
| 4586 | dev->ibm8514.rect_height = (dev->ibm8514.rect_height & 0x00ff) | (data << 8); |
| 4536 | 4587 | break; |
| 4537 | 4588 | case 0x814a: |
| 4538 | | ibm8514.rect_width = (ibm8514.rect_width & 0xff00) | data; |
| 4589 | dev->ibm8514.rect_width = (dev->ibm8514.rect_width & 0xff00) | data; |
| 4539 | 4590 | break; |
| 4540 | 4591 | case 0x814b: |
| 4541 | | ibm8514.rect_width = (ibm8514.rect_width & 0x00ff) | (data << 8); |
| 4592 | dev->ibm8514.rect_width = (dev->ibm8514.rect_width & 0x00ff) | (data << 8); |
| 4542 | 4593 | break; |
| 4543 | 4594 | case 0x8150: |
| 4544 | | ibm8514.pixel_xfer = (ibm8514.pixel_xfer & 0xffffff00) | data; |
| 4545 | | if(ibm8514.state == IBM8514_DRAWING_RECT) |
| 4546 | | ibm8514_wait_draw(); |
| 4595 | dev->ibm8514.pixel_xfer = (dev->ibm8514.pixel_xfer & 0xffffff00) | data; |
| 4596 | if(dev->ibm8514.state == IBM8514_DRAWING_RECT) |
| 4597 | dev->ibm8514_wait_draw(); |
| 4547 | 4598 | break; |
| 4548 | 4599 | case 0x8151: |
| 4549 | | ibm8514.pixel_xfer = (ibm8514.pixel_xfer & 0xffff00ff) | (data << 8); |
| 4550 | | if(ibm8514.state == IBM8514_DRAWING_RECT) |
| 4551 | | ibm8514_wait_draw(); |
| 4600 | dev->ibm8514.pixel_xfer = (dev->ibm8514.pixel_xfer & 0xffff00ff) | (data << 8); |
| 4601 | if(dev->ibm8514.state == IBM8514_DRAWING_RECT) |
| 4602 | dev->ibm8514_wait_draw(); |
| 4552 | 4603 | break; |
| 4553 | 4604 | case 0x8152: |
| 4554 | | ibm8514.pixel_xfer = (ibm8514.pixel_xfer & 0xff00ffff) | (data << 16); |
| 4555 | | if(ibm8514.state == IBM8514_DRAWING_RECT) |
| 4556 | | ibm8514_wait_draw(); |
| 4605 | dev->ibm8514.pixel_xfer = (dev->ibm8514.pixel_xfer & 0xff00ffff) | (data << 16); |
| 4606 | if(dev->ibm8514.state == IBM8514_DRAWING_RECT) |
| 4607 | dev->ibm8514_wait_draw(); |
| 4557 | 4608 | break; |
| 4558 | 4609 | case 0x8153: |
| 4559 | | ibm8514.pixel_xfer = (ibm8514.pixel_xfer & 0x00ffffff) | (data << 24); |
| 4560 | | if(ibm8514.state == IBM8514_DRAWING_RECT) |
| 4561 | | ibm8514_wait_draw(); |
| 4610 | dev->ibm8514.pixel_xfer = (dev->ibm8514.pixel_xfer & 0x00ffffff) | (data << 24); |
| 4611 | if(dev->ibm8514.state == IBM8514_DRAWING_RECT) |
| 4612 | dev->ibm8514_wait_draw(); |
| 4562 | 4613 | break; |
| 4563 | 4614 | case 0xbee8: |
| 4564 | 4615 | s3.mmio_bee8 = (s3.mmio_bee8 & 0xff00) | data; |
| 4565 | 4616 | break; |
| 4566 | 4617 | case 0xbee9: |
| 4567 | 4618 | s3.mmio_bee8 = (s3.mmio_bee8 & 0x00ff) | (data << 8); |
| 4568 | | ibm8514_multifunc_w(space,0,s3.mmio_bee8,0xffff); |
| 4619 | dev->ibm8514_multifunc_w(space,0,s3.mmio_bee8,0xffff); |
| 4569 | 4620 | break; |
| 4570 | 4621 | default: |
| 4571 | 4622 | if(LOG_8514) logerror("S3: MMIO offset %05x write %02x\n",offset+0xa0000,data); |
| r18277 | r18278 | |
| 4892 | 4943 | This bit toggles every time a HSYNC pulse starts |
| 4893 | 4944 | 3-15 Reserved(0) |
| 4894 | 4945 | */ |
| 4895 | | READ16_MEMBER(ati_vga_device::ibm8514_status_r) |
| 4946 | READ16_MEMBER(ibm8514a_device::ibm8514_status_r) |
| 4896 | 4947 | { |
| 4897 | | return vga_vblank() << 1; |
| 4948 | return m_vga->vga_vblank() << 1; |
| 4898 | 4949 | } |
| 4899 | 4950 | |
| 4900 | | WRITE16_MEMBER(ati_vga_device::ibm8514_htotal_w) |
| 4951 | WRITE16_MEMBER(ibm8514a_device::ibm8514_htotal_w) |
| 4901 | 4952 | { |
| 4902 | 4953 | ibm8514.htotal = data & 0x01ff; |
| 4903 | 4954 | //vga.crtc.horz_total = data & 0x01ff; |
| r18277 | r18278 | |
| 4924 | 4975 | 8-11 CHIP_REV. Chip revision number. |
| 4925 | 4976 | 12-15 (CT82c480) CHIP_ID. 0=CT 82c480. |
| 4926 | 4977 | */ |
| 4927 | | READ16_MEMBER(ati_vga_device::ibm8514_substatus_r) |
| 4978 | READ16_MEMBER(ibm8514a_device::ibm8514_substatus_r) |
| 4928 | 4979 | { |
| 4929 | 4980 | // TODO: |
| 4930 | | if(vga_vblank() != 0) // not correct, but will do for now |
| 4981 | if(m_vga->vga_vblank() != 0) // not correct, but will do for now |
| 4931 | 4982 | ibm8514.substatus |= 0x01; |
| 4932 | 4983 | return ibm8514.substatus; |
| 4933 | 4984 | } |
| r18277 | r18278 | |
| 4949 | 5000 | 12-13 CHPTEST. Used for chip testing. |
| 4950 | 5001 | 14-15 Graphics Processor Control (GPCTRL). |
| 4951 | 5002 | */ |
| 4952 | | WRITE16_MEMBER(ati_vga_device::ibm8514_subcontrol_w) |
| 5003 | WRITE16_MEMBER(ibm8514a_device::ibm8514_subcontrol_w) |
| 4953 | 5004 | { |
| 4954 | 5005 | ibm8514.subctrl = data; |
| 4955 | 5006 | ibm8514.substatus &= ~(data & 0x0f); // reset interrupts |
| 4956 | 5007 | // if(LOG_8514) logerror("8514/A: Subsystem control write %04x\n",data); |
| 4957 | 5008 | } |
| 4958 | 5009 | |
| 4959 | | READ16_MEMBER(ati_vga_device::ibm8514_subcontrol_r) |
| 5010 | READ16_MEMBER(ibm8514a_device::ibm8514_subcontrol_r) |
| 4960 | 5011 | { |
| 4961 | 5012 | return ibm8514.subctrl; |
| 4962 | 5013 | } |
| 4963 | 5014 | |
| 4964 | | READ16_MEMBER(ati_vga_device::ibm8514_htotal_r) |
| 5015 | READ16_MEMBER(ibm8514a_device::ibm8514_htotal_r) |
| 4965 | 5016 | { |
| 4966 | 5017 | return ibm8514.htotal; |
| 4967 | 5018 | } |
| 4968 | 5019 | |
| 4969 | | READ16_MEMBER(ati_vga_device::ibm8514_vtotal_r) |
| 5020 | READ16_MEMBER(ibm8514a_device::ibm8514_vtotal_r) |
| 4970 | 5021 | { |
| 4971 | 5022 | return ibm8514.vtotal; |
| 4972 | 5023 | } |
| 4973 | 5024 | |
| 4974 | | WRITE16_MEMBER(ati_vga_device::ibm8514_vtotal_w) |
| 5025 | WRITE16_MEMBER(ibm8514a_device::ibm8514_vtotal_w) |
| 4975 | 5026 | { |
| 4976 | 5027 | ibm8514.vtotal = data; |
| 4977 | 5028 | // vga.crtc.vert_total = data; |
| 4978 | 5029 | if(LOG_8514) logerror("8514/A: Vertical total write %04x\n",data); |
| 4979 | 5030 | } |
| 4980 | 5031 | |
| 4981 | | READ16_MEMBER(ati_vga_device::ibm8514_vdisp_r) |
| 5032 | READ16_MEMBER(ibm8514a_device::ibm8514_vdisp_r) |
| 4982 | 5033 | { |
| 4983 | 5034 | return ibm8514.vdisp; |
| 4984 | 5035 | } |
| 4985 | 5036 | |
| 4986 | | WRITE16_MEMBER(ati_vga_device::ibm8514_vdisp_w) |
| 5037 | WRITE16_MEMBER(ibm8514a_device::ibm8514_vdisp_w) |
| 4987 | 5038 | { |
| 4988 | 5039 | ibm8514.vdisp = data; |
| 4989 | 5040 | // vga.crtc.vert_disp_end = data >> 3; |
| 4990 | 5041 | if(LOG_8514) logerror("8514/A: Vertical Displayed write %04x\n",data); |
| 4991 | 5042 | } |
| 4992 | 5043 | |
| 4993 | | READ16_MEMBER(ati_vga_device::ibm8514_vsync_r) |
| 5044 | READ16_MEMBER(ibm8514a_device::ibm8514_vsync_r) |
| 4994 | 5045 | { |
| 4995 | 5046 | return ibm8514.vsync; |
| 4996 | 5047 | } |
| 4997 | 5048 | |
| 4998 | | WRITE16_MEMBER(ati_vga_device::ibm8514_vsync_w) |
| 5049 | WRITE16_MEMBER(ibm8514a_device::ibm8514_vsync_w) |
| 4999 | 5050 | { |
| 5000 | 5051 | ibm8514.vsync = data; |
| 5001 | 5052 | if(LOG_8514) logerror("8514/A: Vertical Sync write %04x\n",data); |
| 5002 | 5053 | } |
| 5003 | 5054 | |
| 5004 | | READ16_MEMBER(ati_vga_device::mach8_ec0_r) |
| 5055 | void ibm8514a_device::enabled() |
| 5005 | 5056 | { |
| 5057 | ibm8514.state = IBM8514_IDLE; |
| 5058 | ibm8514.gpbusy = false; |
| 5059 | } |
| 5060 | |
| 5061 | READ16_MEMBER(mach8_device::mach8_ec0_r) |
| 5062 | { |
| 5006 | 5063 | return ibm8514.ec0; |
| 5007 | 5064 | } |
| 5008 | 5065 | |
| 5009 | | WRITE16_MEMBER(ati_vga_device::mach8_ec0_w) |
| 5066 | WRITE16_MEMBER(mach8_device::mach8_ec0_w) |
| 5010 | 5067 | { |
| 5011 | 5068 | ibm8514.ec0 = data; |
| 5012 | 5069 | if(LOG_8514) logerror("8514/A: Extended configuration 0 write %04x\n",data); |
| 5013 | 5070 | } |
| 5014 | 5071 | |
| 5015 | | READ16_MEMBER(ati_vga_device::mach8_ec1_r) |
| 5072 | READ16_MEMBER(mach8_device::mach8_ec1_r) |
| 5016 | 5073 | { |
| 5017 | 5074 | return ibm8514.ec1; |
| 5018 | 5075 | } |
| 5019 | 5076 | |
| 5020 | | WRITE16_MEMBER(ati_vga_device::mach8_ec1_w) |
| 5077 | WRITE16_MEMBER(mach8_device::mach8_ec1_w) |
| 5021 | 5078 | { |
| 5022 | 5079 | ibm8514.ec1 = data; |
| 5023 | 5080 | if(LOG_8514) logerror("8514/A: Extended configuration 1 write %04x\n",data); |
| 5024 | 5081 | } |
| 5025 | 5082 | |
| 5026 | | READ16_MEMBER(ati_vga_device::mach8_ec2_r) |
| 5083 | READ16_MEMBER(mach8_device::mach8_ec2_r) |
| 5027 | 5084 | { |
| 5028 | 5085 | return ibm8514.ec2; |
| 5029 | 5086 | } |
| 5030 | 5087 | |
| 5031 | | WRITE16_MEMBER(ati_vga_device::mach8_ec2_w) |
| 5088 | WRITE16_MEMBER(mach8_device::mach8_ec2_w) |
| 5032 | 5089 | { |
| 5033 | 5090 | ibm8514.ec2 = data; |
| 5034 | 5091 | if(LOG_8514) logerror("8514/A: Extended configuration 2 write %04x\n",data); |
| 5035 | 5092 | } |
| 5036 | 5093 | |
| 5037 | | READ16_MEMBER(ati_vga_device::mach8_ec3_r) |
| 5094 | READ16_MEMBER(mach8_device::mach8_ec3_r) |
| 5038 | 5095 | { |
| 5039 | 5096 | return ibm8514.ec3; |
| 5040 | 5097 | } |
| 5041 | 5098 | |
| 5042 | | WRITE16_MEMBER(ati_vga_device::mach8_ec3_w) |
| 5099 | WRITE16_MEMBER(mach8_device::mach8_ec3_w) |
| 5043 | 5100 | { |
| 5044 | 5101 | ibm8514.ec3 = data; |
| 5045 | 5102 | if(LOG_8514) logerror("8514/A: Extended configuration 3 write %04x\n",data); |
| 5046 | 5103 | } |
| 5047 | 5104 | |
| 5048 | | READ16_MEMBER(ati_vga_device::mach8_ext_fifo_r) |
| 5105 | READ16_MEMBER(mach8_device::mach8_ext_fifo_r) |
| 5049 | 5106 | { |
| 5050 | 5107 | return 0x00; // for now, report all FIFO slots at free |
| 5051 | 5108 | } |
| 5052 | 5109 | |
| 5053 | | WRITE16_MEMBER(ati_vga_device::mach8_linedraw_index_w) |
| 5110 | WRITE16_MEMBER(mach8_device::mach8_linedraw_index_w) |
| 5054 | 5111 | { |
| 5055 | | ati.linedraw = data & 0x07; |
| 5112 | mach8.linedraw = data & 0x07; |
| 5056 | 5113 | if(LOG_8514) logerror("Mach8: Line Draw Index write %04x\n",data); |
| 5057 | 5114 | } |
| 5058 | 5115 | |
| 5059 | | READ16_MEMBER(ati_vga_device::mach8_bresenham_count_r) |
| 5116 | READ16_MEMBER(mach8_device::mach8_bresenham_count_r) |
| 5060 | 5117 | { |
| 5061 | 5118 | return ibm8514.rect_width & 0x1fff; |
| 5062 | 5119 | } |
| 5063 | 5120 | |
| 5064 | | WRITE16_MEMBER(ati_vga_device::mach8_bresenham_count_w) |
| 5121 | WRITE16_MEMBER(mach8_device::mach8_bresenham_count_w) |
| 5065 | 5122 | { |
| 5066 | 5123 | ibm8514.rect_width = data & 0x1fff; |
| 5067 | 5124 | if(LOG_8514) logerror("Mach8: Bresenham count write %04x\n",data); |
| 5068 | 5125 | } |
| 5069 | 5126 | |
| 5070 | | WRITE16_MEMBER(ati_vga_device::mach8_linedraw_w) |
| 5127 | READ16_MEMBER(mach8_device::mach8_linedraw_r) |
| 5071 | 5128 | { |
| 5129 | return 0xff; |
| 5130 | } |
| 5131 | |
| 5132 | WRITE16_MEMBER(mach8_device::mach8_linedraw_w) |
| 5133 | { |
| 5072 | 5134 | // TODO: actually draw the lines |
| 5073 | | switch(ati.linedraw) |
| 5135 | switch(mach8.linedraw) |
| 5074 | 5136 | { |
| 5075 | 5137 | case 0: // Set current X |
| 5076 | 5138 | ibm8514.curr_x = data; |
| 5077 | | ati.linedraw++; |
| 5139 | mach8.linedraw++; |
| 5078 | 5140 | break; |
| 5079 | 5141 | case 1: // Set current Y |
| 5080 | 5142 | ibm8514.curr_y = data; |
| 5081 | | ati.linedraw++; |
| 5143 | mach8.linedraw++; |
| 5082 | 5144 | break; |
| 5083 | 5145 | case 2: // Line end X |
| 5084 | 5146 | ibm8514.curr_x = data; |
| 5085 | | ati.linedraw++; |
| 5147 | mach8.linedraw++; |
| 5086 | 5148 | break; |
| 5087 | 5149 | case 3: // Line end Y |
| 5088 | 5150 | ibm8514.curr_y = data; |
| 5089 | | ati.linedraw = 2; |
| 5151 | mach8.linedraw = 2; |
| 5090 | 5152 | break; |
| 5091 | 5153 | case 4: // Set current X |
| 5092 | 5154 | ibm8514.curr_x = data; |
| 5093 | | ati.linedraw++; |
| 5155 | mach8.linedraw++; |
| 5094 | 5156 | break; |
| 5095 | 5157 | case 5: // Set current Y |
| 5096 | 5158 | ibm8514.curr_y = data; |
| 5097 | | ati.linedraw = 4; |
| 5159 | mach8.linedraw = 4; |
| 5098 | 5160 | break; |
| 5099 | 5161 | } |
| 5100 | | logerror("ATI: Linedraw register write %04x, mode %i\n",data,ati.linedraw); |
| 5162 | logerror("ATI: Linedraw register write %04x, mode %i\n",data,mach8.linedraw); |
| 5101 | 5163 | } |
| 5102 | 5164 | |
| 5103 | | READ16_MEMBER(ati_vga_device::mach8_scratch0_r) |
| 5165 | READ16_MEMBER(mach8_device::mach8_scratch0_r) |
| 5104 | 5166 | { |
| 5105 | | return ati.scratch0; |
| 5167 | return mach8.scratch0; |
| 5106 | 5168 | } |
| 5107 | 5169 | |
| 5108 | | WRITE16_MEMBER(ati_vga_device::mach8_scratch0_w) |
| 5170 | WRITE16_MEMBER(mach8_device::mach8_scratch0_w) |
| 5109 | 5171 | { |
| 5110 | | ati.scratch0 = data; |
| 5172 | mach8.scratch0 = data; |
| 5111 | 5173 | if(LOG_8514) logerror("Mach8: Scratch Pad 0 write %04x\n",data); |
| 5112 | 5174 | } |
| 5113 | 5175 | |
| 5114 | | READ16_MEMBER(ati_vga_device::mach8_scratch1_r) |
| 5176 | READ16_MEMBER(mach8_device::mach8_scratch1_r) |
| 5115 | 5177 | { |
| 5116 | | return ati.scratch1; |
| 5178 | return mach8.scratch1; |
| 5117 | 5179 | } |
| 5118 | 5180 | |
| 5119 | | WRITE16_MEMBER(ati_vga_device::mach8_scratch1_w) |
| 5181 | WRITE16_MEMBER(mach8_device::mach8_scratch1_w) |
| 5120 | 5182 | { |
| 5121 | | ati.scratch1 = data; |
| 5183 | mach8.scratch1 = data; |
| 5122 | 5184 | if(LOG_8514) logerror("Mach8: Scratch Pad 1 write %04x\n",data); |
| 5123 | 5185 | } |
| 5124 | 5186 | |
| r18277 | r18278 | |
| 5135 | 5197 | 9-15 ROM_LOCATION. If bit 2 and 3 are 0 the ROM will be at this location: |
| 5136 | 5198 | 0: C000h, 1: C080h, 2: C100h, .. 127: FF80h (unlikely) |
| 5137 | 5199 | */ |
| 5138 | | READ16_MEMBER(ati_vga_device::mach8_config1_r) |
| 5200 | READ16_MEMBER(mach8_device::mach8_config1_r) |
| 5139 | 5201 | { |
| 5140 | 5202 | return 0x0082; |
| 5141 | 5203 | } |
| r18277 | r18278 | |
| 5148 | 5210 | 3 WRITE_PER_BIT. Write masked VRAM operations supported if set |
| 5149 | 5211 | 4 FLASH_ENA. Flash page writes supported if set |
| 5150 | 5212 | */ |
| 5151 | | READ16_MEMBER(ati_vga_device::mach8_config2_r) |
| 5213 | READ16_MEMBER(mach8_device::mach8_config2_r) |
| 5152 | 5214 | { |
| 5153 | 5215 | return 0x0002; |
| 5154 | 5216 | } |
trunk/src/emu/video/pc_vga.h
| r18277 | r18278 | |
| 18 | 18 | |
| 19 | 19 | class vga_device : public device_t |
| 20 | 20 | { |
| 21 | friend class ibm8514a_device; |
| 22 | |
| 21 | 23 | public: |
| 22 | 24 | // construction/destruction |
| 23 | 25 | vga_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock); |
| r18277 | r18278 | |
| 204 | 206 | void svga_vh_rgb24(bitmap_rgb32 &bitmap, const rectangle &cliprect); |
| 205 | 207 | void svga_vh_rgb32(bitmap_rgb32 &bitmap, const rectangle &cliprect); |
| 206 | 208 | virtual UINT8 pc_vga_choosevideomode(); |
| 209 | virtual void device_start(); |
| 207 | 210 | struct |
| 208 | 211 | { |
| 209 | 212 | UINT8 bank_r,bank_w; |
| r18277 | r18278 | |
| 217 | 220 | private: |
| 218 | 221 | }; |
| 219 | 222 | |
| 220 | | // ======================> tseng_vga_device |
| 223 | // ======================> ibm8514_device |
| 221 | 224 | |
| 222 | | class tseng_vga_device : public svga_device |
| 225 | class ibm8514a_device : public device_t |
| 223 | 226 | { |
| 224 | 227 | public: |
| 225 | | // construction/destruction |
| 226 | | tseng_vga_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock); |
| 228 | ibm8514a_device(const machine_config &mconfig, device_type type, const char *name, const char *tag, device_t *owner, UINT32 clock); |
| 229 | ibm8514a_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock); |
| 227 | 230 | |
| 228 | | virtual READ8_MEMBER(port_03b0_r); |
| 229 | | virtual WRITE8_MEMBER(port_03b0_w); |
| 230 | | virtual READ8_MEMBER(port_03c0_r); |
| 231 | | virtual WRITE8_MEMBER(port_03c0_w); |
| 232 | | virtual READ8_MEMBER(port_03d0_r); |
| 233 | | virtual WRITE8_MEMBER(port_03d0_w); |
| 234 | | virtual READ8_MEMBER(mem_r); |
| 235 | | virtual WRITE8_MEMBER(mem_w); |
| 231 | void set_vga(const char* tag) { m_vga_tag.cpy(tag); } |
| 232 | void set_vga_owner() { m_vga = dynamic_cast<vga_device*>(owner()); } |
| 236 | 233 | |
| 237 | | protected: |
| 234 | void enabled(); |
| 238 | 235 | |
| 239 | | private: |
| 240 | | void tseng_define_video_mode(); |
| 241 | | UINT8 tseng_crtc_reg_read(UINT8 index); |
| 242 | | void tseng_crtc_reg_write(UINT8 index, UINT8 data); |
| 243 | | UINT8 tseng_seq_reg_read(UINT8 index); |
| 244 | | void tseng_seq_reg_write(UINT8 index, UINT8 data); |
| 245 | | |
| 246 | | struct |
| 247 | | { |
| 248 | | UINT8 reg_3d8; |
| 249 | | UINT8 dac_ctrl; |
| 250 | | UINT8 dac_state; |
| 251 | | UINT8 horz_overflow; |
| 252 | | UINT8 aux_ctrl; |
| 253 | | bool ext_reg_ena; |
| 254 | | }et4k; |
| 255 | | |
| 256 | | }; |
| 257 | | |
| 258 | | |
| 259 | | // device type definition |
| 260 | | extern const device_type TSENG_VGA; |
| 261 | | |
| 262 | | // ======================> trident_vga_device |
| 263 | | |
| 264 | | class trident_vga_device : public svga_device |
| 265 | | { |
| 266 | | public: |
| 267 | | // construction/destruction |
| 268 | | trident_vga_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock); |
| 269 | | |
| 270 | | virtual READ8_MEMBER(port_03c0_r); |
| 271 | | virtual WRITE8_MEMBER(port_03c0_w); |
| 272 | | virtual READ8_MEMBER(port_03d0_r); |
| 273 | | virtual WRITE8_MEMBER(port_03d0_w); |
| 274 | | virtual READ8_MEMBER(mem_r); |
| 275 | | virtual WRITE8_MEMBER(mem_w); |
| 276 | | |
| 277 | | protected: |
| 278 | | |
| 279 | | private: |
| 280 | | UINT8 trident_seq_reg_read(UINT8 index); |
| 281 | | void trident_seq_reg_write(UINT8 index, UINT8 data); |
| 282 | | |
| 283 | | }; |
| 284 | | |
| 285 | | |
| 286 | | // device type definition |
| 287 | | extern const device_type TRIDENT_VGA; |
| 288 | | |
| 289 | | |
| 290 | | // ======================> ati_vga_device |
| 291 | | |
| 292 | | class ati_vga_device : public svga_device |
| 293 | | { |
| 294 | | public: |
| 295 | | // construction/destruction |
| 296 | | ati_vga_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock); |
| 297 | | ati_vga_device(const machine_config &mconfig, device_type type, const char *name, const char *tag, device_t *owner, UINT32 clock); |
| 298 | | |
| 299 | | virtual READ8_MEMBER(mem_r); |
| 300 | | virtual WRITE8_MEMBER(mem_w); |
| 301 | | |
| 302 | | // VGA registers |
| 303 | | virtual READ8_MEMBER(port_03c0_r); |
| 304 | | READ8_MEMBER(ati_port_ext_r); |
| 305 | | WRITE8_MEMBER(ati_port_ext_w); |
| 306 | | |
| 307 | | // TODO: move 8514/A registers to their own device |
| 308 | 236 | READ16_MEMBER(ibm8514_gpstatus_r); |
| 309 | 237 | WRITE16_MEMBER(ibm8514_cmd_w); |
| 310 | 238 | READ16_MEMBER(ibm8514_line_error_r); |
| r18277 | r18278 | |
| 345 | 273 | WRITE16_MEMBER(ibm8514_foremix_w); |
| 346 | 274 | READ16_MEMBER(ibm8514_pixel_xfer_r); |
| 347 | 275 | WRITE16_MEMBER(ibm8514_pixel_xfer_w); |
| 348 | | |
| 349 | | // extra registers for the Mach8 |
| 350 | | READ16_MEMBER(mach8_ec0_r); |
| 351 | | WRITE16_MEMBER(mach8_ec0_w); |
| 352 | | READ16_MEMBER(mach8_ec1_r); |
| 353 | | WRITE16_MEMBER(mach8_ec1_w); |
| 354 | | READ16_MEMBER(mach8_ec2_r); |
| 355 | | WRITE16_MEMBER(mach8_ec2_w); |
| 356 | | READ16_MEMBER(mach8_ec3_r); |
| 357 | | WRITE16_MEMBER(mach8_ec3_w); |
| 358 | | READ16_MEMBER(mach8_ext_fifo_r); |
| 359 | | WRITE16_MEMBER(mach8_linedraw_index_w); |
| 360 | | READ16_MEMBER(mach8_bresenham_count_r); |
| 361 | | WRITE16_MEMBER(mach8_bresenham_count_w); |
| 362 | | WRITE16_MEMBER(mach8_linedraw_w); |
| 363 | | READ16_MEMBER(mach8_scratch0_r); |
| 364 | | WRITE16_MEMBER(mach8_scratch0_w); |
| 365 | | READ16_MEMBER(mach8_scratch1_r); |
| 366 | | WRITE16_MEMBER(mach8_scratch1_w); |
| 367 | | READ16_MEMBER(mach8_config1_r); |
| 368 | | READ16_MEMBER(mach8_config2_r); |
| 369 | | protected: |
| 370 | | virtual machine_config_constructor device_mconfig_additions() const; |
| 371 | 276 | void ibm8514_wait_draw(); |
| 372 | 277 | struct |
| 373 | 278 | { |
| r18277 | r18278 | |
| 418 | 323 | UINT8 wait_vector_count; |
| 419 | 324 | |
| 420 | 325 | } ibm8514; |
| 326 | protected: |
| 327 | virtual void device_start(); |
| 328 | virtual void device_config_complete(); |
| 421 | 329 | private: |
| 422 | | void ati_define_video_mode(); |
| 423 | 330 | void ibm8514_draw_vector(UINT8 len, UINT8 dir, bool draw); |
| 424 | 331 | void ibm8514_wait_draw_ssv(); |
| 425 | 332 | void ibm8514_draw_ssv(UINT8 data); |
| 426 | 333 | void ibm8514_wait_draw_vector(); |
| 334 | void ibm8514_write_fg(UINT32 offset); |
| 335 | void ibm8514_write_bg(UINT32 offset); |
| 336 | void ibm8514_write(UINT32 offset, UINT32 src); |
| 337 | |
| 338 | vga_device* m_vga; // for pass-through |
| 339 | astring m_vga_tag; // pass-through device tag |
| 340 | UINT8* m_vram; // the original 8514/A has it's own VRAM, but most VGA+8514 combination cards will have |
| 341 | // only one set of VRAM, so this will only be needed in standalone 8514/A cards |
| 342 | UINT32 m_vramsize; |
| 343 | }; |
| 344 | |
| 345 | // device type definition |
| 346 | extern const device_type IBM8514A; |
| 347 | |
| 348 | #define MCFG_8514A_ADD(_tag, _param) \ |
| 349 | MCFG_DEVICE_ADD(_tag, IBM8514A, 0) \ |
| 350 | downcast<ibm8514a_device*>(device)->set_vga(_param); |
| 351 | |
| 352 | #define MCFG_8514A_ADD_OWNER(_tag) \ |
| 353 | MCFG_DEVICE_ADD(_tag, IBM8514A, 0) \ |
| 354 | downcast<ibm8514a_device*>(device)->set_vga_owner(); |
| 355 | |
| 356 | |
| 357 | class mach8_device : public ibm8514a_device |
| 358 | { |
| 359 | public: |
| 360 | mach8_device(const machine_config &mconfig, device_type type, const char *name, const char *tag, device_t *owner, UINT32 clock); |
| 361 | mach8_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock); |
| 362 | |
| 363 | READ16_MEMBER(mach8_ec0_r); |
| 364 | WRITE16_MEMBER(mach8_ec0_w); |
| 365 | READ16_MEMBER(mach8_ec1_r); |
| 366 | WRITE16_MEMBER(mach8_ec1_w); |
| 367 | READ16_MEMBER(mach8_ec2_r); |
| 368 | WRITE16_MEMBER(mach8_ec2_w); |
| 369 | READ16_MEMBER(mach8_ec3_r); |
| 370 | WRITE16_MEMBER(mach8_ec3_w); |
| 371 | READ16_MEMBER(mach8_ext_fifo_r); |
| 372 | WRITE16_MEMBER(mach8_linedraw_index_w); |
| 373 | READ16_MEMBER(mach8_bresenham_count_r); |
| 374 | WRITE16_MEMBER(mach8_bresenham_count_w); |
| 375 | WRITE16_MEMBER(mach8_linedraw_w); |
| 376 | READ16_MEMBER(mach8_linedraw_r); |
| 377 | READ16_MEMBER(mach8_scratch0_r); |
| 378 | WRITE16_MEMBER(mach8_scratch0_w); |
| 379 | READ16_MEMBER(mach8_scratch1_r); |
| 380 | WRITE16_MEMBER(mach8_scratch1_w); |
| 381 | READ16_MEMBER(mach8_config1_r); |
| 382 | READ16_MEMBER(mach8_config2_r); |
| 383 | protected: |
| 384 | virtual void device_start(); |
| 427 | 385 | struct |
| 428 | 386 | { |
| 429 | | UINT8 ext_reg[64]; |
| 430 | | UINT8 ext_reg_select; |
| 431 | 387 | UINT16 scratch0; |
| 432 | 388 | UINT16 scratch1; |
| 433 | 389 | UINT16 linedraw; |
| 390 | } mach8; |
| 391 | }; |
| 392 | |
| 393 | // device type definition |
| 394 | extern const device_type MACH8; |
| 395 | |
| 396 | #define MCFG_MACH8_ADD(_tag, _param) \ |
| 397 | MCFG_DEVICE_ADD(_tag, MACH8, 0) \ |
| 398 | downcast<mach8_device*>(device)->set_vga(_param); |
| 399 | |
| 400 | #define MCFG_MACH8_ADD_OWNER(_tag) \ |
| 401 | MCFG_DEVICE_ADD(_tag, MACH8, 0) \ |
| 402 | downcast<mach8_device*>(device)->set_vga_owner(); |
| 403 | |
| 404 | // ======================> tseng_vga_device |
| 405 | |
| 406 | class tseng_vga_device : public svga_device |
| 407 | { |
| 408 | public: |
| 409 | // construction/destruction |
| 410 | tseng_vga_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock); |
| 411 | |
| 412 | virtual READ8_MEMBER(port_03b0_r); |
| 413 | virtual WRITE8_MEMBER(port_03b0_w); |
| 414 | virtual READ8_MEMBER(port_03c0_r); |
| 415 | virtual WRITE8_MEMBER(port_03c0_w); |
| 416 | virtual READ8_MEMBER(port_03d0_r); |
| 417 | virtual WRITE8_MEMBER(port_03d0_w); |
| 418 | virtual READ8_MEMBER(mem_r); |
| 419 | virtual WRITE8_MEMBER(mem_w); |
| 420 | |
| 421 | protected: |
| 422 | virtual void device_start(); |
| 423 | |
| 424 | private: |
| 425 | void tseng_define_video_mode(); |
| 426 | UINT8 tseng_crtc_reg_read(UINT8 index); |
| 427 | void tseng_crtc_reg_write(UINT8 index, UINT8 data); |
| 428 | UINT8 tseng_seq_reg_read(UINT8 index); |
| 429 | void tseng_seq_reg_write(UINT8 index, UINT8 data); |
| 430 | |
| 431 | struct |
| 432 | { |
| 433 | UINT8 reg_3d8; |
| 434 | UINT8 dac_ctrl; |
| 435 | UINT8 dac_state; |
| 436 | UINT8 horz_overflow; |
| 437 | UINT8 aux_ctrl; |
| 438 | bool ext_reg_ena; |
| 439 | }et4k; |
| 440 | |
| 441 | }; |
| 442 | |
| 443 | |
| 444 | // device type definition |
| 445 | extern const device_type TSENG_VGA; |
| 446 | |
| 447 | // ======================> trident_vga_device |
| 448 | |
| 449 | class trident_vga_device : public svga_device |
| 450 | { |
| 451 | public: |
| 452 | // construction/destruction |
| 453 | trident_vga_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock); |
| 454 | |
| 455 | virtual READ8_MEMBER(port_03c0_r); |
| 456 | virtual WRITE8_MEMBER(port_03c0_w); |
| 457 | virtual READ8_MEMBER(port_03d0_r); |
| 458 | virtual WRITE8_MEMBER(port_03d0_w); |
| 459 | virtual READ8_MEMBER(mem_r); |
| 460 | virtual WRITE8_MEMBER(mem_w); |
| 461 | |
| 462 | protected: |
| 463 | |
| 464 | private: |
| 465 | UINT8 trident_seq_reg_read(UINT8 index); |
| 466 | void trident_seq_reg_write(UINT8 index, UINT8 data); |
| 467 | |
| 468 | }; |
| 469 | |
| 470 | |
| 471 | // device type definition |
| 472 | extern const device_type TRIDENT_VGA; |
| 473 | |
| 474 | |
| 475 | // ======================> ati_vga_device |
| 476 | |
| 477 | class ati_vga_device : public svga_device |
| 478 | { |
| 479 | public: |
| 480 | // construction/destruction |
| 481 | ati_vga_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock); |
| 482 | ati_vga_device(const machine_config &mconfig, device_type type, const char *name, const char *tag, device_t *owner, UINT32 clock); |
| 483 | |
| 484 | virtual READ8_MEMBER(mem_r); |
| 485 | virtual WRITE8_MEMBER(mem_w); |
| 486 | |
| 487 | // VGA registers |
| 488 | virtual READ8_MEMBER(port_03c0_r); |
| 489 | READ8_MEMBER(ati_port_ext_r); |
| 490 | WRITE8_MEMBER(ati_port_ext_w); |
| 491 | |
| 492 | virtual machine_config_constructor device_mconfig_additions() const; |
| 493 | |
| 494 | mach8_device* get_8514() { return m_8514; } |
| 495 | protected: |
| 496 | virtual void device_start(); |
| 497 | private: |
| 498 | void ati_define_video_mode(); |
| 499 | struct |
| 500 | { |
| 501 | UINT8 ext_reg[64]; |
| 502 | UINT8 ext_reg_select; |
| 434 | 503 | } ati; |
| 435 | | void ibm8514_write_fg(UINT32 offset); |
| 436 | | void ibm8514_write_bg(UINT32 offset); |
| 437 | | void ibm8514_write(UINT32 offset, UINT32 src); |
| 504 | mach8_device* m_8514; |
| 438 | 505 | }; |
| 439 | 506 | |
| 440 | 507 | // device type definition |
| r18277 | r18278 | |
| 457 | 524 | virtual WRITE8_MEMBER(port_03d0_w); |
| 458 | 525 | virtual READ8_MEMBER(mem_r); |
| 459 | 526 | virtual WRITE8_MEMBER(mem_w); |
| 460 | | |
| 527 | |
| 461 | 528 | virtual UINT32 screen_update(screen_device &screen, bitmap_rgb32 &bitmap, const rectangle &cliprect); |
| 462 | | |
| 463 | | READ16_MEMBER(s3_gpstatus_r); |
| 464 | | WRITE16_MEMBER(s3_cmd_w); |
| 465 | | |
| 529 | |
| 530 | virtual machine_config_constructor device_mconfig_additions() const; |
| 531 | |
| 532 | ibm8514a_device* get_8514() { return m_8514; } |
| 466 | 533 | protected: |
| 467 | 534 | // device-level overrides |
| 468 | 535 | virtual void device_start(); |
| r18277 | r18278 | |
| 492 | 559 | UINT8 cursor_fg_ptr; |
| 493 | 560 | UINT8 cursor_bg_ptr; |
| 494 | 561 | UINT8 extended_dac_ctrl; |
| 495 | | } s3; |
| 562 | } s3; |
| 496 | 563 | private: |
| 497 | 564 | UINT8 s3_crtc_reg_read(UINT8 index); |
| 498 | 565 | void s3_define_video_mode(void); |
| 499 | 566 | void s3_crtc_reg_write(UINT8 index, UINT8 data); |
| 567 | ibm8514a_device* m_8514; |
| 500 | 568 | }; |
| 501 | 569 | |
| 502 | | |
| 503 | 570 | // device type definition |
| 504 | 571 | extern const device_type S3_VGA; |
| 505 | 572 | |
| r18277 | r18278 | |
| 591 | 658 | ROM_LOAD("oakvga.bin", 0xc0000, 0x8000, CRC(318c5f43)) |
| 592 | 659 | */ |
| 593 | 660 | |
| 661 | |
| 594 | 662 | #endif /* PC_VGA_H */ |
| 595 | 663 | |
trunk/src/mess/video/isa_vga_ati.c
| r18277 | r18278 | |
| 77 | 77 | set_isa_device(); |
| 78 | 78 | |
| 79 | 79 | m_vga = subdevice<ati_vga_device>("vga"); |
| 80 | m_8514 = subdevice<mach8_device>("vga:8514a"); |
| 80 | 81 | |
| 81 | 82 | m_isa->install_rom(this, 0xc0000, 0xc7fff, 0, 0, "vga", "gfxultra"); |
| 82 | 83 | |
| 83 | 84 | m_isa->install_device(0x1ce, 0x1cf, 0, 0, read8_delegate(FUNC(ati_vga_device::ati_port_ext_r),m_vga), write8_delegate(FUNC(ati_vga_device::ati_port_ext_w),m_vga)); |
| 84 | | m_isa->install16_device(0x2e8, 0x2eb, 0, 0, read16_delegate(FUNC(ati_vga_device::ibm8514_status_r),m_vga), write16_delegate(FUNC(ati_vga_device::ibm8514_htotal_w),m_vga)); |
| 85 | m_isa->install16_device(0x2e8, 0x2eb, 0, 0, read16_delegate(FUNC(mach8_device::ibm8514_status_r),m_8514), write16_delegate(FUNC(mach8_device::ibm8514_htotal_w),m_8514)); |
| 85 | 86 | m_isa->install_device(0x3b0, 0x3bf, 0, 0, read8_delegate(FUNC(ati_vga_device::port_03b0_r),m_vga), write8_delegate(FUNC(vga_device::port_03b0_w),m_vga)); |
| 86 | 87 | m_isa->install_device(0x3c0, 0x3cf, 0, 0, read8_delegate(FUNC(ati_vga_device::port_03c0_r),m_vga), write8_delegate(FUNC(vga_device::port_03c0_w),m_vga)); |
| 87 | 88 | m_isa->install_device(0x3d0, 0x3df, 0, 0, read8_delegate(FUNC(ati_vga_device::port_03d0_r),m_vga), write8_delegate(FUNC(vga_device::port_03d0_w),m_vga)); |
| 88 | | m_isa->install16_device(0x12e8, 0x12eb, 0, 0, read16_delegate(FUNC(ati_vga_device::ibm8514_vtotal_r),m_vga), write16_delegate(FUNC(ati_vga_device::ibm8514_vtotal_w),m_vga)); |
| 89 | | m_isa->install16_device(0x12ec, 0x12ef, 0, 0, read16_delegate(FUNC(ati_vga_device::mach8_config1_r),m_vga), write16_delegate()); |
| 90 | | m_isa->install16_device(0x16e8, 0x16eb, 0, 0, read16_delegate(FUNC(ati_vga_device::ibm8514_vdisp_r),m_vga), write16_delegate(FUNC(ati_vga_device::ibm8514_vdisp_w),m_vga)); |
| 91 | | m_isa->install16_device(0x16ec, 0x16ef, 0, 0, read16_delegate(FUNC(ati_vga_device::mach8_config2_r),m_vga), write16_delegate()); |
| 92 | | m_isa->install16_device(0x1ae8, 0x1aeb, 0, 0, read16_delegate(FUNC(ati_vga_device::ibm8514_vsync_r),m_vga), write16_delegate(FUNC(ati_vga_device::ibm8514_vsync_w),m_vga)); |
| 93 | | m_isa->install16_device(0x26e8, 0x26eb, 0, 0, read16_delegate(FUNC(ati_vga_device::ibm8514_htotal_r),m_vga),write16_delegate()); |
| 94 | | m_isa->install16_device(0x2ee8, 0x2eeb, 0, 0, read16_delegate(FUNC(ati_vga_device::ibm8514_subcontrol_r),m_vga),write16_delegate()); |
| 95 | | m_isa->install16_device(0x42e8, 0x42eb, 0, 0, read16_delegate(FUNC(ati_vga_device::ibm8514_substatus_r),m_vga), write16_delegate(FUNC(ati_vga_device::ibm8514_subcontrol_w),m_vga)); |
| 96 | | m_isa->install16_device(0x52e8, 0x52eb, 0, 0, read16_delegate(FUNC(ati_vga_device::mach8_ec0_r),m_vga), write16_delegate(FUNC(ati_vga_device::mach8_ec0_w),m_vga)); |
| 97 | | m_isa->install16_device(0x52ec, 0x52ef, 0, 0, read16_delegate(FUNC(ati_vga_device::mach8_scratch0_r),m_vga), write16_delegate(FUNC(ati_vga_device::mach8_scratch0_w),m_vga)); |
| 98 | | m_isa->install16_device(0x56e8, 0x56eb, 0, 0, read16_delegate(FUNC(ati_vga_device::mach8_ec1_r),m_vga), write16_delegate(FUNC(ati_vga_device::mach8_ec1_w),m_vga)); |
| 99 | | m_isa->install16_device(0x56ec, 0x56ef, 0, 0, read16_delegate(FUNC(ati_vga_device::mach8_scratch0_r),m_vga), write16_delegate(FUNC(ati_vga_device::mach8_scratch0_w),m_vga)); |
| 100 | | m_isa->install16_device(0x5ae8, 0x5aeb, 0, 0, read16_delegate(FUNC(ati_vga_device::mach8_ec2_r),m_vga), write16_delegate(FUNC(ati_vga_device::mach8_ec2_w),m_vga)); |
| 101 | | m_isa->install16_device(0x5ee8, 0x5eeb, 0, 0, read16_delegate(FUNC(ati_vga_device::mach8_ec3_r),m_vga), write16_delegate(FUNC(ati_vga_device::mach8_ec3_w),m_vga)); |
| 102 | | m_isa->install16_device(0x82e8, 0x82eb, 0, 0, read16_delegate(FUNC(ati_vga_device::ibm8514_currenty_r),m_vga), write16_delegate(FUNC(ati_vga_device::ibm8514_currenty_w),m_vga)); |
| 103 | | m_isa->install16_device(0x86e8, 0x86eb, 0, 0, read16_delegate(FUNC(ati_vga_device::ibm8514_currentx_r),m_vga), write16_delegate(FUNC(ati_vga_device::ibm8514_currentx_w),m_vga)); |
| 104 | | m_isa->install16_device(0x8ae8, 0x8aeb, 0, 0, read16_delegate(FUNC(ati_vga_device::ibm8514_desty_r),m_vga), write16_delegate(FUNC(ati_vga_device::ibm8514_desty_w),m_vga)); |
| 105 | | m_isa->install16_device(0x8ee8, 0x8eeb, 0, 0, read16_delegate(FUNC(ati_vga_device::ibm8514_destx_r),m_vga), write16_delegate(FUNC(ati_vga_device::ibm8514_destx_w),m_vga)); |
| 106 | | m_isa->install16_device(0x92e8, 0x92eb, 0, 0, read16_delegate(FUNC(ati_vga_device::ibm8514_line_error_r),m_vga), write16_delegate(FUNC(ati_vga_device::ibm8514_line_error_w),m_vga)); |
| 107 | | m_isa->install16_device(0x96e8, 0x96eb, 0, 0, read16_delegate(FUNC(ati_vga_device::ibm8514_width_r),m_vga), write16_delegate(FUNC(ati_vga_device::ibm8514_width_w),m_vga)); |
| 108 | | m_isa->install16_device(0x96ec, 0x96ef, 0, 0, read16_delegate(FUNC(ati_vga_device::mach8_bresenham_count_r),m_vga), write16_delegate(FUNC(ati_vga_device::mach8_bresenham_count_w),m_vga)); |
| 109 | | m_isa->install16_device(0x9ae8, 0x9aeb, 0, 0, read16_delegate(FUNC(ati_vga_device::ibm8514_gpstatus_r),m_vga), write16_delegate(FUNC(ati_vga_device::ibm8514_cmd_w),m_vga)); |
| 110 | | m_isa->install16_device(0x9aec, 0x9aef, 0, 0, read16_delegate(FUNC(ati_vga_device::mach8_ext_fifo_r),m_vga), write16_delegate(FUNC(ati_vga_device::mach8_linedraw_index_w),m_vga)); |
| 111 | | m_isa->install16_device(0x9ee8, 0x9eeb, 0, 0, read16_delegate(FUNC(ati_vga_device::ibm8514_ssv_r),m_vga), write16_delegate(FUNC(ati_vga_device::ibm8514_ssv_w),m_vga)); |
| 112 | | m_isa->install16_device(0xa2e8, 0xa2eb, 0, 0, read16_delegate(FUNC(ati_vga_device::ibm8514_bgcolour_r),m_vga), write16_delegate(FUNC(ati_vga_device::ibm8514_bgcolour_w),m_vga)); |
| 113 | | m_isa->install16_device(0xa6e8, 0xa6eb, 0, 0, read16_delegate(FUNC(ati_vga_device::ibm8514_fgcolour_r),m_vga), write16_delegate(FUNC(ati_vga_device::ibm8514_fgcolour_w),m_vga)); |
| 114 | | m_isa->install16_device(0xb6e8, 0xb6eb, 0, 0, read16_delegate(FUNC(ati_vga_device::ibm8514_backmix_r),m_vga), write16_delegate(FUNC(ati_vga_device::ibm8514_backmix_w),m_vga)); |
| 115 | | m_isa->install16_device(0xbae8, 0xbaeb, 0, 0, read16_delegate(FUNC(ati_vga_device::ibm8514_foremix_r),m_vga), write16_delegate(FUNC(ati_vga_device::ibm8514_foremix_w),m_vga)); |
| 116 | | m_isa->install16_device(0xbee8, 0xbeeb, 0, 0, read16_delegate(FUNC(ati_vga_device::ibm8514_multifunc_r),m_vga), write16_delegate(FUNC(ati_vga_device::ibm8514_multifunc_w),m_vga)); |
| 117 | | m_isa->install16_device(0xe2e8, 0xe2eb, 0, 0, read16_delegate(FUNC(ati_vga_device::ibm8514_pixel_xfer_r),m_vga), write16_delegate(FUNC(ati_vga_device::ibm8514_pixel_xfer_w),m_vga)); |
| 118 | | m_isa->install16_device(0xfeec, 0xfeef, 0, 0, read16_delegate(), write16_delegate(FUNC(ati_vga_device::mach8_linedraw_w),m_vga)); |
| 89 | m_isa->install16_device(0x12e8, 0x12eb, 0, 0, read16_delegate(FUNC(mach8_device::ibm8514_vtotal_r),m_8514), write16_delegate(FUNC(mach8_device::ibm8514_vtotal_w),m_8514)); |
| 90 | m_isa->install16_device(0x12ec, 0x12ef, 0, 0, read16_delegate(FUNC(mach8_device::mach8_config1_r),m_8514), write16_delegate()); |
| 91 | m_isa->install16_device(0x16e8, 0x16eb, 0, 0, read16_delegate(FUNC(mach8_device::ibm8514_vdisp_r),m_8514), write16_delegate(FUNC(mach8_device::ibm8514_vdisp_w),m_8514)); |
| 92 | m_isa->install16_device(0x16ec, 0x16ef, 0, 0, read16_delegate(FUNC(mach8_device::mach8_config2_r),m_8514), write16_delegate()); |
| 93 | m_isa->install16_device(0x1ae8, 0x1aeb, 0, 0, read16_delegate(FUNC(mach8_device::ibm8514_vsync_r),m_8514), write16_delegate(FUNC(mach8_device::ibm8514_vsync_w),m_8514)); |
| 94 | m_isa->install16_device(0x26e8, 0x26eb, 0, 0, read16_delegate(FUNC(mach8_device::ibm8514_htotal_r),m_8514),write16_delegate()); |
| 95 | m_isa->install16_device(0x2ee8, 0x2eeb, 0, 0, read16_delegate(FUNC(mach8_device::ibm8514_subcontrol_r),m_8514),write16_delegate()); |
| 96 | m_isa->install16_device(0x42e8, 0x42eb, 0, 0, read16_delegate(FUNC(mach8_device::ibm8514_substatus_r),m_8514), write16_delegate(FUNC(mach8_device::ibm8514_subcontrol_w),m_8514)); |
| 97 | m_isa->install16_device(0x52e8, 0x52eb, 0, 0, read16_delegate(FUNC(mach8_device::mach8_ec0_r),m_8514), write16_delegate(FUNC(mach8_device::mach8_ec0_w),m_8514)); |
| 98 | m_isa->install16_device(0x52ec, 0x52ef, 0, 0, read16_delegate(FUNC(mach8_device::mach8_scratch0_r),m_8514), write16_delegate(FUNC(mach8_device::mach8_scratch0_w),m_8514)); |
| 99 | m_isa->install16_device(0x56e8, 0x56eb, 0, 0, read16_delegate(FUNC(mach8_device::mach8_ec1_r),m_8514), write16_delegate(FUNC(mach8_device::mach8_ec1_w),m_8514)); |
| 100 | m_isa->install16_device(0x56ec, 0x56ef, 0, 0, read16_delegate(FUNC(mach8_device::mach8_scratch0_r),m_8514), write16_delegate(FUNC(mach8_device::mach8_scratch0_w),m_8514)); |
| 101 | m_isa->install16_device(0x5ae8, 0x5aeb, 0, 0, read16_delegate(FUNC(mach8_device::mach8_ec2_r),m_8514), write16_delegate(FUNC(mach8_device::mach8_ec2_w),m_8514)); |
| 102 | m_isa->install16_device(0x5ee8, 0x5eeb, 0, 0, read16_delegate(FUNC(mach8_device::mach8_ec3_r),m_8514), write16_delegate(FUNC(mach8_device::mach8_ec3_w),m_8514)); |
| 103 | m_isa->install16_device(0x82e8, 0x82eb, 0, 0, read16_delegate(FUNC(mach8_device::ibm8514_currenty_r),m_8514), write16_delegate(FUNC(mach8_device::ibm8514_currenty_w),m_8514)); |
| 104 | m_isa->install16_device(0x86e8, 0x86eb, 0, 0, read16_delegate(FUNC(mach8_device::ibm8514_currentx_r),m_8514), write16_delegate(FUNC(mach8_device::ibm8514_currentx_w),m_8514)); |
| 105 | m_isa->install16_device(0x8ae8, 0x8aeb, 0, 0, read16_delegate(FUNC(mach8_device::ibm8514_desty_r),m_8514), write16_delegate(FUNC(mach8_device::ibm8514_desty_w),m_8514)); |
| 106 | m_isa->install16_device(0x8ee8, 0x8eeb, 0, 0, read16_delegate(FUNC(mach8_device::ibm8514_destx_r),m_8514), write16_delegate(FUNC(mach8_device::ibm8514_destx_w),m_8514)); |
| 107 | m_isa->install16_device(0x92e8, 0x92eb, 0, 0, read16_delegate(FUNC(mach8_device::ibm8514_line_error_r),m_8514), write16_delegate(FUNC(mach8_device::ibm8514_line_error_w),m_8514)); |
| 108 | m_isa->install16_device(0x96e8, 0x96eb, 0, 0, read16_delegate(FUNC(mach8_device::ibm8514_width_r),m_8514), write16_delegate(FUNC(mach8_device::ibm8514_width_w),m_8514)); |
| 109 | m_isa->install16_device(0x96ec, 0x96ef, 0, 0, read16_delegate(FUNC(mach8_device::mach8_bresenham_count_r),m_8514), write16_delegate(FUNC(mach8_device::mach8_bresenham_count_w),m_8514)); |
| 110 | m_isa->install16_device(0x9ae8, 0x9aeb, 0, 0, read16_delegate(FUNC(mach8_device::ibm8514_gpstatus_r),m_8514), write16_delegate(FUNC(mach8_device::ibm8514_cmd_w),m_8514)); |
| 111 | m_isa->install16_device(0x9aec, 0x9aef, 0, 0, read16_delegate(FUNC(mach8_device::mach8_ext_fifo_r),m_8514), write16_delegate(FUNC(mach8_device::mach8_linedraw_index_w),m_8514)); |
| 112 | m_isa->install16_device(0x9ee8, 0x9eeb, 0, 0, read16_delegate(FUNC(mach8_device::ibm8514_ssv_r),m_8514), write16_delegate(FUNC(mach8_device::ibm8514_ssv_w),m_8514)); |
| 113 | m_isa->install16_device(0xa2e8, 0xa2eb, 0, 0, read16_delegate(FUNC(mach8_device::ibm8514_bgcolour_r),m_8514), write16_delegate(FUNC(mach8_device::ibm8514_bgcolour_w),m_8514)); |
| 114 | m_isa->install16_device(0xa6e8, 0xa6eb, 0, 0, read16_delegate(FUNC(mach8_device::ibm8514_fgcolour_r),m_8514), write16_delegate(FUNC(mach8_device::ibm8514_fgcolour_w),m_8514)); |
| 115 | m_isa->install16_device(0xb6e8, 0xb6eb, 0, 0, read16_delegate(FUNC(mach8_device::ibm8514_backmix_r),m_8514), write16_delegate(FUNC(mach8_device::ibm8514_backmix_w),m_8514)); |
| 116 | m_isa->install16_device(0xbae8, 0xbaeb, 0, 0, read16_delegate(FUNC(mach8_device::ibm8514_foremix_r),m_8514), write16_delegate(FUNC(mach8_device::ibm8514_foremix_w),m_8514)); |
| 117 | m_isa->install16_device(0xbee8, 0xbeeb, 0, 0, read16_delegate(FUNC(mach8_device::ibm8514_multifunc_r),m_8514), write16_delegate(FUNC(mach8_device::ibm8514_multifunc_w),m_8514)); |
| 118 | m_isa->install16_device(0xe2e8, 0xe2eb, 0, 0, read16_delegate(FUNC(mach8_device::ibm8514_pixel_xfer_r),m_8514), write16_delegate(FUNC(mach8_device::ibm8514_pixel_xfer_w),m_8514)); |
| 119 | m_isa->install16_device(0xfeec, 0xfeef, 0, 0, read16_delegate(FUNC(mach8_device::mach8_linedraw_r),m_8514), write16_delegate(FUNC(mach8_device::mach8_linedraw_w),m_8514)); |
| 119 | 120 | |
| 120 | 121 | m_isa->install_memory(0xa0000, 0xbffff, 0, 0, read8_delegate(FUNC(ati_vga_device::mem_r),m_vga), write8_delegate(FUNC(ati_vga_device::mem_w),m_vga)); |
| 121 | 122 | } |