Menu
▾
▴
[PATCH 2/3] drm modesetting core
|
From: Jesse B. <jes...@in...> - 2007-05-17 22:38:02
|
This patch adds the core of the new DRM based modesetting system. It
creates several new structures in the DRM, the primary ones being the
CRTC, which controls all aspects of your device's CRTC(s), output,
which describes and controls the various outputs on your gfx chip (e.g.
TMDS, LVDS, VGA, etc.), and mode, which describes graphics modes in
enough detail for the output and CRTC callbacks to program them to
hardware.
It also contains the user level IOCTL interfaces for doing graphics
programming (getting CRTC, output and mode lists, setting up new
frame buffer objects, etc.).
It relies on the new TTM patch Dave posted recently.
Jesse
diff --git a/linux-core/Makefile.kernel b/linux-core/Makefile.kernel
index 6f5b021..b9684d6 100644
=2D-- a/linux-core/Makefile.kernel
+++ b/linux-core/Makefile.kernel
@@ -13,13 +13,15 @@ drm-objs :=3D drm_auth.o drm_bufs.o drm_context.o=20
drm_dma.o drm_drawable.o \
drm_sysfs.o drm_pci.o drm_agpsupport.o drm_scatter.o \
drm_memory_debug.o ati_pcigart.o drm_sman.o \
drm_hashtab.o drm_mm.o drm_object.o drm_compat.o \
=2D drm_fence.o drm_ttm.o drm_bo.o drm_bo_move.o
+ drm_fence.o drm_ttm.o drm_bo.o drm_bo_move.o drm_crtc.o \
+ drm_edid.o drm_modes.o drm_fb.o
tdfx-objs :=3D tdfx_drv.o
r128-objs :=3D r128_drv.o r128_cce.o r128_state.o r128_irq.o
mga-objs :=3D mga_drv.o mga_dma.o mga_state.o mga_warp.o mga_irq.o
i810-objs :=3D i810_drv.o i810_dma.o
i915-objs :=3D i915_drv.o i915_dma.o i915_irq.o i915_mem.o i915_fence.o=
=20
\
=2D i915_buffer.o
+ i915_buffer.o intel_display.o intel_crt.o intel_lvds.o \
+ intel_sdvo.o intel_modes.o intel_i2c.o i915_init.o
nouveau-objs :=3D nouveau_drv.o nouveau_state.o nouveau_fifo.o=20
nouveau_mem.o \
nouveau_object.o nouveau_irq.o \
nv04_timer.o \
diff --git a/linux-core/drmP.h b/linux-core/drmP.h
index a3f9ca8..377f447 100644
=2D-- a/linux-core/drmP.h
+++ b/linux-core/drmP.h
@@ -164,6 +164,8 @@
=20
#include "drm_compat.h"
=20
+#include "drm_crtc.h"
+
/***********************************************************************/
/** \name Macros to make printk easier */
/*@{*/
@@ -429,6 +431,8 @@ typedef struct drm_file {
=20
drm_open_hash_t refd_object_hash[_DRM_NO_REF_TYPES];
void *driver_priv;
+
+ struct list_head fbs;
} drm_file_t;
=20
/** Wait queue */
@@ -831,6 +835,9 @@ typedef struct drm_device {
unsigned int drw_info_length;
drm_drawable_info_t **drw_info;
/*@} */
+
+ /* DRM mode setting */
+ struct drm_mode_config mode_config;
} drm_device_t;
=20
#if __OS_HAS_AGP
@@ -1128,10 +1135,6 @@ extern drm_head_t **drm_heads;
extern struct drm_sysfs_class *drm_class;
extern struct proc_dir_entry *drm_proc_root;
=20
=2Dextern drm_local_map_t *drm_getsarea(struct drm_device *dev);
=2Dextern int drm_wait_on(drm_device_t *dev, wait_queue_head_t *queue,
=2D int timeout, int (*fn)(drm_device_t *dev, void *priv),
=2D void *priv);
/* Proc support (drm_proc.h) */
extern int drm_proc_init(drm_device_t * dev,
int minor,
diff --git a/linux-core/drm_bo.c b/linux-core/drm_bo.c
index 1c7013b..27016d8 100644
=2D-- a/linux-core/drm_bo.c
+++ b/linux-core/drm_bo.c
@@ -494,6 +494,7 @@ void drm_bo_usage_deref_locked(drm_buffer_object_t *=20
bo)
drm_bo_destroy_locked(bo);
}
}
+EXPORT_SYMBOL(drm_bo_usage_deref_locked);
=20
static void drm_bo_base_deref_locked(drm_file_t * priv,=20
drm_user_object_t * uo)
{
@@ -1624,6 +1625,7 @@ int drm_buffer_object_create(drm_device_t *dev,
drm_bo_usage_deref_unlocked(bo);
return ret;
}
+EXPORT_SYMBOL(drm_buffer_object_create);
=20
static int drm_bo_add_user_object(drm_file_t * priv,=20
drm_buffer_object_t * bo,
int shareable)
@@ -1732,7 +1734,6 @@ int drm_bo_ioctl(DRM_IOCTL_ARGS)
drm_buffer_type, &uo);
if (rep.ret)
break;
=2D
rep.ret =3D drm_bo_handle_info(priv, req->handle, &rep);
break;
case drm_bo_unreference:
@@ -1983,6 +1984,7 @@ int drm_bo_clean_mm(drm_device_t * dev, unsigned=20
mem_type)
=20
return ret;
}
+EXPORT_SYMBOL(drm_bo_clean_mm);
=20
/**
*Evict all buffers of a particular mem_type, but leave memory manager
@@ -2115,6 +2117,7 @@ int drm_bo_driver_finish(drm_device_t * dev)
mutex_unlock(&dev->bm.init_mutex);
return ret;
}
+EXPORT_SYMBOL(drm_bo_driver_finish);
=20
int drm_bo_driver_init(drm_device_t * dev)
{
@@ -2306,9 +2309,6 @@ void drm_bo_unmap_virtual(drm_buffer_object_t *=20
bo)
loff_t offset =3D ((loff_t) bo->map_list.hash.key) << PAGE_SHIFT;
loff_t holelen =3D ((loff_t) bo->mem.num_pages) << PAGE_SHIFT;
=20
=2D if (!dev->dev_mapping)
=2D return;
=2D
unmap_mapping_range(dev->dev_mapping, offset, holelen, 1);
}
=20
diff --git a/linux-core/drm_bo_move.c b/linux-core/drm_bo_move.c
index 4f75206..eaeef1b 100644
=2D-- a/linux-core/drm_bo_move.c
+++ b/linux-core/drm_bo_move.c
@@ -128,6 +128,7 @@ int drm_mem_reg_ioremap(drm_device_t * dev,=20
drm_bo_mem_reg_t * mem,
*virtual =3D addr;
return 0;
}
+EXPORT_SYMBOL(drm_mem_reg_ioremap);
=20
/**
* \c Unmap mapping obtained using drm_bo_ioremap
@@ -150,6 +151,7 @@ void drm_mem_reg_iounmap(drm_device_t * dev,=20
drm_bo_mem_reg_t * mem,
iounmap(virtual);
}
}
+EXPORT_SYMBOL(drm_mem_reg_iounmap);
=20
static int drm_copy_io_page(void *dst, void *src, unsigned long page)
{
diff --git a/linux-core/drm_bufs.c b/linux-core/drm_bufs.c
index 8793ba0..1ba53c8 100644
=2D-- a/linux-core/drm_bufs.c
+++ b/linux-core/drm_bufs.c
@@ -57,7 +57,7 @@ static drm_map_list_t=20
*drm_find_matching_map(drm_device_t *dev,
drm_map_list_t *entry =3D list_entry(list, drm_map_list_t, head);
if (entry->map && map->type =3D=3D entry->map->type &&
((entry->map->offset =3D=3D map->offset) ||=20
=2D (map->type =3D=3D _DRM_SHM && map->flags=3D=3D_DRM_CONTAINS_LOCK)=
)) {
+ ((map->type =3D=3D _DRM_SHM) && (map->flags&_DRM_CONTAINS_LOCK)))) {
return entry;
}
}
@@ -417,6 +417,7 @@ int drm_rmmap_locked(drm_device_t *dev,=20
drm_local_map_t *map)
break;
case _DRM_SHM:
vfree(map->handle);
+ dev->sigdata.lock =3D dev->lock.hw_lock =3D NULL; /* SHM removed */
break;
case _DRM_AGP:
case _DRM_SCATTER_GATHER:
diff --git a/linux-core/drm_compat.h b/linux-core/drm_compat.h
index bc5fadc..bada1fd 100644
=2D-- a/linux-core/drm_compat.h
+++ b/linux-core/drm_compat.h
@@ -60,6 +60,13 @@
#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,19))
#undef DRM_IRQ_ARGS
#define DRM_IRQ_ARGS int irq, void *arg, struct pt_regs *regs
+
+typedef _Bool bool;
+enum {
+ false =3D 0,
+ true =3D 1
+};
+
#endif
=20
#ifndef list_for_each_safe
diff --git a/linux-core/drm_crtc.c b/linux-core/drm_crtc.c
new file mode 100644
index 0000000..16cf62a
=2D-- /dev/null
+++ b/linux-core/drm_crtc.c
@@ -0,0 +1,1652 @@
+/*
+ * Copyright (c) 2006-2007 Intel Corporation
+ * Copyright (c) 2007 Dave Airlie <ai...@li...>
+ *
+ * DRM core CRTC related functions
+ *
+ * Permission to use, copy, modify, distribute, and sell this software=20
and its
+ * documentation for any purpose is hereby granted without fee,=20
provided that
+ * the above copyright notice appear in all copies and that both that=20
copyright
+ * notice and this permission notice appear in supporting=20
documentation, and
+ * that the name of the copyright holders not be used in advertising or
+ * publicity pertaining to distribution of the software without=20
specific,
+ * written prior permission. The copyright holders make no=20
representations
+ * about the suitability of this software for any purpose. It is=20
provided "as
+ * is" without express or implied warranty.
+ *
+ * THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS=20
SOFTWARE,
+ * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN=20
NO
+ * EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY SPECIAL,=20
INDIRECT OR
+ * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS=20
OF USE,
+ * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR=20
OTHER
+ * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR=20
PERFORMANCE
+ * OF THIS SOFTWARE.
+ *
+ * Authors:
+ * Keith Packard
+ * Eric Anholt <er...@an...>
+ * Dave Airlie <ai...@li...>
+ * Jesse Barnes <jes...@in...>
+ */
+#include <linux/list.h>
+#include "drm.h"
+#include "drmP.h"
+#include "drm_crtc.h"
+
+/**
+ * drm_idr_get - allocate a new identifier
+ * @dev: DRM device
+ * @ptr: object pointer, used to generate unique ID
+ *
+ * LOCKING:
+ * Process context (either init or calling process). Must take DRM=20
mode_config
+ * lock around IDR allocation.
+ *
+ * Create a unique identifier based on @ptr in @dev's identifier space. =20
Used
+ * for tracking modes, CRTCs and outputs.
+ *
+ * RETURNS:
+ * New unique (relative to other objects in @dev) integer identifier=20
for the
+ * object.
+ */
+int drm_idr_get(struct drm_device *dev, void *ptr)
+{
+ int new_id =3D 0;
+ int ret;
+again:
+ if (idr_pre_get(&dev->mode_config.crtc_idr, GFP_KERNEL) =3D=3D 0) {
+ DRM_ERROR("Ran out memory getting a mode number\n");
+ return 0;
+ }
+
+ spin_lock(&dev->mode_config.config_lock);
+
+ ret =3D idr_get_new_above(&dev->mode_config.crtc_idr, ptr, 1, &new_id);
+ if (ret =3D=3D -EAGAIN) {
+ spin_unlock(&dev->mode_config.config_lock);
+ goto again;
+ }=09
+
+ spin_unlock(&dev->mode_config.config_lock);
+ return new_id;
+}
+
+/**
+ * drm_idr_put - free an identifer
+ * @dev: DRM device
+ * @id: ID to free
+ *
+ * LOCKING:
+ * Caller must hold DRM mode_config lock.
+ *
+ * Free @id from @dev's unique identifier pool.
+ */
+void drm_idr_put(struct drm_device *dev, int id)
+{
+ idr_remove(&dev->mode_config.crtc_idr, id);
+}
+
+/**
+ * drm_framebuffer_create - create a new framebuffer object
+ * @dev: DRM device
+ *
+ * LOCKING:
+ * Process context (either init or calling process). Must take DRM=20
mode_config
+ * lock around mode_config manipulation.
+ *
+ * Creates a new framebuffer objects and adds it to @dev's DRM=20
mode_config.
+ *
+ * RETURNS:
+ * Pointer to new framebuffer or NULL on error.
+ */
+struct drm_framebuffer *drm_framebuffer_create(drm_device_t *dev)
+{
+ struct drm_framebuffer *fb;
+
+ spin_lock(&dev->mode_config.config_lock);
+ /* Limit to single framebuffer for now */
+ if (dev->mode_config.num_fb > 1) {
+ spin_unlock(&dev->mode_config.config_lock);
+ DRM_ERROR("Attempt to add multiple framebuffers failed\n");
+ return NULL;
+ }
+ spin_unlock(&dev->mode_config.config_lock);
+
+ fb =3D kzalloc(sizeof(struct drm_framebuffer), GFP_KERNEL);
+ if (!fb) {
+
+ return NULL;
+ }
+=09
+ fb->id =3D drm_idr_get(dev, fb);
+ fb->dev =3D dev;
+ spin_lock(&dev->mode_config.config_lock);
+ dev->mode_config.num_fb++;
+ list_add(&fb->head, &dev->mode_config.fb_list);
+ spin_unlock(&dev->mode_config.config_lock);
+
+ return fb;
+}
+EXPORT_SYMBOL(drm_framebuffer_create);
+
+/**
+ * drm_framebuffer_destroy - remove a framebuffer object
+ * @fb: framebuffer to remove
+ *
+ * LOCKING:
+ * Process context (either init or calling process). Must take DRM=20
mode_config
+ * lock around mode_config manipulation.
+ *
+ * Scans all the CRTCs in @dev's mode_config. If they're using @fb,=20
removes
+ * it, setting it to NULL.
+ */
+void drm_framebuffer_destroy(struct drm_framebuffer *fb)
+{
+ drm_device_t *dev =3D fb->dev;
+ struct drm_crtc *crtc;
+
+ /* remove from any CRTC */
+ spin_lock(&dev->mode_config.config_lock);
+ list_for_each_entry(crtc, &dev->mode_config.crtc_list, head) {
+ if (crtc->fb =3D=3D fb)
+ crtc->fb =3D NULL;
+ }
+
+ drm_idr_put(dev, fb->id);
+ list_del(&fb->head);
+ dev->mode_config.num_fb--;
+ spin_unlock(&dev->mode_config.config_lock);
+
+ kfree(fb);
+}
+
+/**
+ * drm_crtc_create - create a new CRTC object
+ * @dev: DRM device
+ * @funcs: callbacks for the new CRTC
+ *
+ * LOCKING:
+ * Process context (either init or calling process). Must take DRM=20
mode_config
+ * lock around mode_config manipulation.
+ *
+ * Creates a new CRTC object and adds it to @dev's mode_config=20
structure.
+ *
+ * RETURNS:
+ * Pointer to new CRTC object or NULL on error.
+ */
+struct drm_crtc *drm_crtc_create(drm_device_t *dev,
+ const struct drm_crtc_funcs *funcs)
+{
+ struct drm_crtc *crtc;
+
+ crtc =3D kzalloc(sizeof(struct drm_crtc), GFP_KERNEL);
+ if (!crtc)
+ return NULL;
+
+ crtc->dev =3D dev;
+ crtc->funcs =3D funcs;
+
+ crtc->id =3D drm_idr_get(dev, crtc);
+
+ spin_lock(&dev->mode_config.config_lock);
+ list_add_tail(&crtc->head, &dev->mode_config.crtc_list);
+ dev->mode_config.num_crtc++;
+ spin_unlock(&dev->mode_config.config_lock);
+
+ return crtc;
+}
+EXPORT_SYMBOL(drm_crtc_create);
+
+/**
+ * drm_crtc_destroy - remove a CRTC object
+ * @crtc: CRTC to remove
+ *
+ * LOCKING:
+ * Process context (either init or calling process). Must take DRM=20
mode_config
+ * lock around mode_config traversal.
+ *
+ * Cleanup @crtc. Calls @crtc's cleanup function, then removes @crtc=20
from
+ * its associated DRM device's mode_config. Frees it afterwards.
+ */
+void drm_crtc_destroy(struct drm_crtc *crtc)
+{
+ drm_device_t *dev =3D crtc->dev;
+
+ if (crtc->funcs->cleanup)
+ (*crtc->funcs->cleanup)(crtc);
+
+ spin_lock(&dev->mode_config.config_lock);
+ drm_idr_put(dev, crtc->id);
+ list_del(&crtc->head);
+ dev->mode_config.num_crtc--;
+ spin_unlock(&dev->mode_config.config_lock);
+ kfree(crtc);
+}
+EXPORT_SYMBOL(drm_crtc_destroy);
+
+/**
+ * drm_crtc_in_use - check if a given CRTC is in a mode_config
+ * @crtc: CRTC to check
+ *
+ * LOCKING:
+ * Caller? (FIXME)
+ *
+ * Walk @crtc's DRM device's mode_config and see if it's in use.
+ *
+ * RETURNS:
+ * True if @crtc is part of the mode_config, false otherwise.
+ */
+bool drm_crtc_in_use(struct drm_crtc *crtc)
+{
+ struct drm_output *output;
+ drm_device_t *dev =3D crtc->dev;
+ /* FIXME: Locking around list access? */
+ list_for_each_entry(output, &dev->mode_config.output_list, head)
+ if (output->crtc =3D=3D crtc)
+ return true;
+ return false;
+}
+EXPORT_SYMBOL(drm_crtc_in_use);
+
+/*
+ * Detailed mode info for a standard 640x480@60Hz monitor
+ */
+static struct drm_display_mode std_mode[] =3D {
+ { DRM_MODE("640x480", DRM_MODE_TYPE_DRIVER, 25200, 640, 656,
+ 752, 800, 0, 480, 490, 492, 525, 0,
+ V_NHSYNC | V_NVSYNC) }, /* 640x480@60Hz */
+};
+
+/**
+ * drm_crtc_probe_output_modes - get complete set of display modes
+ * @dev: DRM device
+ * @maxX: max width for modes
+ * @maxY: max height for modes
+ *
+ * LOCKING:
+ * Caller? (FIXME)
+ *
+ * Based on @dev's mode_config layout, scan all the outputs and try to=20
detect
+ * modes on them. Modes will first be added to the output's=20
probed_modes
+ * list, then culled (based on validity and the @maxX, @maxY=20
parameters) and
+ * put into the normal modes list.
+ *
+ * Intended to be used either at bootup time or when major=20
configuration
+ * changes have occurred.
+ *
+ * FIXME: take into account monitor limits
+ */
+void drm_crtc_probe_output_modes(struct drm_device *dev, int maxX, int=20
maxY)
+{
+ struct drm_output *output;
+ struct drm_display_mode *mode, *t;
+ int ret;
+ //if (maxX =3D=3D 0 || maxY =3D=3D 0)=20
+ // TODO
+
+ list_for_each_entry(output, &dev->mode_config.output_list, head) {
+
+ /* set all modes to the unverified state */
+ list_for_each_entry_safe(mode, t, &output->modes, head)
+ mode->status =3D MODE_UNVERIFIED;
+ =09
+ output->status =3D (*output->funcs->detect)(output);
+
+ if (output->status =3D=3D output_status_disconnected) {
+ DRM_DEBUG("%s is disconnected\n", output->name);
+ /* TODO set EDID to NULL */
+ continue;
+ }
+
+ ret =3D (*output->funcs->get_modes)(output);
+
+ if (ret) {
+ drm_mode_output_list_update(output);
+ }
+
+ if (maxX && maxY)
+ drm_mode_validate_size(dev, &output->modes, maxX,
+ maxY, 0);
+ list_for_each_entry_safe(mode, t, &output->modes, head) {
+ if (mode->status =3D=3D MODE_OK)
+ mode->status =3D (*output->funcs->mode_valid)(output,mode);
+ }
+ =09
+
+ drm_mode_prune_invalid(dev, &output->modes, TRUE);
+
+ if (list_empty(&output->modes)) {
+ struct drm_display_mode *stdmode;
+
+ DRM_DEBUG("No valid modes on %s\n", output->name);
+
+ /* Should we do this here ???
+ * When no valid EDID modes are available we end up
+ * here and bailed in the past, now we add a standard
+ * 640x480@60Hz mode and carry on.
+ */
+ stdmode =3D drm_mode_duplicate(dev, &std_mode[0]);
+ drm_mode_probed_add(output, stdmode);
+ drm_mode_list_concat(&output->probed_modes,
+ &output->modes);
+
+ DRM_DEBUG("Adding standard 640x480 @ 60Hz to %s\n",
+ output->name);
+ }
+
+ drm_mode_sort(&output->modes);
+
+ DRM_DEBUG("Probed modes for %s\n", output->name);
+ list_for_each_entry_safe(mode, t, &output->modes, head) {
+ mode->vrefresh =3D drm_mode_vrefresh(mode);
+
+ drm_mode_set_crtcinfo(mode, CRTC_INTERLACE_HALVE_V);
+ drm_mode_debug_printmodeline(dev, mode);
+ }
+ }
+}
+
+/**
+ * drm_crtc_set_mode - set a mode
+ * @crtc: CRTC to program
+ * @mode: mode to use
+ * @x: width of mode
+ * @y: height of mode
+ *
+ * LOCKING:
+ * Caller? (FIXME)
+ *
+ * Try to set @mode on @crtc. Give @crtc and its associated outputs a=20
chance
+ * to fixup or reject the mode prior to trying to set it.
+ *
+ * RETURNS:
+ * True if the mode was set successfully, or false otherwise.
+ */
+bool drm_crtc_set_mode(struct drm_crtc *crtc, struct drm_display_mode=20
*mode,
+ int x, int y)
+{
+ drm_device_t *dev =3D crtc->dev;
+ struct drm_display_mode *adjusted_mode, saved_mode;
+ int saved_x, saved_y;
+ bool didLock =3D false;
+ bool ret =3D false;
+ struct drm_output *output;
+
+ adjusted_mode =3D drm_mode_duplicate(dev, mode);
+
+ crtc->enabled =3D drm_crtc_in_use(crtc);
+
+ if (!crtc->enabled) {
+ return true;
+ }
+
+ didLock =3D crtc->funcs->lock(crtc);
+
+ saved_mode =3D crtc->mode;
+ saved_x =3D crtc->x;
+ saved_y =3D crtc->y;
+=09
+ /* Update crtc values up front so the driver can rely on them for mode
+ * setting.
+ */
+ crtc->mode =3D *mode;
+ crtc->x =3D x;
+ crtc->y =3D y;
+
+ /* XXX short-circuit changes to base location only */
+=09
+ /* Pass our mode to the outputs and the CRTC to give them a chance to
+ * adjust it according to limitations or output properties, and also
+ * a chance to reject the mode entirely.
+ */
+ list_for_each_entry(output, &dev->mode_config.output_list, head) {
+ =09
+ if (output->crtc !=3D crtc)
+ continue;
+ =09
+ if (!output->funcs->mode_fixup(output, mode, adjusted_mode)) {
+ goto done;
+ }
+ }
+=09
+ if (!crtc->funcs->mode_fixup(crtc, mode, adjusted_mode)) {
+ goto done;
+ }
+
+ /* Prepare the outputs and CRTCs before setting the mode. */
+ list_for_each_entry(output, &dev->mode_config.output_list, head) {
+
+ if (output->crtc !=3D crtc)
+ continue;
+ =09
+ /* Disable the output as the first thing we do. */
+ output->funcs->prepare(output);
+ }
+=09
+ crtc->funcs->prepare(crtc);
+=09
+ /* Set up the DPLL and any output state that needs to adjust or depend
+ * on the DPLL.
+ */
+ crtc->funcs->mode_set(crtc, mode, adjusted_mode, x, y);
+ list_for_each_entry(output, &dev->mode_config.output_list, head) {
+ if (output->crtc =3D=3D crtc)
+ output->funcs->mode_set(output, mode, adjusted_mode);
+ }
+=09
+ /* Now, enable the clocks, plane, pipe, and outputs that we set up. */
+ crtc->funcs->commit(crtc);
+ list_for_each_entry(output, &dev->mode_config.output_list, head) {
+ if (output->crtc =3D=3D crtc) {
+ output->funcs->commit(output);
+#if 0 // TODO def RANDR_12_INTERFACE
+ if (output->randr_output)
+ RRPostPendingProperties (output->randr_output);
+#endif
+ }
+ }
+=09
+ /* XXX free adjustedmode */
+ drm_mode_destroy(dev, adjusted_mode);
+ ret =3D TRUE;
+ /* TODO */
+// if (scrn->pScreen)
+// drm_crtc_set_screen_sub_pixel_order(dev);
+
+done:
+ if (!ret) {
+ crtc->x =3D saved_x;
+ crtc->y =3D saved_y;
+ crtc->mode =3D saved_mode;
+ }
+=09
+ if (didLock)
+ crtc->funcs->unlock (crtc);
+=09
+ return ret;
+}
+
+/**
+ * drm_set_desired_modes - set a good mode on every CRTC & output
+ * @dev: DRM device
+ *
+ * LOCKING:
+ * Caller? (FIXME)
+ *
+ * Each CRTC may have a desired mode associated with it. This routine=20
simply
+ * walks @dev's mode_config and sets the desired mode on every CRTC. =20
Intended
+ * for use at startup time.
+ *
+ * RETURNS:
+ * True if modes were set, false otherwise.
+ */
+bool drm_set_desired_modes(struct drm_device *dev)
+{
+ struct drm_crtc *crtc;
+ struct drm_output *output, *list_output;
+
+ list_for_each_entry(crtc, &dev->mode_config.crtc_list, head) {
+ output =3D NULL;
+
+ list_for_each_entry(list_output, &dev->mode_config.output_list,
+ head) {
+ if (list_output->crtc =3D=3D crtc) {
+ output =3D list_output;
+ break;
+ }
+ }
+ /* Skip disabled crtcs */
+ if (!output) {
+ DRM_DEBUG("skipping disabled crtc\n");
+ continue;
+ }
+
+ if (!drm_crtc_set_mode(crtc, crtc->desired_mode,
+ crtc->desired_x, crtc->desired_y))
+ return false;
+ }
+
+ drm_disable_unused_functions(dev);
+ return true;
+}
+EXPORT_SYMBOL(drm_set_desired_modes);
+
+/**
+ * drm_disable_unused_functions - disable unused objects
+ * @dev: DRM device
+ *
+ * LOCKING:
+ * Caller? (FIXME)
+ *
+ * If an output or CRTC isn't part of @dev's mode_config, it can be=20
disabled
+ * by calling its dpms function, which should power it off.
+ */
+void drm_disable_unused_functions(struct drm_device *dev)
+{
+ struct drm_output *output;
+ struct drm_crtc *crtc;
+
+ list_for_each_entry(output, &dev->mode_config.output_list, head) {
+ if (!output->crtc)
+ (*output->funcs->dpms)(output, DPMSModeOff);
+ }
+
+ list_for_each_entry(crtc, &dev->mode_config.crtc_list, head) {
+ if (!crtc->enabled)
+ crtc->funcs->dpms(crtc, DPMSModeOff);
+ }
+}
+=09
+/**
+ * drm_mode_probed_add - add a mode to the specified output's probed=20
mode list
+ * @output: output the new mode
+ * @mode: mode data
+ *
+ * LOCKING:
+ * Process context (either init or calling process). Must take=20
@output's
+ * mode_lock around mode list manipulation.
+ *=20
+ * Add @mode to @output's mode list for later use.
+ */
+void drm_mode_probed_add(struct drm_output *output,
+ struct drm_display_mode *mode)
+{
+ spin_lock(&output->modes_lock);
+ list_add(&mode->head, &output->probed_modes);
+ spin_unlock(&output->modes_lock);
+}
+EXPORT_SYMBOL(drm_mode_probed_add);
+
+/**
+ * drm_mode_remove - remove and free a mode
+ * @output: output list to modify
+ * @mode: mode to remove
+ *
+ * LOCKING:
+ * Process context (either init or calling process). Must take=20
@output's
+ * mode_lock around mode list manipulation.
+ *=20
+ * Remove @mode from @output's mode list, then free it.
+ */
+void drm_mode_remove(struct drm_output *output, struct drm_display_mode=20
*mode)
+{
+ spin_lock(&output->modes_lock);
+ list_del(&mode->head);
+ spin_unlock(&output->modes_lock);
+ kfree(mode);
+}
+EXPORT_SYMBOL(drm_mode_remove);
+
+/**
+ * drm_output_create - create a new output
+ * @dev: DRM device
+ * @funcs: callbacks for this output
+ * @name: user visible name of the output
+ *
+ * LOCKING:
+ * Process context (either init or calling process). Must take @dev's
+ * mode_config lock around mode list manipulation.
+ *
+ * Creates a new drm_output structure and adds it to @dev's mode_config
+ * structure.
+ *
+ * RETURNS:
+ * Pointer to the new output or NULL on error.
+ */
+struct drm_output *drm_output_create(drm_device_t *dev,
+ const struct drm_output_funcs *funcs,
+ const char *name)
+{
+ struct drm_output *output =3D NULL;
+
+ output =3D kzalloc(sizeof(struct drm_output), GFP_KERNEL);
+ if (!output)
+ return NULL;
+ =09
+ output->dev =3D dev;
+ output->funcs =3D funcs;
+ output->id =3D drm_idr_get(dev, output);
+ if (name)
+ strncpy(output->name, name, DRM_OUTPUT_LEN);
+ output->name[DRM_OUTPUT_LEN - 1] =3D 0;
+ output->subpixel_order =3D SubPixelUnknown;
+ INIT_LIST_HEAD(&output->probed_modes);
+ INIT_LIST_HEAD(&output->modes);
+ spin_lock_init(&output->modes_lock);
+ /* randr_output? */
+ /* output_set_monitor(output)? */
+ /* check for output_ignored(output)? */
+
+ spin_lock(&dev->mode_config.config_lock);
+ list_add_tail(&output->head, &dev->mode_config.output_list);
+ dev->mode_config.num_output++;
+
+ spin_unlock(&dev->mode_config.config_lock);
+
+ return output;
+
+}
+EXPORT_SYMBOL(drm_output_create);
+
+/**
+ * drm_output_destroy - remove an output
+ * @output: output to remove
+ *
+ * LOCKING:
+ * Process context (either init or calling process). Must take @dev's
+ * mode_config lock around mode list manipulation. Caller must hold
+ * modes lock? (FIXME)
+ *
+ * Call @output's cleanup function, then remove the output from the DRM
+ * mode_config after freeing @output's modes.
+ */
+void drm_output_destroy(struct drm_output *output)
+{
+ struct drm_device *dev =3D output->dev;
+ struct drm_display_mode *mode, *t;
+
+ if (*output->funcs->cleanup)
+ (*output->funcs->cleanup)(output);
+
+ list_for_each_entry_safe(mode, t, &output->probed_modes, head)
+ drm_mode_remove(output, mode);
+
+ list_for_each_entry_safe(mode, t, &output->modes, head)
+ drm_mode_remove(output, mode);
+
+ spin_lock(&dev->mode_config.config_lock);
+ drm_idr_put(dev, output->id);
+ list_del(&output->head);
+ spin_unlock(&dev->mode_config.config_lock);
+ kfree(output);
+}
+EXPORT_SYMBOL(drm_output_destroy);
+
+/**
+ * drm_output_rename - rename an output
+ * @output: output to rename
+ * @name: new user visible name
+ *
+ * LOCKING:
+ * None.
+ *
+ * Simply stuff a new name into @output's name field, based on @name.
+ *
+ * RETURNS:
+ * True if the name was changed, false otherwise.
+ */
+bool drm_output_rename(struct drm_output *output, const char *name)
+{
+ if (!name)
+ return false;
+
+ strncpy(output->name, name, DRM_OUTPUT_LEN);
+ output->name[DRM_OUTPUT_LEN - 1] =3D 0;
+
+ DRM_DEBUG("Changed name to %s\n", output->name);
+// drm_output_set_monitor(output);
+// if (drm_output_ignored(output))
+// return FALSE;
+
+ return TRUE;
+}
+EXPORT_SYMBOL(drm_output_rename);
+
+/**
+ * drm_mode_create - create a new display mode
+ * @dev: DRM device
+ *
+ * LOCKING:
+ * None.
+ *
+ * Create a new drm_display_mode, give it an ID, and return it.
+ *
+ * RETURNS:
+ * Pointer to new mode on success, NULL on error.
+ */
+struct drm_display_mode *drm_mode_create(struct drm_device *dev)
+{
+ struct drm_display_mode *nmode;
+
+ nmode =3D kzalloc(sizeof(struct drm_display_mode), GFP_KERNEL);
+ if (!nmode)
+ return NULL;
+
+ nmode->mode_id =3D drm_idr_get(dev, nmode);
+ return nmode;
+}
+
+/**
+ * drm_mode_destroy - remove a mode
+ * @dev: DRM device
+ * @mode: mode to remove
+ *
+ * LOCKING:
+ * None.
+ *
+ * Free @mode's unique identifier, then free it.
+ */
+void drm_mode_destroy(struct drm_device *dev, struct drm_display_mode=20
*mode)
+{
+ drm_idr_put(dev, mode->mode_id);
+
+ kfree(mode);
+}
+
+/**
+ * drm_mode_config_init - initialize DRM mode_configuration structure
+ * @dev: DRM device
+ *
+ * LOCKING:
+ * None, should happen single threaded at init time.
+ *
+ * Initialize @dev's mode_config structure, used for tracking the=20
graphics
+ * configuration of @dev.
+ */
+void drm_mode_config_init(drm_device_t *dev)
+{
+ spin_lock_init(&dev->mode_config.config_lock);
+ INIT_LIST_HEAD(&dev->mode_config.fb_list);
+ INIT_LIST_HEAD(&dev->mode_config.crtc_list);
+ INIT_LIST_HEAD(&dev->mode_config.output_list);
+ idr_init(&dev->mode_config.crtc_idr);
+}
+EXPORT_SYMBOL(drm_mode_config_init);
+
+/**
+ * drm_get_buffer_object - find the buffer object for a given handle
+ * @dev: DRM device
+ * @bo: pointer to caller's buffer_object pointer
+ * @handle: handle to lookup
+ *
+ * LOCKING:
+ * Must take @dev's struct_mutex to protect buffer object lookup.
+ *
+ * Given @handle, lookup the buffer object in @dev and put it in the=20
caller's
+ * @bo pointer.
+ *
+ * RETURNS:
+ * Zero on success, -EINVAL if the handle couldn't be found.
+ */
+static int drm_get_buffer_object(drm_device_t *dev, struct=20
drm_buffer_object **bo, unsigned long handle)
+{
+ drm_user_object_t *uo;
+ drm_hash_item_t *hash;
+ int ret;
+
+ *bo =3D NULL;
+
+ mutex_lock(&dev->struct_mutex);
+ ret =3D drm_ht_find_item(&dev->object_hash, handle, &hash);
+ if (ret) {
+ DRM_ERROR("Couldn't find handle.\n");
+ ret =3D -EINVAL;
+ goto out_err;
+ }
+
+ uo =3D drm_hash_entry(hash, drm_user_object_t, hash);
+ if (uo->type !=3D drm_buffer_type) {
+ ret =3D -EINVAL;
+ goto out_err;
+ }
+=09
+ *bo =3D drm_user_object_entry(uo, drm_buffer_object_t, base);
+ ret =3D 0;
+out_err:
+ mutex_unlock(&dev->struct_mutex);
+ return ret;
+}
+
+/**
+ * drm_setup_output - setup an output structure
+ * @output: output to setup
+ * @crtc: CRTC this output belongs to
+ * @mode: desired mode for this output
+ *
+ * LOCKING:
+ * None.
+ *
+ * Setup @output with the parameters given, with its initial=20
coordinates set
+ * at the origin.
+ */
+static void drm_setup_output(struct drm_output *output, struct drm_crtc=20
*crtc,
+ struct drm_display_mode *mode)
+{
+ output->crtc =3D crtc;
+ output->crtc->desired_mode =3D mode;
+ output->initial_x =3D 0;
+ output->initial_y =3D 0;
+}
+
+/**
+ * drm_initial_config - setup a sane initial output configuration
+ * @dev: DRM device
+ * @can_grow: this configuration is growable
+ *
+ * LOCKING:
+ * Must take various locks. (FIXME)
+ *
+ * Scan the CRTCs and outputs and try to put together an initial setup.
+ * At the moment, this is a cloned configuration across all heads with
+ * a new framebuffer object as the backing store.
+ *
+ * FIXME: return value and better initial config.
+ *
+ * RETURNS:
+ * Zero if everything went ok, nonzero otherwise.
+ */
+bool drm_initial_config(drm_device_t *dev, bool can_grow)
+{
+ /* do a hardcoded initial configuration here */
+ struct drm_crtc *crtc, *vga_crtc =3D NULL, *tmds_crtc =3D NULL,
+ *lvds_crtc =3D NULL;
+ struct drm_output *output;
+ struct drm_framebuffer *fb;
+ drm_buffer_object_t *fbo;
+ unsigned long size, bytes_per_pixel;
+
+ fb =3D drm_framebuffer_create(dev);
+ if (!fb) {
+ DRM_ERROR("failed to allocate fb.\n");
+ return true;
+ }
+
+ /* bind both CRTCs to this fb */
+ /* only initialise one crtc to enabled state */
+ list_for_each_entry(crtc, &dev->mode_config.crtc_list, head) {
+ crtc->fb =3D fb;
+ if (!vga_crtc) {
+ vga_crtc =3D crtc;
+ crtc->enabled =3D 1;
+ crtc->desired_x =3D 0;
+ crtc->desired_y =3D 0;
+ } else {
+ if (!lvds_crtc) {
+ lvds_crtc =3D crtc;
+ crtc->enabled =3D 1;
+ crtc->desired_x =3D 0;
+ crtc->desired_y =3D 0;
+ }
+ if (!tmds_crtc) {
+ tmds_crtc =3D crtc;
+ crtc->enabled =3D 1;
+ crtc->desired_x =3D 0;
+ crtc->desired_y =3D 0;
+ }
+ }
+ }
+
+ drm_crtc_probe_output_modes(dev, 2048, 2048);
+
+ /* hard bind the CRTCS */
+
+ /* bind analog output to one crtc */
+ list_for_each_entry(output, &dev->mode_config.output_list, head) {
+ struct drm_display_mode *des_mode =3D NULL;
+
+ if (list_empty(&output->modes))
+ continue;
+
+ /* Get the first preferred moded */
+ list_for_each_entry(des_mode, &output->modes, head) {
+ if (des_mode->flags & DRM_MODE_TYPE_PREFERRED)
+ break;
+ }
+
+ if (!des_mode)
+ continue;
+
+ if (!strncmp(output->name, "VGA", 3)) {
+ DRM_DEBUG("VGA preferred mode: %s\n", des_mode->name);
+ drm_setup_output(output, vga_crtc, des_mode);
+ } else if (!strncmp(output->name, "TMDS", 4)) {
+ DRM_DEBUG("TMDS preferred mode: %s\n", des_mode->name);
+ drm_setup_output(output, tmds_crtc, des_mode);
+ } else if (!strncmp(output->name, "LVDS", 3)) {
+ DRM_DEBUG("LVDS preferred mode: %s\n", des_mode->name);
+ drm_setup_output(output, lvds_crtc, des_mode);
+ } else
+ output->crtc =3D NULL;
+
+ /* FB config is max of above desired resolutions */
+ /* FIXME: per-output FBs/CRTCs */
+ if (des_mode->hdisplay > fb->width) {
+ fb->width =3D des_mode->hdisplay;
+ fb->pitch =3D fb->width;
+ }
+ if (des_mode->vdisplay > fb->height)
+ fb->height =3D des_mode->vdisplay;
+ }
+
+ /* FIXME: multiple depths */
+ bytes_per_pixel =3D 4;
+ fb->bits_per_pixel =3D bytes_per_pixel * 8;
+ fb->depth =3D bytes_per_pixel * 8;
+ size =3D fb->width * fb->height * bytes_per_pixel;
+ drm_buffer_object_create(dev, size, drm_bo_type_kernel,
+ DRM_BO_FLAG_READ | DRM_BO_FLAG_WRITE |
+ DRM_BO_FLAG_MEM_PRIV0 | DRM_BO_FLAG_NO_MOVE,
+ 0, 0, 0,
+ &fbo);
+ DRM_DEBUG("allocated %dx%d fb: 0x%08lx, bo %p\n", fb->width,
+ fb->height, fbo->offset, fbo);
+ fb->offset =3D fbo->offset;
+ fb->bo =3D fbo;
+ drmfb_probe(dev, fb);
+
+ return false;
+}
+EXPORT_SYMBOL(drm_initial_config);
+
+/**
+ * drm_mode_config_cleanup - free up DRM mode_config info
+ * @dev: DRM device
+ *
+ * LOCKING:
+ * Caller? (FIXME)
+ *
+ * Free up all the outputs and CRTCs associated with this DRM device,=20
then
+ * free up the framebuffers and associated buffer objects.
+ *
+ * FIXME: cleanup any dangling user buffer objects too
+ */
+void drm_mode_config_cleanup(drm_device_t *dev)
+{
+ struct drm_output *output, *ot;
+ struct drm_crtc *crtc, *ct;
+ struct drm_framebuffer *fb, *fbt;
+ list_for_each_entry_safe(output, ot, &dev->mode_config.output_list,=20
head) {
+ drm_output_destroy(output);
+ }
+
+ list_for_each_entry_safe(crtc, ct, &dev->mode_config.crtc_list, head)=20
{
+ drm_crtc_destroy(crtc);
+ }
+
+ list_for_each_entry_safe(fb, fbt, &dev->mode_config.fb_list, head) {
+ drmfb_remove(dev, fb);
+ /* If this FB was the kernel one, free it */
+ if (fb->bo->type =3D=3D drm_bo_type_kernel) {
+ mutex_lock(&dev->struct_mutex);
+ drm_bo_usage_deref_locked(fb->bo);
+ mutex_unlock(&dev->struct_mutex);
+ }
+ drm_framebuffer_destroy(fb);
+ }
+}
+EXPORT_SYMBOL(drm_mode_config_cleanup);
+
+/**
+ * drm_crtc_set_config - set a new config from userspace
+ * @crtc: CRTC to setup
+ * @crtc_info: user provided configuration
+ * @new_mode: new mode to set
+ * @output_set: set of outputs for the new config
+ * @fb: new framebuffer
+ *
+ * LOCKING:
+ * Caller? (FIXME)
+ *
+ * Setup a new configuration, provided by the user in @crtc_info, and=20
enable
+ * it.
+ *
+ * RETURNS:
+ * Zero. (FIXME)
+ */
+int drm_crtc_set_config(struct drm_crtc *crtc, struct drm_mode_crtc=20
*crtc_info, struct drm_display_mode *new_mode, struct drm_output=20
**output_set, struct drm_framebuffer *fb)
+{
+ drm_device_t *dev =3D crtc->dev;
+ struct drm_crtc **save_crtcs, *new_crtc;
+ bool save_enabled =3D crtc->enabled;
+ bool changed;
+ struct drm_output *output;
+ int count =3D 0, ro;
+
+ save_crtcs =3D kzalloc(dev->mode_config.num_crtc * sizeof(struct=20
drm_crtc *), GFP_KERNEL);
+ if (!save_crtcs)
+ return -ENOMEM;
+
+ if (crtc->fb !=3D fb)
+ changed =3D true;
+
+ if (crtc_info->x !=3D crtc->x || crtc_info->y !=3D crtc->y)
+ changed =3D true;
+
+ if (new_mode && (crtc->mode.mode_id !=3D new_mode->mode_id))
+ changed =3D true;
+
+ list_for_each_entry(output, &dev->mode_config.output_list, head) {
+ save_crtcs[count++] =3D output->crtc;
+
+ if (output->crtc =3D=3D crtc)
+ new_crtc =3D NULL;
+ else
+ new_crtc =3D output->crtc;
+
+ for (ro =3D 0; ro < crtc_info->count_outputs; ro++) {
+ if (output_set[ro] =3D=3D output)
+ new_crtc =3D crtc;
+ }
+ if (new_crtc !=3D output->crtc) {
+ changed =3D true;
+ output->crtc =3D new_crtc;
+ }
+ }
+
+ if (changed) {
+ crtc->fb =3D fb;
+ crtc->enabled =3D (new_mode !=3D NULL);
+ if (new_mode !=3D NULL) {
+ DRM_DEBUG("attempting to set mode from userspace\n");
+ drm_mode_debug_printmodeline(dev, new_mode);
+ if (!drm_crtc_set_mode(crtc, new_mode, crtc_info->x,
+ crtc_info->y)) {
+ crtc->enabled =3D save_enabled;
+ count =3D 0;
+ list_for_each_entry(output, &dev->mode_config.output_list, head)
+ output->crtc =3D save_crtcs[count++];
+ kfree(save_crtcs);
+ return -EINVAL;
+ }
+ crtc->desired_x =3D crtc_info->x;
+ crtc->desired_y =3D crtc_info->y;
+ crtc->desired_mode =3D new_mode;
+ }
+ drm_disable_unused_functions(dev);
+ }
+ kfree(save_crtcs);
+ return 0;
+}
+
+/**
+ * drm_crtc_convert_to_umode - convert a drm_display_mode into a=20
modeinfo
+ * @out: drm_mode_modeinfo struct to return to the user
+ * @in: drm_display_mode to use
+ *
+ * LOCKING:
+ * None.
+ *
+ * Convert a drm_display_mode into a drm_mode_modeinfo structure to=20
return to
+ * the user.
+ */
+void drm_crtc_convert_to_umode(struct drm_mode_modeinfo *out, struct=20
drm_display_mode *in)
+{
+
+ out->id =3D in->mode_id;
+ out->clock =3D in->clock;
+ out->hdisplay =3D in->hdisplay;
+ out->hsync_start =3D in->hsync_start;
+ out->hsync_end =3D in->hsync_end;
+ out->htotal =3D in->htotal;
+ out->hskew =3D in->hskew;
+ out->vdisplay =3D in->vdisplay;
+ out->vsync_start =3D in->vsync_start;
+ out->vsync_end =3D in->vsync_end;
+ out->vtotal =3D in->vtotal;
+ out->vscan =3D in->vscan;
+ out->vrefresh =3D in->vrefresh;
+ out->flags =3D in->flags;
+ strncpy(out->name, in->name, DRM_DISPLAY_MODE_LEN);
+ out->name[DRM_DISPLAY_MODE_LEN-1] =3D 0;
+}
+
+=09
+/**
+ * drm_mode_getresources - get graphics configuration
+ * @inode: inode from the ioctl
+ * @filp: file * from the ioctl
+ * @cmd: cmd from ioctl
+ * @arg: arg from ioctl
+ *
+ * LOCKING:
+ * Caller? (FIXME)
+ *
+ * Construct a set of configuration description structures and return
+ * them to the user, including CRTC, output and framebuffer=20
configuration.
+ *
+ * Called by the user via ioctl.
+ *
+ * RETURNS:
+ * Zero on success, errno on failure.
+ */
+int drm_mode_getresources(struct inode *inode, struct file *filp,
+ unsigned int cmd, unsigned long arg)
+{
+ drm_file_t *priv =3D filp->private_data;
+ drm_device_t *dev =3D priv->head->dev;
+ struct drm_mode_card_res __user *argp =3D (void __user *)arg;
+ struct drm_mode_card_res card_res;
+ struct list_head *lh;
+ struct drm_framebuffer *fb;
+ struct drm_output *output;
+ struct drm_crtc *crtc;
+ struct drm_mode_modeinfo u_mode;
+ struct drm_display_mode *mode;
+ int retcode =3D 0;
+ int mode_count=3D 0;
+ int output_count =3D 0;
+ int crtc_count =3D 0;
+ int fb_count =3D 0;
+ int copied =3D 0;
+=09
+ memset(&u_mode, 0, sizeof(struct drm_mode_modeinfo));
+
+ list_for_each(lh, &dev->mode_config.fb_list)
+ fb_count++;
+
+ list_for_each(lh, &dev->mode_config.crtc_list)
+ crtc_count++;
+
+ list_for_each_entry(output, &dev->mode_config.output_list,
+ head) {
+ output_count++;
+ list_for_each(lh, &output->modes)
+ mode_count++;
+ }
+
+ if (copy_from_user(&card_res, argp, sizeof(card_res)))
+ return -EFAULT;
+
+ if (card_res.count_modes =3D=3D 0) {
+ DRM_DEBUG("probing modes %dx%d\n", dev->mode_config.max_width,=20
dev->mode_config.max_height);
+ drm_crtc_probe_output_modes(dev, dev->mode_config.max_width,=20
dev->mode_config.max_height);
+ mode_count =3D 0;
+ list_for_each_entry(output, &dev->mode_config.output_list, head) {
+ list_for_each(lh, &output->modes)
+ mode_count++;
+ }
+ }
+
+ /* handle this in 4 parts */
+ /* FBs */
+ if (card_res.count_fbs >=3D fb_count) {
+ copied =3D 0;
+ list_for_each_entry(fb, &dev->mode_config.fb_list, head) {
+ if (put_user(fb->id, &card_res.fb_id[copied++])) {
+ retcode =3D -EFAULT;
+ goto done;
+ }
+ }
+ }
+ card_res.count_fbs =3D fb_count;
+
+ /* CRTCs */
+ if (card_res.count_crtcs >=3D crtc_count) {
+ copied =3D 0;
+ list_for_each_entry(crtc, &dev->mode_config.crtc_list, head){
+ DRM_DEBUG("CRTC ID is %d\n", crtc->id);
+ if (put_user(crtc->id, &card_res.crtc_id[copied++])) {
+ retcode =3D -EFAULT;
+ goto done;
+ }
+ }
+ }
+ card_res.count_crtcs =3D crtc_count;
+
+
+ /* Outputs */
+ if (card_res.count_outputs >=3D output_count) {
+ copied =3D 0;
+ list_for_each_entry(output, &dev->mode_config.output_list,
+ head) {
+ DRM_DEBUG("OUTPUT ID is %d\n", output->id);
+ if (put_user(output->id, &card_res.output_id[copied++])) {
+ retcode =3D -EFAULT;
+ goto done;
+ }
+ }
+ }
+ card_res.count_outputs =3D output_count;
+=09
+ /* Modes */
+ if (card_res.count_modes >=3D mode_count) {
+ copied =3D 0;
+ list_for_each_entry(output, &dev->mode_config.output_list,
+ head) {
+ list_for_each_entry(mode, &output->modes, head) {
+ drm_crtc_convert_to_umode(&u_mode, mode);
+ if (copy_to_user(&card_res.modes[copied++], &u_mode, sizeof(struct=20
drm_mode_modeinfo))) {
+ retcode =3D -EFAULT;
+ goto done;
+ }
+ }
+ }
+ }
+ card_res.count_modes =3D mode_count;
+
+done:
+ DRM_DEBUG("Counted %d %d %d\n", card_res.count_crtcs,
+ card_res.count_outputs,
+ card_res.count_modes);
+=09
+ if (copy_to_user(argp, &card_res, sizeof(card_res)))
+ return -EFAULT;
+
+ return retcode;
+}
+
+/**
+ * drm_mode_getcrtc - get CRTC configuration
+ * @inode: inode from the ioctl
+ * @filp: file * from the ioctl
+ * @cmd: cmd from ioctl
+ * @arg: arg from ioctl
+ *
+ * LOCKING:
+ * Caller? (FIXME)
+ *
+ * Construct a CRTC configuration structure to return to the user.
+ *
+ * Called by the user via ioctl.
+ *
+ * RETURNS:
+ * Zero on success, errno on failure.
+ */
+int drm_mode_getcrtc(struct inode *inode, struct file *filp,
+ unsigned int cmd, unsigned long arg)
+{
+ drm_file_t *priv =3D filp->private_data;
+ drm_device_t *dev =3D priv->head->dev;
+ struct drm_mode_crtc __user *argp =3D (void __user *)arg;
+ struct drm_mode_crtc crtc_resp;
+ struct drm_crtc *crtc;
+ struct drm_output *output;
+ int ocount;
+ int retcode =3D 0;
+
+ if (copy_from_user(&crtc_resp, argp, sizeof(crtc_resp)))
+ return -EFAULT;
+
+ crtc =3D idr_find(&dev->mode_config.crtc_idr, crtc_resp.crtc_id);
+ if (!crtc || (crtc->id !=3D crtc_resp.crtc_id))
+ return -EINVAL;
+ crtc_resp.x =3D crtc->x;
+ crtc_resp.y =3D crtc->y;
+ crtc_resp.fb_id =3D 1;
+
+ crtc_resp.outputs =3D 0;
+ if (crtc->enabled) {
+
+ crtc_resp.mode =3D crtc->mode.mode_id;
+ ocount =3D 0;
+ list_for_each_entry(output, &dev->mode_config.output_list, head) {
+ if (output->crtc =3D=3D crtc)
+ crtc_resp.outputs |=3D 1 << (ocount++);
+ }
+ } else {
+ crtc_resp.mode =3D 0;
+ }
+
+ if (copy_to_user(argp, &crtc_resp, sizeof(crtc_resp)))
+ return -EFAULT;
+
+ return retcode;
+}
+
+/**
+ * drm_mode_getoutput - get output configuration
+ * @inode: inode from the ioctl
+ * @filp: file * from the ioctl
+ * @cmd: cmd from ioctl
+ * @arg: arg from ioctl
+ *
+ * LOCKING:
+ * Caller? (FIXME)
+ *
+ * Construct a output configuration structure to return to the user.
+ *
+ * Called by the user via ioctl.
+ *
+ * RETURNS:
+ * Zero on success, errno on failure.
+ */
+int drm_mode_getoutput(struct inode *inode, struct file *filp,
+ unsigned int cmd, unsigned long arg)
+{
+ drm_file_t *priv =3D filp->private_data;
+ drm_device_t *dev =3D priv->head->dev;
+ struct drm_mode_get_output __user *argp =3D (void __user *)arg;
+ struct drm_mode_get_output out_resp;
+ struct drm_output *output;
+ struct drm_display_mode *mode;
+ int mode_count =3D 0;
+ int retcode =3D 0;
+ int copied =3D 0;
+
+ if (copy_from_user(&out_resp, argp, sizeof(out_resp)))
+ return -EFAULT;=09
+
+ DRM_DEBUG("output id %d:\n", out_resp.output);
+ output=3D idr_find(&dev->mode_config.crtc_idr, out_resp.output);
+ if (!output || (output->id !=3D out_resp.output))
+ return -EINVAL;
+
+ list_for_each_entry(mode, &output->modes, head)
+ mode_count++;
+
+ strncpy(out_resp.name, output->name, DRM_OUTPUT_NAME_LEN);
+ out_resp.name[DRM_OUTPUT_NAME_LEN-1] =3D 0;
+
+ out_resp.mm_width =3D output->mm_width;
+ out_resp.mm_height =3D output->mm_height;
+ out_resp.subpixel =3D output->subpixel_order;
+ out_resp.connection =3D output->status;
+ if (output->crtc)
+ out_resp.crtc =3D output->crtc->id;
+ else
+ out_resp.crtc =3D 0;
+
+ if ((out_resp.count_modes >=3D mode_count) && mode_count) {
+ copied =3D 0;
+ list_for_each_entry(mode, &output->modes, head) {
+ if (put_user(mode->mode_id, &out_resp.modes[copied++])) {
+ retcode =3D -EFAULT;
+ goto done;
+ }
+ }
+ }
+ out_resp.count_modes =3D mode_count;
+
+done:
+ if (copy_to_user(argp, &out_resp, sizeof(out_resp)))
+ return -EFAULT;
+
+ return retcode;
+}
+
+/**
+ * drm_mode_setcrtc - set CRTC configuration
+ * @inode: inode from the ioctl
+ * @filp: file * from the ioctl
+ * @cmd: cmd from ioctl
+ * @arg: arg from ioctl
+ *
+ * LOCKING:
+ * Caller? (FIXME)
+ *
+ * Build a new CRTC configuration based on user request.
+ *
+ * Called by the user via ioctl.
+ *
+ * RETURNS:
+ * Zero on success, errno on failure.
+ */
+int drm_mode_setcrtc(struct inode *inode, struct file *filp,
+ unsigned int cmd, unsigned long arg)
+{
+ drm_file_t *priv =3D filp->private_data;
+ drm_device_t *dev =3D priv->head->dev;
+ struct drm_mode_crtc __user *argp =3D (void __user *)arg;
+ struct drm_mode_crtc crtc_req;
+ struct drm_crtc *crtc;
+ struct drm_output **output_set =3D NULL, *output;
+ struct drm_display_mode *mode;
+ struct drm_framebuffer *fb =3D NULL;
+ int retcode =3D 0;
+ int i;
+
+ if (copy_from_user(&crtc_req, argp, sizeof(crtc_req)))
+ return -EFAULT;
+
+ crtc =3D idr_find(&dev->mode_config.crtc_idr, crtc_req.crtc_id);
+ if (!crtc || (crtc->id !=3D crtc_req.crtc_id)) {
+ DRM_DEBUG("Unknown CRTC ID %d\n", crtc_req.crtc_id);
+ return -EINVAL;
+ }
+
+ if (crtc_req.mode) {
+
+ /* if we have a mode we need a framebuffer */
+ if (crtc_req.fb_id) {
+ fb =3D idr_find(&dev->mode_config.crtc_idr, crtc_req.fb_id);
+ if (!fb || (fb->id !=3D crtc_req.fb_id)) {
+ DRM_DEBUG("Unknown FB ID%d\n", crtc_req.fb_id);
+ return -EINVAL;
+ }
+ }
+ mode =3D idr_find(&dev->mode_config.crtc_idr, crtc_req.mode);
+ if (!mode || (mode->mode_id !=3D crtc_req.mode)) {
+ struct drm_output *output;
+ =09
+ list_for_each_entry(output, &dev->mode_config.output_list, head) {
+ list_for_each_entry(mode, &output->modes, head) {
+ drm_mode_debug_printmodeline(dev, mode);
+ }
+ }
+
+ DRM_DEBUG("Unknown mode id %d, %p\n", crtc_req.mode, mode);
+ return -EINVAL;
+ }
+ } else
+ mode =3D NULL;
+
+ if (crtc_req.count_outputs =3D=3D 0 && mode) {
+ DRM_DEBUG("Count outputs is 0 but mode set\n");
+ return -EINVAL;
+ }
+
+ if (crtc_req.count_outputs > 0 && !mode && !fb) {
+ DRM_DEBUG("Count outputs is %d but no mode or fb set\n",=20
crtc_req.count_outputs);
+ return -EINVAL;
+ }
+
+ if (crtc_req.count_outputs > 0) {
+ u32 out_id;
+ output_set =3D kmalloc(crtc_req.count_outputs * sizeof(struct=20
drm_output *), GFP_KERNEL);
+ if (!output_set)
+ return -ENOMEM;
+
+ for (i =3D 0; i < crtc_req.count_outputs; i++) {
+ if (get_user(out_id, &crtc_req.set_outputs[i]))
+ return -EFAULT;
+
+ output =3D idr_find(&dev->mode_config.crtc_idr, out_id);
+ if (!output || (out_id !=3D output->id)) {
+ DRM_DEBUG("Output id %d unknown\n", out_id);
+ return -EINVAL;
+ }
+
+ output_set[i] =3D output;
+ }
+ }
+ =09
+ retcode =3D drm_crtc_set_config(crtc, &crtc_req, mode, output_set, fb);
+ return retcode;
+}
+
+/**
+ * drm_mode_addfb - add an FB to the graphics configuration
+ * @inode: inode from the ioctl
+ * @filp: file * from the ioctl
+ * @cmd: cmd from ioctl
+ * @arg: arg from ioctl
+ *
+ * LOCKING:
+ * Caller? (FIXME)
+ *
+ * Add a new FB to the specified CRTC, given a user request.
+ *
+ * Called by the user via ioctl.
+ *
+ * RETURNS:
+ * Zero on success, errno on failure.
+ */
+int drm_mode_addfb(struct inode *inode, struct file *filp,
+ unsigned int cmd, unsigned long arg)
+{
+ struct drm_file *priv =3D filp->private_data;
+ struct drm_device *dev =3D priv->head->dev;
+ struct drm_mode_fb_cmd __user *argp =3D (void __user *)arg;
+ struct drm_mode_fb_cmd r;
+ struct drm_mode_config *config =3D &dev->mode_config;
+ struct drm_framebuffer *fb;
+ struct drm_buffer_object *bo;
+ int ret;
+
+ if (copy_from_user(&r, argp, sizeof(r)))
+ return -EFAULT;
+
+ if ((config->min_width > r.width) || (r.width > config->max_width)) {
+ DRM_ERROR("mode new framebuffer width not within limits\n");
+ return -EINVAL;
+ }
+ if ((config->min_height > r.height) || (r.height >=20
config->max_height)) {
+ DRM_ERROR("mode new framebuffer height not within limits\n");
+ return -EINVAL;
+ }
+
+ /* TODO check limits are okay */
+ ret =3D drm_get_buffer_object(dev, &bo, r.handle);
+ if (ret || !bo)
+ return -EINVAL;
+
+ /* TODO check buffer is sufficently large */
+ /* TODO setup destructor callback */
+
+ fb =3D drm_framebuffer_create(dev);
+ if(!fb)
+ return -EINVAL;;
+
+ fb->width =3D r.width;
+ fb->height =3D r.height;
+ fb->pitch =3D r.pitch;
+ fb->bits_per_pixel =3D r.bpp;
+ fb->depth =3D r.depth;
+ fb->offset =3D bo->offset;
+ fb->bo =3D bo;
+
+ r.buffer_id =3D fb->id;
+
+ list_add(&fb->filp_head, &priv->fbs);
+ /* bind the fb to the crtc for now */
+ {
+ struct drm_crtc *crtc;
+ list_for_each_entry(crtc, &dev->mode_config.crtc_list, head) {
+ crtc->fb =3D fb;
+ }
+ }
+ if (copy_to_user(argp, &r, sizeof(r)))
+ return -EFAULT;
+
+ drmfb_probe(dev, fb);
+ return 0;
+}
+
+/**
+ * drm_mode_rmfb - remove an FB from the configuration
+ * @inode: inode from the ioctl
+ * @filp: file * from the ioctl
+ * @cmd: cmd from ioctl
+ * @arg: arg from ioctl
+ *
+ * LOCKING:
+ * Caller? (FIXME)
+ *
+ * Remove the FB specified by the user.
+ *
+ * Called by the user via ioctl.
+ *
+ * RETURNS:
+ * Zero on success, errno on failure.
+ */
+int drm_mode_rmfb(struct inode *inode, struct file *filp,
+ unsigned int cmd, unsigned long arg)
+{
+ drm_file_t *priv =3D filp->private_data;
+ drm_device_t *dev =3D priv->head->dev;
+ struct drm_framebuffer *fb =3D 0;
+ uint32_t id =3D arg;
+
+ fb =3D idr_find(&dev->mode_config.crtc_idr, id);
+ /* TODO check that we realy get a framebuffer back. */
+ if (!fb || (id !=3D fb->id)) {
+ DRM_ERROR("mode invalid framebuffer id\n");
+ return -EINVAL;
+ }
+
+ drmfb_remove(dev, fb);
+ /* TODO check if we own the buffer */
+ /* TODO release all crtc connected to the framebuffer */
+ /* bind the fb to the crtc for now */
+ /* TODO unhock the destructor from the buffer object */
+
+ drm_framebuffer_destroy(fb);
+
+ return 0;
+}
+
+/**
+ * drm_mode_getfb - get FB info
+ * @inode: inode from the ioctl
+ * @filp: file * from the ioctl
+ * @cmd: cmd from ioctl
+ * @arg: arg from ioctl
+ *
+ * LOCKING:
+ * Caller? (FIXME)
+ *
+ * Lookup the FB given its ID and return info about it.
+ *
+ * Called by the user via ioctl.
+ *
+ * RETURNS:
+ * Zero on success, errno on failure.
+ */
+int drm_mode_getfb(struct inode *inode, struct file *filp,
+ unsigned int cmd, unsigned long arg)
+{
+ drm_file_t *priv =3D filp->private_data;
+ drm_device_t *dev =3D priv->head->dev;=09
+ struct drm_mode_fb_cmd __user *argp =3D (void __user *)arg;
+ struct drm_mode_fb_cmd r;
+ struct drm_framebuffer *fb;
+
+ if (copy_from_user(&r, argp, sizeof(r)))
+ return -EFAULT;
+
+ fb =3D idr_find(&dev->mode_config.crtc_idr, r.buffer_id);
+ if (!fb || (r.buffer_id !=3D fb->id)) {
+ DRM_ERROR("invalid framebuffer id\n");
+ return -EINVAL;
+ }
+
+ r.height =3D fb->height;
+ r.width =3D fb->width;
+ r.depth =3D fb->depth;
+ r.bpp =3D fb->bits_per_pixel;
+ r.handle =3D fb->bo->base.hash.key;
+ r.pitch =3D fb->pitch;
+
+ if (copy_to_user(argp, &r, sizeof(r)))
+ return -EFAULT;
+
+ return 0;
+}
+
+/**
+ * drm_fb_release - remove and free the FBs on this file
+ * @filp: file * from the ioctl
+ *
+ * LOCKING:
+ * Caller? (FIXME)
+ *
+ * Destroy all the FBs associated with @filp.
+ *
+ * Called by the user via ioctl.
+ *
+ * RETURNS:
+ * Zero on success, errno on failure.
+ */
+void drm_fb_release(struct file *filp)
+{
+ drm_file_t *priv =3D filp->private_data;
+ drm_device_t *dev =3D priv->head->dev;
+ struct drm_framebuffer *fb, *tfb;
+
+ list_for_each_entry_safe(fb, tfb, &priv->fbs, filp_head) {
+ list_del(&fb->filp_head);
+ drmfb_remove(dev, fb);
+ drm_framebuffer_destroy(fb);
+ =09
+ }
+}
diff --git a/linux-core/drm_crtc.h b/linux-core/drm_crtc.h
new file mode 100644
index 0000000..a15ce0c
=2D-- /dev/null
+++ b/linux-core/drm_crtc.h
@@ -0,0 +1,535 @@
+/*
+ * Copyright =C2=A9 2006 Keith Packard
+ * Copyright =C2=A9 2007 Intel Corporation
+ * Jesse Barnes <jes...@in...>
+ */
+#ifndef __DRM_CRTC_H__
+#define __DRM_CRTC_H__
+
+#include <linux/i2c.h>
+#include <linux/spinlock.h>
+#include <linux/types.h>
+#include <linux/idr.h>
+
+#include <linux/fb.h>
+
+struct drm_device;
+
+/*
+ * Note on terminology: here, for brevity and convenience, we refer to=20
output
+ * control chips as 'CRTCs'. They can control any type of output, VGA,=20
LVDS,
+ * DVI, etc. And 'screen' refers to the whole of the visible display,=20
which
+ * may span multiple monitors (and therefore multiple CRTC and output
+ * structures).
+ */
+
+enum drm_mode_status {
+ MODE_OK =3D 0, /* Mode OK */
+ MODE_HSYNC, /* hsync out of range */
+ MODE_VSYNC, /* vsync out of range */
+ MODE_H_ILLEGAL, /* mode has illegal horizontal timings */
+ MODE_V_ILLEGAL, /* mode has illegal horizontal timings */
+ MODE_BAD_WIDTH, /* requires an unsupported linepitch */
+ MODE_NOMODE, /* no mode with a maching name */
+ MODE_NO_INTERLACE, /* interlaced mode not supported */
+ MODE_NO_DBLESCAN, /* doublescan mode not supported */
+ MODE_NO_VSCAN, /* multiscan mode not supported */
+ MODE_MEM, /* insufficient video memory */
+ MODE_VIRTUAL_X, /* mode width too large for specified virtual size=20
*/
+ MODE_VIRTUAL_Y, /* mode height too large for specified virtual size=20
*/
+ MODE_MEM_VIRT, /* insufficient video memory given virtual size */
+ MODE_NOCLOCK, /* no fixed clock available */
+ MODE_CLOCK_HIGH, /* clock required is too high */
+ MODE_CLOCK_LOW, /* clock required is too low */
+ MODE_CLOCK_RANGE, /* clock/mode isn't in a ClockRange */
+ MODE_BAD_HVALUE, /* horizontal timing was out of range */
+ MODE_BAD_VVALUE, /* vertical timing was out of range */
+ MODE_BAD_VSCAN, /* VScan value out of range */
+ MODE_HSYNC_NARROW, /* horizontal sync too narrow */
+ MODE_HSYNC_WIDE, /* horizontal sync too wide */
+ MODE_HBLANK_NARROW, /* horizontal blanking too narrow */
+ MODE_HBLANK_WIDE, /* horizontal blanking too wide */
+ MODE_VSYNC_NARROW, /* vertical sync too narrow */
+ MODE_VSYNC_WIDE, /* vertical sync too wide */
+ MODE_VBLANK_NARROW, /* vertical blanking too narrow */
+ MODE_VBLANK_WIDE, /* vertical blanking too wide */
+ MODE_PANEL, /* exceeds panel dimensions */
+ MODE_INTERLACE_WIDTH, /* width too large for interlaced mode */
+ MODE_ONE_WIDTH, /* only one width is supported */
+ MODE_ONE_HEIGHT, /* only one height is supported */
+ MODE_ONE_SIZE, /* only one resolution is supported */
+ MODE_NO_REDUCED, /* monitor doesn't accept reduced blanking */
+ MODE_UNVERIFIED =3D -3, /* mode needs to reverified */
+ MODE_BAD =3D -2, /* unspecified reason */
+ MODE_ERROR =3D -1 /* error condition */
+};
+
+#define DRM_MODE_TYPE_BUILTIN (1<<0)
+#define DRM_MODE_TYPE_CLOCK_C ((1<<1) | DRM_MODE_TYPE_BUILTIN)
+#define DRM_MODE_TYPE_CRTC_C ((1<<2) | DRM_MODE_TYPE_BUILTIN)
+#define DRM_MODE_TYPE_PREFERRED (1<<3)
+#define DRM_MODE_TYPE_DEFAULT (1<<4)
+#define DRM_MODE_TYPE_USERDEF (1<<5)
+#define DRM_MODE_TYPE_DRIVER (1<<6)
+
+#define DRM_MODE_TYPE_CLOCK_CRTC_C (DRM_MODE_TYPE_CLOCK_C | \
+ DRM_MODE_TYPE_CRTC_C)
+
+#define DRM_MODE(nm, t, c, hd, hss, hse, ht, hsk, vd, vss, vse, vt, vs,=20
f) \
+ .name =3D nm, .status =3D 0, .type =3D (t), .clock =3D (c), \
+ .hdisplay =3D (hd), .hsync_start =3D (hss), .hsync_end =3D (hse), \
+ .htotal =3D (ht), .hskew =3D (hsk), .vdisplay =3D (vd), \
+ .vsync_start =3D (vss), .vsync_end =3D (vse), .vtotal =3D (vt), \
+ .vscan =3D (vs), .flags =3D (f), .vrefresh =3D 0
+
+struct drm_display_mode {
+ /* Header */
+ struct list_head head;
+ char name[DRM_DISPLAY_MODE_LEN];
+ int mode_id;
+ enum drm_mode_status status;
+ int type;
+
+ /* Proposed mode values */
+ int clock;
+ int hdisplay;
+ int hsync_start;
+ int hsync_end;
+ int htotal;
+ int hskew;
+ int vdisplay;
+ int vsync_start;
+ int vsync_end;
+ int vtotal;
+ int vscan;
+ unsigned int flags;
+
+ /* Actual mode we give to hw */
+ int clock_index;
+ int synth_clock;
+ int crtc_hdisplay;
+ int crtc_hblank_start;
+ int crtc_hblank_end;
+ int crtc_hsync_start;
+ int crtc_hsync_end;
+ int crtc_htotal;
+ int crtc_hskew;
+ int crtc_vdisplay;
+ int crtc_vblank_start;
+ int crtc_vblank_end;
+ int crtc_vsync_start;
+ int crtc_vsync_end;
+ int crtc_vtotal;
+ int crtc_hadjusted;
+ int crtc_vadjusted;
+
+ /* Driver private mode info */
+ int private_size;
+ int *private;
+ int private_flags;
+
+ int vrefresh;
+ float hsync;
+};
+
+/* Video mode flags */
+#define V_PHSYNC (1<<0)
+#define V_NHSYNC (1<<1)
+#define V_PVSYNC (1<<2)
+#define V_NVSYNC (1<<3)
+#define V_INTERLACE (1<<4)
+#define V_DBLSCAN (1<<5)
+#define V_CSYNC (1<<6)
+#define V_PCSYNC (1<<7)
+#define V_NCSYNC (1<<8)
+#define V_HSKEW (1<<9) /* hskew provided */
+#define V_BCAST (1<<10)
+#define V_PIXMUX (1<<11)
+#define V_DBLCLK (1<<12)
+#define V_CLKDIV2 (1<<13)
+
+#define CRTC_INTERLACE_HALVE_V 0x1 /* halve V values for interlacing */
+#define DPMSModeOn 0
+#define DPMSModeStandby 1
+#define DPMSModeSuspend 2
+#define DPMSModeOff 3
+
+enum drm_output_status {
+ output_status_connected,
+ output_status_disconnected,
+ output_status_unknown,
+};
+
+enum subpixel_order {
+ SubPixelUnknown =3D 0,
+ SubPixelHorizontalRGB,
+ SubPixelHorizontalBGR,
+ SubPixelVerticalRGB,
+ SubPixelVerticalBGR,
+ SubPixelNone,
+};
+
+/*
+ * Describes a given display (e.g. CRT or flat panel) and its=20
limitations.
+ */
+struct drm_display_info {
+ char name[DRM_DISPLAY_INFO_LEN];
+ /* Input info */
+ bool serration_vsync;
+ bool sync_on_green;
+ bool composite_sync;
+ bool separate_syncs;
+ bool blank_to_black;
+ unsigned char video_level;
+ bool digital;
+ /* Physical size */
+ unsigned int width_mm;
+ unsigned int height_mm;
+
+ /* Display parameters */
+ unsigned char gamma; /* FIXME: storage format */
+ bool gtf_supported;
+ bool standard_color;
+ enum {
+ monochrome,
+ rgb,
+ other,
+ unknown,
+ } display_type;
+ bool active_off_supported;
+ bool suspend_supported;
+ bool standby_supported;
+
+ /* Color info FIXME: storage format */
+ unsigned short redx, redy;
+ unsigned short greenx, greeny;
+ unsigned short bluex, bluey;
+ unsigned short whitex, whitey;
+
+ /* Clock limits FIXME: storage format */
+ unsigned int min_vfreq, max_vfreq;
+ unsigned int min_hfreq, max_hfreq;
+ unsigned int pixel_clock;
+
+ /* White point indices FIXME: storage format */
+ unsigned int wpx1, wpy1;
+ unsigned int wpgamma1;
+ unsigned int wpx2, wpy2;
+ unsigned int wpgamma2;
+
+ /* Preferred mode (if any) */
+ struct drm_display_mode *preferred_mode;
+ char *raw_edid; /* if any */
+};
+
+struct drm_framebuffer {
+ struct drm_device *dev;
+ struct list_head head;
+ int id; /* idr assigned */
+ unsigned int pitch;
+ unsigned long offset;
+ unsigned int width;
+ unsigned int height;
+ /* depth can be 15 or 16 */
+ unsigned int depth;
+ int bits_per_pixel;
+ int flags;
+ struct drm_buffer_object *bo;
+ void *fbdev;
+ u32 pseudo_palette[17];
+ void *virtual_base;
+ struct list_head filp_head;
+};
+struct drm_crtc;
+struct drm_output;
+
+/**
+ * drm_crtc_funcs - control CRTCs for a given device
+ * @dpms: control display power levels
+ * @save: save CRTC state
+ * @resore: restore CRTC state
+ * @lock: lock the CRTC
+ * @unlock: unlock the CRTC
+ * @shadow_allocate: allocate shadow pixmap
+ * @shadow_create: create shadow pixmap for rotation support
+ * @shadow_destroy: free shadow pixmap
+ * @mode_fixup: fixup proposed mode
+ * @mode_set: set the desired mode on the CRTC
+ * @gamma_set: specify color ramp for CRTC
+ * @cleanup: cleanup driver private state prior to close
+ *
+ * The drm_crtc_funcs structure is the central CRTC management=20
structure
+ * in the DRM. Each CRTC controls one or more outputs (note that the=20
name
+ * CRTC is simply historical, a CRTC may control LVDS, VGA, DVI, TV=20
out, etc.
+ * outputs, not just CRTs).
+ *
+ * Each driver is responsible for filling out this structure at startup=20
time,
+ * in addition to providing other modesetting features, like i2c and=20
DDC
+ * bus accessors.
+ */
+struct drm_crtc_funcs {
+ /*
+ * Control power levels on the CRTC. If the mode passed in is
+ * unsupported, the provider must use the next lowest power level.
+ */
+ void (*dpms)(struct drm_crtc *crtc, int mode);
+
+ /* JJJ: Are these needed? */
+ /* Save CRTC state */
+ void (*save)(struct drm_crtc *crtc); /* suspend? */
+ /* Restore CRTC state */
+ void (*restore)(struct drm_crtc *crtc); /* resume? */
+ bool (*lock)(struct drm_crtc *crtc);
+ void (*unlock)(struct drm_crtc *crtc);
+
+ void (*prepare)(struct drm_crtc *crtc);
+ void (*commit)(struct drm_crtc *crtc);
+
+ /* Provider can fixup or change mode timings before modeset occurs */
+ bool (*mode_fixup)(struct drm_crtc *crtc,
+ struct drm_display_mode *mode,
+ struct drm_d...
[truncated message content] |