andreacavalli/xserver-multidpi
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Delete VDIF support; it was never used anyway.

Browse Source
This commit is contained in:
Adam Jackson 2007-06-02 16:07:20 -04:00
parent 66702f3c1c
commit 0e1384d831
9 changed files with 3 additions and 598 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
hw/xfree86/ddc/Makefile.am
View File

@ -1,9 +1,9 @@
sdk_HEADERS = edid.h vdif.h xf86DDC.h
sdk_HEADERS = edid.h xf86DDC.h
noinst_LIBRARIES = libddc.a
libddc_a_SOURCES = xf86DDC.c edid.c interpret_edid.c print_edid.c \
interpret_vdif.c print_vdif.c ddcProperty.c
ddcProperty.c
INCLUDES = $(XORG_INCS) -I$(srcdir)/../i2c

11
hw/xfree86/ddc/ddcProperty.c
View File

@ -35,7 +35,6 @@
#define EDID1_ATOM_NAME "XFree86_DDC_EDID1_RAWDATA"
#define EDID2_ATOM_NAME "XFree86_DDC_EDID2_RAWDATA"
#define VDIF_ATOM_NAME "XFree86_DDC_VDIF_RAWDATA"
static void
addRootWindowProperties(ScrnInfoPtr pScrn, xf86MonPtr DDC)
@ -103,16 +102,6 @@ addRootWindowProperties(ScrnInfoPtr pScrn, xf86MonPtr DDC)
xf86RegisterRootWindowProperty(scrnIndex, EDID2Atom, XA_INTEGER, 8,
256, (unsigned char *)EDID2rawdata);
}
#if 0
if (DDC->vdif) {
#define VDIF_DUMMY_STRING "setting dummy VDIF property - please insert correct values\n"
VDIFAtom = MakeAtom(VDIF_ATOM_NAME, sizeof(VDIF_ATOM_NAME), TRUE);
xf86RegisterRootWindowProperty(scrnIndex, VDIFAtom, XA_STRING, 8,
strlen(VDIF_DUMMY_STRING), VDIF_DUMMY_STRING);
}
#endif
}
Bool

4
hw/xfree86/ddc/edid.h
View File

@ -12,8 +12,6 @@
#ifndef _EDID_H_
#define _EDID_H_
#include "vdif.h"
/* read complete EDID record */
#define EDID1_LEN 128
#define BITS_PER_BYTE 9
@ -453,7 +451,7 @@ typedef struct {
struct established_timings timings1;
struct std_timings timings2[8];
struct detailed_monitor_section det_mon[4];
xf86vdifPtr vdif;
void *vdif; /* unused */
int no_sections;
Uchar *rawData;
} xf86Monitor, *xf86MonPtr;

132
hw/xfree86/ddc/interpret_vdif.c
View File

@ -1,132 +0,0 @@
#ifdef HAVE_XORG_CONFIG_H
#include <xorg-config.h>
#endif
#include <X11/Xarch.h>
#include "xf86DDC.h"
#include "vdif.h"
static xf86VdifLimitsPtr* get_limits(CARD8 *c);
static xf86VdifGammaPtr* get_gamma(CARD8 *c);
static xf86VdifTimingPtr* get_timings(CARD8 *c);
#if X_BYTE_ORDER == X_BIG_ENDIAN
static CARD32 swap_byte_order(CARD32 c);
#endif
xf86vdifPtr
xf86InterpretVdif(CARD8 *c)
{
xf86VdifPtr p = (xf86VdifPtr)c;
xf86vdifPtr vdif;
int i;
#if X_BYTE_ORDER == X_BIG_ENDIAN
int length;
#endif
unsigned long l = 0;
if (c == NULL) return NULL;
#if X_BYTE_ORDER == X_BIG_ENDIAN
length = swap_byte_order(p->FileLength);
for (i = 0; i < (length >>2); i++)
((CARD32*)c)[i] = swap_byte_order(((CARD32*)c)[i]) ;
#endif
if (p->VDIFId[0] != 'V' || p->VDIFId[1] != 'D' || p->VDIFId[2] != 'I'
|| p->VDIFId[3] != 'F') return NULL;
for ( i = 12; i < p->FileLength; i++)
l += c[i];
if ( l != p->Checksum) return NULL;
vdif = xalloc(sizeof(xf86vdif));
vdif->vdif = p;
vdif->limits = get_limits(c);
vdif->timings = get_timings(c);
vdif->gamma = get_gamma(c);
vdif->strings = VDIF_STRING(((xf86VdifPtr)c),0);
xfree(c);
return vdif;
}
static xf86VdifLimitsPtr*
get_limits(CARD8 *c)
{
int num, i, j;
xf86VdifLimitsPtr *pp;
xf86VdifLimitsPtr p;
num = ((xf86VdifPtr)c)->NumberOperationalLimits;
pp = xalloc(sizeof(xf86VdifLimitsPtr) * (num+1));
p = VDIF_OPERATIONAL_LIMITS(((xf86VdifPtr)c));
j = 0;
for ( i = 0; i<num; i++) {
if (p->Header.ScnTag == VDIF_OPERATIONAL_LIMITS_TAG)
pp[j++] = p;
VDIF_NEXT_OPERATIONAL_LIMITS(p);
}
pp[j] = NULL;
return pp;
}
static xf86VdifGammaPtr*
get_gamma(CARD8 *c)
{
int num, i, j;
xf86VdifGammaPtr *pp;
xf86VdifGammaPtr p;
num = ((xf86VdifPtr)c)->NumberOptions;
pp = xalloc(sizeof(xf86VdifGammaPtr) * (num+1));
p = (xf86VdifGammaPtr)VDIF_OPTIONS(((xf86VdifPtr)c));
j = 0;
for ( i = 0; i<num; i++)
{
if (p->Header.ScnTag == VDIF_GAMMA_TABLE_TAG)
pp[j++] = p;
VDIF_NEXT_OPTIONS(p);
}
pp[j] = NULL;
return pp;
}
static xf86VdifTimingPtr*
get_timings(CARD8 *c)
{
int num, num_limits;
int i,j,k;
xf86VdifLimitsPtr lp;
xf86VdifTimingPtr *pp;
xf86VdifTimingPtr p;
num = ((xf86VdifPtr)c)->NumberOperationalLimits;
lp = VDIF_OPERATIONAL_LIMITS(((xf86VdifPtr)c));
num_limits = 0;
for (i = 0; i < num; i++) {
if (lp->Header.ScnTag == VDIF_OPERATIONAL_LIMITS_TAG)
num_limits += lp->NumberPreadjustedTimings;
VDIF_NEXT_OPERATIONAL_LIMITS(lp);
}
pp = xalloc(sizeof(xf86VdifTimingPtr)
* (num_limits+1));
j = 0;
lp = VDIF_OPERATIONAL_LIMITS(((xf86VdifPtr) c));
for (i = 0; i < num; i++) {
p = VDIF_PREADJUSTED_TIMING(lp);
for (k = 0; k < lp->NumberPreadjustedTimings; k++) {
if (p->Header.ScnTag == VDIF_PREADJUSTED_TIMING_TAG)
pp[j++] = p;
VDIF_NEXT_PREADJUSTED_TIMING(p);
}
VDIF_NEXT_OPERATIONAL_LIMITS(lp);
}
pp[j] = NULL;
return pp;
}
#if X_BYTE_ORDER == X_BIG_ENDIAN
static CARD32
swap_byte_order(CARD32 c)
{
return ((c & 0xFF000000) >> 24) | ((c & 0xFF0000) >> 8)
| ((c & 0xFF00) << 8) | ((c & 0xFF) << 24);
}
#endif

225
hw/xfree86/ddc/print_vdif.c
View File

@ -1,225 +0,0 @@
#ifdef HAVE_XORG_CONFIG_H
#include <xorg-config.h>
#endif
#include "vdif.h"
#include "misc.h"
#include "xf86DDC.h"
static void print_vdif(xf86VdifPtr l, char *s);
static void print_timings(xf86VdifTimingPtr *pt);
static void print_limits(xf86VdifLimitsPtr *pl);
static void print_gamma(xf86VdifGammaPtr *pg);
static void print_type(CARD8 c);
static void print_polarity(CARD8 c);
void
xf86print_vdif(xf86vdifPtr v)
{
print_vdif(v->vdif,v->strings);
print_limits(v->limits);
print_timings(v->timings);
print_gamma(v->gamma);
}
static void
print_vdif(xf86VdifPtr l, char *s)
{
ErrorF("Version %i.%i",l->VDIFVersion,l->VDIFRevision);
ErrorF(" Date: %i/%i/%i, Manufactured: %i/%i/%i\n",l->Date[0],
l->Date[1],l->Date[2],l->DateManufactured[0],
l->DateManufactured[1],l->DateManufactured[2]);
ErrorF("File Revision: %i",l->FileRevision);
ErrorF("Manufacturer: %s\n",s + l->Manufacturer);
ErrorF("ModelNumber: %s\n",s + l->ModelNumber);
ErrorF("VDIFIndex: %s\n",s +l->MinVDIFIndex);
ErrorF("Version: %s\n",s + l->Version);
ErrorF("SerialNumber %s\n",s + l->SerialNumber);
ErrorF("MonitorType: ");
switch (l->MonitorType) {
case VDIF_MONITOR_MONOCHROME:
ErrorF("Mono\n");
break;
case VDIF_MONITOR_COLOR:
ErrorF("Color\n");
break;
}
ErrorF("CRT Size: %i inches\n",l->CRTSize);
switch (l->MonitorType) {
case VDIF_MONITOR_MONOCHROME:
ErrorF("Border: %i percent\n",
l->BorderRed);
ErrorF("Phosphor Decay: 1: %i,",l->RedPhosphorDecay);
if (l->GreenPhosphorDecay !=0)
ErrorF(" 2: %i,",l->GreenPhosphorDecay);
if (l->BluePhosphorDecay !=0)
ErrorF(" 3: %i",l->BluePhosphorDecay);
ErrorF(" ms\n");
if (l->RedChromaticity_x)
ErrorF("Chromaticity: 1: x:%f, y:%f; ",
l->RedChromaticity_x/1000.0,l->RedChromaticity_y/1000.0);
if (l->GreenChromaticity_x)
ErrorF("Chromaticity: 2: x:%f, y:%f; ",
l->GreenChromaticity_x/1000.0,l->GreenChromaticity_y/1000.0);
if (l->BlueChromaticity_x)
ErrorF("Chromaticity: 3: x:%f, y:%f ",
l->BlueChromaticity_x/1000.0,l->BlueChromaticity_y/1000.0);
ErrorF("\n");
ErrorF("Gamma: %f\n",l->RedGamma/1000.0);
break;
case VDIF_MONITOR_COLOR:
ErrorF("Border: Red: %i Green: %i Blue: %i percent\n",
l->BorderRed,l->BorderGreen,l->BorderBlue);
ErrorF("Phosphor Decay: Red: %i, Green: %i, Blue: %i ms\n",
l->RedPhosphorDecay,l->GreenPhosphorDecay,l->BluePhosphorDecay);
ErrorF("Chromaticity: Red: x:%f, y:%f; Green: x:%f, y:%f; "
"Blue: x:%f, y:%f\n",
l->RedChromaticity_x/1000.0,l->RedChromaticity_y/1000.0,
l->GreenChromaticity_x/1000.0,l->GreenChromaticity_y/1000.0,
l->BlueChromaticity_x/1000.0,l->BlueChromaticity_y/1000.0);
ErrorF("Gamma: Red:%f, Green:%f, Blue:%f\n",l->RedGamma/1000.0,
l->GreenGamma/1000.0,l->BlueGamma/1000.0);
break;
}
ErrorF("White Point: x: %f y: %f Y: %f\n",l->WhitePoint_x/1000.0,
l->WhitePoint_y/1000.0,l->WhitePoint_Y/1000.0);
}
static void
print_limits(xf86VdifLimitsPtr *pl)
{
int i = 0;
xf86VdifLimitsPtr l;
while((l = pl[i]) != NULL) {
ErrorF("Max display resolution: %i x %i pixel\n",l->MaxHorPixel,
l->MaxVerPixel);
ErrorF("Size of active area: %i x %i millimeters\n",l->MaxHorActiveLength,
l->MaxVerActiveHeight);
ErrorF("Video Type: ");
print_type(l->VideoType);
ErrorF("Sync Type: ");
print_type(l->SyncType);
ErrorF("Sync Configuration ");
switch (l->SyncConfiguration) {
case VDIF_SYNC_SEPARATE:
ErrorF("separate\n");
break;
case VDIF_SYNC_C:
ErrorF("composite C\n");
break;
case VDIF_SYNC_CP:
ErrorF("composite CP\n");
break;
case VDIF_SYNC_G:
ErrorF("composite G\n");
break;
case VDIF_SYNC_GP:
ErrorF("composite GP\n");
break;
case VDIF_SYNC_OTHER:
ErrorF("other\n");
break;
}
ErrorF("Termination Resistance: %i\n",l->TerminationResistance);
ErrorF("Levels: white: %i, black: %i, blank: %i, sync: %i mV\n",
l->WhiteLevel,l->BlackLevel,l->BlankLevel,l->SyncLevel);
ErrorF("Max. Pixel Clock: %f MHz\n",l->MaxPixelClock/1000.0);
ErrorF("Freq. Range: Hor.: %f - %f kHz, Ver.: %f - %f Hz\n",
l->MaxHorFrequency/1000.0,l->MinHorFrequency/1000.0,
l->MaxVerFrequency/1000.0,l->MinVerFrequency/1000.0);
ErrorF("Retrace time: Hor: %f us, Ver: %f ms\n",l->MinHorRetrace/1000.0,
l->MinVerRetrace/1000.0);
}
}
static void
print_timings(xf86VdifTimingPtr *pt)
{
int i = 0;
xf86VdifTimingPtr t;
while((t = pt[i]) != NULL) {
ErrorF("SVGA / SVPMI mode number: %i\n",t->PreadjustedTimingName);
ErrorF("Mode %i x %i\n",t->HorPixel,t->VerPixel);
ErrorF("Size: %i x %i mm\n",t->HorAddrLength,t->VerAddrHeight);
ErrorF("Ratios: %i/%i\n",t->PixelWidthRatio,t->PixelHeightRatio);
ErrorF("Character width: %i",t->CharacterWidth);
ErrorF("Clock: %f MHz HFreq.: %f kHz, VFreq: %f Hz\n",t->PixelClock/1000.0,
t->HorFrequency/1000.0,t->VerFrequency/1000.0);
ErrorF("Htotal: %f us, Vtotal %f ms\n", t->HorTotalTime/1000.0,
t->VerTotalTime/1000.0);
ErrorF("HDisp: %f, HBlankStart: %f, HBlankLength: %f, "
"HSyncStart: %f HSyncEnd: %f us\n",t->HorAddrTime/1000.0,
t->HorBlankStart/1000.0,t->HorBlankTime/1000.0,
t->HorSyncStart/1000.0,t->HorSyncTime/1000.0);
ErrorF("VDisp: %f, VBlankStart: %f, VBlankLength: %f, "
"VSyncStart: %f VSyncEnd: %f us\n",t->VerAddrTime/1000.0,
t->VerBlankStart/1000.0,t->VerBlankTime/1000.0,
t->VerSyncStart/1000.0,t->VerSyncTime/1000.0);
ErrorF("Scan Type: ");
switch (t->ScanType) {
case VDIF_SCAN_INTERLACED:
ErrorF("interlaced ");
break;
case VDIF_SCAN_NONINTERLACED:
ErrorF("non interlaced ");
break;
case VDIF_SCAN_OTHER:
ErrorF("other ");
break;
}
ErrorF("Polarity: H: ");
print_polarity(t->HorSyncPolarity);
ErrorF("V: ");
print_polarity(t->VerSyncPolarity);
ErrorF("\n");
}
}
static void
print_gamma(xf86VdifGammaPtr *pg)
{
int i = 0;
xf86VdifGammaPtr g;
while((g = pg[i]) != NULL) {
ErrorF("Gamma Table Entries: %i\n",g->GammaTableEntries);
}
}
static void
print_type(CARD8 c)
{
switch (c) {
case VDIF_VIDEO_TTL :
ErrorF("TTL\n");
break;
case VDIF_VIDEO_ANALOG :
ErrorF("Analog\n");
break;
case VDIF_VIDEO_ECL:
ErrorF("ECL\n");
break;
case VDIF_VIDEO_DECL:
ErrorF("DECL\n");
break;
case VDIF_VIDEO_OTHER:
ErrorF("other\n");
break;
}
}
static void
print_polarity(CARD8 c)
{
switch (c) {
case VDIF_POLARITY_NEGATIVE:
ErrorF(" Neg.");
break;
case VDIF_POLARITY_POSITIVE:
ErrorF(" Pos.");
break;
}
}

174
hw/xfree86/ddc/vdif.h
View File

@ -1,174 +0,0 @@
#ifndef _VDIF_H
#define _VDIF_H
#define VDIF_MONITOR_MONOCHROME 0
#define VDIF_MONITOR_COLOR 1
#define VDIF_VIDEO_TTL 0
#define VDIF_VIDEO_ANALOG 1
#define VDIF_VIDEO_ECL 2
#define VDIF_VIDEO_DECL 3
#define VDIF_VIDEO_OTHER 4
#define VDIF_SYNC_SEPARATE 0
#define VDIF_SYNC_C 1
#define VDIF_SYNC_CP 2
#define VDIF_SYNC_G 3
#define VDIF_SYNC_GP 4
#define VDIF_SYNC_OTHER 5
#define VDIF_SCAN_NONINTERLACED 0
#define VDIF_SCAN_INTERLACED 1
#define VDIF_SCAN_OTHER 2
#define VDIF_POLARITY_NEGATIVE 0
#define VDIF_POLARITY_POSITIVE 1
#include <X11/Xmd.h>
#undef CARD32
#define CARD32 unsigned int /* ... on all supported platforms */
typedef struct _VDIF { /* Monitor Description: */
CARD8 VDIFId[4]; /* alway "VDIF" */
CARD32 FileLength; /* lenght of the whole file */
CARD32 Checksum; /* sum of all bytes in the file after*/
/* this field */
CARD16 VDIFVersion; /* structure version number */
CARD16 VDIFRevision; /* structure revision number */
CARD16 Date[3]; /* file date Year/Month/Day */
CARD16 DateManufactured[3]; /* date Year/Month/Day */
CARD32 FileRevision; /* file revision string */
CARD32 Manufacturer; /* ASCII ID of the manufacturer */
CARD32 ModelNumber; /* ASCII ID of the model */
CARD32 MinVDIFIndex; /* ASCII ID of Minimum VDIF index */
CARD32 Version; /* ASCII ID of the model version */
CARD32 SerialNumber; /* ASCII ID of the serial number */
CARD8 MonitorType; /* Monochrome or Color */
CARD8 CRTSize; /* inches */
CARD8 BorderRed; /* percent */
CARD8 BorderGreen; /* percent */
CARD8 BorderBlue; /* percent */
CARD8 Reserved1; /* padding */
CARD16 Reserved2; /* padding */
CARD32 RedPhosphorDecay; /* microseconds */
CARD32 GreenPhosphorDecay; /* microseconds */
CARD32 BluePhosphorDecay; /* microseconds */
CARD16 WhitePoint_x; /* WhitePoint in CIExyY (scale 1000) */
CARD16 WhitePoint_y;
CARD16 WhitePoint_Y;
CARD16 RedChromaticity_x; /* Red chromaticity in x,y */
CARD16 RedChromaticity_y;
CARD16 GreenChromaticity_x; /* Green chromaticity in x,y */
CARD16 GreenChromaticity_y;
CARD16 BlueChromaticity_x; /* Blue chromaticity in x,y */
CARD16 BlueChromaticity_y;
CARD16 RedGamma; /* Gamme curve exponent (scale 1000) */
CARD16 GreenGamma;
CARD16 BlueGamma;
CARD32 NumberOperationalLimits;
CARD32 OffsetOperationalLimits;
CARD32 NumberOptions; /* optinal sections (gamma table) */
CARD32 OffsetOptions;
CARD32 OffsetStringTable;
} xf86VdifRec, *xf86VdifPtr;
typedef enum { /* Tags for section identification */
VDIF_OPERATIONAL_LIMITS_TAG = 1,
VDIF_PREADJUSTED_TIMING_TAG,
VDIF_GAMMA_TABLE_TAG
} VDIFScnTag;
typedef struct _VDIFScnHdr { /* Generic Section Header: */
CARD32 ScnLength; /* lenght of section */
CARD32 ScnTag; /* tag for section identification */
} VDIFScnHdrRec, *VDIFScnHdrPtr;
typedef struct _VDIFLimits { /* Operational Limits: */
VDIFScnHdrRec Header; /* common section info */
CARD16 MaxHorPixel; /* pixels */
CARD16 MaxVerPixel; /* lines */
CARD16 MaxHorActiveLength; /* millimeters */
CARD16 MaxVerActiveHeight; /* millimeters */
CARD8 VideoType; /* TTL / Analog / ECL / DECL */
CARD8 SyncType; /* TTL / Analog / ECL / DECL */
CARD8 SyncConfiguration; /* separate / composite / other */
CARD8 Reserved1; /* padding */
CARD16 Reserved2; /* padding */
CARD16 TerminationResistance; /* */
CARD16 WhiteLevel; /* millivolts */
CARD16 BlackLevel; /* millivolts */
CARD16 BlankLevel; /* millivolts */
CARD16 SyncLevel; /* millivolts */
CARD32 MaxPixelClock; /* kiloHertz */
CARD32 MinHorFrequency; /* Hertz */
CARD32 MaxHorFrequency; /* Hertz */
CARD32 MinVerFrequency; /* milliHertz */
CARD32 MaxVerFrequency; /* milliHertz */
CARD16 MinHorRetrace; /* nanoseconds */
CARD16 MinVerRetrace; /* microseconds */
CARD32 NumberPreadjustedTimings;
CARD32 OffsetNextLimits;
} xf86VdifLimitsRec, *xf86VdifLimitsPtr;
typedef struct _VDIFTiming { /* Preadjusted Timing: */
VDIFScnHdrRec Header; /* common section info */
CARD32 PreadjustedTimingName; /* SVGA/SVPMI mode number */
CARD16 HorPixel; /* pixels */
CARD16 VerPixel; /* lines */
CARD16 HorAddrLength; /* millimeters */
CARD16 VerAddrHeight; /* millimeters */
CARD8 PixelWidthRatio; /* gives H:V */
CARD8 PixelHeightRatio;
CARD8 Reserved1; /* padding */
CARD8 ScanType; /* noninterlaced / interlaced / other*/
CARD8 HorSyncPolarity; /* negative / positive */
CARD8 VerSyncPolarity; /* negative / positive */
CARD16 CharacterWidth; /* pixels */
CARD32 PixelClock; /* kiloHertz */
CARD32 HorFrequency; /* Hertz */
CARD32 VerFrequency; /* milliHertz */
CARD32 HorTotalTime; /* nanoseconds */
CARD32 VerTotalTime; /* microseconds */
CARD16 HorAddrTime; /* nanoseconds */
CARD16 HorBlankStart; /* nanoseconds */
CARD16 HorBlankTime; /* nanoseconds */
CARD16 HorSyncStart; /* nanoseconds */
CARD16 HorSyncTime; /* nanoseconds */
CARD16 VerAddrTime; /* microseconds */
CARD16 VerBlankStart; /* microseconds */
CARD16 VerBlankTime; /* microseconds */
CARD16 VerSyncStart; /* microseconds */
CARD16 VerSyncTime; /* microseconds */
} xf86VdifTimingRec, *xf86VdifTimingPtr;
typedef struct _VDIFGamma { /* Gamma Table: */
VDIFScnHdrRec Header; /* common section info */
CARD16 GammaTableEntries; /* count of grays or RGB 3-tuples */
CARD16 Unused1;
} xf86VdifGammaRec, *xf86VdifGammaPtr;
/* access macros */
#define VDIF_OPERATIONAL_LIMITS(vdif) \
((xf86VdifLimitsPtr)((char*)(vdif) + (vdif)->OffsetOperationalLimits))
#define VDIF_NEXT_OPERATIONAL_LIMITS(limits) limits = \
((xf86VdifLimitsPtr)((char*)(limits) + (limits)->OffsetNextLimits))
#define VDIF_PREADJUSTED_TIMING(limits) \
((xf86VdifTimingPtr)((char*)(limits) + (limits)->Header.ScnLength))
#define VDIF_NEXT_PREADJUSTED_TIMING(timing) timing = \
((xf86VdifTimingPtr)((char*)(timing) + (timing)->Header.ScnLength))
#define VDIF_OPTIONS(vdif) \
((VDIFScnHdrPtr)((char*)(vdif) + (vdif)->OffsetOptions))
#define VDIF_NEXT_OPTIONS(options) options = \
((xf86VdifGammaPtr)((char*)(options) + (options)->Header.ScnLength))
#define VDIF_STRING(vdif, string) \
((char*)((char*)vdif + vdif->OffsetStringTable + (string)))
typedef struct _vdif {
xf86VdifPtr vdif;
xf86VdifLimitsPtr *limits;
xf86VdifTimingPtr *timings;
xf86VdifGammaPtr *gamma;
char * strings;
} xf86vdif, *xf86vdifPtr;
#undef CARD32
#endif

41
hw/xfree86/ddc/xf86DDC.c
View File

@ -38,12 +38,6 @@ static unsigned char* EDID1Read_DDC2(
I2CBusPtr pBus
);
static unsigned char * VDIFRead(
int scrnIndex,
I2CBusPtr pBus,
int start
);
static unsigned char * DDCRead_DDC2(
int scrnIndex,
I2CBusPtr pBus,
@ -138,7 +132,6 @@ xf86DoEDID_DDC2(int scrnIndex, I2CBusPtr pBus)
{
ScrnInfoPtr pScrn = xf86Screens[scrnIndex];
unsigned char *EDID_block = NULL;
unsigned char *VDIF_Block = NULL;
xf86MonPtr tmp = NULL;
/* Default DDC and DDC2 to enabled. */
Bool noddc = FALSE, noddc2 = FALSE;
@ -171,11 +164,6 @@ xf86DoEDID_DDC2(int scrnIndex, I2CBusPtr pBus)
else
ErrorF("Sections to follow: %i\n",tmp->no_sections);
#endif
if (tmp) {
VDIF_Block =
VDIFRead(scrnIndex, pBus, EDID1_LEN * (tmp->no_sections + 1));
tmp->vdif = xf86InterpretVdif(VDIF_Block);
}
return tmp;
}
@ -253,35 +241,6 @@ EDID1Read_DDC2(int scrnIndex, I2CBusPtr pBus)
return DDCRead_DDC2(scrnIndex, pBus, 0, EDID1_LEN);
}
static unsigned char*
VDIFRead(int scrnIndex, I2CBusPtr pBus, int start)
{
unsigned char * Buffer, *v_buffer = NULL, *v_bufferp = NULL;
int i, num = 0;
/* read VDIF length in 64 byte blocks */
Buffer = DDCRead_DDC2(scrnIndex, pBus,start,64);
if (Buffer == NULL)
return NULL;
#ifdef DEBUG
ErrorF("number of 64 bit blocks: %i\n",Buffer[0]);
#endif
if ((num = Buffer[0]) > 0)
v_buffer = v_bufferp = xalloc(sizeof(unsigned char) * 64 * num);
for (i = 0; i < num; i++) {
Buffer = DDCRead_DDC2(scrnIndex, pBus,start,64);
if (Buffer == NULL) {
xfree (v_buffer);
return NULL;
}
memcpy(v_bufferp,Buffer,63); /* 64th byte is checksum */
xfree(Buffer);
v_bufferp += 63;
}
return v_buffer;
}
static unsigned char *
DDCRead_DDC2(int scrnIndex, I2CBusPtr pBus, int start, int len)
{

8
hw/xfree86/ddc/xf86DDC.h
View File

@ -43,10 +43,6 @@ extern xf86MonPtr xf86InterpretEDID(
int screenIndex, Uchar *block
);
extern xf86vdifPtr xf86InterpretVdif(
CARD8 *c
);
extern void
xf86DDCMonitorSet(int scrnIndex, MonPtr Monitor, xf86MonPtr DDC);
@ -55,10 +51,6 @@ extern Bool xf86SetDDCproperties(
xf86MonPtr DDC
);
extern void xf86print_vdif(
xf86vdifPtr v
);
DisplayModePtr xf86DDCGetModes(int scrnIndex, xf86MonPtr DDC);
#endif

2
hw/xfree86/loader/xf86sym.c
View File

@ -1236,8 +1236,6 @@ _X_HIDDEN void *xfree86LookupTab[] = {
SYMFUNC(xf86DoEDID_DDC2)
SYMFUNC(xf86InterpretEDID)
SYMFUNC(xf86PrintEDID)
SYMFUNC(xf86InterpretVdif)
SYMFUNC(xf86print_vdif)
SYMFUNC(xf86DDCMonitorSet)
SYMFUNC(xf86SetDDCproperties)