imped: initial randr impl step 1

6 files changed, 397 insertions, 1 deletions

diff --git a/drv/Makefile.am b/drv/Makefile.am
index 20775076f..ac29d2d31 100644
--- a/drv/Makefile.am
+++ b/drv/Makefile.am
@@ -32,7 +32,9 @@ libdrv_la_SOURCES = 	\
 	drv_picture.c \
 	drv_damage.c \
 	drv_screen.c \
+	drv_randr.c \
 	impedscrn.c \
 	impedgc.c \
 	impedpict.c \
-	impedplug.c
+	impedplug.c \
+	impedrandr.c
diff --git a/drv/drv_imped.h b/drv/drv_imped.h
index ec05e9b80..6e2c8d0dd 100644
--- a/drv/drv_imped.h
+++ b/drv/drv_imped.h
@@ -124,4 +124,6 @@ extern _X_EXPORT Bool impedFinishScreenInit(ScreenPtr pScreen,
 extern _X_EXPORT void impedInit(void);
 
 void impedPictureDuplicate(PicturePtr pPicture, int new_gpu_index);
+
+void impedRandRBindScreen(ScreenPtr pScreen, DrvScreenPtr pDrvScreen, int gpu_index);
 #endif
diff --git a/drv/drv_randr.c b/drv/drv_randr.c
new file mode 100644
index 000000000..cb4e45e32
--- /dev/null
+++ b/drv/drv_randr.c
@@ -0,0 +1,105 @@
+/* randr 1.2 drv impedance layer */
+
+#ifdef HAVE_DIX_CONFIG_H
+#include <dix-config.h>
+#endif
+
+#include "drv_randr.h"
+
+DevPrivateKeyRec drvrrPrivKeyRec;
+
+Bool DrvRRInit(void)
+{
+    if (!dixRegisterPrivateKey(&drvrrPrivKeyRec, PRIVATE_DRV_SCREEN, 0))
+	return FALSE;
+}
+
+Bool DrvRRScreenInit(DrvScreenPtr pDrvScreen)
+{
+    drvrrScrPrivPtr pScrPriv;
+
+    if (!DrvRRInit())
+	return FALSE;
+
+    pScrPriv = (drvrrScrPrivPtr)calloc(1, sizeof(drvrrScrPrivRec));
+    if (!pScrPriv)
+	return FALSE;
+
+    DrvSetRRScreen(pDrvScreen, pScrPriv);
+    return TRUE;
+}
+		   
+
+DrvRRCrtcPtr DrvRRCrtcCreate(DrvScreenPtr pDrvScreen, void *devPrivate)
+{
+    DrvRRCrtcPtr crtc;
+    drvrrScrPrivPtr pDrvScrPriv;
+    DrvRRCrtcPtr *crtcs;
+
+    if (!DrvRRInit())
+	return FALSE;
+
+    pDrvScrPriv = drvrrGetScrPriv(pDrvScreen);
+    if (pDrvScrPriv->numCrtcs)
+	crtcs = realloc(pDrvScrPriv->crtcs,
+			(pDrvScrPriv->numCrtcs + 1) * sizeof(DrvRRCrtcPtr));
+    else
+	crtcs = malloc(sizeof(DrvRRCrtcPtr));
+
+    if (!crtcs)
+	return NULL;
+    pDrvScrPriv->crtcs = crtcs;
+
+    crtc = calloc(1, sizeof(DrvRRCrtcRec));
+    if (!crtc)
+	return NULL;
+    crtc->pDrvScreen = pDrvScreen;
+    crtc->devPrivate = devPrivate;
+
+    pDrvScrPriv->crtcs[pDrvScrPriv->numCrtcs++] = crtc;
+    return crtc;
+}
+
+void DrvRRCrtcDestroy(DrvRRCrtcPtr crtc)
+{
+}
+
+DrvRROutputPtr DrvRROutputCreate(DrvScreenPtr pDrvScreen,
+				 const char *name,
+				 int nameLength,
+				 void *devPrivate)
+{
+    DrvRROutputPtr output;
+    DrvRROutputPtr *outputs;
+    drvrrScrPrivPtr pDrvScrPriv;
+
+    if (!DrvRRInit())
+	return FALSE;
+
+    pDrvScrPriv = drvrrGetScrPriv(pDrvScreen);
+    if (pDrvScrPriv->numOutputs)
+	outputs = realloc(pDrvScrPriv->outputs,
+			  (pDrvScrPriv->numOutputs + 1) * sizeof(DrvRROutputPtr));
+    else
+	outputs = malloc(sizeof(DrvRROutputPtr));
+
+    if (!outputs)
+	return NULL;
+    pDrvScrPriv->outputs = outputs;
+
+    output = calloc(1, sizeof(DrvRROutputRec));
+    if (!output)
+	return NULL;
+
+    output->pDrvScreen = pDrvScreen;
+    output->devPrivate = devPrivate;
+    output->name = name;
+    output->name_len = nameLength;
+    pDrvScrPriv->outputs[pDrvScrPriv->numOutputs++] = output;
+    return output;
+}
+
+void
+DrvRROutputDestroy(DrvRROutputPtr output)
+{
+}
diff --git a/drv/drv_randr.h b/drv/drv_randr.h
new file mode 100644
index 000000000..74f7176d4
--- /dev/null
+++ b/drv/drv_randr.h
@@ -0,0 +1,150 @@
+
+#ifndef DRV_RANDR_H
+#define DRV_RANDR_H
+
+#include <X11/X.h>
+#include <X11/Xproto.h>
+#include "misc.h"
+
+#include "randrstr.h"
+
+#include "drv_scrnintstr.h"
+
+struct _drvrrCrtc {
+    DrvScreenPtr pDrvScreen;
+    void *devPrivate;
+    RRCrtcPtr rr_crtc;
+};
+
+struct _drvrrOutput {
+    DrvScreenPtr pDrvScreen;
+    void *devPrivate;
+    RROutputPtr rr_output;
+    char *name;
+    int name_len;
+};
+
+struct _drvrrMode {
+};
+
+typedef struct _rrPropertyValue DrvRRPropertyValueRec, *DrvRRPropertyValuePtr;
+typedef struct _drvrrOutput DrvRROutputRec, *DrvRROutputPtr;
+typedef struct _drvrrCrtc DrvRRCrtcRec, *DrvRRCrtcPtr;
+typedef struct _drvrrMode DrvRRModeRec, *DrvRRModePtr;
+
+typedef Bool (*DrvRRScreenSetSizeProcPtr)(DrvScreenPtr pScreen,
+					  CARD16 width,
+					  CARD16 height,
+					  CARD32 mmWidth,
+					  CARD32 mmHeight);
+
+typedef Bool (*DrvRRCrtcSetProcPtr) (DrvScreenPtr		pScreen,
+				  DrvRRCrtcPtr		crtc,
+				  DrvRRModePtr		mode,
+				  int			x,
+				  int			y,
+				  Rotation		rotation,
+				  int			numOutputs,
+				  DrvRROutputPtr		*outputs);
+
+typedef Bool (*DrvRRCrtcSetGammaProcPtr) (DrvScreenPtr	pScreen,
+				       DrvRRCrtcPtr	crtc);
+
+typedef Bool (*DrvRRCrtcGetGammaProcPtr) (DrvScreenPtr	pScreen,
+				       DrvRRCrtcPtr	crtc);
+
+typedef Bool (*DrvRROutputSetPropertyProcPtr) (DrvScreenPtr		pScreen,
+					    DrvRROutputPtr		output,
+					    Atom		property,
+					    DrvRRPropertyValuePtr	value);
+
+typedef Bool (*DrvRROutputValidateModeProcPtr) (DrvScreenPtr		pScreen,
+					     DrvRROutputPtr	output,
+					     DrvRRModePtr		mode);
+
+typedef void (*DrvRRModeDestroyProcPtr) (DrvScreenPtr	    pScreen,
+				      DrvRRModePtr	    mode);
+
+
+#if RANDR_13_INTERFACE
+typedef Bool (*DrvRROutputGetPropertyProcPtr) (DrvScreenPtr		pScreen,
+					    DrvRROutputPtr		output,
+					    Atom		property);
+typedef Bool (*DrvRRGetPanningProcPtr)    (DrvScreenPtr		pScrn,
+					DrvRRCrtcPtr		crtc,
+					BoxPtr		totalArea,
+					BoxPtr		trackingArea,
+					INT16		*border);
+typedef Bool (*DrvRRSetPanningProcPtr)    (DrvScreenPtr		pScrn,
+					DrvRRCrtcPtr		crtc,
+					BoxPtr		totalArea,
+					BoxPtr		trackingArea,
+					INT16		*border);
+
+#endif /* RANDR_13_INTERFACE */
+
+typedef Bool (*DrvRRGetInfoProcPtr) (DrvScreenPtr pScreen, Rotation *rotations);
+typedef Bool (*DrvRRCloseScreenProcPtr) ( int i, DrvScreenPtr pscreen);
+
+typedef struct _drvrrScrPriv {
+    DrvRRGetInfoProcPtr	    drvrrGetInfo;
+    DrvRRScreenSetSizeProcPtr  drvrrScreenSetSize;
+    DrvRRCrtcSetProcPtr	    drvrrCrtcSet;
+    DrvRRCrtcSetGammaProcPtr   drvrrCrtcSetGamma;
+    DrvRRCrtcGetGammaProcPtr   drvrrCrtcGetGamma;
+    DrvRROutputSetPropertyProcPtr	drvrrOutputSetProperty;
+    DrvRROutputValidateModeProcPtr	drvrrOutputValidateMode;
+    DrvRRModeDestroyProcPtr	drvrrModeDestroy;
+
+    int numCrtcs;
+    DrvRRCrtcPtr *crtcs;
+    int numOutputs;
+    DrvRROutputPtr *outputs;
+    
+} drvrrScrPrivRec, *drvrrScrPrivPtr;
+
+extern _X_EXPORT DrvRRCrtcPtr
+DrvRRCrtcCreate(DrvScreenPtr pDrvScreen, void *drvPrivate);
+
+extern _X_EXPORT void
+DrvRRCrtcDestroy(DrvRRCrtcPtr crtc);
+
+extern _X_EXPORT void
+DrvRRCrtcSetRotations(DrvRRCrtcPtr crtc, Rotation rotations);
+
+extern _X_EXPORT void
+DrvRRCrtcSetTransformSupport(DrvRRCrtcPtr crtc, Bool transforms);
+
+extern _X_EXPORT DrvRROutputPtr
+DrvRROutputCreate(DrvScreenPtr pDrvScreen,
+		  const char *name,
+		  int nameLength,
+		  void *devPrivate);
+
+extern _X_EXPORT Bool
+DrvRROutputSetClones(DrvRROutputPtr output,
+		     DrvRROutputPtr *clones,
+		     int numClones);
+
+extern _X_EXPORT Bool
+DrvRROutputSetModes(DrvRROutputPtr output,
+		    DrvRRModePtr *modes,
+		    int numModes,
+		    int numPreferred);
+
+extern _X_EXPORT Bool
+DrvRROutputSetConnection(DrvRROutputPtr output,
+			 CARD8 connection);
+
+extern _X_EXPORT void
+DrvRROutputDestroy(DrvRROutputPtr output);
+
+
+extern _X_EXPORT DevPrivateKeyRec drvrrPrivKeyRec;
+#define drvrrPrivKey (&drvrrPrivKeyRec)
+
+#define drvrrGetScrPriv(pScr)  ((drvrrScrPrivPtr)dixLookupPrivate(&(pScr)->devPrivates, drvrrPrivKey))
+#define drvrrScrPriv(pScr)	drvrrScrPrivPtr    pScrPriv = drvrrGetScrPriv(pScr)
+#define DrvSetRRScreen(s,p) dixSetPrivate(&(s)->devPrivates, drvrrPrivKey, p)
+
+#endif
diff --git a/drv/impedrandr.c b/drv/impedrandr.c
new file mode 100644
index 000000000..9ba6e65bc
--- /dev/null
+++ b/drv/impedrandr.c
@@ -0,0 +1,136 @@
+/* impedance randr 1.2 implementation hack job */
+#ifdef HAVE_DIX_CONFIG_H
+#include <dix-config.h>
+#endif
+
+#include "servermd.h"
+#include "privates.h"
+#include "randrstr.h"
+#include "drv_imped.h"
+#include "drv_randr.h"
+
+static DevPrivateKeyRec impedRandR12KeyRec;
+static DevPrivateKey impedRandR12Key;
+
+typedef struct _impedRRInfo {
+    struct _drvrrScrPriv gpu[MAX_GPU];
+} impedRRInfoRec, *impedRRInfoPtr;
+
+#define IMPEDRANDRINFO(p) ((impedRRInfoPtr) \
+    dixLookupPrivate(&(p)->devPrivates, impedRandR12Key))
+
+/* provide a wrapper layer around sub-screens randr implementation for now
+   - for randr 1.4 this needs more thinking about */
+Bool
+impedRandRGetInfo12(ScreenPtr pScreen, Rotation *rotations)
+{
+    impedScreenPrivPtr imped_screen = impedGetScreen(pScreen);
+    IMPEDRANDRINFO(pScreen);
+    int i;
+
+    
+    return TRUE;
+}
+
+Bool
+impedScreenSetSize(ScreenPtr pScreen, CARD16 width, CARD16 height,
+		   CARD32 mmWidth, CARD32 mmHeight)
+{
+    return FALSE;
+}
+
+Bool
+impedCrtcSet(ScreenPtr pScreen, RRCrtcPtr crtc, RRModePtr mode,
+	     int x, int y, Rotation rotation, int numOutputs,
+	     RROutputPtr *output)
+{
+    return FALSE;
+}
+
+Bool
+impedCrtcSetGamma(ScreenPtr pScreen, RRCrtcPtr crtc)
+{
+}
+
+Bool
+impedCrtcGetGamma(ScreenPtr pScreen, RRCrtcPtr crtc)
+{
+}
+
+Bool
+impedOutputSetProperty(ScreenPtr pScreen, RROutputPtr output,
+		       Atom property, RRPropertyValuePtr value)
+{
+
+}
+
+Bool
+impedOutputValidateMode(ScreenPtr pScreen, RROutputPtr output,
+			RRModePtr mode)
+{
+
+}
+
+void
+impedModeDestroy(ScreenPtr pScreen,
+		 RRModePtr mode)
+{
+
+}
+
+Bool
+impedRandR12Init(ScreenPtr pScreen)
+{
+    impedScreenPrivPtr imped_screen;
+    rrScrPrivPtr rp;
+    int i;
+
+    impedRandR12Key = &impedRandR12KeyRec;
+    if (!dixRegisterPrivateKey(&impedRandR12KeyRec, PRIVATE_SCREEN, 0))
+	return FALSE;
+
+	
+    if (!RRScreenInit(pScreen))
+	return FALSE;
+    
+    rp = rrGetScrPriv(pScreen);
+    rp->rrGetInfo = impedRandRGetInfo12;
+    rp->rrCrtcSet = impedCrtcSet;
+    rp->rrCrtcSetGamma = impedCrtcSetGamma;
+    rp->rrCrtcGetGamma = impedCrtcGetGamma;
+    rp->rrOutputSetProperty = impedOutputSetProperty;
+    rp->rrOutputValidateMode = impedOutputValidateMode;
+    rp->rrModeDestroy = impedModeDestroy;
+
+    rp->numCrtcs = 0;
+    rp->numOutputs = 0;
+    dixSetPrivate(&pScreen->devPrivates, impedRandR12Key, rp);
+
+    imped_screen = impedGetScreen(pScreen);
+    for (i = 0; i < imped_screen->num_gpu; i++) {
+	impedRandRBindScreen(pScreen, imped_screen->gpu[i], i);
+    }
+    return TRUE;
+}
+
+void
+impedRandRBindScreen(ScreenPtr pScreen, DrvScreenPtr pDrvScreen, int gpu_index)
+{
+    impedScreenPrivPtr imped_screen = impedGetScreen(pScreen);
+    //    IMPEDRANDRINFO(pScreen);
+    drvrrScrPriv(pDrvScreen);
+    int i;
+    
+    for (i = 0; i < pScrPriv->numCrtcs; i++) {
+	pScrPriv->crtcs[i]->rr_crtc = RRCrtcCreate(pScreen, pScrPriv->crtcs[i]);
+    }
+
+    for (i = 0; i < pScrPriv->numOutputs; i++) {
+	DrvRROutputPtr drv_output = pScrPriv->outputs[i];
+	drv_output->rr_output = RROutputCreate(pScreen, drv_output->name,
+					       drv_output->name_len,
+					       drv_output);
+    }
+
+}
+
diff --git a/drv/impedscrn.c b/drv/impedscrn.c
index 043ed9166..d60b70936 100644
--- a/drv/impedscrn.c
+++ b/drv/impedscrn.c
@@ -341,6 +341,7 @@ impedCreatePixmap (ScreenPtr pScreen, int width, int height, int depth,
     pPixmap->usage_hint = usage_hint;
 
     {
+	impedScreenPrivPtr imped_screen = impedGetScreen(pScreen);
 	impedPixmapPrivPtr imped_pixmap = impedGetPixmap(pPixmap);
 	int i;