Sign Up
Log In
Log In
or
Sign Up
Places
All Projects
Status Monitor
Collapse sidebar
openSUSE:Evergreen:11.2
xorg-x11-driver-video
xf86-video-ati-6.7.197-r128-xvideo.patch
Overview
Repositories
Revisions
Requests
Users
Attributes
Meta
File xf86-video-ati-6.7.197-r128-xvideo.patch of Package xorg-x11-driver-video
diff --git a/src/r128.h b/src/r128.h index 1205245..6e608b9 100644 --- a/src/r128.h +++ b/src/r128.h @@ -430,6 +430,12 @@ typedef struct { XF86VideoAdaptorPtr adaptor; void (*VideoTimerCallback)(ScrnInfoPtr, Time); int videoKey; + Bool forceXvProbing; + int RageTheatreCrystal; + int RageTheatreTunerPort; + int RageTheatreCompositePort; + int RageTheatreSVideoPort; + int tunerType; Bool showCache; OptionInfoPtr Options; @@ -473,6 +479,11 @@ extern Bool R128DGAInit(ScreenPtr pScreen); extern int R128MinBits(int val); extern void R128InitVideo(ScreenPtr pScreen); +#ifdef XvExtension +extern void R128ShutdownVideo(ScrnInfoPtr pScrn); +extern void R128LeaveVT_Video(ScrnInfoPtr pScrn); +extern void R128EnterVT_Video(ScrnInfoPtr pScrn); +#endif #ifdef XF86DRI extern Bool R128DRIScreenInit(ScreenPtr pScreen); diff --git a/src/r128_accel.c b/src/r128_accel.c index 8870682..f75b38e 100644 --- a/src/r128_accel.c +++ b/src/r128_accel.c @@ -242,6 +242,10 @@ void R128CCEWaitForIdle(ScrnInfoPtr pScrn) R128InfoPtr info = R128PTR(pScrn); int ret, i; + if(!info->CCEInUse){ + R128WaitForIdle(pScrn); + return; + } FLUSH_RING(); for (;;) { @@ -260,7 +264,10 @@ void R128CCEWaitForIdle(ScrnInfoPtr pScrn) "%s: (DEBUG) CCE idle took i = %d\n", __FUNCTION__, i); } - if (ret == 0) return; + if (ret == 0){ + R128WaitForIdle(pScrn); + return; + } xf86DrvMsg(pScrn->scrnIndex, X_ERROR, "Idle timed out, resetting engine...\n"); diff --git a/src/r128_driver.c b/src/r128_driver.c index 45917cd..c5a77b6 100644 --- a/src/r128_driver.c +++ b/src/r128_driver.c @@ -78,7 +78,18 @@ #include "r128_sarea.h" #endif +#define USE_FB /* don't disable it: CFB code is broken */ +#ifdef USE_FB #include "fb.h" +#else + + /* CFB support */ +#define PSZ 8 +#include "cfb.h" +#undef PSZ +#include "cfb16.h" +#include "cfb32.h" +#endif /* colormap initialization */ #include "micmap.h" @@ -90,6 +101,7 @@ #include "xf86Resources.h" #include "xf86cmap.h" #include "xf86xv.h" +#include "xf86i2c.h" #include "vbe.h" /* fbdevhw & vgahw */ @@ -144,6 +156,14 @@ typedef enum { /* FIXME: Disable CRTOnly until it is tested */ OPTION_CRT, #endif +#ifdef XvExtension + OPTION_FORCE_XV_PROBING, + OPTION_RAGE_THEATRE_CRYSTAL, + OPTION_RAGE_THEATRE_TUNER_PORT, + OPTION_RAGE_THEATRE_COMPOSITE_PORT, + OPTION_RAGE_THEATRE_SVIDEO_PORT, + OPTION_TUNER_TYPE, +#endif OPTION_DISPLAY, OPTION_PANEL_WIDTH, OPTION_PANEL_HEIGHT, @@ -179,6 +199,15 @@ static const OptionInfoRec R128Options[] = { { OPTION_VIDEO_KEY, "VideoKey", OPTV_INTEGER, {0}, FALSE }, { OPTION_SHOW_CACHE, "ShowCache", OPTV_BOOLEAN, {0}, FALSE }, { OPTION_VGA_ACCESS, "VGAAccess", OPTV_BOOLEAN, {0}, TRUE }, +#ifdef XvExtension + { OPTION_VIDEO_KEY, "VideoKey", OPTV_INTEGER, {0}, FALSE }, + { OPTION_FORCE_XV_PROBING, "ForceXvProbing", OPTV_BOOLEAN, {0}, FALSE}, + { OPTION_RAGE_THEATRE_CRYSTAL, "RageTheatreCrystal", OPTV_INTEGER, {0}, FALSE }, + { OPTION_RAGE_THEATRE_TUNER_PORT, "RageTheatreTunerPort", OPTV_INTEGER, {0}, FALSE }, + { OPTION_RAGE_THEATRE_COMPOSITE_PORT, "RageTheatreCompositePort", OPTV_INTEGER, {0}, FALSE }, + { OPTION_RAGE_THEATRE_SVIDEO_PORT, "RageTheatreSVideoPort", OPTV_INTEGER, {0}, FALSE }, + { OPTION_TUNER_TYPE, "TunerType", OPTV_INTEGER, {0}, FALSE }, +#endif { -1, NULL, OPTV_NONE, {0}, FALSE } }; @@ -762,7 +791,7 @@ static Bool R128PreInitVisual(ScrnInfoPtr pScrn) { R128InfoPtr info = R128PTR(pScrn); - if (!xf86SetDepthBpp(pScrn, 0, 0, 0, (Support24bppFb + if (!xf86SetDepthBpp(pScrn, 8, 8, 8, (Support24bppFb | Support32bppFb | SupportConvert32to24 ))) @@ -1315,7 +1344,7 @@ R128I2cInit(ScrnInfoPtr pScrn) return FALSE; } - info->pI2CBus = xf86CreateI2CBusRec(); + info->pI2CBus = xf86CreateI2CBusRec(); if(!info->pI2CBus) return FALSE; info->pI2CBus->BusName = "DDC"; @@ -1634,6 +1663,10 @@ static Bool R128PreInitModes(ScrnInfoPtr pScrn) R128InfoPtr info = R128PTR(pScrn); ClockRangePtr clockRanges; int modesFound; + char *mod = NULL; +#ifndef USE_FB + const char *Sym = NULL; +#endif if(info->isDFP) { R128MapMem(pScrn); @@ -2016,6 +2049,76 @@ Bool R128PreInit(ScrnInfoPtr pScrn, int flags) if (!R128PreInitWeight(pScrn)) goto fail; +#ifdef XvExtension + if(xf86GetOptValInteger(info->Options, OPTION_RAGE_THEATRE_CRYSTAL, &(info->RageTheatreCrystal))) { + xf86DrvMsg(pScrn->scrnIndex, X_CONFIG, "Rage Theatre Crystal frequency was specified as %d.%d Mhz\n", + info->RageTheatreCrystal/100, info->RageTheatreCrystal % 100); + } else { + info->RageTheatreCrystal=-1; + } + + if(xf86GetOptValInteger(info->Options, OPTION_RAGE_THEATRE_TUNER_PORT, &(info->RageTheatreTunerPort))) { + xf86DrvMsg(pScrn->scrnIndex, X_CONFIG, "Rage Theatre tuner port was specified as %d\n", + info->RageTheatreTunerPort); + } else { + info->RageTheatreTunerPort=-1; + } + + if(info->RageTheatreTunerPort>5){ + xf86DrvMsg(pScrn->scrnIndex, X_ERROR, "Attempt to assign Rage Theatre tuner port to invalid value. Disabling setting\n"); + info->RageTheatreTunerPort=-1; + } + + if(xf86GetOptValInteger(info->Options, OPTION_RAGE_THEATRE_COMPOSITE_PORT, &(info->RageTheatreCompositePort))) { + xf86DrvMsg(pScrn->scrnIndex, X_CONFIG, "Rage Theatre composite port was specified as %d\n", + info->RageTheatreCompositePort); + } else { + info->RageTheatreCompositePort=-1; + } + + if(info->RageTheatreCompositePort>6){ + xf86DrvMsg(pScrn->scrnIndex, X_ERROR, "Attempt to assign Rage Theatre composite port to invalid value. Disabling setting\n"); + info->RageTheatreCompositePort=-1; + } + + if(xf86GetOptValInteger(info->Options, OPTION_RAGE_THEATRE_SVIDEO_PORT, &(info->RageTheatreSVideoPort))) { + xf86DrvMsg(pScrn->scrnIndex, X_CONFIG, "Rage Theatre SVideo Port was specified as %d\n", + info->RageTheatreSVideoPort); + } else { + info->RageTheatreSVideoPort=-1; + } + + if(info->RageTheatreSVideoPort>6){ + xf86DrvMsg(pScrn->scrnIndex, X_ERROR, "Attempt to assign Rage Theatre SVideo port to invalid value. Disabling setting\n"); + info->RageTheatreSVideoPort=-1; + } + + if(xf86GetOptValInteger(info->Options, OPTION_TUNER_TYPE, &(info->tunerType))) { + xf86DrvMsg(pScrn->scrnIndex, X_CONFIG, "Tuner type was specified as %d\n", + info->tunerType); + } else { + info->tunerType=-1; + } + + if(info->tunerType>31){ + xf86DrvMsg(pScrn->scrnIndex, X_ERROR, "Attempt to set tuner type to invalid value. Disabling setting\n"); + info->tunerType=-1; + } + + if(xf86ReturnOptValBool(info->Options, OPTION_FORCE_XV_PROBING, FALSE)) { + xf86DrvMsg(pScrn->scrnIndex, X_CONFIG, "Forcing Xv probing for multimedia harware (lockup prone)\n"); + info->forceXvProbing=TRUE; + } + + if(xf86GetOptValInteger(info->Options, OPTION_VIDEO_KEY, &(info->videoKey))) { + xf86DrvMsg(pScrn->scrnIndex, X_CONFIG, "video key set to 0x%x\n", + info->videoKey); + } else { + /* this default is very unlikely to occur (mostly a few pixels in photos) */ + info->videoKey = (1<<pScrn->offset.red) | (2<<pScrn->offset.green) | (3<<pScrn->offset.blue); + } +#endif + if(xf86GetOptValInteger(info->Options, OPTION_VIDEO_KEY, &(info->videoKey))) { xf86DrvMsg(pScrn->scrnIndex, X_CONFIG, "video key set to 0x%x\n", info->videoKey); @@ -2073,10 +2176,12 @@ Bool R128PreInit(ScrnInfoPtr pScrn, int flags) #endif /* Free the video bios (if applicable) */ +#ifndef XvExtension if (info->VBIOS) { xfree(info->VBIOS); info->VBIOS = NULL; } +#endif /* Free int10 info */ if (pInt10) @@ -2292,12 +2397,18 @@ Bool R128ScreenInit(int scrnIndex, ScreenPtr pScreen, } #endif +#ifdef USE_FB if (!fbScreenInit (pScreen, info->FB, pScrn->virtualX, pScrn->virtualY, pScrn->xDpi, pScrn->yDpi, pScrn->displayWidth, pScrn->bitsPerPixel)) return FALSE; - +#else + if (!cfbScreenInit(pScreen, info->FB, + pScrn->virtualX, pScrn->virtualY, + pScrn->xDpi, pScrn->yDpi, pScrn->displayWidth)) + return FALSE; +#endif xf86SetBlackWhitePixels(pScreen); if (pScrn->bitsPerPixel > 8) { @@ -2316,9 +2427,10 @@ Bool R128ScreenInit(int scrnIndex, ScreenPtr pScreen, } } +#ifdef USE_FB /* must be after RGB order fixed */ fbPictureInit (pScreen, 0, 0); - +#endif /* Memory manager setup */ #ifdef XF86DRI if (info->directRenderingEnabled) { @@ -3375,6 +3487,7 @@ static Bool R128InitCrtcRegisters(ScrnInfoPtr pScrn, R128SavePtr save, int hsync_wid; int hsync_fudge; int vsync_wid; + int bytpp; int hsync_fudge_default[] = { 0x00, 0x12, 0x09, 0x09, 0x06, 0x05 }; int hsync_fudge_fp[] = { 0x12, 0x11, 0x09, 0x09, 0x05, 0x05 }; // int hsync_fudge_fp_crt[] = { 0x12, 0x10, 0x08, 0x08, 0x04, 0x04 }; @@ -3498,6 +3611,10 @@ static Bool R128InitCrtcRegisters(ScrnInfoPtr pScrn, R128SavePtr save, } #endif +#ifdef XvExtension + R128EnterVT_Video(pScrn); +#endif + return TRUE; } @@ -4261,6 +4378,10 @@ void R128LeaveVT(int scrnIndex, int flags) R128SavePtr save = &info->ModeReg; R128TRACE(("R128LeaveVT\n")); +#ifdef XvExtension + R128LeaveVT_Video(pScrn); +#endif + #ifdef XF86DRI if (info->directRenderingEnabled) { DRILock(pScrn->pScreen, 0); @@ -4311,11 +4432,15 @@ static Bool R128CloseScreen(int scrnIndex, ScreenPtr pScreen) if (info->DGAModes) xfree(info->DGAModes); info->DGAModes = NULL; +#if 0 + /* This code causes server crash on exit freedesktop#8811#c12 */ if (info->adaptor) { + R128ShutdownVideo(pScrn); xfree(info->adaptor->pPortPrivates[0].ptr); xf86XVFreeVideoAdaptorRec(info->adaptor); info->adaptor = NULL; } +#endif pScrn->vtSema = FALSE; diff --git a/src/r128_reg.h b/src/r128_reg.h index dac22e6..beed9b2 100644 --- a/src/r128_reg.h +++ b/src/r128_reg.h @@ -275,7 +275,11 @@ #define R128_CACHE_CNTL 0x1724 #define R128_CACHE_LINE 0x0f0c /* PCI */ #define R128_CAP0_TRIG_CNTL 0x0950 /* ? */ -#define R128_CAP1_TRIG_CNTL 0x09c0 /* ? */ +#define R128_CAP0_TRIG_CNTL_TRIGGER_GET 0x00000003 +#define R128_CAP0_TRIG_CNTL_TRIGGER_SET 0x00000001 +#define R128_CAP0_TRIG_CNTL_CAPTURE_EN 0x00000010 +#define R128_CAP0_TRIG_CNTL_VSYNC_GET 0x0000FF00 +#define R128_CAP0_TRIG_CNTL_VSYNC_SET 0x00010000 #define R128_CAPABILITIES_ID 0x0f50 /* PCI */ #define R128_CAPABILITIES_PTR 0x0f34 /* PCI */ #define R128_CLK_PIN_CNTL 0x0001 /* PLL */ @@ -713,6 +717,10 @@ #define R128_HW_DEBUG2 0x011c #define R128_I2C_CNTL_1 0x0094 /* ? */ +#define R128_I2C_CNTL_0 0x0090 +#define R128_I2C_CNTL_1 0x0094 +#define R128_I2C_DATA 0x0098 + #define R128_INTERRUPT_LINE 0x0f3c /* PCI */ #define R128_INTERRUPT_PIN 0x0f3d /* PCI */ #define R128_IO_BASE 0x0f14 /* PCI */ @@ -841,6 +849,16 @@ #define R128_OV0_VID_BUF_PITCH0_VALUE 0x0460 #define R128_OV0_VID_BUF_PITCH1_VALUE 0x0464 #define R128_OV0_AUTO_FLIP_CNTL 0x0470 +#define R128_OV0_AUTO_FLIP_CNTL_SOFT_BUF_NUM 0x00000007 +#define R128_OV0_AUTO_FLIP_CNTL_SOFT_REPEAT_FIELD 0x00000008 +#define R128_OV0_AUTO_FLIP_CNTL_SOFT_BUF_ODD 0x00000010 +#define R128_OV0_AUTO_FLIP_CNTL_IGNORE_REPEAT_FIELD 0x00000020 +#define R128_OV0_AUTO_FLIP_CNTL_SOFT_EOF_TOGGLE 0x00000040 +#define R128_OV0_AUTO_FLIP_CNTL_VID_PORT_SELECT 0x00000300 +#define R128_OV0_AUTO_FLIP_CNTL_P1_FIRST_LINE_EVEN 0x00010000 +#define R128_OV0_AUTO_FLIP_CNTL_SHIFT_EVEN_DOWN 0x00040000 +#define R128_OV0_AUTO_FLIP_CNTL_SHIFT_ODD_DOWN 0x00080000 +#define R128_OV0_AUTO_FLIP_CNTL_FIELD_POL_SOURCE 0x00800000 #define R128_OV0_DEINTERLACE_PATTERN 0x0474 #define R128_OV0_H_INC 0x0480 #define R128_OV0_STEP_BY 0x0484 @@ -876,6 +894,92 @@ # define R128_CMP_MIX_AND 0x00000100L #define R128_OV0_TEST 0x04F8 +/* first capture unit */ + +#define R128_CAP0_BUF0_OFFSET 0x0920 +#define R128_CAP0_BUF1_OFFSET 0x0924 +#define R128_CAP0_BUF0_EVEN_OFFSET 0x0928 +#define R128_CAP0_BUF1_EVEN_OFFSET 0x092C + +#define R128_CAP0_BUF_PITCH 0x0930 +#define R128_CAP0_V_WINDOW 0x0934 +#define R128_CAP0_H_WINDOW 0x0938 +#define R128_CAP0_VBI_ODD_OFFSET 0x093C +#define R128_CAP0_VBI_EVEN_OFFSET 0x0940 +#define R128_CAP0_VBI_V_WINDOW 0x0944 +#define R128_CAP0_VBI_H_WINDOW 0x0948 +#define R128_CAP0_PORT_MODE_CNTL 0x094C +#define R128_CAP0_TRIG_CNTL 0x0950 +#define R128_CAP0_DEBUG 0x0954 +#define R128_CAP0_CONFIG 0x0958 +#define R128_CAP0_CONFIG_CONTINUOS 0x00000001 +#define R128_CAP0_CONFIG_START_FIELD_EVEN 0x00000002 +#define R128_CAP0_CONFIG_START_BUF_GET 0x00000004 +#define R128_CAP0_CONFIG_START_BUF_SET 0x00000008 +#define R128_CAP0_CONFIG_BUF_TYPE_ALT 0x00000010 +#define R128_CAP0_CONFIG_BUF_TYPE_FRAME 0x00000020 +#define R128_CAP0_CONFIG_ONESHOT_MODE_FRAME 0x00000040 +#define R128_CAP0_CONFIG_BUF_MODE_DOUBLE 0x00000080 +#define R128_CAP0_CONFIG_BUF_MODE_TRIPLE 0x00000100 +#define R128_CAP0_CONFIG_MIRROR_EN 0x00000200 +#define R128_CAP0_CONFIG_ONESHOT_MIRROR_EN 0x00000400 +#define R128_CAP0_CONFIG_VIDEO_SIGNED_UV 0x00000800 +#define R128_CAP0_CONFIG_ANC_DECODE_EN 0x00001000 +#define R128_CAP0_CONFIG_VBI_EN 0x00002000 +#define R128_CAP0_CONFIG_SOFT_PULL_DOWN_EN 0x00004000 +#define R128_CAP0_CONFIG_VIP_EXTEND_FLAG_EN 0x00008000 +#define R128_CAP0_CONFIG_FAKE_FIELD_EN 0x00010000 +#define R128_CAP0_CONFIG_ODD_ONE_MORE_LINE 0x00020000 +#define R128_CAP0_CONFIG_EVEN_ONE_MORE_LINE 0x00040000 +#define R128_CAP0_CONFIG_HORZ_DIVIDE_2 0x00080000 +#define R128_CAP0_CONFIG_HORZ_DIVIDE_4 0x00100000 +#define R128_CAP0_CONFIG_VERT_DIVIDE_2 0x00200000 +#define R128_CAP0_CONFIG_VERT_DIVIDE_4 0x00400000 +#define R128_CAP0_CONFIG_FORMAT_BROOKTREE 0x00000000 +#define R128_CAP0_CONFIG_FORMAT_CCIR656 0x00800000 +#define R128_CAP0_CONFIG_FORMAT_ZV 0x01000000 +#define R128_CAP0_CONFIG_FORMAT_VIP 0x01800000 +#define R128_CAP0_CONFIG_FORMAT_TRANSPORT 0x02000000 +#define R128_CAP0_CONFIG_HORZ_DECIMATOR 0x04000000 +#define R128_CAP0_CONFIG_VIDEO_IN_YVYU422 0x00000000 +#define R128_CAP0_CONFIG_VIDEO_IN_VYUY422 0x20000000 +#define R128_CAP0_ANC_ODD_OFFSET 0x095C +#define R128_CAP0_ANC_EVEN_OFFSET 0x0960 +#define R128_CAP0_ANC_H_WINDOW 0x0964 +#define R128_CAP0_VIDEO_SYNC_TEST 0x0968 +#define R128_CAP0_ONESHOT_BUF_OFFSET 0x096C +#define R128_CAP0_BUF_STATUS 0x0970 +#define R128_CAP0_DWNSC_XRATIO 0x0978 +#define R128_CAP0_XSHARPNESS 0x097C + +/* second capture unit */ + +#define R128_CAP1_BUF0_OFFSET 0x0990 +#define R128_CAP1_BUF1_OFFSET 0x0994 +#define R128_CAP1_BUF0_EVEN_OFFSET 0x0998 +#define R128_CAP1_BUF1_EVEN_OFFSET 0x099C + +#define R128_CAP1_BUF_PITCH 0x09A0 +#define R128_CAP1_V_WINDOW 0x09A4 +#define R128_CAP1_H_WINDOW 0x09A8 +#define R128_CAP1_VBI_ODD_OFFSET 0x09AC +#define R128_CAP1_VBI_EVEN_OFFSET 0x09B0 +#define R128_CAP1_VBI_V_WINDOW 0x09B4 +#define R128_CAP1_VBI_H_WINDOW 0x09B8 +#define R128_CAP1_PORT_MODE_CNTL 0x09BC +#define R128_CAP1_TRIG_CNTL 0x09C0 +#define R128_CAP1_DEBUG 0x09C4 +#define R128_CAP1_CONFIG 0x09C8 +#define R128_CAP1_ANC_ODD_OFFSET 0x09CC +#define R128_CAP1_ANC_EVEN_OFFSET 0x09D0 +#define R128_CAP1_ANC_H_WINDOW 0x09D4 +#define R128_CAP1_VIDEO_SYNC_TEST 0x09D8 +#define R128_CAP1_ONESHOT_BUF_OFFSET 0x09DC +#define R128_CAP1_BUF_STATUS 0x09E0 +#define R128_CAP1_DWNSC_XRATIO 0x09E8 +#define R128_CAP1_XSHARPNESS 0x09EC + + #define R128_PALETTE_DATA 0x00b4 #define R128_PALETTE_INDEX 0x00b0 diff --git a/src/r128_sarea.h b/src/r128_sarea.h index 70f9122..cad9aa8 100644 --- a/src/r128_sarea.h +++ b/src/r128_sarea.h @@ -157,10 +157,12 @@ typedef struct { unsigned int vertsize; unsigned int vc_format; +#ifdef XF86DRI /* The current cliprects, or a subset thereof. */ drm_clip_rect_t boxes[R128_NR_SAREA_CLIPRECTS]; unsigned int nbox; +#endif /* Counters for throttling of rendering clients. */ diff --git a/src/r128_video.c b/src/r128_video.c index 8e83323..339bd66 100644 --- a/src/r128_video.c +++ b/src/r128_video.c @@ -15,6 +15,18 @@ #include "xf86.h" #include "dixstruct.h" +#include "xf86PciInfo.h" +#include "xf86i2c.h" +#include "fi1236.h" +#include "msp3430.h" +#include "bt829.h" +#include "tda9850.h" +#include "tda8425.h" +#include "generic_bus.h" +#include "theatre_reg.h" +#include "theatre.h" +#include "theatre_detect.h" +#include "i2c_def.h" #include <X11/extensions/Xv.h> #include "fourcc.h" @@ -28,6 +40,10 @@ #define TIMER_MASK (OFF_TIMER | FREE_TIMER) +#ifndef XvExtension +void R128InitVideo(ScreenPtr pScreen) {} +#else + static XF86VideoAdaptorPtr R128SetupImageVideo(ScreenPtr); static int R128SetPortAttribute(ScrnInfoPtr, Atom, INT32, pointer); static int R128GetPortAttribute(ScrnInfoPtr, Atom ,INT32 *, pointer); @@ -37,6 +53,9 @@ static void R128QueryBestSize(ScrnInfoPtr, Bool, short, short, short, short, static int R128PutImage(ScrnInfoPtr, short, short, short, short, short, short, short, short, int, unsigned char*, short, short, Bool, RegionPtr, pointer, DrawablePtr); +static int R128PutVideo(ScrnInfoPtr pScrn, short src_x, short src_y, short drw_x, short drw_y, + short src_w, short src_h, short drw_w, short drw_h, + RegionPtr clipBoxes, pointer data); static int R128QueryImageAttributes(ScrnInfoPtr, int, unsigned short *, unsigned short *, int *, int *); @@ -48,12 +67,31 @@ static void R128VideoTimerCallback(ScrnInfoPtr pScrn, Time now); #define MAKE_ATOM(a) MakeAtom(a, sizeof(a) - 1, TRUE) -static Atom xvBrightness, xvColorKey, xvSaturation, xvDoubleBuffer; +static Atom xvBrightness, xvColorKey, xvSaturation, xvColor, xvDoubleBuffer, + xvEncoding, xvVolume, xvMute, xvFrequency, xvContrast, xvHue, + xv_autopaint_colorkey, xv_set_defaults, xvTunerStatus, xvSAP, + xvLocationID, xvDeviceID, xvInstanceID; + +typedef struct +{ + BYTE table_revision; + BYTE table_size; + BYTE tuner_type; + BYTE audio_chip; + BYTE product_id; + BYTE tuner_voltage_teletext_fm; + BYTE i2s_config; /* configuration of the sound chip */ + BYTE video_decoder_type; + BYTE video_decoder_host_config; + BYTE input[5]; +} _MM_TABLE; typedef struct { int brightness; int saturation; + int contrast; + int hue; Bool doubleBuffer; unsigned char currentBuffer; FBLinearPtr linear; @@ -62,9 +100,55 @@ typedef struct { CARD32 videoStatus; Time offTime; Time freeTime; + + I2CBusPtr i2c; + CARD32 r128_i2c_timing; + CARD32 r128_M; + CARD32 r128_N; + + FI1236Ptr fi1236; + MSP3430Ptr msp3430; + BT829Ptr bt829; + TDA9850Ptr tda9850; + TDA8425Ptr tda8425; + + GENERIC_BUS_Ptr VIP; + TheatrePtr theatre; + + Bool video_stream_active; + int encoding; + CARD32 frequency; + int volume; + Bool mute; + int sap_channel; + int v; int ecp_div; + + Bool MM_TABLE_valid; + _MM_TABLE MM_TABLE; + + Bool EEPROM_present; + int EEPROM_addr; + + Bool addon_board; + CARD8 board_info; + int board_control; + + Bool autopaint_colorkey; + Atom device_id, location_id, instance_id; + } R128PortPrivRec, *R128PortPrivPtr; +static void R128MuteAudio(R128PortPrivPtr pPriv, Bool mute); +void R128_detect_addon(R128PortPrivPtr pPriv); +Bool R128SetupTheatre(ScrnInfoPtr pScrn, R128PortPrivPtr pPriv, TheatrePtr t); +void R128_RT_SetEncoding(R128PortPrivPtr pPriv); +void R128_MSP_SetEncoding(R128PortPrivPtr pPriv); +void R128_BT_SetEncoding(R128PortPrivPtr pPriv); +void R128_board_setmisc(R128PortPrivPtr pPriv); +void R128VIP_init(ScrnInfoPtr pScrn, R128PortPrivPtr pPriv); +void R128VIP_reset(ScrnInfoPtr pScrn, R128PortPrivPtr pPriv); + static void R128ECP(ScrnInfoPtr pScrn, R128PortPrivPtr pPriv) { R128InfoPtr info = R128PTR(pScrn); @@ -81,10 +165,12 @@ static void R128ECP(ScrnInfoPtr pScrn, R128PortPrivPtr pPriv) void R128InitVideo(ScreenPtr pScreen) { ScrnInfoPtr pScrn = xf86Screens[pScreen->myNum]; + R128InfoPtr info = R128PTR(pScrn); XF86VideoAdaptorPtr *adaptors, *newAdaptors = NULL; XF86VideoAdaptorPtr newAdaptor = NULL; int num_adaptors; + if(info->accel && info->accel->FillSolidRects) newAdaptor = R128SetupImageVideo(pScreen); num_adaptors = xf86XVListGenericAdaptors(pScrn, &adaptors); @@ -125,6 +211,29 @@ static XF86VideoEncodingRec DummyEncoding = {1, 1} }; + /* the picture is interlaced - hence the half-heights */ + +static XF86VideoEncodingRec +InputVideoEncodings[] = +{ + { 0, "XV_IMAGE", 2048,2048,{1,1}}, + { 1, "pal-composite", 720, 288, { 1, 50 }}, + { 2, "pal-tuner", 720, 288, { 1, 50 }}, + { 3, "pal-svideo", 720, 288, { 1, 50 }}, + { 4, "ntsc-composite", 640, 240, { 1001, 60000 }}, + { 5, "ntsc-tuner", 640, 240, { 1001, 60000 }}, + { 6, "ntsc-svideo", 640, 240, { 1001, 60000 }}, + { 7, "secam-composite", 720, 288, { 1, 50 }}, + { 8, "secam-tuner", 720, 288, { 1, 50 }}, + { 9, "secam-svideo", 720, 288, { 1, 50 }}, + { 10,"pal_60-composite", 768, 288, { 1, 50 }}, + { 11,"pal_60-tuner", 768, 288, { 1, 50 }}, + { 12,"pal_60-svideo", 768, 288, { 1, 50 }}, + { 13, "pal_m-composite", 640, 240, { 1001, 60000 }}, + { 14, "pal_m-tuner", 640, 240, { 1001, 60000 }}, + { 15, "pal_m-svideo", 640, 240, { 1001, 60000 }} +}; + #define NUM_FORMATS 12 static XF86VideoFormatRec Formats[NUM_FORMATS] = @@ -136,14 +245,29 @@ static XF86VideoFormatRec Formats[NUM_FORMATS] = }; -#define NUM_ATTRIBUTES 4 +#define NUM_ATTRIBUTES 18 -static XF86AttributeRec Attributes[NUM_ATTRIBUTES] = +static XF86AttributeRec Attributes[NUM_ATTRIBUTES+1] = { - {XvSettable | XvGettable, 0, (1 << 24) - 1, "XV_COLORKEY"}, - {XvSettable | XvGettable, -64, 63, "XV_BRIGHTNESS"}, - {XvSettable | XvGettable, 0, 31, "XV_SATURATION"}, - {XvSettable | XvGettable, 0, 1, "XV_DOUBLE_BUFFER"} + { XvGettable, 0, ~0, "XV_DEVICE_ID"}, + { XvGettable, 0, ~0, "XV_LOCATION_ID"}, + { XvGettable, 0, ~0, "XV_INSTANCE_ID"}, + {XvSettable , 0, 1, "XV_SET_DEFAULTS"}, + {XvSettable | XvGettable, 0, 1, "XV_AUTOPAINT_COLORKEY"}, + {XvSettable | XvGettable, 0, ~0, "XV_COLORKEY"}, + {XvSettable | XvGettable, 0, 1, "XV_DOUBLE_BUFFER"}, + {XvSettable | XvGettable, 0, 12, "XV_ENCODING"}, + {XvSettable | XvGettable, 0, -1, "XV_FREQ"}, + {XvGettable, -1000, 1000, "XV_TUNER_STATUS"}, + {XvSettable | XvGettable, -1000, 1000, "XV_BRIGHTNESS"}, + {XvSettable | XvGettable, -1000, 1000, "XV_CONTRAST"}, + {XvSettable | XvGettable, -1000, 1000, "XV_SATURATION"}, + {XvSettable | XvGettable, -1000, 1000, "XV_COLOR"}, + {XvSettable | XvGettable, -1000, 1000, "XV_HUE"}, + {XvSettable | XvGettable, 0, 1, "XV_MUTE"}, + {XvSettable | XvGettable, 0, 1, "XV_SAP" }, + {XvSettable | XvGettable, -1000, 1000, "XV_VOLUME"}, + { 0, 0, 0, NULL} /* just a place holder so I don't have to be fancy with commas */ }; #define NUM_IMAGES 4 @@ -157,24 +281,1018 @@ static XF86ImageRec Images[NUM_IMAGES] = }; static void +R128MuteAudio(R128PortPrivPtr pPriv, Bool mute) +{ + pPriv->mute=mute; + if (pPriv->msp3430 != NULL) xf86_MSP3430SetVolume(pPriv->msp3430, mute ? MSP3430_FAST_MUTE : MSP3430_VOLUME(pPriv->volume)); + if (pPriv->tda9850 != NULL) xf86_tda9850_mute(pPriv->tda9850, mute); + if (pPriv->tda8425 != NULL) xf86_tda8425_mute(pPriv->tda8425, mute); + if ((pPriv->bt829 != NULL) && (pPriv->bt829->out_en)) { + if (mute) xf86_bt829_SetP_IO(pPriv->bt829, 0x02); + else { + switch (pPriv->bt829->mux) { + case BT829_MUX2: + xf86_bt829_SetP_IO(pPriv->bt829, 0x00); + break; + case BT829_MUX0: + xf86_bt829_SetP_IO(pPriv->bt829, 0x01); + break; + case BT829_MUX1: + xf86_bt829_SetP_IO(pPriv->bt829, 0x00); + break; + default: /* shouldn't get here */ + xf86_bt829_SetP_IO(pPriv->bt829, 0x00); /* hardware default */ + break; + } + } + } +} + +void R128LeaveVT_Video(ScrnInfoPtr pScrn) +{ + R128InfoPtr info = R128PTR(pScrn); + R128PortPrivPtr pPriv; + xf86DrvMsg(pScrn->scrnIndex, X_INFO, "LeaveVT: Shutting down Xvideo subsystems\n"); + + if(info->adaptor==NULL)return; + pPriv = info->adaptor->pPortPrivates[0].ptr; + R128ResetVideo(pScrn); + if(pPriv==NULL)return; + if(pPriv->theatre!=NULL){ + xf86_ShutdownTheatre(pPriv->theatre); + } +} + +void R128EnterVT_Video(ScrnInfoPtr pScrn) +{ + R128InfoPtr info = R128PTR(pScrn); + R128PortPrivPtr pPriv; + + xf86DrvMsg(pScrn->scrnIndex, X_INFO, "Starting up Xvideo subsystems\n"); + if(info->adaptor==NULL)return; + pPriv = info->adaptor->pPortPrivates[0].ptr; + if(pPriv==NULL)return; + R128ResetVideo(pScrn); +} + +void R128ShutdownVideo(ScrnInfoPtr pScrn) +{ + R128InfoPtr info = R128PTR(pScrn); + R128PortPrivPtr pPriv = info->adaptor->pPortPrivates[0].ptr; + xf86DrvMsg(pScrn->scrnIndex, X_INFO, "** Shutting down Xvideo subsystems\n"); + if(pPriv->theatre!=NULL){ + xf86_ShutdownTheatre(pPriv->theatre); + } + if(pPriv->i2c!=NULL){ + if(pPriv->msp3430!=NULL){ + xfree(pPriv->msp3430); + pPriv->msp3430=NULL; + } + if(pPriv->fi1236!=NULL){ + xfree(pPriv->fi1236); + pPriv->fi1236=NULL; + } + if(pPriv->bt829!=NULL){ + xfree(pPriv->bt829); + pPriv->bt829=NULL; + } + if(pPriv->tda9850!=NULL){ + xfree(pPriv->tda9850); + pPriv->tda9850=NULL; + } + if(pPriv->tda8425!=NULL){ + xfree(pPriv->tda8425); + pPriv->tda8425=NULL; + } + DestroyI2CBusRec(pPriv->i2c, TRUE, TRUE); + pPriv->i2c=NULL; + } + if(pPriv->VIP!=NULL){ + xfree(pPriv->VIP); + pPriv->VIP=NULL; + } + if(pPriv->theatre!=NULL){ + xfree(pPriv->theatre); + pPriv->theatre=NULL; + } +} + +void R128ResetVideo(ScrnInfoPtr pScrn) { R128InfoPtr info = R128PTR(pScrn); unsigned char *R128MMIO = info->MMIO; R128PortPrivPtr pPriv = info->adaptor->pPortPrivates[0].ptr; + char tmp[200]; + /* this is done here because each time the server is reset these + could change.. Otherwise they remain constant */ + xvBrightness = MAKE_ATOM("XV_BRIGHTNESS"); + xvSaturation = MAKE_ATOM("XV_SATURATION"); + xvColor = MAKE_ATOM("XV_COLOR"); + xvContrast = MAKE_ATOM("XV_CONTRAST"); + xvColorKey = MAKE_ATOM("XV_COLORKEY"); + xvDoubleBuffer = MAKE_ATOM("XV_DOUBLE_BUFFER"); + xvEncoding = MAKE_ATOM("XV_ENCODING"); + xvTunerStatus = MAKE_ATOM("XV_TUNER_STATUS"); + xvFrequency = MAKE_ATOM("XV_FREQ"); + xvVolume = MAKE_ATOM("XV_VOLUME"); + xvMute = MAKE_ATOM("XV_MUTE"); + xvSAP = MAKE_ATOM("XV_SAP"); + xvHue = MAKE_ATOM("XV_HUE"); + xv_autopaint_colorkey = MAKE_ATOM("XV_AUTOPAINT_COLORKEY"); + xv_set_defaults = MAKE_ATOM("XV_SET_DEFAULTS"); + + xvInstanceID = MAKE_ATOM("XV_INSTANCE_ID"); + xvDeviceID = MAKE_ATOM("XV_DEVICE_ID"); + xvLocationID = MAKE_ATOM("XV_LOCATION_ID"); + + sprintf(tmp, "RXXX:%d.%d.%d", info->PciInfo->vendor, info->PciInfo->chipType, info->PciInfo->chipRev); + pPriv->device_id = MAKE_ATOM(tmp); + sprintf(tmp, "PCI:%02d:%02d.%d", info->PciInfo->bus, info->PciInfo->device, info->PciInfo->func); + pPriv->location_id = MAKE_ATOM(tmp); + sprintf(tmp, "INSTANCE:%d", pScrn->scrnIndex); + pPriv->instance_id = MAKE_ATOM(tmp); + + + R128WaitForFifo(pScrn, 11); OUTREG(R128_OV0_SCALE_CNTL, 0x80000000); OUTREG(R128_OV0_EXCLUSIVE_HORZ, 0); OUTREG(R128_OV0_AUTO_FLIP_CNTL, 0); /* maybe */ OUTREG(R128_OV0_FILTER_CNTL, 0x0000000f); - OUTREG(R128_OV0_COLOUR_CNTL, (pPriv->brightness & 0x7f) | - (pPriv->saturation << 8) | - (pPriv->saturation << 16)); + OUTREG(R128_OV0_COLOUR_CNTL, (((pPriv->brightness*64)/1000) & 0x7f) | + (((pPriv->saturation*31+31000)/2000) << 8) | + (((pPriv->saturation*31+31000)/2000) << 16)); OUTREG(R128_OV0_GRAPHICS_KEY_MSK, (1 << pScrn->depth) - 1); OUTREG(R128_OV0_GRAPHICS_KEY_CLR, pPriv->colorKey); OUTREG(R128_OV0_KEY_CNTL, R128_GRAPHIC_KEY_FN_NE); OUTREG(R128_OV0_TEST, 0); + OUTPLL(R128_FCP_CNTL, 0x404); + OUTREG(R128_CAP0_TRIG_CNTL, 0x0); + + if(pPriv->VIP!=NULL){ + R128VIP_init(pScrn, pPriv); + } + + if(pPriv->theatre != NULL){ + xf86_InitTheatre(pPriv->theatre); + } +} + + +#define I2C_DONE (1<<0) +#define I2C_NACK (1<<1) +#define I2C_HALT (1<<2) +#define I2C_SOFT_RST (1<<5) +#define I2C_DRIVE_EN (1<<6) +#define I2C_DRIVE_SEL (1<<7) +#define I2C_START (1<<8) +#define I2C_STOP (1<<9) +#define I2C_RECEIVE (1<<10) +#define I2C_ABORT (1<<11) +#define I2C_GO (1<<12) +#define I2C_SEL (1<<16) +#define I2C_EN (1<<17) + + +/**************************************************************************** + * I2C_WaitForAck (void) * + * * + * Function: polls the I2C status bits, waiting for an acknowledge or * + * an error condition. * + * Inputs: NONE * + * Outputs: I2C_DONE - the I2C transfer was completed * + * I2C_NACK - an NACK was received from the slave * + * I2C_HALT - a timeout condition has occured * + ****************************************************************************/ +static CARD8 R128_I2C_WaitForAck (ScrnInfoPtr pScrn, R128PortPrivPtr pPriv) +{ + CARD8 retval = 0; + R128InfoPtr info = R128PTR(pScrn); + unsigned char *R128MMIO = info->MMIO; + long counter = 0; + + usleep(1000); + while(1) + { + retval = INREG8(R128_I2C_CNTL_0); + if (retval & I2C_HALT) + { + return (I2C_HALT); + } + if (retval & I2C_NACK) + { + return (I2C_NACK); + } + if (retval & I2C_DONE) + { + return (I2C_DONE); + } + counter++; + if(counter>1000000) + { + xf86DrvMsg(pScrn->scrnIndex, X_INFO, "Timeout condition on rage128 i2c bus\n"); + return (I2C_HALT); + } + + } +} + +static void R128_I2C_Halt (ScrnInfoPtr pScrn) +{ + R128InfoPtr info = R128PTR(pScrn); + unsigned char *R128MMIO = info->MMIO; + CARD8 reg; + long counter = 0; + + /* reset status flags */ + reg = INREG8 (R128_I2C_CNTL_0 + 0) & 0xF8; + OUTREG8 (R128_I2C_CNTL_0 + 0, reg); + + /* issue ABORT call */ + reg = INREG8 (R128_I2C_CNTL_0 + 1) & 0xE7; + OUTREG8 (R128_I2C_CNTL_0 + 1, (reg | 0x18)); + + /* wait for GO bit to go low */ + while (INREG8 (R128_I2C_CNTL_0 + 1) & (I2C_GO >> 8)) + { + counter++; + if(counter>1000000)return; + } + +} + + + +static Bool R128I2CWriteRead(I2CDevPtr d, I2CByte *WriteBuffer, int nWrite, + I2CByte *ReadBuffer, int nRead) +{ + int loop, status; + CARD32 i2c_cntl_0, i2c_cntl_1; + R128PortPrivPtr pPriv = (R128PortPrivPtr)(d->pI2CBus->DriverPrivate.ptr); + ScrnInfoPtr pScrn = xf86Screens[d->pI2CBus->scrnIndex]; + R128InfoPtr info = R128PTR(pScrn); + unsigned char *R128MMIO = info->MMIO; + + status=I2C_DONE; + + if(nWrite>0){ + R128WaitForFifo(pScrn, 4+nWrite); + + /* Clear the status bits of the I2C Controller */ + OUTREG(R128_I2C_CNTL_0, I2C_DONE | I2C_NACK | I2C_HALT | I2C_SOFT_RST); + + /* Write the address into the buffer first */ + OUTREG(R128_I2C_DATA, (CARD32) (d->SlaveAddr) & ~(1)); + + /* Write Value into the buffer */ + for (loop = 0; loop < nWrite; loop++) + { + OUTREG8(R128_I2C_DATA, WriteBuffer[loop]); + } + + i2c_cntl_1 = (pPriv->r128_i2c_timing << 24) | I2C_EN | I2C_SEL | + nWrite | 0x100; + OUTREG(R128_I2C_CNTL_1, i2c_cntl_1); + + i2c_cntl_0 = (pPriv->r128_N << 24) | (pPriv->r128_M << 16) | + I2C_GO | (1<<8) | (((nRead>0)?0:1) << 9) | I2C_DRIVE_EN; + OUTREG(R128_I2C_CNTL_0, i2c_cntl_0); + + while(INREG8(R128_I2C_CNTL_0+1) & (I2C_GO >> 8)); + + status=R128_I2C_WaitForAck(pScrn,pPriv); + + if(status!=I2C_DONE){ + R128_I2C_Halt(pScrn); + return FALSE; + } + } + + if(nRead > 0) { + R128WaitForFifo(pScrn, 4+nRead); + + OUTREG(R128_I2C_CNTL_0, 0x27); + + /* Write the address into the buffer first */ + OUTREG(R128_I2C_DATA, (CARD32) (d->SlaveAddr) | (1)); + + i2c_cntl_1 = (pPriv->r128_i2c_timing << 24) | I2C_EN | I2C_SEL | + nRead | 0x100; + OUTREG(R128_I2C_CNTL_1, i2c_cntl_1); + + i2c_cntl_0 = (pPriv->r128_N << 24) | (pPriv->r128_M << 16) | + I2C_GO | (1<<8) | ((1) << 9) | I2C_DRIVE_EN | I2C_RECEIVE; + OUTREG(R128_I2C_CNTL_0, i2c_cntl_0); + + while(INREG8(R128_I2C_CNTL_0+1) & (I2C_GO >> 8)); + + status=R128_I2C_WaitForAck(pScrn,pPriv); + + /* Write Value into the buffer */ + for (loop = 0; loop < nRead; loop++) + { + R128WaitForFifo(pScrn, 1); + if((status == I2C_HALT) || (status == I2C_NACK)) + { + ReadBuffer[loop]=0xff; + } else { + ReadBuffer[loop]=INREG8(R128_I2C_DATA) & 0xff; + } + } + + } + + if(status!=I2C_DONE){ + R128_I2C_Halt(pScrn); + return FALSE; + } + return TRUE; +} + +static Bool R128ProbeAddress(I2CBusPtr b, I2CSlaveAddr addr) +{ + I2CByte a; + I2CDevRec d; + + d.DevName = "Probing"; + d.SlaveAddr = addr; + d.pI2CBus = b; + d.NextDev = NULL; + + return I2C_WriteRead(&d, NULL, 0, &a, 1); +} + + +#define I2C_CLOCK_FREQ (80000.0) + +const struct +{ + char *name; + int type; +} R128_tuners[32] = + { + /* name ,index to tuner_parms table */ + {"NO TUNNER" , -1}, + {"FI1236" , TUNER_TYPE_FI1236}, + {"FI1236" , TUNER_TYPE_FI1236}, + {"FI1216" , TUNER_TYPE_FI1216}, + {"FI1246" , TUNER_TYPE_FI1246}, + {"FI1216MF" , TUNER_TYPE_FI1216}, + {"FI1236" , TUNER_TYPE_FI1236}, + {"FI1256" , TUNER_TYPE_FI1256}, + {"FI1236" , TUNER_TYPE_FI1236}, + {"FI1216" , TUNER_TYPE_FI1216}, + {"FI1246" , TUNER_TYPE_FI1246}, + {"FI1216MF" , TUNER_TYPE_FI1216}, + {"FI1236" , TUNER_TYPE_FI1236}, + {"TEMIC-FN5AL" , TUNER_TYPE_TEMIC_FN5AL}, + {"FQ1216ME/P" , TUNER_TYPE_FI1216}, + {"UNKNOWN-15" , -1}, + {"Alps TSBH5" , -1}, + {"Alps TSCxx" , -1}, + {"Alps TSCH5 FM" , -1}, + {"UNKNOWN-19" , -1}, + {"UNKNOWN-20" , -1}, + {"UNKNOWN-21" , -1}, + {"UNKNOWN-22" , -1}, + {"UNKNOWN-23" , -1}, + {"UNKNOWN-24" , -1}, + {"UNKNOWN-25" , -1}, + {"UNKNOWN-26" , -1}, + {"UNKNOWN-27" , -1}, + {"UNKNOWN-28" , -1}, + {"UNKNOWN-29" , -1}, + {"UNKNOWN-30" , -1}, + {"UNKNOWN-31" , -1} + }; + +static void R128ResetI2C(ScrnInfoPtr pScrn, R128PortPrivPtr pPriv) +{ + R128InfoPtr info = R128PTR(pScrn); + unsigned char *R128MMIO = info->MMIO; + + OUTREG8(R128_I2C_CNTL_1+2, ((I2C_SEL | I2C_EN)>>16)); + OUTREG8(R128_I2C_CNTL_0+0, (I2C_DONE | I2C_NACK | I2C_HALT | I2C_SOFT_RST | I2C_DRIVE_EN | I2C_DRIVE_SEL)); +} + +static void R128InitI2C(ScrnInfoPtr pScrn, R128PortPrivPtr pPriv) +{ + double nm; + R128InfoPtr info = R128PTR(pScrn); + R128PLLPtr pll = &(info->pll); + + pPriv->fi1236 = NULL; + pPriv->bt829 = NULL; + pPriv->tda9850 = NULL; + pPriv->msp3430 = NULL; + + if(pPriv->i2c==NULL) { + if(!xf86LoadSubModule(pScrn,"i2c")) { + xf86DrvMsg(pScrn->scrnIndex,X_ERROR,"Unable to initialize i2c bus\n"); + pPriv->i2c=NULL; + return; + } + xf86LoaderReqSymbols("xf86CreateI2CBusRec", + "xf86I2CBusInit", + "xf86DestroyI2CBus", + "xf86CreateI2CDevRec", + "xf86DestroyI2CDevRec", + "xf86I2CDevInit", + "xf86I2CWriteRead", + NULL); + pPriv->i2c=CreateI2CBusRec(); + pPriv->i2c->scrnIndex=pScrn->scrnIndex; + pPriv->i2c->BusName="Rage 128 multimedia bus"; + pPriv->i2c->DriverPrivate.ptr=(pointer)pPriv; + pPriv->i2c->I2CWriteRead=R128I2CWriteRead; + if(!I2CBusInit(pPriv->i2c)){ + xf86DrvMsg(pScrn->scrnIndex,X_ERROR,"Failed to register i2c bus\n"); + } + } + + nm=(pll->reference_freq * 10000.0)/(4.0 * I2C_CLOCK_FREQ); + for(pPriv->r128_N=1; pPriv->r128_N<255; pPriv->r128_N++) + if((pPriv->r128_N * (pPriv->r128_N-1)) > nm)break; + pPriv->r128_M=pPriv->r128_N-1; + pPriv->r128_i2c_timing=2*pPriv->r128_N; + + R128ResetI2C(pScrn, pPriv); + + /* You can't attach addon card to a notebook */ + if(!pPriv->MM_TABLE_valid && + (((info->Chipset != PCI_CHIP_RAGE128LE) && + (info->Chipset != PCI_CHIP_RAGE128LF) && + (info->Chipset != PCI_CHIP_RAGE128MF) && + (info->Chipset != PCI_CHIP_RAGE128ML)) || + info->forceXvProbing))R128_detect_addon(pPriv); + else pPriv->addon_board = FALSE; + + /* no multimedia capabilities detected */ + /* the following code _will_ lockup with MobilityM3 and no i2c device attached + at the moment no safe way is known to detect this (as BIOS has no multimedia table) */ + if(!pPriv->MM_TABLE_valid && !pPriv->addon_board) + { + if(!info->forceXvProbing){ + xf86DrvMsg(pScrn->scrnIndex, X_INFO, "No video input capabilities detected\n"); + return; + } else { + xf86DrvMsg(pScrn->scrnIndex, X_INFO, "No video input capabilities detected, but continuing anyway.\n"); + xf86DrvMsg(pScrn->scrnIndex, X_INFO, "Don't be surprised if the system locks up.\n"); + } + } + + if(!xf86LoadSubModule(pScrn,"fi1236")) + { + xf86DrvMsg(pScrn->scrnIndex, X_ERROR, "Unable to initialize fi1236 driver\n"); + } + else + { + xf86LoaderReqSymbols(FI1236SymbolsList, NULL); + if(pPriv->fi1236 == NULL) + { + pPriv->fi1236 = xf86_Detect_FI1236(pPriv->i2c, FI1236_ADDR_1); + } + if(pPriv->fi1236 == NULL) + { + pPriv->fi1236 = xf86_Detect_FI1236(pPriv->i2c, FI1236_ADDR_2); + } + } + if(pPriv->fi1236 != NULL) + { + xf86DrvMsg(pScrn->scrnIndex, X_INFO, "Detected %s device at 0x%02x\n", + R128_tuners[pPriv->board_info & 0x0f].name, + FI1236_ADDR(pPriv->fi1236)); + xf86_FI1236_set_tuner_type(pPriv->fi1236, R128_tuners[pPriv->board_info & 0x0f].type); + } + + if(!xf86LoadSubModule(pScrn, "bt829")) + { + xf86DrvMsg(pScrn->scrnIndex, X_ERROR, "Unable to initialize bt829 driver\n"); + } else + { + xf86LoaderReqSymbols(BT829SymbolsList, NULL); + if(pPriv->bt829 == NULL) + { + pPriv->bt829 = xf86_bt829_Detect(pPriv->i2c, BT829_ATI_ADDR_1); + } + if(pPriv->bt829 == NULL) + { + pPriv->bt829 = xf86_bt829_Detect(pPriv->i2c, BT829_ATI_ADDR_2); + } + if(pPriv->bt829 != NULL) + { + pPriv->bt829->tunertype = pPriv->board_info & 0x0f; + if(xf86_bt829_ATIInit(pPriv->bt829) < 0)pPriv->bt829 = NULL; /* disable it */ + if(pPriv->MM_TABLE_valid && (pPriv->bt829!=NULL)) + { + xf86_bt829_SetP_IO(pPriv->bt829, 0x02); /* mute */ + xf86_bt829_SetOUT_EN(pPriv->bt829, 1); + } + } + } + +/* I am not sure whether this is really necessary.. but just in case - and it does + not hurt right now */ + +#if 1 + if(!pPriv->MM_TABLE_valid) + { + xf86DrvMsg(pScrn->scrnIndex,X_ERROR,"Skipping Rage Theatre detection because of absent or invalid MM_TABLE\n"); + pPriv->theatre=NULL; + } else +#endif + if(pPriv->bt829 == NULL){ + + R128VIP_init(pScrn,pPriv); + + if(!xf86LoadSubModule(pScrn,"theatre_detect")) + { + xf86DrvMsg(pScrn->scrnIndex,X_ERROR,"Unable to load Rage Theatre detect module\n"); + pPriv->theatre=NULL; + } else + { + pPriv->theatre=xf86_DetectTheatre(pPriv->VIP); + if((pPriv->theatre != NULL) && !R128SetupTheatre(pScrn, pPriv, pPriv->theatre)) + { + free(pPriv->theatre); + pPriv->theatre=NULL; + xf86DrvMsg(pScrn->scrnIndex, X_ERROR, "Failed to initialize Rage Theatre, chip disabled\n"); + } + + if(pPriv->theatre != NULL) { + if(!xf86LoadSubModule(pScrn,"theatre")) + { + xf86DrvMsg(pScrn->scrnIndex,X_ERROR,"Unable to load Rage Theatre module\n"); + pPriv->theatre=NULL; + } else + xf86_InitTheatre(pPriv->theatre); + } + } + } + + if((pPriv->bt829 == NULL) && (pPriv->theatre == NULL)) + /* No decoder found. No sense initializing audio chips */ + { + return; + } + + if(!xf86LoadSubModule(pScrn, "msp3430")) + { + xf86DrvMsg(pScrn->scrnIndex, X_ERROR, "Unable to initialize msp3430 driver\n"); + } + else + { + xf86LoaderReqSymbols(MSP3430SymbolsList, NULL); + if(pPriv->msp3430 == NULL) + { + pPriv->msp3430 = xf86_DetectMSP3430(pPriv->i2c, MSP3430_ADDR_1); + } + if(pPriv->msp3430 == NULL) + { + pPriv->msp3430 = xf86_DetectMSP3430(pPriv->i2c, MSP3430_ADDR_2); + } +#if 0 /* this would confuse bt829 with MSP3430 */ + if(pPriv->msp3430 == NULL) + { + pPriv->msp3430 = xf86_DetectMSP3430(pPriv->i2c, MSP3430_ADDR_3); + } +#endif + } + if(pPriv->msp3430 != NULL) + { + xf86DrvMsg(pScrn->scrnIndex, X_INFO, "Detected MSP3430 at 0x%02x\n", + MSP3430_ADDR(pPriv->msp3430)); + } + + if(!xf86LoadSubModule(pScrn, "tda9850")) + { + xf86DrvMsg(pScrn->scrnIndex, X_ERROR, "Unable to initialize tda9850 driver\n"); + } else + { + xf86LoaderReqSymbols(TDA9850SymbolsList, NULL); + if(pPriv->tda9850 == NULL) + { + pPriv->tda9850 = xf86_Detect_tda9850(pPriv->i2c, TDA9850_ADDR_1); + } + if(pPriv->tda9850 != NULL) + { + if(!xf86_tda9850_init(pPriv->tda9850))pPriv->tda9850 = NULL; /* disable it */ + } + if(pPriv->tda9850 != NULL) + { + xf86_tda9850_setaudio(pPriv->tda9850); + xf86DrvMsg(pScrn->scrnIndex, X_INFO, "tda9850 status 0x%04x\n", xf86_tda9850_getstatus(pPriv->tda9850)); + } + } + if(!xf86LoadSubModule(pScrn, "tda8425")) + { + xf86DrvMsg(pScrn->scrnIndex, X_ERROR, "Unable to initialize tda8425 driver\n"); + } else + { + /* Bug bug bug. I don't know how to probe a write-only device properly with Rage 128 + hardware assisted i2c. Help ?! */ + xf86LoaderReqSymbols(TDA8425SymbolsList, NULL); + if((pPriv->tda8425 == NULL) && !pPriv->MM_TABLE_valid) + { + pPriv->tda8425 = xf86_Detect_tda8425(pPriv->i2c, TDA8425_ADDR_1, TRUE); + } + if(pPriv->tda8425 != NULL) + { + if(!xf86_tda8425_init(pPriv->tda8425))pPriv->tda8425 = NULL; /* disable it */ + } + } + + if(pPriv->i2c!=NULL) R128_board_setmisc(pPriv); +} + +#define VIP_NAME "R128 VIP BUS" +#define VIP_TYPE "ATI VIP BUS" + +static Bool R128VIP_ioctl(GENERIC_BUS_Ptr b, long ioctl, long arg1, char *arg2) +{ + long count; + switch(ioctl){ + case GB_IOCTL_GET_NAME: + count=strlen(VIP_NAME)+1; + if(count>arg1)return FALSE; + memcpy(arg2,VIP_NAME,count); + return TRUE; + + case GB_IOCTL_GET_TYPE: + count=strlen(VIP_TYPE)+1; + if(count>arg1)return FALSE; + memcpy(arg2,VIP_TYPE,count); + return TRUE; + + default: + return FALSE; + } +} + +static CARD32 R128VIP_idle(GENERIC_BUS_Ptr b) +{ + ScrnInfoPtr pScrn = xf86Screens[b->scrnIndex]; + R128InfoPtr info = R128PTR(pScrn); + unsigned char *R128MMIO = info->MMIO; + + CARD32 timeout; + + timeout = INREG(VIPH_TIMEOUT_STAT); + if(timeout & VIPH_TIMEOUT_STAT__VIPH_REG_STAT) /* lockup ?? */ + { + OUTREG(VIPH_TIMEOUT_STAT, (timeout & 0xffffff00) | VIPH_TIMEOUT_STAT__VIPH_REG_AK); + return (INREG(VIPH_CONTROL) & 0x2000) ? VIP_BUSY: VIP_RESET; + } + return (INREG(VIPH_CONTROL) & 0x2000) ? VIP_BUSY: VIP_IDLE; +} + +/* address format: + ((device & 0x3)<<14) | (fifo << 12) | (addr) +*/ + +static Bool R128VIP_read(GENERIC_BUS_Ptr b, CARD32 address, CARD32 count, CARD8 *buffer) +{ + ScrnInfoPtr pScrn = xf86Screens[b->scrnIndex]; + R128InfoPtr info = R128PTR(pScrn); + unsigned char *R128MMIO = info->MMIO; + CARD32 status; + + if((count!=1) && (count!=2) && (count!=4)) + { + xf86DrvMsg(pScrn->scrnIndex,X_ERROR,"Attempt to access VIP bus with non-stadard transaction length\n"); + return FALSE; + } + + OUTREG(VIPH_REG_ADDR, address | 0x2000); + while(VIP_BUSY == (status = R128VIP_idle(b))); + if(VIP_IDLE != status) return FALSE; + +/* + disable VIPH_REGR_DIS to enable VIP cycle. + The LSB of VIPH_TIMEOUT_STAT are set to 0 + because 1 would have acknowledged various VIP + interrupts unexpectedly +*/ + OUTREG(VIPH_TIMEOUT_STAT, INREG(VIPH_TIMEOUT_STAT) & (0xffffff00 & ~VIPH_TIMEOUT_STAT__VIPH_REGR_DIS) ); +/* + the value returned here is garbage. The read merely initiates + a register cycle +*/ + INREG(VIPH_REG_DATA); + + while(VIP_BUSY == (status = R128VIP_idle(b))); + if(VIP_IDLE != status) return FALSE; +/* + set VIPH_REGR_DIS so that the read won't take too long. +*/ + OUTREG(VIPH_TIMEOUT_STAT, (INREG(VIPH_TIMEOUT_STAT) & 0xffffff00) | VIPH_TIMEOUT_STAT__VIPH_REGR_DIS); + switch(count){ + case 1: + *buffer=(CARD8)(INREG(VIPH_REG_DATA) & 0xff); + break; + case 2: + *(CARD16 *)buffer=(CARD16) (INREG(VIPH_REG_DATA) & 0xffff); + break; + case 4: + *(CARD32 *)buffer=(CARD32) ( INREG(VIPH_REG_DATA) & 0xffffffff); + break; + } + while(VIP_BUSY == (status = R128VIP_idle(b))); + if(VIP_IDLE != status) return FALSE; + /* + so that reading VIPH_REG_DATA would not trigger unnecessary vip cycles. +*/ + OUTREG(VIPH_TIMEOUT_STAT, (INREG(VIPH_TIMEOUT_STAT) & 0xffffff00) | VIPH_TIMEOUT_STAT__VIPH_REGR_DIS); + return TRUE; +} + +static Bool R128VIP_write(GENERIC_BUS_Ptr b, CARD32 address, CARD32 count, CARD8 *buffer) +{ + ScrnInfoPtr pScrn = xf86Screens[b->scrnIndex]; + R128InfoPtr info = R128PTR(pScrn); + unsigned char *R128MMIO = info->MMIO; + + CARD32 status; + + + if((count!=4)) + { + xf86DrvMsg(pScrn->scrnIndex, X_ERROR, "Attempt to access VIP bus with non-stadard transaction length\n"); + return FALSE; + } + + OUTREG(VIPH_REG_ADDR, address & (~0x2000)); + while(VIP_BUSY == (status = R128VIP_idle(b))); + + if(VIP_IDLE != status) return FALSE; + + switch(count){ + case 4: + OUTREG(VIPH_REG_DATA, *(CARD32 *)buffer); + break; + } + while(VIP_BUSY == (status = R128VIP_idle(b))); + if(VIP_IDLE != status) return FALSE; + return TRUE; +} + +static int R128_eeprom_addresses[] = { 0xA8, 0x70, 0x40, 0x78, 0x72, 0x42, 0}; + +static void R128_read_eeprom(R128PortPrivPtr pPriv) +{ + I2CDevRec d; + unsigned char data[5]; + int i; + if(pPriv->i2c == NULL) return; + + d.DevName = "temporary"; + d.pI2CBus = pPriv->i2c; + d.NextDev = NULL; + d.StartTimeout = pPriv->i2c->StartTimeout; + d.BitTimeout = pPriv->i2c->BitTimeout; + d.AcknTimeout = pPriv->i2c->AcknTimeout; + d.ByteTimeout = pPriv->i2c->ByteTimeout; + pPriv->EEPROM_addr = 0; + + for(i=0;R128_eeprom_addresses[i];i++) + { + d.SlaveAddr = R128_eeprom_addresses[i]; + data[0]=0x00; + if(!I2C_WriteRead(&d, data, 1, NULL, 0))continue; + if(!I2C_WriteRead(&d, NULL, 0, data, 5))continue; + if(!memcmp(data, "ATI", 3)) + { + pPriv->EEPROM_present = TRUE; + pPriv->EEPROM_addr = R128_eeprom_addresses[i]; + break; + } + xf86DrvMsg(pPriv->i2c->scrnIndex, X_INFO, "Device at eeprom addr 0x%02x found, returned 0x%02x-0x%02x-0x%02x-0x%02x-0x%02x\n", + d.SlaveAddr, + data[0], data[1], data[2], data[3], data[4]); + } + + +} + +void R128VIP_reset(ScrnInfoPtr pScrn, R128PortPrivPtr pPriv) +{ + R128InfoPtr info = R128PTR(pScrn); + unsigned char *R128MMIO = info->MMIO; + + R128WaitForFifo(pScrn, 7); + OUTREG(VIPH_CONTROL, 0x003F0004); /* slowest, timeout in 16 phases */ + OUTREG(VIPH_TIMEOUT_STAT, (INREG(VIPH_TIMEOUT_STAT) & 0xFFFFFF00) | VIPH_TIMEOUT_STAT__VIPH_REGR_DIS); + OUTREG(VIPH_DV_LAT, 0x444400FF); /* set timeslice */ + OUTREG(VIPH_BM_CHUNK, 0x151); + OUTREG(R128_TEST_DEBUG_CNTL, INREG(R128_TEST_DEBUG_CNTL) & (~TEST_DEBUG_CNTL__TEST_DEBUG_OUT_EN)); + OUTREG(R128_MPP_GP_CONFIG, 0); + OUTREG(R128_MPP_TB_CONFIG, 0); +} + +void R128VIP_init(ScrnInfoPtr pScrn, R128PortPrivPtr pPriv) +{ + pPriv->VIP=xcalloc(1,sizeof(GENERIC_BUS_Rec)); + pPriv->VIP->scrnIndex=pScrn->scrnIndex; + pPriv->VIP->DriverPrivate.ptr=pPriv; + pPriv->VIP->ioctl=R128VIP_ioctl; + pPriv->VIP->read=R128VIP_read; + pPriv->VIP->write=R128VIP_write; + + R128VIP_reset(pScrn, pPriv); +} + + +static void R128ReadMM_TABLE(ScrnInfoPtr pScrn, R128PortPrivPtr pPriv) +{ + R128InfoPtr info = R128PTR(pScrn); + CARD16 mm_table; + CARD16 bios_header; + + + if((info->VBIOS==NULL)||(info->VBIOS[0]!=0x55)||(info->VBIOS[1]!=0xaa)){ + xf86DrvMsg(pScrn->scrnIndex, X_INFO, "Cannot access BIOS or it is not valid.\n" + "\t\tYou will need to specify options RageTheatreCrystal, RageTheatreTunerPort, \n" + "\t\tRageTheatreSVideoPort and TunerType in /etc/XF86Config.\n" + ); + pPriv->MM_TABLE_valid = FALSE; + } else { + + + bios_header=info->VBIOS[0x48]; + bios_header+=(((int)info->VBIOS[0x49]+0)<<8); + + mm_table=info->VBIOS[bios_header+0x38]; + if(mm_table==0) + { + xf86DrvMsg(pScrn->scrnIndex,X_INFO,"No MM_TABLE found, %x, %x\n",bios_header,mm_table); + pPriv->MM_TABLE_valid = FALSE; + goto forced_settings; + } + + mm_table+=(((int)info->VBIOS[bios_header+0x39]+0)<<8)-2; + + xf86DrvMsg(pScrn->scrnIndex,X_INFO,"VIDEO BIOS TABLE OFFSETS: bios_header=0x%04x mm_table=0x%04x\n",bios_header,mm_table); + + if(mm_table>0) + { + memcpy(&(pPriv->MM_TABLE), &(info->VBIOS[mm_table]), sizeof(_MM_TABLE)); + xf86DrvMsg(pScrn->scrnIndex, X_INFO, "MM_TABLE: %02x-%02x-%02x-%02x-%02x-%02x-%02x-%02x-%02x-%02x-%02x-%02x-%02x-%02x\n", + pPriv->MM_TABLE.table_revision, + pPriv->MM_TABLE.table_size, + pPriv->MM_TABLE.tuner_type, + pPriv->MM_TABLE.audio_chip, + pPriv->MM_TABLE.product_id, + pPriv->MM_TABLE.tuner_voltage_teletext_fm, + pPriv->MM_TABLE.i2s_config, + pPriv->MM_TABLE.video_decoder_type, + pPriv->MM_TABLE.video_decoder_host_config, + pPriv->MM_TABLE.input[0], + pPriv->MM_TABLE.input[1], + pPriv->MM_TABLE.input[2], + pPriv->MM_TABLE.input[3], + pPriv->MM_TABLE.input[4]); + pPriv->MM_TABLE_valid = TRUE; + pPriv->board_info = pPriv->MM_TABLE.tuner_type; + } else { + xf86DrvMsg(pScrn->scrnIndex,X_INFO,"No MM_TABLE found: %x, %x\n",bios_header,mm_table); + pPriv->MM_TABLE_valid = FALSE; + } } + forced_settings: + + if(info->tunerType>=0){ + pPriv->MM_TABLE.tuner_type=info->tunerType; + pPriv->board_info=info->tunerType; + } + /* enough information was provided in the options */ + + if(!pPriv->MM_TABLE_valid && (info->tunerType>=0) && (info->RageTheatreCrystal>=0) && + (info->RageTheatreTunerPort>=0) && (info->RageTheatreCompositePort>=0) && + (info->RageTheatreSVideoPort>=0) ) { + pPriv->MM_TABLE_valid = TRUE; + } +} + +static int R128_addon_addresses[] = { 0x70, 0x40, 0x78, 0x72, 0x42, 0}; + +void R128_detect_addon(R128PortPrivPtr pPriv) +{ + I2CDevRec d; + CARD8 data[1]; + int i; + if(pPriv->i2c == NULL) return; + + d.DevName = "temporary"; + d.pI2CBus = pPriv->i2c; + d.NextDev = NULL; + d.StartTimeout = pPriv->i2c->StartTimeout; + d.BitTimeout = pPriv->i2c->BitTimeout; + d.AcknTimeout = pPriv->i2c->AcknTimeout; + d.ByteTimeout = pPriv->i2c->ByteTimeout; + pPriv->addon_board = FALSE; + + for(i=0;R128_addon_addresses[i];i++) + { + d.SlaveAddr = R128_addon_addresses[i]; + data[0]=0xFF; + if(!I2C_WriteRead(&d, data, 1, NULL, 0))continue; + if(!I2C_WriteRead(&d, NULL, 0, data, 1))continue; + if((data[0] == 0xFF) || (data[0] == 0x00))continue; + pPriv->addon_board = TRUE; + pPriv->board_control = R128_addon_addresses[i]; + pPriv->board_info = data[0]; + xf86DrvMsg(pPriv->i2c->scrnIndex, X_INFO, "Standalone board at addr 0x%02x found, returned 0x%02x\n", + d.SlaveAddr, + data[0]); + R128_board_setmisc(pPriv); + break; + } + + +} + +Bool R128SetupTheatre(ScrnInfoPtr pScrn, R128PortPrivPtr pPriv, TheatrePtr t) +{ + R128InfoPtr info = R128PTR(pScrn); + R128PLLPtr pll = &(info->pll); + + CARD8 a; + CARD16 bios_header; + CARD16 pll_info_block; + int i; + + xf86DrvMsg(pScrn->scrnIndex, X_INFO, "0x%02x 0x%02x\n", info->VBIOS[0], + info->VBIOS[1]); + bios_header=info->VBIOS[0x48]; + bios_header+=(((int)info->VBIOS[0x49]+0)<<8); + + pll_info_block=info->VBIOS[bios_header+0x30]; + pll_info_block+=(((int)info->VBIOS[bios_header+0x31]+0)<<8); + + t->video_decoder_type=info->VBIOS[pll_info_block+0x08]; + t->video_decoder_type+=(((int)info->VBIOS[pll_info_block+0x09]+0)<<8); + + xf86DrvMsg(t->VIP->scrnIndex,X_INFO,"video decoder type is 0x%04x versus 0x%04x\n",t->video_decoder_type, + pll->xclk); + + if(!pPriv->MM_TABLE_valid) + { + xf86DrvMsg(t->VIP->scrnIndex, X_INFO, "no multimedia table present, not using Rage Theatre for input\n"); + free(pPriv->theatre); + pPriv->theatre = NULL; + return FALSE; + } + for(i=0;i<5;i++){ + a=pPriv->MM_TABLE.input[i]; + + switch(a & 0x3){ + case 1: + t->wTunerConnector=i; + xf86DrvMsg(t->VIP->scrnIndex,X_INFO,"Tuner is on port %d\n",i); + break; + case 2: if(a & 0x4){ + t->wComp0Connector=RT_COMP2; + } else { + t->wComp0Connector=RT_COMP1; + } + xf86DrvMsg(t->VIP->scrnIndex,X_INFO,"Composite connector is port %d\n",(int)t->wComp0Connector); + break; + case 3: if(a & 0x4){ + t->wSVideo0Connector=RT_YCR_COMP4; + } else { + t->wSVideo0Connector=RT_YCF_COMP4; + } + xf86DrvMsg(t->VIP->scrnIndex,X_INFO,"SVideo connector is port %d\n",(int)t->wSVideo0Connector); + break; + default: + break; + } + } + + xf86DrvMsg(t->VIP->scrnIndex,X_INFO,"Rage Theatre: Connectors (detected): tuner=%d, composite=%d, svideo=%d\n",(int)t->wTunerConnector, (int)t->wComp0Connector, (int)t->wSVideo0Connector); + + if(info->RageTheatreTunerPort>=0)t->wTunerConnector=info->RageTheatreTunerPort; + if(info->RageTheatreCompositePort>=0)t->wComp0Connector=info->RageTheatreCompositePort; + if(info->RageTheatreSVideoPort>=0)t->wSVideo0Connector=info->RageTheatreSVideoPort; + + xf86DrvMsg(t->VIP->scrnIndex,X_INFO,"Rage Theatre: Connectors (using): tuner=%d, composite=%d, svideo=%d\n",(int)t->wTunerConnector, (int)t->wComp0Connector, (int)t->wSVideo0Connector); + + switch((info->RageTheatreCrystal>=0)?info->RageTheatreCrystal:pll->reference_freq){ + case 2700: + t->video_decoder_type=RT_FREF_2700; + break; + case 2950: + t->video_decoder_type=RT_FREF_2950; + break; + default: + xf86DrvMsg(t->VIP->scrnIndex,X_INFO, + "Unsupported reference clock frequency, Rage Theatre disabled\n"); + t->theatre_num=-1; + return FALSE; + } + xf86DrvMsg(t->VIP->scrnIndex,X_INFO,"video decoder type used: 0x%04x\n",t->video_decoder_type); + return TRUE; } @@ -184,6 +1302,7 @@ R128AllocAdaptor(ScrnInfoPtr pScrn) XF86VideoAdaptorPtr adapt; R128InfoPtr info = R128PTR(pScrn); R128PortPrivPtr pPriv; + unsigned char *R128MMIO = info->MMIO; if(!(adapt = xf86XVAllocateVideoAdaptorRec(pScrn))) return NULL; @@ -206,10 +1325,29 @@ R128AllocAdaptor(ScrnInfoPtr pScrn) pPriv->doubleBuffer = TRUE; pPriv->videoStatus = 0; pPriv->brightness = 0; - pPriv->saturation = 16; + pPriv->saturation = 0; + pPriv->contrast = 0; + pPriv->hue = 0; pPriv->currentBuffer = 0; R128ECP(pScrn, pPriv); + pPriv->video_stream_active = FALSE; + pPriv->encoding = 1; + pPriv->frequency = 1000; + pPriv->volume = -1000; + pPriv->mute = TRUE; + pPriv->v=0; + + pPriv->autopaint_colorkey = TRUE; + /* choose ecp_div setting */ + if(info->ModeReg.dot_clock_freq < 12500) pPriv->ecp_div = 0; + else + if(info->ModeReg.dot_clock_freq < 25000) pPriv->ecp_div = 1; + else pPriv->ecp_div = 2; + xf86DrvMsg(pScrn->scrnIndex, X_INFO, "Dotclock is %g Mhz, setting ecp_div to %d\n", info->ModeReg.dot_clock_freq/100.0, pPriv->ecp_div); + + OUTPLL(R128_VCLK_ECP_CNTL, (INPLL(pScrn, R128_VCLK_ECP_CNTL) & 0xfffffCff) | (pPriv->ecp_div << 8)); + return adapt; } @@ -221,22 +1359,55 @@ R128SetupImageVideo(ScreenPtr pScreen) R128PortPrivPtr pPriv; XF86VideoAdaptorPtr adapt; + info->accel->Sync(pScrn); + + if(info->adaptor != NULL){ + xf86DrvMsg(pScrn->scrnIndex, X_INFO, "Reinitializing Xvideo subsystems\n"); + R128ResetVideo(pScrn); + return info->adaptor; + } + if(!(adapt = R128AllocAdaptor(pScrn))) return NULL; + pPriv = (R128PortPrivPtr)(adapt->pPortPrivates[0].ptr); + + R128ReadMM_TABLE(pScrn, pPriv); + + R128InitI2C(pScrn,pPriv); adapt->type = XvWindowMask | XvInputMask | XvImageMask; adapt->flags = VIDEO_OVERLAID_IMAGES | VIDEO_CLIP_TO_VIEWPORT; adapt->name = "ATI Rage128 Video Overlay"; + if(pPriv->theatre != NULL) + { + adapt->type = XvWindowMask | XvInputMask | XvImageMask | XvVideoMask; + adapt->nEncodings = 13; + adapt->pEncodings = InputVideoEncodings; + } else + if(pPriv->bt829 != NULL) + { + adapt->type = XvWindowMask | XvInputMask | XvImageMask | XvVideoMask; + adapt->nEncodings = 16; + adapt->pEncodings = InputVideoEncodings; + } else + { + adapt->type = XvWindowMask | XvInputMask | XvImageMask; adapt->nEncodings = 1; adapt->pEncodings = &DummyEncoding; + } adapt->nFormats = NUM_FORMATS; adapt->pFormats = Formats; adapt->nPorts = 1; + if(pPriv->msp3430!=NULL) adapt->nAttributes = NUM_ATTRIBUTES; + else + if((pPriv->theatre!=NULL)||(pPriv->bt829!=NULL)) + adapt->nAttributes = NUM_ATTRIBUTES-1; + else adapt->nAttributes = NUM_ATTRIBUTES-3; adapt->pAttributes = Attributes; adapt->nImages = NUM_IMAGES; adapt->pImages = Images; - adapt->PutVideo = NULL; + adapt->PutVideo = R128PutVideo; adapt->PutStill = NULL; adapt->GetVideo = NULL; adapt->GetStill = NULL; @@ -254,9 +1425,135 @@ R128SetupImageVideo(ScreenPtr pScreen) R128ResetVideo(pScrn); + if(info->VBIOS!=NULL){ + xfree(info->VBIOS); + info->VBIOS=NULL; + } + return adapt; } +/* I really should stick this in miregion */ +static Bool +RegionsEqual(RegionPtr A, RegionPtr B) +{ + int *dataA, *dataB; + int num; + + num = REGION_NUM_RECTS(A); + if(num != REGION_NUM_RECTS(B)) + return FALSE; + + if((A->extents.x1 != B->extents.x1) || + (A->extents.x2 != B->extents.x2) || + (A->extents.y1 != B->extents.y1) || + (A->extents.y2 != B->extents.y2)) + return FALSE; + + dataA = (pointer)REGION_RECTS(A); + dataB = (pointer)REGION_RECTS(B); + + while(num--) { + if((dataA[0] != dataB[0]) || (dataA[1] != dataB[1])) + return FALSE; + dataA += 2; + dataB += 2; + } + + return TRUE; +} + + +/* R128ClipVideo - + + Takes the dst box in standard X BoxRec form (top and left + edges inclusive, bottom and right exclusive). The new dst + box is returned. The source boundaries are given (xa, ya + inclusive, xb, yb exclusive) and returned are the new source + boundaries in 16.16 fixed point. +*/ + +#define DummyScreen screenInfo.screens[0] + +static Bool +R128ClipVideo( + BoxPtr dst, + INT32 *xa, + INT32 *xb, + INT32 *ya, + INT32 *yb, + RegionPtr reg, + INT32 width, + INT32 height +){ + INT32 vscale, hscale, delta; + BoxPtr extents = REGION_EXTENTS(DummyScreen, reg); + int diff; + + hscale = ((*xb - *xa) << 16) / (dst->x2 - dst->x1); + vscale = ((*yb - *ya) << 16) / (dst->y2 - dst->y1); + + *xa <<= 16; *xb <<= 16; + *ya <<= 16; *yb <<= 16; + + diff = extents->x1 - dst->x1; + if(diff > 0) { + dst->x1 = extents->x1; + *xa += diff * hscale; + } + diff = dst->x2 - extents->x2; + if(diff > 0) { + dst->x2 = extents->x2; + *xb -= diff * hscale; + } + diff = extents->y1 - dst->y1; + if(diff > 0) { + dst->y1 = extents->y1; + *ya += diff * vscale; + } + diff = dst->y2 - extents->y2; + if(diff > 0) { + dst->y2 = extents->y2; + *yb -= diff * vscale; + } + + if(*xa < 0) { + diff = (- *xa + hscale - 1)/ hscale; + dst->x1 += diff; + *xa += diff * hscale; + } + delta = *xb - (width << 16); + if(delta > 0) { + diff = (delta + hscale - 1)/ hscale; + dst->x2 -= diff; + *xb -= diff * hscale; + } + if(*xa >= *xb) return FALSE; + + if(*ya < 0) { + diff = (- *ya + vscale - 1)/ vscale; + dst->y1 += diff; + *ya += diff * vscale; + } + delta = *yb - (height << 16); + if(delta > 0) { + diff = (delta + vscale - 1)/ vscale; + dst->y2 -= diff; + *yb -= diff * vscale; + } + if(*ya >= *yb) return FALSE; + + if((dst->x1 != extents->x1) || (dst->x2 != extents->x2) || + (dst->y1 != extents->y1) || (dst->y2 != extents->y2)) + { + RegionRec clipReg; + REGION_INIT(DummyScreen, &clipReg, dst, 1); + REGION_INTERSECT(DummyScreen, reg, reg, &clipReg); + REGION_UNINIT(DummyScreen, &clipReg); + } + return TRUE; +} + static void R128StopVideo(ScrnInfoPtr pScrn, pointer data, Bool cleanup) { @@ -269,6 +1566,17 @@ R128StopVideo(ScrnInfoPtr pScrn, pointer data, Bool cleanup) if(cleanup) { if(pPriv->videoStatus & CLIENT_VIDEO_ON) { OUTREG(R128_OV0_SCALE_CNTL, 0); + if (info->cursor_start) + xf86ForceHWCursor (pScrn->pScreen, FALSE); + } + if(pPriv->video_stream_active) { + R128WaitForFifo(pScrn, 8); + OUTPLL(R128_FCP_CNTL, 0x404); + OUTREG(R128_CAP0_TRIG_CNTL, 0x0); + R128ResetVideo(pScrn); + pPriv->video_stream_active = FALSE; + R128MuteAudio(pPriv, TRUE); + if(pPriv->i2c!=NULL) R128_board_setmisc(pPriv); } if(pPriv->linear) { xf86FreeOffscreenLinear(pPriv->linear); @@ -293,24 +1601,60 @@ R128SetPortAttribute( R128InfoPtr info = R128PTR(pScrn); unsigned char *R128MMIO = info->MMIO; R128PortPrivPtr pPriv = (R128PortPrivPtr)data; + Bool save_mute; + + info->accel->Sync(pScrn); + if(attribute == xv_autopaint_colorkey) { + pPriv->autopaint_colorkey = value; + } else + if(attribute == xv_set_defaults) { + R128SetPortAttribute(pScrn, xv_autopaint_colorkey, TRUE, data); + R128SetPortAttribute(pScrn, xvBrightness, 0, data); + R128SetPortAttribute(pScrn, xvSaturation, 0, data); + R128SetPortAttribute(pScrn, xvContrast, 0, data); + R128SetPortAttribute(pScrn, xvHue, 0, data); + R128SetPortAttribute(pScrn, xvVolume, 0, data); + R128SetPortAttribute(pScrn, xvMute, 1, data); + R128SetPortAttribute(pScrn, xvSAP, 0, data); + R128SetPortAttribute(pScrn, xvDoubleBuffer, 1, data); + } else if(attribute == xvBrightness) { - if((value < -64) || (value > 63)) - return BadValue; - pPriv->brightness = value; + if(value < -1000)value = -1000; + if(value > 1000)value = 1000; - OUTREG(R128_OV0_COLOUR_CNTL, (pPriv->brightness & 0x7f) | - (pPriv->saturation << 8) | - (pPriv->saturation << 16)); + pPriv->brightness = value; + R128WaitForFifo(pScrn, 2); + OUTREG(R128_OV0_COLOUR_CNTL, (((pPriv->brightness*64)/1000) & 0x7f) | + (((pPriv->saturation*31+31000)/2000) << 8) | + (((pPriv->saturation*31+31000)/2000) << 16)); + if(pPriv->theatre!=NULL) xf86_RT_SetBrightness(pPriv->theatre, pPriv->brightness); + if(pPriv->bt829!=NULL) xf86_bt829_SetBrightness(pPriv->bt829, pPriv->brightness); } else - if(attribute == xvSaturation) { - if((value < 0) || (value > 31)) - return BadValue; + if((attribute == xvSaturation) || (attribute == xvColor)) { + if(value < -1000)value = -1000; + if(value > 1000)value = 1000; pPriv->saturation = value; - - OUTREG(R128_OV0_COLOUR_CNTL, (pPriv->brightness & 0x7f) | - (pPriv->saturation << 8) | - (pPriv->saturation << 16)); + R128WaitForFifo(pScrn, 2); + OUTREG(R128_OV0_COLOUR_CNTL, (((pPriv->brightness*64)/1000) & 0x7f) | + (((pPriv->saturation*31+31000)/2000) << 8) | + (((pPriv->saturation*31+31000)/2000) << 16)); + if(pPriv->theatre != NULL)xf86_RT_SetSaturation(pPriv->theatre, value); + if(pPriv->bt829!=NULL) xf86_bt829_SetSaturation(pPriv->bt829, pPriv->saturation); + } else + if(attribute == xvContrast) { + if(value < -1000)value = -1000; + if(value > 1000)value = 1000; + pPriv->contrast = value; + if(pPriv->theatre != NULL)xf86_RT_SetContrast(pPriv->theatre, value); + if(pPriv->bt829!=NULL) xf86_bt829_SetContrast(pPriv->bt829, pPriv->contrast); + } else + if(attribute == xvHue) { + if(value < -1000)value = -1000; + if(value > 1000)value = 1000; + pPriv->hue = value; + if(pPriv->theatre != NULL)xf86_RT_SetTint(pPriv->theatre, value); + if(pPriv->bt829!=NULL) xf86_bt829_SetTint(pPriv->bt829, pPriv->hue); } else if(attribute == xvDoubleBuffer) { if((value < 0) || (value > 1)) @@ -319,10 +1663,51 @@ R128SetPortAttribute( } else if(attribute == xvColorKey) { pPriv->colorKey = value; + R128WaitForFifo(pScrn, 2); OUTREG(R128_OV0_GRAPHICS_KEY_CLR, pPriv->colorKey); REGION_EMPTY(pScrn->pScreen, &pPriv->clip); - } else return BadMatch; + } else + if(attribute == xvEncoding) { + pPriv->encoding = value; + if(pPriv->video_stream_active) + { + if(pPriv->theatre != NULL) R128_RT_SetEncoding(pPriv); + if(pPriv->bt829 != NULL) R128_BT_SetEncoding(pPriv); + if(pPriv->msp3430 != NULL) R128_MSP_SetEncoding(pPriv); + if(pPriv->i2c!=NULL) R128_board_setmisc(pPriv); + /* put more here to actually change it */ + } + } else + if(attribute == xvFrequency) { + pPriv->frequency = value; + save_mute = pPriv->mute; + R128MuteAudio(pPriv, TRUE); + if(pPriv->fi1236 != NULL) xf86_TUNER_set_frequency(pPriv->fi1236, value); + if((pPriv->msp3430 != NULL) && (pPriv->msp3430->recheck)) + xf86_InitMSP3430(pPriv->msp3430); + R128MuteAudio(pPriv, save_mute); + } else + if(attribute == xvMute) { + pPriv->mute = value; + R128MuteAudio(pPriv, pPriv->mute); + if(pPriv->i2c!=NULL) R128_board_setmisc(pPriv); + } else + if(attribute == xvSAP) { + pPriv->sap_channel = value; + if(pPriv->msp3430!=NULL)xf86_MSP3430SetSAP(pPriv->msp3430, pPriv->sap_channel?4:3); + if(pPriv->tda9850!=NULL)xf86_tda9850_sap_mute(pPriv->tda9850, pPriv->sap_channel?1:0); + } else + if(attribute == xvVolume) { + if(value<-1000) value=-1000; + if(value>1000) value=1000; + pPriv->volume = value; + pPriv->mute = FALSE; + if(pPriv->msp3430 != NULL) xf86_MSP3430SetVolume(pPriv->msp3430, MSP3430_VOLUME(value)); + R128MuteAudio(pPriv, pPriv->mute); + if(pPriv->i2c!=NULL) R128_board_setmisc(pPriv); + } else + return BadMatch; return Success; } @@ -334,20 +1719,65 @@ R128GetPortAttribute( INT32 *value, pointer data ){ + R128InfoPtr info = R128PTR(pScrn); R128PortPrivPtr pPriv = (R128PortPrivPtr)data; + info->accel->Sync(pScrn); + + if(attribute == xv_autopaint_colorkey) { + *value = pPriv->autopaint_colorkey; + } else if(attribute == xvBrightness) { *value = pPriv->brightness; } else - if(attribute == xvSaturation) { + if((attribute == xvSaturation) || (attribute == xvColor)) { *value = pPriv->saturation; } else + if(attribute == xvContrast) { + *value = pPriv->contrast; + } else + if(attribute == xvHue) { + *value = pPriv->hue; + } else if(attribute == xvDoubleBuffer) { *value = pPriv->doubleBuffer ? 1 : 0; } else if(attribute == xvColorKey) { *value = pPriv->colorKey; - } else return BadMatch; + } else + if(attribute == xvEncoding) { + *value = pPriv->encoding; + } else + if(attribute == xvFrequency) { + *value = pPriv->frequency; + } else + if(attribute == xvTunerStatus) { + if(pPriv->fi1236==NULL){ + *value=TUNER_OFF; + } else + { + *value = xf86_TUNER_get_afc_hint(pPriv->fi1236); + } + } else + if(attribute == xvMute) { + *value = pPriv->mute; + } else + if(attribute == xvSAP) { + *value = pPriv->sap_channel; + } else + if(attribute == xvVolume) { + *value = pPriv->volume; + } else + if(attribute == xvDeviceID) { + *value = pPriv->device_id; + } else + if(attribute == xvLocationID) { + *value = pPriv->location_id; + } else + if(attribute == xvInstanceID) { + *value = pPriv->instance_id; + } else + return BadMatch; return Success; } @@ -383,6 +1813,7 @@ R128QueryBestSize( static Bool R128DMA( + ScrnInfoPtr pScrn, R128InfoPtr info, unsigned char *src, unsigned char *dst, @@ -414,6 +1845,10 @@ R128DMA( if ((passes = (h+hpass-1)/hpass) > MAXPASSES) return FALSE; +#if 0 + R128CCEWaitForIdle(pScrn); +#endif + /* Request indirect buffers */ srcpassbytes = w*hpass; @@ -491,6 +1926,7 @@ R128DMA( static void R128CopyData422( + ScrnInfoPtr pScrn, R128InfoPtr info, unsigned char *src, unsigned char *dst, @@ -503,7 +1939,7 @@ R128CopyData422( /* Attempt data transfer with DMA and fall back to memcpy */ - if (!R128DMA(info, src, dst, srcPitch, dstPitch, h, w)) { + if (!R128DMA(pScrn, info, src, dst, srcPitch, dstPitch, h, w)) { while(h--) { memcpy(dst, src, w); src += srcPitch; @@ -514,6 +1950,7 @@ R128CopyData422( static void R128CopyData420( + ScrnInfoPtr pScrn, R128InfoPtr info, unsigned char *src1, unsigned char *src2, @@ -531,7 +1968,7 @@ R128CopyData420( /* Attempt data transfer with DMA and fall back to memcpy */ - if (!R128DMA(info, src1, dst1, srcPitch, dstPitch, h, w)) { + if (!R128DMA(pScrn,info, src1, dst1, srcPitch, dstPitch, h, w)) { count = h; while(count--) { memcpy(dst1, src1, w); @@ -544,7 +1981,7 @@ R128CopyData420( h >>= 1; dstPitch >>= 1; - if (!R128DMA(info, src2, dst2, srcPitch2, dstPitch, h, w)) { + if (!R128DMA(pScrn,info, src2, dst2, srcPitch2, dstPitch, h, w)) { count = h; while(count--) { memcpy(dst2, src2, w); @@ -553,7 +1990,7 @@ R128CopyData420( } } - if (!R128DMA(info, src3, dst3, srcPitch2, dstPitch, h, w)) { + if (!R128DMA(pScrn, info, src3, dst3, srcPitch2, dstPitch, h, w)) { count = h; while(count--) { memcpy(dst3, src3, w); @@ -609,7 +2046,7 @@ static void R128DisplayVideo422( ScrnInfoPtr pScrn, int id, - int offset, + int offset1, int offset2, short width, short height, int pitch, int left, int right, int top, @@ -621,13 +2058,31 @@ R128DisplayVideo422( unsigned char *R128MMIO = info->MMIO; R128PortPrivPtr pPriv = info->adaptor->pPortPrivates[0].ptr; int v_inc, h_inc, step_by, tmp; + double v_inc_d; int p1_h_accum_init, p23_h_accum_init; int p1_v_accum_init; + long counter; R128ECP(pScrn, pPriv); + /* Choose ecp_div setting. As the user may have switched resolution + we better do it again. */ + if(info->ModeReg.dot_clock_freq < 12500) pPriv->ecp_div = 0; + else + if(info->ModeReg.dot_clock_freq < 25000) pPriv->ecp_div = 1; + else pPriv->ecp_div = 2; - v_inc = (src_h << 20) / drw_h; - h_inc = (src_w << (12 + pPriv->ecp_div)) / drw_w; + OUTPLL(R128_VCLK_ECP_CNTL, (INPLL(pScrn, R128_VCLK_ECP_CNTL) & 0xfffffCff) | (pPriv->ecp_div << 8)); + + v_inc = (1 << (20 + + ((pScrn->currentMode->Flags & V_INTERLACE)?1:0) + - ((pScrn->currentMode->Flags & V_DBLSCAN)?1:0))); + + v_inc_d = src_h; + v_inc_d = v_inc_d/drw_h; + v_inc = v_inc * v_inc_d; + + h_inc = ((src_w << (12 + + pPriv->ecp_div)) / drw_w); step_by = 1; while(h_inc >= (2 << 12)) { @@ -637,7 +2092,8 @@ R128DisplayVideo422( /* keep everything in 16.16 */ - offset += ((left >> 16) & ~7) << 1; + offset1 += ((left >> 16) & ~7) << 1; + offset2 += ((left >> 16) & ~7) << 1; tmp = (left & 0x0003ffff) + 0x00028000 + (h_inc << 3); p1_h_accum_init = ((tmp << 4) & 0x000f8000) | @@ -652,13 +2108,17 @@ R128DisplayVideo422( left = (left >> 16) & 7; - OUTREG(R128_OV0_REG_LOAD_CNTL, 1); - while(!(INREG(R128_OV0_REG_LOAD_CNTL) & (1 << 3))); + R128WaitForFifo(pScrn,2); + OUTREG(R128_OV0_REG_LOAD_CNTL, R128_REG_LD_CTL_LOCK); + R128WaitForIdle(pScrn); + counter=10000; + while(!(INREG(R128_OV0_REG_LOAD_CNTL) & R128_REG_LD_CTL_LOCK_READBACK) && (counter>=0))counter--; + if(counter<0)xf86DrvMsg(pScrn->scrnIndex, X_ERROR, "Cannot lock overlay registers\n"); OUTREG(R128_OV0_H_INC, h_inc | ((h_inc >> 1) << 16)); OUTREG(R128_OV0_STEP_BY, step_by | (step_by << 8)); - OUTREG(R128_OV0_Y_X_START, dstBox->x1 | (dstBox->y1 << 16)); - OUTREG(R128_OV0_Y_X_END, dstBox->x2 | (dstBox->y2 << 16)); + OUTREG(R128_OV0_Y_X_START, dstBox->x1 | ((dstBox->y1*((pScrn->currentMode->Flags & V_DBLSCAN)?2:1)) << 16)); + OUTREG(R128_OV0_Y_X_END, dstBox->x2 | ((dstBox->y2*((pScrn->currentMode->Flags & V_DBLSCAN)?2:1)) << 16)); OUTREG(R128_OV0_V_INC, v_inc); OUTREG(R128_OV0_P1_BLANK_LINES_AT_TOP, 0x00000fff | ((src_h - 1) << 16)); OUTREG(R128_OV0_VID_BUF_PITCH0_VALUE, pitch); @@ -666,17 +2126,41 @@ R128DisplayVideo422( left >>= 1; width >>= 1; OUTREG(R128_OV0_P2_X_START_END, (width - 1) | (left << 16)); OUTREG(R128_OV0_P3_X_START_END, (width - 1) | (left << 16)); - OUTREG(R128_OV0_VID_BUF0_BASE_ADRS, offset & 0xfffffff0); + OUTREG(R128_OV0_VID_BUF0_BASE_ADRS, offset1 & 0xfffffff0); + + R128WaitForFifo(pScrn, 14); + OUTREG(R128_OV0_VID_BUF1_BASE_ADRS, offset1 & 0xfffffff0); + OUTREG(R128_OV0_VID_BUF2_BASE_ADRS, offset1 & 0xfffffff0); + + OUTREG(R128_OV0_VID_BUF3_BASE_ADRS, offset2 & 0xfffffff0); + OUTREG(R128_OV0_VID_BUF4_BASE_ADRS, offset2 & 0xfffffff0); + OUTREG(R128_OV0_VID_BUF5_BASE_ADRS, offset2 & 0xfffffff0); OUTREG(R128_OV0_P1_V_ACCUM_INIT, p1_v_accum_init); OUTREG(R128_OV0_P23_V_ACCUM_INIT, 0); OUTREG(R128_OV0_P1_H_ACCUM_INIT, p1_h_accum_init); OUTREG(R128_OV0_P23_H_ACCUM_INIT, p23_h_accum_init); - +/* older, original magic if(id == FOURCC_UYVY) OUTREG(R128_OV0_SCALE_CNTL, 0x41FF8C03); else OUTREG(R128_OV0_SCALE_CNTL, 0x41FF8B03); - +*/ + if(id == FOURCC_UYVY) + OUTREG(R128_OV0_SCALE_CNTL, R128_SCALER_PIX_EXPAND \ + | R128_SCALER_Y2R_TEMP \ + | R128_SCALER_SOURCE_YVYU422 \ + | R128_SCALER_SMART_SWITCH \ + | R128_SCALER_BURST_PER_PLANE \ + | R128_SCALER_DOUBLE_BUFFER \ + | R128_SCALER_ENABLE); + else + OUTREG(R128_OV0_SCALE_CNTL, R128_SCALER_PIX_EXPAND \ + | R128_SCALER_Y2R_TEMP \ + | R128_SCALER_SOURCE_VYUY422 \ + | R128_SCALER_SMART_SWITCH \ + | R128_SCALER_BURST_PER_PLANE \ + | R128_SCALER_DOUBLE_BUFFER \ + | R128_SCALER_ENABLE); OUTREG(R128_OV0_REG_LOAD_CNTL, 0); } @@ -697,8 +2181,20 @@ R128DisplayVideo420( int v_inc, h_inc, step_by, tmp, leftUV; int p1_h_accum_init, p23_h_accum_init; int p1_v_accum_init, p23_v_accum_init; + long counter; - v_inc = (src_h << 20) / drw_h; + /* Choose ecp_div setting. As the user may have switched resolution + we better do it again. */ + if(info->ModeReg.dot_clock_freq < 12500) pPriv->ecp_div = 0; + else + if(info->ModeReg.dot_clock_freq < 25000) pPriv->ecp_div = 1; + else pPriv->ecp_div = 2; + + OUTPLL(R128_VCLK_ECP_CNTL, (INPLL(pScrn, R128_VCLK_ECP_CNTL) & 0xfffffCff) | (pPriv->ecp_div << 8)); + + v_inc = (src_h << (20 + + ((pScrn->currentMode->Flags & V_INTERLACE)?1:0) + - ((pScrn->currentMode->Flags & V_DBLSCAN)?1:0))) / drw_h; h_inc = (src_w << (12 + pPriv->ecp_div)) / drw_w; step_by = 1; @@ -730,13 +2226,17 @@ R128DisplayVideo420( leftUV = (left >> 17) & 15; left = (left >> 16) & 15; - OUTREG(R128_OV0_REG_LOAD_CNTL, 1); - while(!(INREG(R128_OV0_REG_LOAD_CNTL) & (1 << 3))); + R128WaitForFifo(pScrn, 2); + OUTREG(R128_OV0_REG_LOAD_CNTL, R128_REG_LD_CTL_LOCK); + R128WaitForIdle(pScrn); + counter=10000; + while(!(INREG(R128_OV0_REG_LOAD_CNTL) & R128_REG_LD_CTL_LOCK_READBACK) && (counter>=0))counter--; + if(counter<0)xf86DrvMsg(pScrn->scrnIndex, X_ERROR, "Cannot lock overlay registers\n"); OUTREG(R128_OV0_H_INC, h_inc | ((h_inc >> 1) << 16)); OUTREG(R128_OV0_STEP_BY, step_by | (step_by << 8)); - OUTREG(R128_OV0_Y_X_START, dstBox->x1 | (dstBox->y1 << 16)); - OUTREG(R128_OV0_Y_X_END, dstBox->x2 | (dstBox->y2 << 16)); + OUTREG(R128_OV0_Y_X_START, dstBox->x1 | ((dstBox->y1*((pScrn->currentMode->Flags & V_DBLSCAN)?2:1)) << 16)); + OUTREG(R128_OV0_Y_X_END, dstBox->x2 | ((dstBox->y2*((pScrn->currentMode->Flags & V_DBLSCAN)?2:1)) << 16)); OUTREG(R128_OV0_V_INC, v_inc); OUTREG(R128_OV0_P1_BLANK_LINES_AT_TOP, 0x00000fff | ((src_h - 1) << 16)); src_h = (src_h + 1) >> 1; @@ -745,6 +2245,7 @@ R128DisplayVideo420( OUTREG(R128_OV0_VID_BUF_PITCH1_VALUE, pitch >> 1); OUTREG(R128_OV0_P1_X_START_END, (width - 1) | (left << 16)); width >>= 1; + R128WaitForFifo(pScrn,14); OUTREG(R128_OV0_P2_X_START_END, (width - 1) | (leftUV << 16)); OUTREG(R128_OV0_P3_X_START_END, (width - 1) | (leftUV << 16)); OUTREG(R128_OV0_VID_BUF0_BASE_ADRS, offset1 & 0xfffffff0); @@ -754,7 +2255,16 @@ R128DisplayVideo420( OUTREG(R128_OV0_P23_V_ACCUM_INIT, p23_v_accum_init); OUTREG(R128_OV0_P1_H_ACCUM_INIT, p1_h_accum_init); OUTREG(R128_OV0_P23_H_ACCUM_INIT, p23_h_accum_init); +/* original magic OUTREG(R128_OV0_SCALE_CNTL, 0x41FF8A03); +*/ + OUTREG(R128_OV0_SCALE_CNTL, R128_SCALER_PIX_EXPAND \ + | R128_SCALER_Y2R_TEMP \ + | R128_SCALER_SOURCE_YUV12 \ + | R128_SCALER_SMART_SWITCH \ + | R128_SCALER_BURST_PER_PLANE \ + | R128_SCALER_DOUBLE_BUFFER \ + | R128_SCALER_ENABLE ); OUTREG(R128_OV0_REG_LOAD_CNTL, 0); } @@ -777,13 +2287,15 @@ R128PutImage( R128InfoPtr info = R128PTR(pScrn); R128PortPrivPtr pPriv = (R128PortPrivPtr)data; unsigned char *fb = (CARD8*)info->FB; + unsigned char *R128MMIO = info->MMIO; INT32 xa, xb, ya, yb; - int new_size, offset, s1offset, s2offset, s3offset; + int pitch, new_size, offset, s1offset, s2offset, s3offset; int srcPitch, srcPitch2, dstPitch; int d1line, d2line, d3line, d1offset, d2offset, d3offset; int top, left, npixels, nlines, bpp; BoxRec dstBox; CARD32 tmp; + int retcode; #if X_BYTE_ORDER == X_BIG_ENDIAN unsigned char *R128MMIO = info->MMIO; CARD32 config_cntl = INREG(R128_CONFIG_CNTL); @@ -793,6 +2305,18 @@ R128PutImage( ~(APER_0_BIG_ENDIAN_16BPP_SWAP | APER_0_BIG_ENDIAN_32BPP_SWAP)); #endif + info->accel->Sync(pScrn); + + /* if capture was active shutdown it first */ + if(pPriv->video_stream_active) + { + R128WaitForFifo(pScrn, 8); + OUTPLL(R128_FCP_CNTL, 0x404); + OUTREG(R128_CAP0_TRIG_CNTL, 0x0); + pPriv->video_stream_active = FALSE; + R128MuteAudio(pPriv, TRUE); + } + /* * s1offset, s2offset, s3offset - byte offsets to the Y, U and V planes * of the source. @@ -824,9 +2348,11 @@ R128PutImage( dstBox.y1 = drw_y; dstBox.y2 = drw_y + drw_h; - if(!xf86XVClipVideoHelper(&dstBox, &xa, &xb, &ya, &yb, - clipBoxes, width, height)) - return Success; + if(!R128ClipVideo(&dstBox, &xa, &xb, &ya, &yb, clipBoxes, width, height)) + { + retcode = Success; + goto done; + } dstBox.x1 -= pScrn->frameX0; dstBox.x2 -= pScrn->frameX0; @@ -834,6 +2360,13 @@ R128PutImage( dstBox.y2 -= pScrn->frameY0; bpp = pScrn->bitsPerPixel >> 3; + pitch = bpp * pScrn->displayWidth; + + R128WaitForFifo(pScrn, 4); + OUTREG(R128_OV0_DEINTERLACE_PATTERN, 0xAAAAA); + OUTREG(R128_OV0_AUTO_FLIP_CNTL, 0); + OUTREG(R128_VIDEOMUX_CNTL, (INREG(R128_VIDEOMUX_CNTL)& ~3)); + OUTREG(R128_CAP0_CONFIG, 0); switch(id) { case FOURCC_YV12: @@ -862,7 +2395,8 @@ R128PutImage( if(!(pPriv->linear = R128AllocateMemory(pScrn, pPriv->linear, pPriv->doubleBuffer ? (new_size << 1) : new_size))) { - return BadAlloc; + retcode = BadAlloc; + goto done; } pPriv->currentBuffer ^= 1; @@ -876,6 +2410,8 @@ R128PutImage( if(pPriv->doubleBuffer) offset += pPriv->currentBuffer * new_size * bpp; + + info->accel->Sync(pScrn); switch(id) { case FOURCC_YV12: case FOURCC_I420: @@ -900,7 +2436,7 @@ R128PutImage( } nlines = ((((yb + 0xffff) >> 16) + 1) & ~1) - top; - R128CopyData420(info, buf + s1offset, buf + s2offset, buf + s3offset, + R128CopyData420(pScrn, info, buf + s1offset, buf + s2offset, buf + s3offset, fb + d1offset, fb + d2offset, fb + d3offset, srcPitch, srcPitch2, dstPitch, nlines, npixels); break; @@ -916,7 +2452,7 @@ R128PutImage( d3offset = 0; s1offset += (top * srcPitch) + left; nlines = ((yb + 0xffff) >> 16) - top; - R128CopyData422(info, buf + s1offset, fb + d1offset, + R128CopyData422(pScrn, info, buf + s1offset, fb + d1offset, srcPitch, dstPitch, nlines, npixels); break; } @@ -930,9 +2466,13 @@ R128PutImage( if(!REGION_EQUAL(pScrn->pScreen, &pPriv->clip, clipBoxes)) { REGION_COPY(pScrn->pScreen, &pPriv->clip, clipBoxes); /* draw these */ - xf86XVFillKeyHelper(pScrn->pScreen, pPriv->colorKey, clipBoxes); + if(pPriv->autopaint_colorkey)(*info->accel->FillSolidRects)(pScrn, pPriv->colorKey, GXcopy, + (CARD32)~0, + REGION_NUM_RECTS(clipBoxes), + REGION_RECTS(clipBoxes)); } + info->accel->Sync(pScrn); switch(id) { case FOURCC_YV12: @@ -944,18 +2484,26 @@ R128PutImage( case FOURCC_UYVY: case FOURCC_YUY2: default: - R128DisplayVideo422(pScrn, id, offset + d1line, width, height, dstPitch, + R128DisplayVideo422(pScrn, id, offset + d1line, offset + d1line, width, height, dstPitch, xa, xb, ya, &dstBox, src_w, src_h, drw_w, drw_h); break; } + if (info->cursor_start && !(pPriv->videoStatus & CLIENT_VIDEO_ON)) + xf86ForceHWCursor (pScrn->pScreen, TRUE); pPriv->videoStatus = CLIENT_VIDEO_ON; info->VideoTimerCallback = R128VideoTimerCallback; + retcode = Success; - return Success; -} +done: +#if X_BYTE_ORDER == X_BIG_ENDIAN + /* restore byte swapping */ + OUTREG(R128_CONFIG_CNTL, config_cntl); +#endif + return retcode; +} static int R128QueryImageAttributes( @@ -999,6 +2547,518 @@ R128QueryImageAttributes( return size; } +/* this routine is here because different mach64/r128 boards use + different methods of muting. And because sometimes there is + no good way to autodetect this (besides knowing which board + we have) */ + + + +void R128_board_setmisc(R128PortPrivPtr pPriv) +{ + CARD8 a; + I2CDevRec d; + + d.DevName = "temporary"; + d.pI2CBus = pPriv->i2c; + d.NextDev = NULL; + d.StartTimeout = pPriv->i2c->StartTimeout; + d.BitTimeout = pPriv->i2c->BitTimeout; + d.AcknTimeout = pPriv->i2c->AcknTimeout; + d.ByteTimeout = pPriv->i2c->ByteTimeout; + + if(pPriv->addon_board) + { + a = 0x2F; + if(!pPriv->mute && pPriv->video_stream_active) a |= 0x50; + if(((pPriv->encoding-1) % 3) != 1) a |= 0x40; + d.SlaveAddr = pPriv->board_control; + I2C_WriteRead(&d, &a, 1, NULL, 0); + } + + if(pPriv->tda8425 != NULL) + { + pPriv->tda8425->v_left = (pPriv->mute ? 0xc0 : 0xff); + pPriv->tda8425->v_right = (pPriv->mute ? 0xc0 : 0xff); + if(((pPriv->encoding-1) % 3) != 1) pPriv->tda8425->mux = 0; + else pPriv->tda8425->mux = 1; /* this is a fancy way + to choose all encodings + except tuner ones */ + xf86_tda8425_setaudio(pPriv->tda8425); + } + + /* Adjust PAL/SECAM constants for FI1216MF tuner */ + if((((pPriv->board_info & 0xf)==5) || + ((pPriv->board_info & 0xf)==11) || + ((pPriv->board_info & 0xf)==14))&& (pPriv->fi1236!=NULL)) + { + if((pPriv->encoding>=1)&&(pPriv->encoding<=3)) /*PAL*/ + { + pPriv->fi1236->parm.band_low = 0xA1; + pPriv->fi1236->parm.band_mid = 0x91; + pPriv->fi1236->parm.band_high = 0x31; + } + if((pPriv->encoding>=7)&&(pPriv->encoding<=9)) /*SECAM*/ + { + pPriv->fi1236->parm.band_low = 0xA3; + pPriv->fi1236->parm.band_mid = 0x93; + pPriv->fi1236->parm.band_high = 0x33; + } + } + + R128MuteAudio(pPriv, pPriv->mute); +} + + +void R128_RT_SetEncoding(R128PortPrivPtr pPriv) +{ +switch(pPriv->encoding){ + case 1: + xf86_RT_SetStandard(pPriv->theatre,DEC_PAL | extPAL); + xf86_RT_SetConnector(pPriv->theatre,DEC_COMPOSITE, 0); + pPriv->v=24; + break; + case 2: + xf86_RT_SetStandard(pPriv->theatre,DEC_PAL | extPAL); + xf86_RT_SetConnector(pPriv->theatre,DEC_TUNER,0); + pPriv->v=24; + break; + case 3: + xf86_RT_SetStandard(pPriv->theatre,DEC_PAL | extPAL); + xf86_RT_SetConnector(pPriv->theatre,DEC_SVIDEO,0); + pPriv->v=24; + break; + case 4: + xf86_RT_SetStandard(pPriv->theatre,DEC_NTSC | extNONE); + xf86_RT_SetConnector(pPriv->theatre, DEC_COMPOSITE,0); + pPriv->v=23; + break; + case 5: + xf86_RT_SetStandard(pPriv->theatre,DEC_NTSC | extNONE); + xf86_RT_SetConnector(pPriv->theatre, DEC_TUNER, 0); + pPriv->v=23; + break; + case 6: + xf86_RT_SetStandard(pPriv->theatre,DEC_NTSC | extNONE); + xf86_RT_SetConnector(pPriv->theatre, DEC_SVIDEO, 0); + pPriv->v=23; + break; + case 7: + xf86_RT_SetStandard(pPriv->theatre,DEC_SECAM | extNONE); + xf86_RT_SetConnector(pPriv->theatre, DEC_COMPOSITE, 0); + pPriv->v=25; + break; + case 8: + xf86_RT_SetStandard(pPriv->theatre,DEC_SECAM | extNONE); + xf86_RT_SetConnector(pPriv->theatre, DEC_TUNER, 0); + pPriv->v=25; + break; + case 9: + xf86_RT_SetStandard(pPriv->theatre,DEC_SECAM | extNONE); + xf86_RT_SetConnector(pPriv->theatre, DEC_SVIDEO, 0); + pPriv->v=25; + break; + case 10: + xf86_RT_SetStandard(pPriv->theatre,DEC_PAL | extPAL_60); + xf86_RT_SetConnector(pPriv->theatre,DEC_COMPOSITE, 0); + pPriv->v=24; + break; + case 11: + xf86_RT_SetStandard(pPriv->theatre,DEC_PAL | extPAL_60); + xf86_RT_SetConnector(pPriv->theatre,DEC_TUNER,0); + pPriv->v=24; + break; + case 12: + xf86_RT_SetStandard(pPriv->theatre,DEC_PAL | extPAL_60); + xf86_RT_SetConnector(pPriv->theatre,DEC_SVIDEO,0); + pPriv->v=24; + break; + default: + pPriv->v=0; + return; + } +} + +void R128_MSP_SetEncoding(R128PortPrivPtr pPriv) +{ +xf86_MSP3430SetVolume(pPriv->msp3430, MSP3430_FAST_MUTE); +switch(pPriv->encoding){ + case 1: + pPriv->msp3430->standard = MSP3430_PAL; + pPriv->msp3430->connector = MSP3430_CONNECTOR_3; + break; + case 2: + pPriv->msp3430->standard = MSP3430_PAL; + pPriv->msp3430->connector = MSP3430_CONNECTOR_1; + break; + case 3: + pPriv->msp3430->standard = MSP3430_PAL; + pPriv->msp3430->connector = MSP3430_CONNECTOR_2; + break; + case 4: + pPriv->msp3430->standard = MSP3430_NTSC; + pPriv->msp3430->connector = MSP3430_CONNECTOR_3; + break; + case 5: + pPriv->msp3430->standard = MSP3430_NTSC; + pPriv->msp3430->connector = MSP3430_CONNECTOR_1; + break; + case 6: + pPriv->msp3430->standard = MSP3430_NTSC; + pPriv->msp3430->connector = MSP3430_CONNECTOR_2; + break; + case 7: + pPriv->msp3430->standard = MSP3430_SECAM; + pPriv->msp3430->connector = MSP3430_CONNECTOR_3; + break; + case 8: + pPriv->msp3430->standard = MSP3430_SECAM; + pPriv->msp3430->connector = MSP3430_CONNECTOR_1; + break; + case 9: + pPriv->msp3430->standard = MSP3430_SECAM; + pPriv->msp3430->connector = MSP3430_CONNECTOR_2; + break; + case 10: + pPriv->msp3430->standard = MSP3430_SECAM; + pPriv->msp3430->connector = MSP3430_CONNECTOR_3; + break; + case 11: + pPriv->msp3430->standard = MSP3430_SECAM; + pPriv->msp3430->connector = MSP3430_CONNECTOR_1; + break; + case 12: + pPriv->msp3430->standard = MSP3430_SECAM; + pPriv->msp3430->connector = MSP3430_CONNECTOR_2; + break; + default: + return; + } +xf86_InitMSP3430(pPriv->msp3430); +xf86_MSP3430SetVolume(pPriv->msp3430, pPriv->mute ? MSP3430_FAST_MUTE : MSP3430_VOLUME(pPriv->volume)); +} + +void R128_BT_SetEncoding(R128PortPrivPtr pPriv) +{ +switch(pPriv->encoding){ + case 1: + xf86_bt829_SetMux(pPriv->bt829, BT829_MUX2); + pPriv->v=24; + xf86_bt829_SetFormat(pPriv->bt829, BT829_PAL); + break; + case 2: + xf86_bt829_SetMux(pPriv->bt829, BT829_MUX0); + pPriv->v=24; + xf86_bt829_SetFormat(pPriv->bt829, BT829_PAL); + break; + case 3: + xf86_bt829_SetMux(pPriv->bt829, BT829_MUX1); + pPriv->v=24; + xf86_bt829_SetFormat(pPriv->bt829, BT829_PAL); + break; + case 4: + xf86_bt829_SetMux(pPriv->bt829, BT829_MUX2); + pPriv->v=23; + xf86_bt829_SetFormat(pPriv->bt829, BT829_NTSC); + break; + case 5: + xf86_bt829_SetMux(pPriv->bt829, BT829_MUX0); + pPriv->v=23; + xf86_bt829_SetFormat(pPriv->bt829, BT829_NTSC); + break; + case 6: + xf86_bt829_SetMux(pPriv->bt829, BT829_MUX1); + pPriv->v=23; + xf86_bt829_SetFormat(pPriv->bt829, BT829_NTSC); + break; + case 7: + xf86_bt829_SetMux(pPriv->bt829, BT829_MUX2); + pPriv->v=25; + xf86_bt829_SetFormat(pPriv->bt829, BT829_SECAM); + break; + case 8: + xf86_bt829_SetMux(pPriv->bt829, BT829_MUX0); + pPriv->v=25; + xf86_bt829_SetFormat(pPriv->bt829, BT829_SECAM); + break; + case 9: + xf86_bt829_SetMux(pPriv->bt829, BT829_MUX1); + pPriv->v=25; + xf86_bt829_SetFormat(pPriv->bt829, BT829_SECAM); + break; + case 13: + xf86_bt829_SetMux(pPriv->bt829, BT829_MUX2); + pPriv->v=23; + xf86_bt829_SetFormat(pPriv->bt829, BT829_PAL_M); + break; + case 14: + xf86_bt829_SetMux(pPriv->bt829, BT829_MUX0); + pPriv->v=23; + xf86_bt829_SetFormat(pPriv->bt829, BT829_PAL_M); + break; + case 15: + xf86_bt829_SetMux(pPriv->bt829, BT829_MUX1); + pPriv->v=23; + xf86_bt829_SetFormat(pPriv->bt829, BT829_PAL_M); + break; + default: + xf86_bt829_SetMux(pPriv->bt829, BT829_MUX2); + pPriv->v=23; + xf86_bt829_SetFormat(pPriv->bt829, BT829_NTSC); + return; + } +if(pPriv->tda9850!=NULL){ + pPriv->tda9850->mux = pPriv->bt829->mux; + xf86_tda9850_setaudio(pPriv->tda9850); + } +} + +/* capture config constants */ +#define BUF_TYPE_FIELD 0 +#define BUF_TYPE_ALTERNATING 1 +#define BUF_TYPE_FRAME 2 + + +#define BUF_MODE_SINGLE 0 +#define BUF_MODE_DOUBLE 1 +#define BUF_MODE_TRIPLE 2 +/* CAP0_CONFIG values */ + + +/* Older, original magic.. let's leave these for reference +#define ENABLE_R128_CAPTURE_WEAVE (0x1C000005L \ + | (BUF_MODE_SINGLE <<7) \ + | (BUF_TYPE_FRAME << 4) \ + | ( (pPriv->theatre !=NULL)?(1L<<23):0) \ + | (1<<29)) +#define ENABLE_R128_CAPTURE_BOB (0x1C000005L \ + | (BUF_MODE_SINGLE <<7) \ + | (BUF_TYPE_ALTERNATING << 4) \ + | ( (pPriv->theatre !=NULL)?(1L<<23):0) \ + | (0<<15) \ + | (1<<29)) + +*/ + +#define ENABLE_R128_CAPTURE_WEAVE (R128_CAP0_CONFIG_CONTINUOS \ + | (BUF_MODE_SINGLE <<7) \ + | (BUF_TYPE_FRAME << 4) \ + | ( (pPriv->theatre !=NULL) ? \ + (R128_CAP0_CONFIG_FORMAT_CCIR656): \ + (R128_CAP0_CONFIG_FORMAT_BROOKTREE)) \ + | R128_CAP0_CONFIG_HORZ_DECIMATOR \ + | R128_CAP0_CONFIG_VIDEO_IN_VYUY422) + +#define ENABLE_R128_CAPTURE_BOB (R128_CAP0_CONFIG_CONTINUOS \ + | (BUF_MODE_SINGLE <<7) \ + | (BUF_TYPE_ALTERNATING << 4) \ + | ( (pPriv->theatre !=NULL) ? \ + (R128_CAP0_CONFIG_FORMAT_CCIR656): \ + (R128_CAP0_CONFIG_FORMAT_BROOKTREE)) \ + | R128_CAP0_CONFIG_HORZ_DECIMATOR \ + | R128_CAP0_CONFIG_VIDEO_IN_VYUY422) + +static int +R128PutVideo( + ScrnInfoPtr pScrn, + short src_x, short src_y, + short drw_x, short drw_y, + short src_w, short src_h, + short drw_w, short drw_h, + RegionPtr clipBoxes, pointer data +){ + R128InfoPtr info = R128PTR(pScrn); + R128PortPrivPtr pPriv = (R128PortPrivPtr)data; + unsigned char *R128MMIO = info->MMIO; + INT32 xa, xb, ya, yb, top; + int pitch, new_size, offset1, offset2, s2offset, s3offset; + int srcPitch, srcPitch2, dstPitch; + int bpp; + BoxRec dstBox; + CARD32 id; + int width, height; + + xf86DrvMsg(pScrn->scrnIndex, X_INFO, "PutVideo\n"); + info->accel->Sync(pScrn); + /* + * s2offset, s3offset - byte offsets into U and V plane of the + * source where copying starts. Y plane is + * done by editing "buf". + * + * offset - byte offset to the first line of the destination. + * + * dst_start - byte address to the first displayed pel. + * + */ + + /* make the compiler happy */ + s2offset = s3offset = srcPitch2 = 0; + + if(src_w > (drw_w << 4)) + drw_w = src_w >> 4; + if(src_h > (drw_h << 4)) + drw_h = src_h >> 4; + + /* Clip */ + xa = src_x; + xb = src_x + src_w; + ya = src_y; + yb = src_y + src_h; + + dstBox.x1 = drw_x; + dstBox.x2 = drw_x + drw_w; + dstBox.y1 = drw_y; + dstBox.y2 = drw_y + drw_h; + + if(pPriv->theatre != NULL) + { + width = InputVideoEncodings[pPriv->encoding].width; + height = InputVideoEncodings[pPriv->encoding].height; + } else + if(pPriv->bt829 != NULL) + { + width = InputVideoEncodings[pPriv->encoding].width; + height = InputVideoEncodings[pPriv->encoding].height; + } else + return FALSE; + + if(!R128ClipVideo(&dstBox, &xa, &xb, &ya, &yb, clipBoxes, width, height)) + return Success; + + dstBox.x1 -= pScrn->frameX0; + dstBox.x2 -= pScrn->frameX0; + dstBox.y1 -= pScrn->frameY0; + dstBox.y2 -= pScrn->frameY0; + + bpp = pScrn->bitsPerPixel >> 3; + pitch = bpp * pScrn->displayWidth; + + id = FOURCC_YUY2; + + top = ya>>16; + + switch(id) { + case FOURCC_YV12: + case FOURCC_I420: + top &= ~1; + dstPitch = ((width << 1) + 15) & ~15; + new_size = ((dstPitch * height) + bpp - 1) / bpp; + srcPitch = (width + 3) & ~3; + s2offset = srcPitch * height; + srcPitch2 = ((width >> 1) + 3) & ~3; + s3offset = (srcPitch2 * (height >> 1)) + s2offset; + break; + case FOURCC_UYVY: + case FOURCC_YUY2: + default: + dstPitch = ((width << 1) + 15) & ~15; + new_size = ((dstPitch * height) + bpp - 1) / bpp; + srcPitch = (width << 1); + break; + } + + new_size += 0x1f; /* for aligning */ + + if(!(pPriv->linear = R128AllocateMemory(pScrn, pPriv->linear, new_size*2))) + { + return BadAlloc; + } + + + R128WaitForFifo(pScrn, 14); + + offset1 = (pPriv->linear->offset*bpp+0xf) & (~0xf); + offset2 = ((pPriv->linear->offset+new_size)*bpp + 0x1f) & (~0xf); + + OUTREG(R128_CAP0_BUF0_OFFSET, offset1); + OUTREG(R128_CAP0_BUF0_EVEN_OFFSET, offset2); + OUTREG(R128_CAP0_ONESHOT_BUF_OFFSET, offset1); + OUTREG(R128_CAP0_BUF1_OFFSET, offset1); + OUTREG(R128_CAP0_BUF1_EVEN_OFFSET, offset2); + + OUTREG(R128_CAP0_BUF_PITCH, width*2); + OUTREG(R128_CAP0_H_WINDOW, (2*width)<<16); + OUTREG(R128_CAP0_V_WINDOW, (((height)+pPriv->v-1)<<16)|(pPriv->v)); + OUTREG(R128_OV0_AUTO_FLIP_CNTL, R128_OV0_AUTO_FLIP_CNTL_SOFT_BUF_ODD); + OUTREG(R128_CAP0_CONFIG, ENABLE_R128_CAPTURE_BOB); + OUTREG(R128_CAP0_DEBUG, 0); + + OUTREG(R128_CAP0_DWNSC_XRATIO, 0x10001000); + OUTREG(R128_CAP0_XSHARPNESS, 0); + OUTREG(R128_TEST_DEBUG_CNTL, 0); + + if(! pPriv->video_stream_active){ + + /* activate capture unit */ + R128WaitForFifo(pScrn, 4); + + /* undocumented magic, note: these work.. unlike the values in ATI kit, + ATI has been notified.. */ + OUTREG(R128_VIDEOMUX_CNTL, (INREG(R128_VIDEOMUX_CNTL)| 2 |1)); + + OUTREG(R128_CAP0_PORT_MODE_CNTL, (pPriv->theatre!=NULL)? 1: 0); + + OUTPLL(R128_FCP_CNTL, 0x101); + + OUTREG(R128_CAP0_TRIG_CNTL, R128_CAP0_TRIG_CNTL_TRIGGER_SET | + R128_CAP0_TRIG_CNTL_CAPTURE_EN); + + + if(pPriv->theatre != NULL) + { + xf86_RT_SetInterlace(pPriv->theatre, 1); + R128_RT_SetEncoding(pPriv); + xf86_RT_SetOutputVideoSize(pPriv->theatre, width, height*2, 0, 0); + } + + if(pPriv->bt829 != NULL) + { + R128_BT_SetEncoding(pPriv); + xf86_bt829_SetCaptSize(pPriv->bt829, width, height*2); + } + + if(pPriv->i2c!=NULL) R128_board_setmisc(pPriv); + if(pPriv->msp3430 != NULL) R128_MSP_SetEncoding(pPriv); + if(pPriv->tda9850 != NULL) + { + xf86_tda9850_mute(pPriv->tda9850, pPriv->mute); + } + } + /* update cliplist */ + if(!RegionsEqual(&pPriv->clip, clipBoxes)) { + REGION_COPY(pScrn->pScreen, &pPriv->clip, clipBoxes); + /* draw these */ + if(pPriv->autopaint_colorkey)(*info->accel->FillSolidRects)(pScrn, pPriv->colorKey, GXcopy, ~0, + REGION_NUM_RECTS(clipBoxes), + REGION_RECTS(clipBoxes)); + } + + pPriv->doubleBuffer = 1; + R128DisplayVideo422(pScrn, id, offset1 + top*srcPitch, offset2 + top*srcPitch, width, height, dstPitch, + xa, xb, ya, &dstBox, src_w, src_h, drw_w, drw_h); + + R128WaitForIdle(pScrn); + + OUTREG(R128_OV0_REG_LOAD_CNTL, R128_REG_LD_CTL_LOCK); + while(!(INREG(R128_OV0_REG_LOAD_CNTL) & R128_REG_LD_CTL_LOCK_READBACK)); + + OUTREG(R128_OV0_AUTO_FLIP_CNTL, R128_OV0_AUTO_FLIP_CNTL_SOFT_BUF_ODD|R128_OV0_AUTO_FLIP_CNTL_SHIFT_ODD_DOWN); + + OUTREG (R128_OV0_AUTO_FLIP_CNTL, (INREG (R128_OV0_AUTO_FLIP_CNTL) ^ R128_OV0_AUTO_FLIP_CNTL_SOFT_EOF_TOGGLE )); + OUTREG (R128_OV0_AUTO_FLIP_CNTL, (INREG (R128_OV0_AUTO_FLIP_CNTL) ^ R128_OV0_AUTO_FLIP_CNTL_SOFT_EOF_TOGGLE )); + + OUTREG(R128_OV0_DEINTERLACE_PATTERN, 0xAAAAA); + + OUTREG(R128_OV0_REG_LOAD_CNTL, 0); + + pPriv->videoStatus = CLIENT_VIDEO_ON; + pPriv->video_stream_active = TRUE; + + info->VideoTimerCallback = R128VideoTimerCallback; + + return Success; +} + static void R128VideoTimerCallback(ScrnInfoPtr pScrn, Time now) { @@ -1010,6 +3070,8 @@ R128VideoTimerCallback(ScrnInfoPtr pScrn, Time now) if(pPriv->offTime < now) { unsigned char *R128MMIO = info->MMIO; OUTREG(R128_OV0_SCALE_CNTL, 0); + if (info->cursor_start && pPriv->videoStatus & CLIENT_VIDEO_ON) + xf86ForceHWCursor (pScrn->pScreen, FALSE); pPriv->videoStatus = FREE_TIMER; pPriv->freeTime = now + FREE_DELAY; } @@ -1019,6 +3081,8 @@ R128VideoTimerCallback(ScrnInfoPtr pScrn, Time now) xf86FreeOffscreenLinear(pPriv->linear); pPriv->linear = NULL; } + if (info->cursor_start && pPriv->videoStatus & CLIENT_VIDEO_ON) + xf86ForceHWCursor (pScrn->pScreen, FALSE); pPriv->videoStatus = 0; info->VideoTimerCallback = NULL; } @@ -1026,3 +3090,6 @@ R128VideoTimerCallback(ScrnInfoPtr pScrn, Time now) } else /* shouldn't get here */ info->VideoTimerCallback = NULL; } + + +#endif /* !XvExtension */
Locations
Projects
Search
Status Monitor
Help
OpenBuildService.org
Documentation
API Documentation
Code of Conduct
Contact
Support
@OBShq
Terms
openSUSE Build Service is sponsored by
The Open Build Service is an
openSUSE project
.
Sign Up
Log In
Places
Places
All Projects
Status Monitor
