nkeynes@31: /** nkeynes@586: * $Id$ nkeynes@31: * nkeynes@133: * PVR2 (Video) Core module implementation and MMIO registers. nkeynes@31: * nkeynes@31: * Copyright (c) 2005 Nathan Keynes. nkeynes@31: * nkeynes@31: * This program is free software; you can redistribute it and/or modify nkeynes@31: * it under the terms of the GNU General Public License as published by nkeynes@31: * the Free Software Foundation; either version 2 of the License, or nkeynes@31: * (at your option) any later version. nkeynes@31: * nkeynes@31: * This program is distributed in the hope that it will be useful, nkeynes@31: * but WITHOUT ANY WARRANTY; without even the implied warranty of nkeynes@31: * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the nkeynes@31: * GNU General Public License for more details. nkeynes@31: */ nkeynes@35: #define MODULE pvr2_module nkeynes@31: nkeynes@477: #include nkeynes@1: #include "dream.h" nkeynes@265: #include "eventq.h" nkeynes@144: #include "display.h" nkeynes@1: #include "mem.h" nkeynes@1: #include "asic.h" nkeynes@261: #include "clock.h" nkeynes@103: #include "pvr2/pvr2.h" nkeynes@677: #include "pvr2/pvr2mmio.h" nkeynes@669: #include "pvr2/scene.h" nkeynes@586: #include "sh4/sh4.h" nkeynes@1: #define MMIO_IMPL nkeynes@103: #include "pvr2/pvr2mmio.h" nkeynes@1: nkeynes@502: unsigned char *video_base; nkeynes@1: nkeynes@352: #define MAX_RENDER_BUFFERS 4 nkeynes@352: nkeynes@304: #define HPOS_PER_FRAME 0 nkeynes@304: #define HPOS_PER_LINECOUNT 1 nkeynes@304: nkeynes@133: static void pvr2_init( void ); nkeynes@133: static void pvr2_reset( void ); nkeynes@133: static uint32_t pvr2_run_slice( uint32_t ); nkeynes@133: static void pvr2_save_state( FILE *f ); nkeynes@133: static int pvr2_load_state( FILE *f ); nkeynes@265: static void pvr2_update_raster_posn( uint32_t nanosecs ); nkeynes@304: static void pvr2_schedule_scanline_event( int eventid, int line, int minimum_lines, int line_time_ns ); nkeynes@352: static render_buffer_t pvr2_get_render_buffer( frame_buffer_t frame ); nkeynes@352: static render_buffer_t pvr2_next_render_buffer( ); nkeynes@477: static render_buffer_t pvr2_frame_buffer_to_render_buffer( frame_buffer_t frame ); nkeynes@265: uint32_t pvr2_get_sync_status(); nkeynes@133: nkeynes@94: void pvr2_display_frame( void ); nkeynes@94: nkeynes@477: static int output_colour_formats[] = { COLFMT_BGRA1555, COLFMT_RGB565, COLFMT_BGR888, COLFMT_BGRA8888 }; nkeynes@856: static int render_colour_formats[8] = { nkeynes@856: COLFMT_BGRA1555, COLFMT_RGB565, COLFMT_BGRA4444, COLFMT_BGRA1555, nkeynes@856: COLFMT_BGR888, COLFMT_BGRA8888, COLFMT_BGRA8888, COLFMT_BGRA4444 }; nkeynes@856: nkeynes@161: nkeynes@133: struct dreamcast_module pvr2_module = { "PVR2", pvr2_init, pvr2_reset, NULL, nkeynes@736: pvr2_run_slice, NULL, nkeynes@736: pvr2_save_state, pvr2_load_state }; nkeynes@133: nkeynes@103: nkeynes@144: display_driver_t display_driver = NULL; nkeynes@15: nkeynes@133: struct pvr2_state { nkeynes@133: uint32_t frame_count; nkeynes@133: uint32_t line_count; nkeynes@133: uint32_t line_remainder; nkeynes@265: uint32_t cycles_run; /* Cycles already executed prior to main time slice */ nkeynes@304: uint32_t irq_hpos_line; nkeynes@304: uint32_t irq_hpos_line_count; nkeynes@304: uint32_t irq_hpos_mode; nkeynes@304: uint32_t irq_hpos_time_ns; /* Time within the line */ nkeynes@133: uint32_t irq_vpos1; nkeynes@133: uint32_t irq_vpos2; nkeynes@261: uint32_t odd_even_field; /* 1 = odd, 0 = even */ nkeynes@674: int32_t palette_changed; /* TRUE if palette has changed since last render */ nkeynes@261: /* timing */ nkeynes@261: uint32_t dot_clock; nkeynes@261: uint32_t total_lines; nkeynes@261: uint32_t line_size; nkeynes@261: uint32_t line_time_ns; nkeynes@261: uint32_t vsync_lines; nkeynes@261: uint32_t hsync_width_ns; nkeynes@261: uint32_t front_porch_ns; nkeynes@261: uint32_t back_porch_ns; nkeynes@265: uint32_t retrace_start_line; nkeynes@265: uint32_t retrace_end_line; nkeynes@674: int32_t interlaced; nkeynes@133: } pvr2_state; nkeynes@15: nkeynes@674: static gchar *save_next_render_filename; nkeynes@441: static render_buffer_t render_buffers[MAX_RENDER_BUFFERS]; nkeynes@674: static uint32_t render_buffer_count = 0; nkeynes@441: static render_buffer_t displayed_render_buffer = NULL; nkeynes@545: static uint32_t displayed_border_colour = 0; nkeynes@133: nkeynes@265: /** nkeynes@304: * Event handler for the hpos callback nkeynes@265: */ nkeynes@304: static void pvr2_hpos_callback( int eventid ) { nkeynes@265: asic_event( eventid ); nkeynes@265: pvr2_update_raster_posn(sh4r.slice_cycle); nkeynes@304: if( pvr2_state.irq_hpos_mode == HPOS_PER_LINECOUNT ) { nkeynes@736: pvr2_state.irq_hpos_line += pvr2_state.irq_hpos_line_count; nkeynes@736: while( pvr2_state.irq_hpos_line > (pvr2_state.total_lines>>1) ) { nkeynes@736: pvr2_state.irq_hpos_line -= (pvr2_state.total_lines>>1); nkeynes@736: } nkeynes@304: } nkeynes@304: pvr2_schedule_scanline_event( eventid, pvr2_state.irq_hpos_line, 1, nkeynes@736: pvr2_state.irq_hpos_time_ns ); nkeynes@265: } nkeynes@265: nkeynes@265: /** nkeynes@265: * Event handler for the scanline callbacks. Fires the corresponding nkeynes@265: * ASIC event, and resets the timer for the next field. nkeynes@265: */ nkeynes@850: static void pvr2_scanline_callback( int eventid ) nkeynes@850: { nkeynes@265: asic_event( eventid ); nkeynes@265: pvr2_update_raster_posn(sh4r.slice_cycle); nkeynes@265: if( eventid == EVENT_SCANLINE1 ) { nkeynes@736: pvr2_schedule_scanline_event( eventid, pvr2_state.irq_vpos1, 1, 0 ); nkeynes@265: } else { nkeynes@736: pvr2_schedule_scanline_event( eventid, pvr2_state.irq_vpos2, 1, 0 ); nkeynes@265: } nkeynes@265: } nkeynes@265: nkeynes@850: static void pvr2_gunpos_callback( int eventid ) nkeynes@850: { nkeynes@850: pvr2_update_raster_posn(sh4r.slice_cycle); nkeynes@850: int hpos = pvr2_state.line_remainder * pvr2_state.dot_clock / 1000000; nkeynes@850: MMIO_WRITE( PVR2, GUNPOS, ((pvr2_state.line_count<<16)|(hpos&0x3FF)) ); nkeynes@850: asic_event( EVENT_MAPLE_DMA ); nkeynes@850: } nkeynes@850: nkeynes@133: static void pvr2_init( void ) nkeynes@1: { nkeynes@352: int i; nkeynes@1: register_io_region( &mmio_region_PVR2 ); nkeynes@85: register_io_region( &mmio_region_PVR2PAL ); nkeynes@56: register_io_region( &mmio_region_PVR2TA ); nkeynes@304: register_event_callback( EVENT_HPOS, pvr2_hpos_callback ); nkeynes@265: register_event_callback( EVENT_SCANLINE1, pvr2_scanline_callback ); nkeynes@265: register_event_callback( EVENT_SCANLINE2, pvr2_scanline_callback ); nkeynes@850: register_event_callback( EVENT_GUNPOS, pvr2_gunpos_callback ); nkeynes@1: video_base = mem_get_region_by_name( MEM_REGION_VIDEO ); nkeynes@133: texcache_init(); nkeynes@133: pvr2_reset(); nkeynes@214: pvr2_ta_reset(); nkeynes@674: save_next_render_filename = NULL; nkeynes@352: for( i=0; idisplay_blank(0); nkeynes@736: for( i=0; idestroy_render_buffer(render_buffers[i]); nkeynes@736: render_buffers[i] = NULL; nkeynes@736: } nkeynes@736: render_buffer_count = 0; nkeynes@477: } nkeynes@133: } nkeynes@133: nkeynes@477: void pvr2_save_render_buffer( FILE *f, render_buffer_t buffer ) nkeynes@477: { nkeynes@477: struct frame_buffer fbuf; nkeynes@477: nkeynes@477: fbuf.width = buffer->width; nkeynes@477: fbuf.height = buffer->height; nkeynes@477: fbuf.rowstride = fbuf.width*3; nkeynes@477: fbuf.colour_format = COLFMT_BGR888; nkeynes@477: fbuf.inverted = buffer->inverted; nkeynes@477: fbuf.data = g_malloc0( buffer->width * buffer->height * 3 ); nkeynes@736: nkeynes@477: display_driver->read_render_buffer( fbuf.data, buffer, fbuf.rowstride, COLFMT_BGR888 ); nkeynes@477: write_png_to_stream( f, &fbuf ); nkeynes@477: g_free( fbuf.data ); nkeynes@477: nkeynes@477: fwrite( &buffer->rowstride, sizeof(buffer->rowstride), 1, f ); nkeynes@477: fwrite( &buffer->colour_format, sizeof(buffer->colour_format), 1, f ); nkeynes@477: fwrite( &buffer->address, sizeof(buffer->address), 1, f ); nkeynes@477: fwrite( &buffer->scale, sizeof(buffer->scale), 1, f ); nkeynes@674: int32_t flushed = (int32_t)buffer->flushed; // Force to 32-bits for save-file consistency nkeynes@674: fwrite( &flushed, sizeof(flushed), 1, f ); nkeynes@736: nkeynes@477: } nkeynes@477: nkeynes@477: render_buffer_t pvr2_load_render_buffer( FILE *f ) nkeynes@477: { nkeynes@477: frame_buffer_t frame = read_png_from_stream( f ); nkeynes@477: if( frame == NULL ) { nkeynes@736: return NULL; nkeynes@477: } nkeynes@477: nkeynes@477: render_buffer_t buffer = pvr2_frame_buffer_to_render_buffer(frame); nkeynes@653: if( buffer != NULL ) { nkeynes@674: int32_t flushed; nkeynes@736: fread( &buffer->rowstride, sizeof(buffer->rowstride), 1, f ); nkeynes@736: fread( &buffer->colour_format, sizeof(buffer->colour_format), 1, f ); nkeynes@736: fread( &buffer->address, sizeof(buffer->address), 1, f ); nkeynes@736: fread( &buffer->scale, sizeof(buffer->scale), 1, f ); nkeynes@736: fread( &flushed, sizeof(flushed), 1, f ); nkeynes@736: buffer->flushed = (gboolean)flushed; nkeynes@653: } else { nkeynes@736: fseek( f, sizeof(buffer->rowstride)+sizeof(buffer->colour_format)+ nkeynes@736: sizeof(buffer->address)+sizeof(buffer->scale)+ nkeynes@736: sizeof(int32_t), SEEK_CUR ); nkeynes@653: } nkeynes@477: return buffer; nkeynes@477: } nkeynes@477: nkeynes@477: nkeynes@477: nkeynes@477: nkeynes@477: void pvr2_save_render_buffers( FILE *f ) nkeynes@477: { nkeynes@477: int i; nkeynes@674: uint32_t has_frontbuffer; nkeynes@477: fwrite( &render_buffer_count, sizeof(render_buffer_count), 1, f ); nkeynes@477: if( displayed_render_buffer != NULL ) { nkeynes@736: has_frontbuffer = 1; nkeynes@736: fwrite( &has_frontbuffer, sizeof(has_frontbuffer), 1, f ); nkeynes@736: pvr2_save_render_buffer( f, displayed_render_buffer ); nkeynes@477: } else { nkeynes@736: has_frontbuffer = 0; nkeynes@736: fwrite( &has_frontbuffer, sizeof(has_frontbuffer), 1, f ); nkeynes@477: } nkeynes@477: nkeynes@477: for( i=0; i MAX_RENDER_BUFFERS ) { nkeynes@736: return FALSE; nkeynes@477: } nkeynes@477: fread( &has_frontbuffer, sizeof(has_frontbuffer), 1, f ); nkeynes@477: for( i=0; idestroy_render_buffer(render_buffers[i]); nkeynes@736: render_buffers[i] = NULL; nkeynes@477: } nkeynes@477: render_buffer_count = 0; nkeynes@477: nkeynes@477: if( has_frontbuffer ) { nkeynes@736: displayed_render_buffer = pvr2_load_render_buffer(f); nkeynes@867: if( displayed_render_buffer == NULL ) nkeynes@867: return FALSE; nkeynes@736: display_driver->display_render_buffer( displayed_render_buffer ); nkeynes@736: count--; nkeynes@477: } nkeynes@477: nkeynes@477: for( i=0; i= pvr2_state.line_time_ns ) { nkeynes@736: pvr2_state.line_count ++; nkeynes@736: pvr2_state.line_remainder -= pvr2_state.line_time_ns; nkeynes@265: } nkeynes@265: nkeynes@265: if( pvr2_state.line_count >= pvr2_state.total_lines ) { nkeynes@736: pvr2_state.line_count -= pvr2_state.total_lines; nkeynes@736: if( pvr2_state.interlaced ) { nkeynes@736: pvr2_state.odd_even_field = !pvr2_state.odd_even_field; nkeynes@736: } nkeynes@265: } nkeynes@265: if( pvr2_state.line_count >= pvr2_state.retrace_end_line && nkeynes@736: (old_line_count < pvr2_state.retrace_end_line || nkeynes@736: old_line_count > pvr2_state.line_count) ) { nkeynes@736: pvr2_state.frame_count++; nkeynes@736: pvr2_display_frame(); nkeynes@265: } nkeynes@265: } nkeynes@265: nkeynes@133: static uint32_t pvr2_run_slice( uint32_t nanosecs ) nkeynes@133: { nkeynes@265: pvr2_update_raster_posn( nanosecs ); nkeynes@265: pvr2_state.cycles_run = 0; nkeynes@133: return nanosecs; nkeynes@133: } nkeynes@133: nkeynes@133: int pvr2_get_frame_count() nkeynes@133: { nkeynes@133: return pvr2_state.frame_count; nkeynes@106: } nkeynes@106: nkeynes@677: void pvr2_redraw_display() nkeynes@477: { nkeynes@677: if( display_driver != NULL ) { nkeynes@677: if( displayed_render_buffer == NULL ) { nkeynes@677: display_driver->display_blank(displayed_border_colour); nkeynes@677: } else { nkeynes@677: display_driver->display_render_buffer(displayed_render_buffer); nkeynes@677: } nkeynes@677: } nkeynes@545: } nkeynes@545: nkeynes@295: gboolean pvr2_save_next_scene( const gchar *filename ) nkeynes@295: { nkeynes@674: if( save_next_render_filename != NULL ) { nkeynes@736: g_free( save_next_render_filename ); nkeynes@295: } nkeynes@674: save_next_render_filename = g_strdup(filename); nkeynes@295: return TRUE; nkeynes@295: } nkeynes@295: nkeynes@295: nkeynes@295: nkeynes@103: /** nkeynes@1: * Display the next frame, copying the current contents of video ram to nkeynes@1: * the window. If the video configuration has changed, first recompute the nkeynes@1: * new frame size/depth. nkeynes@1: */ nkeynes@94: void pvr2_display_frame( void ) nkeynes@1: { nkeynes@197: int dispmode = MMIO_READ( PVR2, DISP_MODE ); nkeynes@261: int vidcfg = MMIO_READ( PVR2, DISP_SYNCCFG ); nkeynes@335: gboolean bEnabled = (dispmode & DISPMODE_ENABLE) && (vidcfg & DISPCFG_VO ) ? TRUE : FALSE; nkeynes@352: nkeynes@352: if( display_driver == NULL ) { nkeynes@736: return; /* can't really do anything much */ nkeynes@352: } else if( !bEnabled ) { nkeynes@736: /* Output disabled == black */ nkeynes@736: displayed_render_buffer = NULL; nkeynes@736: displayed_border_colour = 0; nkeynes@736: display_driver->display_blank( 0 ); nkeynes@352: } else if( MMIO_READ( PVR2, DISP_CFG2 ) & 0x08 ) { nkeynes@736: /* Enabled but blanked - border colour */ nkeynes@736: displayed_border_colour = MMIO_READ( PVR2, DISP_BORDER ); nkeynes@736: displayed_render_buffer = NULL; nkeynes@736: display_driver->display_blank( displayed_border_colour ); nkeynes@352: } else { nkeynes@736: /* Real output - determine dimensions etc */ nkeynes@736: struct frame_buffer fbuf; nkeynes@736: uint32_t dispsize = MMIO_READ( PVR2, DISP_SIZE ); nkeynes@736: int vid_stride = (((dispsize & DISPSIZE_MODULO) >> 20) - 1); nkeynes@736: int vid_ppl = ((dispsize & DISPSIZE_PPL)) + 1; nkeynes@352: nkeynes@736: fbuf.colour_format = output_colour_formats[(dispmode & DISPMODE_COLFMT) >> 2]; nkeynes@736: fbuf.width = vid_ppl << 2 / colour_formats[fbuf.colour_format].bpp; nkeynes@736: fbuf.height = ((dispsize & DISPSIZE_LPF) >> 10) + 1; nkeynes@736: fbuf.size = vid_ppl << 2 * fbuf.height; nkeynes@736: fbuf.rowstride = (vid_ppl + vid_stride) << 2; nkeynes@352: nkeynes@736: /* Determine the field to display, and deinterlace if possible */ nkeynes@736: if( pvr2_state.interlaced ) { nkeynes@736: if( vid_ppl == vid_stride ) { /* Magic deinterlace */ nkeynes@736: fbuf.height = fbuf.height << 1; nkeynes@736: fbuf.rowstride = vid_ppl << 2; nkeynes@736: fbuf.address = MMIO_READ( PVR2, DISP_ADDR1 ); nkeynes@736: } else { nkeynes@736: /* Just display the field as is, folks. This is slightly tricky - nkeynes@736: * we pick the field based on which frame is about to come through, nkeynes@736: * which may not be the same as the odd_even_field. nkeynes@736: */ nkeynes@736: gboolean oddfield = pvr2_state.odd_even_field; nkeynes@736: if( pvr2_state.line_count >= pvr2_state.retrace_start_line ) { nkeynes@736: oddfield = !oddfield; nkeynes@736: } nkeynes@736: if( oddfield ) { nkeynes@736: fbuf.address = MMIO_READ( PVR2, DISP_ADDR1 ); nkeynes@736: } else { nkeynes@736: fbuf.address = MMIO_READ( PVR2, DISP_ADDR2 ); nkeynes@736: } nkeynes@736: } nkeynes@736: } else { nkeynes@736: fbuf.address = MMIO_READ( PVR2, DISP_ADDR1 ); nkeynes@736: } nkeynes@736: fbuf.address = (fbuf.address & 0x00FFFFFF) + PVR2_RAM_BASE; nkeynes@736: fbuf.inverted = FALSE; nkeynes@736: fbuf.data = video_base + (fbuf.address&0x00FFFFFF); nkeynes@352: nkeynes@736: render_buffer_t rbuf = pvr2_get_render_buffer( &fbuf ); nkeynes@736: if( rbuf == NULL ) { nkeynes@736: rbuf = pvr2_frame_buffer_to_render_buffer( &fbuf ); nkeynes@736: } nkeynes@736: displayed_render_buffer = rbuf; nkeynes@736: if( rbuf != NULL ) { nkeynes@736: display_driver->display_render_buffer( rbuf ); nkeynes@736: } nkeynes@1: } nkeynes@1: } nkeynes@1: nkeynes@197: /** nkeynes@197: * This has to handle every single register individually as they all get masked nkeynes@197: * off differently (and its easier to do it at write time) nkeynes@197: */ nkeynes@1: void mmio_region_PVR2_write( uint32_t reg, uint32_t val ) nkeynes@1: { nkeynes@1: if( reg >= 0x200 && reg < 0x600 ) { /* Fog table */ nkeynes@1: MMIO_WRITE( PVR2, reg, val ); nkeynes@1: return; nkeynes@1: } nkeynes@736: nkeynes@1: switch(reg) { nkeynes@189: case PVRID: nkeynes@189: case PVRVER: nkeynes@261: case GUNPOS: /* Read only registers */ nkeynes@736: break; nkeynes@197: case PVRRESET: nkeynes@736: val &= 0x00000007; /* Do stuff? */ nkeynes@736: MMIO_WRITE( PVR2, reg, val ); nkeynes@736: break; nkeynes@295: case RENDER_START: /* Don't really care what value */ nkeynes@736: if( save_next_render_filename != NULL ) { nkeynes@736: if( pvr2_render_save_scene(save_next_render_filename) == 0 ) { nkeynes@736: INFO( "Saved scene to %s", save_next_render_filename); nkeynes@736: } nkeynes@736: g_free( save_next_render_filename ); nkeynes@736: save_next_render_filename = NULL; nkeynes@736: } nkeynes@736: pvr2_scene_read(); nkeynes@736: render_buffer_t buffer = pvr2_next_render_buffer(); nkeynes@736: if( buffer != NULL ) { nkeynes@736: pvr2_scene_render( buffer ); nkeynes@856: pvr2_finish_render_buffer( buffer ); nkeynes@736: } nkeynes@736: asic_event( EVENT_PVR_RENDER_DONE ); nkeynes@736: break; nkeynes@191: case RENDER_POLYBASE: nkeynes@736: MMIO_WRITE( PVR2, reg, val&0x00F00000 ); nkeynes@736: break; nkeynes@191: case RENDER_TSPCFG: nkeynes@736: MMIO_WRITE( PVR2, reg, val&0x00010101 ); nkeynes@736: break; nkeynes@197: case DISP_BORDER: nkeynes@736: MMIO_WRITE( PVR2, reg, val&0x01FFFFFF ); nkeynes@736: break; nkeynes@197: case DISP_MODE: nkeynes@736: MMIO_WRITE( PVR2, reg, val&0x00FFFF7F ); nkeynes@736: break; nkeynes@191: case RENDER_MODE: nkeynes@736: MMIO_WRITE( PVR2, reg, val&0x00FFFF0F ); nkeynes@736: break; nkeynes@191: case RENDER_SIZE: nkeynes@736: MMIO_WRITE( PVR2, reg, val&0x000001FF ); nkeynes@736: break; nkeynes@197: case DISP_ADDR1: nkeynes@736: val &= 0x00FFFFFC; nkeynes@736: MMIO_WRITE( PVR2, reg, val ); nkeynes@736: pvr2_update_raster_posn(sh4r.slice_cycle); nkeynes@736: break; nkeynes@197: case DISP_ADDR2: nkeynes@736: MMIO_WRITE( PVR2, reg, val&0x00FFFFFC ); nkeynes@736: pvr2_update_raster_posn(sh4r.slice_cycle); nkeynes@736: break; nkeynes@197: case DISP_SIZE: nkeynes@736: MMIO_WRITE( PVR2, reg, val&0x3FFFFFFF ); nkeynes@736: break; nkeynes@191: case RENDER_ADDR1: nkeynes@191: case RENDER_ADDR2: nkeynes@736: MMIO_WRITE( PVR2, reg, val&0x01FFFFFC ); nkeynes@736: break; nkeynes@191: case RENDER_HCLIP: nkeynes@736: MMIO_WRITE( PVR2, reg, val&0x07FF07FF ); nkeynes@736: break; nkeynes@191: case RENDER_VCLIP: nkeynes@736: MMIO_WRITE( PVR2, reg, val&0x03FF03FF ); nkeynes@736: break; nkeynes@197: case DISP_HPOSIRQ: nkeynes@736: MMIO_WRITE( PVR2, reg, val&0x03FF33FF ); nkeynes@736: pvr2_state.irq_hpos_line = val & 0x03FF; nkeynes@736: pvr2_state.irq_hpos_time_ns = 2000000*((val>>16)&0x03FF)/pvr2_state.dot_clock; nkeynes@736: pvr2_state.irq_hpos_mode = (val >> 12) & 0x03; nkeynes@736: switch( pvr2_state.irq_hpos_mode ) { nkeynes@736: case 3: /* Reserved - treat as 0 */ nkeynes@736: case 0: /* Once per frame at specified line */ nkeynes@736: pvr2_state.irq_hpos_mode = HPOS_PER_FRAME; nkeynes@736: break; nkeynes@736: case 2: /* Once per line - as per-line-count */ nkeynes@736: pvr2_state.irq_hpos_line = 1; nkeynes@736: pvr2_state.irq_hpos_mode = 1; nkeynes@736: case 1: /* Once per N lines */ nkeynes@736: pvr2_state.irq_hpos_line_count = pvr2_state.irq_hpos_line; nkeynes@736: pvr2_state.irq_hpos_line = (pvr2_state.line_count >> 1) + nkeynes@736: pvr2_state.irq_hpos_line_count; nkeynes@736: while( pvr2_state.irq_hpos_line > (pvr2_state.total_lines>>1) ) { nkeynes@736: pvr2_state.irq_hpos_line -= (pvr2_state.total_lines>>1); nkeynes@736: } nkeynes@736: pvr2_state.irq_hpos_mode = HPOS_PER_LINECOUNT; nkeynes@736: } nkeynes@736: pvr2_schedule_scanline_event( EVENT_HPOS, pvr2_state.irq_hpos_line, 0, nkeynes@736: pvr2_state.irq_hpos_time_ns ); nkeynes@736: break; nkeynes@736: case DISP_VPOSIRQ: nkeynes@736: val = val & 0x03FF03FF; nkeynes@736: pvr2_state.irq_vpos1 = (val >> 16); nkeynes@736: pvr2_state.irq_vpos2 = val & 0x03FF; nkeynes@736: pvr2_update_raster_posn(sh4r.slice_cycle); nkeynes@736: pvr2_schedule_scanline_event( EVENT_SCANLINE1, pvr2_state.irq_vpos1, 0, 0 ); nkeynes@736: pvr2_schedule_scanline_event( EVENT_SCANLINE2, pvr2_state.irq_vpos2, 0, 0 ); nkeynes@736: MMIO_WRITE( PVR2, reg, val ); nkeynes@736: break; nkeynes@736: case RENDER_NEARCLIP: nkeynes@736: MMIO_WRITE( PVR2, reg, val & 0x7FFFFFFF ); nkeynes@736: break; nkeynes@736: case RENDER_SHADOW: nkeynes@736: MMIO_WRITE( PVR2, reg, val&0x000001FF ); nkeynes@736: break; nkeynes@736: case RENDER_OBJCFG: nkeynes@736: MMIO_WRITE( PVR2, reg, val&0x003FFFFF ); nkeynes@736: break; nkeynes@736: case RENDER_TSPCLIP: nkeynes@736: MMIO_WRITE( PVR2, reg, val&0x7FFFFFFF ); nkeynes@736: break; nkeynes@736: case RENDER_FARCLIP: nkeynes@736: MMIO_WRITE( PVR2, reg, val&0xFFFFFFF0 ); nkeynes@736: break; nkeynes@736: case RENDER_BGPLANE: nkeynes@736: MMIO_WRITE( PVR2, reg, val&0x1FFFFFFF ); nkeynes@736: break; nkeynes@736: case RENDER_ISPCFG: nkeynes@736: MMIO_WRITE( PVR2, reg, val&0x00FFFFF9 ); nkeynes@736: break; nkeynes@736: case VRAM_CFG1: nkeynes@736: MMIO_WRITE( PVR2, reg, val&0x000000FF ); nkeynes@736: break; nkeynes@736: case VRAM_CFG2: nkeynes@736: MMIO_WRITE( PVR2, reg, val&0x003FFFFF ); nkeynes@736: break; nkeynes@736: case VRAM_CFG3: nkeynes@736: MMIO_WRITE( PVR2, reg, val&0x1FFFFFFF ); nkeynes@736: break; nkeynes@736: case RENDER_FOGTBLCOL: nkeynes@736: case RENDER_FOGVRTCOL: nkeynes@736: MMIO_WRITE( PVR2, reg, val&0x00FFFFFF ); nkeynes@736: break; nkeynes@736: case RENDER_FOGCOEFF: nkeynes@736: MMIO_WRITE( PVR2, reg, val&0x0000FFFF ); nkeynes@736: break; nkeynes@736: case RENDER_CLAMPHI: nkeynes@736: case RENDER_CLAMPLO: nkeynes@736: MMIO_WRITE( PVR2, reg, val ); nkeynes@736: break; nkeynes@736: case RENDER_TEXSIZE: nkeynes@736: MMIO_WRITE( PVR2, reg, val&0x00031F1F ); nkeynes@736: break; nkeynes@736: case RENDER_PALETTE: nkeynes@736: MMIO_WRITE( PVR2, reg, val&0x00000003 ); nkeynes@736: break; nkeynes@736: case RENDER_ALPHA_REF: nkeynes@736: MMIO_WRITE( PVR2, reg, val&0x000000FF ); nkeynes@736: break; nkeynes@736: /********** CRTC registers *************/ nkeynes@736: case DISP_HBORDER: nkeynes@736: case DISP_VBORDER: nkeynes@736: MMIO_WRITE( PVR2, reg, val&0x03FF03FF ); nkeynes@736: break; nkeynes@736: case DISP_TOTAL: nkeynes@736: val = val & 0x03FF03FF; nkeynes@736: MMIO_WRITE( PVR2, reg, val ); nkeynes@736: pvr2_update_raster_posn(sh4r.slice_cycle); nkeynes@736: pvr2_state.total_lines = (val >> 16) + 1; nkeynes@736: pvr2_state.line_size = (val & 0x03FF) + 1; nkeynes@736: pvr2_state.line_time_ns = 1000000 * pvr2_state.line_size / pvr2_state.dot_clock; nkeynes@736: pvr2_state.retrace_end_line = 0x2A; nkeynes@736: pvr2_state.retrace_start_line = pvr2_state.total_lines - 6; nkeynes@736: pvr2_schedule_scanline_event( EVENT_SCANLINE1, pvr2_state.irq_vpos1, 0, 0 ); nkeynes@736: pvr2_schedule_scanline_event( EVENT_SCANLINE2, pvr2_state.irq_vpos2, 0, 0 ); nkeynes@736: pvr2_schedule_scanline_event( EVENT_HPOS, pvr2_state.irq_hpos_line, 0, nkeynes@736: pvr2_state.irq_hpos_time_ns ); nkeynes@736: break; nkeynes@736: case DISP_SYNCCFG: nkeynes@736: MMIO_WRITE( PVR2, reg, val&0x000003FF ); nkeynes@736: pvr2_state.interlaced = (val & 0x0010) ? TRUE : FALSE; nkeynes@736: break; nkeynes@736: case DISP_SYNCTIME: nkeynes@736: pvr2_state.vsync_lines = (val >> 8) & 0x0F; nkeynes@736: pvr2_state.hsync_width_ns = ((val & 0x7F) + 1) * 2000000 / pvr2_state.dot_clock; nkeynes@736: MMIO_WRITE( PVR2, reg, val&0xFFFFFF7F ); nkeynes@736: break; nkeynes@736: case DISP_CFG2: nkeynes@736: MMIO_WRITE( PVR2, reg, val&0x003F01FF ); nkeynes@736: break; nkeynes@736: case DISP_HPOS: nkeynes@736: val = val & 0x03FF; nkeynes@736: pvr2_state.front_porch_ns = (val + 1) * 1000000 / pvr2_state.dot_clock; nkeynes@736: MMIO_WRITE( PVR2, reg, val ); nkeynes@736: break; nkeynes@736: case DISP_VPOS: nkeynes@736: MMIO_WRITE( PVR2, reg, val&0x03FF03FF ); nkeynes@736: break; nkeynes@261: nkeynes@736: /*********** Tile accelerator registers ***********/ nkeynes@736: case TA_POLYPOS: nkeynes@736: case TA_LISTPOS: nkeynes@736: /* Readonly registers */ nkeynes@736: break; nkeynes@736: case TA_TILEBASE: nkeynes@736: case TA_LISTEND: nkeynes@736: case TA_LISTBASE: nkeynes@736: MMIO_WRITE( PVR2, reg, val&0x00FFFFE0 ); nkeynes@736: break; nkeynes@736: case RENDER_TILEBASE: nkeynes@736: case TA_POLYBASE: nkeynes@736: case TA_POLYEND: nkeynes@736: MMIO_WRITE( PVR2, reg, val&0x00FFFFFC ); nkeynes@736: break; nkeynes@736: case TA_TILESIZE: nkeynes@736: MMIO_WRITE( PVR2, reg, val&0x000F003F ); nkeynes@736: break; nkeynes@736: case TA_TILECFG: nkeynes@736: MMIO_WRITE( PVR2, reg, val&0x00133333 ); nkeynes@736: break; nkeynes@736: case TA_INIT: nkeynes@736: if( val & 0x80000000 ) nkeynes@736: pvr2_ta_init(); nkeynes@736: break; nkeynes@736: case TA_REINIT: nkeynes@736: break; nkeynes@736: /**************** Scaler registers? ****************/ nkeynes@736: case RENDER_SCALER: nkeynes@736: MMIO_WRITE( PVR2, reg, val&0x0007FFFF ); nkeynes@736: break; nkeynes@261: nkeynes@736: case YUV_ADDR: nkeynes@736: val = val & 0x00FFFFF8; nkeynes@736: MMIO_WRITE( PVR2, reg, val ); nkeynes@736: pvr2_yuv_init( val ); nkeynes@736: break; nkeynes@736: case YUV_CFG: nkeynes@736: MMIO_WRITE( PVR2, reg, val&0x01013F3F ); nkeynes@736: pvr2_yuv_set_config(val); nkeynes@736: break; nkeynes@261: nkeynes@736: /**************** Unknowns ***************/ nkeynes@736: case PVRUNK1: nkeynes@736: MMIO_WRITE( PVR2, reg, val&0x000007FF ); nkeynes@736: break; nkeynes@736: case PVRUNK2: nkeynes@736: MMIO_WRITE( PVR2, reg, val&0x00000007 ); nkeynes@736: break; nkeynes@736: case PVRUNK3: nkeynes@736: MMIO_WRITE( PVR2, reg, val&0x000FFF3F ); nkeynes@736: break; nkeynes@736: case PVRUNK5: nkeynes@736: MMIO_WRITE( PVR2, reg, val&0x0000FFFF ); nkeynes@736: break; nkeynes@736: case PVRUNK7: nkeynes@736: MMIO_WRITE( PVR2, reg, val&0x00000001 ); nkeynes@736: break; nkeynes@736: case PVRUNK8: nkeynes@736: MMIO_WRITE( PVR2, reg, val&0x0300FFFF ); nkeynes@736: break; nkeynes@1: } nkeynes@1: } nkeynes@1: nkeynes@261: /** nkeynes@261: * Calculate the current read value of the syncstat register, using nkeynes@261: * the current SH4 clock time as an offset from the last timeslice. nkeynes@261: * The register reads (LSB to MSB) as: nkeynes@261: * 0..9 Current scan line nkeynes@261: * 10 Odd/even field (1 = odd, 0 = even) nkeynes@261: * 11 Display active (including border and overscan) nkeynes@261: * 12 Horizontal sync off nkeynes@261: * 13 Vertical sync off nkeynes@261: * Note this method is probably incorrect for anything other than straight nkeynes@265: * interlaced PAL/NTSC, and needs further testing. nkeynes@261: */ nkeynes@261: uint32_t pvr2_get_sync_status() nkeynes@261: { nkeynes@265: pvr2_update_raster_posn(sh4r.slice_cycle); nkeynes@265: uint32_t result = pvr2_state.line_count; nkeynes@261: nkeynes@265: if( pvr2_state.odd_even_field ) { nkeynes@736: result |= 0x0400; nkeynes@261: } nkeynes@265: if( (pvr2_state.line_count & 0x01) == pvr2_state.odd_even_field ) { nkeynes@736: if( pvr2_state.line_remainder > pvr2_state.hsync_width_ns ) { nkeynes@736: result |= 0x1000; /* !HSYNC */ nkeynes@736: } nkeynes@736: if( pvr2_state.line_count >= pvr2_state.vsync_lines ) { nkeynes@736: if( pvr2_state.line_remainder > pvr2_state.front_porch_ns ) { nkeynes@736: result |= 0x2800; /* Display active */ nkeynes@736: } else { nkeynes@736: result |= 0x2000; /* Front porch */ nkeynes@736: } nkeynes@736: } nkeynes@261: } else { nkeynes@736: if( pvr2_state.line_count >= pvr2_state.vsync_lines ) { nkeynes@736: if( pvr2_state.line_remainder < (pvr2_state.line_time_ns - pvr2_state.back_porch_ns)) { nkeynes@736: result |= 0x3800; /* Display active */ nkeynes@736: } else { nkeynes@736: result |= 0x3000; nkeynes@736: } nkeynes@736: } else { nkeynes@736: result |= 0x1000; /* Back porch */ nkeynes@736: } nkeynes@261: } nkeynes@261: return result; nkeynes@261: } nkeynes@261: nkeynes@265: /** nkeynes@265: * Schedule a "scanline" event. This actually goes off at nkeynes@265: * 2 * line in even fields and 2 * line + 1 in odd fields. nkeynes@265: * Otherwise this behaves as per pvr2_schedule_line_event(). nkeynes@265: * The raster position should be updated before calling this nkeynes@265: * method. nkeynes@304: * @param eventid Event to fire at the specified time nkeynes@304: * @param line Line on which to fire the event (this is 2n/2n+1 for interlaced nkeynes@304: * displays). nkeynes@304: * @param hpos_ns Nanoseconds into the line at which to fire. nkeynes@265: */ nkeynes@304: static void pvr2_schedule_scanline_event( int eventid, int line, int minimum_lines, int hpos_ns ) nkeynes@265: { nkeynes@265: uint32_t field = pvr2_state.odd_even_field; nkeynes@265: if( line <= pvr2_state.line_count && pvr2_state.interlaced ) { nkeynes@736: field = !field; nkeynes@265: } nkeynes@304: if( hpos_ns > pvr2_state.line_time_ns ) { nkeynes@736: hpos_ns = pvr2_state.line_time_ns; nkeynes@304: } nkeynes@265: nkeynes@265: line <<= 1; nkeynes@265: if( field ) { nkeynes@736: line += 1; nkeynes@265: } nkeynes@736: nkeynes@274: if( line < pvr2_state.total_lines ) { nkeynes@736: uint32_t lines; nkeynes@736: uint32_t time; nkeynes@736: if( line <= pvr2_state.line_count ) { nkeynes@736: lines = (pvr2_state.total_lines - pvr2_state.line_count + line); nkeynes@736: } else { nkeynes@736: lines = (line - pvr2_state.line_count); nkeynes@736: } nkeynes@736: if( lines <= minimum_lines ) { nkeynes@736: lines += pvr2_state.total_lines; nkeynes@736: } nkeynes@736: time = (lines * pvr2_state.line_time_ns) - pvr2_state.line_remainder + hpos_ns; nkeynes@736: event_schedule( eventid, time ); nkeynes@274: } else { nkeynes@736: event_cancel( eventid ); nkeynes@274: } nkeynes@265: } nkeynes@265: nkeynes@850: void pvr2_queue_gun_event( int xpos, int ypos ) nkeynes@850: { nkeynes@850: pvr2_update_raster_posn(sh4r.slice_cycle); nkeynes@850: pvr2_schedule_scanline_event( EVENT_GUNPOS, (ypos >> 1) + pvr2_state.vsync_lines, 0, nkeynes@850: (1000000 * xpos / pvr2_state.dot_clock) + pvr2_state.hsync_width_ns ); nkeynes@850: } nkeynes@850: nkeynes@1: MMIO_REGION_READ_FN( PVR2, reg ) nkeynes@1: { nkeynes@1: switch( reg ) { nkeynes@736: case DISP_SYNCSTAT: nkeynes@736: return pvr2_get_sync_status(); nkeynes@736: default: nkeynes@736: return MMIO_READ( PVR2, reg ); nkeynes@1: } nkeynes@1: } nkeynes@19: nkeynes@337: MMIO_REGION_WRITE_FN( PVR2PAL, reg, val ) nkeynes@337: { nkeynes@337: MMIO_WRITE( PVR2PAL, reg, val ); nkeynes@337: pvr2_state.palette_changed = TRUE; nkeynes@337: } nkeynes@337: nkeynes@337: void pvr2_check_palette_changed() nkeynes@337: { nkeynes@337: if( pvr2_state.palette_changed ) { nkeynes@736: texcache_invalidate_palette(); nkeynes@736: pvr2_state.palette_changed = FALSE; nkeynes@337: } nkeynes@337: } nkeynes@337: nkeynes@337: MMIO_REGION_READ_DEFFN( PVR2PAL ); nkeynes@85: nkeynes@19: void pvr2_set_base_address( uint32_t base ) nkeynes@19: { nkeynes@197: mmio_region_PVR2_write( DISP_ADDR1, base ); nkeynes@19: } nkeynes@56: nkeynes@56: nkeynes@65: nkeynes@98: nkeynes@56: int32_t mmio_region_PVR2TA_read( uint32_t reg ) nkeynes@56: { nkeynes@56: return 0xFFFFFFFF; nkeynes@56: } nkeynes@56: nkeynes@56: void mmio_region_PVR2TA_write( uint32_t reg, uint32_t val ) nkeynes@56: { nkeynes@433: pvr2_ta_write( (unsigned char *)&val, sizeof(uint32_t) ); nkeynes@56: } nkeynes@56: nkeynes@856: render_buffer_t pvr2_create_render_buffer( sh4addr_t addr, int width, int height, GLuint tex_id ) nkeynes@856: { nkeynes@856: if( display_driver != NULL && display_driver->create_render_buffer != NULL ) { nkeynes@856: render_buffer_t buffer = display_driver->create_render_buffer(width,height,tex_id); nkeynes@856: buffer->address = addr; nkeynes@856: return buffer; nkeynes@856: } nkeynes@856: return NULL; nkeynes@856: } nkeynes@856: nkeynes@856: void pvr2_destroy_render_buffer( render_buffer_t buffer ) nkeynes@856: { nkeynes@856: if( !buffer->flushed ) nkeynes@856: pvr2_render_buffer_copy_to_sh4( buffer ); nkeynes@856: display_driver->destroy_render_buffer( buffer ); nkeynes@856: } nkeynes@856: nkeynes@856: void pvr2_finish_render_buffer( render_buffer_t buffer ) nkeynes@856: { nkeynes@856: display_driver->finish_render( buffer ); nkeynes@856: } nkeynes@856: nkeynes@352: /** nkeynes@352: * Find the render buffer corresponding to the requested output frame nkeynes@352: * (does not consider texture renders). nkeynes@352: * @return the render_buffer if found, or null if no such buffer. nkeynes@352: * nkeynes@352: * Note: Currently does not consider "partial matches", ie partial nkeynes@352: * frame overlap - it probably needs to do this. nkeynes@352: */ nkeynes@352: render_buffer_t pvr2_get_render_buffer( frame_buffer_t frame ) nkeynes@352: { nkeynes@352: int i; nkeynes@352: for( i=0; iaddress == frame->address ) { nkeynes@736: return render_buffers[i]; nkeynes@736: } nkeynes@352: } nkeynes@352: return NULL; nkeynes@352: } nkeynes@352: nkeynes@352: /** nkeynes@477: * Allocate a render buffer with the requested parameters. nkeynes@477: * The order of preference is: nkeynes@352: * 1. An existing buffer with the same address. (not flushed unless the new nkeynes@352: * size is smaller than the old one). nkeynes@352: * 2. An existing buffer with the same size chosen by LRU order. Old buffer nkeynes@352: * is flushed to vram. nkeynes@352: * 3. A new buffer if one can be created. nkeynes@352: * 4. The current display buff nkeynes@352: * Note: The current display field(s) will never be overwritten except as a last nkeynes@352: * resort. nkeynes@352: */ nkeynes@477: render_buffer_t pvr2_alloc_render_buffer( sh4addr_t render_addr, int width, int height ) nkeynes@352: { nkeynes@477: int i; nkeynes@352: render_buffer_t result = NULL; nkeynes@352: nkeynes@352: /* Check existing buffers for an available buffer */ nkeynes@352: for( i=0; iwidth == width && render_buffers[i]->height == height ) { nkeynes@736: /* needs to be the right dimensions */ nkeynes@736: if( render_buffers[i]->address == render_addr ) { nkeynes@736: if( displayed_render_buffer == render_buffers[i] ) { nkeynes@736: /* Same address, but we can't use it because the nkeynes@736: * display has it. Mark it as unaddressed for later. nkeynes@736: */ nkeynes@736: render_buffers[i]->address = -1; nkeynes@736: } else { nkeynes@736: /* perfect */ nkeynes@736: result = render_buffers[i]; nkeynes@736: break; nkeynes@736: } nkeynes@736: } else if( render_buffers[i]->address == -1 && result == NULL && nkeynes@736: displayed_render_buffer != render_buffers[i] ) { nkeynes@736: result = render_buffers[i]; nkeynes@736: } nkeynes@736: nkeynes@736: } else if( render_buffers[i]->address == render_addr ) { nkeynes@736: /* right address, wrong size - if it's larger, flush it, otherwise nkeynes@736: * nuke it quietly */ nkeynes@736: if( render_buffers[i]->width * render_buffers[i]->height > nkeynes@736: width*height ) { nkeynes@736: pvr2_render_buffer_copy_to_sh4( render_buffers[i] ); nkeynes@736: } nkeynes@736: render_buffers[i]->address = -1; nkeynes@736: } nkeynes@352: } nkeynes@352: nkeynes@352: /* Nothing available - make one */ nkeynes@352: if( result == NULL ) { nkeynes@736: if( render_buffer_count == MAX_RENDER_BUFFERS ) { nkeynes@736: /* maximum buffers reached - need to throw one away */ nkeynes@736: uint32_t field1_addr = MMIO_READ( PVR2, DISP_ADDR1 ); nkeynes@736: uint32_t field2_addr = MMIO_READ( PVR2, DISP_ADDR2 ); nkeynes@736: for( i=0; iaddress != field1_addr && nkeynes@736: render_buffers[i]->address != field2_addr && nkeynes@736: render_buffers[i] != displayed_render_buffer ) { nkeynes@736: /* Never throw away the current "front buffer(s)" */ nkeynes@736: result = render_buffers[i]; nkeynes@736: if( !result->flushed ) { nkeynes@736: pvr2_render_buffer_copy_to_sh4( result ); nkeynes@736: } nkeynes@736: if( result->width != width || result->height != height ) { nkeynes@736: display_driver->destroy_render_buffer(render_buffers[i]); nkeynes@805: result = display_driver->create_render_buffer(width,height,0); nkeynes@736: render_buffers[i] = result; nkeynes@736: } nkeynes@736: break; nkeynes@736: } nkeynes@736: } nkeynes@736: } else { nkeynes@805: result = display_driver->create_render_buffer(width,height,0); nkeynes@736: if( result != NULL ) { nkeynes@736: render_buffers[render_buffer_count++] = result; nkeynes@736: } nkeynes@736: } nkeynes@352: } nkeynes@352: nkeynes@477: if( result != NULL ) { nkeynes@736: result->address = render_addr; nkeynes@477: } nkeynes@352: return result; nkeynes@352: } nkeynes@352: nkeynes@352: /** nkeynes@477: * Allocate a render buffer based on the current rendering settings nkeynes@477: */ nkeynes@477: render_buffer_t pvr2_next_render_buffer() nkeynes@477: { nkeynes@477: render_buffer_t result = NULL; nkeynes@477: uint32_t render_addr = MMIO_READ( PVR2, RENDER_ADDR1 ); nkeynes@477: uint32_t render_mode = MMIO_READ( PVR2, RENDER_MODE ); nkeynes@477: uint32_t render_scale = MMIO_READ( PVR2, RENDER_SCALER ); nkeynes@477: uint32_t render_stride = MMIO_READ( PVR2, RENDER_SIZE ) << 3; nkeynes@477: nkeynes@856: int width = pvr2_scene_buffer_width(); nkeynes@856: int height = pvr2_scene_buffer_height(); nkeynes@856: int colour_format = render_colour_formats[render_mode&0x07]; nkeynes@856: nkeynes@477: if( render_addr & 0x01000000 ) { /* vram64 */ nkeynes@736: render_addr = (render_addr & 0x00FFFFFF) + PVR2_RAM_BASE_INT; nkeynes@856: result = texcache_get_render_buffer( render_addr, colour_format, width, height ); nkeynes@477: } else { /* vram32 */ nkeynes@736: render_addr = (render_addr & 0x00FFFFFF) + PVR2_RAM_BASE; nkeynes@856: result = pvr2_alloc_render_buffer( render_addr, width, height ); nkeynes@477: } nkeynes@477: nkeynes@477: /* Setup the buffer */ nkeynes@477: if( result != NULL ) { nkeynes@736: result->rowstride = render_stride; nkeynes@736: result->colour_format = colour_format; nkeynes@736: result->scale = render_scale; nkeynes@736: result->size = width * height * colour_formats[colour_format].bpp; nkeynes@736: result->flushed = FALSE; nkeynes@736: result->inverted = TRUE; // render buffers are inverted normally nkeynes@477: } nkeynes@477: return result; nkeynes@477: } nkeynes@477: nkeynes@477: static render_buffer_t pvr2_frame_buffer_to_render_buffer( frame_buffer_t frame ) nkeynes@477: { nkeynes@477: render_buffer_t result = pvr2_alloc_render_buffer( frame->address, frame->width, frame->height ); nkeynes@477: if( result != NULL ) { nkeynes@736: int bpp = colour_formats[frame->colour_format].bpp; nkeynes@736: result->rowstride = frame->rowstride; nkeynes@736: result->colour_format = frame->colour_format; nkeynes@736: result->scale = 0x400; nkeynes@736: result->size = frame->width * frame->height * bpp; nkeynes@736: result->flushed = TRUE; nkeynes@736: result->inverted = frame->inverted; nkeynes@736: display_driver->load_frame_buffer( frame, result ); nkeynes@477: } nkeynes@477: return result; nkeynes@477: } nkeynes@736: nkeynes@477: nkeynes@477: /** nkeynes@352: * Invalidate any caching on the supplied address. Specifically, if it falls nkeynes@352: * within any of the render buffers, flush the buffer back to PVR2 ram. nkeynes@352: */ nkeynes@352: gboolean pvr2_render_buffer_invalidate( sh4addr_t address, gboolean isWrite ) nkeynes@352: { nkeynes@352: int i; nkeynes@352: address = address & 0x1FFFFFFF; nkeynes@352: for( i=0; iaddress; nkeynes@736: if( bufaddr != -1 && bufaddr <= address && nkeynes@736: (bufaddr + render_buffers[i]->size) > address ) { nkeynes@736: if( !render_buffers[i]->flushed ) { nkeynes@736: pvr2_render_buffer_copy_to_sh4( render_buffers[i] ); nkeynes@736: } nkeynes@736: if( isWrite ) { nkeynes@736: render_buffers[i]->address = -1; /* Invalid */ nkeynes@736: } nkeynes@736: return TRUE; /* should never have overlapping buffers */ nkeynes@736: } nkeynes@352: } nkeynes@352: return FALSE; nkeynes@352: }