Subversion Repositories Kolibri OS

Rev

Rev 1125 | Rev 1221 | Go to most recent revision | Details | Compare with Previous | Last modification | View Log | RSS feed

Rev Author Line No. Line
1123 serge 1
/*
2
 * Copyright (c) 2006 Luc Verhaegen (quirks list)
3
 * Copyright (c) 2007-2008 Intel Corporation
4
 *   Jesse Barnes 
5
 *
6
 * DDC probing routines (drm_ddc_read & drm_do_probe_ddc_edid) originally from
7
 * FB layer.
8
 *   Copyright (C) 2006 Dennis Munsie 
9
 *
10
 * Permission is hereby granted, free of charge, to any person obtaining a
11
 * copy of this software and associated documentation files (the "Software"),
12
 * to deal in the Software without restriction, including without limitation
13
 * the rights to use, copy, modify, merge, publish, distribute, sub license,
14
 * and/or sell copies of the Software, and to permit persons to whom the
15
 * Software is furnished to do so, subject to the following conditions:
16
 *
17
 * The above copyright notice and this permission notice (including the
18
 * next paragraph) shall be included in all copies or substantial portions
19
 * of the Software.
20
 *
21
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
22
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
23
 * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL
24
 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
25
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
26
 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
27
 * DEALINGS IN THE SOFTWARE.
28
 */
29
//#include 
1125 serge 30
#include 
31
#include 
32
 
33
#include 
34
#include 
1123 serge 35
#include "drmP.h"
36
#include "drm_edid.h"
37
 
38
/*
39
 * TODO:
40
 *   - support EDID 1.4 (incl. CE blocks)
41
 */
42
 
43
/*
44
 * EDID blocks out in the wild have a variety of bugs, try to collect
45
 * them here (note that userspace may work around broken monitors first,
46
 * but fixes should make their way here so that the kernel "just works"
47
 * on as many displays as possible).
48
 */
49
 
50
/* First detailed mode wrong, use largest 60Hz mode */
51
#define EDID_QUIRK_PREFER_LARGE_60		(1 << 0)
52
/* Reported 135MHz pixel clock is too high, needs adjustment */
53
#define EDID_QUIRK_135_CLOCK_TOO_HIGH		(1 << 1)
54
/* Prefer the largest mode at 75 Hz */
55
#define EDID_QUIRK_PREFER_LARGE_75		(1 << 2)
56
/* Detail timing is in cm not mm */
57
#define EDID_QUIRK_DETAILED_IN_CM		(1 << 3)
58
/* Detailed timing descriptors have bogus size values, so just take the
59
 * maximum size and use that.
60
 */
61
#define EDID_QUIRK_DETAILED_USE_MAXIMUM_SIZE	(1 << 4)
62
/* Monitor forgot to set the first detailed is preferred bit. */
63
#define EDID_QUIRK_FIRST_DETAILED_PREFERRED	(1 << 5)
64
/* use +hsync +vsync for detailed mode */
65
#define EDID_QUIRK_DETAILED_SYNC_PP		(1 << 6)
1179 serge 66
/* define the number of Extension EDID block */
67
#define MAX_EDID_EXT_NUM 4
1123 serge 68
 
1179 serge 69
#define LEVEL_DMT	0
70
#define LEVEL_GTF	1
71
#define LEVEL_CVT	2
72
 
1123 serge 73
static struct edid_quirk {
74
	char *vendor;
75
	int product_id;
76
	u32 quirks;
77
} edid_quirk_list[] = {
78
	/* Acer AL1706 */
79
	{ "ACR", 44358, EDID_QUIRK_PREFER_LARGE_60 },
80
	/* Acer F51 */
81
	{ "API", 0x7602, EDID_QUIRK_PREFER_LARGE_60 },
82
	/* Unknown Acer */
83
	{ "ACR", 2423, EDID_QUIRK_FIRST_DETAILED_PREFERRED },
84
 
85
	/* Belinea 10 15 55 */
86
	{ "MAX", 1516, EDID_QUIRK_PREFER_LARGE_60 },
87
	{ "MAX", 0x77e, EDID_QUIRK_PREFER_LARGE_60 },
88
 
89
	/* Envision Peripherals, Inc. EN-7100e */
90
	{ "EPI", 59264, EDID_QUIRK_135_CLOCK_TOO_HIGH },
91
 
92
	/* Funai Electronics PM36B */
93
	{ "FCM", 13600, EDID_QUIRK_PREFER_LARGE_75 |
94
	  EDID_QUIRK_DETAILED_IN_CM },
95
 
96
	/* LG Philips LCD LP154W01-A5 */
97
	{ "LPL", 0, EDID_QUIRK_DETAILED_USE_MAXIMUM_SIZE },
98
	{ "LPL", 0x2a00, EDID_QUIRK_DETAILED_USE_MAXIMUM_SIZE },
99
 
100
	/* Philips 107p5 CRT */
101
	{ "PHL", 57364, EDID_QUIRK_FIRST_DETAILED_PREFERRED },
102
 
103
	/* Proview AY765C */
104
	{ "PTS", 765, EDID_QUIRK_FIRST_DETAILED_PREFERRED },
105
 
106
	/* Samsung SyncMaster 205BW.  Note: irony */
107
	{ "SAM", 541, EDID_QUIRK_DETAILED_SYNC_PP },
108
	/* Samsung SyncMaster 22[5-6]BW */
109
	{ "SAM", 596, EDID_QUIRK_PREFER_LARGE_60 },
110
	{ "SAM", 638, EDID_QUIRK_PREFER_LARGE_60 },
111
};
112
 
113
 
114
/* Valid EDID header has these bytes */
115
static u8 edid_header[] = { 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00 };
116
 
117
/**
118
 * edid_is_valid - sanity check EDID data
119
 * @edid: EDID data
120
 *
121
 * Sanity check the EDID block by looking at the header, the version number
122
 * and the checksum.  Return 0 if the EDID doesn't check out, or 1 if it's
123
 * valid.
124
 */
125
static bool edid_is_valid(struct edid *edid)
126
{
127
	int i;
128
	u8 csum = 0;
129
	u8 *raw_edid = (u8 *)edid;
130
 
131
	if (memcmp(edid->header, edid_header, sizeof(edid_header)))
132
		goto bad;
133
	if (edid->version != 1) {
134
		DRM_ERROR("EDID has major version %d, instead of 1\n", edid->version);
135
		goto bad;
136
	}
137
	if (edid->revision > 4)
138
		DRM_DEBUG("EDID minor > 4, assuming backward compatibility\n");
139
 
140
	for (i = 0; i < EDID_LENGTH; i++)
141
		csum += raw_edid[i];
142
	if (csum) {
143
		DRM_ERROR("EDID checksum is invalid, remainder is %d\n", csum);
144
		goto bad;
145
	}
146
 
147
	return 1;
148
 
149
bad:
150
	if (raw_edid) {
151
		DRM_ERROR("Raw EDID:\n");
152
//       print_hex_dump_bytes(KERN_ERR, DUMP_PREFIX_NONE, raw_edid, EDID_LENGTH);
153
//       printk("\n");
154
	}
155
	return 0;
156
}
157
 
158
/**
159
 * edid_vendor - match a string against EDID's obfuscated vendor field
160
 * @edid: EDID to match
161
 * @vendor: vendor string
162
 *
163
 * Returns true if @vendor is in @edid, false otherwise
164
 */
165
static bool edid_vendor(struct edid *edid, char *vendor)
166
{
167
	char edid_vendor[3];
168
 
169
	edid_vendor[0] = ((edid->mfg_id[0] & 0x7c) >> 2) + '@';
170
	edid_vendor[1] = (((edid->mfg_id[0] & 0x3) << 3) |
171
			  ((edid->mfg_id[1] & 0xe0) >> 5)) + '@';
172
	edid_vendor[2] = (edid->mfg_id[1] & 0x1f) + '@';
173
 
174
	return !strncmp(edid_vendor, vendor, 3);
175
}
176
 
177
/**
178
 * edid_get_quirks - return quirk flags for a given EDID
179
 * @edid: EDID to process
180
 *
181
 * This tells subsequent routines what fixes they need to apply.
182
 */
183
static u32 edid_get_quirks(struct edid *edid)
184
{
185
	struct edid_quirk *quirk;
186
	int i;
187
 
188
	for (i = 0; i < ARRAY_SIZE(edid_quirk_list); i++) {
189
		quirk = &edid_quirk_list[i];
190
 
191
		if (edid_vendor(edid, quirk->vendor) &&
192
		    (EDID_PRODUCT_ID(edid) == quirk->product_id))
193
			return quirk->quirks;
194
	}
195
 
196
	return 0;
197
}
198
 
199
#define MODE_SIZE(m) ((m)->hdisplay * (m)->vdisplay)
200
#define MODE_REFRESH_DIFF(m,r) (abs((m)->vrefresh - target_refresh))
201
 
202
 
203
/**
204
 * edid_fixup_preferred - set preferred modes based on quirk list
205
 * @connector: has mode list to fix up
206
 * @quirks: quirks list
207
 *
208
 * Walk the mode list for @connector, clearing the preferred status
209
 * on existing modes and setting it anew for the right mode ala @quirks.
210
 */
211
static void edid_fixup_preferred(struct drm_connector *connector,
212
				 u32 quirks)
213
{
214
	struct drm_display_mode *t, *cur_mode, *preferred_mode;
215
	int target_refresh = 0;
216
 
217
	if (list_empty(&connector->probed_modes))
218
		return;
219
 
220
	if (quirks & EDID_QUIRK_PREFER_LARGE_60)
221
		target_refresh = 60;
222
	if (quirks & EDID_QUIRK_PREFER_LARGE_75)
223
		target_refresh = 75;
224
 
225
	preferred_mode = list_first_entry(&connector->probed_modes,
226
					  struct drm_display_mode, head);
227
 
228
	list_for_each_entry_safe(cur_mode, t, &connector->probed_modes, head) {
229
		cur_mode->type &= ~DRM_MODE_TYPE_PREFERRED;
230
 
231
		if (cur_mode == preferred_mode)
232
			continue;
233
 
234
		/* Largest mode is preferred */
235
		if (MODE_SIZE(cur_mode) > MODE_SIZE(preferred_mode))
236
			preferred_mode = cur_mode;
237
 
238
		/* At a given size, try to get closest to target refresh */
239
		if ((MODE_SIZE(cur_mode) == MODE_SIZE(preferred_mode)) &&
240
		    MODE_REFRESH_DIFF(cur_mode, target_refresh) <
241
		    MODE_REFRESH_DIFF(preferred_mode, target_refresh)) {
242
			preferred_mode = cur_mode;
243
		}
244
	}
245
 
246
	preferred_mode->type |= DRM_MODE_TYPE_PREFERRED;
247
}
248
 
1179 serge 249
/*
250
 * Add the Autogenerated from the DMT spec.
251
 * This table is copied from xfree86/modes/xf86EdidModes.c.
252
 * But the mode with Reduced blank feature is deleted.
253
 */
254
static struct drm_display_mode drm_dmt_modes[] = {
255
	/* 640x350@85Hz */
256
	{ DRM_MODE("640x350", DRM_MODE_TYPE_DRIVER, 31500, 640, 672,
257
		   736, 832, 0, 350, 382, 385, 445, 0,
258
		   DRM_MODE_FLAG_PHSYNC | DRM_MODE_FLAG_NVSYNC) },
259
	/* 640x400@85Hz */
260
	{ DRM_MODE("640x400", DRM_MODE_TYPE_DRIVER, 31500, 640, 672,
261
		   736, 832, 0, 400, 401, 404, 445, 0,
262
		   DRM_MODE_FLAG_NHSYNC | DRM_MODE_FLAG_PVSYNC) },
263
	/* 720x400@85Hz */
264
	{ DRM_MODE("720x400", DRM_MODE_TYPE_DRIVER, 35500, 720, 756,
265
		   828, 936, 0, 400, 401, 404, 446, 0,
266
		   DRM_MODE_FLAG_NHSYNC | DRM_MODE_FLAG_PVSYNC) },
267
	/* 640x480@60Hz */
268
	{ DRM_MODE("640x480", DRM_MODE_TYPE_DRIVER, 25175, 640, 656,
269
		   752, 800, 0, 480, 489, 492, 525, 0,
270
		   DRM_MODE_FLAG_NHSYNC | DRM_MODE_FLAG_NVSYNC) },
271
	/* 640x480@72Hz */
272
	{ DRM_MODE("640x480", DRM_MODE_TYPE_DRIVER, 31500, 640, 664,
273
		   704, 832, 0, 480, 489, 492, 520, 0,
274
		   DRM_MODE_FLAG_NHSYNC | DRM_MODE_FLAG_NVSYNC) },
275
	/* 640x480@75Hz */
276
	{ DRM_MODE("640x480", DRM_MODE_TYPE_DRIVER, 31500, 640, 656,
277
		   720, 840, 0, 480, 481, 484, 500, 0,
278
		   DRM_MODE_FLAG_NHSYNC | DRM_MODE_FLAG_NVSYNC) },
279
	/* 640x480@85Hz */
280
	{ DRM_MODE("640x480", DRM_MODE_TYPE_DRIVER, 36000, 640, 696,
281
		   752, 832, 0, 480, 481, 484, 509, 0,
282
		   DRM_MODE_FLAG_NHSYNC | DRM_MODE_FLAG_NVSYNC) },
283
	/* 800x600@56Hz */
284
	{ DRM_MODE("800x600", DRM_MODE_TYPE_DRIVER, 36000, 800, 824,
285
		   896, 1024, 0, 600, 601, 603, 625, 0,
286
		   DRM_MODE_FLAG_PHSYNC | DRM_MODE_FLAG_PVSYNC) },
287
	/* 800x600@60Hz */
288
	{ DRM_MODE("800x600", DRM_MODE_TYPE_DRIVER, 40000, 800, 840,
289
		   968, 1056, 0, 600, 601, 605, 628, 0,
290
		   DRM_MODE_FLAG_PHSYNC | DRM_MODE_FLAG_PVSYNC) },
291
	/* 800x600@72Hz */
292
	{ DRM_MODE("800x600", DRM_MODE_TYPE_DRIVER, 50000, 800, 856,
293
		   976, 1040, 0, 600, 637, 643, 666, 0,
294
		   DRM_MODE_FLAG_PHSYNC | DRM_MODE_FLAG_PVSYNC) },
295
	/* 800x600@75Hz */
296
	{ DRM_MODE("800x600", DRM_MODE_TYPE_DRIVER, 49500, 800, 816,
297
		   896, 1056, 0, 600, 601, 604, 625, 0,
298
		   DRM_MODE_FLAG_PHSYNC | DRM_MODE_FLAG_PVSYNC) },
299
	/* 800x600@85Hz */
300
	{ DRM_MODE("800x600", DRM_MODE_TYPE_DRIVER, 56250, 800, 832,
301
		   896, 1048, 0, 600, 601, 604, 631, 0,
302
		   DRM_MODE_FLAG_PHSYNC | DRM_MODE_FLAG_PVSYNC) },
303
	/* 848x480@60Hz */
304
	{ DRM_MODE("848x480", DRM_MODE_TYPE_DRIVER, 33750, 848, 864,
305
		   976, 1088, 0, 480, 486, 494, 517, 0,
306
		   DRM_MODE_FLAG_PHSYNC | DRM_MODE_FLAG_PVSYNC) },
307
	/* 1024x768@43Hz, interlace */
308
	{ DRM_MODE("1024x768", DRM_MODE_TYPE_DRIVER, 44900, 1024, 1032,
309
		   1208, 1264, 0, 768, 768, 772, 817, 0,
310
		   DRM_MODE_FLAG_PHSYNC | DRM_MODE_FLAG_PVSYNC |
311
			DRM_MODE_FLAG_INTERLACE) },
312
	/* 1024x768@60Hz */
313
	{ DRM_MODE("1024x768", DRM_MODE_TYPE_DRIVER, 65000, 1024, 1048,
314
		   1184, 1344, 0, 768, 771, 777, 806, 0,
315
		   DRM_MODE_FLAG_NHSYNC | DRM_MODE_FLAG_NVSYNC) },
316
	/* 1024x768@70Hz */
317
	{ DRM_MODE("1024x768", DRM_MODE_TYPE_DRIVER, 75000, 1024, 1048,
318
		   1184, 1328, 0, 768, 771, 777, 806, 0,
319
		   DRM_MODE_FLAG_NHSYNC | DRM_MODE_FLAG_NVSYNC) },
320
	/* 1024x768@75Hz */
321
	{ DRM_MODE("1024x768", DRM_MODE_TYPE_DRIVER, 78750, 1024, 1040,
322
		   1136, 1312, 0, 768, 769, 772, 800, 0,
323
		   DRM_MODE_FLAG_PHSYNC | DRM_MODE_FLAG_PVSYNC) },
324
	/* 1024x768@85Hz */
325
	{ DRM_MODE("1024x768", DRM_MODE_TYPE_DRIVER, 94500, 1024, 1072,
326
		   1072, 1376, 0, 768, 769, 772, 808, 0,
327
		   DRM_MODE_FLAG_PHSYNC | DRM_MODE_FLAG_PVSYNC) },
328
	/* 1152x864@75Hz */
329
	{ DRM_MODE("1152x864", DRM_MODE_TYPE_DRIVER, 108000, 1152, 1216,
330
		   1344, 1600, 0, 864, 865, 868, 900, 0,
331
		   DRM_MODE_FLAG_PHSYNC | DRM_MODE_FLAG_PVSYNC) },
332
	/* 1280x768@60Hz */
333
	{ DRM_MODE("1280x768", DRM_MODE_TYPE_DRIVER, 79500, 1280, 1344,
334
		   1472, 1664, 0, 768, 771, 778, 798, 0,
335
		   DRM_MODE_FLAG_NHSYNC | DRM_MODE_FLAG_PVSYNC) },
336
	/* 1280x768@75Hz */
337
	{ DRM_MODE("1280x768", DRM_MODE_TYPE_DRIVER, 102250, 1280, 1360,
338
		   1488, 1696, 0, 768, 771, 778, 805, 0,
339
		   DRM_MODE_FLAG_PHSYNC | DRM_MODE_FLAG_NVSYNC) },
340
	/* 1280x768@85Hz */
341
	{ DRM_MODE("1280x768", DRM_MODE_TYPE_DRIVER, 117500, 1280, 1360,
342
		   1496, 1712, 0, 768, 771, 778, 809, 0,
343
		   DRM_MODE_FLAG_NHSYNC | DRM_MODE_FLAG_PVSYNC) },
344
	/* 1280x800@60Hz */
345
	{ DRM_MODE("1280x800", DRM_MODE_TYPE_DRIVER, 83500, 1280, 1352,
346
		   1480, 1680, 0, 800, 803, 809, 831, 0,
347
		   DRM_MODE_FLAG_PHSYNC | DRM_MODE_FLAG_NVSYNC) },
348
	/* 1280x800@75Hz */
349
	{ DRM_MODE("1280x800", DRM_MODE_TYPE_DRIVER, 106500, 1280, 1360,
350
		   1488, 1696, 0, 800, 803, 809, 838, 0,
351
		   DRM_MODE_FLAG_NHSYNC | DRM_MODE_FLAG_PVSYNC) },
352
	/* 1280x800@85Hz */
353
	{ DRM_MODE("1280x800", DRM_MODE_TYPE_DRIVER, 122500, 1280, 1360,
354
		   1496, 1712, 0, 800, 803, 809, 843, 0,
355
		   DRM_MODE_FLAG_NHSYNC | DRM_MODE_FLAG_PVSYNC) },
356
	/* 1280x960@60Hz */
357
	{ DRM_MODE("1280x960", DRM_MODE_TYPE_DRIVER, 108000, 1280, 1376,
358
		   1488, 1800, 0, 960, 961, 964, 1000, 0,
359
		   DRM_MODE_FLAG_PHSYNC | DRM_MODE_FLAG_PVSYNC) },
360
	/* 1280x960@85Hz */
361
	{ DRM_MODE("1280x960", DRM_MODE_TYPE_DRIVER, 148500, 1280, 1344,
362
		   1504, 1728, 0, 960, 961, 964, 1011, 0,
363
		   DRM_MODE_FLAG_PHSYNC | DRM_MODE_FLAG_PVSYNC) },
364
	/* 1280x1024@60Hz */
365
	{ DRM_MODE("1280x1024", DRM_MODE_TYPE_DRIVER, 108000, 1280, 1328,
366
		   1440, 1688, 0, 1024, 1025, 1028, 1066, 0,
367
		   DRM_MODE_FLAG_PHSYNC | DRM_MODE_FLAG_PVSYNC) },
368
	/* 1280x1024@75Hz */
369
	{ DRM_MODE("1280x1024", DRM_MODE_TYPE_DRIVER, 135000, 1280, 1296,
370
		   1440, 1688, 0, 1024, 1025, 1028, 1066, 0,
371
		   DRM_MODE_FLAG_PHSYNC | DRM_MODE_FLAG_PVSYNC) },
372
	/* 1280x1024@85Hz */
373
	{ DRM_MODE("1280x1024", DRM_MODE_TYPE_DRIVER, 157500, 1280, 1344,
374
		   1504, 1728, 0, 1024, 1025, 1028, 1072, 0,
375
		   DRM_MODE_FLAG_PHSYNC | DRM_MODE_FLAG_PVSYNC) },
376
	/* 1360x768@60Hz */
377
	{ DRM_MODE("1360x768", DRM_MODE_TYPE_DRIVER, 85500, 1360, 1424,
378
		   1536, 1792, 0, 768, 771, 777, 795, 0,
379
		   DRM_MODE_FLAG_PHSYNC | DRM_MODE_FLAG_PVSYNC) },
380
	/* 1440x1050@60Hz */
381
	{ DRM_MODE("1400x1050", DRM_MODE_TYPE_DRIVER, 121750, 1400, 1488,
382
		   1632, 1864, 0, 1050, 1053, 1057, 1089, 0,
383
		   DRM_MODE_FLAG_NHSYNC | DRM_MODE_FLAG_PVSYNC) },
384
	/* 1440x1050@75Hz */
385
	{ DRM_MODE("1400x1050", DRM_MODE_TYPE_DRIVER, 156000, 1400, 1504,
386
		   1648, 1896, 0, 1050, 1053, 1057, 1099, 0,
387
		   DRM_MODE_FLAG_NHSYNC | DRM_MODE_FLAG_PVSYNC) },
388
	/* 1440x1050@85Hz */
389
	{ DRM_MODE("1400x1050", DRM_MODE_TYPE_DRIVER, 179500, 1400, 1504,
390
		   1656, 1912, 0, 1050, 1053, 1057, 1105, 0,
391
		   DRM_MODE_FLAG_NHSYNC | DRM_MODE_FLAG_PVSYNC) },
392
	/* 1440x900@60Hz */
393
	{ DRM_MODE("1440x900", DRM_MODE_TYPE_DRIVER, 106500, 1440, 1520,
394
		   1672, 1904, 0, 900, 903, 909, 934, 0,
395
		   DRM_MODE_FLAG_NHSYNC | DRM_MODE_FLAG_PVSYNC) },
396
	/* 1440x900@75Hz */
397
	{ DRM_MODE("1440x900", DRM_MODE_TYPE_DRIVER, 136750, 1440, 1536,
398
		   1688, 1936, 0, 900, 903, 909, 942, 0,
399
		   DRM_MODE_FLAG_NHSYNC | DRM_MODE_FLAG_PVSYNC) },
400
	/* 1440x900@85Hz */
401
	{ DRM_MODE("1440x900", DRM_MODE_TYPE_DRIVER, 157000, 1440, 1544,
402
		   1696, 1952, 0, 900, 903, 909, 948, 0,
403
		   DRM_MODE_FLAG_NHSYNC | DRM_MODE_FLAG_PVSYNC) },
404
	/* 1600x1200@60Hz */
405
	{ DRM_MODE("1600x1200", DRM_MODE_TYPE_DRIVER, 162000, 1600, 1664,
406
		   1856, 2160, 0, 1200, 1201, 1204, 1250, 0,
407
		   DRM_MODE_FLAG_PHSYNC | DRM_MODE_FLAG_PVSYNC) },
408
	/* 1600x1200@65Hz */
409
	{ DRM_MODE("1600x1200", DRM_MODE_TYPE_DRIVER, 175500, 1600, 1664,
410
		   1856, 2160, 0, 1200, 1201, 1204, 1250, 0,
411
		   DRM_MODE_FLAG_PHSYNC | DRM_MODE_FLAG_PVSYNC) },
412
	/* 1600x1200@70Hz */
413
	{ DRM_MODE("1600x1200", DRM_MODE_TYPE_DRIVER, 189000, 1600, 1664,
414
		   1856, 2160, 0, 1200, 1201, 1204, 1250, 0,
415
		   DRM_MODE_FLAG_PHSYNC | DRM_MODE_FLAG_PVSYNC) },
416
	/* 1600x1200@75Hz */
417
	{ DRM_MODE("1600x1200", DRM_MODE_TYPE_DRIVER, 2025000, 1600, 1664,
418
		   1856, 2160, 0, 1200, 1201, 1204, 1250, 0,
419
		   DRM_MODE_FLAG_PHSYNC | DRM_MODE_FLAG_PVSYNC) },
420
	/* 1600x1200@85Hz */
421
	{ DRM_MODE("1600x1200", DRM_MODE_TYPE_DRIVER, 229500, 1600, 1664,
422
		   1856, 2160, 0, 1200, 1201, 1204, 1250, 0,
423
		   DRM_MODE_FLAG_PHSYNC | DRM_MODE_FLAG_PVSYNC) },
424
	/* 1680x1050@60Hz */
425
	{ DRM_MODE("1680x1050", DRM_MODE_TYPE_DRIVER, 146250, 1680, 1784,
426
		   1960, 2240, 0, 1050, 1053, 1059, 1089, 0,
427
		   DRM_MODE_FLAG_NHSYNC | DRM_MODE_FLAG_PVSYNC) },
428
	/* 1680x1050@75Hz */
429
	{ DRM_MODE("1680x1050", DRM_MODE_TYPE_DRIVER, 187000, 1680, 1800,
430
		   1976, 2272, 0, 1050, 1053, 1059, 1099, 0,
431
		   DRM_MODE_FLAG_NHSYNC | DRM_MODE_FLAG_PVSYNC) },
432
	/* 1680x1050@85Hz */
433
	{ DRM_MODE("1680x1050", DRM_MODE_TYPE_DRIVER, 214750, 1680, 1808,
434
		   1984, 2288, 0, 1050, 1053, 1059, 1105, 0,
435
		   DRM_MODE_FLAG_NHSYNC | DRM_MODE_FLAG_PVSYNC) },
436
	/* 1792x1344@60Hz */
437
	{ DRM_MODE("1792x1344", DRM_MODE_TYPE_DRIVER, 204750, 1792, 1920,
438
		   2120, 2448, 0, 1344, 1345, 1348, 1394, 0,
439
		   DRM_MODE_FLAG_NHSYNC | DRM_MODE_FLAG_PVSYNC) },
440
	/* 1729x1344@75Hz */
441
	{ DRM_MODE("1792x1344", DRM_MODE_TYPE_DRIVER, 261000, 1792, 1888,
442
		   2104, 2456, 0, 1344, 1345, 1348, 1417, 0,
443
		   DRM_MODE_FLAG_NHSYNC | DRM_MODE_FLAG_PVSYNC) },
444
	/* 1853x1392@60Hz */
445
	{ DRM_MODE("1856x1392", DRM_MODE_TYPE_DRIVER, 218250, 1856, 1952,
446
		   2176, 2528, 0, 1392, 1393, 1396, 1439, 0,
447
		   DRM_MODE_FLAG_NHSYNC | DRM_MODE_FLAG_PVSYNC) },
448
	/* 1856x1392@75Hz */
449
	{ DRM_MODE("1856x1392", DRM_MODE_TYPE_DRIVER, 288000, 1856, 1984,
450
		   2208, 2560, 0, 1392, 1395, 1399, 1500, 0,
451
		   DRM_MODE_FLAG_NHSYNC | DRM_MODE_FLAG_PVSYNC) },
452
	/* 1920x1200@60Hz */
453
	{ DRM_MODE("1920x1200", DRM_MODE_TYPE_DRIVER, 193250, 1920, 2056,
454
		   2256, 2592, 0, 1200, 1203, 1209, 1245, 0,
455
		   DRM_MODE_FLAG_NHSYNC | DRM_MODE_FLAG_PVSYNC) },
456
	/* 1920x1200@75Hz */
457
	{ DRM_MODE("1920x1200", DRM_MODE_TYPE_DRIVER, 245250, 1920, 2056,
458
		   2264, 2608, 0, 1200, 1203, 1209, 1255, 0,
459
		   DRM_MODE_FLAG_NHSYNC | DRM_MODE_FLAG_PVSYNC) },
460
	/* 1920x1200@85Hz */
461
	{ DRM_MODE("1920x1200", DRM_MODE_TYPE_DRIVER, 281250, 1920, 2064,
462
		   2272, 2624, 0, 1200, 1203, 1209, 1262, 0,
463
		   DRM_MODE_FLAG_NHSYNC | DRM_MODE_FLAG_PVSYNC) },
464
	/* 1920x1440@60Hz */
465
	{ DRM_MODE("1920x1440", DRM_MODE_TYPE_DRIVER, 234000, 1920, 2048,
466
		   2256, 2600, 0, 1440, 1441, 1444, 1500, 0,
467
		   DRM_MODE_FLAG_NHSYNC | DRM_MODE_FLAG_PVSYNC) },
468
	/* 1920x1440@75Hz */
469
	{ DRM_MODE("1920x1440", DRM_MODE_TYPE_DRIVER, 297000, 1920, 2064,
470
		   2288, 2640, 0, 1440, 1441, 1444, 1500, 0,
471
		   DRM_MODE_FLAG_NHSYNC | DRM_MODE_FLAG_PVSYNC) },
472
	/* 2560x1600@60Hz */
473
	{ DRM_MODE("2560x1600", DRM_MODE_TYPE_DRIVER, 348500, 2560, 2752,
474
		   3032, 3504, 0, 1600, 1603, 1609, 1658, 0,
475
		   DRM_MODE_FLAG_NHSYNC | DRM_MODE_FLAG_PVSYNC) },
476
	/* 2560x1600@75HZ */
477
	{ DRM_MODE("2560x1600", DRM_MODE_TYPE_DRIVER, 443250, 2560, 2768,
478
		   3048, 3536, 0, 1600, 1603, 1609, 1672, 0,
479
		   DRM_MODE_FLAG_NHSYNC | DRM_MODE_FLAG_PVSYNC) },
480
	/* 2560x1600@85HZ */
481
	{ DRM_MODE("2560x1600", DRM_MODE_TYPE_DRIVER, 505250, 2560, 2768,
482
		   3048, 3536, 0, 1600, 1603, 1609, 1682, 0,
483
		   DRM_MODE_FLAG_NHSYNC | DRM_MODE_FLAG_PVSYNC) },
484
};
485
 
486
static struct drm_display_mode *drm_find_dmt(struct drm_device *dev,
487
			int hsize, int vsize, int fresh)
488
{
489
	int i, count;
490
	struct drm_display_mode *ptr, *mode;
491
 
492
	count = sizeof(drm_dmt_modes) / sizeof(struct drm_display_mode);
493
	mode = NULL;
494
	for (i = 0; i < count; i++) {
495
		ptr = &drm_dmt_modes[i];
496
		if (hsize == ptr->hdisplay &&
497
			vsize == ptr->vdisplay &&
498
			fresh == drm_mode_vrefresh(ptr)) {
499
			/* get the expected default mode */
500
			mode = drm_mode_duplicate(dev, ptr);
501
			break;
502
		}
503
	}
504
	return mode;
505
}
1123 serge 506
/**
507
 * drm_mode_std - convert standard mode info (width, height, refresh) into mode
508
 * @t: standard timing params
509
 *
510
 * Take the standard timing params (in this case width, aspect, and refresh)
511
 * and convert them into a real mode using CVT.
512
 *
513
 * Punts for now, but should eventually use the FB layer's CVT based mode
514
 * generation code.
515
 */
516
struct drm_display_mode *drm_mode_std(struct drm_device *dev,
1179 serge 517
				      struct std_timing *t,
518
				      int timing_level)
1123 serge 519
{
520
	struct drm_display_mode *mode;
1179 serge 521
	int hsize, vsize;
522
	int vrefresh_rate;
1123 serge 523
	unsigned aspect_ratio = (t->vfreq_aspect & EDID_TIMING_ASPECT_MASK)
524
		>> EDID_TIMING_ASPECT_SHIFT;
1179 serge 525
	unsigned vfreq = (t->vfreq_aspect & EDID_TIMING_VFREQ_MASK)
526
		>> EDID_TIMING_VFREQ_SHIFT;
1123 serge 527
 
1179 serge 528
	/* According to the EDID spec, the hdisplay = hsize * 8 + 248 */
529
	hsize = t->hsize * 8 + 248;
530
	/* vrefresh_rate = vfreq + 60 */
531
	vrefresh_rate = vfreq + 60;
532
	/* the vdisplay is calculated based on the aspect ratio */
1123 serge 533
 
534
	if (aspect_ratio == 0)
535
		vsize = (hsize * 10) / 16;
536
	else if (aspect_ratio == 1)
537
		vsize = (hsize * 3) / 4;
538
	else if (aspect_ratio == 2)
539
		vsize = (hsize * 4) / 5;
540
	else
541
		vsize = (hsize * 9) / 16;
1179 serge 542
	/* HDTV hack */
543
	if (hsize == 1360 && vsize == 765 && vrefresh_rate == 60) {
544
		mode = drm_cvt_mode(dev, hsize, vsize, vrefresh_rate, 0, 0);
545
		mode->hdisplay = 1366;
546
		mode->vsync_start = mode->vsync_start - 1;
547
		mode->vsync_end = mode->vsync_end - 1;
548
		return mode;
549
	}
550
	mode = NULL;
551
	/* check whether it can be found in default mode table */
552
	mode = drm_find_dmt(dev, hsize, vsize, vrefresh_rate);
553
	if (mode)
554
		return mode;
1123 serge 555
 
1179 serge 556
	switch (timing_level) {
557
	case LEVEL_DMT:
558
		break;
559
	case LEVEL_GTF:
560
		mode = drm_gtf_mode(dev, hsize, vsize, vrefresh_rate, 0, 0);
561
		break;
562
	case LEVEL_CVT:
563
		mode = drm_cvt_mode(dev, hsize, vsize, vrefresh_rate, 0, 0);
564
		break;
565
	}
1123 serge 566
	return mode;
567
}
568
 
569
/**
570
 * drm_mode_detailed - create a new mode from an EDID detailed timing section
571
 * @dev: DRM device (needed to create new mode)
572
 * @edid: EDID block
573
 * @timing: EDID detailed timing info
574
 * @quirks: quirks to apply
575
 *
576
 * An EDID detailed timing block contains enough info for us to create and
577
 * return a new struct drm_display_mode.
578
 */
579
static struct drm_display_mode *drm_mode_detailed(struct drm_device *dev,
580
						  struct edid *edid,
581
						  struct detailed_timing *timing,
582
						  u32 quirks)
583
{
584
	struct drm_display_mode *mode;
585
	struct detailed_pixel_timing *pt = &timing->data.pixel_data;
586
	unsigned hactive = (pt->hactive_hblank_hi & 0xf0) << 4 | pt->hactive_lo;
587
	unsigned vactive = (pt->vactive_vblank_hi & 0xf0) << 4 | pt->vactive_lo;
588
	unsigned hblank = (pt->hactive_hblank_hi & 0xf) << 8 | pt->hblank_lo;
589
	unsigned vblank = (pt->vactive_vblank_hi & 0xf) << 8 | pt->vblank_lo;
590
	unsigned hsync_offset = (pt->hsync_vsync_offset_pulse_width_hi & 0xc0) << 2 | pt->hsync_offset_lo;
591
	unsigned hsync_pulse_width = (pt->hsync_vsync_offset_pulse_width_hi & 0x30) << 4 | pt->hsync_pulse_width_lo;
592
	unsigned vsync_offset = (pt->hsync_vsync_offset_pulse_width_hi & 0xc) >> 2 | pt->vsync_offset_pulse_width_lo >> 4;
593
	unsigned vsync_pulse_width = (pt->hsync_vsync_offset_pulse_width_hi & 0x3) << 4 | (pt->vsync_offset_pulse_width_lo & 0xf);
594
 
595
	/* ignore tiny modes */
596
	if (hactive < 64 || vactive < 64)
597
		return NULL;
598
 
599
	if (pt->misc & DRM_EDID_PT_STEREO) {
600
		printk(KERN_WARNING "stereo mode not supported\n");
601
		return NULL;
602
	}
603
	if (!(pt->misc & DRM_EDID_PT_SEPARATE_SYNC)) {
604
		printk(KERN_WARNING "integrated sync not supported\n");
605
		return NULL;
606
	}
607
 
608
	mode = drm_mode_create(dev);
609
	if (!mode)
610
		return NULL;
611
 
612
	mode->type = DRM_MODE_TYPE_DRIVER;
613
 
614
	if (quirks & EDID_QUIRK_135_CLOCK_TOO_HIGH)
615
		timing->pixel_clock = cpu_to_le16(1088);
616
 
617
	mode->clock = le16_to_cpu(timing->pixel_clock) * 10;
618
 
619
	mode->hdisplay = hactive;
620
	mode->hsync_start = mode->hdisplay + hsync_offset;
621
	mode->hsync_end = mode->hsync_start + hsync_pulse_width;
622
	mode->htotal = mode->hdisplay + hblank;
623
 
624
	mode->vdisplay = vactive;
625
	mode->vsync_start = mode->vdisplay + vsync_offset;
626
	mode->vsync_end = mode->vsync_start + vsync_pulse_width;
627
	mode->vtotal = mode->vdisplay + vblank;
628
 
629
	drm_mode_set_name(mode);
630
 
631
	if (pt->misc & DRM_EDID_PT_INTERLACED)
632
		mode->flags |= DRM_MODE_FLAG_INTERLACE;
633
 
634
	if (quirks & EDID_QUIRK_DETAILED_SYNC_PP) {
635
		pt->misc |= DRM_EDID_PT_HSYNC_POSITIVE | DRM_EDID_PT_VSYNC_POSITIVE;
636
	}
637
 
638
	mode->flags |= (pt->misc & DRM_EDID_PT_HSYNC_POSITIVE) ?
639
		DRM_MODE_FLAG_PHSYNC : DRM_MODE_FLAG_NHSYNC;
640
	mode->flags |= (pt->misc & DRM_EDID_PT_VSYNC_POSITIVE) ?
641
		DRM_MODE_FLAG_PVSYNC : DRM_MODE_FLAG_NVSYNC;
642
 
643
	mode->width_mm = pt->width_mm_lo | (pt->width_height_mm_hi & 0xf0) << 4;
644
	mode->height_mm = pt->height_mm_lo | (pt->width_height_mm_hi & 0xf) << 8;
645
 
646
	if (quirks & EDID_QUIRK_DETAILED_IN_CM) {
647
		mode->width_mm *= 10;
648
		mode->height_mm *= 10;
649
	}
650
 
651
	if (quirks & EDID_QUIRK_DETAILED_USE_MAXIMUM_SIZE) {
652
		mode->width_mm = edid->width_cm * 10;
653
		mode->height_mm = edid->height_cm * 10;
654
	}
655
 
656
	return mode;
657
}
658
 
659
/*
660
 * Detailed mode info for the EDID "established modes" data to use.
661
 */
662
static struct drm_display_mode edid_est_modes[] = {
663
	{ DRM_MODE("800x600", DRM_MODE_TYPE_DRIVER, 40000, 800, 840,
664
		   968, 1056, 0, 600, 601, 605, 628, 0,
665
		   DRM_MODE_FLAG_PHSYNC | DRM_MODE_FLAG_PVSYNC) }, /* 800x600@60Hz */
666
	{ DRM_MODE("800x600", DRM_MODE_TYPE_DRIVER, 36000, 800, 824,
667
		   896, 1024, 0, 600, 601, 603,  625, 0,
668
		   DRM_MODE_FLAG_PHSYNC | DRM_MODE_FLAG_PVSYNC) }, /* 800x600@56Hz */
669
	{ DRM_MODE("640x480", DRM_MODE_TYPE_DRIVER, 31500, 640, 656,
670
		   720, 840, 0, 480, 481, 484, 500, 0,
671
		   DRM_MODE_FLAG_NHSYNC | DRM_MODE_FLAG_NVSYNC) }, /* 640x480@75Hz */
672
	{ DRM_MODE("640x480", DRM_MODE_TYPE_DRIVER, 31500, 640, 664,
673
		   704,  832, 0, 480, 489, 491, 520, 0,
674
		   DRM_MODE_FLAG_NHSYNC | DRM_MODE_FLAG_NVSYNC) }, /* 640x480@72Hz */
675
	{ DRM_MODE("640x480", DRM_MODE_TYPE_DRIVER, 30240, 640, 704,
676
		   768,  864, 0, 480, 483, 486, 525, 0,
677
		   DRM_MODE_FLAG_NHSYNC | DRM_MODE_FLAG_NVSYNC) }, /* 640x480@67Hz */
678
	{ DRM_MODE("640x480", DRM_MODE_TYPE_DRIVER, 25200, 640, 656,
679
		   752, 800, 0, 480, 490, 492, 525, 0,
680
		   DRM_MODE_FLAG_NHSYNC | DRM_MODE_FLAG_NVSYNC) }, /* 640x480@60Hz */
681
	{ DRM_MODE("720x400", DRM_MODE_TYPE_DRIVER, 35500, 720, 738,
682
		   846, 900, 0, 400, 421, 423,  449, 0,
683
		   DRM_MODE_FLAG_NHSYNC | DRM_MODE_FLAG_NVSYNC) }, /* 720x400@88Hz */
684
	{ DRM_MODE("720x400", DRM_MODE_TYPE_DRIVER, 28320, 720, 738,
685
		   846,  900, 0, 400, 412, 414, 449, 0,
686
		   DRM_MODE_FLAG_NHSYNC | DRM_MODE_FLAG_PVSYNC) }, /* 720x400@70Hz */
687
	{ DRM_MODE("1280x1024", DRM_MODE_TYPE_DRIVER, 135000, 1280, 1296,
688
		   1440, 1688, 0, 1024, 1025, 1028, 1066, 0,
689
		   DRM_MODE_FLAG_PHSYNC | DRM_MODE_FLAG_PVSYNC) }, /* 1280x1024@75Hz */
690
	{ DRM_MODE("1024x768", DRM_MODE_TYPE_DRIVER, 78800, 1024, 1040,
691
		   1136, 1312, 0,  768, 769, 772, 800, 0,
692
		   DRM_MODE_FLAG_PHSYNC | DRM_MODE_FLAG_PVSYNC) }, /* 1024x768@75Hz */
693
	{ DRM_MODE("1024x768", DRM_MODE_TYPE_DRIVER, 75000, 1024, 1048,
694
		   1184, 1328, 0,  768, 771, 777, 806, 0,
695
		   DRM_MODE_FLAG_NHSYNC | DRM_MODE_FLAG_NVSYNC) }, /* 1024x768@70Hz */
696
	{ DRM_MODE("1024x768", DRM_MODE_TYPE_DRIVER, 65000, 1024, 1048,
697
		   1184, 1344, 0,  768, 771, 777, 806, 0,
698
		   DRM_MODE_FLAG_NHSYNC | DRM_MODE_FLAG_NVSYNC) }, /* 1024x768@60Hz */
699
	{ DRM_MODE("1024x768", DRM_MODE_TYPE_DRIVER,44900, 1024, 1032,
700
		   1208, 1264, 0, 768, 768, 776, 817, 0,
701
		   DRM_MODE_FLAG_PHSYNC | DRM_MODE_FLAG_PVSYNC | DRM_MODE_FLAG_INTERLACE) }, /* 1024x768@43Hz */
702
	{ DRM_MODE("832x624", DRM_MODE_TYPE_DRIVER, 57284, 832, 864,
703
		   928, 1152, 0, 624, 625, 628, 667, 0,
704
		   DRM_MODE_FLAG_NHSYNC | DRM_MODE_FLAG_NVSYNC) }, /* 832x624@75Hz */
705
	{ DRM_MODE("800x600", DRM_MODE_TYPE_DRIVER, 49500, 800, 816,
706
		   896, 1056, 0, 600, 601, 604,  625, 0,
707
		   DRM_MODE_FLAG_PHSYNC | DRM_MODE_FLAG_PVSYNC) }, /* 800x600@75Hz */
708
	{ DRM_MODE("800x600", DRM_MODE_TYPE_DRIVER, 50000, 800, 856,
709
		   976, 1040, 0, 600, 637, 643, 666, 0,
710
		   DRM_MODE_FLAG_PHSYNC | DRM_MODE_FLAG_PVSYNC) }, /* 800x600@72Hz */
711
	{ DRM_MODE("1152x864", DRM_MODE_TYPE_DRIVER, 108000, 1152, 1216,
712
		   1344, 1600, 0,  864, 865, 868, 900, 0,
713
		   DRM_MODE_FLAG_PHSYNC | DRM_MODE_FLAG_PVSYNC) }, /* 1152x864@75Hz */
714
};
715
 
716
#define EDID_EST_TIMINGS 16
717
#define EDID_STD_TIMINGS 8
718
#define EDID_DETAILED_TIMINGS 4
719
 
720
/**
721
 * add_established_modes - get est. modes from EDID and add them
722
 * @edid: EDID block to scan
723
 *
724
 * Each EDID block contains a bitmap of the supported "established modes" list
725
 * (defined above).  Tease them out and add them to the global modes list.
726
 */
727
static int add_established_modes(struct drm_connector *connector, struct edid *edid)
728
{
729
	struct drm_device *dev = connector->dev;
730
	unsigned long est_bits = edid->established_timings.t1 |
731
		(edid->established_timings.t2 << 8) |
732
		((edid->established_timings.mfg_rsvd & 0x80) << 9);
733
	int i, modes = 0;
734
 
735
	for (i = 0; i <= EDID_EST_TIMINGS; i++)
736
		if (est_bits & (1<
737
			struct drm_display_mode *newmode;
738
			newmode = drm_mode_duplicate(dev, &edid_est_modes[i]);
739
			if (newmode) {
740
				drm_mode_probed_add(connector, newmode);
741
				modes++;
742
			}
743
		}
744
 
745
	return modes;
746
}
1179 serge 747
/**
748
 * stanard_timing_level - get std. timing level(CVT/GTF/DMT)
749
 * @edid: EDID block to scan
750
 */
751
static int standard_timing_level(struct edid *edid)
752
{
753
	if (edid->revision >= 2) {
754
		if (edid->revision >= 4 && (edid->features & DRM_EDID_FEATURE_DEFAULT_GTF))
755
			return LEVEL_CVT;
756
		return LEVEL_GTF;
757
	}
758
	return LEVEL_DMT;
759
}
1123 serge 760
 
761
/**
762
 * add_standard_modes - get std. modes from EDID and add them
763
 * @edid: EDID block to scan
764
 *
765
 * Standard modes can be calculated using the CVT standard.  Grab them from
766
 * @edid, calculate them, and add them to the list.
767
 */
768
static int add_standard_modes(struct drm_connector *connector, struct edid *edid)
769
{
770
	struct drm_device *dev = connector->dev;
771
	int i, modes = 0;
1179 serge 772
	int timing_level;
1123 serge 773
 
1179 serge 774
	timing_level = standard_timing_level(edid);
775
 
1123 serge 776
	for (i = 0; i < EDID_STD_TIMINGS; i++) {
777
		struct std_timing *t = &edid->standard_timings[i];
778
		struct drm_display_mode *newmode;
779
 
780
		/* If std timings bytes are 1, 1 it's empty */
781
		if (t->hsize == 1 && t->vfreq_aspect == 1)
782
			continue;
783
 
1179 serge 784
		newmode = drm_mode_std(dev, &edid->standard_timings[i],
785
					timing_level);
1123 serge 786
		if (newmode) {
787
			drm_mode_probed_add(connector, newmode);
788
			modes++;
789
		}
790
	}
791
 
792
	return modes;
793
}
794
 
795
/**
796
 * add_detailed_modes - get detailed mode info from EDID data
797
 * @connector: attached connector
798
 * @edid: EDID block to scan
799
 * @quirks: quirks to apply
800
 *
801
 * Some of the detailed timing sections may contain mode information.  Grab
802
 * it and add it to the list.
803
 */
804
static int add_detailed_info(struct drm_connector *connector,
805
			     struct edid *edid, u32 quirks)
806
{
807
	struct drm_device *dev = connector->dev;
808
	int i, j, modes = 0;
1179 serge 809
	int timing_level;
1123 serge 810
 
1179 serge 811
	timing_level = standard_timing_level(edid);
812
 
1123 serge 813
	for (i = 0; i < EDID_DETAILED_TIMINGS; i++) {
814
		struct detailed_timing *timing = &edid->detailed_timings[i];
815
		struct detailed_non_pixel *data = &timing->data.other_data;
816
		struct drm_display_mode *newmode;
817
 
1179 serge 818
		/* X server check is version 1.1 or higher */
819
		if (edid->version == 1 && edid->revision >= 1 &&
820
		    !timing->pixel_clock) {
821
		/* Other timing or info */
822
		switch (data->type) {
823
		case EDID_DETAIL_MONITOR_SERIAL:
824
			break;
825
		case EDID_DETAIL_MONITOR_STRING:
826
			break;
827
		case EDID_DETAIL_MONITOR_RANGE:
828
			/* Get monitor range data */
829
			break;
830
		case EDID_DETAIL_MONITOR_NAME:
831
			break;
832
		case EDID_DETAIL_MONITOR_CPDATA:
833
			break;
834
		case EDID_DETAIL_STD_MODES:
835
			/* Five modes per detailed section */
836
			for (j = 0; j < 5; i++) {
837
				struct std_timing *std;
838
				struct drm_display_mode *newmode;
1123 serge 839
 
1179 serge 840
				std = &data->data.timings[j];
841
					newmode = drm_mode_std(dev, std,
842
							       timing_level);
843
				if (newmode) {
844
					drm_mode_probed_add(connector, newmode);
845
					modes++;
846
				}
847
			}
848
			break;
849
		default:
850
			break;
851
		}
852
		} else {
1123 serge 853
			newmode = drm_mode_detailed(dev, edid, timing, quirks);
854
			if (!newmode)
855
				continue;
856
 
857
			/* First detailed mode is preferred */
858
			if (i == 0 && (edid->features & DRM_EDID_FEATURE_PREFERRED_TIMING))
859
				newmode->type |= DRM_MODE_TYPE_PREFERRED;
860
			drm_mode_probed_add(connector, newmode);
861
 
862
			modes++;
1179 serge 863
		}
864
	}
865
 
866
	return modes;
867
}
868
/**
869
 * add_detailed_mode_eedid - get detailed mode info from addtional timing
870
 * 			EDID block
871
 * @connector: attached connector
872
 * @edid: EDID block to scan(It is only to get addtional timing EDID block)
873
 * @quirks: quirks to apply
874
 *
875
 * Some of the detailed timing sections may contain mode information.  Grab
876
 * it and add it to the list.
877
 */
878
static int add_detailed_info_eedid(struct drm_connector *connector,
879
			     struct edid *edid, u32 quirks)
880
{
881
	struct drm_device *dev = connector->dev;
882
	int i, j, modes = 0;
883
	char *edid_ext = NULL;
884
	struct detailed_timing *timing;
885
	struct detailed_non_pixel *data;
886
	struct drm_display_mode *newmode;
887
	int edid_ext_num;
888
	int start_offset, end_offset;
889
	int timing_level;
890
 
891
	if (edid->version == 1 && edid->revision < 3) {
892
		/* If the EDID version is less than 1.3, there is no
893
		 * extension EDID.
894
		 */
895
		return 0;
896
	}
897
	if (!edid->extensions) {
898
		/* if there is no extension EDID, it is unnecessary to
899
		 * parse the E-EDID to get detailed info
900
		 */
901
		return 0;
902
	}
903
 
904
	/* Chose real EDID extension number */
905
	edid_ext_num = edid->extensions > MAX_EDID_EXT_NUM ?
906
		       MAX_EDID_EXT_NUM : edid->extensions;
907
 
908
	/* Find CEA extension */
909
	for (i = 0; i < edid_ext_num; i++) {
910
		edid_ext = (char *)edid + EDID_LENGTH * (i + 1);
911
		/* This block is CEA extension */
912
		if (edid_ext[0] == 0x02)
913
			break;
914
	}
915
 
916
	if (i == edid_ext_num) {
917
		/* if there is no additional timing EDID block, return */
918
		return 0;
919
	}
920
 
921
	/* Get the start offset of detailed timing block */
922
	start_offset = edid_ext[2];
923
	if (start_offset == 0) {
924
		/* If the start_offset is zero, it means that neither detailed
925
		 * info nor data block exist. In such case it is also
926
		 * unnecessary to parse the detailed timing info.
927
		 */
928
		return 0;
929
	}
930
 
931
	timing_level = standard_timing_level(edid);
932
	end_offset = EDID_LENGTH;
933
	end_offset -= sizeof(struct detailed_timing);
934
	for (i = start_offset; i < end_offset;
935
			i += sizeof(struct detailed_timing)) {
936
		timing = (struct detailed_timing *)(edid_ext + i);
937
		data = &timing->data.other_data;
938
		/* Detailed mode timing */
939
		if (timing->pixel_clock) {
940
			newmode = drm_mode_detailed(dev, edid, timing, quirks);
941
			if (!newmode)
942
				continue;
943
 
944
			drm_mode_probed_add(connector, newmode);
945
 
946
			modes++;
1123 serge 947
			continue;
948
		}
949
 
950
		/* Other timing or info */
951
		switch (data->type) {
952
		case EDID_DETAIL_MONITOR_SERIAL:
953
			break;
954
		case EDID_DETAIL_MONITOR_STRING:
955
			break;
956
		case EDID_DETAIL_MONITOR_RANGE:
957
			/* Get monitor range data */
958
			break;
959
		case EDID_DETAIL_MONITOR_NAME:
960
			break;
961
		case EDID_DETAIL_MONITOR_CPDATA:
962
			break;
963
		case EDID_DETAIL_STD_MODES:
964
			/* Five modes per detailed section */
965
			for (j = 0; j < 5; i++) {
966
				struct std_timing *std;
967
				struct drm_display_mode *newmode;
968
 
969
				std = &data->data.timings[j];
1179 serge 970
				newmode = drm_mode_std(dev, std, timing_level);
1123 serge 971
				if (newmode) {
972
					drm_mode_probed_add(connector, newmode);
973
					modes++;
974
				}
975
			}
976
			break;
977
		default:
978
			break;
979
		}
980
	}
981
 
982
	return modes;
983
}
984
 
985
#define DDC_ADDR 0x50
986
/**
987
 * Get EDID information via I2C.
988
 *
989
 * \param adapter : i2c device adaptor
990
 * \param buf     : EDID data buffer to be filled
991
 * \param len     : EDID data buffer length
992
 * \return 0 on success or -1 on failure.
993
 *
994
 * Try to fetch EDID information by calling i2c driver function.
995
 */
996
int drm_do_probe_ddc_edid(struct i2c_adapter *adapter,
997
			  unsigned char *buf, int len)
998
{
999
	unsigned char start = 0x0;
1000
	struct i2c_msg msgs[] = {
1001
		{
1002
			.addr	= DDC_ADDR,
1003
			.flags	= 0,
1004
			.len	= 1,
1005
			.buf	= &start,
1006
		}, {
1007
			.addr	= DDC_ADDR,
1008
			.flags	= I2C_M_RD,
1009
			.len	= len,
1010
			.buf	= buf,
1011
		}
1012
	};
1013
 
1014
	if (i2c_transfer(adapter, msgs, 2) == 2)
1015
		return 0;
1016
 
1017
//   dev_info(&adapter->dev, "unable to read EDID block.\n");
1018
	return -1;
1019
}
1020
EXPORT_SYMBOL(drm_do_probe_ddc_edid);
1021
 
1022
static int drm_ddc_read_edid(struct drm_connector *connector,
1023
			     struct i2c_adapter *adapter,
1024
			     char *buf, int len)
1025
{
1026
	int ret;
1027
 
1028
	ret = drm_do_probe_ddc_edid(adapter, buf, len);
1029
	if (ret != 0) {
1030
		goto end;
1031
	}
1032
	if (!edid_is_valid((struct edid *)buf)) {
1033
//       dev_warn(&connector->dev->pdev->dev, "%s: EDID invalid.\n",
1034
//            drm_get_connector_name(connector));
1035
		ret = -1;
1036
	}
1037
end:
1038
	return ret;
1039
}
1040
 
1041
/**
1042
 * drm_get_edid - get EDID data, if available
1043
 * @connector: connector we're probing
1044
 * @adapter: i2c adapter to use for DDC
1045
 *
1046
 * Poke the given connector's i2c channel to grab EDID data if possible.
1047
 *
1048
 * Return edid data or NULL if we couldn't find any.
1049
 */
1050
struct edid *drm_get_edid(struct drm_connector *connector,
1051
			  struct i2c_adapter *adapter)
1052
{
1053
	int ret;
1054
	struct edid *edid;
1055
 
1056
	edid = kmalloc(EDID_LENGTH * (MAX_EDID_EXT_NUM + 1),
1057
		       GFP_KERNEL);
1058
	if (edid == NULL) {
1059
//       dev_warn(&connector->dev->pdev->dev,
1060
//            "Failed to allocate EDID\n");
1061
		goto end;
1062
	}
1063
 
1064
	/* Read first EDID block */
1065
	ret = drm_ddc_read_edid(connector, adapter,
1066
				(unsigned char *)edid, EDID_LENGTH);
1067
	if (ret != 0)
1068
		goto clean_up;
1069
 
1070
	/* There are EDID extensions to be read */
1071
	if (edid->extensions != 0) {
1072
		int edid_ext_num = edid->extensions;
1073
 
1074
		if (edid_ext_num > MAX_EDID_EXT_NUM) {
1075
 //          dev_warn(&connector->dev->pdev->dev,
1076
//                "The number of extension(%d) is "
1077
//                "over max (%d), actually read number (%d)\n",
1078
//                edid_ext_num, MAX_EDID_EXT_NUM,
1079
//                MAX_EDID_EXT_NUM);
1080
			/* Reset EDID extension number to be read */
1081
			edid_ext_num = MAX_EDID_EXT_NUM;
1082
		}
1083
		/* Read EDID including extensions too */
1084
		ret = drm_ddc_read_edid(connector, adapter, (char *)edid,
1085
					EDID_LENGTH * (edid_ext_num + 1));
1086
		if (ret != 0)
1087
			goto clean_up;
1088
 
1089
	}
1090
 
1091
	connector->display_info.raw_edid = (char *)edid;
1092
	goto end;
1093
 
1094
clean_up:
1095
	kfree(edid);
1096
	edid = NULL;
1097
end:
1098
	return edid;
1099
 
1100
}
1101
EXPORT_SYMBOL(drm_get_edid);
1102
 
1103
#define HDMI_IDENTIFIER 0x000C03
1104
#define VENDOR_BLOCK    0x03
1105
/**
1106
 * drm_detect_hdmi_monitor - detect whether monitor is hdmi.
1107
 * @edid: monitor EDID information
1108
 *
1109
 * Parse the CEA extension according to CEA-861-B.
1110
 * Return true if HDMI, false if not or unknown.
1111
 */
1112
bool drm_detect_hdmi_monitor(struct edid *edid)
1113
{
1114
	char *edid_ext = NULL;
1115
	int i, hdmi_id, edid_ext_num;
1116
	int start_offset, end_offset;
1117
	bool is_hdmi = false;
1118
 
1119
	/* No EDID or EDID extensions */
1120
	if (edid == NULL || edid->extensions == 0)
1121
		goto end;
1122
 
1123
	/* Chose real EDID extension number */
1124
	edid_ext_num = edid->extensions > MAX_EDID_EXT_NUM ?
1125
		       MAX_EDID_EXT_NUM : edid->extensions;
1126
 
1127
	/* Find CEA extension */
1128
	for (i = 0; i < edid_ext_num; i++) {
1129
		edid_ext = (char *)edid + EDID_LENGTH * (i + 1);
1130
		/* This block is CEA extension */
1131
		if (edid_ext[0] == 0x02)
1132
			break;
1133
	}
1134
 
1135
	if (i == edid_ext_num)
1136
		goto end;
1137
 
1138
	/* Data block offset in CEA extension block */
1139
	start_offset = 4;
1140
	end_offset = edid_ext[2];
1141
 
1142
	/*
1143
	 * Because HDMI identifier is in Vendor Specific Block,
1144
	 * search it from all data blocks of CEA extension.
1145
	 */
1146
	for (i = start_offset; i < end_offset;
1147
		/* Increased by data block len */
1148
		i += ((edid_ext[i] & 0x1f) + 1)) {
1149
		/* Find vendor specific block */
1150
		if ((edid_ext[i] >> 5) == VENDOR_BLOCK) {
1151
			hdmi_id = edid_ext[i + 1] | (edid_ext[i + 2] << 8) |
1152
				  edid_ext[i + 3] << 16;
1153
			/* Find HDMI identifier */
1154
			if (hdmi_id == HDMI_IDENTIFIER)
1155
				is_hdmi = true;
1156
			break;
1157
		}
1158
	}
1159
 
1160
end:
1161
	return is_hdmi;
1162
}
1163
EXPORT_SYMBOL(drm_detect_hdmi_monitor);
1164
 
1165
/**
1166
 * drm_add_edid_modes - add modes from EDID data, if available
1167
 * @connector: connector we're probing
1168
 * @edid: edid data
1169
 *
1170
 * Add the specified modes to the connector's mode list.
1171
 *
1172
 * Return number of modes added or 0 if we couldn't find any.
1173
 */
1174
int drm_add_edid_modes(struct drm_connector *connector, struct edid *edid)
1175
{
1176
	int num_modes = 0;
1177
	u32 quirks;
1178
 
1179
	if (edid == NULL) {
1180
		return 0;
1181
	}
1182
	if (!edid_is_valid(edid)) {
1183
//       dev_warn(&connector->dev->pdev->dev, "%s: EDID invalid.\n",
1184
//            drm_get_connector_name(connector));
1185
		return 0;
1186
	}
1187
 
1188
	quirks = edid_get_quirks(edid);
1189
 
1190
	num_modes += add_established_modes(connector, edid);
1191
	num_modes += add_standard_modes(connector, edid);
1192
	num_modes += add_detailed_info(connector, edid, quirks);
1179 serge 1193
	num_modes += add_detailed_info_eedid(connector, edid, quirks);
1123 serge 1194
 
1195
	if (quirks & (EDID_QUIRK_PREFER_LARGE_60 | EDID_QUIRK_PREFER_LARGE_75))
1196
		edid_fixup_preferred(connector, quirks);
1197
 
1198
	connector->display_info.serration_vsync = (edid->input & DRM_EDID_INPUT_SERRATION_VSYNC) ? 1 : 0;
1199
	connector->display_info.sync_on_green = (edid->input & DRM_EDID_INPUT_SYNC_ON_GREEN) ? 1 : 0;
1200
	connector->display_info.composite_sync = (edid->input & DRM_EDID_INPUT_COMPOSITE_SYNC) ? 1 : 0;
1201
	connector->display_info.separate_syncs = (edid->input & DRM_EDID_INPUT_SEPARATE_SYNCS) ? 1 : 0;
1202
	connector->display_info.blank_to_black = (edid->input & DRM_EDID_INPUT_BLANK_TO_BLACK) ? 1 : 0;
1203
	connector->display_info.video_level = (edid->input & DRM_EDID_INPUT_VIDEO_LEVEL) >> 5;
1204
	connector->display_info.digital = (edid->input & DRM_EDID_INPUT_DIGITAL) ? 1 : 0;
1205
	connector->display_info.width_mm = edid->width_cm * 10;
1206
	connector->display_info.height_mm = edid->height_cm * 10;
1207
	connector->display_info.gamma = edid->gamma;
1208
	connector->display_info.gtf_supported = (edid->features & DRM_EDID_FEATURE_DEFAULT_GTF) ? 1 : 0;
1209
	connector->display_info.standard_color = (edid->features & DRM_EDID_FEATURE_STANDARD_COLOR) ? 1 : 0;
1210
	connector->display_info.display_type = (edid->features & DRM_EDID_FEATURE_DISPLAY_TYPE) >> 3;
1211
	connector->display_info.active_off_supported = (edid->features & DRM_EDID_FEATURE_PM_ACTIVE_OFF) ? 1 : 0;
1212
	connector->display_info.suspend_supported = (edid->features & DRM_EDID_FEATURE_PM_SUSPEND) ? 1 : 0;
1213
	connector->display_info.standby_supported = (edid->features & DRM_EDID_FEATURE_PM_STANDBY) ? 1 : 0;
1214
	connector->display_info.gamma = edid->gamma;
1215
 
1216
	return num_modes;
1217
}
1218
EXPORT_SYMBOL(drm_add_edid_modes);
1179 serge 1219
 
1220
/**
1221
 * drm_add_modes_noedid - add modes for the connectors without EDID
1222
 * @connector: connector we're probing
1223
 * @hdisplay: the horizontal display limit
1224
 * @vdisplay: the vertical display limit
1225
 *
1226
 * Add the specified modes to the connector's mode list. Only when the
1227
 * hdisplay/vdisplay is not beyond the given limit, it will be added.
1228
 *
1229
 * Return number of modes added or 0 if we couldn't find any.
1230
 */
1231
int drm_add_modes_noedid(struct drm_connector *connector,
1232
			int hdisplay, int vdisplay)
1233
{
1234
	int i, count, num_modes = 0;
1235
	struct drm_display_mode *mode, *ptr;
1236
	struct drm_device *dev = connector->dev;
1237
 
1238
	count = sizeof(drm_dmt_modes) / sizeof(struct drm_display_mode);
1239
	if (hdisplay < 0)
1240
		hdisplay = 0;
1241
	if (vdisplay < 0)
1242
		vdisplay = 0;
1243
 
1244
	for (i = 0; i < count; i++) {
1245
		ptr = &drm_dmt_modes[i];
1246
		if (hdisplay && vdisplay) {
1247
			/*
1248
			 * Only when two are valid, they will be used to check
1249
			 * whether the mode should be added to the mode list of
1250
			 * the connector.
1251
			 */
1252
			if (ptr->hdisplay > hdisplay ||
1253
					ptr->vdisplay > vdisplay)
1254
				continue;
1255
		}
1256
		mode = drm_mode_duplicate(dev, ptr);
1257
		if (mode) {
1258
			drm_mode_probed_add(connector, mode);
1259
			num_modes++;
1260
		}
1261
	}
1262
	return num_modes;
1263
}
1264
EXPORT_SYMBOL(drm_add_modes_noedid);