nkeynes@31 | 1 | /**
|
nkeynes@265 | 2 | * $Id: pvr2.c,v 1.35 2007-01-06 04:06:36 nkeynes Exp $
|
nkeynes@31 | 3 | *
|
nkeynes@133 | 4 | * PVR2 (Video) Core module implementation and MMIO registers.
|
nkeynes@31 | 5 | *
|
nkeynes@31 | 6 | * Copyright (c) 2005 Nathan Keynes.
|
nkeynes@31 | 7 | *
|
nkeynes@31 | 8 | * This program is free software; you can redistribute it and/or modify
|
nkeynes@31 | 9 | * it under the terms of the GNU General Public License as published by
|
nkeynes@31 | 10 | * the Free Software Foundation; either version 2 of the License, or
|
nkeynes@31 | 11 | * (at your option) any later version.
|
nkeynes@31 | 12 | *
|
nkeynes@31 | 13 | * This program is distributed in the hope that it will be useful,
|
nkeynes@31 | 14 | * but WITHOUT ANY WARRANTY; without even the implied warranty of
|
nkeynes@31 | 15 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
nkeynes@31 | 16 | * GNU General Public License for more details.
|
nkeynes@31 | 17 | */
|
nkeynes@35 | 18 | #define MODULE pvr2_module
|
nkeynes@31 | 19 |
|
nkeynes@1 | 20 | #include "dream.h"
|
nkeynes@265 | 21 | #include "eventq.h"
|
nkeynes@144 | 22 | #include "display.h"
|
nkeynes@1 | 23 | #include "mem.h"
|
nkeynes@1 | 24 | #include "asic.h"
|
nkeynes@261 | 25 | #include "clock.h"
|
nkeynes@103 | 26 | #include "pvr2/pvr2.h"
|
nkeynes@56 | 27 | #include "sh4/sh4core.h"
|
nkeynes@1 | 28 | #define MMIO_IMPL
|
nkeynes@103 | 29 | #include "pvr2/pvr2mmio.h"
|
nkeynes@1 | 30 |
|
nkeynes@1 | 31 | char *video_base;
|
nkeynes@1 | 32 |
|
nkeynes@133 | 33 | static void pvr2_init( void );
|
nkeynes@133 | 34 | static void pvr2_reset( void );
|
nkeynes@133 | 35 | static uint32_t pvr2_run_slice( uint32_t );
|
nkeynes@133 | 36 | static void pvr2_save_state( FILE *f );
|
nkeynes@133 | 37 | static int pvr2_load_state( FILE *f );
|
nkeynes@265 | 38 | static void pvr2_update_raster_posn( uint32_t nanosecs );
|
nkeynes@265 | 39 | static void pvr2_schedule_line_event( int eventid, int line );
|
nkeynes@265 | 40 | static void pvr2_schedule_scanline_event( int eventid, int line );
|
nkeynes@265 | 41 | uint32_t pvr2_get_sync_status();
|
nkeynes@133 | 42 |
|
nkeynes@94 | 43 | void pvr2_display_frame( void );
|
nkeynes@94 | 44 |
|
nkeynes@161 | 45 | int colour_format_bytes[] = { 2, 2, 2, 1, 3, 4, 1, 1 };
|
nkeynes@161 | 46 |
|
nkeynes@133 | 47 | struct dreamcast_module pvr2_module = { "PVR2", pvr2_init, pvr2_reset, NULL,
|
nkeynes@133 | 48 | pvr2_run_slice, NULL,
|
nkeynes@133 | 49 | pvr2_save_state, pvr2_load_state };
|
nkeynes@133 | 50 |
|
nkeynes@103 | 51 |
|
nkeynes@144 | 52 | display_driver_t display_driver = NULL;
|
nkeynes@15 | 53 |
|
nkeynes@103 | 54 | struct video_timing {
|
nkeynes@103 | 55 | int fields_per_second;
|
nkeynes@103 | 56 | int total_lines;
|
nkeynes@108 | 57 | int retrace_lines;
|
nkeynes@103 | 58 | int line_time_ns;
|
nkeynes@103 | 59 | };
|
nkeynes@103 | 60 |
|
nkeynes@261 | 61 | struct video_timing pal_timing = { 50, 625, 65, 31945 };
|
nkeynes@108 | 62 | struct video_timing ntsc_timing= { 60, 525, 65, 31746 };
|
nkeynes@103 | 63 |
|
nkeynes@133 | 64 | struct pvr2_state {
|
nkeynes@133 | 65 | uint32_t frame_count;
|
nkeynes@133 | 66 | uint32_t line_count;
|
nkeynes@133 | 67 | uint32_t line_remainder;
|
nkeynes@265 | 68 | uint32_t cycles_run; /* Cycles already executed prior to main time slice */
|
nkeynes@133 | 69 | uint32_t irq_vpos1;
|
nkeynes@133 | 70 | uint32_t irq_vpos2;
|
nkeynes@261 | 71 | uint32_t odd_even_field; /* 1 = odd, 0 = even */
|
nkeynes@261 | 72 |
|
nkeynes@261 | 73 | /* timing */
|
nkeynes@261 | 74 | uint32_t dot_clock;
|
nkeynes@261 | 75 | uint32_t total_lines;
|
nkeynes@261 | 76 | uint32_t line_size;
|
nkeynes@261 | 77 | uint32_t line_time_ns;
|
nkeynes@261 | 78 | uint32_t vsync_lines;
|
nkeynes@261 | 79 | uint32_t hsync_width_ns;
|
nkeynes@261 | 80 | uint32_t front_porch_ns;
|
nkeynes@261 | 81 | uint32_t back_porch_ns;
|
nkeynes@265 | 82 | uint32_t retrace_start_line;
|
nkeynes@265 | 83 | uint32_t retrace_end_line;
|
nkeynes@261 | 84 | gboolean interlaced;
|
nkeynes@133 | 85 | struct video_timing timing;
|
nkeynes@133 | 86 | } pvr2_state;
|
nkeynes@15 | 87 |
|
nkeynes@133 | 88 | struct video_buffer video_buffer[2];
|
nkeynes@133 | 89 | int video_buffer_idx = 0;
|
nkeynes@133 | 90 |
|
nkeynes@265 | 91 | /**
|
nkeynes@265 | 92 | * Event handler for the retrace callback (fires on line 0 normally)
|
nkeynes@265 | 93 | */
|
nkeynes@265 | 94 | static void pvr2_retrace_callback( int eventid ) {
|
nkeynes@265 | 95 | asic_event( eventid );
|
nkeynes@265 | 96 | pvr2_update_raster_posn(sh4r.slice_cycle);
|
nkeynes@265 | 97 | pvr2_schedule_line_event( EVENT_RETRACE, 0 );
|
nkeynes@265 | 98 | }
|
nkeynes@265 | 99 |
|
nkeynes@265 | 100 | /**
|
nkeynes@265 | 101 | * Event handler for the scanline callbacks. Fires the corresponding
|
nkeynes@265 | 102 | * ASIC event, and resets the timer for the next field.
|
nkeynes@265 | 103 | */
|
nkeynes@265 | 104 | static void pvr2_scanline_callback( int eventid ) {
|
nkeynes@265 | 105 | asic_event( eventid );
|
nkeynes@265 | 106 | pvr2_update_raster_posn(sh4r.slice_cycle);
|
nkeynes@265 | 107 | if( eventid == EVENT_SCANLINE1 ) {
|
nkeynes@265 | 108 | pvr2_schedule_scanline_event( eventid, pvr2_state.irq_vpos1 );
|
nkeynes@265 | 109 | } else {
|
nkeynes@265 | 110 | pvr2_schedule_scanline_event( eventid, pvr2_state.irq_vpos2 );
|
nkeynes@265 | 111 | }
|
nkeynes@265 | 112 | }
|
nkeynes@265 | 113 |
|
nkeynes@133 | 114 | static void pvr2_init( void )
|
nkeynes@1 | 115 | {
|
nkeynes@1 | 116 | register_io_region( &mmio_region_PVR2 );
|
nkeynes@85 | 117 | register_io_region( &mmio_region_PVR2PAL );
|
nkeynes@56 | 118 | register_io_region( &mmio_region_PVR2TA );
|
nkeynes@265 | 119 | register_event_callback( EVENT_RETRACE, pvr2_retrace_callback );
|
nkeynes@265 | 120 | register_event_callback( EVENT_SCANLINE1, pvr2_scanline_callback );
|
nkeynes@265 | 121 | register_event_callback( EVENT_SCANLINE2, pvr2_scanline_callback );
|
nkeynes@1 | 122 | video_base = mem_get_region_by_name( MEM_REGION_VIDEO );
|
nkeynes@133 | 123 | texcache_init();
|
nkeynes@133 | 124 | pvr2_reset();
|
nkeynes@214 | 125 | pvr2_ta_reset();
|
nkeynes@133 | 126 | }
|
nkeynes@133 | 127 |
|
nkeynes@133 | 128 | static void pvr2_reset( void )
|
nkeynes@133 | 129 | {
|
nkeynes@133 | 130 | pvr2_state.line_count = 0;
|
nkeynes@133 | 131 | pvr2_state.line_remainder = 0;
|
nkeynes@265 | 132 | pvr2_state.cycles_run = 0;
|
nkeynes@133 | 133 | pvr2_state.irq_vpos1 = 0;
|
nkeynes@133 | 134 | pvr2_state.irq_vpos2 = 0;
|
nkeynes@133 | 135 | pvr2_state.timing = ntsc_timing;
|
nkeynes@265 | 136 | pvr2_state.dot_clock = PVR2_DOT_CLOCK;
|
nkeynes@265 | 137 | pvr2_state.back_porch_ns = 4000;
|
nkeynes@265 | 138 | mmio_region_PVR2_write( DISP_TOTAL, 0x0270035F );
|
nkeynes@265 | 139 | mmio_region_PVR2_write( DISP_SYNCTIME, 0x07D6A53F );
|
nkeynes@133 | 140 | video_buffer_idx = 0;
|
nkeynes@133 | 141 |
|
nkeynes@133 | 142 | pvr2_ta_init();
|
nkeynes@107 | 143 | pvr2_render_init();
|
nkeynes@133 | 144 | texcache_flush();
|
nkeynes@133 | 145 | }
|
nkeynes@133 | 146 |
|
nkeynes@133 | 147 | static void pvr2_save_state( FILE *f )
|
nkeynes@133 | 148 | {
|
nkeynes@133 | 149 | fwrite( &pvr2_state, sizeof(pvr2_state), 1, f );
|
nkeynes@193 | 150 | pvr2_ta_save_state( f );
|
nkeynes@133 | 151 | }
|
nkeynes@133 | 152 |
|
nkeynes@133 | 153 | static int pvr2_load_state( FILE *f )
|
nkeynes@133 | 154 | {
|
nkeynes@153 | 155 | if( fread( &pvr2_state, sizeof(pvr2_state), 1, f ) != 1 )
|
nkeynes@153 | 156 | return 1;
|
nkeynes@193 | 157 | return pvr2_ta_load_state(f);
|
nkeynes@133 | 158 | }
|
nkeynes@133 | 159 |
|
nkeynes@265 | 160 | /**
|
nkeynes@265 | 161 | * Update the current raster position to the given number of nanoseconds,
|
nkeynes@265 | 162 | * relative to the last time slice. (ie the raster will be adjusted forward
|
nkeynes@265 | 163 | * by nanosecs - nanosecs_already_run_this_timeslice)
|
nkeynes@265 | 164 | */
|
nkeynes@265 | 165 | static void pvr2_update_raster_posn( uint32_t nanosecs )
|
nkeynes@265 | 166 | {
|
nkeynes@265 | 167 | uint32_t old_line_count = pvr2_state.line_count;
|
nkeynes@265 | 168 | if( pvr2_state.line_time_ns == 0 ) {
|
nkeynes@265 | 169 | return; /* do nothing */
|
nkeynes@265 | 170 | }
|
nkeynes@265 | 171 | pvr2_state.line_remainder += (nanosecs - pvr2_state.cycles_run);
|
nkeynes@265 | 172 | pvr2_state.cycles_run = nanosecs;
|
nkeynes@265 | 173 | while( pvr2_state.line_remainder >= pvr2_state.line_time_ns ) {
|
nkeynes@265 | 174 | pvr2_state.line_count ++;
|
nkeynes@265 | 175 | pvr2_state.line_remainder -= pvr2_state.line_time_ns;
|
nkeynes@265 | 176 | }
|
nkeynes@265 | 177 |
|
nkeynes@265 | 178 | if( pvr2_state.line_count >= pvr2_state.total_lines ) {
|
nkeynes@265 | 179 | pvr2_state.line_count -= pvr2_state.total_lines;
|
nkeynes@265 | 180 | if( pvr2_state.interlaced ) {
|
nkeynes@265 | 181 | pvr2_state.odd_even_field = !pvr2_state.odd_even_field;
|
nkeynes@265 | 182 | }
|
nkeynes@265 | 183 | }
|
nkeynes@265 | 184 | if( pvr2_state.line_count >= pvr2_state.retrace_end_line &&
|
nkeynes@265 | 185 | (old_line_count < pvr2_state.retrace_end_line ||
|
nkeynes@265 | 186 | old_line_count > pvr2_state.line_count) ) {
|
nkeynes@265 | 187 | pvr2_display_frame();
|
nkeynes@265 | 188 | }
|
nkeynes@265 | 189 | }
|
nkeynes@265 | 190 |
|
nkeynes@133 | 191 | static uint32_t pvr2_run_slice( uint32_t nanosecs )
|
nkeynes@133 | 192 | {
|
nkeynes@265 | 193 | pvr2_update_raster_posn( nanosecs );
|
nkeynes@265 | 194 | pvr2_state.cycles_run = 0;
|
nkeynes@133 | 195 | return nanosecs;
|
nkeynes@133 | 196 | }
|
nkeynes@133 | 197 |
|
nkeynes@133 | 198 | int pvr2_get_frame_count()
|
nkeynes@133 | 199 | {
|
nkeynes@133 | 200 | return pvr2_state.frame_count;
|
nkeynes@106 | 201 | }
|
nkeynes@106 | 202 |
|
nkeynes@103 | 203 | /**
|
nkeynes@1 | 204 | * Display the next frame, copying the current contents of video ram to
|
nkeynes@1 | 205 | * the window. If the video configuration has changed, first recompute the
|
nkeynes@1 | 206 | * new frame size/depth.
|
nkeynes@1 | 207 | */
|
nkeynes@94 | 208 | void pvr2_display_frame( void )
|
nkeynes@1 | 209 | {
|
nkeynes@197 | 210 | uint32_t display_addr = MMIO_READ( PVR2, DISP_ADDR1 );
|
nkeynes@103 | 211 |
|
nkeynes@197 | 212 | int dispsize = MMIO_READ( PVR2, DISP_SIZE );
|
nkeynes@197 | 213 | int dispmode = MMIO_READ( PVR2, DISP_MODE );
|
nkeynes@261 | 214 | int vidcfg = MMIO_READ( PVR2, DISP_SYNCCFG );
|
nkeynes@94 | 215 | int vid_stride = ((dispsize & DISPSIZE_MODULO) >> 20) - 1;
|
nkeynes@94 | 216 | int vid_lpf = ((dispsize & DISPSIZE_LPF) >> 10) + 1;
|
nkeynes@94 | 217 | int vid_ppl = ((dispsize & DISPSIZE_PPL)) + 1;
|
nkeynes@103 | 218 | gboolean bEnabled = (dispmode & DISPMODE_DE) && (vidcfg & DISPCFG_VO ) ? TRUE : FALSE;
|
nkeynes@103 | 219 | gboolean interlaced = (vidcfg & DISPCFG_I ? TRUE : FALSE);
|
nkeynes@161 | 220 | video_buffer_t buffer = &video_buffer[video_buffer_idx];
|
nkeynes@161 | 221 | video_buffer_idx = !video_buffer_idx;
|
nkeynes@161 | 222 | video_buffer_t last = &video_buffer[video_buffer_idx];
|
nkeynes@161 | 223 | buffer->rowstride = (vid_ppl + vid_stride) << 2;
|
nkeynes@197 | 224 | buffer->data = video_base + MMIO_READ( PVR2, DISP_ADDR1 );
|
nkeynes@161 | 225 | buffer->vres = vid_lpf;
|
nkeynes@161 | 226 | if( interlaced ) buffer->vres <<= 1;
|
nkeynes@161 | 227 | switch( (dispmode & DISPMODE_COL) >> 2 ) {
|
nkeynes@161 | 228 | case 0:
|
nkeynes@161 | 229 | buffer->colour_format = COLFMT_ARGB1555;
|
nkeynes@161 | 230 | buffer->hres = vid_ppl << 1;
|
nkeynes@161 | 231 | break;
|
nkeynes@161 | 232 | case 1:
|
nkeynes@161 | 233 | buffer->colour_format = COLFMT_RGB565;
|
nkeynes@161 | 234 | buffer->hres = vid_ppl << 1;
|
nkeynes@161 | 235 | break;
|
nkeynes@161 | 236 | case 2:
|
nkeynes@161 | 237 | buffer->colour_format = COLFMT_RGB888;
|
nkeynes@161 | 238 | buffer->hres = (vid_ppl << 2) / 3;
|
nkeynes@161 | 239 | break;
|
nkeynes@161 | 240 | case 3:
|
nkeynes@161 | 241 | buffer->colour_format = COLFMT_ARGB8888;
|
nkeynes@161 | 242 | buffer->hres = vid_ppl;
|
nkeynes@161 | 243 | break;
|
nkeynes@161 | 244 | }
|
nkeynes@161 | 245 |
|
nkeynes@161 | 246 | if( buffer->hres <=8 )
|
nkeynes@161 | 247 | buffer->hres = 640;
|
nkeynes@161 | 248 | if( buffer->vres <=8 )
|
nkeynes@161 | 249 | buffer->vres = 480;
|
nkeynes@161 | 250 | if( display_driver != NULL ) {
|
nkeynes@161 | 251 | if( buffer->hres != last->hres ||
|
nkeynes@161 | 252 | buffer->vres != last->vres ||
|
nkeynes@161 | 253 | buffer->colour_format != last->colour_format) {
|
nkeynes@161 | 254 | display_driver->set_display_format( buffer->hres, buffer->vres,
|
nkeynes@161 | 255 | buffer->colour_format );
|
nkeynes@94 | 256 | }
|
nkeynes@161 | 257 | if( !bEnabled ) {
|
nkeynes@161 | 258 | display_driver->display_blank_frame( 0 );
|
nkeynes@197 | 259 | } else if( MMIO_READ( PVR2, DISP_CFG2 ) & 0x08 ) { /* Blanked */
|
nkeynes@197 | 260 | uint32_t colour = MMIO_READ( PVR2, DISP_BORDER );
|
nkeynes@161 | 261 | display_driver->display_blank_frame( colour );
|
nkeynes@161 | 262 | } else if( !pvr2_render_display_frame( PVR2_RAM_BASE + display_addr ) ) {
|
nkeynes@161 | 263 | display_driver->display_frame( buffer );
|
nkeynes@65 | 264 | }
|
nkeynes@1 | 265 | }
|
nkeynes@133 | 266 | pvr2_state.frame_count++;
|
nkeynes@1 | 267 | }
|
nkeynes@1 | 268 |
|
nkeynes@197 | 269 | /**
|
nkeynes@197 | 270 | * This has to handle every single register individually as they all get masked
|
nkeynes@197 | 271 | * off differently (and its easier to do it at write time)
|
nkeynes@197 | 272 | */
|
nkeynes@1 | 273 | void mmio_region_PVR2_write( uint32_t reg, uint32_t val )
|
nkeynes@1 | 274 | {
|
nkeynes@1 | 275 | if( reg >= 0x200 && reg < 0x600 ) { /* Fog table */
|
nkeynes@1 | 276 | MMIO_WRITE( PVR2, reg, val );
|
nkeynes@1 | 277 | return;
|
nkeynes@1 | 278 | }
|
nkeynes@1 | 279 |
|
nkeynes@1 | 280 | switch(reg) {
|
nkeynes@189 | 281 | case PVRID:
|
nkeynes@189 | 282 | case PVRVER:
|
nkeynes@261 | 283 | case GUNPOS: /* Read only registers */
|
nkeynes@189 | 284 | break;
|
nkeynes@197 | 285 | case PVRRESET:
|
nkeynes@197 | 286 | val &= 0x00000007; /* Do stuff? */
|
nkeynes@197 | 287 | MMIO_WRITE( PVR2, reg, val );
|
nkeynes@197 | 288 | break;
|
nkeynes@191 | 289 | case RENDER_START:
|
nkeynes@261 | 290 | if( val == 0xFFFFFFFF || val == 0x00000001 )
|
nkeynes@189 | 291 | pvr2_render_scene();
|
nkeynes@189 | 292 | break;
|
nkeynes@191 | 293 | case RENDER_POLYBASE:
|
nkeynes@191 | 294 | MMIO_WRITE( PVR2, reg, val&0x00F00000 );
|
nkeynes@191 | 295 | break;
|
nkeynes@191 | 296 | case RENDER_TSPCFG:
|
nkeynes@191 | 297 | MMIO_WRITE( PVR2, reg, val&0x00010101 );
|
nkeynes@191 | 298 | break;
|
nkeynes@197 | 299 | case DISP_BORDER:
|
nkeynes@191 | 300 | MMIO_WRITE( PVR2, reg, val&0x01FFFFFF );
|
nkeynes@191 | 301 | break;
|
nkeynes@197 | 302 | case DISP_MODE:
|
nkeynes@191 | 303 | MMIO_WRITE( PVR2, reg, val&0x00FFFF7F );
|
nkeynes@191 | 304 | break;
|
nkeynes@191 | 305 | case RENDER_MODE:
|
nkeynes@191 | 306 | MMIO_WRITE( PVR2, reg, val&0x00FFFF0F );
|
nkeynes@191 | 307 | break;
|
nkeynes@191 | 308 | case RENDER_SIZE:
|
nkeynes@191 | 309 | MMIO_WRITE( PVR2, reg, val&0x000001FF );
|
nkeynes@191 | 310 | break;
|
nkeynes@197 | 311 | case DISP_ADDR1:
|
nkeynes@189 | 312 | val &= 0x00FFFFFC;
|
nkeynes@189 | 313 | MMIO_WRITE( PVR2, reg, val );
|
nkeynes@265 | 314 | pvr2_update_raster_posn(sh4r.slice_cycle);
|
nkeynes@265 | 315 | if( pvr2_state.line_count >= pvr2_state.retrace_start_line ||
|
nkeynes@265 | 316 | pvr2_state.line_count < pvr2_state.retrace_end_line ) {
|
nkeynes@108 | 317 | pvr2_display_frame();
|
nkeynes@108 | 318 | }
|
nkeynes@108 | 319 | break;
|
nkeynes@197 | 320 | case DISP_ADDR2:
|
nkeynes@191 | 321 | MMIO_WRITE( PVR2, reg, val&0x00FFFFFC );
|
nkeynes@191 | 322 | break;
|
nkeynes@197 | 323 | case DISP_SIZE:
|
nkeynes@191 | 324 | MMIO_WRITE( PVR2, reg, val&0x3FFFFFFF );
|
nkeynes@191 | 325 | break;
|
nkeynes@191 | 326 | case RENDER_ADDR1:
|
nkeynes@191 | 327 | case RENDER_ADDR2:
|
nkeynes@191 | 328 | MMIO_WRITE( PVR2, reg, val&0x01FFFFFC );
|
nkeynes@191 | 329 | break;
|
nkeynes@191 | 330 | case RENDER_HCLIP:
|
nkeynes@191 | 331 | MMIO_WRITE( PVR2, reg, val&0x07FF07FF );
|
nkeynes@189 | 332 | break;
|
nkeynes@191 | 333 | case RENDER_VCLIP:
|
nkeynes@191 | 334 | MMIO_WRITE( PVR2, reg, val&0x03FF03FF );
|
nkeynes@189 | 335 | break;
|
nkeynes@197 | 336 | case DISP_HPOSIRQ:
|
nkeynes@191 | 337 | MMIO_WRITE( PVR2, reg, val&0x03FF33FF );
|
nkeynes@189 | 338 | break;
|
nkeynes@197 | 339 | case DISP_VPOSIRQ:
|
nkeynes@189 | 340 | val = val & 0x03FF03FF;
|
nkeynes@189 | 341 | pvr2_state.irq_vpos1 = (val >> 16);
|
nkeynes@133 | 342 | pvr2_state.irq_vpos2 = val & 0x03FF;
|
nkeynes@265 | 343 | pvr2_update_raster_posn(sh4r.slice_cycle);
|
nkeynes@265 | 344 | pvr2_schedule_scanline_event( EVENT_SCANLINE1, pvr2_state.irq_vpos1 );
|
nkeynes@265 | 345 | pvr2_schedule_scanline_event( EVENT_SCANLINE2, pvr2_state.irq_vpos2 );
|
nkeynes@189 | 346 | MMIO_WRITE( PVR2, reg, val );
|
nkeynes@103 | 347 | break;
|
nkeynes@197 | 348 | case RENDER_NEARCLIP:
|
nkeynes@197 | 349 | MMIO_WRITE( PVR2, reg, val & 0x7FFFFFFF );
|
nkeynes@197 | 350 | break;
|
nkeynes@191 | 351 | case RENDER_SHADOW:
|
nkeynes@191 | 352 | MMIO_WRITE( PVR2, reg, val&0x000001FF );
|
nkeynes@191 | 353 | break;
|
nkeynes@191 | 354 | case RENDER_OBJCFG:
|
nkeynes@191 | 355 | MMIO_WRITE( PVR2, reg, val&0x003FFFFF );
|
nkeynes@191 | 356 | break;
|
nkeynes@191 | 357 | case RENDER_TSPCLIP:
|
nkeynes@191 | 358 | MMIO_WRITE( PVR2, reg, val&0x7FFFFFFF );
|
nkeynes@191 | 359 | break;
|
nkeynes@197 | 360 | case RENDER_FARCLIP:
|
nkeynes@197 | 361 | MMIO_WRITE( PVR2, reg, val&0xFFFFFFF0 );
|
nkeynes@197 | 362 | break;
|
nkeynes@191 | 363 | case RENDER_BGPLANE:
|
nkeynes@191 | 364 | MMIO_WRITE( PVR2, reg, val&0x1FFFFFFF );
|
nkeynes@191 | 365 | break;
|
nkeynes@191 | 366 | case RENDER_ISPCFG:
|
nkeynes@191 | 367 | MMIO_WRITE( PVR2, reg, val&0x00FFFFF9 );
|
nkeynes@191 | 368 | break;
|
nkeynes@197 | 369 | case VRAM_CFG1:
|
nkeynes@197 | 370 | MMIO_WRITE( PVR2, reg, val&0x000000FF );
|
nkeynes@197 | 371 | break;
|
nkeynes@197 | 372 | case VRAM_CFG2:
|
nkeynes@197 | 373 | MMIO_WRITE( PVR2, reg, val&0x003FFFFF );
|
nkeynes@197 | 374 | break;
|
nkeynes@197 | 375 | case VRAM_CFG3:
|
nkeynes@197 | 376 | MMIO_WRITE( PVR2, reg, val&0x1FFFFFFF );
|
nkeynes@197 | 377 | break;
|
nkeynes@197 | 378 | case RENDER_FOGTBLCOL:
|
nkeynes@197 | 379 | case RENDER_FOGVRTCOL:
|
nkeynes@197 | 380 | MMIO_WRITE( PVR2, reg, val&0x00FFFFFF );
|
nkeynes@197 | 381 | break;
|
nkeynes@197 | 382 | case RENDER_FOGCOEFF:
|
nkeynes@197 | 383 | MMIO_WRITE( PVR2, reg, val&0x0000FFFF );
|
nkeynes@197 | 384 | break;
|
nkeynes@197 | 385 | case RENDER_CLAMPHI:
|
nkeynes@197 | 386 | case RENDER_CLAMPLO:
|
nkeynes@197 | 387 | MMIO_WRITE( PVR2, reg, val );
|
nkeynes@197 | 388 | break;
|
nkeynes@261 | 389 | case RENDER_TEXSIZE:
|
nkeynes@261 | 390 | MMIO_WRITE( PVR2, reg, val&0x00031F1F );
|
nkeynes@197 | 391 | break;
|
nkeynes@261 | 392 | case RENDER_PALETTE:
|
nkeynes@261 | 393 | MMIO_WRITE( PVR2, reg, val&0x00000003 );
|
nkeynes@261 | 394 | break;
|
nkeynes@261 | 395 |
|
nkeynes@261 | 396 | /********** CRTC registers *************/
|
nkeynes@197 | 397 | case DISP_HBORDER:
|
nkeynes@197 | 398 | case DISP_VBORDER:
|
nkeynes@197 | 399 | MMIO_WRITE( PVR2, reg, val&0x03FF03FF );
|
nkeynes@197 | 400 | break;
|
nkeynes@261 | 401 | case DISP_TOTAL:
|
nkeynes@261 | 402 | val = val & 0x03FF03FF;
|
nkeynes@261 | 403 | MMIO_WRITE( PVR2, reg, val );
|
nkeynes@265 | 404 | pvr2_update_raster_posn(sh4r.slice_cycle);
|
nkeynes@261 | 405 | pvr2_state.total_lines = (val >> 16) + 1;
|
nkeynes@261 | 406 | pvr2_state.line_size = (val & 0x03FF) + 1;
|
nkeynes@261 | 407 | pvr2_state.line_time_ns = 1000000 * pvr2_state.line_size / pvr2_state.dot_clock;
|
nkeynes@265 | 408 | pvr2_state.retrace_end_line = 0x2A;
|
nkeynes@265 | 409 | pvr2_state.retrace_start_line = pvr2_state.total_lines - 6;
|
nkeynes@265 | 410 | pvr2_schedule_line_event( EVENT_RETRACE, 0 );
|
nkeynes@265 | 411 | pvr2_schedule_scanline_event( EVENT_SCANLINE1, pvr2_state.irq_vpos1 );
|
nkeynes@265 | 412 | pvr2_schedule_scanline_event( EVENT_SCANLINE2, pvr2_state.irq_vpos2 );
|
nkeynes@261 | 413 | break;
|
nkeynes@261 | 414 | case DISP_SYNCCFG:
|
nkeynes@261 | 415 | MMIO_WRITE( PVR2, reg, val&0x000003FF );
|
nkeynes@261 | 416 | pvr2_state.interlaced = (val & 0x0010) ? TRUE : FALSE;
|
nkeynes@261 | 417 | break;
|
nkeynes@261 | 418 | case DISP_SYNCTIME:
|
nkeynes@261 | 419 | pvr2_state.vsync_lines = (val >> 8) & 0x0F;
|
nkeynes@261 | 420 | pvr2_state.hsync_width_ns = ((val & 0x7F) + 1) * 1000000 / pvr2_state.dot_clock;
|
nkeynes@197 | 421 | MMIO_WRITE( PVR2, reg, val&0xFFFFFF7F );
|
nkeynes@197 | 422 | break;
|
nkeynes@197 | 423 | case DISP_CFG2:
|
nkeynes@197 | 424 | MMIO_WRITE( PVR2, reg, val&0x003F01FF );
|
nkeynes@197 | 425 | break;
|
nkeynes@197 | 426 | case DISP_HPOS:
|
nkeynes@261 | 427 | val = val & 0x03FF;
|
nkeynes@261 | 428 | pvr2_state.front_porch_ns = (val + 1) * 1000000 / pvr2_state.dot_clock;
|
nkeynes@261 | 429 | MMIO_WRITE( PVR2, reg, val );
|
nkeynes@197 | 430 | break;
|
nkeynes@197 | 431 | case DISP_VPOS:
|
nkeynes@197 | 432 | MMIO_WRITE( PVR2, reg, val&0x03FF03FF );
|
nkeynes@197 | 433 | break;
|
nkeynes@261 | 434 |
|
nkeynes@261 | 435 | /*********** Tile accelerator registers ***********/
|
nkeynes@261 | 436 | case TA_POLYPOS:
|
nkeynes@261 | 437 | case TA_LISTPOS:
|
nkeynes@261 | 438 | /* Readonly registers */
|
nkeynes@197 | 439 | break;
|
nkeynes@189 | 440 | case TA_TILEBASE:
|
nkeynes@193 | 441 | case TA_LISTEND:
|
nkeynes@189 | 442 | case TA_LISTBASE:
|
nkeynes@191 | 443 | MMIO_WRITE( PVR2, reg, val&0x00FFFFE0 );
|
nkeynes@189 | 444 | break;
|
nkeynes@191 | 445 | case RENDER_TILEBASE:
|
nkeynes@189 | 446 | case TA_POLYBASE:
|
nkeynes@189 | 447 | case TA_POLYEND:
|
nkeynes@191 | 448 | MMIO_WRITE( PVR2, reg, val&0x00FFFFFC );
|
nkeynes@189 | 449 | break;
|
nkeynes@189 | 450 | case TA_TILESIZE:
|
nkeynes@191 | 451 | MMIO_WRITE( PVR2, reg, val&0x000F003F );
|
nkeynes@189 | 452 | break;
|
nkeynes@189 | 453 | case TA_TILECFG:
|
nkeynes@191 | 454 | MMIO_WRITE( PVR2, reg, val&0x00133333 );
|
nkeynes@189 | 455 | break;
|
nkeynes@261 | 456 | case TA_INIT:
|
nkeynes@261 | 457 | if( val & 0x80000000 )
|
nkeynes@261 | 458 | pvr2_ta_init();
|
nkeynes@261 | 459 | break;
|
nkeynes@261 | 460 | case TA_REINIT:
|
nkeynes@261 | 461 | break;
|
nkeynes@261 | 462 | /**************** Scaler registers? ****************/
|
nkeynes@261 | 463 | case SCALERCFG:
|
nkeynes@261 | 464 | MMIO_WRITE( PVR2, reg, val&0x0007FFFF );
|
nkeynes@261 | 465 | break;
|
nkeynes@261 | 466 |
|
nkeynes@197 | 467 | case YUV_ADDR:
|
nkeynes@197 | 468 | MMIO_WRITE( PVR2, reg, val&0x00FFFFF8 );
|
nkeynes@197 | 469 | break;
|
nkeynes@197 | 470 | case YUV_CFG:
|
nkeynes@197 | 471 | MMIO_WRITE( PVR2, reg, val&0x01013F3F );
|
nkeynes@197 | 472 | break;
|
nkeynes@261 | 473 |
|
nkeynes@261 | 474 |
|
nkeynes@261 | 475 | /**************** Unknowns ***************/
|
nkeynes@261 | 476 | case PVRUNK1:
|
nkeynes@261 | 477 | MMIO_WRITE( PVR2, reg, val&0x000007FF );
|
nkeynes@261 | 478 | break;
|
nkeynes@261 | 479 | case PVRUNK2:
|
nkeynes@261 | 480 | MMIO_WRITE( PVR2, reg, val&0x00000007 );
|
nkeynes@100 | 481 | break;
|
nkeynes@261 | 482 | case PVRUNK3:
|
nkeynes@261 | 483 | MMIO_WRITE( PVR2, reg, val&0x000FFF3F );
|
nkeynes@261 | 484 | break;
|
nkeynes@261 | 485 | case PVRUNK5:
|
nkeynes@261 | 486 | MMIO_WRITE( PVR2, reg, val&0x0000FFFF );
|
nkeynes@261 | 487 | break;
|
nkeynes@261 | 488 | case PVRUNK6:
|
nkeynes@261 | 489 | MMIO_WRITE( PVR2, reg, val&0x000000FF );
|
nkeynes@197 | 490 | break;
|
nkeynes@197 | 491 | case PVRUNK7:
|
nkeynes@197 | 492 | MMIO_WRITE( PVR2, reg, val&0x00000001 );
|
nkeynes@197 | 493 | break;
|
nkeynes@1 | 494 | }
|
nkeynes@1 | 495 | }
|
nkeynes@1 | 496 |
|
nkeynes@261 | 497 | /**
|
nkeynes@261 | 498 | * Calculate the current read value of the syncstat register, using
|
nkeynes@261 | 499 | * the current SH4 clock time as an offset from the last timeslice.
|
nkeynes@261 | 500 | * The register reads (LSB to MSB) as:
|
nkeynes@261 | 501 | * 0..9 Current scan line
|
nkeynes@261 | 502 | * 10 Odd/even field (1 = odd, 0 = even)
|
nkeynes@261 | 503 | * 11 Display active (including border and overscan)
|
nkeynes@261 | 504 | * 12 Horizontal sync off
|
nkeynes@261 | 505 | * 13 Vertical sync off
|
nkeynes@261 | 506 | * Note this method is probably incorrect for anything other than straight
|
nkeynes@265 | 507 | * interlaced PAL/NTSC, and needs further testing.
|
nkeynes@261 | 508 | */
|
nkeynes@261 | 509 | uint32_t pvr2_get_sync_status()
|
nkeynes@261 | 510 | {
|
nkeynes@265 | 511 | pvr2_update_raster_posn(sh4r.slice_cycle);
|
nkeynes@265 | 512 | uint32_t result = pvr2_state.line_count;
|
nkeynes@261 | 513 |
|
nkeynes@265 | 514 | if( pvr2_state.odd_even_field ) {
|
nkeynes@261 | 515 | result |= 0x0400;
|
nkeynes@261 | 516 | }
|
nkeynes@265 | 517 | if( (pvr2_state.line_count & 0x01) == pvr2_state.odd_even_field ) {
|
nkeynes@265 | 518 | if( pvr2_state.line_remainder > pvr2_state.hsync_width_ns ) {
|
nkeynes@261 | 519 | result |= 0x1000; /* !HSYNC */
|
nkeynes@261 | 520 | }
|
nkeynes@265 | 521 | if( pvr2_state.line_count >= pvr2_state.vsync_lines ) {
|
nkeynes@265 | 522 | if( pvr2_state.line_remainder > pvr2_state.front_porch_ns ) {
|
nkeynes@261 | 523 | result |= 0x2800; /* Display active */
|
nkeynes@261 | 524 | } else {
|
nkeynes@261 | 525 | result |= 0x2000; /* Front porch */
|
nkeynes@261 | 526 | }
|
nkeynes@261 | 527 | }
|
nkeynes@261 | 528 | } else {
|
nkeynes@265 | 529 | if( pvr2_state.line_remainder < (pvr2_state.line_time_ns - pvr2_state.back_porch_ns) &&
|
nkeynes@265 | 530 | pvr2_state.line_count >= pvr2_state.vsync_lines ) {
|
nkeynes@261 | 531 | result |= 0x3800; /* Display active */
|
nkeynes@261 | 532 | } else {
|
nkeynes@261 | 533 | result |= 0x1000; /* Back porch */
|
nkeynes@261 | 534 | }
|
nkeynes@261 | 535 | }
|
nkeynes@265 | 536 |
|
nkeynes@261 | 537 | return result;
|
nkeynes@261 | 538 | }
|
nkeynes@261 | 539 |
|
nkeynes@265 | 540 | /**
|
nkeynes@265 | 541 | * Schedule an event for the start of the given line. If the line is actually
|
nkeynes@265 | 542 | * the current line, schedules it for the next field.
|
nkeynes@265 | 543 | * The raster position should be updated before calling this method.
|
nkeynes@265 | 544 | */
|
nkeynes@265 | 545 | static void pvr2_schedule_line_event( int eventid, int line )
|
nkeynes@265 | 546 | {
|
nkeynes@265 | 547 | uint32_t time;
|
nkeynes@265 | 548 | if( line <= pvr2_state.line_count ) {
|
nkeynes@265 | 549 | time = (pvr2_state.total_lines - pvr2_state.line_count + line) * pvr2_state.line_time_ns
|
nkeynes@265 | 550 | - pvr2_state.line_remainder;
|
nkeynes@265 | 551 | } else {
|
nkeynes@265 | 552 | time = (line - pvr2_state.line_count) * pvr2_state.line_time_ns - pvr2_state.line_remainder;
|
nkeynes@265 | 553 | }
|
nkeynes@265 | 554 |
|
nkeynes@265 | 555 | if( line < pvr2_state.total_lines ) {
|
nkeynes@265 | 556 | event_schedule( eventid, time );
|
nkeynes@265 | 557 | } else {
|
nkeynes@265 | 558 | event_cancel( eventid );
|
nkeynes@265 | 559 | }
|
nkeynes@265 | 560 | }
|
nkeynes@265 | 561 |
|
nkeynes@265 | 562 | /**
|
nkeynes@265 | 563 | * Schedule a "scanline" event. This actually goes off at
|
nkeynes@265 | 564 | * 2 * line in even fields and 2 * line + 1 in odd fields.
|
nkeynes@265 | 565 | * Otherwise this behaves as per pvr2_schedule_line_event().
|
nkeynes@265 | 566 | * The raster position should be updated before calling this
|
nkeynes@265 | 567 | * method.
|
nkeynes@265 | 568 | */
|
nkeynes@265 | 569 | static void pvr2_schedule_scanline_event( int eventid, int line )
|
nkeynes@265 | 570 | {
|
nkeynes@265 | 571 | uint32_t field = pvr2_state.odd_even_field;
|
nkeynes@265 | 572 | if( line <= pvr2_state.line_count && pvr2_state.interlaced ) {
|
nkeynes@265 | 573 | field = !field;
|
nkeynes@265 | 574 | }
|
nkeynes@265 | 575 |
|
nkeynes@265 | 576 | line <<= 1;
|
nkeynes@265 | 577 | if( field ) {
|
nkeynes@265 | 578 | line += 1;
|
nkeynes@265 | 579 | }
|
nkeynes@265 | 580 | pvr2_schedule_line_event( eventid, line );
|
nkeynes@265 | 581 | }
|
nkeynes@265 | 582 |
|
nkeynes@1 | 583 | MMIO_REGION_READ_FN( PVR2, reg )
|
nkeynes@1 | 584 | {
|
nkeynes@1 | 585 | switch( reg ) {
|
nkeynes@261 | 586 | case DISP_SYNCSTAT:
|
nkeynes@261 | 587 | return pvr2_get_sync_status();
|
nkeynes@1 | 588 | default:
|
nkeynes@1 | 589 | return MMIO_READ( PVR2, reg );
|
nkeynes@1 | 590 | }
|
nkeynes@1 | 591 | }
|
nkeynes@19 | 592 |
|
nkeynes@85 | 593 | MMIO_REGION_DEFFNS( PVR2PAL )
|
nkeynes@85 | 594 |
|
nkeynes@19 | 595 | void pvr2_set_base_address( uint32_t base )
|
nkeynes@19 | 596 | {
|
nkeynes@197 | 597 | mmio_region_PVR2_write( DISP_ADDR1, base );
|
nkeynes@19 | 598 | }
|
nkeynes@56 | 599 |
|
nkeynes@56 | 600 |
|
nkeynes@65 | 601 |
|
nkeynes@98 | 602 |
|
nkeynes@56 | 603 | int32_t mmio_region_PVR2TA_read( uint32_t reg )
|
nkeynes@56 | 604 | {
|
nkeynes@56 | 605 | return 0xFFFFFFFF;
|
nkeynes@56 | 606 | }
|
nkeynes@56 | 607 |
|
nkeynes@56 | 608 | void mmio_region_PVR2TA_write( uint32_t reg, uint32_t val )
|
nkeynes@56 | 609 | {
|
nkeynes@189 | 610 | pvr2_ta_write( (char *)&val, sizeof(uint32_t) );
|
nkeynes@56 | 611 | }
|
nkeynes@56 | 612 |
|
nkeynes@85 | 613 |
|
nkeynes@103 | 614 | void pvr2_vram64_write( sh4addr_t destaddr, char *src, uint32_t length )
|
nkeynes@103 | 615 | {
|
nkeynes@103 | 616 | int bank_flag = (destaddr & 0x04) >> 2;
|
nkeynes@103 | 617 | uint32_t *banks[2];
|
nkeynes@103 | 618 | uint32_t *dwsrc;
|
nkeynes@103 | 619 | int i;
|
nkeynes@65 | 620 |
|
nkeynes@103 | 621 | destaddr = destaddr & 0x7FFFFF;
|
nkeynes@103 | 622 | if( destaddr + length > 0x800000 ) {
|
nkeynes@103 | 623 | length = 0x800000 - destaddr;
|
nkeynes@103 | 624 | }
|
nkeynes@103 | 625 |
|
nkeynes@103 | 626 | for( i=destaddr & 0xFFFFF000; i < destaddr + length; i+= PAGE_SIZE ) {
|
nkeynes@103 | 627 | texcache_invalidate_page( i );
|
nkeynes@103 | 628 | }
|
nkeynes@103 | 629 |
|
nkeynes@108 | 630 | banks[0] = ((uint32_t *)(video_base + ((destaddr & 0x007FFFF8) >>1)));
|
nkeynes@103 | 631 | banks[1] = banks[0] + 0x100000;
|
nkeynes@108 | 632 | if( bank_flag )
|
nkeynes@108 | 633 | banks[0]++;
|
nkeynes@103 | 634 |
|
nkeynes@103 | 635 | /* Handle non-aligned start of source */
|
nkeynes@103 | 636 | if( destaddr & 0x03 ) {
|
nkeynes@103 | 637 | char *dest = ((char *)banks[bank_flag]) + (destaddr & 0x03);
|
nkeynes@103 | 638 | for( i= destaddr & 0x03; i < 4 && length > 0; i++, length-- ) {
|
nkeynes@103 | 639 | *dest++ = *src++;
|
nkeynes@103 | 640 | }
|
nkeynes@103 | 641 | bank_flag = !bank_flag;
|
nkeynes@103 | 642 | }
|
nkeynes@103 | 643 |
|
nkeynes@103 | 644 | dwsrc = (uint32_t *)src;
|
nkeynes@103 | 645 | while( length >= 4 ) {
|
nkeynes@103 | 646 | *banks[bank_flag]++ = *dwsrc++;
|
nkeynes@103 | 647 | bank_flag = !bank_flag;
|
nkeynes@103 | 648 | length -= 4;
|
nkeynes@103 | 649 | }
|
nkeynes@103 | 650 |
|
nkeynes@103 | 651 | /* Handle non-aligned end of source */
|
nkeynes@103 | 652 | if( length ) {
|
nkeynes@103 | 653 | src = (char *)dwsrc;
|
nkeynes@103 | 654 | char *dest = (char *)banks[bank_flag];
|
nkeynes@103 | 655 | while( length-- > 0 ) {
|
nkeynes@103 | 656 | *dest++ = *src++;
|
nkeynes@103 | 657 | }
|
nkeynes@103 | 658 | }
|
nkeynes@218 | 659 | }
|
nkeynes@103 | 660 |
|
nkeynes@218 | 661 | void pvr2_vram_write_invert( sh4addr_t destaddr, char *src, uint32_t length, uint32_t line_length )
|
nkeynes@218 | 662 | {
|
nkeynes@218 | 663 | char *dest = video_base + (destaddr & 0x007FFFFF);
|
nkeynes@218 | 664 | char *p = src + length - line_length;
|
nkeynes@218 | 665 | while( p >= src ) {
|
nkeynes@218 | 666 | memcpy( dest, p, line_length );
|
nkeynes@218 | 667 | p -= line_length;
|
nkeynes@218 | 668 | dest += line_length;
|
nkeynes@218 | 669 | }
|
nkeynes@103 | 670 | }
|
nkeynes@103 | 671 |
|
nkeynes@103 | 672 | void pvr2_vram64_read( char *dest, sh4addr_t srcaddr, uint32_t length )
|
nkeynes@103 | 673 | {
|
nkeynes@103 | 674 | int bank_flag = (srcaddr & 0x04) >> 2;
|
nkeynes@103 | 675 | uint32_t *banks[2];
|
nkeynes@103 | 676 | uint32_t *dwdest;
|
nkeynes@103 | 677 | int i;
|
nkeynes@103 | 678 |
|
nkeynes@103 | 679 | srcaddr = srcaddr & 0x7FFFFF;
|
nkeynes@103 | 680 | if( srcaddr + length > 0x800000 )
|
nkeynes@103 | 681 | length = 0x800000 - srcaddr;
|
nkeynes@103 | 682 |
|
nkeynes@108 | 683 | banks[0] = ((uint32_t *)(video_base + ((srcaddr&0x007FFFF8)>>1)));
|
nkeynes@103 | 684 | banks[1] = banks[0] + 0x100000;
|
nkeynes@108 | 685 | if( bank_flag )
|
nkeynes@108 | 686 | banks[0]++;
|
nkeynes@103 | 687 |
|
nkeynes@103 | 688 | /* Handle non-aligned start of source */
|
nkeynes@103 | 689 | if( srcaddr & 0x03 ) {
|
nkeynes@103 | 690 | char *src = ((char *)banks[bank_flag]) + (srcaddr & 0x03);
|
nkeynes@103 | 691 | for( i= srcaddr & 0x03; i < 4 && length > 0; i++, length-- ) {
|
nkeynes@103 | 692 | *dest++ = *src++;
|
nkeynes@103 | 693 | }
|
nkeynes@103 | 694 | bank_flag = !bank_flag;
|
nkeynes@103 | 695 | }
|
nkeynes@103 | 696 |
|
nkeynes@103 | 697 | dwdest = (uint32_t *)dest;
|
nkeynes@103 | 698 | while( length >= 4 ) {
|
nkeynes@103 | 699 | *dwdest++ = *banks[bank_flag]++;
|
nkeynes@103 | 700 | bank_flag = !bank_flag;
|
nkeynes@103 | 701 | length -= 4;
|
nkeynes@103 | 702 | }
|
nkeynes@103 | 703 |
|
nkeynes@103 | 704 | /* Handle non-aligned end of source */
|
nkeynes@103 | 705 | if( length ) {
|
nkeynes@103 | 706 | dest = (char *)dwdest;
|
nkeynes@103 | 707 | char *src = (char *)banks[bank_flag];
|
nkeynes@103 | 708 | while( length-- > 0 ) {
|
nkeynes@103 | 709 | *dest++ = *src++;
|
nkeynes@103 | 710 | }
|
nkeynes@103 | 711 | }
|
nkeynes@103 | 712 | }
|
nkeynes@127 | 713 |
|
nkeynes@127 | 714 | void pvr2_vram64_dump( sh4addr_t addr, uint32_t length, FILE *f )
|
nkeynes@127 | 715 | {
|
nkeynes@127 | 716 | char tmp[length];
|
nkeynes@127 | 717 | pvr2_vram64_read( tmp, addr, length );
|
nkeynes@127 | 718 | fwrite_dump( tmp, length, f );
|
nkeynes@127 | 719 | }
|