Subversion Repositories Kolibri OS

Rev

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

Rev Author Line No. Line
1408 serge 1
/*
2
 * Copyright © 2006 Keith Packard
3
 * Copyright © 2007-2008 Dave Airlie
4
 * Copyright © 2007-2008 Intel Corporation
5
 *   Jesse Barnes 
6
 *
7
 * Permission is hereby granted, free of charge, to any person obtaining a
8
 * copy of this software and associated documentation files (the "Software"),
9
 * to deal in the Software without restriction, including without limitation
10
 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
11
 * and/or sell copies of the Software, and to permit persons to whom the
12
 * Software is furnished to do so, subject to the following conditions:
13
 *
14
 * The above copyright notice and this permission notice shall be included in
15
 * all copies or substantial portions of the Software.
16
 *
17
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
18
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
19
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
20
 * THE COPYRIGHT HOLDER(S) OR AUTHOR(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR
21
 * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
22
 * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
23
 * OTHER DEALINGS IN THE SOFTWARE.
24
 */
25
#ifndef __DRM_CRTC_H__
26
#define __DRM_CRTC_H__
27
 
28
#include 
1630 serge 29
#include 
1408 serge 30
#include 
31
#include 
32
#include 
3031 serge 33
#include 
1408 serge 34
 
2967 Serge 35
#include 
36
 
1408 serge 37
struct drm_device;
38
struct drm_mode_set;
39
struct drm_framebuffer;
3031 serge 40
struct drm_object_properties;
3391 Serge 41
struct drm_file;
42
struct drm_clip_rect;
1408 serge 43
 
44
#define DRM_MODE_OBJECT_CRTC 0xcccccccc
45
#define DRM_MODE_OBJECT_CONNECTOR 0xc0c0c0c0
46
#define DRM_MODE_OBJECT_ENCODER 0xe0e0e0e0
47
#define DRM_MODE_OBJECT_MODE 0xdededede
48
#define DRM_MODE_OBJECT_PROPERTY 0xb0b0b0b0
49
#define DRM_MODE_OBJECT_FB 0xfbfbfbfb
50
#define DRM_MODE_OBJECT_BLOB 0xbbbbbbbb
2967 Serge 51
#define DRM_MODE_OBJECT_PLANE 0xeeeeeeee
1408 serge 52
 
53
struct drm_mode_object {
54
	uint32_t id;
55
	uint32_t type;
3031 serge 56
	struct drm_object_properties *properties;
1408 serge 57
};
58
 
3031 serge 59
#define DRM_OBJECT_MAX_PROPERTY 24
60
struct drm_object_properties {
61
	int count;
62
	uint32_t ids[DRM_OBJECT_MAX_PROPERTY];
63
	uint64_t values[DRM_OBJECT_MAX_PROPERTY];
64
};
65
 
1408 serge 66
/*
67
 * Note on terminology:  here, for brevity and convenience, we refer to connector
68
 * control chips as 'CRTCs'.  They can control any type of connector, VGA, LVDS,
69
 * DVI, etc.  And 'screen' refers to the whole of the visible display, which
70
 * may span multiple monitors (and therefore multiple CRTC and connector
71
 * structures).
72
 */
73
 
74
enum drm_mode_status {
75
    MODE_OK	= 0,	/* Mode OK */
76
    MODE_HSYNC,		/* hsync out of range */
77
    MODE_VSYNC,		/* vsync out of range */
78
    MODE_H_ILLEGAL,	/* mode has illegal horizontal timings */
79
    MODE_V_ILLEGAL,	/* mode has illegal horizontal timings */
80
    MODE_BAD_WIDTH,	/* requires an unsupported linepitch */
1964 serge 81
    MODE_NOMODE,	/* no mode with a matching name */
1408 serge 82
    MODE_NO_INTERLACE,	/* interlaced mode not supported */
83
    MODE_NO_DBLESCAN,	/* doublescan mode not supported */
84
    MODE_NO_VSCAN,	/* multiscan mode not supported */
85
    MODE_MEM,		/* insufficient video memory */
86
    MODE_VIRTUAL_X,	/* mode width too large for specified virtual size */
87
    MODE_VIRTUAL_Y,	/* mode height too large for specified virtual size */
88
    MODE_MEM_VIRT,	/* insufficient video memory given virtual size */
89
    MODE_NOCLOCK,	/* no fixed clock available */
90
    MODE_CLOCK_HIGH,	/* clock required is too high */
91
    MODE_CLOCK_LOW,	/* clock required is too low */
92
    MODE_CLOCK_RANGE,	/* clock/mode isn't in a ClockRange */
93
    MODE_BAD_HVALUE,	/* horizontal timing was out of range */
94
    MODE_BAD_VVALUE,	/* vertical timing was out of range */
95
    MODE_BAD_VSCAN,	/* VScan value out of range */
96
    MODE_HSYNC_NARROW,	/* horizontal sync too narrow */
97
    MODE_HSYNC_WIDE,	/* horizontal sync too wide */
98
    MODE_HBLANK_NARROW,	/* horizontal blanking too narrow */
99
    MODE_HBLANK_WIDE,	/* horizontal blanking too wide */
100
    MODE_VSYNC_NARROW,	/* vertical sync too narrow */
101
    MODE_VSYNC_WIDE,	/* vertical sync too wide */
102
    MODE_VBLANK_NARROW,	/* vertical blanking too narrow */
103
    MODE_VBLANK_WIDE,	/* vertical blanking too wide */
104
    MODE_PANEL,         /* exceeds panel dimensions */
105
    MODE_INTERLACE_WIDTH, /* width too large for interlaced mode */
106
    MODE_ONE_WIDTH,     /* only one width is supported */
107
    MODE_ONE_HEIGHT,    /* only one height is supported */
108
    MODE_ONE_SIZE,      /* only one resolution is supported */
109
    MODE_NO_REDUCED,    /* monitor doesn't accept reduced blanking */
110
    MODE_UNVERIFIED = -3, /* mode needs to reverified */
111
    MODE_BAD = -2,	/* unspecified reason */
112
    MODE_ERROR	= -1	/* error condition */
113
};
114
 
115
#define DRM_MODE_TYPE_CLOCK_CRTC_C (DRM_MODE_TYPE_CLOCK_C | \
116
				    DRM_MODE_TYPE_CRTC_C)
117
 
118
#define DRM_MODE(nm, t, c, hd, hss, hse, ht, hsk, vd, vss, vse, vt, vs, f) \
119
	.name = nm, .status = 0, .type = (t), .clock = (c), \
120
	.hdisplay = (hd), .hsync_start = (hss), .hsync_end = (hse), \
121
	.htotal = (ht), .hskew = (hsk), .vdisplay = (vd), \
122
	.vsync_start = (vss), .vsync_end = (vse), .vtotal = (vt), \
3031 serge 123
	.vscan = (vs), .flags = (f), .vrefresh = 0, \
124
	.base.type = DRM_MODE_OBJECT_MODE
1408 serge 125
 
126
#define CRTC_INTERLACE_HALVE_V 0x1 /* halve V values for interlacing */
127
 
128
struct drm_display_mode {
129
	/* Header */
130
	struct list_head head;
131
	struct drm_mode_object base;
132
 
133
	char name[DRM_DISPLAY_MODE_LEN];
134
 
135
	enum drm_mode_status status;
3031 serge 136
	unsigned int type;
1408 serge 137
 
138
	/* Proposed mode values */
139
	int clock;		/* in kHz */
140
	int hdisplay;
141
	int hsync_start;
142
	int hsync_end;
143
	int htotal;
144
	int hskew;
145
	int vdisplay;
146
	int vsync_start;
147
	int vsync_end;
148
	int vtotal;
149
	int vscan;
150
	unsigned int flags;
151
 
152
	/* Addressable image size (may be 0 for projectors, etc.) */
153
	int width_mm;
154
	int height_mm;
155
 
156
	/* Actual mode we give to hw */
157
	int clock_index;
158
	int synth_clock;
159
	int crtc_hdisplay;
160
	int crtc_hblank_start;
161
	int crtc_hblank_end;
162
	int crtc_hsync_start;
163
	int crtc_hsync_end;
164
	int crtc_htotal;
165
	int crtc_hskew;
166
	int crtc_vdisplay;
167
	int crtc_vblank_start;
168
	int crtc_vblank_end;
169
	int crtc_vsync_start;
170
	int crtc_vsync_end;
171
	int crtc_vtotal;
172
 
173
	/* Driver private mode info */
174
	int private_size;
175
	int *private;
176
	int private_flags;
177
 
178
	int vrefresh;		/* in Hz */
179
	int hsync;		/* in kHz */
180
};
181
 
182
enum drm_connector_status {
183
	connector_status_connected = 1,
184
	connector_status_disconnected = 2,
185
	connector_status_unknown = 3,
186
};
187
 
188
enum subpixel_order {
189
	SubPixelUnknown = 0,
190
	SubPixelHorizontalRGB,
191
	SubPixelHorizontalBGR,
192
	SubPixelVerticalRGB,
193
	SubPixelVerticalBGR,
194
	SubPixelNone,
195
};
196
 
1964 serge 197
#define DRM_COLOR_FORMAT_RGB444		(1<<0)
198
#define DRM_COLOR_FORMAT_YCRCB444	(1<<1)
199
#define DRM_COLOR_FORMAT_YCRCB422	(1<<2)
1408 serge 200
/*
201
 * Describes a given display (e.g. CRT or flat panel) and its limitations.
202
 */
203
struct drm_display_info {
204
	char name[DRM_DISPLAY_INFO_LEN];
1964 serge 205
 
1408 serge 206
	/* Physical size */
207
        unsigned int width_mm;
208
	unsigned int height_mm;
209
 
210
	/* Clock limits FIXME: storage format */
211
	unsigned int min_vfreq, max_vfreq;
212
	unsigned int min_hfreq, max_hfreq;
213
	unsigned int pixel_clock;
1964 serge 214
	unsigned int bpc;
1408 serge 215
 
216
	enum subpixel_order subpixel_order;
1964 serge 217
	u32 color_formats;
1408 serge 218
 
2161 serge 219
	u8 cea_rev;
1408 serge 220
};
221
 
222
struct drm_framebuffer_funcs {
3031 serge 223
	/* note: use drm_framebuffer_remove() */
1408 serge 224
	void (*destroy)(struct drm_framebuffer *framebuffer);
225
	int (*create_handle)(struct drm_framebuffer *fb,
226
			     struct drm_file *file_priv,
227
			     unsigned int *handle);
228
	/**
229
	 * Optinal callback for the dirty fb ioctl.
230
	 *
231
	 * Userspace can notify the driver via this callback
232
	 * that a area of the framebuffer has changed and should
233
	 * be flushed to the display hardware.
234
	 *
235
	 * See documentation in drm_mode.h for the struct
236
	 * drm_mode_fb_dirty_cmd for more information as all
237
	 * the semantics and arguments have a one to one mapping
238
	 * on this function.
239
	 */
1964 serge 240
	int (*dirty)(struct drm_framebuffer *framebuffer,
241
		     struct drm_file *file_priv, unsigned flags,
1408 serge 242
		     unsigned color, struct drm_clip_rect *clips,
243
		     unsigned num_clips);
244
};
245
 
246
struct drm_framebuffer {
247
	struct drm_device *dev;
3262 Serge 248
	/*
249
	 * Note that the fb is refcounted for the benefit of driver internals,
250
	 * for example some hw, disabling a CRTC/plane is asynchronous, and
251
	 * scanout does not actually complete until the next vblank.  So some
252
	 * cleanup (like releasing the reference(s) on the backing GEM bo(s))
253
	 * should be deferred.  In cases like this, the driver would like to
254
	 * hold a ref to the fb even though it has already been removed from
255
	 * userspace perspective.
256
	 */
257
	struct kref refcount;
3391 Serge 258
	/*
259
	 * Place on the dev->mode_config.fb_list, access protected by
260
	 * dev->mode_config.fb_lock.
261
	 */
1408 serge 262
	struct list_head head;
263
	struct drm_mode_object base;
264
	const struct drm_framebuffer_funcs *funcs;
2967 Serge 265
	unsigned int pitches[4];
266
	unsigned int offsets[4];
1408 serge 267
	unsigned int width;
268
	unsigned int height;
269
	/* depth can be 15 or 16 */
270
	unsigned int depth;
271
	int bits_per_pixel;
272
	int flags;
2967 Serge 273
	uint32_t pixel_format; /* fourcc format */
1408 serge 274
	struct list_head filp_head;
275
	/* if you are using the helper */
276
	void *helper_private;
277
};
278
 
279
struct drm_property_blob {
280
	struct drm_mode_object base;
281
	struct list_head head;
282
	unsigned int length;
3031 serge 283
	unsigned char data[];
1408 serge 284
};
285
 
286
struct drm_property_enum {
287
	uint64_t value;
288
	struct list_head head;
289
	char name[DRM_PROP_NAME_LEN];
290
};
291
 
292
struct drm_property {
293
    struct      list_head head;
294
    struct      drm_mode_object base;
295
    uint32_t    flags;
296
    char        name[DRM_PROP_NAME_LEN];
297
    uint32_t    num_values;
298
    uint64_t    *values;
299
 
300
	struct list_head enum_blob_list;
301
};
302
 
303
struct drm_crtc;
304
struct drm_connector;
305
struct drm_encoder;
306
struct drm_pending_vblank_event;
2967 Serge 307
struct drm_plane;
1408 serge 308
 
309
/**
310
 * drm_crtc_funcs - control CRTCs for a given device
3031 serge 311
 * @save: save CRTC state
312
 * @restore: restore CRTC state
1964 serge 313
 * @reset: reset CRTC after state has been invalidate (e.g. resume)
3031 serge 314
 * @cursor_set: setup the cursor
315
 * @cursor_move: move the cursor
1408 serge 316
 * @gamma_set: specify color ramp for CRTC
3031 serge 317
 * @destroy: deinit and free object
318
 * @set_property: called when a property is changed
319
 * @set_config: apply a new CRTC configuration
320
 * @page_flip: initiate a page flip
1408 serge 321
 *
322
 * The drm_crtc_funcs structure is the central CRTC management structure
323
 * in the DRM.  Each CRTC controls one or more connectors (note that the name
324
 * CRTC is simply historical, a CRTC may control LVDS, VGA, DVI, TV out, etc.
325
 * connectors, not just CRTs).
326
 *
327
 * Each driver is responsible for filling out this structure at startup time,
328
 * in addition to providing other modesetting features, like i2c and DDC
329
 * bus accessors.
330
 */
331
struct drm_crtc_funcs {
332
	/* Save CRTC state */
333
	void (*save)(struct drm_crtc *crtc); /* suspend? */
334
	/* Restore CRTC state */
335
	void (*restore)(struct drm_crtc *crtc); /* resume? */
1964 serge 336
	/* Reset CRTC state */
337
	void (*reset)(struct drm_crtc *crtc);
1408 serge 338
 
339
	/* cursor controls */
340
	int (*cursor_set)(struct drm_crtc *crtc, struct drm_file *file_priv,
341
			  uint32_t handle, uint32_t width, uint32_t height);
342
	int (*cursor_move)(struct drm_crtc *crtc, int x, int y);
343
 
344
	/* Set gamma on the CRTC */
345
	void (*gamma_set)(struct drm_crtc *crtc, u16 *r, u16 *g, u16 *b,
1964 serge 346
			  uint32_t start, uint32_t size);
1408 serge 347
	/* Object destroy routine */
348
	void (*destroy)(struct drm_crtc *crtc);
349
 
350
	int (*set_config)(struct drm_mode_set *set);
351
 
352
	/*
353
	 * Flip to the given framebuffer.  This implements the page
1964 serge 354
	 * flip ioctl described in drm_mode.h, specifically, the
1408 serge 355
	 * implementation must return immediately and block all
356
	 * rendering to the current fb until the flip has completed.
357
	 * If userspace set the event flag in the ioctl, the event
358
	 * argument will point to an event to send back when the flip
359
	 * completes, otherwise it will be NULL.
360
	 */
361
	int (*page_flip)(struct drm_crtc *crtc,
362
			 struct drm_framebuffer *fb,
363
			 struct drm_pending_vblank_event *event);
3031 serge 364
 
365
	int (*set_property)(struct drm_crtc *crtc,
366
			    struct drm_property *property, uint64_t val);
1408 serge 367
};
368
 
369
/**
370
 * drm_crtc - central CRTC control structure
2967 Serge 371
 * @dev: parent DRM device
372
 * @head: list management
373
 * @base: base KMS object for ID tracking etc.
1408 serge 374
 * @enabled: is this CRTC enabled?
2967 Serge 375
 * @mode: current mode timings
376
 * @hwmode: mode timings as programmed to hw regs
3031 serge 377
 * @invert_dimensions: for purposes of error checking crtc vs fb sizes,
378
 *    invert the width/height of the crtc.  This is used if the driver
379
 *    is performing 90 or 270 degree rotated scanout
1408 serge 380
 * @x: x position on screen
381
 * @y: y position on screen
382
 * @funcs: CRTC control functions
2967 Serge 383
 * @gamma_size: size of gamma ramp
384
 * @gamma_store: gamma ramp values
385
 * @framedur_ns: precise frame timing
386
 * @framedur_ns: precise line timing
387
 * @pixeldur_ns: precise pixel timing
388
 * @helper_private: mid-layer private data
3031 serge 389
 * @properties: property tracking for this CRTC
1408 serge 390
 *
391
 * Each CRTC may have one or more connectors associated with it.  This structure
392
 * allows the CRTC to be controlled.
393
 */
394
struct drm_crtc {
395
	struct drm_device *dev;
396
	struct list_head head;
397
 
3391 Serge 398
	/**
399
	 * crtc mutex
400
	 *
401
	 * This provides a read lock for the overall crtc state (mode, dpms
402
	 * state, ...) and a write lock for everything which can be update
403
	 * without a full modeset (fb, cursor data, ...)
404
	 */
405
	struct mutex mutex;
406
 
1408 serge 407
	struct drm_mode_object base;
408
 
409
	/* framebuffer the connector is currently bound to */
410
	struct drm_framebuffer *fb;
411
 
412
	bool enabled;
413
 
1964 serge 414
	/* Requested mode from modesetting. */
1408 serge 415
	struct drm_display_mode mode;
416
 
1964 serge 417
	/* Programmed mode in hw, after adjustments for encoders,
418
	 * crtc, panel scaling etc. Needed for timestamping etc.
419
	 */
420
	struct drm_display_mode hwmode;
421
 
3031 serge 422
	bool invert_dimensions;
423
 
1408 serge 424
	int x, y;
425
	const struct drm_crtc_funcs *funcs;
426
 
427
	/* CRTC gamma size for reporting to userspace */
428
	uint32_t gamma_size;
429
	uint16_t *gamma_store;
430
 
1964 serge 431
	/* Constants needed for precise vblank and swap timestamping. */
432
	s64 framedur_ns, linedur_ns, pixeldur_ns;
433
 
1408 serge 434
	/* if you are using the helper */
435
	void *helper_private;
3031 serge 436
 
437
	struct drm_object_properties properties;
1408 serge 438
};
439
 
440
 
441
/**
442
 * drm_connector_funcs - control connectors on a given device
443
 * @dpms: set power state (see drm_crtc_funcs above)
444
 * @save: save connector state
445
 * @restore: restore connector state
3391 Serge 446
 * @reset: reset connector after state has been invalidated (e.g. resume)
1408 serge 447
 * @detect: is this connector active?
3031 serge 448
 * @fill_modes: fill mode list for this connector
3391 Serge 449
 * @set_property: property for this connector may need an update
1408 serge 450
 * @destroy: make object go away
3391 Serge 451
 * @force: notify the driver that the connector is forced on
1408 serge 452
 *
453
 * Each CRTC may have one or more connectors attached to it.  The functions
454
 * below allow the core DRM code to control connectors, enumerate available modes,
455
 * etc.
456
 */
457
struct drm_connector_funcs {
458
	void (*dpms)(struct drm_connector *connector, int mode);
459
	void (*save)(struct drm_connector *connector);
460
	void (*restore)(struct drm_connector *connector);
1964 serge 461
	void (*reset)(struct drm_connector *connector);
462
 
463
	/* Check to see if anything is attached to the connector.
464
	 * @force is set to false whilst polling, true when checking the
465
	 * connector due to user request. @force can be used by the driver
466
	 * to avoid expensive, destructive operations during automated
467
	 * probing.
468
	 */
469
	enum drm_connector_status (*detect)(struct drm_connector *connector,
470
					    bool force);
1408 serge 471
	int (*fill_modes)(struct drm_connector *connector, uint32_t max_width, uint32_t max_height);
472
	int (*set_property)(struct drm_connector *connector, struct drm_property *property,
473
			     uint64_t val);
474
	void (*destroy)(struct drm_connector *connector);
475
	void (*force)(struct drm_connector *connector);
476
};
477
 
2967 Serge 478
/**
479
 * drm_encoder_funcs - encoder controls
480
 * @reset: reset state (e.g. at init or resume time)
481
 * @destroy: cleanup and free associated data
482
 *
483
 * Encoders sit between CRTCs and connectors.
484
 */
1408 serge 485
struct drm_encoder_funcs {
1964 serge 486
	void (*reset)(struct drm_encoder *encoder);
1408 serge 487
	void (*destroy)(struct drm_encoder *encoder);
488
};
489
 
490
#define DRM_CONNECTOR_MAX_UMODES 16
491
#define DRM_CONNECTOR_LEN 32
2967 Serge 492
#define DRM_CONNECTOR_MAX_ENCODER 3
1408 serge 493
 
494
/**
495
 * drm_encoder - central DRM encoder structure
2967 Serge 496
 * @dev: parent DRM device
497
 * @head: list management
498
 * @base: base KMS object
499
 * @encoder_type: one of the %DRM_MODE_ENCODER_ types in drm_mode.h
500
 * @possible_crtcs: bitmask of potential CRTC bindings
501
 * @possible_clones: bitmask of potential sibling encoders for cloning
502
 * @crtc: currently bound CRTC
503
 * @funcs: control functions
504
 * @helper_private: mid-layer private data
505
 *
506
 * CRTCs drive pixels to encoders, which convert them into signals
507
 * appropriate for a given connector or set of connectors.
1408 serge 508
 */
509
struct drm_encoder {
510
	struct drm_device *dev;
511
	struct list_head head;
512
 
513
	struct drm_mode_object base;
514
	int encoder_type;
515
	uint32_t possible_crtcs;
516
	uint32_t possible_clones;
517
 
518
	struct drm_crtc *crtc;
519
	const struct drm_encoder_funcs *funcs;
520
	void *helper_private;
521
};
522
 
523
enum drm_connector_force {
524
	DRM_FORCE_UNSPECIFIED,
525
	DRM_FORCE_OFF,
526
	DRM_FORCE_ON,         /* force on analog part normally */
527
	DRM_FORCE_ON_DIGITAL, /* for DVI-I use digital connector */
528
};
529
 
1964 serge 530
/* should we poll this connector for connects and disconnects */
531
/* hot plug detectable */
532
#define DRM_CONNECTOR_POLL_HPD (1 << 0)
533
/* poll for connections */
534
#define DRM_CONNECTOR_POLL_CONNECT (1 << 1)
535
/* can cleanly poll for disconnections without flickering the screen */
536
/* DACs should rarely do this without a lot of testing */
537
#define DRM_CONNECTOR_POLL_DISCONNECT (1 << 2)
538
 
2967 Serge 539
#define MAX_ELD_BYTES	128
540
 
1408 serge 541
/**
542
 * drm_connector - central DRM connector control structure
2967 Serge 543
 * @dev: parent DRM device
544
 * @kdev: kernel device for sysfs attributes
545
 * @attr: sysfs attributes
546
 * @head: list management
547
 * @base: base KMS object
548
 * @connector_type: one of the %DRM_MODE_CONNECTOR_ types from drm_mode.h
549
 * @connector_type_id: index into connector type enum
1408 serge 550
 * @interlace_allowed: can this connector handle interlaced modes?
551
 * @doublescan_allowed: can this connector handle doublescan?
2967 Serge 552
 * @modes: modes available on this connector (from fill_modes() + user)
553
 * @status: one of the drm_connector_status enums (connected, not, or unknown)
554
 * @probed_modes: list of modes derived directly from the display
555
 * @display_info: information about attached display (e.g. from EDID)
1408 serge 556
 * @funcs: connector control functions
2967 Serge 557
 * @user_modes: user added mode list
558
 * @edid_blob_ptr: DRM property containing EDID if present
3031 serge 559
 * @properties: property tracking for this connector
2967 Serge 560
 * @polled: a %DRM_CONNECTOR_POLL_ value for core driven polling
561
 * @dpms: current dpms state
562
 * @helper_private: mid-layer private data
563
 * @force: a %DRM_FORCE_ state for forced mode sets
564
 * @encoder_ids: valid encoders for this connector
565
 * @encoder: encoder driving this connector, if any
566
 * @eld: EDID-like data, if present
567
 * @dvi_dual: dual link DVI, if found
568
 * @max_tmds_clock: max clock rate, if found
569
 * @latency_present: AV delay info from ELD, if found
570
 * @video_latency: video latency info from ELD, if found
571
 * @audio_latency: audio latency info from ELD, if found
572
 * @null_edid_counter: track sinks that give us all zeros for the EDID
1408 serge 573
 *
574
 * Each connector may be connected to one or more CRTCs, or may be clonable by
575
 * another connector if they can share a CRTC.  Each connector also has a specific
576
 * position in the broader display (referred to as a 'screen' though it could
577
 * span multiple monitors).
578
 */
579
struct drm_connector {
580
	struct drm_device *dev;
1964 serge 581
	struct device kdev;
1408 serge 582
	struct device_attribute *attr;
583
	struct list_head head;
584
 
585
	struct drm_mode_object base;
586
 
587
	int connector_type;
588
	int connector_type_id;
589
	bool interlace_allowed;
590
	bool doublescan_allowed;
591
	struct list_head modes; /* list of modes on this connector */
592
 
593
	enum drm_connector_status status;
594
 
595
	/* these are modes added by probing with DDC or the BIOS */
596
	struct list_head probed_modes;
597
 
598
	struct drm_display_info display_info;
599
	const struct drm_connector_funcs *funcs;
600
 
601
	struct list_head user_modes;
602
	struct drm_property_blob *edid_blob_ptr;
3031 serge 603
	struct drm_object_properties properties;
1408 serge 604
 
1964 serge 605
	uint8_t polled; /* DRM_CONNECTOR_POLL_* */
606
 
1408 serge 607
	/* requested DPMS state */
608
	int dpms;
609
 
610
	void *helper_private;
611
 
612
	/* forced on connector */
613
	enum drm_connector_force force;
614
	uint32_t encoder_ids[DRM_CONNECTOR_MAX_ENCODER];
615
	struct drm_encoder *encoder; /* currently active encoder */
1987 serge 616
 
2967 Serge 617
	/* EDID bits */
618
	uint8_t eld[MAX_ELD_BYTES];
619
	bool dvi_dual;
620
	int max_tmds_clock;	/* in MHz */
621
	bool latency_present[2];
622
	int video_latency[2];	/* [0]: progressive, [1]: interlaced */
623
	int audio_latency[2];
1987 serge 624
	int null_edid_counter; /* needed to workaround some HW bugs where we get all 0s */
3031 serge 625
	unsigned bad_edid_counter;
1408 serge 626
};
627
 
628
/**
2967 Serge 629
 * drm_plane_funcs - driver plane control functions
630
 * @update_plane: update the plane configuration
631
 * @disable_plane: shut down the plane
632
 * @destroy: clean up plane resources
3031 serge 633
 * @set_property: called when a property is changed
2967 Serge 634
 */
635
struct drm_plane_funcs {
636
	int (*update_plane)(struct drm_plane *plane,
637
			    struct drm_crtc *crtc, struct drm_framebuffer *fb,
638
			    int crtc_x, int crtc_y,
639
			    unsigned int crtc_w, unsigned int crtc_h,
640
			    uint32_t src_x, uint32_t src_y,
641
			    uint32_t src_w, uint32_t src_h);
642
	int (*disable_plane)(struct drm_plane *plane);
643
	void (*destroy)(struct drm_plane *plane);
3031 serge 644
 
645
	int (*set_property)(struct drm_plane *plane,
646
			    struct drm_property *property, uint64_t val);
2967 Serge 647
};
648
 
649
/**
650
 * drm_plane - central DRM plane control structure
651
 * @dev: DRM device this plane belongs to
652
 * @head: for list management
653
 * @base: base mode object
654
 * @possible_crtcs: pipes this plane can be bound to
655
 * @format_types: array of formats supported by this plane
656
 * @format_count: number of formats supported
657
 * @crtc: currently bound CRTC
658
 * @fb: currently bound fb
659
 * @gamma_size: size of gamma table
660
 * @gamma_store: gamma correction table
661
 * @enabled: enabled flag
662
 * @funcs: helper functions
663
 * @helper_private: storage for drver layer
3031 serge 664
 * @properties: property tracking for this plane
2967 Serge 665
 */
666
struct drm_plane {
667
	struct drm_device *dev;
668
	struct list_head head;
669
 
670
	struct drm_mode_object base;
671
 
672
	uint32_t possible_crtcs;
673
	uint32_t *format_types;
674
	uint32_t format_count;
675
 
676
	struct drm_crtc *crtc;
677
	struct drm_framebuffer *fb;
678
 
679
	/* CRTC gamma size for reporting to userspace */
680
	uint32_t gamma_size;
681
	uint16_t *gamma_store;
682
 
683
	bool enabled;
684
 
685
	const struct drm_plane_funcs *funcs;
686
	void *helper_private;
3031 serge 687
 
688
	struct drm_object_properties properties;
2967 Serge 689
};
690
 
691
/**
692
 * drm_mode_set - new values for a CRTC config change
693
 * @head: list management
694
 * @fb: framebuffer to use for new config
695
 * @crtc: CRTC whose configuration we're about to change
696
 * @mode: mode timings to use
697
 * @x: position of this CRTC relative to @fb
698
 * @y: position of this CRTC relative to @fb
699
 * @connectors: array of connectors to drive with this CRTC if possible
700
 * @num_connectors: size of @connectors array
1408 serge 701
 *
702
 * Represents a single crtc the connectors that it drives with what mode
703
 * and from which framebuffer it scans out from.
704
 *
705
 * This is used to set modes.
706
 */
707
struct drm_mode_set {
708
	struct drm_framebuffer *fb;
709
	struct drm_crtc *crtc;
710
	struct drm_display_mode *mode;
711
 
712
	uint32_t x;
713
	uint32_t y;
714
 
715
	struct drm_connector **connectors;
716
	size_t num_connectors;
717
};
718
 
719
/**
2967 Serge 720
 * struct drm_mode_config_funcs - basic driver provided mode setting functions
721
 * @fb_create: create a new framebuffer object
722
 * @output_poll_changed: function to handle output configuration changes
723
 *
724
 * Some global (i.e. not per-CRTC, connector, etc) mode setting functions that
725
 * involve drivers.
1408 serge 726
 */
727
struct drm_mode_config_funcs {
2967 Serge 728
	struct drm_framebuffer *(*fb_create)(struct drm_device *dev,
729
					     struct drm_file *file_priv,
730
					     struct drm_mode_fb_cmd2 *mode_cmd);
1964 serge 731
	void (*output_poll_changed)(struct drm_device *dev);
1408 serge 732
};
733
 
2967 Serge 734
/**
735
 * drm_mode_group - group of mode setting resources for potential sub-grouping
736
 * @num_crtcs: CRTC count
737
 * @num_encoders: encoder count
738
 * @num_connectors: connector count
739
 * @id_list: list of KMS object IDs in this group
740
 *
741
 * Currently this simply tracks the global mode setting state.  But in the
742
 * future it could allow groups of objects to be set aside into independent
743
 * control groups for use by different user level processes (e.g. two X servers
744
 * running simultaneously on different heads, each with their own mode
745
 * configuration and freedom of mode setting).
746
 */
1408 serge 747
struct drm_mode_group {
748
	uint32_t num_crtcs;
749
	uint32_t num_encoders;
750
	uint32_t num_connectors;
751
 
752
	/* list of object IDs for this group */
753
	uint32_t *id_list;
754
};
755
 
756
/**
757
 * drm_mode_config - Mode configuration control structure
2967 Serge 758
 * @mutex: mutex protecting KMS related lists and structures
759
 * @idr_mutex: mutex for KMS ID allocation and management
760
 * @crtc_idr: main KMS ID tracking object
761
 * @num_fb: number of fbs available
762
 * @fb_list: list of framebuffers available
763
 * @num_connector: number of connectors on this device
764
 * @connector_list: list of connector objects
765
 * @num_encoder: number of encoders on this device
766
 * @encoder_list: list of encoder objects
767
 * @num_crtc: number of CRTCs on this device
768
 * @crtc_list: list of CRTC objects
769
 * @min_width: minimum pixel width on this device
770
 * @min_height: minimum pixel height on this device
771
 * @max_width: maximum pixel width on this device
772
 * @max_height: maximum pixel height on this device
773
 * @funcs: core driver provided mode setting functions
774
 * @fb_base: base address of the framebuffer
775
 * @poll_enabled: track polling status for this device
776
 * @output_poll_work: delayed work for polling in process context
777
 * @*_property: core property tracking
1408 serge 778
 *
2967 Serge 779
 * Core mode resource tracking structure.  All CRTC, encoders, and connectors
780
 * enumerated by the driver are added here, as are global properties.  Some
781
 * global restrictions are also here, e.g. dimension restrictions.
1408 serge 782
 */
783
struct drm_mode_config {
1630 serge 784
	struct mutex mutex; /* protects configuration (mode lists etc.) */
785
	struct mutex idr_mutex; /* for IDR management */
1408 serge 786
    struct idr crtc_idr; /* use this idr for all IDs, fb, crtc, connector, modes - just makes life easier */
787
	/* this is limited to one for now */
3391 Serge 788
 
789
 
790
	/**
791
	 * fb_lock - mutex to protect fb state
792
	 *
793
	 * Besides the global fb list his also protects the fbs list in the
794
	 * file_priv
795
	 */
796
	struct mutex fb_lock;
1408 serge 797
	int num_fb;
798
	struct list_head fb_list;
3391 Serge 799
 
1408 serge 800
	int num_connector;
801
	struct list_head connector_list;
802
	int num_encoder;
803
	struct list_head encoder_list;
2967 Serge 804
	int num_plane;
805
	struct list_head plane_list;
1408 serge 806
 
807
	int num_crtc;
808
	struct list_head crtc_list;
809
 
810
	struct list_head property_list;
811
 
812
	int min_width, min_height;
813
	int max_width, max_height;
3031 serge 814
	const struct drm_mode_config_funcs *funcs;
1408 serge 815
	resource_size_t fb_base;
816
 
1964 serge 817
	/* output poll support */
818
	bool poll_enabled;
3192 Serge 819
	bool poll_running;
1964 serge 820
//	struct delayed_work output_poll_work;
821
 
1408 serge 822
	/* pointers to standard properties */
823
	struct list_head property_blob_list;
824
	struct drm_property *edid_property;
825
	struct drm_property *dpms_property;
826
 
827
	/* DVI-I properties */
828
	struct drm_property *dvi_i_subconnector_property;
829
	struct drm_property *dvi_i_select_subconnector_property;
830
 
831
	/* TV properties */
832
	struct drm_property *tv_subconnector_property;
833
	struct drm_property *tv_select_subconnector_property;
834
	struct drm_property *tv_mode_property;
835
	struct drm_property *tv_left_margin_property;
836
	struct drm_property *tv_right_margin_property;
837
	struct drm_property *tv_top_margin_property;
838
	struct drm_property *tv_bottom_margin_property;
839
	struct drm_property *tv_brightness_property;
840
	struct drm_property *tv_contrast_property;
841
	struct drm_property *tv_flicker_reduction_property;
842
	struct drm_property *tv_overscan_property;
843
	struct drm_property *tv_saturation_property;
844
	struct drm_property *tv_hue_property;
845
 
846
	/* Optional properties */
847
	struct drm_property *scaling_mode_property;
848
	struct drm_property *dithering_mode_property;
849
	struct drm_property *dirty_info_property;
3031 serge 850
 
851
	/* dumb ioctl parameters */
852
	uint32_t preferred_depth, prefer_shadow;
1408 serge 853
};
854
 
855
#define obj_to_crtc(x) container_of(x, struct drm_crtc, base)
856
#define obj_to_connector(x) container_of(x, struct drm_connector, base)
857
#define obj_to_encoder(x) container_of(x, struct drm_encoder, base)
858
#define obj_to_mode(x) container_of(x, struct drm_display_mode, base)
859
#define obj_to_fb(x) container_of(x, struct drm_framebuffer, base)
860
#define obj_to_property(x) container_of(x, struct drm_property, base)
861
#define obj_to_blob(x) container_of(x, struct drm_property_blob, base)
2967 Serge 862
#define obj_to_plane(x) container_of(x, struct drm_plane, base)
1408 serge 863
 
3031 serge 864
struct drm_prop_enum_list {
865
	int type;
866
	char *name;
867
};
1408 serge 868
 
3391 Serge 869
extern void drm_modeset_lock_all(struct drm_device *dev);
870
extern void drm_modeset_unlock_all(struct drm_device *dev);
871
extern void drm_warn_on_modeset_not_all_locked(struct drm_device *dev);
872
 
3031 serge 873
extern int drm_crtc_init(struct drm_device *dev,
1408 serge 874
			  struct drm_crtc *crtc,
875
			  const struct drm_crtc_funcs *funcs);
876
extern void drm_crtc_cleanup(struct drm_crtc *crtc);
877
 
3031 serge 878
extern int drm_connector_init(struct drm_device *dev,
1408 serge 879
			    struct drm_connector *connector,
880
			    const struct drm_connector_funcs *funcs,
881
			    int connector_type);
882
 
883
extern void drm_connector_cleanup(struct drm_connector *connector);
3031 serge 884
/* helper to unplug all connectors from sysfs for device */
885
extern void drm_connector_unplug_all(struct drm_device *dev);
1408 serge 886
 
3031 serge 887
extern int drm_encoder_init(struct drm_device *dev,
1408 serge 888
			     struct drm_encoder *encoder,
889
			     const struct drm_encoder_funcs *funcs,
890
			     int encoder_type);
891
 
2967 Serge 892
extern int drm_plane_init(struct drm_device *dev,
893
			  struct drm_plane *plane,
894
			  unsigned long possible_crtcs,
895
			  const struct drm_plane_funcs *funcs,
896
			  const uint32_t *formats, uint32_t format_count,
897
			  bool priv);
898
extern void drm_plane_cleanup(struct drm_plane *plane);
899
 
1408 serge 900
extern void drm_encoder_cleanup(struct drm_encoder *encoder);
901
 
902
extern char *drm_get_connector_name(struct drm_connector *connector);
903
extern char *drm_get_dpms_name(int val);
904
extern char *drm_get_dvi_i_subconnector_name(int val);
905
extern char *drm_get_dvi_i_select_name(int val);
906
extern char *drm_get_tv_subconnector_name(int val);
907
extern char *drm_get_tv_select_name(int val);
1987 serge 908
extern void drm_fb_release(struct drm_file *file_priv);
1408 serge 909
extern int drm_mode_group_init_legacy_group(struct drm_device *dev, struct drm_mode_group *group);
3031 serge 910
extern bool drm_probe_ddc(struct i2c_adapter *adapter);
1408 serge 911
extern struct edid *drm_get_edid(struct drm_connector *connector,
912
				 struct i2c_adapter *adapter);
913
extern int drm_add_edid_modes(struct drm_connector *connector, struct edid *edid);
914
extern void drm_mode_probed_add(struct drm_connector *connector, struct drm_display_mode *mode);
915
extern void drm_mode_remove(struct drm_connector *connector, struct drm_display_mode *mode);
3031 serge 916
extern void drm_mode_copy(struct drm_display_mode *dst, const struct drm_display_mode *src);
1408 serge 917
extern struct drm_display_mode *drm_mode_duplicate(struct drm_device *dev,
1964 serge 918
						   const struct drm_display_mode *mode);
3192 Serge 919
extern void drm_mode_debug_printmodeline(const struct drm_display_mode *mode);
1408 serge 920
extern void drm_mode_config_init(struct drm_device *dev);
1964 serge 921
extern void drm_mode_config_reset(struct drm_device *dev);
1408 serge 922
extern void drm_mode_config_cleanup(struct drm_device *dev);
923
extern void drm_mode_set_name(struct drm_display_mode *mode);
3192 Serge 924
extern bool drm_mode_equal(const struct drm_display_mode *mode1, const struct drm_display_mode *mode2);
925
extern int drm_mode_width(const struct drm_display_mode *mode);
926
extern int drm_mode_height(const struct drm_display_mode *mode);
1408 serge 927
 
928
/* for us by fb module */
929
extern int drm_mode_attachmode_crtc(struct drm_device *dev,
930
				    struct drm_crtc *crtc,
3031 serge 931
				    const struct drm_display_mode *mode);
1408 serge 932
extern int drm_mode_detachmode_crtc(struct drm_device *dev, struct drm_display_mode *mode);
933
 
934
extern struct drm_display_mode *drm_mode_create(struct drm_device *dev);
935
extern void drm_mode_destroy(struct drm_device *dev, struct drm_display_mode *mode);
936
extern void drm_mode_list_concat(struct list_head *head,
937
                struct list_head *new);
938
extern void drm_mode_validate_size(struct drm_device *dev,
939
                  struct list_head *mode_list,
940
                  int maxX, int maxY, int maxPitch);
941
extern void drm_mode_prune_invalid(struct drm_device *dev,
942
                  struct list_head *mode_list, bool verbose);
943
extern void drm_mode_sort(struct list_head *mode_list);
1964 serge 944
extern int drm_mode_hsync(const struct drm_display_mode *mode);
945
extern int drm_mode_vrefresh(const struct drm_display_mode *mode);
1408 serge 946
extern void drm_mode_set_crtcinfo(struct drm_display_mode *p,
947
				  int adjust_flags);
948
extern void drm_mode_connector_list_update(struct drm_connector *connector);
949
extern int drm_mode_connector_update_edid_property(struct drm_connector *connector,
950
                       struct edid *edid);
3031 serge 951
extern int drm_object_property_set_value(struct drm_mode_object *obj,
952
					 struct drm_property *property,
953
					 uint64_t val);
954
extern int drm_object_property_get_value(struct drm_mode_object *obj,
955
					 struct drm_property *property,
956
					 uint64_t *value);
1408 serge 957
extern struct drm_display_mode *drm_crtc_mode_create(struct drm_device *dev);
958
extern void drm_framebuffer_set_object(struct drm_device *dev,
959
				       unsigned long handle);
960
extern int drm_framebuffer_init(struct drm_device *dev,
961
				struct drm_framebuffer *fb,
962
				const struct drm_framebuffer_funcs *funcs);
3391 Serge 963
extern struct drm_framebuffer *drm_framebuffer_lookup(struct drm_device *dev,
964
						      uint32_t id);
3031 serge 965
extern void drm_framebuffer_unreference(struct drm_framebuffer *fb);
966
extern void drm_framebuffer_reference(struct drm_framebuffer *fb);
967
extern void drm_framebuffer_remove(struct drm_framebuffer *fb);
1408 serge 968
extern void drm_framebuffer_cleanup(struct drm_framebuffer *fb);
3391 Serge 969
extern void drm_framebuffer_unregister_private(struct drm_framebuffer *fb);
1408 serge 970
extern int drmfb_probe(struct drm_device *dev, struct drm_crtc *crtc);
971
extern int drmfb_remove(struct drm_device *dev, struct drm_framebuffer *fb);
972
extern void drm_crtc_probe_connector_modes(struct drm_device *dev, int maxX, int maxY);
973
extern bool drm_crtc_in_use(struct drm_crtc *crtc);
974
 
3031 serge 975
extern void drm_object_attach_property(struct drm_mode_object *obj,
976
				       struct drm_property *property,
977
				       uint64_t init_val);
1408 serge 978
extern struct drm_property *drm_property_create(struct drm_device *dev, int flags,
979
						const char *name, int num_values);
3031 serge 980
extern struct drm_property *drm_property_create_enum(struct drm_device *dev, int flags,
981
					 const char *name,
982
					 const struct drm_prop_enum_list *props,
983
					 int num_values);
984
struct drm_property *drm_property_create_bitmask(struct drm_device *dev,
985
					 int flags, const char *name,
986
					 const struct drm_prop_enum_list *props,
987
					 int num_values);
988
struct drm_property *drm_property_create_range(struct drm_device *dev, int flags,
989
					 const char *name,
990
					 uint64_t min, uint64_t max);
1408 serge 991
extern void drm_property_destroy(struct drm_device *dev, struct drm_property *property);
992
extern int drm_property_add_enum(struct drm_property *property, int index,
993
				 uint64_t value, const char *name);
994
extern int drm_mode_create_dvi_i_properties(struct drm_device *dev);
995
extern int drm_mode_create_tv_properties(struct drm_device *dev, int num_formats,
996
				     char *formats[]);
997
extern int drm_mode_create_scaling_mode_property(struct drm_device *dev);
998
extern int drm_mode_create_dithering_property(struct drm_device *dev);
999
extern int drm_mode_create_dirty_info_property(struct drm_device *dev);
1000
extern char *drm_get_encoder_name(struct drm_encoder *encoder);
1001
 
1002
extern int drm_mode_connector_attach_encoder(struct drm_connector *connector,
1003
					     struct drm_encoder *encoder);
1004
extern void drm_mode_connector_detach_encoder(struct drm_connector *connector,
1005
					   struct drm_encoder *encoder);
3031 serge 1006
extern int drm_mode_crtc_set_gamma_size(struct drm_crtc *crtc,
1408 serge 1007
					 int gamma_size);
1008
extern struct drm_mode_object *drm_mode_object_find(struct drm_device *dev,
1009
		uint32_t id, uint32_t type);
1010
/* IOCTLs */
1011
extern int drm_mode_getresources(struct drm_device *dev,
1012
				 void *data, struct drm_file *file_priv);
2967 Serge 1013
extern int drm_mode_getplane_res(struct drm_device *dev, void *data,
1014
				   struct drm_file *file_priv);
1408 serge 1015
extern int drm_mode_getcrtc(struct drm_device *dev,
1016
			    void *data, struct drm_file *file_priv);
1017
extern int drm_mode_getconnector(struct drm_device *dev,
1018
			      void *data, struct drm_file *file_priv);
3391 Serge 1019
extern int drm_mode_set_config_internal(struct drm_mode_set *set);
1408 serge 1020
extern int drm_mode_setcrtc(struct drm_device *dev,
1021
			    void *data, struct drm_file *file_priv);
2967 Serge 1022
extern int drm_mode_getplane(struct drm_device *dev,
1023
			       void *data, struct drm_file *file_priv);
1024
extern int drm_mode_setplane(struct drm_device *dev,
1025
			       void *data, struct drm_file *file_priv);
1408 serge 1026
extern int drm_mode_cursor_ioctl(struct drm_device *dev,
1027
				void *data, struct drm_file *file_priv);
1028
extern int drm_mode_addfb(struct drm_device *dev,
1029
			  void *data, struct drm_file *file_priv);
2967 Serge 1030
extern int drm_mode_addfb2(struct drm_device *dev,
1031
			   void *data, struct drm_file *file_priv);
1032
extern uint32_t drm_mode_legacy_fb_format(uint32_t bpp, uint32_t depth);
1408 serge 1033
extern int drm_mode_rmfb(struct drm_device *dev,
1034
			 void *data, struct drm_file *file_priv);
1035
extern int drm_mode_getfb(struct drm_device *dev,
1036
			  void *data, struct drm_file *file_priv);
1037
extern int drm_mode_dirtyfb_ioctl(struct drm_device *dev,
1038
				  void *data, struct drm_file *file_priv);
1039
extern int drm_mode_addmode_ioctl(struct drm_device *dev,
1040
				  void *data, struct drm_file *file_priv);
1041
extern int drm_mode_rmmode_ioctl(struct drm_device *dev,
1042
				 void *data, struct drm_file *file_priv);
1043
extern int drm_mode_attachmode_ioctl(struct drm_device *dev,
1044
				     void *data, struct drm_file *file_priv);
1045
extern int drm_mode_detachmode_ioctl(struct drm_device *dev,
1046
				     void *data, struct drm_file *file_priv);
1047
 
1048
extern int drm_mode_getproperty_ioctl(struct drm_device *dev,
1049
				      void *data, struct drm_file *file_priv);
1050
extern int drm_mode_getblob_ioctl(struct drm_device *dev,
1051
				  void *data, struct drm_file *file_priv);
1052
extern int drm_mode_connector_property_set_ioctl(struct drm_device *dev,
1053
					      void *data, struct drm_file *file_priv);
1054
extern int drm_mode_hotplug_ioctl(struct drm_device *dev,
1055
				  void *data, struct drm_file *file_priv);
1056
extern int drm_mode_replacefb(struct drm_device *dev,
1057
			      void *data, struct drm_file *file_priv);
1058
extern int drm_mode_getencoder(struct drm_device *dev,
1059
			       void *data, struct drm_file *file_priv);
1060
extern int drm_mode_gamma_get_ioctl(struct drm_device *dev,
1061
				    void *data, struct drm_file *file_priv);
1062
extern int drm_mode_gamma_set_ioctl(struct drm_device *dev,
1063
				    void *data, struct drm_file *file_priv);
1964 serge 1064
extern u8 *drm_find_cea_extension(struct edid *edid);
3391 Serge 1065
extern u8 drm_match_cea_mode(const struct drm_display_mode *to_match);
1408 serge 1066
extern bool drm_detect_hdmi_monitor(struct edid *edid);
1964 serge 1067
extern bool drm_detect_monitor_audio(struct edid *edid);
3391 Serge 1068
extern bool drm_rgb_quant_range_selectable(struct edid *edid);
1408 serge 1069
extern int drm_mode_page_flip_ioctl(struct drm_device *dev,
1070
				    void *data, struct drm_file *file_priv);
1071
extern struct drm_display_mode *drm_cvt_mode(struct drm_device *dev,
1072
				int hdisplay, int vdisplay, int vrefresh,
1073
				bool reduced, bool interlaced, bool margins);
1074
extern struct drm_display_mode *drm_gtf_mode(struct drm_device *dev,
1075
				int hdisplay, int vdisplay, int vrefresh,
1076
				bool interlaced, int margins);
1964 serge 1077
extern struct drm_display_mode *drm_gtf_mode_complex(struct drm_device *dev,
1078
				int hdisplay, int vdisplay, int vrefresh,
1079
				bool interlaced, int margins, int GTF_M,
1080
				int GTF_2C, int GTF_K, int GTF_2J);
1408 serge 1081
extern int drm_add_modes_noedid(struct drm_connector *connector,
1082
				int hdisplay, int vdisplay);
1430 serge 1083
 
2161 serge 1084
extern int drm_edid_header_is_valid(const u8 *raw_edid);
3031 serge 1085
extern bool drm_edid_block_valid(u8 *raw_edid, int block, bool print_bad_edid);
1430 serge 1086
extern bool drm_edid_is_valid(struct edid *edid);
1964 serge 1087
struct drm_display_mode *drm_mode_find_dmt(struct drm_device *dev,
3031 serge 1088
					   int hsize, int vsize, int fresh,
1089
					   bool rb);
1090
 
1091
extern int drm_mode_create_dumb_ioctl(struct drm_device *dev,
1092
				      void *data, struct drm_file *file_priv);
1093
extern int drm_mode_mmap_dumb_ioctl(struct drm_device *dev,
1094
				    void *data, struct drm_file *file_priv);
1095
extern int drm_mode_destroy_dumb_ioctl(struct drm_device *dev,
1096
				      void *data, struct drm_file *file_priv);
1097
extern int drm_mode_obj_get_properties_ioctl(struct drm_device *dev, void *data,
1098
					     struct drm_file *file_priv);
1099
extern int drm_mode_obj_set_property_ioctl(struct drm_device *dev, void *data,
1100
					   struct drm_file *file_priv);
1101
 
1102
extern void drm_fb_get_bpp_depth(uint32_t format, unsigned int *depth,
1103
				 int *bpp);
1104
extern int drm_format_num_planes(uint32_t format);
1105
extern int drm_format_plane_cpp(uint32_t format, int plane);
1106
extern int drm_format_horz_chroma_subsampling(uint32_t format);
1107
extern int drm_format_vert_chroma_subsampling(uint32_t format);
1108
 
1408 serge 1109
#endif /* __DRM_CRTC_H__ */