1/*
  2 * Copyright © 2006 Keith Packard
  3 * Copyright © 2007-2008 Dave Airlie
  4 * Copyright © 2007-2008 Intel Corporation
  5 *   Jesse Barnes <jesse.barnes@intel.com>
  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 <linux/i2c.h>
 29#include <linux/spinlock.h>
 30#include <linux/types.h>
 31#include <linux/idr.h>
 32
 33#include <linux/fb.h>
 34
 
 
 35struct drm_device;
 36struct drm_mode_set;
 37struct drm_framebuffer;
 
 38
 39
 40#define DRM_MODE_OBJECT_CRTC 0xcccccccc
 41#define DRM_MODE_OBJECT_CONNECTOR 0xc0c0c0c0
 42#define DRM_MODE_OBJECT_ENCODER 0xe0e0e0e0
 43#define DRM_MODE_OBJECT_MODE 0xdededede
 44#define DRM_MODE_OBJECT_PROPERTY 0xb0b0b0b0
 45#define DRM_MODE_OBJECT_FB 0xfbfbfbfb
 46#define DRM_MODE_OBJECT_BLOB 0xbbbbbbbb
 
 47
 48struct drm_mode_object {
 49	uint32_t id;
 50	uint32_t type;
 
 
 
 
 
 
 
 
 51};
 52
 53/*
 54 * Note on terminology:  here, for brevity and convenience, we refer to connector
 55 * control chips as 'CRTCs'.  They can control any type of connector, VGA, LVDS,
 56 * DVI, etc.  And 'screen' refers to the whole of the visible display, which
 57 * may span multiple monitors (and therefore multiple CRTC and connector
 58 * structures).
 59 */
 60
 61enum drm_mode_status {
 62    MODE_OK	= 0,	/* Mode OK */
 63    MODE_HSYNC,		/* hsync out of range */
 64    MODE_VSYNC,		/* vsync out of range */
 65    MODE_H_ILLEGAL,	/* mode has illegal horizontal timings */
 66    MODE_V_ILLEGAL,	/* mode has illegal horizontal timings */
 67    MODE_BAD_WIDTH,	/* requires an unsupported linepitch */
 68    MODE_NOMODE,	/* no mode with a matching name */
 69    MODE_NO_INTERLACE,	/* interlaced mode not supported */
 70    MODE_NO_DBLESCAN,	/* doublescan mode not supported */
 71    MODE_NO_VSCAN,	/* multiscan mode not supported */
 72    MODE_MEM,		/* insufficient video memory */
 73    MODE_VIRTUAL_X,	/* mode width too large for specified virtual size */
 74    MODE_VIRTUAL_Y,	/* mode height too large for specified virtual size */
 75    MODE_MEM_VIRT,	/* insufficient video memory given virtual size */
 76    MODE_NOCLOCK,	/* no fixed clock available */
 77    MODE_CLOCK_HIGH,	/* clock required is too high */
 78    MODE_CLOCK_LOW,	/* clock required is too low */
 79    MODE_CLOCK_RANGE,	/* clock/mode isn't in a ClockRange */
 80    MODE_BAD_HVALUE,	/* horizontal timing was out of range */
 81    MODE_BAD_VVALUE,	/* vertical timing was out of range */
 82    MODE_BAD_VSCAN,	/* VScan value out of range */
 83    MODE_HSYNC_NARROW,	/* horizontal sync too narrow */
 84    MODE_HSYNC_WIDE,	/* horizontal sync too wide */
 85    MODE_HBLANK_NARROW,	/* horizontal blanking too narrow */
 86    MODE_HBLANK_WIDE,	/* horizontal blanking too wide */
 87    MODE_VSYNC_NARROW,	/* vertical sync too narrow */
 88    MODE_VSYNC_WIDE,	/* vertical sync too wide */
 89    MODE_VBLANK_NARROW,	/* vertical blanking too narrow */
 90    MODE_VBLANK_WIDE,	/* vertical blanking too wide */
 91    MODE_PANEL,         /* exceeds panel dimensions */
 92    MODE_INTERLACE_WIDTH, /* width too large for interlaced mode */
 93    MODE_ONE_WIDTH,     /* only one width is supported */
 94    MODE_ONE_HEIGHT,    /* only one height is supported */
 95    MODE_ONE_SIZE,      /* only one resolution is supported */
 96    MODE_NO_REDUCED,    /* monitor doesn't accept reduced blanking */
 97    MODE_UNVERIFIED = -3, /* mode needs to reverified */
 98    MODE_BAD = -2,	/* unspecified reason */
 99    MODE_ERROR	= -1	/* error condition */
100};
101
102#define DRM_MODE_TYPE_CLOCK_CRTC_C (DRM_MODE_TYPE_CLOCK_C | \
103				    DRM_MODE_TYPE_CRTC_C)
104
105#define DRM_MODE(nm, t, c, hd, hss, hse, ht, hsk, vd, vss, vse, vt, vs, f) \
106	.name = nm, .status = 0, .type = (t), .clock = (c), \
107	.hdisplay = (hd), .hsync_start = (hss), .hsync_end = (hse), \
108	.htotal = (ht), .hskew = (hsk), .vdisplay = (vd), \
109	.vsync_start = (vss), .vsync_end = (vse), .vtotal = (vt), \
110	.vscan = (vs), .flags = (f), .vrefresh = 0
111
112#define CRTC_INTERLACE_HALVE_V 0x1 /* halve V values for interlacing */
113
114struct drm_display_mode {
115	/* Header */
116	struct list_head head;
117	struct drm_mode_object base;
118
119	char name[DRM_DISPLAY_MODE_LEN];
120
121	int connector_count;
122	enum drm_mode_status status;
123	int type;
124
125	/* Proposed mode values */
126	int clock;		/* in kHz */
127	int hdisplay;
128	int hsync_start;
129	int hsync_end;
130	int htotal;
131	int hskew;
132	int vdisplay;
133	int vsync_start;
134	int vsync_end;
135	int vtotal;
136	int vscan;
137	unsigned int flags;
138
139	/* Addressable image size (may be 0 for projectors, etc.) */
140	int width_mm;
141	int height_mm;
142
143	/* Actual mode we give to hw */
144	int clock_index;
145	int synth_clock;
146	int crtc_hdisplay;
147	int crtc_hblank_start;
148	int crtc_hblank_end;
149	int crtc_hsync_start;
150	int crtc_hsync_end;
151	int crtc_htotal;
152	int crtc_hskew;
153	int crtc_vdisplay;
154	int crtc_vblank_start;
155	int crtc_vblank_end;
156	int crtc_vsync_start;
157	int crtc_vsync_end;
158	int crtc_vtotal;
159	int crtc_hadjusted;
160	int crtc_vadjusted;
161
162	/* Driver private mode info */
163	int private_size;
164	int *private;
165	int private_flags;
166
167	int vrefresh;		/* in Hz */
168	int hsync;		/* in kHz */
169};
170
171enum drm_connector_status {
172	connector_status_connected = 1,
173	connector_status_disconnected = 2,
174	connector_status_unknown = 3,
175};
176
177enum subpixel_order {
178	SubPixelUnknown = 0,
179	SubPixelHorizontalRGB,
180	SubPixelHorizontalBGR,
181	SubPixelVerticalRGB,
182	SubPixelVerticalBGR,
183	SubPixelNone,
184};
185
186#define DRM_COLOR_FORMAT_RGB444		(1<<0)
187#define DRM_COLOR_FORMAT_YCRCB444	(1<<1)
188#define DRM_COLOR_FORMAT_YCRCB422	(1<<2)
189/*
190 * Describes a given display (e.g. CRT or flat panel) and its limitations.
191 */
192struct drm_display_info {
193	char name[DRM_DISPLAY_INFO_LEN];
194
195	/* Physical size */
196        unsigned int width_mm;
197	unsigned int height_mm;
198
199	/* Clock limits FIXME: storage format */
200	unsigned int min_vfreq, max_vfreq;
201	unsigned int min_hfreq, max_hfreq;
202	unsigned int pixel_clock;
203	unsigned int bpc;
204
205	enum subpixel_order subpixel_order;
206	u32 color_formats;
207
208	u8 cea_rev;
209
210	char *raw_edid; /* if any */
211};
212
213struct drm_framebuffer_funcs {
214	void (*destroy)(struct drm_framebuffer *framebuffer);
215	int (*create_handle)(struct drm_framebuffer *fb,
216			     struct drm_file *file_priv,
217			     unsigned int *handle);
218	/**
219	 * Optinal callback for the dirty fb ioctl.
220	 *
221	 * Userspace can notify the driver via this callback
222	 * that a area of the framebuffer has changed and should
223	 * be flushed to the display hardware.
224	 *
225	 * See documentation in drm_mode.h for the struct
226	 * drm_mode_fb_dirty_cmd for more information as all
227	 * the semantics and arguments have a one to one mapping
228	 * on this function.
229	 */
230	int (*dirty)(struct drm_framebuffer *framebuffer,
231		     struct drm_file *file_priv, unsigned flags,
232		     unsigned color, struct drm_clip_rect *clips,
233		     unsigned num_clips);
234};
235
236struct drm_framebuffer {
237	struct drm_device *dev;
238	struct list_head head;
239	struct drm_mode_object base;
240	const struct drm_framebuffer_funcs *funcs;
241	unsigned int pitch;
 
242	unsigned int width;
243	unsigned int height;
244	/* depth can be 15 or 16 */
245	unsigned int depth;
246	int bits_per_pixel;
247	int flags;
 
248	struct list_head filp_head;
249	/* if you are using the helper */
250	void *helper_private;
251};
252
253struct drm_property_blob {
254	struct drm_mode_object base;
255	struct list_head head;
256	unsigned int length;
257	void *data;
258};
259
260struct drm_property_enum {
261	uint64_t value;
262	struct list_head head;
263	char name[DRM_PROP_NAME_LEN];
264};
265
266struct drm_property {
267	struct list_head head;
268	struct drm_mode_object base;
269	uint32_t flags;
270	char name[DRM_PROP_NAME_LEN];
271	uint32_t num_values;
272	uint64_t *values;
273
274	struct list_head enum_blob_list;
275};
276
277struct drm_crtc;
278struct drm_connector;
279struct drm_encoder;
280struct drm_pending_vblank_event;
 
281
282/**
283 * drm_crtc_funcs - control CRTCs for a given device
284 * @reset: reset CRTC after state has been invalidate (e.g. resume)
285 * @dpms: control display power levels
286 * @save: save CRTC state
287 * @resore: restore CRTC state
288 * @lock: lock the CRTC
289 * @unlock: unlock the CRTC
290 * @shadow_allocate: allocate shadow pixmap
291 * @shadow_create: create shadow pixmap for rotation support
292 * @shadow_destroy: free shadow pixmap
293 * @mode_fixup: fixup proposed mode
294 * @mode_set: set the desired mode on the CRTC
295 * @gamma_set: specify color ramp for CRTC
296 * @destroy: deinit and free object.
 
 
 
297 *
298 * The drm_crtc_funcs structure is the central CRTC management structure
299 * in the DRM.  Each CRTC controls one or more connectors (note that the name
300 * CRTC is simply historical, a CRTC may control LVDS, VGA, DVI, TV out, etc.
301 * connectors, not just CRTs).
302 *
303 * Each driver is responsible for filling out this structure at startup time,
304 * in addition to providing other modesetting features, like i2c and DDC
305 * bus accessors.
306 */
307struct drm_crtc_funcs {
308	/* Save CRTC state */
309	void (*save)(struct drm_crtc *crtc); /* suspend? */
310	/* Restore CRTC state */
311	void (*restore)(struct drm_crtc *crtc); /* resume? */
312	/* Reset CRTC state */
313	void (*reset)(struct drm_crtc *crtc);
314
315	/* cursor controls */
316	int (*cursor_set)(struct drm_crtc *crtc, struct drm_file *file_priv,
317			  uint32_t handle, uint32_t width, uint32_t height);
318	int (*cursor_move)(struct drm_crtc *crtc, int x, int y);
319
320	/* Set gamma on the CRTC */
321	void (*gamma_set)(struct drm_crtc *crtc, u16 *r, u16 *g, u16 *b,
322			  uint32_t start, uint32_t size);
323	/* Object destroy routine */
324	void (*destroy)(struct drm_crtc *crtc);
325
326	int (*set_config)(struct drm_mode_set *set);
327
328	/*
329	 * Flip to the given framebuffer.  This implements the page
330	 * flip ioctl described in drm_mode.h, specifically, the
331	 * implementation must return immediately and block all
332	 * rendering to the current fb until the flip has completed.
333	 * If userspace set the event flag in the ioctl, the event
334	 * argument will point to an event to send back when the flip
335	 * completes, otherwise it will be NULL.
336	 */
337	int (*page_flip)(struct drm_crtc *crtc,
338			 struct drm_framebuffer *fb,
339			 struct drm_pending_vblank_event *event);
 
 
 
340};
341
342/**
343 * drm_crtc - central CRTC control structure
 
 
 
344 * @enabled: is this CRTC enabled?
 
 
345 * @x: x position on screen
346 * @y: y position on screen
347 * @funcs: CRTC control functions
 
 
 
 
 
 
 
348 *
349 * Each CRTC may have one or more connectors associated with it.  This structure
350 * allows the CRTC to be controlled.
351 */
352struct drm_crtc {
353	struct drm_device *dev;
354	struct list_head head;
355
356	struct drm_mode_object base;
357
358	/* framebuffer the connector is currently bound to */
359	struct drm_framebuffer *fb;
360
361	bool enabled;
362
363	/* Requested mode from modesetting. */
364	struct drm_display_mode mode;
365
366	/* Programmed mode in hw, after adjustments for encoders,
367	 * crtc, panel scaling etc. Needed for timestamping etc.
368	 */
369	struct drm_display_mode hwmode;
370
371	int x, y;
372	const struct drm_crtc_funcs *funcs;
373
374	/* CRTC gamma size for reporting to userspace */
375	uint32_t gamma_size;
376	uint16_t *gamma_store;
377
378	/* Constants needed for precise vblank and swap timestamping. */
379	s64 framedur_ns, linedur_ns, pixeldur_ns;
380
381	/* if you are using the helper */
382	void *helper_private;
 
 
383};
384
385
386/**
387 * drm_connector_funcs - control connectors on a given device
388 * @dpms: set power state (see drm_crtc_funcs above)
389 * @save: save connector state
390 * @restore: restore connector state
391 * @reset: reset connector after state has been invalidate (e.g. resume)
392 * @mode_valid: is this mode valid on the given connector?
393 * @mode_fixup: try to fixup proposed mode for this connector
394 * @mode_set: set this mode
395 * @detect: is this connector active?
396 * @get_modes: get mode list for this connector
397 * @set_property: property for this connector may need update
398 * @destroy: make object go away
399 * @force: notify the driver the connector is forced on
400 *
401 * Each CRTC may have one or more connectors attached to it.  The functions
402 * below allow the core DRM code to control connectors, enumerate available modes,
403 * etc.
404 */
405struct drm_connector_funcs {
406	void (*dpms)(struct drm_connector *connector, int mode);
407	void (*save)(struct drm_connector *connector);
408	void (*restore)(struct drm_connector *connector);
409	void (*reset)(struct drm_connector *connector);
410
411	/* Check to see if anything is attached to the connector.
412	 * @force is set to false whilst polling, true when checking the
413	 * connector due to user request. @force can be used by the driver
414	 * to avoid expensive, destructive operations during automated
415	 * probing.
416	 */
417	enum drm_connector_status (*detect)(struct drm_connector *connector,
418					    bool force);
419	int (*fill_modes)(struct drm_connector *connector, uint32_t max_width, uint32_t max_height);
420	int (*set_property)(struct drm_connector *connector, struct drm_property *property,
421			     uint64_t val);
422	void (*destroy)(struct drm_connector *connector);
423	void (*force)(struct drm_connector *connector);
424};
425
 
 
 
 
 
 
 
426struct drm_encoder_funcs {
427	void (*reset)(struct drm_encoder *encoder);
428	void (*destroy)(struct drm_encoder *encoder);
429};
430
431#define DRM_CONNECTOR_MAX_UMODES 16
432#define DRM_CONNECTOR_MAX_PROPERTY 16
433#define DRM_CONNECTOR_LEN 32
434#define DRM_CONNECTOR_MAX_ENCODER 2
435
436/**
437 * drm_encoder - central DRM encoder structure
 
 
 
 
 
 
 
 
 
 
 
 
438 */
439struct drm_encoder {
440	struct drm_device *dev;
441	struct list_head head;
442
443	struct drm_mode_object base;
444	int encoder_type;
445	uint32_t possible_crtcs;
446	uint32_t possible_clones;
447
448	struct drm_crtc *crtc;
449	const struct drm_encoder_funcs *funcs;
450	void *helper_private;
451};
452
453enum drm_connector_force {
454	DRM_FORCE_UNSPECIFIED,
455	DRM_FORCE_OFF,
456	DRM_FORCE_ON,         /* force on analog part normally */
457	DRM_FORCE_ON_DIGITAL, /* for DVI-I use digital connector */
458};
459
460/* should we poll this connector for connects and disconnects */
461/* hot plug detectable */
462#define DRM_CONNECTOR_POLL_HPD (1 << 0)
463/* poll for connections */
464#define DRM_CONNECTOR_POLL_CONNECT (1 << 1)
465/* can cleanly poll for disconnections without flickering the screen */
466/* DACs should rarely do this without a lot of testing */
467#define DRM_CONNECTOR_POLL_DISCONNECT (1 << 2)
468
 
 
469/**
470 * drm_connector - central DRM connector control structure
471 * @crtc: CRTC this connector is currently connected to, NULL if none
 
 
 
 
 
 
472 * @interlace_allowed: can this connector handle interlaced modes?
473 * @doublescan_allowed: can this connector handle doublescan?
474 * @available_modes: modes available on this connector (from get_modes() + user)
475 * @initial_x: initial x position for this connector
476 * @initial_y: initial y position for this connector
477 * @status: connector connected?
478 * @funcs: connector control functions
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
479 *
480 * Each connector may be connected to one or more CRTCs, or may be clonable by
481 * another connector if they can share a CRTC.  Each connector also has a specific
482 * position in the broader display (referred to as a 'screen' though it could
483 * span multiple monitors).
484 */
485struct drm_connector {
486	struct drm_device *dev;
487	struct device kdev;
488	struct device_attribute *attr;
489	struct list_head head;
490
491	struct drm_mode_object base;
492
493	int connector_type;
494	int connector_type_id;
495	bool interlace_allowed;
496	bool doublescan_allowed;
497	struct list_head modes; /* list of modes on this connector */
498
499	int initial_x, initial_y;
500	enum drm_connector_status status;
501
502	/* these are modes added by probing with DDC or the BIOS */
503	struct list_head probed_modes;
504
505	struct drm_display_info display_info;
506	const struct drm_connector_funcs *funcs;
507
508	struct list_head user_modes;
509	struct drm_property_blob *edid_blob_ptr;
510	u32 property_ids[DRM_CONNECTOR_MAX_PROPERTY];
511	uint64_t property_values[DRM_CONNECTOR_MAX_PROPERTY];
512
513	uint8_t polled; /* DRM_CONNECTOR_POLL_* */
514
515	/* requested DPMS state */
516	int dpms;
517
518	void *helper_private;
519
520	/* forced on connector */
521	enum drm_connector_force force;
522	uint32_t encoder_ids[DRM_CONNECTOR_MAX_ENCODER];
523	uint32_t force_encoder_id;
524	struct drm_encoder *encoder; /* currently active encoder */
525
 
 
 
 
 
 
 
526	int null_edid_counter; /* needed to workaround some HW bugs where we get all 0s */
527};
528
529/**
530 * struct drm_mode_set
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
531 *
532 * Represents a single crtc the connectors that it drives with what mode
533 * and from which framebuffer it scans out from.
534 *
535 * This is used to set modes.
536 */
537struct drm_mode_set {
538	struct list_head head;
539
540	struct drm_framebuffer *fb;
541	struct drm_crtc *crtc;
542	struct drm_display_mode *mode;
543
544	uint32_t x;
545	uint32_t y;
546
547	struct drm_connector **connectors;
548	size_t num_connectors;
549};
550
551/**
552 * struct drm_mode_config_funcs - configure CRTCs for a given screen layout
 
 
 
 
 
553 */
554struct drm_mode_config_funcs {
555	struct drm_framebuffer *(*fb_create)(struct drm_device *dev, struct drm_file *file_priv, struct drm_mode_fb_cmd *mode_cmd);
 
 
556	void (*output_poll_changed)(struct drm_device *dev);
557};
558
 
 
 
 
 
 
 
 
 
 
 
 
 
559struct drm_mode_group {
560	uint32_t num_crtcs;
561	uint32_t num_encoders;
562	uint32_t num_connectors;
563
564	/* list of object IDs for this group */
565	uint32_t *id_list;
566};
567
568/**
569 * drm_mode_config - Mode configuration control structure
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
570 *
 
 
 
571 */
572struct drm_mode_config {
573	struct mutex mutex; /* protects configuration (mode lists etc.) */
574	struct mutex idr_mutex; /* for IDR management */
575	struct idr crtc_idr; /* use this idr for all IDs, fb, crtc, connector, modes - just makes life easier */
576	/* this is limited to one for now */
577	int num_fb;
578	struct list_head fb_list;
579	int num_connector;
580	struct list_head connector_list;
581	int num_encoder;
582	struct list_head encoder_list;
 
 
583
584	int num_crtc;
585	struct list_head crtc_list;
586
587	struct list_head property_list;
588
589	int min_width, min_height;
590	int max_width, max_height;
591	struct drm_mode_config_funcs *funcs;
592	resource_size_t fb_base;
593
594	/* output poll support */
595	bool poll_enabled;
596	struct delayed_work output_poll_work;
597
598	/* pointers to standard properties */
599	struct list_head property_blob_list;
600	struct drm_property *edid_property;
601	struct drm_property *dpms_property;
602
603	/* DVI-I properties */
604	struct drm_property *dvi_i_subconnector_property;
605	struct drm_property *dvi_i_select_subconnector_property;
606
607	/* TV properties */
608	struct drm_property *tv_subconnector_property;
609	struct drm_property *tv_select_subconnector_property;
610	struct drm_property *tv_mode_property;
611	struct drm_property *tv_left_margin_property;
612	struct drm_property *tv_right_margin_property;
613	struct drm_property *tv_top_margin_property;
614	struct drm_property *tv_bottom_margin_property;
615	struct drm_property *tv_brightness_property;
616	struct drm_property *tv_contrast_property;
617	struct drm_property *tv_flicker_reduction_property;
618	struct drm_property *tv_overscan_property;
619	struct drm_property *tv_saturation_property;
620	struct drm_property *tv_hue_property;
621
622	/* Optional properties */
623	struct drm_property *scaling_mode_property;
624	struct drm_property *dithering_mode_property;
625	struct drm_property *dirty_info_property;
 
 
 
626};
627
628#define obj_to_crtc(x) container_of(x, struct drm_crtc, base)
629#define obj_to_connector(x) container_of(x, struct drm_connector, base)
630#define obj_to_encoder(x) container_of(x, struct drm_encoder, base)
631#define obj_to_mode(x) container_of(x, struct drm_display_mode, base)
632#define obj_to_fb(x) container_of(x, struct drm_framebuffer, base)
633#define obj_to_property(x) container_of(x, struct drm_property, base)
634#define obj_to_blob(x) container_of(x, struct drm_property_blob, base)
 
635
 
 
 
 
636
637extern void drm_crtc_init(struct drm_device *dev,
638			  struct drm_crtc *crtc,
639			  const struct drm_crtc_funcs *funcs);
640extern void drm_crtc_cleanup(struct drm_crtc *crtc);
641
642extern void drm_connector_init(struct drm_device *dev,
643			    struct drm_connector *connector,
644			    const struct drm_connector_funcs *funcs,
645			    int connector_type);
646
647extern void drm_connector_cleanup(struct drm_connector *connector);
 
 
648
649extern void drm_encoder_init(struct drm_device *dev,
650			     struct drm_encoder *encoder,
651			     const struct drm_encoder_funcs *funcs,
652			     int encoder_type);
 
 
 
 
 
 
 
 
653
654extern void drm_encoder_cleanup(struct drm_encoder *encoder);
655
656extern char *drm_get_connector_name(struct drm_connector *connector);
657extern char *drm_get_dpms_name(int val);
658extern char *drm_get_dvi_i_subconnector_name(int val);
659extern char *drm_get_dvi_i_select_name(int val);
660extern char *drm_get_tv_subconnector_name(int val);
661extern char *drm_get_tv_select_name(int val);
662extern void drm_fb_release(struct drm_file *file_priv);
663extern int drm_mode_group_init_legacy_group(struct drm_device *dev, struct drm_mode_group *group);
664extern struct edid *drm_get_edid(struct drm_connector *connector,
665				 struct i2c_adapter *adapter);
666extern int drm_add_edid_modes(struct drm_connector *connector, struct edid *edid);
667extern void drm_mode_probed_add(struct drm_connector *connector, struct drm_display_mode *mode);
668extern void drm_mode_remove(struct drm_connector *connector, struct drm_display_mode *mode);
 
669extern struct drm_display_mode *drm_mode_duplicate(struct drm_device *dev,
670						   const struct drm_display_mode *mode);
671extern void drm_mode_debug_printmodeline(struct drm_display_mode *mode);
672extern void drm_mode_config_init(struct drm_device *dev);
673extern void drm_mode_config_reset(struct drm_device *dev);
674extern void drm_mode_config_cleanup(struct drm_device *dev);
675extern void drm_mode_set_name(struct drm_display_mode *mode);
676extern bool drm_mode_equal(struct drm_display_mode *mode1, struct drm_display_mode *mode2);
677extern int drm_mode_width(struct drm_display_mode *mode);
678extern int drm_mode_height(struct drm_display_mode *mode);
679
680/* for us by fb module */
681extern int drm_mode_attachmode_crtc(struct drm_device *dev,
682				    struct drm_crtc *crtc,
683				    struct drm_display_mode *mode);
684extern int drm_mode_detachmode_crtc(struct drm_device *dev, struct drm_display_mode *mode);
685
686extern struct drm_display_mode *drm_mode_create(struct drm_device *dev);
687extern void drm_mode_destroy(struct drm_device *dev, struct drm_display_mode *mode);
688extern void drm_mode_list_concat(struct list_head *head,
689				 struct list_head *new);
690extern void drm_mode_validate_size(struct drm_device *dev,
691				   struct list_head *mode_list,
692				   int maxX, int maxY, int maxPitch);
693extern void drm_mode_prune_invalid(struct drm_device *dev,
694				   struct list_head *mode_list, bool verbose);
695extern void drm_mode_sort(struct list_head *mode_list);
696extern int drm_mode_hsync(const struct drm_display_mode *mode);
697extern int drm_mode_vrefresh(const struct drm_display_mode *mode);
698extern void drm_mode_set_crtcinfo(struct drm_display_mode *p,
699				  int adjust_flags);
700extern void drm_mode_connector_list_update(struct drm_connector *connector);
701extern int drm_mode_connector_update_edid_property(struct drm_connector *connector,
702						struct edid *edid);
703extern int drm_connector_property_set_value(struct drm_connector *connector,
704					 struct drm_property *property,
705					 uint64_t value);
706extern int drm_connector_property_get_value(struct drm_connector *connector,
707					 struct drm_property *property,
708					 uint64_t *value);
 
 
 
 
 
 
709extern struct drm_display_mode *drm_crtc_mode_create(struct drm_device *dev);
710extern void drm_framebuffer_set_object(struct drm_device *dev,
711				       unsigned long handle);
712extern int drm_framebuffer_init(struct drm_device *dev,
713				struct drm_framebuffer *fb,
714				const struct drm_framebuffer_funcs *funcs);
715extern void drm_framebuffer_cleanup(struct drm_framebuffer *fb);
716extern int drmfb_probe(struct drm_device *dev, struct drm_crtc *crtc);
717extern int drmfb_remove(struct drm_device *dev, struct drm_framebuffer *fb);
718extern void drm_crtc_probe_connector_modes(struct drm_device *dev, int maxX, int maxY);
719extern bool drm_crtc_in_use(struct drm_crtc *crtc);
720
721extern int drm_connector_attach_property(struct drm_connector *connector,
722				      struct drm_property *property, uint64_t init_val);
 
 
 
723extern struct drm_property *drm_property_create(struct drm_device *dev, int flags,
724						const char *name, int num_values);
 
 
 
 
 
 
 
 
 
 
 
725extern void drm_property_destroy(struct drm_device *dev, struct drm_property *property);
726extern int drm_property_add_enum(struct drm_property *property, int index,
727				 uint64_t value, const char *name);
728extern int drm_mode_create_dvi_i_properties(struct drm_device *dev);
729extern int drm_mode_create_tv_properties(struct drm_device *dev, int num_formats,
730				     char *formats[]);
731extern int drm_mode_create_scaling_mode_property(struct drm_device *dev);
732extern int drm_mode_create_dithering_property(struct drm_device *dev);
733extern int drm_mode_create_dirty_info_property(struct drm_device *dev);
734extern char *drm_get_encoder_name(struct drm_encoder *encoder);
735
736extern int drm_mode_connector_attach_encoder(struct drm_connector *connector,
737					     struct drm_encoder *encoder);
738extern void drm_mode_connector_detach_encoder(struct drm_connector *connector,
739					   struct drm_encoder *encoder);
740extern bool drm_mode_crtc_set_gamma_size(struct drm_crtc *crtc,
741					 int gamma_size);
742extern struct drm_mode_object *drm_mode_object_find(struct drm_device *dev,
743		uint32_t id, uint32_t type);
744/* IOCTLs */
745extern int drm_mode_getresources(struct drm_device *dev,
746				 void *data, struct drm_file *file_priv);
747
 
748extern int drm_mode_getcrtc(struct drm_device *dev,
749			    void *data, struct drm_file *file_priv);
750extern int drm_mode_getconnector(struct drm_device *dev,
751			      void *data, struct drm_file *file_priv);
752extern int drm_mode_setcrtc(struct drm_device *dev,
753			    void *data, struct drm_file *file_priv);
 
 
 
 
754extern int drm_mode_cursor_ioctl(struct drm_device *dev,
755				void *data, struct drm_file *file_priv);
756extern int drm_mode_addfb(struct drm_device *dev,
757			  void *data, struct drm_file *file_priv);
 
 
 
758extern int drm_mode_rmfb(struct drm_device *dev,
759			 void *data, struct drm_file *file_priv);
760extern int drm_mode_getfb(struct drm_device *dev,
761			  void *data, struct drm_file *file_priv);
762extern int drm_mode_dirtyfb_ioctl(struct drm_device *dev,
763				  void *data, struct drm_file *file_priv);
764extern int drm_mode_addmode_ioctl(struct drm_device *dev,
765				  void *data, struct drm_file *file_priv);
766extern int drm_mode_rmmode_ioctl(struct drm_device *dev,
767				 void *data, struct drm_file *file_priv);
768extern int drm_mode_attachmode_ioctl(struct drm_device *dev,
769				     void *data, struct drm_file *file_priv);
770extern int drm_mode_detachmode_ioctl(struct drm_device *dev,
771				     void *data, struct drm_file *file_priv);
772
773extern int drm_mode_getproperty_ioctl(struct drm_device *dev,
774				      void *data, struct drm_file *file_priv);
775extern int drm_mode_getblob_ioctl(struct drm_device *dev,
776				  void *data, struct drm_file *file_priv);
777extern int drm_mode_connector_property_set_ioctl(struct drm_device *dev,
778					      void *data, struct drm_file *file_priv);
779extern int drm_mode_hotplug_ioctl(struct drm_device *dev,
780				  void *data, struct drm_file *file_priv);
781extern int drm_mode_replacefb(struct drm_device *dev,
782			      void *data, struct drm_file *file_priv);
783extern int drm_mode_getencoder(struct drm_device *dev,
784			       void *data, struct drm_file *file_priv);
785extern int drm_mode_gamma_get_ioctl(struct drm_device *dev,
786				    void *data, struct drm_file *file_priv);
787extern int drm_mode_gamma_set_ioctl(struct drm_device *dev,
788				    void *data, struct drm_file *file_priv);
789extern u8 *drm_find_cea_extension(struct edid *edid);
790extern bool drm_detect_hdmi_monitor(struct edid *edid);
791extern bool drm_detect_monitor_audio(struct edid *edid);
792extern int drm_mode_page_flip_ioctl(struct drm_device *dev,
793				    void *data, struct drm_file *file_priv);
794extern struct drm_display_mode *drm_cvt_mode(struct drm_device *dev,
795				int hdisplay, int vdisplay, int vrefresh,
796				bool reduced, bool interlaced, bool margins);
797extern struct drm_display_mode *drm_gtf_mode(struct drm_device *dev,
798				int hdisplay, int vdisplay, int vrefresh,
799				bool interlaced, int margins);
800extern struct drm_display_mode *drm_gtf_mode_complex(struct drm_device *dev,
801				int hdisplay, int vdisplay, int vrefresh,
802				bool interlaced, int margins, int GTF_M,
803				int GTF_2C, int GTF_K, int GTF_2J);
804extern int drm_add_modes_noedid(struct drm_connector *connector,
805				int hdisplay, int vdisplay);
806
807extern int drm_edid_header_is_valid(const u8 *raw_edid);
 
808extern bool drm_edid_is_valid(struct edid *edid);
809struct drm_display_mode *drm_mode_find_dmt(struct drm_device *dev,
810					   int hsize, int vsize, int fresh);
 
811
812extern int drm_mode_create_dumb_ioctl(struct drm_device *dev,
813				      void *data, struct drm_file *file_priv);
814extern int drm_mode_mmap_dumb_ioctl(struct drm_device *dev,
815				    void *data, struct drm_file *file_priv);
816extern int drm_mode_destroy_dumb_ioctl(struct drm_device *dev,
817				      void *data, struct drm_file *file_priv);
 
 
 
 
 
 
 
 
 
 
 
 
818#endif /* __DRM_CRTC_H__ */