[deb_xorg-server.git] / hw / xfree86 / ddc / ddc.c

/* xf86DDC.c 
 * 
 * Copyright 1998,1999 by Egbert Eich <Egbert.Eich@Physik.TU-Darmstadt.DE>
 */

/*
 * A note on terminology.  DDC1 is the original dumb serial protocol, and
 * can only do up to 128 bytes of EDID.  DDC2 is I2C-encapsulated and
 * introduces extension blocks.  EDID is the old display identification
 * block, DisplayID is the new one.
 */

#ifdef HAVE_XORG_CONFIG_H
#include <xorg-config.h>
#endif

#include "misc.h"
#include "xf86.h"
#include "xf86_OSproc.h"
#include "xf86DDC.h"
#include <string.h>

#define RETRIES 4

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},
};

/* DDC1 */

static int
find_start(unsigned int *ptr)
{
    unsigned int comp[9], test[9];
    int i, j;

    for (i = 0; i < 9; i++) {
        comp[i] = *(ptr++);
        test[i] = 1;
    }
    for (i = 0; i < 127; i++) {
        for (j = 0; j < 9; j++) {
            test[j] = test[j] & !(comp[j] ^ *(ptr++));
        }
    }
    for (i = 0; i < 9; i++)
        if (test[i])
            return i + 1;
    return -1;
}

static unsigned char *
find_header(unsigned char *block)
{
    unsigned char *ptr, *head_ptr, *end;
    unsigned char header[] = { 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00 };

    ptr = block;
    end = block + EDID1_LEN;
    while (ptr < end) {
        int i;

        head_ptr = ptr;
        for (i = 0; i < 8; i++) {
            if (header[i] != *(head_ptr++))
                break;
            if (head_ptr == end)
                head_ptr = block;
        }
        if (i == 8)
            break;
        ptr++;
    }
    if (ptr == end)
        return NULL;
    return ptr;
}

static unsigned char *
resort(unsigned char *s_block)
{
    unsigned char *d_new, *d_ptr, *d_end, *s_ptr, *s_end;
    unsigned char tmp;

    s_ptr = find_header(s_block);
    if (!s_ptr)
        return NULL;
    s_end = s_block + EDID1_LEN;

    d_new = malloc(EDID1_LEN);
    if (!d_new)
        return NULL;
    d_end = d_new + EDID1_LEN;

    for (d_ptr = d_new; d_ptr < d_end; d_ptr++) {
        tmp = *(s_ptr++);
        *d_ptr = tmp;
        if (s_ptr == s_end)
            s_ptr = s_block;
    }
    free(s_block);
    return d_new;
}

static int
DDC_checksum(const unsigned char *block, int len)
{
    int i, result = 0;
    int not_null = 0;

    for (i = 0; i < len; i++) {
        not_null |= block[i];
        result += block[i];
    }

#ifdef DEBUG
    if (result & 0xFF)
        ErrorF("DDC checksum not correct\n");
    if (!not_null)
        ErrorF("DDC read all Null\n");
#endif

    /* catch the trivial case where all bytes are 0 */
    if (!not_null)
        return 1;

    return result & 0xFF;
}

static unsigned char *
GetEDID_DDC1(unsigned int *s_ptr)
{
    unsigned char *d_block, *d_pos;
    unsigned int *s_pos, *s_end;
    int s_start;
    int i, j;

    s_start = find_start(s_ptr);
    if (s_start == -1)
        return NULL;
    s_end = s_ptr + NUM;
    s_pos = s_ptr + s_start;
    d_block = malloc(EDID1_LEN);
    if (!d_block)
        return NULL;
    d_pos = d_block;
    for (i = 0; i < EDID1_LEN; i++) {
        for (j = 0; j < 8; j++) {
            *d_pos <<= 1;
            if (*s_pos) {
                *d_pos |= 0x01;
            }
            s_pos++;
            if (s_pos == s_end)
                s_pos = s_ptr;
        };
        s_pos++;
        if (s_pos == s_end)
            s_pos = s_ptr;
        d_pos++;
    }
    free(s_ptr);
    if (d_block && DDC_checksum(d_block, EDID1_LEN)) {
        free(d_block);
        return NULL;
    }
    return (resort(d_block));
}

/* 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 = malloc(sizeof(int) * NUM);

    if (!ptr)
        return NULL;
    do {
        /* wait for next retrace */
        *xp = read_DDC(pScrn);
        xp++;
    } while (--count);
    return ptr;
}

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

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

/**
 * 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(ScrnInfoPtr pScrn, DDC1SetSpeedProc DDC1SetSpeed,
                unsigned int (*DDC1Read) (ScrnInfoPtr))
{
    unsigned char *EDID_block = NULL;
    xf86MonPtr tmp = NULL;

    /* 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);
    free(options);

    if (noddc || noddc1)
        return NULL;

    OsBlockSignals();
    EDID_block = EDIDRead_DDC1(pScrn, DDC1SetSpeed, DDC1Read);
    OsReleaseSignals();

    if (EDID_block) {
        tmp = xf86InterpretEDID(pScrn->scrnIndex, EDID_block);
    }
#ifdef DEBUG
    else
        ErrorF("No EDID block returned\n");
    if (!tmp)
        ErrorF("Cannot interpret EDID block\n");
#endif
    return tmp;
}

/* DDC2 */

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(I2CBusPtr pBus)
{
    I2CDevPtr dev = NULL;

    /*
     * Slow down the bus so that older monitors don't 
     * miss things.
     */
    pBus->RiseFallTime = 20;

    dev = DDC2MakeDevice(pBus, 0x00A0, "ddc2");
    if (xf86I2CProbeAddress(pBus, 0x0060))
        DDC2MakeDevice(pBus, 0x0060, "E-EDID segment register");

    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(ScrnInfoPtr pScrn, I2CBusPtr pBus, Bool complete)
{
    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 = malloc(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);
    free(options);

    if (noddc || noddc2)
        return NULL;

    if (!(dev = DDC2Init(pBus)))
        return NULL;

    EDID_block = calloc(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 = realloc(EDID_block, EDID1_LEN * (1 + n));

            for (i = 0; i < n; i++)
                DDC2Read(dev, i + 1, EDID_block + (EDID1_LEN * (1 + i)));
        }

        tmp = xf86InterpretEEDID(pScrn->scrnIndex, EDID_block);
    }

    if (tmp && complete)
        tmp->flags |= MONITOR_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(ScrnInfoPtr pScrn, I2CBusPtr pBus)
{
    return xf86DoEEDID(pScrn, pBus, FALSE);
}

/* XXX write me */
static void *
DDC2ReadDisplayID(void)
{
    return FALSE;
}

/**
 * Attempts to probe the monitor for DisplayID information, if NoDDC and
 * NoDDC2 are unset.  DisplayID 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 DisplayID information.
 *
 * @return pointer to a new xf86MonPtr containing the DisplayID information.
 * @return NULL if no monitor attached or failure to interpret the DisplayID.
 */
xf86MonPtr
xf86DoDisplayID(ScrnInfoPtr pScrn, I2CBusPtr pBus)
{
    unsigned char *did = NULL;
    xf86MonPtr tmp = NULL;
    I2CDevPtr dev = NULL;

    /* Default DDC and DDC2 to enabled. */
    Bool noddc = FALSE, noddc2 = FALSE;
    OptionInfoPtr options;

    options = malloc(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);
    free(options);

    if (noddc || noddc2)
        return NULL;

    if (!(dev = DDC2Init(pBus)))
        return NULL;

    if ((did = DDC2ReadDisplayID())) {
        tmp = calloc(1, sizeof(*tmp));
        if (!tmp)
            return NULL;

        tmp->scrnIndex = pScrn->scrnIndex;
        tmp->flags |= MONITOR_DISPLAYID;
        tmp->rawData = did;
    }

    return tmp;
}
Commit	Line	Data
a09e091a JB	1	/* xf86DDC.c
	2	*
	3	* Copyright 1998,1999 by Egbert Eich <Egbert.Eich@Physik.TU-Darmstadt.DE>
	4	*/
	5
	6	/*
	7	* A note on terminology. DDC1 is the original dumb serial protocol, and
	8	* can only do up to 128 bytes of EDID. DDC2 is I2C-encapsulated and
	9	* introduces extension blocks. EDID is the old display identification
	10	* block, DisplayID is the new one.
	11	*/
	12
	13	#ifdef HAVE_XORG_CONFIG_H
	14	#include <xorg-config.h>
	15	#endif
	16
	17	#include "misc.h"
	18	#include "xf86.h"
	19	#include "xf86_OSproc.h"
	20	#include "xf86DDC.h"
	21	#include <string.h>
	22
	23	#define RETRIES 4
	24
	25	typedef enum {
	26	DDCOPT_NODDC1,
	27	DDCOPT_NODDC2,
	28	DDCOPT_NODDC
	29	} DDCOpts;
	30
	31	static const OptionInfoRec DDCOptions[] = {
	32	{DDCOPT_NODDC1, "NoDDC1", OPTV_BOOLEAN, {0}, FALSE},
	33	{DDCOPT_NODDC2, "NoDDC2", OPTV_BOOLEAN, {0}, FALSE},
	34	{DDCOPT_NODDC, "NoDDC", OPTV_BOOLEAN, {0}, FALSE},
	35	{-1, NULL, OPTV_NONE, {0}, FALSE},
	36	};
	37
	38	/* DDC1 */
	39
	40	static int
	41	find_start(unsigned int *ptr)
	42	{
	43	unsigned int comp[9], test[9];
	44	int i, j;
	45
	46	for (i = 0; i < 9; i++) {
	47	comp[i] = *(ptr++);
	48	test[i] = 1;
	49	}
	50	for (i = 0; i < 127; i++) {
	51	for (j = 0; j < 9; j++) {
	52	test[j] = test[j] & !(comp[j] ^ *(ptr++));
	53	}
	54	}
	55	for (i = 0; i < 9; i++)
	56	if (test[i])
	57	return i + 1;
	58	return -1;
	59	}
	60
	61	static unsigned char *
	62	find_header(unsigned char *block)
	63	{
	64	unsigned char ptr, head_ptr, *end;
65	unsigned char header[] = { 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00 };
66
67	ptr = block;
68	end = block + EDID1_LEN;
69	while (ptr < end) {
70	int i;
71
72	head_ptr = ptr;
73	for (i = 0; i < 8; i++) {
74	if (header[i] != *(head_ptr++))
75	break;
76	if (head_ptr == end)
77	head_ptr = block;
78	}
79	if (i == 8)
80	break;
81	ptr++;
82	}
83	if (ptr == end)
84	return NULL;
85	return ptr;
86	}
87
88	static unsigned char *
89	resort(unsigned char *s_block)
90	{
91	unsigned char d_new, d_ptr, d_end, s_ptr, *s_end;
92	unsigned char tmp;
93
94	s_ptr = find_header(s_block);
95	if (!s_ptr)
96	return NULL;
97	s_end = s_block + EDID1_LEN;
98
99	d_new = malloc(EDID1_LEN);
100	if (!d_new)
101	return NULL;
102	d_end = d_new + EDID1_LEN;
103
104	for (d_ptr = d_new; d_ptr < d_end; d_ptr++) {
105	tmp = *(s_ptr++);
106	*d_ptr = tmp;
107	if (s_ptr == s_end)
108	s_ptr = s_block;
109	}
110	free(s_block);
111	return d_new;
112	}
113
114	static int
115	DDC_checksum(const unsigned char *block, int len)
116	{
117	int i, result = 0;
118	int not_null = 0;
119
120	for (i = 0; i < len; i++) {
121	not_null \|= block[i];
122	result += block[i];
123	}
124
125	#ifdef DEBUG
126	if (result & 0xFF)
127	ErrorF("DDC checksum not correct\n");
128	if (!not_null)
129	ErrorF("DDC read all Null\n");
130	#endif
131
132	/* catch the trivial case where all bytes are 0 */
133	if (!not_null)
134	return 1;
135
136	return result & 0xFF;
137	}
138
139	static unsigned char *
140	GetEDID_DDC1(unsigned int *s_ptr)
141	{
142	unsigned char d_block, d_pos;
143	unsigned int s_pos, s_end;
144	int s_start;
145	int i, j;
146
147	s_start = find_start(s_ptr);
148	if (s_start == -1)
149	return NULL;
150	s_end = s_ptr + NUM;
151	s_pos = s_ptr + s_start;
152	d_block = malloc(EDID1_LEN);
153	if (!d_block)
154	return NULL;
155	d_pos = d_block;
156	for (i = 0; i < EDID1_LEN; i++) {
157	for (j = 0; j < 8; j++) {
158	*d_pos <<= 1;
159	if (*s_pos) {
160	*d_pos \|= 0x01;
161	}
162	s_pos++;
163	if (s_pos == s_end)
164	s_pos = s_ptr;
165	};
166	s_pos++;
167	if (s_pos == s_end)
168	s_pos = s_ptr;
169	d_pos++;
170	}
171	free(s_ptr);
172	if (d_block && DDC_checksum(d_block, EDID1_LEN)) {
173	free(d_block);
174	return NULL;
175	}
176	return (resort(d_block));
177	}
178
179	/* fetch entire EDID record; DDC bit needs to be masked */
180	static unsigned int *
181	FetchEDID_DDC1(register ScrnInfoPtr pScrn,
182	register unsigned int (*read_DDC) (ScrnInfoPtr))
183	{
184	int count = NUM;
185	unsigned int ptr, xp;
186
187	ptr = xp = malloc(sizeof(int) * NUM);
188
189	if (!ptr)
190	return NULL;
191	do {
192	/* wait for next retrace */
193	*xp = read_DDC(pScrn);
194	xp++;
195	} while (--count);
196	return ptr;
197	}
198
199	/* test if DDC1 return 0 if not */
200	static Bool
201	TestDDC1(ScrnInfoPtr pScrn, unsigned int (*read_DDC) (ScrnInfoPtr))
202	{
203	int old, count;
204
205	old = read_DDC(pScrn);
206	count = HEADER * BITS_PER_BYTE;
207	do {
208	/* wait for next retrace */
209	if (old != read_DDC(pScrn))
210	break;
211	} while (count--);
212	return count;
213	}
214
215	/*
216	* read EDID record , pass it to callback function to interpret.
217	* callback function will store it for further use by calling
218	* function; it will also decide if we need to reread it
219	*/
220	static unsigned char *
221	EDIDRead_DDC1(ScrnInfoPtr pScrn, DDC1SetSpeedProc DDCSpeed,
222	unsigned int (*read_DDC) (ScrnInfoPtr))
223	{
224	unsigned char *EDID_block = NULL;
225	int count = RETRIES;
226
227	if (!read_DDC) {
228	xf86DrvMsg(pScrn->scrnIndex, X_PROBED,
229	"chipset doesn't support DDC1\n");
230	return NULL;
231	};
232
233	if (TestDDC1(pScrn, read_DDC) == -1) {
234	xf86DrvMsg(pScrn->scrnIndex, X_PROBED, "No DDC signal\n");
235	return NULL;
236	};
237
238	if (DDCSpeed)
239	DDCSpeed(pScrn, DDC_FAST);
240	do {
241	EDID_block = GetEDID_DDC1(FetchEDID_DDC1(pScrn, read_DDC));
242	count--;
243	} while (!EDID_block && count);
244	if (DDCSpeed)
245	DDCSpeed(pScrn, DDC_SLOW);
246
247	return EDID_block;
248	}
249
250	/**
251	* Attempts to probe the monitor for EDID information, if NoDDC and NoDDC1 are
252	* unset. EDID information blocks are interpreted and the results returned in
253	* an xf86MonPtr.
254	*
255	* This function does not affect the list of modes used by drivers -- it is up
256	* to the driver to decide policy on what to do with EDID information.
257	*
258	* @return pointer to a new xf86MonPtr containing the EDID information.
259	* @return NULL if no monitor attached or failure to interpret the EDID.
260	*/
261	xf86MonPtr
262	xf86DoEDID_DDC1(ScrnInfoPtr pScrn, DDC1SetSpeedProc DDC1SetSpeed,
263	unsigned int (*DDC1Read) (ScrnInfoPtr))
264	{
265	unsigned char *EDID_block = NULL;
266	xf86MonPtr tmp = NULL;
267
268	/* Default DDC and DDC1 to enabled. */
269	Bool noddc = FALSE, noddc1 = FALSE;
270	OptionInfoPtr options;
271
272	options = xnfalloc(sizeof(DDCOptions));
273	(void) memcpy(options, DDCOptions, sizeof(DDCOptions));
274	xf86ProcessOptions(pScrn->scrnIndex, pScrn->options, options);
275
276	xf86GetOptValBool(options, DDCOPT_NODDC, &noddc);
277	xf86GetOptValBool(options, DDCOPT_NODDC1, &noddc1);
278	free(options);
279
280	if (noddc \|\| noddc1)
281	return NULL;
282
283	OsBlockSignals();
284	EDID_block = EDIDRead_DDC1(pScrn, DDC1SetSpeed, DDC1Read);
285	OsReleaseSignals();
286
287	if (EDID_block) {
288	tmp = xf86InterpretEDID(pScrn->scrnIndex, EDID_block);
289	}
290	#ifdef DEBUG
291	else
292	ErrorF("No EDID block returned\n");
293	if (!tmp)
294	ErrorF("Cannot interpret EDID block\n");
295	#endif
296	return tmp;
297	}
298
299	/* DDC2 */
300
301	static I2CDevPtr
302	DDC2MakeDevice(I2CBusPtr pBus, int address, char *name)
303	{
304	I2CDevPtr dev = NULL;
305
306	if (!(dev = xf86I2CFindDev(pBus, address))) {
307	dev = xf86CreateI2CDevRec();
308	dev->DevName = name;
309	dev->SlaveAddr = address;
310	dev->ByteTimeout = 2200; /* VESA DDC spec 3 p. 43 (+10 %) */
311	dev->StartTimeout = 550;
312	dev->BitTimeout = 40;
313	dev->AcknTimeout = 40;
314
315	dev->pI2CBus = pBus;
316	if (!xf86I2CDevInit(dev)) {
317	xf86DrvMsg(pBus->scrnIndex, X_PROBED, "No DDC2 device\n");
318	return NULL;
319	}
320	}
321
322	return dev;
323	}
324
325	static I2CDevPtr
326	DDC2Init(I2CBusPtr pBus)
327	{
328	I2CDevPtr dev = NULL;
329
330	/*
331	* Slow down the bus so that older monitors don't
332	* miss things.
333	*/
334	pBus->RiseFallTime = 20;
335
336	dev = DDC2MakeDevice(pBus, 0x00A0, "ddc2");
337	if (xf86I2CProbeAddress(pBus, 0x0060))
338	DDC2MakeDevice(pBus, 0x0060, "E-EDID segment register");
339
340	return dev;
341	}
342
343	/* Mmmm, smell the hacks */
344	static void
345	EEDIDStop(I2CDevPtr d)
346	{
347	}
348
349	/* block is the EDID block number. a segment is two blocks. */
350	static Bool
351	DDC2Read(I2CDevPtr dev, int block, unsigned char *R_Buffer)
352	{
353	unsigned char W_Buffer[1];
354	int i, segment;
355	I2CDevPtr seg;
356	void (*stop) (I2CDevPtr);
357
358	for (i = 0; i < RETRIES; i++) {
359	/* Stop bits reset the segment pointer to 0, so be careful here. */
360	segment = block >> 1;
361	if (segment) {
362	Bool b;
363
364	if (!(seg = xf86I2CFindDev(dev->pI2CBus, 0x0060)))
365	return FALSE;
366
367	W_Buffer[0] = segment;
368
369	stop = dev->pI2CBus->I2CStop;
370	dev->pI2CBus->I2CStop = EEDIDStop;
371
372	b = xf86I2CWriteRead(seg, W_Buffer, 1, NULL, 0);
373
374	dev->pI2CBus->I2CStop = stop;
375	if (!b) {
376	dev->pI2CBus->I2CStop(dev);
377	continue;
378	}
379	}
380
381	W_Buffer[0] = (block & 0x01) * EDID1_LEN;
382
383	if (xf86I2CWriteRead(dev, W_Buffer, 1, R_Buffer, EDID1_LEN)) {
384	if (!DDC_checksum(R_Buffer, EDID1_LEN))
385	return TRUE;
386	}
387	}
388
389	return FALSE;
390	}
391
392	/**
393	* Attempts to probe the monitor for EDID information, if NoDDC and NoDDC2 are
394	* unset. EDID information blocks are interpreted and the results returned in
395	* an xf86MonPtr. Unlike xf86DoEDID_DDC[12](), this function will return
396	* the complete EDID data, including all extension blocks, if the 'complete'
397	* parameter is TRUE;
398	*
399	* This function does not affect the list of modes used by drivers -- it is up
400	* to the driver to decide policy on what to do with EDID information.
401	*
402	* @return pointer to a new xf86MonPtr containing the EDID information.
403	* @return NULL if no monitor attached or failure to interpret the EDID.
404	*/
405	xf86MonPtr
406	xf86DoEEDID(ScrnInfoPtr pScrn, I2CBusPtr pBus, Bool complete)
407	{
408	unsigned char *EDID_block = NULL;
409	xf86MonPtr tmp = NULL;
410	I2CDevPtr dev = NULL;
411
412	/* Default DDC and DDC2 to enabled. */
413	Bool noddc = FALSE, noddc2 = FALSE;
414	OptionInfoPtr options;
415
416	options = malloc(sizeof(DDCOptions));
417	if (!options)
418	return NULL;
419	memcpy(options, DDCOptions, sizeof(DDCOptions));
420	xf86ProcessOptions(pScrn->scrnIndex, pScrn->options, options);
421
422	xf86GetOptValBool(options, DDCOPT_NODDC, &noddc);
423	xf86GetOptValBool(options, DDCOPT_NODDC2, &noddc2);
424	free(options);
425
426	if (noddc \|\| noddc2)
427	return NULL;
428
429	if (!(dev = DDC2Init(pBus)))
430	return NULL;
431
432	EDID_block = calloc(1, EDID1_LEN);
433	if (!EDID_block)
434	return NULL;
435
436	if (DDC2Read(dev, 0, EDID_block)) {
437	int i, n = EDID_block[0x7e];
438
439	if (complete && n) {
440	EDID_block = realloc(EDID_block, EDID1_LEN * (1 + n));
441
442	for (i = 0; i < n; i++)
443	DDC2Read(dev, i + 1, EDID_block + (EDID1_LEN * (1 + i)));
444	}
445
446	tmp = xf86InterpretEEDID(pScrn->scrnIndex, EDID_block);
447	}
448
449	if (tmp && complete)
450	tmp->flags \|= MONITOR_EDID_COMPLETE_RAWDATA;
451
452	return tmp;
453	}
454
455	/**
456	* Attempts to probe the monitor for EDID information, if NoDDC and NoDDC2 are
457	* unset. EDID information blocks are interpreted and the results returned in
458	* an xf86MonPtr.
459	*
460	* This function does not affect the list of modes used by drivers -- it is up
461	* to the driver to decide policy on what to do with EDID information.
462	*
463	* @return pointer to a new xf86MonPtr containing the EDID information.
464	* @return NULL if no monitor attached or failure to interpret the EDID.
465	*/
466	xf86MonPtr
467	xf86DoEDID_DDC2(ScrnInfoPtr pScrn, I2CBusPtr pBus)
468	{
469	return xf86DoEEDID(pScrn, pBus, FALSE);
470	}
471
472	/* XXX write me */
473	static void *
474	DDC2ReadDisplayID(void)
475	{
476	return FALSE;
477	}
478
479	/**
480	* Attempts to probe the monitor for DisplayID information, if NoDDC and
481	* NoDDC2 are unset. DisplayID blocks are interpreted and the results
482	* returned in an xf86MonPtr.
483	*
484	* This function does not affect the list of modes used by drivers -- it is up
485	* to the driver to decide policy on what to do with DisplayID information.
486	*
487	* @return pointer to a new xf86MonPtr containing the DisplayID information.
488	* @return NULL if no monitor attached or failure to interpret the DisplayID.
489	*/
490	xf86MonPtr
491	xf86DoDisplayID(ScrnInfoPtr pScrn, I2CBusPtr pBus)
492	{
493	unsigned char *did = NULL;
494	xf86MonPtr tmp = NULL;
495	I2CDevPtr dev = NULL;
496
497	/* Default DDC and DDC2 to enabled. */
498	Bool noddc = FALSE, noddc2 = FALSE;
499	OptionInfoPtr options;
500
501	options = malloc(sizeof(DDCOptions));
502	if (!options)
503	return NULL;
504	memcpy(options, DDCOptions, sizeof(DDCOptions));
505	xf86ProcessOptions(pScrn->scrnIndex, pScrn->options, options);
506
507	xf86GetOptValBool(options, DDCOPT_NODDC, &noddc);
508	xf86GetOptValBool(options, DDCOPT_NODDC2, &noddc2);
509	free(options);
510
511	if (noddc \|\| noddc2)
512	return NULL;
513
514	if (!(dev = DDC2Init(pBus)))
515	return NULL;
516
517	if ((did = DDC2ReadDisplayID())) {
518	tmp = calloc(1, sizeof(*tmp));
519	if (!tmp)
520	return NULL;
521
522	tmp->scrnIndex = pScrn->scrnIndex;
523	tmp->flags \|= MONITOR_DISPLAYID;
524	tmp->rawData = did;
525	}
526
527	return tmp;
528	}