49f77fff14
Save in a few special cases, _X_EXPORT should not be used in C source files. Instead, it should be used in headers, and the proper C source include that header. Some special cases are symbols that need to be shared between modules, but not expected to be used by external drivers, and symbols that are accessible via LoaderSymbol/dlopen. This patch also adds conditionally some new sdk header files, depending on extensions enabled. These files were added to match pattern for other extensions/modules, that is, have the headers "deciding" symbol visibility in the sdk. These headers are: o Xext/panoramiXsrv.h, Xext/panoramiX.h o fbpict.h (unconditionally) o vidmodeproc.h o mioverlay.h (unconditionally, used only by xaa) o xfixes.h (unconditionally, symbols required by dri2) LoaderSymbol and similar functions now don't have different prototypes, in loaderProcs.h and xf86Module.h, so that both headers can be included, without the need of defining IN_LOADER. xf86NewInputDevice() device prototype readded to xf86Xinput.h, but not exported (and with a comment about it).
342 lines
8.4 KiB
C
342 lines
8.4 KiB
C
/* xf86DDC.c
|
|
*
|
|
* Copyright 1998,1999 by Egbert Eich <Egbert.Eich@Physik.TU-Darmstadt.DE>
|
|
*/
|
|
|
|
/*
|
|
* Note that DDC1 does not define any method for returning blocks beyond
|
|
* the first. DDC2 does, but the original implementation would only ever
|
|
* read the first block. If you want to read and parse all blocks, use
|
|
* xf86DoEEDID().
|
|
*/
|
|
|
|
#ifdef HAVE_XORG_CONFIG_H
|
|
#include <xorg-config.h>
|
|
#endif
|
|
|
|
#include "misc.h"
|
|
#include "xf86.h"
|
|
#include "xf86_OSproc.h"
|
|
#include "xf86DDC.h"
|
|
#include "ddcPriv.h"
|
|
#include <string.h>
|
|
|
|
#define RETRIES 4
|
|
|
|
static unsigned char *EDIDRead_DDC1(
|
|
ScrnInfoPtr pScrn,
|
|
DDC1SetSpeedProc,
|
|
unsigned int (*)(ScrnInfoPtr)
|
|
);
|
|
|
|
static Bool TestDDC1(
|
|
ScrnInfoPtr pScrn,
|
|
unsigned int (*)(ScrnInfoPtr)
|
|
);
|
|
|
|
static unsigned int *FetchEDID_DDC1(
|
|
ScrnInfoPtr,
|
|
register unsigned int (*)(ScrnInfoPtr)
|
|
);
|
|
|
|
typedef enum {
|
|
DDCOPT_NODDC1,
|
|
DDCOPT_NODDC2,
|
|
DDCOPT_NODDC
|
|
} DDCOpts;
|
|
|
|
static const OptionInfoRec DDCOptions[] = {
|
|
{ DDCOPT_NODDC1, "NoDDC1", OPTV_BOOLEAN, {0}, FALSE },
|
|
{ DDCOPT_NODDC2, "NoDDC2", OPTV_BOOLEAN, {0}, FALSE },
|
|
{ DDCOPT_NODDC, "NoDDC", OPTV_BOOLEAN, {0}, FALSE },
|
|
{ -1, NULL, OPTV_NONE, {0}, FALSE },
|
|
};
|
|
|
|
/**
|
|
* Attempts to probe the monitor for EDID information, if NoDDC and NoDDC1 are
|
|
* unset. EDID information blocks are interpreted and the results returned in
|
|
* an xf86MonPtr.
|
|
*
|
|
* This function does not affect the list of modes used by drivers -- it is up
|
|
* to the driver to decide policy on what to do with EDID information.
|
|
*
|
|
* @return pointer to a new xf86MonPtr containing the EDID information.
|
|
* @return NULL if no monitor attached or failure to interpret the EDID.
|
|
*/
|
|
xf86MonPtr
|
|
xf86DoEDID_DDC1(
|
|
int scrnIndex, DDC1SetSpeedProc DDC1SetSpeed,
|
|
unsigned int (*DDC1Read)(ScrnInfoPtr)
|
|
)
|
|
{
|
|
ScrnInfoPtr pScrn = xf86Screens[scrnIndex];
|
|
unsigned char *EDID_block = NULL;
|
|
xf86MonPtr tmp = NULL;
|
|
int sigio;
|
|
/* Default DDC and DDC1 to enabled. */
|
|
Bool noddc = FALSE, noddc1 = FALSE;
|
|
OptionInfoPtr options;
|
|
|
|
options = xnfalloc(sizeof(DDCOptions));
|
|
(void)memcpy(options, DDCOptions, sizeof(DDCOptions));
|
|
xf86ProcessOptions(pScrn->scrnIndex, pScrn->options, options);
|
|
|
|
xf86GetOptValBool(options, DDCOPT_NODDC, &noddc);
|
|
xf86GetOptValBool(options, DDCOPT_NODDC1, &noddc1);
|
|
xfree(options);
|
|
|
|
if (noddc || noddc1)
|
|
return NULL;
|
|
|
|
sigio = xf86BlockSIGIO();
|
|
EDID_block = EDIDRead_DDC1(pScrn,DDC1SetSpeed,DDC1Read);
|
|
xf86UnblockSIGIO(sigio);
|
|
|
|
if (EDID_block){
|
|
tmp = xf86InterpretEDID(scrnIndex,EDID_block);
|
|
}
|
|
#ifdef DEBUG
|
|
else ErrorF("No EDID block returned\n");
|
|
if (!tmp)
|
|
ErrorF("Cannot interpret EDID block\n");
|
|
#endif
|
|
return tmp;
|
|
}
|
|
|
|
static I2CDevPtr
|
|
DDC2MakeDevice(I2CBusPtr pBus, int address, char *name)
|
|
{
|
|
I2CDevPtr dev = NULL;
|
|
|
|
if (!(dev = xf86I2CFindDev(pBus, address))) {
|
|
dev = xf86CreateI2CDevRec();
|
|
dev->DevName = name;
|
|
dev->SlaveAddr = address;
|
|
dev->ByteTimeout = 2200; /* VESA DDC spec 3 p. 43 (+10 %) */
|
|
dev->StartTimeout = 550;
|
|
dev->BitTimeout = 40;
|
|
dev->AcknTimeout = 40;
|
|
|
|
dev->pI2CBus = pBus;
|
|
if (!xf86I2CDevInit(dev)) {
|
|
xf86DrvMsg(pBus->scrnIndex, X_PROBED, "No DDC2 device\n");
|
|
return NULL;
|
|
}
|
|
}
|
|
|
|
return dev;
|
|
}
|
|
|
|
static I2CDevPtr
|
|
DDC2Init(int scrnIndex, I2CBusPtr pBus)
|
|
{
|
|
I2CDevPtr dev = NULL;
|
|
|
|
/*
|
|
* Slow down the bus so that older monitors don't
|
|
* miss things.
|
|
*/
|
|
pBus->RiseFallTime = 20;
|
|
|
|
DDC2MakeDevice(pBus, 0x0060, "E-EDID segment register");
|
|
dev = DDC2MakeDevice(pBus, 0x00A0, "ddc2");
|
|
|
|
return dev;
|
|
}
|
|
|
|
/* Mmmm, smell the hacks */
|
|
static void
|
|
EEDIDStop(I2CDevPtr d)
|
|
{
|
|
}
|
|
|
|
/* block is the EDID block number. a segment is two blocks. */
|
|
static Bool
|
|
DDC2Read(I2CDevPtr dev, int block, unsigned char *R_Buffer)
|
|
{
|
|
unsigned char W_Buffer[1];
|
|
int i, segment;
|
|
I2CDevPtr seg;
|
|
void (*stop)(I2CDevPtr);
|
|
|
|
for (i = 0; i < RETRIES; i++) {
|
|
/* Stop bits reset the segment pointer to 0, so be careful here. */
|
|
segment = block >> 1;
|
|
if (segment) {
|
|
Bool b;
|
|
|
|
if (!(seg = xf86I2CFindDev(dev->pI2CBus, 0x0060)))
|
|
return FALSE;
|
|
|
|
W_Buffer[0] = segment;
|
|
|
|
stop = dev->pI2CBus->I2CStop;
|
|
dev->pI2CBus->I2CStop = EEDIDStop;
|
|
|
|
b = xf86I2CWriteRead(seg, W_Buffer, 1, NULL, 0);
|
|
|
|
dev->pI2CBus->I2CStop = stop;
|
|
if (!b) {
|
|
dev->pI2CBus->I2CStop(dev);
|
|
continue;
|
|
}
|
|
}
|
|
|
|
W_Buffer[0] = (block & 0x01) * EDID1_LEN;
|
|
|
|
if (xf86I2CWriteRead(dev, W_Buffer, 1, R_Buffer, EDID1_LEN)) {
|
|
if (!DDC_checksum(R_Buffer, EDID1_LEN))
|
|
return TRUE;
|
|
}
|
|
}
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
/**
|
|
* Attempts to probe the monitor for EDID information, if NoDDC and NoDDC2 are
|
|
* unset. EDID information blocks are interpreted and the results returned in
|
|
* an xf86MonPtr. Unlike xf86DoEDID_DDC[12](), this function will return
|
|
* the complete EDID data, including all extension blocks, if the 'complete'
|
|
* parameter is TRUE;
|
|
*
|
|
* This function does not affect the list of modes used by drivers -- it is up
|
|
* to the driver to decide policy on what to do with EDID information.
|
|
*
|
|
* @return pointer to a new xf86MonPtr containing the EDID information.
|
|
* @return NULL if no monitor attached or failure to interpret the EDID.
|
|
*/
|
|
xf86MonPtr
|
|
xf86DoEEDID(int scrnIndex, I2CBusPtr pBus, Bool complete)
|
|
{
|
|
ScrnInfoPtr pScrn = xf86Screens[scrnIndex];
|
|
unsigned char *EDID_block = NULL;
|
|
xf86MonPtr tmp = NULL;
|
|
I2CDevPtr dev = NULL;
|
|
/* Default DDC and DDC2 to enabled. */
|
|
Bool noddc = FALSE, noddc2 = FALSE;
|
|
OptionInfoPtr options;
|
|
|
|
options = xalloc(sizeof(DDCOptions));
|
|
if (!options)
|
|
return NULL;
|
|
memcpy(options, DDCOptions, sizeof(DDCOptions));
|
|
xf86ProcessOptions(pScrn->scrnIndex, pScrn->options, options);
|
|
|
|
xf86GetOptValBool(options, DDCOPT_NODDC, &noddc);
|
|
xf86GetOptValBool(options, DDCOPT_NODDC2, &noddc2);
|
|
xfree(options);
|
|
|
|
if (noddc || noddc2)
|
|
return NULL;
|
|
|
|
if (!(dev = DDC2Init(scrnIndex, pBus)))
|
|
return NULL;
|
|
|
|
EDID_block = xcalloc(1, EDID1_LEN);
|
|
if (!EDID_block)
|
|
return NULL;
|
|
|
|
if (DDC2Read(dev, 0, EDID_block)) {
|
|
int i, n = EDID_block[0x7e];
|
|
|
|
if (complete && n) {
|
|
EDID_block = xrealloc(EDID_block, EDID1_LEN * (1+n));
|
|
|
|
for (i = 0; i < n; i++)
|
|
DDC2Read(dev, i+1, EDID_block + (EDID1_LEN * (1+i)));
|
|
}
|
|
|
|
tmp = xf86InterpretEEDID(scrnIndex, EDID_block);
|
|
}
|
|
|
|
if (tmp && complete)
|
|
tmp->flags |= EDID_COMPLETE_RAWDATA;
|
|
|
|
return tmp;
|
|
}
|
|
|
|
/**
|
|
* Attempts to probe the monitor for EDID information, if NoDDC and NoDDC2 are
|
|
* unset. EDID information blocks are interpreted and the results returned in
|
|
* an xf86MonPtr.
|
|
*
|
|
* This function does not affect the list of modes used by drivers -- it is up
|
|
* to the driver to decide policy on what to do with EDID information.
|
|
*
|
|
* @return pointer to a new xf86MonPtr containing the EDID information.
|
|
* @return NULL if no monitor attached or failure to interpret the EDID.
|
|
*/
|
|
xf86MonPtr
|
|
xf86DoEDID_DDC2(int scrnIndex, I2CBusPtr pBus)
|
|
{
|
|
return xf86DoEEDID(scrnIndex, pBus, FALSE);
|
|
}
|
|
|
|
/*
|
|
* read EDID record , pass it to callback function to interpret.
|
|
* callback function will store it for further use by calling
|
|
* function; it will also decide if we need to reread it
|
|
*/
|
|
static unsigned char *
|
|
EDIDRead_DDC1(ScrnInfoPtr pScrn, DDC1SetSpeedProc DDCSpeed,
|
|
unsigned int (*read_DDC)(ScrnInfoPtr))
|
|
{
|
|
unsigned char *EDID_block = NULL;
|
|
int count = RETRIES;
|
|
|
|
if (!read_DDC) {
|
|
xf86DrvMsg(pScrn->scrnIndex, X_PROBED,
|
|
"chipset doesn't support DDC1\n");
|
|
return NULL;
|
|
};
|
|
|
|
if (TestDDC1(pScrn,read_DDC)==-1) {
|
|
xf86DrvMsg(pScrn->scrnIndex, X_PROBED, "No DDC signal\n");
|
|
return NULL;
|
|
};
|
|
|
|
if (DDCSpeed) DDCSpeed(pScrn,DDC_FAST);
|
|
do {
|
|
EDID_block = GetEDID_DDC1(FetchEDID_DDC1(pScrn,read_DDC));
|
|
count --;
|
|
} while (!EDID_block && count);
|
|
if (DDCSpeed) DDCSpeed(pScrn,DDC_SLOW);
|
|
|
|
return EDID_block;
|
|
}
|
|
|
|
/* test if DDC1 return 0 if not */
|
|
static Bool
|
|
TestDDC1(ScrnInfoPtr pScrn, unsigned int (*read_DDC)(ScrnInfoPtr))
|
|
{
|
|
int old, count;
|
|
|
|
old = read_DDC(pScrn);
|
|
count = HEADER * BITS_PER_BYTE;
|
|
do {
|
|
/* wait for next retrace */
|
|
if (old != read_DDC(pScrn)) break;
|
|
} while(count--);
|
|
return (count);
|
|
}
|
|
|
|
/* fetch entire EDID record; DDC bit needs to be masked */
|
|
static unsigned int *
|
|
FetchEDID_DDC1(register ScrnInfoPtr pScrn,
|
|
register unsigned int (*read_DDC)(ScrnInfoPtr))
|
|
{
|
|
int count = NUM;
|
|
unsigned int *ptr, *xp;
|
|
|
|
ptr=xp=xalloc(sizeof(int)*NUM);
|
|
|
|
if (!ptr) return NULL;
|
|
do {
|
|
/* wait for next retrace */
|
|
*xp = read_DDC(pScrn);
|
|
xp++;
|
|
} while(--count);
|
|
return (ptr);
|
|
}
|