/* Copyright (c) 2005 Advanced Micro Devices, Inc. * * Permission is hereby granted, free of charge, to any person obtaining a copy * of this software and associated documentation files (the "Software"), to * deal in the Software without restriction, including without limitation the * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or * sell copies of the Software, and to permit persons to whom the Software is * furnished to do so, subject to the following conditions: * * The above copyright notice and this permission notice shall be included in * all copies or substantial portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS * IN THE SOFTWARE. * * Neither the name of the Advanced Micro Devices, Inc. nor the names of its * contributors may be used to endorse or promote products derived from this * software without specific prior written permission. * */ /* * This file contains routines to control the CS5530 video overlay hardware. */ /*---------------------------------------------------------------------------- * CS5530 PLL TABLE *---------------------------------------------------------------------------- */ typedef struct tagCS5530PLLENTRY { long frequency; /* 16.16 fixed point frequency */ unsigned long pll_value; /* associated register value */ } CS5530PLLENTRY; CS5530PLLENTRY CS5530_PLLtable[] = { {0x00192CCC, 0x31C45801,}, /* 25.1750 */ {0x001C526E, 0x20E36802,}, /* 28.3220 */ {0x001F8000, 0x33915801,}, /* 31.5000 */ {0x00240000, 0x31EC4801,}, /* 36.0000 */ {0x00258000, 0x21E22801,}, /* 37.5000 */ {0x00280000, 0x33088801,}, /* 40.0000 */ {0x002CE666, 0x33E22801,}, /* 44.9000 */ {0x00318000, 0x336C4801,}, /* 49.5000 */ {0x00320000, 0x23088801,}, /* 50.0000 */ {0x00325999, 0x23088801,}, /* 50.3500 */ {0x00360000, 0x3708A801,}, /* 54.0000 */ {0x00384000, 0x23E36802,}, /* 56.2500 */ {0x0038643F, 0x23E36802,}, /* 56.3916 */ {0x0038A4DD, 0x23E36802,}, /* 56.6444 */ {0x003B0000, 0x37C45801,}, /* 59.0000 */ {0x003F0000, 0x23EC4801,}, /* 63.0000 */ {0x00410000, 0x37911801,}, /* 65.0000 */ {0x00438000, 0x37963803,}, /* 67.5000 */ {0x0046CCCC, 0x37058803,}, /* 70.8000 */ {0x00480000, 0x3710C805,}, /* 72.0000 */ {0x004B0000, 0x37E22801,}, /* 75.0000 */ {0x004EC000, 0x27915801,}, /* 78.7500 */ {0x00500000, 0x37D8D802,}, /* 80.0000 */ {0x0059CCCC, 0x27588802,}, /* 89.8000 */ {0x005E8000, 0x27EC4802,}, /* 94.5000 */ {0x00630000, 0x27AC6803,}, /* 99.0000 */ {0x00640000, 0x27088801,}, /* 100.0000 */ {0x006C0000, 0x2710C805,}, /* 108.0000 */ {0x00708000, 0x27E36802,}, /* 112.5000 */ {0x00820000, 0x27C58803,}, /* 130.0000 */ {0x00870000, 0x27316803,}, /* 135.0000 */ {0x009D8000, 0x2F915801,}, /* 157.5000 */ {0x00A20000, 0x2F08A801,}, /* 162.0000 */ {0x00AF0000, 0x2FB11802,}, /* 175.0000 */ {0x00BD0000, 0x2FEC4802,}, /* 189.0000 */ {0x00CA0000, 0x2F963803,}, /* 202.0000 */ {0x00E80000, 0x2FB1B802,}, /* 232.0000 */ }; #define NUM_CS5530_FREQUENCIES sizeof(CS5530_PLLtable)/sizeof(CS5530PLLENTRY) /*--------------------------------------------------------------------------- * gfx_set_crt_enable * * This routine enables or disables the CRT output from the video processor. *--------------------------------------------------------------------------- */ #if GFX_VIDEO_DYNAMIC int cs5530_set_crt_enable(int enable) #else int gfx_set_crt_enable(int enable) #endif { unsigned long config; config = READ_VID32(CS5530_DISPLAY_CONFIG); switch (enable) { case CRT_DISABLE: /* Disable everything */ WRITE_VID32(CS5530_DISPLAY_CONFIG, config & ~(CS5530_DCFG_DIS_EN | CS5530_DCFG_HSYNC_EN | CS5530_DCFG_VSYNC_EN | CS5530_DCFG_DAC_BL_EN | CS5530_DCFG_DAC_PWDNX)); break; case CRT_ENABLE: /* Enable CRT display, including display logic */ WRITE_VID32(CS5530_DISPLAY_CONFIG, config | CS5530_DCFG_DIS_EN | CS5530_DCFG_HSYNC_EN | CS5530_DCFG_VSYNC_EN | CS5530_DCFG_DAC_BL_EN | CS5530_DCFG_DAC_PWDNX); break; case CRT_STANDBY: /* HSync:Off VSync:On */ WRITE_VID32(CS5530_DISPLAY_CONFIG, (config & ~(CS5530_DCFG_DIS_EN | CS5530_DCFG_HSYNC_EN | CS5530_DCFG_DAC_BL_EN | CS5530_DCFG_DAC_PWDNX)) | CS5530_DCFG_VSYNC_EN); break; case CRT_SUSPEND: /* HSync:On VSync:Off */ WRITE_VID32(CS5530_DISPLAY_CONFIG, (config & ~(CS5530_DCFG_DIS_EN | CS5530_DCFG_VSYNC_EN | CS5530_DCFG_DAC_BL_EN | CS5530_DCFG_DAC_PWDNX)) | CS5530_DCFG_HSYNC_EN); break; default: return (GFX_STATUS_BAD_PARAMETER); } return (GFX_STATUS_OK); } /*--------------------------------------------------------------------------- * gfx_reset_video (PRIVATE ROUTINE: NOT PART OF DURANGO API) * * This routine is used to disable all components of video overlay before * performing a mode switch. *--------------------------------------------------------------------------- */ #if GFX_VIDEO_DYNAMIC void cs5530_reset_video(void) #else void gfx_reset_video(void) #endif { gfx_set_video_enable(0); /* CLEAR THE DISPLAY BUFFER SIZE TO ZERO */ /* During a modeset,if FIFO load is enabled with a large buffer size, */ /* the FIFO can hang. To prevent this, we set the buffer size to zero */ /* and wait for this new size to be latched */ gfx_set_display_video_size(0, 0); if (gfx_test_timing_active()) { while (!gfx_test_vertical_active()); while (gfx_test_vertical_active()); while (!gfx_test_vertical_active()); while (gfx_test_vertical_active()); } } /*---------------------------------------------------------------------------- * gfx_set_display_control (PRIVATE ROUTINE: NOT PART OF DURANGO API) * * This routine configures the display output. * * "sync_polarities" is used to set the polarities of the sync pulses * according to the following mask: * * Bit 0: If set to 1, negative horizontal polarity is programmed, * otherwise positive horizontal polarity is programmed. * Bit 1: If set to 1, negative vertical polarity is programmed, * otherwise positive vertical polarity is programmed. * *---------------------------------------------------------------------------- */ #if GFX_VIDEO_DYNAMIC int cs5530_set_display_control(int sync_polarities) #else int gfx_set_display_control(int sync_polarities) #endif { unsigned long dcfg; /* ENABLE DISPLAY OUTPUT FROM CX5530 */ dcfg = READ_VID32(CS5530_DISPLAY_CONFIG); /* CLEAR RELEVANT FIELDS */ dcfg &= ~(CS5530_DCFG_CRT_SYNC_SKW_MASK | CS5530_DCFG_PWR_SEQ_DLY_MASK | CS5530_DCFG_CRT_HSYNC_POL | CS5530_DCFG_CRT_VSYNC_POL | CS5530_DCFG_FP_PWR_EN | CS5530_DCFG_FP_DATA_EN); /* INITIALIZATION */ dcfg |= (CS5530_DCFG_CRT_SYNC_SKW_INIT | CS5530_DCFG_PWR_SEQ_DLY_INIT | CS5530_DCFG_GV_PAL_BYP); if (PanelEnable) { dcfg |= CS5530_DCFG_FP_PWR_EN; dcfg |= CS5530_DCFG_FP_DATA_EN; } /* SET APPROPRIATE SYNC POLARITIES */ if (sync_polarities & 1) dcfg |= CS5530_DCFG_CRT_HSYNC_POL; if (sync_polarities & 2) dcfg |= CS5530_DCFG_CRT_VSYNC_POL; WRITE_VID32(CS5530_DISPLAY_CONFIG, dcfg); return (0); } /*--------------------------------------------------------------------------- * gfx_set_clock_frequency * * This routine sets the clock frequency, specified as a 16.16 fixed point * value (0x00318000 = 49.5 MHz). It will set the closest frequency found * in the lookup table. *--------------------------------------------------------------------------- */ #if GFX_VIDEO_DYNAMIC void cs5530_set_clock_frequency(unsigned long frequency) #else void gfx_set_clock_frequency(unsigned long frequency) #endif { unsigned int index; unsigned long value; long min, diff; /* FIND THE REGISTER VALUES FOR THE DESIRED FREQUENCY */ /* Search the table for the closest frequency (16.16 format). */ value = CS5530_PLLtable[0].pll_value; min = (long) CS5530_PLLtable[0].frequency - frequency; if (min < 0L) min = -min; for (index = 1; index < NUM_CS5530_FREQUENCIES; index++) { diff = (long) CS5530_PLLtable[index].frequency - frequency; if (diff < 0L) diff = -diff; if (diff < min) { min = diff; value = CS5530_PLLtable[index].pll_value; } } /* SET THE DOT CLOCK REGISTER */ WRITE_VID32(CS5530_DOT_CLK_CONFIG, value); WRITE_VID32(CS5530_DOT_CLK_CONFIG, value | 0x80000100); /* set reset/bypass */ gfx_delay_milliseconds(1); /* wait for PLL to settle */ WRITE_VID32(CS5530_DOT_CLK_CONFIG, value & 0x7FFFFFFF); /* clear reset */ WRITE_VID32(CS5530_DOT_CLK_CONFIG, value & 0x7FFFFEFF); /* clear bypass */ return; } /*---------------------------------------------------------------------------- * gfx_set_video_enable * * This routine enables or disables the video overlay functionality. *---------------------------------------------------------------------------- */ #if GFX_VIDEO_DYNAMIC int cs5530_set_video_enable(int enable) #else int gfx_set_video_enable(int enable) #endif { unsigned long vcfg; /* WAIT FOR VERTICAL BLANK TO START */ /* Otherwise a glitch can be observed. */ if (gfx_test_timing_active()) { if (!gfx_test_vertical_active()) { while (!gfx_test_vertical_active()); } while (gfx_test_vertical_active()); } vcfg = READ_VID32(CS5530_VIDEO_CONFIG); if (enable) { /* SET CS5530 BUS CONTROL PARAMETERS */ /* Currently always high speed, 8-bit interface. */ vcfg |= CS5530_VCFG_HIGH_SPD_INT; vcfg &= ~(CS5530_VCFG_EARLY_VID_RDY | CS5530_VCFG_16_BIT_EN); /* ENABLE CS5530 VIDEO OVERLAY */ vcfg |= CS5530_VCFG_VID_EN; WRITE_VID32(CS5530_VIDEO_CONFIG, vcfg); } else { /* DISABLE CS5530 VIDEO OVERLAY */ vcfg &= ~CS5530_VCFG_VID_EN; WRITE_VID32(CS5530_VIDEO_CONFIG, vcfg); } return (0); } /*---------------------------------------------------------------------------- * gfx_set_video_format * * Currently only sets 4:2:0 format, Y1 V Y0 U. *---------------------------------------------------------------------------- */ #if GFX_VIDEO_DYNAMIC int cs5530_set_video_format(unsigned long format) #else int gfx_set_video_format(unsigned long format) #endif { unsigned long vcfg = 0; /* SET THE CS5530 VIDEO INPUT FORMAT */ vcfg = READ_VID32(CS5530_VIDEO_CONFIG); vcfg &= ~(CS5530_VCFG_VID_INP_FORMAT | CS5530_VCFG_4_2_0_MODE); vcfg &= ~(CS5530_VCFG_CSC_BYPASS); vcfg &= ~(CS5530_VCFG_GV_SEL); if (format < 4) vcfg |= (format << 2); else { if (format == VIDEO_FORMAT_Y0Y1Y2Y3) { vcfg |= CS5530_VCFG_4_2_0_MODE; vcfg |= 1 << 2; } if (format == VIDEO_FORMAT_RGB) { vcfg |= CS5530_VCFG_CSC_BYPASS; vcfg |= CS5530_VCFG_GV_SEL; } } WRITE_VID32(CS5530_VIDEO_CONFIG, vcfg); return (0); } /*---------------------------------------------------------------------------- * gfx_set_video_size * * This routine specifies the size of the source data. It is used only * to determine how much data to transfer per frame, and is not used to * calculate the scaling value (that is handled by a separate routine). *---------------------------------------------------------------------------- */ #if GFX_VIDEO_DYNAMIC int cs5530_set_video_size(unsigned short width, unsigned short height) #else int gfx_set_video_size(unsigned short width, unsigned short height) #endif { unsigned long size, vcfg; /* SET THE CS5530 VIDEO LINE SIZE */ vcfg = READ_VID32(CS5530_VIDEO_CONFIG); vcfg &= ~(CS5530_VCFG_LINE_SIZE_LOWER_MASK | CS5530_VCFG_LINE_SIZE_UPPER); size = (width >> 1); vcfg |= (size & 0x00FF) << 8; if (size & 0x0100) vcfg |= CS5530_VCFG_LINE_SIZE_UPPER; WRITE_VID32(CS5530_VIDEO_CONFIG, vcfg); /* SET TOTAL VIDEO BUFFER SIZE IN DISPLAY CONTROLLER */ /* Use private routine to abstract the display controller. */ gfx_set_display_video_size(width, height); return (0); } /*---------------------------------------------------------------------------- * gfx_set_video_offset * * This routine sets the starting offset for the video buffer when only * one offset needs to be specified. *---------------------------------------------------------------------------- */ #if GFX_VIDEO_DYNAMIC int cs5530_set_video_offset(unsigned long offset) #else int gfx_set_video_offset(unsigned long offset) #endif { /* SAVE VALUE FOR FUTURE CLIPPING OF THE TOP OF THE VIDEO WINDOW */ gfx_vid_offset = offset; /* SET VIDEO BUFFER OFFSET IN DISPLAY CONTROLLER */ /* Use private routine to abstract the display controller. */ gfx_set_display_video_offset(offset); return (0); } /*--------------------------------------------------------------------------- * gfx_set_video_scale * * This routine sets the scale factor for the video overlay window. The * size of the source and destination regions are specified in pixels. *--------------------------------------------------------------------------- */ #if GFX_VIDEO_DYNAMIC int cs5530_set_video_scale(unsigned short srcw, unsigned short srch, unsigned short dstw, unsigned short dsth) #else int gfx_set_video_scale(unsigned short srcw, unsigned short srch, unsigned short dstw, unsigned short dsth) #endif { unsigned long xscale, yscale; /* SAVE PARAMETERS */ /* These are needed for clipping the video window later. */ gfx_vid_srcw = srcw; gfx_vid_srch = srch; gfx_vid_dstw = dstw; gfx_vid_dsth = dsth; /* CALCULATE CS5530 SCALE FACTORS */ /* No downscaling in CS5530 so force to 1x if attempted. */ if (dstw <= srcw) xscale = 0x1FFF; else if (dstw == 1 || srcw == 1) return GFX_STATUS_BAD_PARAMETER; else xscale = (0x2000l * (srcw - 1l)) / (dstw - 1l); if (dsth <= srch) yscale = 0x1FFF; else if (dsth == 1 || srch == 1) return GFX_STATUS_BAD_PARAMETER; else yscale = (0x2000l * (srch - 1l)) / (dsth - 1l); WRITE_VID32(CS5530_VIDEO_SCALE, (yscale << 16) | xscale); /* CALL ROUTINE TO UPDATE WINDOW POSITION */ /* This is required because the scale values effect the number of */ /* source data pixels that need to be clipped, as well as the */ /* amount of data that needs to be transferred. */ gfx_set_video_window(gfx_vid_xpos, gfx_vid_ypos, gfx_vid_width, gfx_vid_height); return (0); } /*--------------------------------------------------------------------------- * gfx_set_video_window * * This routine sets the position and size of the video overlay window. The * position is specified in screen relative coordinates, and may be negative. * The size of destination region is specified in pixels. The line size * indicates the number of bytes of source data per scanline. *--------------------------------------------------------------------------- */ #if GFX_VIDEO_DYNAMIC int cs5530_set_video_window(short x, short y, unsigned short w, unsigned short h) #else int gfx_set_video_window(short x, short y, unsigned short w, unsigned short h) #endif { unsigned long vcfg = 0; unsigned long hadjust, vadjust; unsigned long xstart, ystart, xend, yend; unsigned long offset, line_size; /* SAVE PARAMETERS */ /* These are needed to call this routine if the scale value changes. */ gfx_vid_xpos = x; gfx_vid_ypos = y; gfx_vid_width = w; gfx_vid_height = h; /* GET ADJUSTMENT VALUES */ /* Use routines to abstract version of display controller. */ hadjust = gfx_get_htotal() - gfx_get_hsync_end() - 13l; vadjust = gfx_get_vtotal() - gfx_get_vsync_end() + 1l; /* LEFT CLIPPING */ if (x < 0) { gfx_set_video_left_crop((unsigned short) (-x)); xstart = hadjust; } else { gfx_set_video_left_crop(0); xstart = (unsigned long) x + hadjust; } /* CLIPPING ON RIGHT */ xend = x + w; if (xend > gfx_get_hactive()) xend = gfx_get_hactive(); xend += hadjust; /* CLIPPING ON TOP */ offset = gfx_vid_offset; if (y >= 0) { ystart = y + vadjust; } else { ystart = vadjust; line_size = (READ_VID32(CS5530_VIDEO_CONFIG) >> 7) & 0x000001FE; if (READ_VID32(CS5530_VIDEO_CONFIG) & CS5530_VCFG_LINE_SIZE_UPPER) line_size += 512l; if (gfx_vid_dsth) offset = gfx_vid_offset + (line_size << 1) * (((-y) * gfx_vid_srch) / gfx_vid_dsth); } /* CLIPPING ON BOTTOM */ yend = y + h; if (yend >= gfx_get_vactive()) yend = gfx_get_vactive(); yend += vadjust; /* SET VIDEO BUFFER OFFSET IN DISPLAY CONTROLLER */ /* Use private routine to abstract the display controller. */ gfx_set_display_video_offset(offset); /* DISABLE REGISTER UPDATES */ vcfg = READ_VID32(CS5530_VIDEO_CONFIG); vcfg &= ~CS5530_VCFG_VID_REG_UPDATE; WRITE_VID32(CS5530_VIDEO_CONFIG, vcfg); /* SET VIDEO POSITION */ WRITE_VID32(CS5530_VIDEO_X_POS, (xend << 16) | xstart); WRITE_VID32(CS5530_VIDEO_Y_POS, (yend << 16) | ystart); vcfg |= CS5530_VCFG_VID_REG_UPDATE; WRITE_VID32(CS5530_VIDEO_CONFIG, vcfg); return (0); } /*--------------------------------------------------------------------------- * gfx_set_video_left_crop * * This routine sets the number of pixels which will be cropped from the * beginning of each video line. The video window will begin to display only * from the pixel following the cropped pixels, and the cropped pixels * will be ignored. *--------------------------------------------------------------------------- */ #if GFX_VIDEO_DYNAMIC int cs5530_set_video_left_crop(unsigned short x) #else int gfx_set_video_left_crop(unsigned short x) #endif { unsigned long vcfg, initread; /* CLIPPING ON LEFT */ /* Adjust initial read for scale, checking for divide by zero */ if (gfx_vid_dstw) initread = (unsigned long) x *gfx_vid_srcw / gfx_vid_dstw; else initread = 0; /* SET INITIAL READ ADDRESS AND ENABLE REGISTER UPDATES */ vcfg = READ_VID32(CS5530_VIDEO_CONFIG); vcfg &= ~CS5530_VCFG_INIT_READ_MASK; vcfg |= (initread << 15) & CS5530_VCFG_INIT_READ_MASK; vcfg |= CS5530_VCFG_VID_REG_UPDATE; WRITE_VID32(CS5530_VIDEO_CONFIG, vcfg); return (0); } /*--------------------------------------------------------------------------- * gfx_set_video_color_key * * This routine specifies the color key value and mask for the video overlay * hardware. To disable color key, the color and mask should both be set to * zero. The hardware uses the color key in the following equation: * * ((source data) & (color key mask)) == ((color key) & (color key mask)) * * The source data can be either graphics data or video data. The bluescreen * parameter is set to have the hardware compare video data and clear to * comapare graphics data. *--------------------------------------------------------------------------- */ #if GFX_VIDEO_DYNAMIC int cs5530_set_video_color_key(unsigned long key, unsigned long mask, int graphics) #else int gfx_set_video_color_key(unsigned long key, unsigned long mask, int graphics) #endif { unsigned long dcfg = 0; /* SET CS5530 COLOR KEY VALUE */ WRITE_VID32(CS5530_VIDEO_COLOR_KEY, key); WRITE_VID32(CS5530_VIDEO_COLOR_MASK, mask); /* SELECT GRAPHICS OR VIDEO DATA TO COMPARE TO THE COLOR KEY */ dcfg = READ_VID32(CS5530_DISPLAY_CONFIG); if (graphics & 0x01) dcfg &= ~CS5530_DCFG_VG_CK; else dcfg |= CS5530_DCFG_VG_CK; WRITE_VID32(CS5530_DISPLAY_CONFIG, dcfg); return (0); } /*--------------------------------------------------------------------------- * gfx_set_video_filter * * This routine enables or disables the video overlay filters. *--------------------------------------------------------------------------- */ #if GFX_VIDEO_DYNAMIC int cs5530_set_video_filter(int xfilter, int yfilter) #else int gfx_set_video_filter(int xfilter, int yfilter) #endif { unsigned long vcfg = 0; /* ENABLE OR DISABLE CS5530 VIDEO OVERLAY FILTERS */ vcfg = READ_VID32(CS5530_VIDEO_CONFIG); vcfg &= ~(CS5530_VCFG_X_FILTER_EN | CS5530_VCFG_Y_FILTER_EN); if (xfilter) vcfg |= CS5530_VCFG_X_FILTER_EN; if (yfilter) vcfg |= CS5530_VCFG_Y_FILTER_EN; WRITE_VID32(CS5530_VIDEO_CONFIG, vcfg); return (0); } /*--------------------------------------------------------------------------- * gfx_set_video_palette * * This routine loads the video hardware palette. If a NULL pointer is * specified, the palette is bypassed (for CS5530, this means loading the * palette with identity values). *--------------------------------------------------------------------------- */ #if GFX_VIDEO_DYNAMIC int cs5530_set_video_palette(unsigned long *palette) #else int gfx_set_video_palette(unsigned long *palette) #endif { unsigned long i, entry; /* LOAD CS5530 VIDEO PALETTE */ WRITE_VID32(CS5530_PALETTE_ADDRESS, 0); for (i = 0; i < 256; i++) { if (palette) entry = palette[i]; else entry = i | (i << 8) | (i << 16); WRITE_VID32(CS5530_PALETTE_DATA, entry); } return (0); } /*--------------------------------------------------------------------------- * gfx_set_video_palette_entry * * This routine loads a single entry of the video hardware palette. *--------------------------------------------------------------------------- */ #if GFX_VIDEO_DYNAMIC int cs5530_set_video_palette_entry(unsigned long index, unsigned long palette) #else int gfx_set_video_palette_entry(unsigned long index, unsigned long palette) #endif { if (index > 0xFF) return GFX_STATUS_BAD_PARAMETER; /* SET A SINGLE ENTRY */ WRITE_VID32(CS5530_PALETTE_ADDRESS, index); WRITE_VID32(CS5530_PALETTE_DATA, palette); return (0); } #define CX55xx_VIDEO_PCI_44 0x80009444 /*--------------------------------------------------------------------------- * gfx_disable_softvga * * Disables SoftVga. This function is only valid with VSA2, Returns 1 if * SoftVga can be disabled; 0 if not. *--------------------------------------------------------------------------- */ #if GFX_VIDEO_DYNAMIC int cs5530_disable_softvga(void) #else int gfx_disable_softvga(void) #endif { unsigned long reg_val; /* get the current value */ reg_val = gfx_pci_config_read(CX55xx_VIDEO_PCI_44); /* setting video PCI register 44 bit 0 to 1 disables SoftVga */ reg_val |= 0x1; gfx_pci_config_write(CX55xx_VIDEO_PCI_44, reg_val); /* see if we set the bit and return the appropriate value */ reg_val = gfx_pci_config_read(CX55xx_VIDEO_PCI_44); if ((reg_val & 0x1) == 0x1) return (1); else return (0); } /*--------------------------------------------------------------------------- * gfx_enable_softvga * * Enables SoftVga. This function is only valid with VSA2, Returns 1 if * SoftVga can be enbled; 0 if not. *--------------------------------------------------------------------------- */ #if GFX_VIDEO_DYNAMIC int cs5530_enable_softvga(void) #else int gfx_enable_softvga(void) #endif { unsigned long reg_val; /* get the current value */ reg_val = gfx_pci_config_read(CX55xx_VIDEO_PCI_44); /* clearing video PCI register 44 bit 0 enables SoftVga */ gfx_pci_config_write(CX55xx_VIDEO_PCI_44, reg_val & 0xfffffffe); /* see if we cleared the bit and return the appropriate value */ reg_val = gfx_pci_config_read(CX55xx_VIDEO_PCI_44); if ((reg_val & 0x1) == 0) return (1); else return (0); } /*--------------------------------------------------------------------------- * gfx_get_clock_frequency * * This routine returns the current clock frequency in 16.16 format. * It reads the current register value and finds the match in the table. * If no match is found, this routine returns 0. *--------------------------------------------------------------------------- */ #if GFX_VIDEO_DYNAMIC unsigned long cs5530_get_clock_frequency(void) #else unsigned long gfx_get_clock_frequency(void) #endif { unsigned int index; unsigned long value, mask; mask = 0x7FFFFEDC; value = READ_VID32(CS5530_DOT_CLK_CONFIG) & mask; for (index = 0; index < NUM_CS5530_FREQUENCIES; index++) { if ((CS5530_PLLtable[index].pll_value & mask) == value) return (CS5530_PLLtable[index].frequency); } return (0); } /*--------------------------------------------------------------------------- * gfx_get_max_video_width * * This routine returns the maximum theoretical video width for the current * display mode. *--------------------------------------------------------------------------- */ #if GFX_VIDEO_DYNAMIC unsigned long cs5530_get_max_video_width(void) #else unsigned long gfx_get_max_video_width(void) #endif { unsigned long htotal, vidclk, dotpll; unsigned long low, high, sublow, subhigh; unsigned long width, value; unsigned long temp0, temp1; unsigned long highshift; unsigned long divisor, dividend; htotal = gfx_get_htotal(); vidclk = gfx_cpu_frequency << 15; if (READ_REG32(DC_GENERAL_CFG) & DC_GCFG_VCLK_DIV) vidclk >>= 1; dotpll = gfx_get_clock_frequency(); /* CHECK FOR UNKNOWN DOT CLOCK */ if (!dotpll) return 0; /* DERIVE THEORETICAL MAXIMUM */ /* The GX/CS5530 video interface transfers 8 bytes for every 9 video */ /* clocks. This implies that 4 video pixels are transferred for every */ /* 9 clocks. The time allowed to fill a line buffer is an entire */ /* display line, or (HTotal * DotPll). The time needed to fill the */ /* line buffer is thus ((4/9) * VidClk * VidWidth). Solving for */ /* equality yields the theoretical maximum: */ /* */ /* 4 * VidClk * HTotal */ /* VidWidth = ----------------------- */ /* 9 * DotPLL */ /* CALCULATE TOP OF EQUATION */ /* The equation as it stands will overflow 32-bit integer math. We must */ /* therefore use tricks to perform a 64-bit equation to calculate the */ /* correct value. We assume in this equation that the upper 16 bits of */ /* htotal are 0, i.e. that htotal is never greater than 65535. */ vidclk <<= 2; low = (vidclk & 0xFFFF) * (htotal & 0xFFFF); temp0 = (vidclk >> 16) * (htotal & 0xFFFF); temp1 = temp0 << 16; high = temp0 >> 16; if ((0xFFFFFFFF - temp1) < low) high++; low += temp1; /* DIVIDE BY BOTTOM OF EQUATION */ /* Use an iterative divide to avoid floating point or inline assembly */ /* Costly, but so is the price of OS independence. */ divisor = 9 * dotpll; highshift = 0; width = 0; while (highshift <= 32) { if (highshift == 0) dividend = high; else if (highshift == 32) dividend = low; else dividend = (high << highshift) | (low >> (32 - highshift)); value = dividend / divisor; width = (width << 4) + value; value *= divisor; subhigh = value >> highshift; sublow = value << (32 - highshift); if (low < sublow) high = high - subhigh - 1; else high = high - subhigh; low -= sublow; highshift += 4; } /* ALIGN TO 8 PIXEL BOUNDARY */ width &= 0xFFFC; return width; } /*************************************************************/ /* READ ROUTINES | INCLUDED FOR DIAGNOSTIC PURPOSES ONLY */ /*************************************************************/ #if GFX_READ_ROUTINES /*--------------------------------------------------------------------------- * gfx_get_vsa2_softvga_enable * * This function returns the enable status of SoftVGA. It is valid * only if VSAII is present. *--------------------------------------------------------------------------- */ #if GFX_VIDEO_DYNAMIC int cs5530_get_vsa2_softvga_enable(void) #else int gfx_get_vsa2_softvga_enable(void) #endif { unsigned long reg_val; reg_val = gfx_pci_config_read(CX55xx_VIDEO_PCI_44); if ((reg_val & 0x1) == 0) return (1); else return (0); } /*--------------------------------------------------------------------------- * gfx_get_sync_polarities * * This routine returns the polarities of the sync pulses: * Bit 0: Set if negative horizontal polarity. * Bit 1: Set if negative vertical polarity. *--------------------------------------------------------------------------- */ #if GFX_VIDEO_DYNAMIC int cs5530_get_sync_polarities(void) #else int gfx_get_sync_polarities(void) #endif { int polarities = 0; if (READ_VID32(CS5530_DISPLAY_CONFIG) & 0x00000100) polarities |= 1; if (READ_VID32(CS5530_DISPLAY_CONFIG) & 0x00000200) polarities |= 2; return (polarities); } /*--------------------------------------------------------------------------- * gfx_get_video_palette_entry * * This routine returns a single palette entry. *--------------------------------------------------------------------------- */ #if GFX_VIDEO_DYNAMIC int cs5530_get_video_palette_entry(unsigned long index, unsigned long *palette) #else int gfx_get_video_palette_entry(unsigned long index, unsigned long *palette) #endif { if (index > 0xFF) return GFX_STATUS_BAD_PARAMETER; /* READ A SINGLE ENTRY */ WRITE_VID32(CS5530_PALETTE_ADDRESS, index); *palette = READ_VID32(CS5530_PALETTE_DATA); return (GFX_STATUS_OK); } /*---------------------------------------------------------------------------- * gfx_get_video_enable * * This routine returns the value "one" if video overlay is currently enabled, * otherwise it returns the value "zero". *---------------------------------------------------------------------------- */ #if GFX_VIDEO_DYNAMIC int cs5530_get_video_enable(void) #else int gfx_get_video_enable(void) #endif { if (READ_VID32(CS5530_VIDEO_CONFIG) & CS5530_VCFG_VID_EN) return (1); return (0); } /*---------------------------------------------------------------------------- * gfx_get_video_format * * This routine returns the current video overlay format. *---------------------------------------------------------------------------- */ #if GFX_VIDEO_DYNAMIC int cs5530_get_video_format(void) #else int gfx_get_video_format(void) #endif { unsigned long vcfg; vcfg = READ_VID32(CS5530_VIDEO_CONFIG); if (vcfg & CS5530_VCFG_CSC_BYPASS) return (VIDEO_FORMAT_RGB); if (vcfg & CS5530_VCFG_4_2_0_MODE) return (VIDEO_FORMAT_Y0Y1Y2Y3); return ((int) ((vcfg >> 2) & 3)); } /*---------------------------------------------------------------------------- * gfx_get_video_src_size * * This routine returns the size of the source video overlay buffer. The * return value is (height << 16) | width. *---------------------------------------------------------------------------- */ #if GFX_VIDEO_DYNAMIC unsigned long cs5530_get_video_src_size(void) #else unsigned long gfx_get_video_src_size(void) #endif { unsigned long width = 0, height = 0; /* DETERMINE SOURCE WIDTH FROM THE CS5530 VIDEO LINE SIZE */ width = (READ_VID32(CS5530_VIDEO_CONFIG) >> 7) & 0x000001FE; if (READ_VID32(CS5530_VIDEO_CONFIG) & CS5530_VCFG_LINE_SIZE_UPPER) width += 512l; if (width) { /* DETERMINE HEIGHT BY DIVIDING TOTAL SIZE BY WIDTH */ /* Get total size from display controller - abtracted. */ height = gfx_get_display_video_size() / (width << 1); } return ((height << 16) | width); } /*---------------------------------------------------------------------------- * gfx_get_video_line_size * * This routine returns the line size of the source video overlay buffer, in * pixels. *---------------------------------------------------------------------------- */ #if GFX_VIDEO_DYNAMIC unsigned long cs5530_get_video_line_size(void) #else unsigned long gfx_get_video_line_size(void) #endif { unsigned long width = 0; /* DETERMINE SOURCE WIDTH FROM THE CS5530 VIDEO LINE SIZE */ width = (READ_VID32(CS5530_VIDEO_CONFIG) >> 7) & 0x000001FE; if (READ_VID32(CS5530_VIDEO_CONFIG) & CS5530_VCFG_LINE_SIZE_UPPER) width += 512l; return (width); } /*---------------------------------------------------------------------------- * gfx_get_video_xclip * * This routine returns the number of bytes clipped on the left side of a * video overlay line (skipped at beginning). *---------------------------------------------------------------------------- */ #if GFX_VIDEO_DYNAMIC unsigned long cs5530_get_video_xclip(void) #else unsigned long gfx_get_video_xclip(void) #endif { unsigned long clip = 0; /* DETERMINE SOURCE WIDTH FROM THE CS5530 VIDEO LINE SIZE */ clip = (READ_VID32(CS5530_VIDEO_CONFIG) >> 14) & 0x000007FC; return (clip); } /*---------------------------------------------------------------------------- * gfx_get_video_offset * * This routine returns the current offset for the video overlay buffer. *---------------------------------------------------------------------------- */ #if GFX_VIDEO_DYNAMIC unsigned long cs5530_get_video_offset(void) #else unsigned long gfx_get_video_offset(void) #endif { return (gfx_get_display_video_offset()); } /*--------------------------------------------------------------------------- * gfx_get_video_scale * * This routine returns the scale factor for the video overlay window. *--------------------------------------------------------------------------- */ #if GFX_VIDEO_DYNAMIC unsigned long cs5530_get_video_scale(void) #else unsigned long gfx_get_video_scale(void) #endif { return (READ_VID32(CS5530_VIDEO_SCALE)); } /*--------------------------------------------------------------------------- * gfx_get_video_dst_size * * This routine returns the size of the displayed video overlay window. * NOTE: This is the displayed window size, which may be different from * the real window size if clipped. *--------------------------------------------------------------------------- */ #if GFX_VIDEO_DYNAMIC unsigned long cs5530_get_video_dst_size(void) #else unsigned long gfx_get_video_dst_size(void) #endif { unsigned long xsize, ysize; xsize = READ_VID32(CS5530_VIDEO_X_POS); xsize = ((xsize >> 16) & 0x7FF) - (xsize & 0x07FF); ysize = READ_VID32(CS5530_VIDEO_Y_POS); ysize = ((ysize >> 16) & 0x7FF) - (ysize & 0x07FF); return ((ysize << 16) | xsize); } /*--------------------------------------------------------------------------- * gfx_get_video_position * * This routine returns the position of the video overlay window. The * return value is (ypos << 16) | xpos. * NOTE: This is the displayed window position, which may be different from * the real window position if clipped. *--------------------------------------------------------------------------- */ #if GFX_VIDEO_DYNAMIC unsigned long cs5530_get_video_position(void) #else unsigned long gfx_get_video_position(void) #endif { unsigned long hadjust, vadjust; unsigned long xpos, ypos; /* READ HARDWARE POSITION */ xpos = READ_VID32(CS5530_VIDEO_X_POS) & 0x000007FF; ypos = READ_VID32(CS5530_VIDEO_Y_POS) & 0x000007FF; /* GET ADJUSTMENT VALUES */ /* Use routines to abstract version of display controller. */ hadjust = gfx_get_htotal() - gfx_get_hsync_end() - 13l; vadjust = gfx_get_vtotal() - gfx_get_vsync_end() + 1l; xpos -= hadjust; ypos -= vadjust; return ((ypos << 16) | (xpos & 0x0000FFFF)); } /*--------------------------------------------------------------------------- * gfx_get_video_color_key * * This routine returns the current video color key value. *--------------------------------------------------------------------------- */ #if GFX_VIDEO_DYNAMIC unsigned long cs5530_get_video_color_key(void) #else unsigned long gfx_get_video_color_key(void) #endif { return (READ_VID32(CS5530_VIDEO_COLOR_KEY)); } /*--------------------------------------------------------------------------- * gfx_get_video_color_key_mask * * This routine returns the current video color mask value. *--------------------------------------------------------------------------- */ #if GFX_VIDEO_DYNAMIC unsigned long cs5530_get_video_color_key_mask(void) #else unsigned long gfx_get_video_color_key_mask(void) #endif { return (READ_VID32(CS5530_VIDEO_COLOR_MASK)); } /*--------------------------------------------------------------------------- * gfx_get_video_color_key_src * * This routine returns 0 for video data compare, 1 for graphics data. *--------------------------------------------------------------------------- */ #if GFX_VIDEO_DYNAMIC int cs5530_get_video_color_key_src(void) #else int gfx_get_video_color_key_src(void) #endif { if (READ_VID32(CS5530_DISPLAY_CONFIG) & CS5530_DCFG_VG_CK) return (0); return (1); } /*--------------------------------------------------------------------------- * gfx_get_video_filter * * This routine returns if the filters are currently enabled. *--------------------------------------------------------------------------- */ #if GFX_VIDEO_DYNAMIC int cs5530_get_video_filter(void) #else int gfx_get_video_filter(void) #endif { int retval = 0; if (READ_VID32(CS5530_VIDEO_CONFIG) & CS5530_VCFG_X_FILTER_EN) retval |= 1; if (READ_VID32(CS5530_VIDEO_CONFIG) & CS5530_VCFG_Y_FILTER_EN) retval |= 2; return (retval); } /*--------------------------------------------------------------------------- * gfx_read_crc * * This routine returns the hardware CRC value, which is used for automated * testing. The value is like a checksum, but will change if pixels move * locations. *--------------------------------------------------------------------------- */ #if GFX_VIDEO_DYNAMIC unsigned long cs5530_read_crc(void) #else unsigned long gfx_read_crc(void) #endif { unsigned long crc = 0xFFFFFFFF; if (gfx_test_timing_active()) { /* WAIT UNTIL ACTIVE DISPLAY */ while (!gfx_test_vertical_active()); /* RESET CRC DURING ACTIVE DISPLAY */ WRITE_VID32(CS5530_CRCSIG_TFT_TV, 0); WRITE_VID32(CS5530_CRCSIG_TFT_TV, 1); /* WAIT UNTIL NOT ACTIVE, THEN ACTIVE, NOT ACTIVE, THEN ACTIVE */ while (gfx_test_vertical_active()); while (!gfx_test_vertical_active()); while (gfx_test_vertical_active()); while (!gfx_test_vertical_active()); crc = READ_VID32(CS5530_CRCSIG_TFT_TV) >> 8; } return (crc); } #endif /* GFX_READ_ROUTINES */ /* END OF FILE */