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 */
