/* $XFree86: xc/programs/Xserver/hw/xfree86/drivers/nsc/gfx/rndr_gu1.c,v 1.2 2003/01/14 09:34:34 alanh Exp $ */ /* * $Workfile: rndr_gu1.c $ * * This file contains routines to program the 2D acceleration hardware for * the first generation graphics unit (GXLV, SC1200). * * gfx_set_bpp * gfx_set_solid_pattern * gfx_set_mono_pattern * gfx_set_color_pattern * gfx_set_solid_source * gfx_set_mono_source * gfx_set_raster_operation * gfx_pattern_fill * gfx_screen_to_screen_blt * gfx_screen_to_screen_xblt * gfx_color_bitmap_to_screen_blt * gfx_color_bitmap_to_screen_xblt * gfx_mono_bitmap_to_screen_blt * gfx_bresenham_line * gfx_wait_until_idle * * NSC_LIC_ALTERNATIVE_PREAMBLE * * Revision 1.0 * * National Semiconductor Alternative GPL-BSD License * * National Semiconductor Corporation licenses this software * ("Software"): * * Durango * * under one of the two following licenses, depending on how the * Software is received by the Licensee. * * If this Software is received as part of the Linux Framebuffer or * other GPL licensed software, then the GPL license designated * NSC_LIC_GPL applies to this Software; in all other circumstances * then the BSD-style license designated NSC_LIC_BSD shall apply. * * END_NSC_LIC_ALTERNATIVE_PREAMBLE */ /* NSC_LIC_BSD * * National Semiconductor Corporation Open Source License for Durango * * (BSD License with Export Notice) * * Copyright (c) 1999-2001 * National Semiconductor Corporation. * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * * * Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * * * Redistributions in binary form must reproduce the above * copyright notice, this list of conditions and the following * disclaimer in the documentation and/or other materials provided * with the distribution. * * * Neither the name of the National Semiconductor Corporation nor * the names of its contributors may be used to endorse or promote * products derived from this software without specific prior * written permission. * * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE * NATIONAL SEMICONDUCTOR CORPORATION OR CONTRIBUTORS BE LIABLE FOR ANY * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER * IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE, * INTELLECTUAL PROPERTY INFRINGEMENT, OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY * OF SUCH DAMAGE. * * EXPORT LAWS: THIS LICENSE ADDS NO RESTRICTIONS TO THE EXPORT LAWS OF * YOUR JURISDICTION. It is licensee's responsibility to comply with * any export regulations applicable in licensee's jurisdiction. Under * CURRENT (2001) U.S. export regulations this software * is eligible for export from the U.S. and can be downloaded by or * otherwise exported or reexported worldwide EXCEPT to U.S. embargoed * destinations which include Cuba, Iraq, Libya, North Korea, Iran, * Syria, Sudan, Afghanistan and any other country to which the U.S. * has embargoed goods and services. * * END_NSC_LIC_BSD */ /* NSC_LIC_GPL * * National Semiconductor Corporation Gnu General Public License for Durango * * (GPL License with Export Notice) * * Copyright (c) 1999-2001 * National Semiconductor Corporation. * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted under the terms of the GNU General * Public License as published by the Free Software Foundation; either * version 2 of the License, or (at your option) any later version * * In addition to the terms of the GNU General Public License, neither * the name of the National Semiconductor Corporation nor the names of * its contributors may be used to endorse or promote products derived * from this software without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE * NATIONAL SEMICONDUCTOR CORPORATION OR CONTRIBUTORS BE LIABLE FOR ANY * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER * IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE, * INTELLECTUAL PROPERTY INFRINGEMENT, OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY * OF SUCH DAMAGE. See the GNU General Public License for more details. * * EXPORT LAWS: THIS LICENSE ADDS NO RESTRICTIONS TO THE EXPORT LAWS OF * YOUR JURISDICTION. It is licensee's responsibility to comply with * any export regulations applicable in licensee's jurisdiction. Under * CURRENT (2001) U.S. export regulations this software * is eligible for export from the U.S. and can be downloaded by or * otherwise exported or reexported worldwide EXCEPT to U.S. embargoed * destinations which include Cuba, Iraq, Libya, North Korea, Iran, * Syria, Sudan, Afghanistan and any other country to which the U.S. * has embargoed goods and services. * * You should have received a copy of the GNU General Public License * along with this file; if not, write to the Free Software Foundation, * Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA * * END_NSC_LIC_GPL */ void gu1_set_bpp(unsigned short bpp); void gu1_set_solid_pattern(unsigned long color); void gu1_set_mono_pattern(unsigned long bgcolor, unsigned long fgcolor, unsigned long data0, unsigned long data1, unsigned char transparency); void gu1_set_color_pattern(unsigned long bgcolor, unsigned long fgcolor, unsigned long data0, unsigned long data1, unsigned long data2, unsigned long data3, unsigned char transparency); void gu1_load_color_pattern_line(short y, unsigned long *pattern_8x8); void gu1_set_solid_source(unsigned long color); void gu1_set_mono_source(unsigned long bgcolor, unsigned long fgcolor, unsigned short transparent); void gu1_set_pattern_flags(unsigned short flags); void gu1_set_raster_operation(unsigned char rop); void gu1_pattern_fill(unsigned short x, unsigned short y, unsigned short width, unsigned short height); void gu1_color_pattern_fill(unsigned short x, unsigned short y, unsigned short width, unsigned short height, unsigned long *pattern); void gu1_screen_to_screen_blt(unsigned short srcx, unsigned short srcy, unsigned short dstx, unsigned short dsty, unsigned short width, unsigned short height); void gu1_screen_to_screen_xblt(unsigned short srcx, unsigned short srcy, unsigned short dstx, unsigned short dsty, unsigned short width, unsigned short height, unsigned long color); void gu1_color_bitmap_to_screen_blt(unsigned short srcx, unsigned short srcy, unsigned short dstx, unsigned short dsty, unsigned short width, unsigned short height, unsigned char *data, long pitch); void gu1_color_bitmap_to_screen_xblt(unsigned short srcx, unsigned short srcy, unsigned short dstx, unsigned short dsty, unsigned short width, unsigned short height, unsigned char *data, long pitch, unsigned long color); void gu1_mono_bitmap_to_screen_blt(unsigned short srcx, unsigned short srcy, unsigned short dstx, unsigned short dsty, unsigned short width, unsigned short height, unsigned char *data, short pitch); void gu1_text_blt(unsigned short dstx, unsigned short dsty, unsigned short width, unsigned short height, unsigned char *data); void gu1_bresenham_line(unsigned short x, unsigned short y, unsigned short length, unsigned short initerr, unsigned short axialerr, unsigned short diagerr, unsigned short flags); void gu1_wait_until_idle(void); #if GFX_NO_IO_IN_WAIT_MACROS #define GFX_WAIT_PENDING while(READ_REG16(GP_BLIT_STATUS) & BS_BLIT_PENDING) { ; } #define GFX_WAIT_BUSY while(READ_REG16(GP_BLIT_STATUS) & BS_BLIT_BUSY) { ; } #define GFX_WAIT_PIPELINE while (READ_REG16(GP_BLIT_STATUS) & BS_PIPELINE_BUSY) { ; } #else #define GFX_WAIT_PENDING while(READ_REG16(GP_BLIT_STATUS) & BS_BLIT_PENDING) { INB (0x80); } #define GFX_WAIT_BUSY while(READ_REG16(GP_BLIT_STATUS) & BS_BLIT_BUSY) { INB (0x80); } #define GFX_WAIT_PIPELINE while (READ_REG16(GP_BLIT_STATUS) & BS_PIPELINE_BUSY) { INB (0x80); } #endif void gu1_detect_blt_buffer_base(void); int gu1_test_blt_pending(void); void gu1_solid_fill(unsigned short x, unsigned short y, unsigned short width, unsigned short height, unsigned long color); /*--------------------------------------------------------------------------- * GFX_SET_BPP * * This routine sets the bits per pixel value in the graphics engine. * It is also stored in a static variable to use in the future calls to * the rendering routines. *--------------------------------------------------------------------------- */ #if GFX_2DACCEL_DYNAMIC void gu1_set_bpp(unsigned short bpp) #else void gfx_set_bpp(unsigned short bpp) #endif { int control = 0; unsigned short pitch = gfx_get_display_pitch(); GFXbpp = bpp; /* DETECT BASE ADDRESSES FOR BLT BUFFERS */ /* Different for 2K or 3K of scratchpad. Also need to calculate */ /* the number of pixels that can fit in a BLT buffer - need to */ /* subtract 16 for alignment considerations. The 2K case, for */ /* example, is 816 bytes wide, allowing 800 pixels in 8 BPP, which */ /* means rendering operations won't be split for 800x600. */ gu1_detect_blt_buffer_base(); GFXbufferWidthPixels = GFXbb1Base - GFXbb0Base - 16; if (bpp > 8) { /* If 16bpp, divide GFXbufferWidthPixels by 2 */ GFXbufferWidthPixels >>= 1; } /* SET THE GRAPHICS CONTROLLER BPP AND PITCH */ if (bpp > 8) { /* Set the 16bpp bit if necessary */ control = BC_16BPP; } if ((gfx_cpu_version == GFX_CPU_PYRAMID) && (pitch > 2048)) { control |= BC_FB_WIDTH_4096; } else if (pitch > 1024) { control |= BC_FB_WIDTH_2048; } GFX_WAIT_BUSY; WRITE_REG32(GP_BLIT_STATUS, control); } /* //--------------------------------------------------------------------------- // GFX_SET_SOLID_SOURCE // // This routine is used to specify a solid source color. For the Xfree96 // display driver, the source color is used to specify a planemask and the // ROP is adjusted accordingly. //--------------------------------------------------------------------------- */ #if GFX_2DACCEL_DYNAMIC void gu1_set_solid_source(unsigned long color) #else void gfx_set_solid_source(unsigned long color) #endif { /* CLEAR TRANSPARENCY FLAG */ GFXsourceFlags = 0; /* FORMAT 8 BPP COLOR */ /* GX requires 8BPP color data be duplicated into bits [15:8]. */ if (GFXbpp == 8) { color &= 0x00FF; color |= (color << 8); } /* POLL UNTIL ABLE TO WRITE THE SOURCE COLOR */ GFX_WAIT_PENDING; WRITE_REG16(GP_SRC_COLOR_0, (unsigned short)color); WRITE_REG16(GP_SRC_COLOR_1, (unsigned short)color); } /* //--------------------------------------------------------------------------- // GFX_SET_MONO_SOURCE // // This routine is used to specify the monochrome source colors. // It must be called *after* loading any pattern data (those routines // clear the source flags). //--------------------------------------------------------------------------- */ #if GFX_2DACCEL_DYNAMIC void gu1_set_mono_source(unsigned long bgcolor, unsigned long fgcolor, unsigned short transparent) #else void gfx_set_mono_source(unsigned long bgcolor, unsigned long fgcolor, unsigned short transparent) #endif { /* SET TRANSPARENCY FLAG */ GFXsourceFlags = transparent ? RM_SRC_TRANSPARENT : 0; /* FORMAT 8 BPP COLOR */ /* GX requires 8BPP color data be duplicated into bits [15:8]. */ if (GFXbpp == 8) { bgcolor &= 0x00FF; bgcolor |= (bgcolor << 8); fgcolor &= 0x00FF; fgcolor |= (fgcolor << 8); } /* POLL UNTIL ABLE TO WRITE THE SOURCE COLOR */ GFX_WAIT_PENDING; WRITE_REG16(GP_SRC_COLOR_0, (unsigned short)bgcolor); WRITE_REG16(GP_SRC_COLOR_1, (unsigned short)fgcolor); } /* //--------------------------------------------------------------------------- // GFX_SET_SOLID_PATTERN // // This routine is used to specify a solid pattern color. It is called // before performing solid rectangle fills or more complicated BLTs that // use a solid pattern color. // // The driver should always call "gfx_load_raster_operation" after a call // to this routine to make sure that the pattern flags are set appropriately. //--------------------------------------------------------------------------- */ #if GFX_2DACCEL_DYNAMIC void gu1_set_solid_pattern(unsigned long color) #else void gfx_set_solid_pattern(unsigned long color) #endif { /* CLEAR TRANSPARENCY FLAG */ GFXsourceFlags = 0; /* SET PATTERN FLAGS */ GFXpatternFlags = 0; /* FORMAT 8 BPP COLOR */ /* GX requires 8BPP color data be duplicated into bits [15:8]. */ if (GFXbpp == 8) { color &= 0x00FF; color |= (color << 8); } /* SAVE THE REFORMATTED COLOR FOR LATER */ /* Used to call the "GFX_solid_fill" routine for special cases. */ GFXsavedColor = color; /* POLL UNTIL ABLE TO WRITE THE PATTERN COLOR */ GFX_WAIT_PENDING; WRITE_REG16(GP_PAT_COLOR_0, (unsigned short)color); } /* //--------------------------------------------------------------------------- // GFX_SET_MONO_PATTERN // // This routine is used to specify a monochrome pattern. //--------------------------------------------------------------------------- */ #if GFX_2DACCEL_DYNAMIC void gu1_set_mono_pattern(unsigned long bgcolor, unsigned long fgcolor, unsigned long data0, unsigned long data1, unsigned char transparent) #else void gfx_set_mono_pattern(unsigned long bgcolor, unsigned long fgcolor, unsigned long data0, unsigned long data1, unsigned char transparent) #endif { /* CLEAR TRANSPARENCY FLAG */ GFXsourceFlags = 0; /* SET PATTERN FLAGS */ GFXpatternFlags = transparent ? RM_PAT_MONO | RM_PAT_TRANSPARENT : RM_PAT_MONO; /* FORMAT 8 BPP COLOR */ /* GXm requires 8BPP color data be duplicated into bits [15:8]. */ if (GFXbpp == 8) { bgcolor &= 0x00FF; bgcolor |= (bgcolor << 8); fgcolor &= 0x00FF; fgcolor |= (fgcolor << 8); } /* POLL UNTIL ABLE TO WRITE THE PATTERN COLORS AND DATA */ GFX_WAIT_PENDING; WRITE_REG16(GP_PAT_COLOR_0, (unsigned short)bgcolor); WRITE_REG16(GP_PAT_COLOR_1, (unsigned short)fgcolor); WRITE_REG32(GP_PAT_DATA_0, data0); WRITE_REG32(GP_PAT_DATA_1, data1); } /* //--------------------------------------------------------------------------- // GFX_SET_COLOR_PATTERN // // This routine is used to specify a color pattern. //--------------------------------------------------------------------------- */ #if GFX_2DACCEL_DYNAMIC void gu1_set_color_pattern(unsigned long bgcolor, unsigned long fgcolor, unsigned long data0, unsigned long data1, unsigned long data2, unsigned long data3, unsigned char transparent) #else void gfx_set_color_pattern(unsigned long bgcolor, unsigned long fgcolor, unsigned long data0, unsigned long data1, unsigned long data2, unsigned long data3, unsigned char transparent) #endif { /* CLEAR TRANSPARENCY FLAG */ GFXsourceFlags = 0; /* SET PATTERN FLAGS */ GFXpatternFlags = transparent ? RM_PAT_MONO | RM_PAT_TRANSPARENT : RM_PAT_MONO; GFXpatternFlags |= RM_PAT_COLOR; /* FORMAT 8 BPP COLOR */ /* GXm requires 8BPP color data be duplicated into bits [15:8]. */ if (GFXbpp == 8) { bgcolor &= 0x00FF; bgcolor |= (bgcolor << 8); fgcolor &= 0x00FF; fgcolor |= (fgcolor << 8); } /* POLL UNTIL ABLE TO WRITE THE PATTERN COLORS AND DATA */ GFX_WAIT_PENDING; WRITE_REG16(GP_PAT_COLOR_0, (unsigned short)bgcolor); WRITE_REG16(GP_PAT_COLOR_1, (unsigned short)fgcolor); WRITE_REG32(GP_PAT_DATA_0, data0); WRITE_REG32(GP_PAT_DATA_1, data1); if (GFXbpp > 8) { WRITE_REG32(GP_PAT_DATA_2, data2); WRITE_REG32(GP_PAT_DATA_3, data3); } } /* //--------------------------------------------------------------------------- // GFX_LOAD_COLOR_PATTERN_LINE // // This routine is used to load a single line of a 8x8 color pattern. //--------------------------------------------------------------------------- */ #if GFX_2DACCEL_DYNAMIC void gu1_load_color_pattern_line(short y, unsigned long *pattern_8x8) #else void gfx_load_color_pattern_line(short y, unsigned long *pattern_8x8) #endif { /* CLEAR TRANSPARENCY FLAG */ GFXsourceFlags = 0; /* SET PATTERN FLAGS */ GFXpatternFlags = RM_PAT_COLOR; y &= 7; if (GFXbpp > 8) pattern_8x8 += (y << 2); else pattern_8x8 += (y << 1); /* POLL UNTIL ABLE TO WRITE THE PATTERN COLORS AND DATA */ GFX_WAIT_PENDING; WRITE_REG32(GP_PAT_DATA_0, pattern_8x8[0]); WRITE_REG32(GP_PAT_DATA_1, pattern_8x8[1]); if (GFXbpp > 8) { WRITE_REG32(GP_PAT_DATA_2, pattern_8x8[2]); WRITE_REG32(GP_PAT_DATA_3, pattern_8x8[3]); } } /* //--------------------------------------------------------------------------- // GFX_SET_RASTER_OPERATION // // This routine loads the specified raster operation. It sets the pattern // flags appropriately. //--------------------------------------------------------------------------- */ #if GFX_2DACCEL_DYNAMIC void gu1_set_raster_operation(unsigned char rop) #else void gfx_set_raster_operation(unsigned char rop) #endif { unsigned short rop16; /* GENERATE 16-BIT VERSION OF ROP WITH PATTERN FLAGS */ rop16 = (unsigned short)rop | GFXpatternFlags; if ((rop & 0x33) ^ ((rop >> 2) & 0x33)) rop16 |= GFXsourceFlags; /* SAVE ROP FOR LATER COMPARISONS */ /* Need to have the pattern flags included */ GFXsavedRop = rop16; /* SET FLAG INDICATING ROP REQUIRES DESTINATION DATA */ /* True if even bits (0:2:4:6) do not equal the correspinding */ /* even bits (1:3:5:7). */ GFXusesDstData = ((rop & 0x55) ^ ((rop >> 1) & 0x55)); /* POLL UNTIL ABLE TO WRITE THE PATTERN COLOR */ /* Only one operation can be pending at a time. */ GFX_WAIT_PENDING; WRITE_REG16(GP_RASTER_MODE, rop16); } /* //--------------------------------------------------------------------------- // GFX_SOLID_FILL // // This routine MUST be used when performing a solid rectangle fill with // the ROPs of PATCOPY (0xF0), BLACKNESS (0x00), WHITENESS (0xFF), or // PATINVERT (0x0F). There is a bug in GXm for these cases that requires a // workaround. // // For BLACKNESS (ROP = 0x00), set the color to 0x0000. // For WHITENESS (ROP = 0xFF), set the color to 0xFFFF. // For PATINVERT (ROP = 0x0F), invert the desired color. // // X screen X position (left) // Y screen Y position (top) // WIDTH width of rectangle, in pixels // HEIGHT height of rectangle, in scanlines // COLOR fill color // // THIS ROUTINE SHOULD NOT BE DIRECTLY CALLED FROM THE DRIVER. The driver // should always use GFX_pattern_fill and let that routine call this one // when approipriate. This is to hide quirks specific to MediaGX hardware. //--------------------------------------------------------------------------- */ void gu1_solid_fill(unsigned short x, unsigned short y, unsigned short width, unsigned short height, unsigned long color) { unsigned short section; /* POLL UNTIL ABLE TO WRITE TO THE REGISTERS */ /* Only one operation can be pending at a time. */ GFX_WAIT_PENDING; /* SET REGISTERS TO DRAW RECTANGLE */ WRITE_REG16(GP_DST_XCOOR, x); WRITE_REG16(GP_DST_YCOOR, y); WRITE_REG16(GP_HEIGHT, height); WRITE_REG16(GP_RASTER_MODE, 0x00F0); /* PATCOPY */ WRITE_REG16(GP_PAT_COLOR_0, (unsigned short)color); /* CHECK WIDTH FOR GX BUG WORKAROUND */ if (width <= 16) { /* OK TO DRAW SMALL RECTANGLE IN ONE PASS */ WRITE_REG16(GP_WIDTH, width); WRITE_REG16(GP_BLIT_MODE, 0); } else { /* DRAW FIRST PART OF RECTANGLE */ /* Get to a 16 pixel boundary. */ section = 0x10 - (x & 0x0F); WRITE_REG16(GP_WIDTH, section); WRITE_REG16(GP_BLIT_MODE, 0); /* POLL UNTIL ABLE TO LOAD THE SECOND RECTANGLE */ GFX_WAIT_PENDING; WRITE_REG16(GP_DST_XCOOR, x + section); WRITE_REG16(GP_DST_YCOOR, y); WRITE_REG16(GP_WIDTH, width - section); WRITE_REG16(GP_BLIT_MODE, 0); } } /* //---------------------------------------------------------------------------- // GFX_PATTERN_FILL // // This routine is used to fill a rectangular region. The pattern must // be previously loaded using one of GFX_load_*_pattern routines. Also, the // raster operation must be previously specified using the // "GFX_load_raster_operation" routine. // // X screen X position (left) // Y screen Y position (top) // WIDTH width of rectangle, in pixels // HEIGHT height of rectangle, in scanlines //---------------------------------------------------------------------------- */ #if GFX_2DACCEL_DYNAMIC void gu1_pattern_fill(unsigned short x, unsigned short y, unsigned short width, unsigned short height) #else void gfx_pattern_fill(unsigned short x, unsigned short y, unsigned short width, unsigned short height) #endif { unsigned short section, buffer_width, blit_mode; /* CHECK IF OPTIMIZED SOLID CASES */ /* Check all 16 bits of the ROP to include solid pattern flags. */ switch (GFXsavedRop) { /* CHECK FOR SPECIAL CASES WITHOUT DESTINATION DATA */ /* Need hardware workaround for fast "burst write" cases. */ case 0x00F0: gu1_solid_fill(x, y, width, height, (unsigned short)GFXsavedColor); break; case 0x000F: gu1_solid_fill(x, y, width, height, (unsigned short)~GFXsavedColor); break; case 0x0000: gu1_solid_fill(x, y, width, height, 0x0000); break; case 0x00FF: gu1_solid_fill(x, y, width, height, 0xFFFF); break; /* REMAINING CASES REQUIRE DESTINATION DATA OR NOT SOLID COLOR */ default: /* DETERMINE BLT MODE VALUE */ /* Still here for non-solid patterns without destination data. */ blit_mode = GFXusesDstData ? BM_READ_DST_FB0 : 0; /* SET SOURCE EXPANSION MODE */ /* If the ROP requires source data, then the source data is all 1's */ /* and then expanded into the desired color in GP_SRC_COLOR_1. */ blit_mode |= BM_SOURCE_EXPAND; /* POLL UNTIL ABLE TO WRITE TO THE REGISTERS */ /* Write the registers that do not change for each section. */ GFX_WAIT_PENDING; WRITE_REG16(GP_HEIGHT, height); /* SINCE ONLY DESTINATION DATA, WE CAN USE BOTH BB0 AND BB1. */ /* Therefore, width available = BLT buffer width * 2. */ buffer_width = GFXbufferWidthPixels << 1; /* REPEAT UNTIL FINISHED WITH RECTANGLE */ /* Perform BLT in vertical sections, as wide as the BLT buffer */ /* allows. Hardware does not split the operations, so */ /* software must do it to avoid large scanlines that would */ /* overflow the BLT buffers. */ while (width > 0) { /* DETERMINE WIDTH OF SECTION */ if (width > buffer_width) section = buffer_width; else section = width; /* POLL UNTIL ABLE TO WRITE TO THE REGISTERS */ GFX_WAIT_PENDING; WRITE_REG16(GP_DST_XCOOR, x); WRITE_REG16(GP_DST_YCOOR, y); WRITE_REG16(GP_WIDTH, section); WRITE_REG16(GP_BLIT_MODE, blit_mode); /* ADJUST PARAMETERS FOR NEXT SECTION */ width -= section; x += section; } break; } } /* //---------------------------------------------------------------------------- // GFX_COLOR_PATTERN_FILL // // This routine is used to render a rectangle using the current raster // operation and the specified color pattern. It allows an 8x8 color // pattern to be rendered without multiple calls to the gfx_set_color_pattern // and gfx_pattern_fill routines. // // X screen X position (left) // Y screen Y position (top) // WIDTH width of rectangle, in pixels // HEIGHT height of rectangle, in scanlines // *PATTERN pointer to 8x8 color pattern data //---------------------------------------------------------------------------- */ #if GFX_2DACCEL_DYNAMIC void gu1_color_pattern_fill(unsigned short x, unsigned short y, unsigned short width, unsigned short height, unsigned long *pattern) #else void gfx_color_pattern_fill(unsigned short x, unsigned short y, unsigned short width, unsigned short height, unsigned long *pattern) #endif { unsigned short blit_mode, passes, cur_y, pat_y, i; unsigned short buffer_width, line_width; unsigned short bpp_shift, section, cur_x; /* SET APPROPRIATE INCREMENT */ bpp_shift = (GFXbpp > 8) ? 2 : 1; /* SET DESTINATION REQUIRED */ blit_mode = GFXusesDstData ? BM_READ_DST_FB0 : 0; /* SET SOURCE EXPANSION */ blit_mode |= BM_SOURCE_EXPAND; /* OVERRIDE RASTER MODE TO FORCE A COLOR PATTERN */ GFX_WAIT_PENDING; WRITE_REG16(GP_RASTER_MODE, (GFXsavedRop & ~RM_PAT_MASK & ~RM_PAT_TRANSPARENT) | RM_PAT_COLOR); /* WRITE THE REGISTERS THAT DO NOT CHANGE */ /* If destination data is required, the width and */ /* x position will be overwritten. */ WRITE_REG16(GP_HEIGHT, 1); WRITE_REG16(GP_WIDTH, width); WRITE_REG16(GP_DST_XCOOR, x); /* THE ENTIRE PATTERN WILL NOT BE DRAWN IF THE HEIGHT IS LESS THAN 8 */ passes = (height < 8) ? height : 8; /* SINCE ONLY DESTINATION DATA, WE CAN USE BOTH BB0 AND BB1. */ /* Therefore, width available = BLT buffer width * 2. */ buffer_width = GFXbufferWidthPixels << 1; for (i = 0; i < passes; i++) { pat_y = ((y + i) & 7) << bpp_shift; cur_y = y + i; /* WRITE THE PATTERN DATA FOR THE ACTIVE LINE */ GFX_WAIT_PENDING; WRITE_REG32(GP_PAT_DATA_0, pattern[pat_y]); WRITE_REG32(GP_PAT_DATA_1, pattern[pat_y + 1]); if (GFXbpp > 8) { WRITE_REG32(GP_PAT_DATA_2, pattern[pat_y + 2]); WRITE_REG32(GP_PAT_DATA_3, pattern[pat_y + 3]); } /* SPLIT BLT LINE INTO SECTIONS IF REQUIRED */ /* If no destination data is required, we can ignore */ /* the BLT buffers. Otherwise, we must separate the BLT */ /* so as not to overflow the buffers */ if (blit_mode & BM_READ_DST_BB0) { line_width = width; cur_x = x; while (line_width) { section = (line_width > buffer_width) ? buffer_width : line_width; cur_y = y + i; GFX_WAIT_PENDING; WRITE_REG16(GP_DST_XCOOR, cur_x); WRITE_REG16(GP_WIDTH, section); while (cur_y < y + height) { GFX_WAIT_PENDING; WRITE_REG16(GP_DST_YCOOR, cur_y); WRITE_REG16(GP_BLIT_MODE, blit_mode); cur_y += 8; } cur_x += section; line_width -= section; } } else { while (cur_y < y + height) { GFX_WAIT_PENDING; WRITE_REG16(GP_DST_YCOOR, cur_y); WRITE_REG16(GP_BLIT_MODE, blit_mode); cur_y += 8; } } } /* RESTORE ORIGINAL ROP AND FLAGS */ GFX_WAIT_PENDING; WRITE_REG16(GP_RASTER_MODE, GFXsavedRop); } /* //---------------------------------------------------------------------------- // SCREEN TO SCREEN BLT // // This routine should be used to perform a screen to screen BLT when the // ROP does not require destination data. // // SRCX screen X position to copy from // SRCY screen Y position to copy from // DSTX screen X position to copy to // DSTY screen Y position to copy to // WIDTH width of rectangle, in pixels // HEIGHT height of rectangle, in scanlines //---------------------------------------------------------------------------- */ #if GFX_2DACCEL_DYNAMIC void gu1_screen_to_screen_blt(unsigned short srcx, unsigned short srcy, unsigned short dstx, unsigned short dsty, unsigned short width, unsigned short height) #else void gfx_screen_to_screen_blt(unsigned short srcx, unsigned short srcy, unsigned short dstx, unsigned short dsty, unsigned short width, unsigned short height) #endif { unsigned short section, buffer_width; unsigned short blit_mode; /* CHECK IF RASTER OPERATION REQUIRES DESTINATION DATA */ blit_mode = GFXusesDstData ? BM_READ_DST_FB1 | BM_READ_SRC_FB : BM_READ_SRC_FB; /* CHECK Y DIRECTION */ /* Hardware has support for negative Y direction. */ if (dsty > srcy) { blit_mode |= BM_REVERSE_Y; srcy += height - 1; dsty += height - 1; } /* CHECK X DIRECTION */ /* Hardware does not support negative X direction since at the time */ /* of development all supported resolutions could fit a scanline of */ /* data at once into the BLT buffers (using both BB0 and BB1). This */ /* code is more generic to allow for any size BLT buffer. */ if (dstx > srcx) { srcx += width; dstx += width; } /* POLL UNTIL ABLE TO WRITE TO THE REGISTERS */ /* Write the registers that do not change for each section. */ GFX_WAIT_PENDING; WRITE_REG16(GP_HEIGHT, height); /* CHECK AVAILABLE BLT BUFFER SIZE */ /* Can use both BLT buffers if no destination data is required. */ buffer_width = GFXusesDstData ? GFXbufferWidthPixels : GFXbufferWidthPixels << 1; /* REPEAT UNTIL FINISHED WITH RECTANGLE */ /* Perform BLT in vertical sections, as wide as the BLT buffer allows. */ /* Hardware does not split the operations, so software must do it to */ /* avoid large scanlines that would overflow the BLT buffers. */ while (width > 0) { /* CHECK WIDTH OF CURRENT SECTION */ if (width > buffer_width) section = buffer_width; else section = width; /* PROGRAM REGISTERS THAT ARE THE SAME FOR EITHER X DIRECTION */ GFX_WAIT_PENDING; WRITE_REG16(GP_SRC_YCOOR, srcy); WRITE_REG16(GP_DST_YCOOR, dsty); WRITE_REG16(GP_WIDTH, section); /* CHECK X DIRECTION */ if (dstx > srcx) { /* NEGATIVE X DIRECTION */ /* Still positive X direction within the section. */ srcx -= section; dstx -= section; WRITE_REG16(GP_SRC_XCOOR, srcx); WRITE_REG16(GP_DST_XCOOR, dstx); WRITE_REG16(GP_BLIT_MODE, blit_mode); } else { /* POSITIVE X DIRECTION */ WRITE_REG16(GP_SRC_XCOOR, srcx); WRITE_REG16(GP_DST_XCOOR, dstx); WRITE_REG16(GP_BLIT_MODE, blit_mode); dstx += section; srcx += section; } width -= section; } } /* //---------------------------------------------------------------------------- // SCREEN TO SCREEN TRANSPARENT BLT // // This routine should be used to perform a screen to screen BLT when a // specified color should by transparent. The only supported ROP is SRCCOPY. // // SRCX screen X position to copy from // SRCY screen Y position to copy from // DSTX screen X position to copy to // DSTY screen Y position to copy to // WIDTH width of rectangle, in pixels // HEIGHT height of rectangle, in scanlines // COLOR transparent color //---------------------------------------------------------------------------- */ #if GFX_2DACCEL_DYNAMIC void gu1_screen_to_screen_xblt(unsigned short srcx, unsigned short srcy, unsigned short dstx, unsigned short dsty, unsigned short width, unsigned short height, unsigned long color) #else void gfx_screen_to_screen_xblt(unsigned short srcx, unsigned short srcy, unsigned short dstx, unsigned short dsty, unsigned short width, unsigned short height, unsigned long color) #endif { unsigned short section, buffer_width; unsigned short blit_mode = BM_READ_SRC_FB; /* CHECK Y DIRECTION */ /* Hardware has support for negative Y direction. */ if (dsty > srcy) { blit_mode |= BM_REVERSE_Y; srcy += height - 1; dsty += height - 1; } /* CHECK X DIRECTION */ /* Hardware does not support negative X direction since at the time */ /* of development all supported resolutions could fit a scanline of */ /* data at once into the BLT buffers (using both BB0 and BB1). This */ /* code is more generic to allow for any size BLT buffer. */ if (dstx > srcx) { srcx += width; dstx += width; } /* CALCULATE BLT BUFFER SIZE */ /* Need to use BB1 to store the BLT buffer data. */ buffer_width = GFXbufferWidthPixels; /* WRITE TRANSPARENCY COLOR TO BLT BUFFER 1 */ if (GFXbpp == 8) { color &= 0x00FF; color |= (color << 8); } color = (color & 0x0000FFFF) | (color << 16); /* WAIT UNTIL PIPELINE IS NOT BUSY BEFORE LOADING DATA INTO BB1 */ /* Need to make sure any previous BLT using BB1 is complete. */ /* Only need to load 32 bits of BB1 for the 1 pixel BLT that follows. */ GFX_WAIT_BUSY; WRITE_SCRATCH32(GFXbb1Base, color); /* DO BOGUS BLT TO LATCH DATA FROM BB1 */ /* Already know graphics pipeline is idle. */ /* Only need to latch data into the holding registers for the current */ /* data from BB1. A 1 pixel wide BLT will suffice. */ WRITE_REG32(GP_DST_XCOOR, 0); WRITE_REG32(GP_SRC_XCOOR, 0); WRITE_REG32(GP_WIDTH, 0x00010001); WRITE_REG16(GP_RASTER_MODE, 0x00CC); WRITE_REG16(GP_BLIT_MODE, BM_READ_SRC_FB | BM_READ_DST_BB1); /* WRITE REGISTERS FOR REAL SCREEN TO SCREEN BLT */ GFX_WAIT_PENDING; WRITE_REG16(GP_HEIGHT, height); WRITE_REG16(GP_RASTER_MODE, 0x10C6); WRITE_REG32(GP_PAT_COLOR_0, 0xFFFFFFFF); /* REPEAT UNTIL FINISHED WITH RECTANGLE */ /* Perform BLT in vertical sections, as wide as the BLT buffer allows. */ /* Hardware does not split the operations, so software must do it to */ /* avoid large scanlines that would overflow the BLT buffers. */ while (width > 0) { /* CHECK WIDTH OF CURRENT SECTION */ if (width > buffer_width) section = buffer_width; else section = width; /* PROGRAM REGISTERS THAT ARE THE SAME FOR EITHER X DIRECTION */ GFX_WAIT_PENDING; WRITE_REG16(GP_SRC_YCOOR, srcy); WRITE_REG16(GP_DST_YCOOR, dsty); WRITE_REG16(GP_WIDTH, section); /* CHECK X DIRECTION */ /* Again, this must be done in software, and can be removed if the */ /* display driver knows that the BLT buffers will always be large */ /* enough to contain an entire scanline of a screen to screen BLT. */ if (dstx > srcx) { /* NEGATIVE X DIRECTION */ /* Still positive X direction within the section. */ srcx -= section; dstx -= section; WRITE_REG16(GP_SRC_XCOOR, srcx); WRITE_REG16(GP_DST_XCOOR, dstx); WRITE_REG16(GP_BLIT_MODE, blit_mode); } else { /* POSITIVE X DIRECTION */ WRITE_REG16(GP_SRC_XCOOR, srcx); WRITE_REG16(GP_DST_XCOOR, dstx); WRITE_REG16(GP_BLIT_MODE, blit_mode); dstx += section; srcx += section; } width -= section; } } /* //---------------------------------------------------------------------------- // COLOR BITMAP TO SCREEN BLT // // This routine transfers color bitmap data to the screen. For most cases, // when the ROP is SRCCOPY, it may be faster to write a separate routine that // copies the data to the frame buffer directly. This routine should be // used when the ROP requires destination data. // // Transparency is handled by another routine. // // SRCX X offset within source bitmap // SRCY Y offset within source bitmap // DSTX screen X position to render data // DSTY screen Y position to render data // WIDTH width of rectangle, in pixels // HEIGHT height of rectangle, in scanlines // *DATA pointer to bitmap data // PITCH pitch of bitmap data (bytes between scanlines) //---------------------------------------------------------------------------- */ #if GFX_2DACCEL_DYNAMIC void gu1_color_bitmap_to_screen_blt(unsigned short srcx, unsigned short srcy, unsigned short dstx, unsigned short dsty, unsigned short width, unsigned short height, unsigned char *data, long pitch) #else void gfx_color_bitmap_to_screen_blt(unsigned short srcx, unsigned short srcy, unsigned short dstx, unsigned short dsty, unsigned short width, unsigned short height, unsigned char *data, long pitch) #endif { unsigned short section, buffer_width; unsigned short blit_mode = BM_READ_SRC_BB0; unsigned short temp_height; unsigned long dword_bytes_needed, bytes_extra; unsigned long bpp_shift; long array_offset; /* CHECK SIZE OF BLT BUFFER */ buffer_width = GFXbufferWidthPixels; /* CHECK IF RASTER OPERATION REQUIRES DESTINATION DATA */ /* If no destination data, we have twice the room for */ /* source data. */ if (GFXusesDstData) blit_mode |= BM_READ_DST_FB1; else buffer_width <<= 1; /* SET THE SCRATCHPAD BASE */ SET_SCRATCH_BASE(GFXbb0Base); /* POLL UNTIL ABLE TO WRITE TO THE REGISTERS */ /* Write the registers that do not change for each section. */ GFX_WAIT_PENDING; WRITE_REG16(GP_HEIGHT, 1); bpp_shift = (GFXbpp + 7) >> 4; while (width > 0) { if (width > buffer_width) section = buffer_width; else section = width; dword_bytes_needed = (section << bpp_shift) & ~3l; bytes_extra = (section << bpp_shift) & 3l; temp_height = height; /* WRITE THE REGISTERS FOR EACH SECTION */ /* The GX hardware will auto-increment the Y coordinate, meaning */ /* that we don't have to. */ WRITE_REG16(GP_WIDTH, section); WRITE_REG16(GP_DST_XCOOR, dstx); WRITE_REG16(GP_DST_YCOOR, dsty); /* CALCULATE THE BITMAP OFFSET */ array_offset = (unsigned long)srcy *(long)pitch + ((long)srcx << bpp_shift); while (temp_height--) { GFX_WAIT_PIPELINE; /* WRITE ALL DATA TO THE BLT BUFFERS */ /* The WRITE_SCRATCH_STRING macro assumes that the data begins at the */ /* scratchpad offset set by the SET_SCRATCH_BASE macro. */ WRITE_SCRATCH_STRING(dword_bytes_needed, bytes_extra, data, array_offset); WRITE_REG16(GP_BLIT_MODE, blit_mode); array_offset += pitch; } width -= section; srcx += section; dstx += section; } } /* //---------------------------------------------------------------------------- // COLOR BITMAP TO SCREEN TRANSPARENT BLT // // This routine transfers color bitmap data to the screen with transparency. // The transparent color is specified. The only supported ROP is SRCCOPY, // meaning that transparency cannot be applied if the ROP requires // destination data (this is a hardware restriction). // // SRCX X offset within source bitmap // SRCY Y offset within source bitmap // DSTX screen X position to render data // DSTY screen Y position to render data // WIDTH width of rectangle, in pixels // HEIGHT height of rectangle, in scanlines // *DATA pointer to bitmap data // PITCH pitch of bitmap data (bytes between scanlines) // COLOR transparent color //---------------------------------------------------------------------------- */ #if GFX_2DACCEL_DYNAMIC void gu1_color_bitmap_to_screen_xblt(unsigned short srcx, unsigned short srcy, unsigned short dstx, unsigned short dsty, unsigned short width, unsigned short height, unsigned char *data, long pitch, unsigned long color) #else void gfx_color_bitmap_to_screen_xblt(unsigned short srcx, unsigned short srcy, unsigned short dstx, unsigned short dsty, unsigned short width, unsigned short height, unsigned char *data, long pitch, unsigned long color) #endif { unsigned short section, buffer_width; unsigned short temp_height; unsigned long dword_bytes_needed, bytes_extra; unsigned long bpp_shift; long array_offset; /* CHECK SIZE OF BLT BUFFER */ buffer_width = GFXbufferWidthPixels; /* WRITE TRANSPARENCY COLOR TO BLT BUFFER 1 */ if (GFXbpp == 8) { color &= 0x00FF; color |= (color << 8); } color = (color & 0x0000FFFF) | (color << 16); /* WAIT UNTIL PIPELINE IS NOT BUSY BEFORE LOADING DATA INTO BB1 */ /* Need to make sure any previous BLT using BB1 is complete. */ /* Only need to load 32 bits of BB1 for the 1 pixel BLT that follows. */ GFX_WAIT_PIPELINE; GFX_WAIT_PENDING; WRITE_SCRATCH32(GFXbb1Base, color); /* DO BOGUS BLT TO LATCH DATA FROM BB1 */ /* Already know graphics pipeline is idle. */ /* Only need to latch data into the holding registers for the current */ /* data from BB1. A 1 pixel wide BLT will suffice. */ WRITE_REG32(GP_DST_XCOOR, 0); WRITE_REG32(GP_SRC_XCOOR, 0); WRITE_REG32(GP_WIDTH, 0x00010001); WRITE_REG16(GP_RASTER_MODE, 0x00CC); WRITE_REG16(GP_BLIT_MODE, BM_READ_SRC_FB | BM_READ_DST_BB1); /* POLL UNTIL ABLE TO WRITE TO THE REGISTERS */ /* Write the registers that do not change for each section. */ GFX_WAIT_PENDING; WRITE_REG16(GP_HEIGHT, 1); WRITE_REG16(GP_RASTER_MODE, 0x10C6); WRITE_REG32(GP_PAT_COLOR_0, 0xFFFFFFFF); bpp_shift = (GFXbpp + 7) >> 4; /* SET THE SCRATCHPAD BASE */ SET_SCRATCH_BASE(GFXbb0Base); while (width > 0) { if (width > buffer_width) section = buffer_width; else section = width; dword_bytes_needed = (section << bpp_shift) & ~3l; bytes_extra = (section << bpp_shift) & 3l; temp_height = height; /* WRITE THE REGISTERS FOR EACH SECTION */ /* The GX hardware will auto-increment the Y coordinate, meaning */ /* that we don't have to. */ WRITE_REG16(GP_WIDTH, section); WRITE_REG16(GP_DST_XCOOR, dstx); WRITE_REG16(GP_DST_YCOOR, dsty); /* CALCULATE THE BITMAP OFFSET */ array_offset = (unsigned long)srcy *(long)pitch + ((long)srcx << bpp_shift); while (temp_height--) { GFX_WAIT_PIPELINE; /* WRITE ALL DATA TO THE BLT BUFFERS */ /* The WRITE_SCRATCH_STRING macro assumes that the data begins at the */ /* scratchpad offset set by the SET_SCRATCH_BASE macro. */ WRITE_SCRATCH_STRING(dword_bytes_needed, bytes_extra, data, array_offset); WRITE_REG16(GP_BLIT_MODE, BM_READ_SRC_BB0); array_offset += pitch; } width -= section; srcx += section; dstx += section; } } /* //---------------------------------------------------------------------------- // MONOCHROME BITMAP TO SCREEN BLT // // This routine transfers monochrome bitmap data to the screen. // // SRCX X offset within source bitmap // SRCY Y offset within source bitmap // DSTX screen X position to render data // DSTY screen Y position to render data // WIDTH width of rectangle, in pixels // HEIGHT height of rectangle, in scanlines // *DATA pointer to bitmap data // PITCH pitch of bitmap data (bytes between scanlines) //---------------------------------------------------------------------------- */ #if GFX_2DACCEL_DYNAMIC void gu1_mono_bitmap_to_screen_blt(unsigned short srcx, unsigned short srcy, unsigned short dstx, unsigned short dsty, unsigned short width, unsigned short height, unsigned char *data, short pitch) #else void gfx_mono_bitmap_to_screen_blt(unsigned short srcx, unsigned short srcy, unsigned short dstx, unsigned short dsty, unsigned short width, unsigned short height, unsigned char *data, short pitch) #endif { unsigned short section, buffer_width; unsigned short blit_mode = BM_READ_SRC_BB0 | BM_SOURCE_EXPAND; unsigned short temp_height; unsigned long dword_bytes_needed, bytes_extra; long array_offset; /* CHECK IF RASTER OPERATION REQUIRES DESTINATION DATA */ /* If no destination data, the source data will always fit. */ /* So, in that event we will set the buffer width to a */ /* fictitiously large value such that the BLT is never split. */ if (GFXusesDstData) { buffer_width = GFXbufferWidthPixels; blit_mode |= BM_READ_DST_FB1; } else buffer_width = 3200; /* CHECK IF DATA ALREADY IN BLIT BUFFER */ /* If the pointer is NULL, data for the full BLT is already there */ /* WARNING: This could cause problems if destination data is */ /* involved and it overflows the BLT buffer. Need to remove */ /* this option and change the drivers to use a temporary buffer. */ if (!data) { GFX_WAIT_PENDING; WRITE_REG16(GP_SRC_XCOOR, srcx & 7); WRITE_REG16(GP_DST_XCOOR, dstx); WRITE_REG16(GP_DST_YCOOR, dsty); WRITE_REG16(GP_WIDTH, width); WRITE_REG16(GP_HEIGHT, height); WRITE_REG16(GP_BLIT_MODE, blit_mode); return; } /* SET THE SCRATCHPAD BASE */ SET_SCRATCH_BASE(GFXbb0Base); /* POLL UNTIL ABLE TO WRITE TO THE REGISTERS */ /* Write the registers that do not change for each section. */ GFX_WAIT_PENDING; WRITE_REG16(GP_HEIGHT, 1); while (width > 0) { if (width > buffer_width) section = buffer_width; else section = width; /* CALCULATE BYTES NEEDED */ /* Add 1 for possible alignment issues. */ dword_bytes_needed = ((section + 7 + (srcx & 7)) >> 3) & ~3l; bytes_extra = ((section + 7 + (srcx & 7)) >> 3) & 3l; temp_height = height; /* WRITE THE REGISTERS FOR EACH SECTION */ /* The GX hardware will auto-increment the Y coordinate, meaning */ /* that we don't have to. */ WRITE_REG16(GP_WIDTH, section); WRITE_REG16(GP_DST_XCOOR, dstx); WRITE_REG16(GP_DST_YCOOR, dsty); WRITE_REG16(GP_SRC_XCOOR, srcx & 7); /* CALCULATE THE BITMAP OFFSET */ array_offset = (unsigned long)srcy *(long)pitch + ((long)srcx >> 3); while (temp_height--) { GFX_WAIT_PIPELINE; /* WRITE ALL DATA TO THE BLT BUFFERS */ /* The WRITE_SCRATCH_STRING macro assumes that the data begins at the */ /* scratchpad offset set by the SET_SCRATCH_BASE macro. */ WRITE_SCRATCH_STRING(dword_bytes_needed, bytes_extra, data, array_offset); WRITE_REG16(GP_BLIT_MODE, blit_mode); array_offset += pitch; } width -= section; srcx += section; dstx += section; } } /* //---------------------------------------------------------------------------- // MONOCHROME TEXT BLT // // This routine transfers contiguous monochrome text data to the screen. // // DSTX screen X position to render data // DSTY screen Y position to render data // WIDTH width of rectangle, in pixels // HEIGHT height of rectangle, in scanlines // *DATA pointer to bitmap data //---------------------------------------------------------------------------- */ #if GFX_2DACCEL_DYNAMIC void gu1_text_blt(unsigned short dstx, unsigned short dsty, unsigned short width, unsigned short height, unsigned char *data) #else void gfx_text_blt(unsigned short dstx, unsigned short dsty, unsigned short width, unsigned short height, unsigned char *data) #endif { unsigned long dword_bytes_needed, bytes_extra; long pitch, buffer_bytes, data_bytes; /* CALCULATE DATA SIZE */ pitch = (width + 7) >> 3; data_bytes = (long)height *pitch; /* CHECK FOR SIMPLE CASE */ /* This routine is designed to render a source copy text glyph. If destination */ /* data is required or the source data will not fit, we will punt the operation */ /* to the more versatile (and slow) mono bitmap routine. */ if (GFXbpp > 8) buffer_bytes = GFXbufferWidthPixels << 1; else buffer_bytes = GFXbufferWidthPixels; if (GFXusesDstData || data_bytes > buffer_bytes) { gfx_mono_bitmap_to_screen_blt(0, 0, dstx, dsty, width, height, data, (short)pitch); return; } /* SET THE SCRATCHPAD BASE */ SET_SCRATCH_BASE(GFXbb0Base); /* POLL UNTIL ABLE TO WRITE TO THE REGISTERS */ dword_bytes_needed = data_bytes & ~3l; bytes_extra = data_bytes & 3l; GFX_WAIT_PENDING; WRITE_REG16(GP_HEIGHT, height); WRITE_REG16(GP_WIDTH, width); WRITE_REG16(GP_DST_XCOOR, dstx); WRITE_REG16(GP_DST_YCOOR, dsty); WRITE_REG16(GP_SRC_XCOOR, 0); /* WRITE ALL DATA TO THE BLT BUFFERS */ /* The WRITE_SCRATCH_STRING macro assumes that the data begins at the */ /* scratchpad offset set by the SET_SCRATCH_BASE macro. */ GFX_WAIT_PIPELINE; WRITE_SCRATCH_STRING(dword_bytes_needed, bytes_extra, data, 0); WRITE_REG16(GP_BLIT_MODE, BM_READ_SRC_BB0 | BM_SOURCE_TEXT); } /* //---------------------------------------------------------------------------- // BRESENHAM LINE // // This routine draws a vector using the specified Bresenham parameters. // Currently this file does not support a routine that accepts the two // endpoints of a vector and calculates the Bresenham parameters. If it // ever does, this routine is still required for vectors that have been // clipped. // // X screen X position to start vector // Y screen Y position to start vector // LENGTH length of the vector, in pixels // INITERR Bresenham initial error term // AXIALERR Bresenham axial error term // DIAGERR Bresenham diagonal error term // FLAGS VM_YMAJOR, VM_MAJOR_INC, VM_MINOR_INC //---------------------------------------------------------------------------- */ #if GFX_2DACCEL_DYNAMIC void gu1_bresenham_line(unsigned short x, unsigned short y, unsigned short length, unsigned short initerr, unsigned short axialerr, unsigned short diagerr, unsigned short flags) #else void gfx_bresenham_line(unsigned short x, unsigned short y, unsigned short length, unsigned short initerr, unsigned short axialerr, unsigned short diagerr, unsigned short flags) #endif { unsigned short vector_mode = flags; if (GFXusesDstData) vector_mode |= VM_READ_DST_FB; /* CHECK NULL LENGTH */ if (!length) return; /* LOAD THE REGISTERS FOR THE VECTOR */ GFX_WAIT_PENDING; WRITE_REG16(GP_DST_XCOOR, x); WRITE_REG16(GP_DST_YCOOR, y); WRITE_REG16(GP_VECTOR_LENGTH, length); WRITE_REG16(GP_INIT_ERROR, initerr); WRITE_REG16(GP_AXIAL_ERROR, axialerr); WRITE_REG16(GP_DIAG_ERROR, diagerr); WRITE_REG16(GP_VECTOR_MODE, vector_mode); } /*--------------------------------------------------------------------------- * GFX_WAIT_UNTIL_IDLE * * This routine waits until the graphics engine is idle. This is required * before allowing direct access to the frame buffer. *--------------------------------------------------------------------------- */ #if GFX_2DACCEL_DYNAMIC void gu1_wait_until_idle(void) #else void gfx_wait_until_idle(void) #endif { GFX_WAIT_BUSY; } /*--------------------------------------------------------------------------- * GFX_TEST_BLT_PENDING * * This routine returns 1 if a BLT is pending, meaning that a call to * perform a rendering operation would stall. Otherwise it returns 0. * It is used by Darwin during random testing to only start a BLT * operation when it knows the Durango routines won't spin on graphics * (so Darwin can continue to do frame buffer reads and writes). *--------------------------------------------------------------------------- */ #if GFX_2DACCEL_DYNAMIC int gu1_test_blt_pending(void) #else int gfx_test_blt_pending(void) #endif { if (READ_REG16(GP_BLIT_STATUS) & BS_BLIT_PENDING) return (1); else return (0); } /*--------------------------------------------------------------------------- * BLT BUFFERS!!!!! *--------------------------------------------------------------------------- */ /* THE BOOT CODE MUST SET THE BLT BUFFER BASES USING THE "CPU_WRITE" */ /* INSTRUCTION TO ONE OF THE FOLLOWING VALUES: */ #define BB0_BASE_2K 0x800 #define BB1_BASE_2K 0xB30 #define BB0_BASE_3K 0x400 #define BB1_BASE_3K 0x930 /*--------------------------------------------------------------------------- * gu1_detect_blt_buffer_base * * This detection is hidden from the driver by being called from the * "gfx_set_bpp" routine. * * This is fairly ugly for the following reasons: * * - It is the boot code that must set the BLT buffer bases to the * appropriate values and load the scratchpad tags. * - The old drivers would also set the base address values to what they * knew they should be for the 2K or 3K scratchpad configuration. * - Unfortunately, to set the base addresses requires the use of the * CPU_WRITE instruction, an instruction specific to GX. * - Using the CPU_WRITE instruction requires the use of assembly to * produce the appropriate op codes. * - Assembly is something that is avoided in Durango because it is not * platform independent. Some compilers do not support inline assembly. * - Therefore Durango cannot use the CPU_WRITE instruction. * - Therefore drivers using Durango must rely on the boot code to set * the appropriate values. Durango uses this routine to check where * the base addresses have been set. * - Unfortunately, it is not as simple as using IO to check for 2K or 3K * scratchpad size. In VSA1, even though the boot code may set it for * 3K, SoftVGA comes along and resets it to 2K for it's use in text * redraws. It used to be that the display driver would set it back * to 3K. * - So, the Durango code was changed to just always use 2K. * - But, the XpressROM code sets it for 3K, and the newer versions of * SoftVGA do not interfere with that, so then Durango needs to use * the 3K values to work properly. * - Therefore, Durango does somewhat of a kludge by writing to directly * to the scratchpad at both the 2K and 3K locations, then performing * a unobtrusive BLT that loads data into BB0 (the graphics engine * always knows the true base). After the BLT, Durango looks to see * which location changed to know where the base address is. * - This is a relatively simple way to allow Durango to work on old * and new platforms without using theCPU_WRITE instructions. * * To summarize, the BLT buffers are one of the most painful aspects of * the GX graphics unit design, and have been removed from future designs * (the graphics unit has its own dedicated RAM). Durango has tried to * hide the BLT buffer use from the drivers. *--------------------------------------------------------------------------- */ void gu1_detect_blt_buffer_base(void) { /* ASSUME 2K */ GFXbb0Base = BB0_BASE_2K; GFXbb1Base = BB1_BASE_2K; /* CHECK IF SCRATCHPAD IS SET TO 3K OR 4K */ /* Boot code should still set 3K values for 4K. */ if (gfx_gxm_config_read(GXM_CONFIG_GCR) & 0x08) { /* WRITE DATA TO 3K LOCATION */ GFX_WAIT_BUSY; WRITE_SCRATCH32(BB0_BASE_3K, 0xFEEDFACE); /* HAVE THE GRAPHICS UNIT STORE SOMETHING IN BB0 */ WRITE_REG32(GP_DST_XCOOR, 0x00000000); /* AT (0,0) */ WRITE_REG32(GP_WIDTH, 0x00010004); /* 4x1 BLT */ WRITE_REG16(GP_RASTER_MODE, 0x00AA); /* KEEP DST */ WRITE_REG16(GP_BLIT_MODE, BM_READ_DST_FB0); /* STORE IN BB0 */ /* CHECK 3K LOCATION */ /* Breaks if data happened to be 0xFEEDFACE - unlikely. */ GFX_WAIT_BUSY; if (READ_SCRATCH32(BB0_BASE_3K) != 0xFEEDFACE) { GFXbb0Base = BB0_BASE_3K; GFXbb1Base = BB1_BASE_3K; } } } /* END OF FILE */