summaryrefslogtreecommitdiff
diff options
context:
space:
mode:
Diffstat
-rw-r--r--libdrm/xf86drmMode.c174
-rw-r--r--libdrm/xf86drmMode.h47
-rw-r--r--linux-core/drm_bufs.c2
-rw-r--r--linux-core/drm_crtc.c657
-rw-r--r--linux-core/drm_crtc.h36
-rw-r--r--linux-core/drm_drv.c9
-rw-r--r--linux-core/drm_modes.c4
-rw-r--r--linux-core/intel_crt.c1
-rw-r--r--linux-core/intel_fb.c62
-rw-r--r--linux-core/intel_modes.c1
-rw-r--r--shared-core/drm.h66
-rw-r--r--tests/mode/modetest.c69
12 files changed, 596 insertions, 532 deletions
diff --git a/libdrm/xf86drmMode.c b/libdrm/xf86drmMode.c
index f697232d..03bd15f1 100644
--- a/libdrm/xf86drmMode.c
+++ b/libdrm/xf86drmMode.c
@@ -42,6 +42,9 @@
#include <drm.h>
#include <string.h>
+#define U642VOID(x) ((void *)(unsigned long)(x))
+#define VOID2U64(x) ((uint64_t)(unsigned long)(x))
+
/*
* Util functions
*/
@@ -101,7 +104,6 @@ void drmModeFreeResources(drmModeResPtr ptr)
if (!ptr)
return;
- drmFree(ptr->modes);
drmFree(ptr);
}
@@ -150,13 +152,11 @@ drmModeResPtr drmModeGetResources(int fd)
return 0;
if (res.count_fbs)
- res.fb_id = drmMalloc(res.count_fbs*sizeof(uint32_t));
+ res.fb_id_ptr = VOID2U64(drmMalloc(res.count_fbs*sizeof(uint32_t)));
if (res.count_crtcs)
- res.crtc_id = drmMalloc(res.count_crtcs*sizeof(uint32_t));
+ res.crtc_id_ptr = VOID2U64(drmMalloc(res.count_crtcs*sizeof(uint32_t)));
if (res.count_outputs)
- res.output_id = drmMalloc(res.count_outputs*sizeof(uint32_t));
- if (res.count_modes)
- res.modes = drmMalloc(res.count_modes*sizeof(*res.modes));
+ res.output_id_ptr = VOID2U64(drmMalloc(res.count_outputs*sizeof(uint32_t)));
if (ioctl(fd, DRM_IOCTL_MODE_GETRESOURCES, &res)) {
r = NULL;
@@ -171,21 +171,22 @@ drmModeResPtr drmModeGetResources(int fd)
if (!(r = drmMalloc(sizeof(*r))))
return 0;
+ r->min_width = res.min_width;
+ r->max_width = res.max_width;
+ r->min_height = res.min_height;
+ r->max_height = res.max_height;
r->count_fbs = res.count_fbs;
r->count_crtcs = res.count_crtcs;
r->count_outputs = res.count_outputs;
- r->count_modes = res.count_modes;
/* TODO we realy should test if these allocs fails. */
- r->fbs = drmAllocCpy(res.fb_id, res.count_fbs, sizeof(uint32_t));
- r->crtcs = drmAllocCpy(res.crtc_id, res.count_crtcs, sizeof(uint32_t));
- r->outputs = drmAllocCpy(res.output_id, res.count_outputs, sizeof(uint32_t));
- r->modes = drmAllocCpy(res.modes, res.count_modes, sizeof(struct drm_mode_modeinfo));
+ r->fbs = drmAllocCpy(U642VOID(res.fb_id_ptr), res.count_fbs, sizeof(uint32_t));
+ r->crtcs = drmAllocCpy(U642VOID(res.crtc_id_ptr), res.count_crtcs, sizeof(uint32_t));
+ r->outputs = drmAllocCpy(U642VOID(res.output_id_ptr), res.count_outputs, sizeof(uint32_t));
err_allocs:
- drmFree(res.fb_id);
- drmFree(res.crtc_id);
- drmFree(res.output_id);
- drmFree(res.modes);
+ drmFree(U642VOID(res.fb_id_ptr));
+ drmFree(U642VOID(res.crtc_id_ptr));
+ drmFree(U642VOID(res.output_id_ptr));
return r;
}
@@ -269,7 +270,9 @@ drmModeCrtcPtr drmModeGetCrtc(int fd, uint32_t crtcId)
r->crtc_id = crtc.crtc_id;
r->x = crtc.x;
r->y = crtc.y;
- r->mode = crtc.mode;
+ r->mode_valid = crtc.mode_valid;
+ if (r->mode_valid)
+ memcpy(&r->mode, &crtc.mode, sizeof(struct drm_mode_modeinfo));
r->buffer_id = crtc.fb_id;
r->gamma_size = crtc.gamma_size;
r->count_outputs = crtc.count_outputs;
@@ -287,8 +290,8 @@ err_allocs:
int drmModeSetCrtc(int fd, uint32_t crtcId, uint32_t bufferId,
- uint32_t x, uint32_t y, uint32_t modeId,
- uint32_t *outputs, int count)
+ uint32_t x, uint32_t y, uint32_t *outputs, int count,
+ struct drm_mode_modeinfo *mode)
{
struct drm_mode_crtc crtc;
@@ -301,9 +304,13 @@ int drmModeSetCrtc(int fd, uint32_t crtcId, uint32_t bufferId,
crtc.y = y;
crtc.crtc_id = crtcId;
crtc.fb_id = bufferId;
- crtc.set_outputs = outputs;
+ crtc.set_outputs_ptr = VOID2U64(outputs);
crtc.count_outputs = count;
- crtc.mode = modeId;
+ if (mode) {
+ memcpy(&crtc.mode, mode, sizeof(struct drm_mode_modeinfo));
+ crtc.mode_valid = 1;
+ } else
+ crtc.mode_valid = 0;
return ioctl(fd, DRM_IOCTL_MODE_SETCRTC, &crtc);
}
@@ -324,21 +331,21 @@ drmModeOutputPtr drmModeGetOutput(int fd, uint32_t output_id)
out.count_clones = 0;
out.clones = 0;
out.count_modes = 0;
- out.modes = 0;
+ out.modes_ptr = 0;
out.count_props = 0;
- out.props = NULL;
- out.prop_values = NULL;
+ out.props_ptr = 0;
+ out.prop_values_ptr = 0;
if (ioctl(fd, DRM_IOCTL_MODE_GETOUTPUT, &out))
return 0;
if (out.count_props) {
- out.props = drmMalloc(out.count_props*sizeof(uint32_t));
- out.prop_values = drmMalloc(out.count_props*sizeof(uint32_t));
+ out.props_ptr = VOID2U64(drmMalloc(out.count_props*sizeof(uint32_t)));
+ out.prop_values_ptr = VOID2U64(drmMalloc(out.count_props*sizeof(uint64_t)));
}
if (out.count_modes)
- out.modes = drmMalloc(out.count_modes*sizeof(uint32_t));
+ out.modes_ptr = VOID2U64(drmMalloc(out.count_modes*sizeof(struct drm_mode_modeinfo)));
if (ioctl(fd, DRM_IOCTL_MODE_GETOUTPUT, &out))
goto err_allocs;
@@ -360,50 +367,36 @@ drmModeOutputPtr drmModeGetOutput(int fd, uint32_t output_id)
r->crtcs = out.crtcs;
r->clones = out.clones;
r->count_props = out.count_props;
- r->props = drmAllocCpy(out.props, out.count_props, sizeof(uint32_t));
- r->prop_values = drmAllocCpy(out.prop_values, out.count_props, sizeof(uint32_t));
- r->modes = drmAllocCpy(out.modes, out.count_modes, sizeof(uint32_t));
+ r->props = drmAllocCpy(U642VOID(out.props_ptr), out.count_props, sizeof(uint32_t));
+ r->prop_values = drmAllocCpy(U642VOID(out.prop_values_ptr), out.count_props, sizeof(uint64_t));
+ r->modes = drmAllocCpy(U642VOID(out.modes_ptr), out.count_modes, sizeof(struct drm_mode_modeinfo));
strncpy(r->name, out.name, DRM_OUTPUT_NAME_LEN);
r->name[DRM_OUTPUT_NAME_LEN-1] = 0;
err_allocs:
- drmFree(out.prop_values);
- drmFree(out.props);
- drmFree(out.modes);
+ drmFree(U642VOID(out.prop_values_ptr));
+ drmFree(U642VOID(out.props_ptr));
+ drmFree(U642VOID(out.modes_ptr));
return r;
}
-uint32_t drmModeAddMode(int fd, struct drm_mode_modeinfo *mode_info)
+int drmModeAttachMode(int fd, uint32_t output_id, struct drm_mode_modeinfo *mode_info)
{
- if (ioctl(fd, DRM_IOCTL_MODE_ADDMODE, mode_info))
- return 0;
-
- return mode_info->id;
-}
-
-int drmModeRmMode(int fd, uint32_t mode_id)
-{
- return ioctl(fd, DRM_IOCTL_MODE_RMMODE, &mode_id);
-}
-
-int drmModeAttachMode(int fd, uint32_t output_id, uint32_t mode_id)
-{
-
struct drm_mode_mode_cmd res;
+ memcpy(&res.mode, mode_info, sizeof(struct drm_mode_modeinfo));
res.output_id = output_id;
- res.mode_id = mode_id;
return ioctl(fd, DRM_IOCTL_MODE_ATTACHMODE, &res);
}
-int drmModeDetachMode(int fd, uint32_t output_id, uint32_t mode_id)
+int drmModeDetachMode(int fd, uint32_t output_id, struct drm_mode_modeinfo *mode_info)
{
struct drm_mode_mode_cmd res;
+ memcpy(&res.mode, mode_info, sizeof(struct drm_mode_modeinfo));
res.output_id = output_id;
- res.mode_id = mode_id;
return ioctl(fd, DRM_IOCTL_MODE_DETACHMODE, &res);
}
@@ -413,22 +406,28 @@ drmModePropertyPtr drmModeGetProperty(int fd, uint32_t property_id)
{
struct drm_mode_get_property prop;
drmModePropertyPtr r;
-
+ struct drm_mode_property_blob *blob_tmp;
+ int i;
prop.prop_id = property_id;
- prop.count_enums = 0;
+ prop.count_enum_blobs = 0;
prop.count_values = 0;
prop.flags = 0;
- prop.enums = NULL;
- prop.values = NULL;
+ prop.enum_blob_ptr = 0;
+ prop.values_ptr = 0;
if (ioctl(fd, DRM_IOCTL_MODE_GETPROPERTY, &prop))
return 0;
if (prop.count_values)
- prop.values = drmMalloc(prop.count_values * sizeof(uint32_t));
+ prop.values_ptr = VOID2U64(drmMalloc(prop.count_values * sizeof(uint64_t)));
+
+ if (prop.count_enum_blobs & (prop.flags & DRM_MODE_PROP_ENUM))
+ prop.enum_blob_ptr = VOID2U64(drmMalloc(prop.count_enum_blobs * sizeof(struct drm_mode_property_enum)));
- if (prop.count_enums)
- prop.enums = drmMalloc(prop.count_enums * sizeof(struct drm_mode_property_enum));
+ if (prop.count_enum_blobs & (prop.flags & DRM_MODE_PROP_BLOB)) {
+ prop.values_ptr = VOID2U64(drmMalloc(prop.count_enum_blobs * sizeof(uint32_t)));
+ prop.enum_blob_ptr = VOID2U64(drmMalloc(prop.count_enum_blobs * sizeof(uint32_t)));
+ }
if (ioctl(fd, DRM_IOCTL_MODE_GETPROPERTY, &prop)) {
r = NULL;
@@ -440,16 +439,24 @@ drmModePropertyPtr drmModeGetProperty(int fd, uint32_t property_id)
r->prop_id = prop.prop_id;
r->count_values = prop.count_values;
- r->count_enums = prop.count_enums;
-
- r->values = drmAllocCpy(prop.values, prop.count_values, sizeof(uint32_t));
- r->enums = drmAllocCpy(prop.enums, prop.count_enums, sizeof(struct drm_mode_property_enum));
+
+ r->flags = prop.flags;
+ if (prop.count_values)
+ r->values = drmAllocCpy(U642VOID(prop.values_ptr), prop.count_values, sizeof(uint64_t));
+ if (prop.flags & DRM_MODE_PROP_ENUM) {
+ r->count_enums = prop.count_enum_blobs;
+ r->enums = drmAllocCpy(U642VOID(prop.enum_blob_ptr), prop.count_enum_blobs, sizeof(struct drm_mode_property_enum));
+ } else if (prop.flags & DRM_MODE_PROP_ENUM) {
+ r->values = drmAllocCpy(U642VOID(prop.values_ptr), prop.count_enum_blobs, sizeof(uint32_t));
+ r->blob_ids = drmAllocCpy(U642VOID(prop.enum_blob_ptr), prop.count_enum_blobs, sizeof(uint32_t));
+ r->count_blobs = prop.count_enum_blobs;
+ }
strncpy(r->name, prop.name, DRM_PROP_NAME_LEN);
r->name[DRM_PROP_NAME_LEN-1] = 0;
err_allocs:
- drmFree(prop.values);
- drmFree(prop.enums);
+ drmFree(U642VOID(prop.values_ptr));
+ drmFree(U642VOID(prop.enum_blob_ptr));
return r;
}
@@ -463,3 +470,44 @@ void drmModeFreeProperty(drmModePropertyPtr ptr)
drmFree(ptr->enums);
drmFree(ptr);
}
+
+drmModePropertyBlobPtr drmModeGetPropertyBlob(int fd, uint32_t blob_id)
+{
+ struct drm_mode_get_blob blob;
+ drmModePropertyBlobPtr r;
+
+ blob.length = 0;
+ blob.data = 0;
+ blob.blob_id = blob_id;
+
+ if (ioctl(fd, DRM_IOCTL_MODE_GETPROPBLOB, &blob))
+ return NULL;
+
+ if (blob.length)
+ blob.data = VOID2U64(drmMalloc(blob.length));
+
+ if (ioctl(fd, DRM_IOCTL_MODE_GETPROPBLOB, &blob)) {
+ r = NULL;
+ goto err_allocs;
+ }
+
+ if (!(r = drmMalloc(sizeof(*r))))
+ return NULL;
+
+ r->id = blob.blob_id;
+ r->length = blob.length;
+ r->data = drmAllocCpy(U642VOID(blob.data), 1, blob.length);
+
+err_allocs:
+ drmFree(U642VOID(blob.data));
+ return r;
+}
+
+void drmModeFreePropertyBlob(drmModePropertyBlobPtr ptr)
+{
+ if (!ptr)
+ return;
+
+ drmFree(ptr->data);
+ drmFree(ptr);
+}
diff --git a/libdrm/xf86drmMode.h b/libdrm/xf86drmMode.h
index 5e966e95..6fcf6a19 100644
--- a/libdrm/xf86drmMode.h
+++ b/libdrm/xf86drmMode.h
@@ -63,22 +63,28 @@ typedef struct _drmModeRes {
int count_outputs;
uint32_t *outputs;
- int count_modes;
- struct drm_mode_modeinfo *modes;
-
+ uint32_t min_width, max_width;
+ uint32_t min_height, max_height;
} drmModeRes, *drmModeResPtr;
typedef struct drm_mode_fb_cmd drmModeFB, *drmModeFBPtr;
+typedef struct _drmModePropertyBlob {
+ uint32_t id;
+ uint32_t length;
+ void *data;
+} drmModePropertyBlobRes, *drmModePropertyBlobPtr;
+
typedef struct _drmModeProperty {
unsigned int prop_id;
unsigned int flags;
unsigned char name[DRM_PROP_NAME_LEN];
int count_values;
- uint32_t *values;
+ uint64_t *values; // store the blob lengths
int count_enums;
struct drm_mode_property_enum *enums;
-
+ int count_blobs;
+ uint32_t *blob_ids; // store the blob IDs
} drmModePropertyRes, *drmModePropertyPtr;
typedef struct _drmModeCrtc {
@@ -87,7 +93,8 @@ typedef struct _drmModeCrtc {
uint32_t x, y; /**< Position on the frameuffer */
uint32_t width, height;
- uint32_t mode; /**< Current mode used */
+ int mode_valid;
+ struct drm_mode_modeinfo mode;
int count_outputs;
uint32_t outputs; /**< Outputs that are connected */
@@ -130,11 +137,11 @@ typedef struct _drmModeOutput {
uint32_t clones; /**< Mask of clones */
int count_modes;
- uint32_t *modes; /**< List of modes ids */
+ struct drm_mode_modeinfo *modes;
int count_props;
uint32_t *props; /**< List of property ids */
- uint32_t *prop_values; /**< List of property values */
+ uint64_t *prop_values; /**< List of property values */
} drmModeOutput, *drmModeOutputPtr;
@@ -185,9 +192,9 @@ extern drmModeCrtcPtr drmModeGetCrtc(int fd, uint32_t crtcId);
/**
* Set the mode on a crtc crtcId with the given mode modeId.
*/
-extern int drmModeSetCrtc(int fd, uint32_t crtcId, uint32_t bufferId,
- uint32_t x, uint32_t y, uint32_t modeId,
- uint32_t *outputs, int count);
+int drmModeSetCrtc(int fd, uint32_t crtcId, uint32_t bufferId,
+ uint32_t x, uint32_t y, uint32_t *outputs, int count,
+ struct drm_mode_modeinfo *mode);
/*
@@ -201,26 +208,18 @@ extern drmModeOutputPtr drmModeGetOutput(int fd,
uint32_t outputId);
/**
- * Adds a new mode from the given mode info.
- * Name must be unique.
- */
-extern uint32_t drmModeAddMode(int fd, struct drm_mode_modeinfo *modeInfo);
-
-/**
- * Removes a mode created with AddMode, must be unused.
- */
-extern int drmModeRmMode(int fd, uint32_t modeId);
-
-/**
* Attaches the given mode to an output.
*/
-extern int drmModeAttachMode(int fd, uint32_t outputId, uint32_t modeId);
+extern int drmModeAttachMode(int fd, uint32_t outputId, struct drm_mode_modeinfo *mode_info);
/**
* Detaches a mode from the output
* must be unused, by the given mode.
*/
-extern int drmModeDetachMode(int fd, uint32_t outputId, uint32_t modeId);
+extern int drmModeDetachMode(int fd, uint32_t outputId, struct drm_mode_modeinfo *mode_info);
extern drmModePropertyPtr drmModeGetProperty(int fd, uint32_t propertyId);
extern void drmModeFreeProperty(drmModePropertyPtr ptr);
+
+extern drmModePropertyBlobPtr drmModeGetPropertyBlob(int fd, uint32_t blob_id);
+extern void drmModeFreePropertyBlob(drmModePropertyBlobPtr ptr);
diff --git a/linux-core/drm_bufs.c b/linux-core/drm_bufs.c
index bfd3dd3d..967e9a2d 100644
--- a/linux-core/drm_bufs.c
+++ b/linux-core/drm_bufs.c
@@ -413,6 +413,8 @@ int drm_rmmap_locked(struct drm_device *dev, drm_local_map_t *map)
case _DRM_SHM:
vfree(map->handle);
dev->sigdata.lock = dev->lock.hw_lock = NULL; /* SHM removed */
+ dev->lock.file_priv = NULL;
+ wake_up_interruptible(&dev->lock.lock_queue);
break;
case _DRM_AGP:
case _DRM_SCATTER_GATHER:
diff --git a/linux-core/drm_crtc.c b/linux-core/drm_crtc.c
index cd60f522..fba275b7 100644
--- a/linux-core/drm_crtc.c
+++ b/linux-core/drm_crtc.c
@@ -280,73 +280,79 @@ static struct drm_display_mode std_mode[] = {
*
* FIXME: take into account monitor limits
*/
-void drm_crtc_probe_output_modes(struct drm_device *dev, int maxX, int maxY)
+void drm_crtc_probe_single_output_modes(struct drm_output *output, int maxX, int maxY)
{
- struct drm_output *output;
+ struct drm_device *dev = output->dev;
struct drm_display_mode *mode, *t;
int ret;
//if (maxX == 0 || maxY == 0)
// 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 = MODE_UNVERIFIED;
+ /* set all modes to the unverified state */
+ list_for_each_entry_safe(mode, t, &output->modes, head)
+ mode->status = MODE_UNVERIFIED;
- output->status = (*output->funcs->detect)(output);
-
- if (output->status == output_status_disconnected) {
- DRM_DEBUG("%s is disconnected\n", output->name);
- /* TODO set EDID to NULL */
- continue;
- }
-
- ret = (*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 == MODE_OK)
- mode->status = (*output->funcs->mode_valid)(output,mode);
- }
+ output->status = (*output->funcs->detect)(output);
+
+ if (output->status == output_status_disconnected) {
+ DRM_DEBUG("%s is disconnected\n", output->name);
+ /* TODO set EDID to NULL */
+ return;
+ }
+
+ ret = (*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 == MODE_OK)
+ mode->status = (*output->funcs->mode_valid)(output,mode);
+ }
+
+
+ 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 = 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 = drm_mode_vrefresh(mode);
+
+ drm_mode_set_crtcinfo(mode, CRTC_INTERLACE_HALVE_V);
+ drm_mode_debug_printmodeline(dev, mode);
+ }
+}
- 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 = 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 = drm_mode_vrefresh(mode);
+void drm_crtc_probe_output_modes(struct drm_device *dev, int maxX, int maxY)
+{
+ struct drm_output *output;
- drm_mode_set_crtcinfo(mode, CRTC_INTERLACE_HALVE_V);
- drm_mode_debug_printmodeline(dev, mode);
- }
+ list_for_each_entry(output, &dev->mode_config.output_list, head) {
+ drm_crtc_probe_single_output_modes(output, maxX, maxY);
}
}
@@ -573,6 +579,7 @@ struct drm_output *drm_output_create(struct drm_device *dev,
strncpy(output->name, name, DRM_OUTPUT_LEN);
output->name[DRM_OUTPUT_LEN - 1] = 0;
output->subpixel_order = SubPixelUnknown;
+ INIT_LIST_HEAD(&output->user_modes);
INIT_LIST_HEAD(&output->probed_modes);
INIT_LIST_HEAD(&output->modes);
/* randr_output? */
@@ -583,6 +590,8 @@ struct drm_output *drm_output_create(struct drm_device *dev,
list_add_tail(&output->head, &dev->mode_config.output_list);
dev->mode_config.num_output++;
+ drm_output_attach_property(output, dev->mode_config.edid_property, 0);
+
mutex_unlock(&dev->mode_config.mutex);
return output;
@@ -614,6 +623,9 @@ void drm_output_destroy(struct drm_output *output)
list_for_each_entry_safe(mode, t, &output->modes, head)
drm_mode_remove(output, mode);
+ list_for_each_entry_safe(mode, t, &output->user_modes, head)
+ drm_mode_remove(output, mode);
+
mutex_lock(&dev->mode_config.mutex);
drm_idr_put(dev, output->id);
list_del(&output->head);
@@ -712,8 +724,11 @@ void drm_mode_config_init(struct drm_device *dev)
INIT_LIST_HEAD(&dev->mode_config.crtc_list);
INIT_LIST_HEAD(&dev->mode_config.output_list);
INIT_LIST_HEAD(&dev->mode_config.property_list);
- INIT_LIST_HEAD(&dev->mode_config.usermode_list);
+ INIT_LIST_HEAD(&dev->mode_config.property_blob_list);
idr_init(&dev->mode_config.crtc_idr);
+ dev->mode_config.edid_property = drm_property_create(dev,
+ DRM_MODE_PROP_BLOB | DRM_MODE_PROP_IMMUTABLE,
+ "EDID", 0);
}
EXPORT_SYMBOL(drm_mode_config_init);
@@ -944,7 +959,6 @@ void drm_mode_config_cleanup(struct drm_device *dev)
struct drm_output *output, *ot;
struct drm_crtc *crtc, *ct;
struct drm_framebuffer *fb, *fbt;
- struct drm_display_mode *mode, *mt;
struct drm_property *property, *pt;
list_for_each_entry_safe(output, ot, &dev->mode_config.output_list, head) {
@@ -955,10 +969,6 @@ void drm_mode_config_cleanup(struct drm_device *dev)
drm_property_destroy(dev, property);
}
- list_for_each_entry_safe(mode, mt, &dev->mode_config.usermode_list, head) {
- drm_mode_destroy(dev, mode);
- }
-
list_for_each_entry_safe(fb, fbt, &dev->mode_config.fb_list, head) {
if (fb->bo->type != drm_bo_type_kernel)
drm_framebuffer_destroy(fb);
@@ -995,7 +1005,7 @@ int drm_crtc_set_config(struct drm_crtc *crtc, struct drm_mode_crtc *crtc_info,
struct drm_device *dev = crtc->dev;
struct drm_crtc **save_crtcs, *new_crtc;
bool save_enabled = crtc->enabled;
- bool changed;
+ bool changed = false;
struct drm_output *output;
int count = 0, ro;
@@ -1009,7 +1019,7 @@ int drm_crtc_set_config(struct drm_crtc *crtc, struct drm_mode_crtc *crtc_info,
if (crtc_info->x != crtc->x || crtc_info->y != crtc->y)
changed = true;
- if (new_mode && (crtc->mode.mode_id != new_mode->mode_id))
+ if (new_mode && !drm_mode_equal(new_mode, &crtc->mode))
changed = true;
list_for_each_entry(output, &dev->mode_config.output_list, head) {
@@ -1068,8 +1078,6 @@ int drm_crtc_set_config(struct drm_crtc *crtc, struct drm_mode_crtc *crtc_info,
*/
void drm_crtc_convert_to_umode(struct drm_mode_modeinfo *out, struct drm_display_mode *in)
{
-
- out->id = in->mode_id;
out->clock = in->clock;
out->hdisplay = in->hdisplay;
out->hsync_start = in->hsync_start;
@@ -1145,16 +1153,14 @@ int drm_mode_getresources(struct drm_device *dev,
struct drm_framebuffer *fb;
struct drm_output *output;
struct drm_crtc *crtc;
- struct drm_mode_modeinfo u_mode;
- struct drm_display_mode *mode;
int ret = 0;
- int mode_count= 0;
int output_count = 0;
int crtc_count = 0;
int fb_count = 0;
int copied = 0;
-
- memset(&u_mode, 0, sizeof(struct drm_mode_modeinfo));
+ uint32_t __user *fb_id;
+ uint32_t __user *crtc_id;
+ uint32_t __user *output_id;
mutex_lock(&dev->mode_config.mutex);
@@ -1164,34 +1170,24 @@ int drm_mode_getresources(struct drm_device *dev,
list_for_each(lh, &dev->mode_config.crtc_list)
crtc_count++;
- list_for_each_entry(output, &dev->mode_config.output_list,
- head) {
+ list_for_each(lh, &dev->mode_config.output_list)
output_count++;
- list_for_each(lh, &output->modes)
- mode_count++;
- }
- list_for_each(lh, &dev->mode_config.usermode_list)
- mode_count++;
- if (card_res->count_modes == 0) {
- DRM_DEBUG("probing modes %dx%d\n", dev->mode_config.max_width, dev->mode_config.max_height);
- drm_crtc_probe_output_modes(dev, dev->mode_config.max_width, dev->mode_config.max_height);
- mode_count = 0;
- list_for_each_entry(output, &dev->mode_config.output_list, head) {
- list_for_each(lh, &output->modes)
- mode_count++;
- }
- list_for_each(lh, &dev->mode_config.usermode_list)
- mode_count++;
- }
+ card_res->max_height = dev->mode_config.max_height;
+ card_res->min_height = dev->mode_config.min_height;
+ card_res->max_width = dev->mode_config.max_width;
+ card_res->min_width = dev->mode_config.min_width;
/* handle this in 4 parts */
/* FBs */
if (card_res->count_fbs >= fb_count) {
copied = 0;
+ fb_id = (uint32_t *)(unsigned long)card_res->fb_id_ptr;
list_for_each_entry(fb, &dev->mode_config.fb_list, head) {
- if (put_user(fb->id, card_res->fb_id + copied))
- return -EFAULT;
+ if (put_user(fb->id, fb_id + copied)) {
+ ret = -EFAULT;
+ goto out;
+ }
copied++;
}
}
@@ -1200,10 +1196,13 @@ int drm_mode_getresources(struct drm_device *dev,
/* CRTCs */
if (card_res->count_crtcs >= crtc_count) {
copied = 0;
+ crtc_id = (uint32_t *)(unsigned long)card_res->crtc_id_ptr;
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))
- return -EFAULT;
+ if (put_user(crtc->id, crtc_id + copied)) {
+ ret = -EFAULT;
+ goto out;
+ }
copied++;
}
}
@@ -1213,44 +1212,23 @@ int drm_mode_getresources(struct drm_device *dev,
/* Outputs */
if (card_res->count_outputs >= output_count) {
copied = 0;
+ output_id = (uint32_t *)(unsigned long)card_res->output_id_ptr;
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))
- return -EFAULT;
+ if (put_user(output->id, output_id + copied)) {
+ ret = -EFAULT;
+ goto out;
+ }
copied++;
}
}
card_res->count_outputs = output_count;
- /* Modes */
- if (card_res->count_modes >= mode_count) {
- copied = 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(u_mode)))
- return -EFAULT;
- copied++;
- }
- }
- /* add in user modes */
- list_for_each_entry(mode, &dev->mode_config.usermode_list, head) {
- drm_crtc_convert_to_umode(&u_mode, mode);
- if (copy_to_user(card_res->modes + copied, &u_mode,
- sizeof(u_mode)))
- return -EFAULT;
- copied++;
- }
- }
- card_res->count_modes = mode_count;
+ DRM_DEBUG("Counted %d %d\n", card_res->count_crtcs,
+ card_res->count_outputs);
- DRM_DEBUG("Counted %d %d %d\n", card_res->count_crtcs,
- card_res->count_outputs,
- card_res->count_modes);
-
+out:
mutex_unlock(&dev->mode_config.mutex);
return ret;
}
@@ -1299,14 +1277,16 @@ int drm_mode_getcrtc(struct drm_device *dev,
crtc_resp->outputs = 0;
if (crtc->enabled) {
- crtc_resp->mode = crtc->mode.mode_id;
+ drm_crtc_convert_to_umode(&crtc_resp->mode, &crtc->mode);
+ crtc_resp->mode_valid = 1;
ocount = 0;
list_for_each_entry(output, &dev->mode_config.output_list, head) {
if (output->crtc == crtc)
crtc_resp->outputs |= 1 << (ocount++);
}
+
} else {
- crtc_resp->mode = 0;
+ crtc_resp->mode_valid = 0;
}
out:
@@ -1342,6 +1322,12 @@ int drm_mode_getoutput(struct drm_device *dev,
int ret = 0;
int copied = 0;
int i;
+ struct drm_mode_modeinfo u_mode;
+ struct drm_mode_modeinfo __user *mode_ptr;
+ uint32_t __user *prop_ptr;
+ uint64_t __user *prop_values;
+
+ memset(&u_mode, 0, sizeof(struct drm_mode_modeinfo));
DRM_DEBUG("output id %d:\n", out_resp->output);
@@ -1355,16 +1341,16 @@ int drm_mode_getoutput(struct drm_device *dev,
list_for_each_entry(mode, &output->modes, head)
mode_count++;
- for (i = 0; i < DRM_OUTPUT_MAX_UMODES; i++)
- if (output->user_mode_ids[i] != 0)
- mode_count++;
-
for (i = 0; i < DRM_OUTPUT_MAX_PROPERTY; i++) {
if (output->property_ids[i] != 0) {
props_count++;
}
}
+ if (out_resp->count_modes == 0) {
+ drm_crtc_probe_single_output_modes(output, dev->mode_config.max_width, dev->mode_config.max_height);
+ }
+
strncpy(out_resp->name, output->name, DRM_OUTPUT_NAME_LEN);
out_resp->name[DRM_OUTPUT_NAME_LEN-1] = 0;
@@ -1382,29 +1368,32 @@ int drm_mode_getoutput(struct drm_device *dev,
if ((out_resp->count_modes >= mode_count) && mode_count) {
copied = 0;
+ mode_ptr = (struct drm_mode_modeinfo *)(unsigned long)out_resp->modes_ptr;
list_for_each_entry(mode, &output->modes, head) {
- out_resp->modes[copied++] = mode->mode_id;
- }
- for (i = 0; i < DRM_OUTPUT_MAX_UMODES; i++) {
- if (output->user_mode_ids[i] != 0) {
- if (put_user(output->user_mode_ids[i], out_resp->modes + copied))
- return -EFAULT;
- copied++;
+ drm_crtc_convert_to_umode(&u_mode, mode);
+ if (copy_to_user(mode_ptr + copied,
+ &u_mode, sizeof(u_mode))) {
+ ret = -EFAULT;
+ goto out;
}
+ copied++;
+
}
}
out_resp->count_modes = mode_count;
if ((out_resp->count_props >= props_count) && props_count) {
copied = 0;
+ prop_ptr = (uint32_t *)(unsigned long)(out_resp->props_ptr);
+ prop_values = (uint64_t *)(unsigned long)(out_resp->prop_values_ptr);
for (i = 0; i < DRM_OUTPUT_MAX_PROPERTY; i++) {
if (output->property_ids[i] != 0) {
- if (put_user(output->property_ids[i], out_resp->props + copied)) {
+ if (put_user(output->property_ids[i], prop_ptr + copied)) {
ret = -EFAULT;
goto out;
}
- if (put_user(output->property_values[i], out_resp->prop_values + copied)) {
+ if (put_user(output->property_values[i], prop_values + copied)) {
ret = -EFAULT;
goto out;
}
@@ -1442,10 +1431,11 @@ int drm_mode_setcrtc(struct drm_device *dev,
struct drm_mode_crtc *crtc_req = data;
struct drm_crtc *crtc;
struct drm_output **output_set = NULL, *output;
- struct drm_display_mode *mode;
struct drm_framebuffer *fb = NULL;
+ struct drm_display_mode *mode = NULL;
int ret = 0;
int i;
+ uint32_t __user *set_outputs_ptr;
mutex_lock(&dev->mode_config.mutex);
crtc = idr_find(&dev->mode_config.crtc_idr, crtc_req->crtc_id);
@@ -1455,7 +1445,7 @@ int drm_mode_setcrtc(struct drm_device *dev,
goto out;
}
- if (crtc_req->mode) {
+ if (crtc_req->mode_valid) {
/* if we have a mode we need a framebuffer */
if (crtc_req->fb_id) {
fb = idr_find(&dev->mode_config.crtc_idr, crtc_req->fb_id);
@@ -1465,26 +1455,10 @@ int drm_mode_setcrtc(struct drm_device *dev,
goto out;
}
}
- mode = idr_find(&dev->mode_config.crtc_idr, crtc_req->mode);
- if (!mode || (mode->mode_id != crtc_req->mode)) {
- struct drm_output *output;
-
- 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);
- ret = -EINVAL;
- goto out;
- }
- } else
- mode = NULL;
+ mode = drm_mode_create(dev);
+ drm_crtc_convert_umode(mode, &crtc_req->mode);
+ }
if (crtc_req->count_outputs == 0 && mode) {
DRM_DEBUG("Count outputs is 0 but mode set\n");
@@ -1508,7 +1482,8 @@ int drm_mode_setcrtc(struct drm_device *dev,
}
for (i = 0; i < crtc_req->count_outputs; i++) {
- if (get_user(out_id, &crtc_req->set_outputs[i])) {
+ set_outputs_ptr = (uint32_t *)(unsigned long)crtc_req->set_outputs_ptr;
+ if (get_user(out_id, &set_outputs_ptr[i])) {
ret = -EFAULT;
goto out;
}
@@ -1523,7 +1498,7 @@ int drm_mode_setcrtc(struct drm_device *dev,
output_set[i] = output;
}
}
-
+
ret = drm_crtc_set_config(crtc, crtc_req, mode, output_set, fb);
out:
@@ -1733,49 +1708,14 @@ void drm_fb_release(struct file *filp)
/*
*
*/
-void drm_mode_addmode(struct drm_device *dev, struct drm_display_mode *user_mode)
-{
- user_mode->type |= DRM_MODE_TYPE_USERDEF;
-
- user_mode->output_count = 0;
- list_add(&user_mode->head, &dev->mode_config.usermode_list);
-}
-EXPORT_SYMBOL(drm_mode_addmode);
-
-int drm_mode_rmmode(struct drm_device *dev, struct drm_display_mode *mode)
-{
- struct drm_display_mode *t;
- int ret = -EINVAL;
- list_for_each_entry(t, &dev->mode_config.usermode_list, head) {
- if (t == mode) {
- list_del(&mode->head);
- drm_mode_destroy(dev, mode);
- ret = 0;
- break;
- }
- }
- return ret;
-}
-EXPORT_SYMBOL(drm_mode_rmmode);
static int drm_mode_attachmode(struct drm_device *dev,
struct drm_output *output,
struct drm_display_mode *mode)
{
int ret = 0;
- int i;
-
- for (i = 0; i < DRM_OUTPUT_MAX_UMODES; i++) {
- if (output->user_mode_ids[i] == 0) {
- output->user_mode_ids[i] = mode->mode_id;
- mode->output_count++;
- break;
- }
- }
-
- if (i == DRM_OUTPUT_MAX_UMODES)
- ret = -ENOSPC;
+ list_add_tail(&mode->head, &output->user_modes);
return ret;
}
@@ -1783,11 +1723,22 @@ int drm_mode_attachmode_crtc(struct drm_device *dev, struct drm_crtc *crtc,
struct drm_display_mode *mode)
{
struct drm_output *output;
-
+ int ret = 0;
+ struct drm_display_mode *dup_mode;
+ int need_dup = 0;
list_for_each_entry(output, &dev->mode_config.output_list, head) {
- if (output->crtc == crtc)
- drm_mode_attachmode(dev, output, mode);
+ if (output->crtc == crtc) {
+ if (need_dup)
+ dup_mode = drm_mode_duplicate(dev, mode);
+ else
+ dup_mode = mode;
+ ret = drm_mode_attachmode(dev, output, dup_mode);
+ if (ret)
+ return ret;
+ need_dup = 1;
+ }
}
+ return 0;
}
EXPORT_SYMBOL(drm_mode_attachmode_crtc);
@@ -1796,13 +1747,15 @@ static int drm_mode_detachmode(struct drm_device *dev,
struct drm_display_mode *mode)
{
int found = 0;
- int ret = 0, i;
+ int ret = 0;
+ struct drm_display_mode *match_mode, *t;
- for (i = 0; i < DRM_OUTPUT_MAX_UMODES; i++) {
- if (output->user_mode_ids[i] == mode->mode_id) {
- output->user_mode_ids[i] = 0;
- mode->output_count--;
+ list_for_each_entry_safe(match_mode, t, &output->user_modes, head) {
+ if (drm_mode_equal(match_mode, mode)) {
+ list_del(&match_mode->head);
+ drm_mode_destroy(dev, match_mode);
found = 1;
+ break;
}
}
@@ -1824,87 +1777,6 @@ int drm_mode_detachmode_crtc(struct drm_device *dev, struct drm_display_mode *mo
EXPORT_SYMBOL(drm_mode_detachmode_crtc);
/**
- * drm_fb_addmode - adds a user defined mode
- * @inode: inode from the ioctl
- * @filp: file * from the ioctl
- * @cmd: cmd from ioctl
- * @arg: arg from ioctl
- *
- * Adds a user specified mode to the kernel.
- *
- * Called by the user via ioctl.
- *
- * RETURNS:
- * writes new mode id into arg.
- * Zero on success, errno on failure.
- */
-int drm_mode_addmode_ioctl(struct drm_device *dev,
- void *data, struct drm_file *file_priv)
-{
- struct drm_mode_modeinfo *new_mode = data;
- struct drm_display_mode *user_mode;
- int ret = 0;
-
- mutex_lock(&dev->mode_config.mutex);
- user_mode = drm_mode_create(dev);
- if (!user_mode) {
- ret = -ENOMEM;
- goto out;
- }
-
- drm_crtc_convert_umode(user_mode, new_mode);
-
- drm_mode_addmode(dev, user_mode);
- new_mode->id = user_mode->mode_id;
-
-out:
- mutex_unlock(&dev->mode_config.mutex);
- return ret;
-}
-
-/**
- * drm_fb_rmmode - removes a user defined mode
- * @inode: inode from the ioctl
- * @filp: file * from the ioctl
- * @cmd: cmd from ioctl
- * @arg: arg from ioctl
- *
- * Remove the user defined mode specified by the user.
- *
- * Called by the user via ioctl
- *
- * RETURNS:
- * Zero on success, errno on failure.
- */
-int drm_mode_rmmode_ioctl(struct drm_device *dev,
- void *data, struct drm_file *file_priv)
-{
- uint32_t *id = data;
- struct drm_display_mode *mode;
- int ret = -EINVAL;
-
- mutex_lock(&dev->mode_config.mutex);
- mode = idr_find(&dev->mode_config.crtc_idr, *id);
- if (!mode || (*id != mode->mode_id)) {
- goto out;
- }
-
- if (!(mode->type & DRM_MODE_TYPE_USERDEF)) {
- goto out;
- }
-
- if (mode->output_count) {
- goto out;
- }
-
- ret = drm_mode_rmmode(dev, mode);
-
-out:
- mutex_unlock(&dev->mode_config.mutex);
- return ret;
-}
-
-/**
* drm_fb_attachmode - Attach a user mode to an output
* @inode: inode from the ioctl
* @filp: file * from the ioctl
@@ -1923,21 +1795,24 @@ int drm_mode_attachmode_ioctl(struct drm_device *dev,
struct drm_mode_mode_cmd *mode_cmd = data;
struct drm_output *output;
struct drm_display_mode *mode;
+ struct drm_mode_modeinfo *umode = &mode_cmd->mode;
int ret = 0;
mutex_lock(&dev->mode_config.mutex);
- mode = idr_find(&dev->mode_config.crtc_idr, mode_cmd->mode_id);
- if (!mode || (mode->mode_id != mode_cmd->mode_id)) {
+ output = idr_find(&dev->mode_config.crtc_idr, mode_cmd->output_id);
+ if (!output || (output->id != mode_cmd->output_id)) {
ret = -EINVAL;
goto out;
}
- output = idr_find(&dev->mode_config.crtc_idr, mode_cmd->output_id);
- if (!output || (output->id != mode_cmd->output_id)) {
- ret = -EINVAL;
+ mode = drm_mode_create(dev);
+ if (!mode) {
+ ret = -ENOMEM;
goto out;
}
+
+ drm_crtc_convert_umode(mode, umode);
ret = drm_mode_attachmode(dev, output, mode);
out:
@@ -1963,25 +1838,20 @@ int drm_mode_detachmode_ioctl(struct drm_device *dev,
{
struct drm_mode_mode_cmd *mode_cmd = data;
struct drm_output *output;
- struct drm_display_mode *mode;
+ struct drm_display_mode mode;
+ struct drm_mode_modeinfo *umode = &mode_cmd->mode;
int ret = 0;
mutex_lock(&dev->mode_config.mutex);
- mode = idr_find(&dev->mode_config.crtc_idr, mode_cmd->mode_id);
- if (!mode || (mode->mode_id != mode_cmd->mode_id)) {
- ret = -EINVAL;
- goto out;
- }
-
output = idr_find(&dev->mode_config.crtc_idr, mode_cmd->output_id);
if (!output || (output->id != mode_cmd->output_id)) {
ret = -EINVAL;
goto out;
}
-
-
- ret = drm_mode_detachmode(dev, output, mode);
+
+ drm_crtc_convert_umode(&mode, umode);
+ ret = drm_mode_detachmode(dev, output, &mode);
out:
mutex_unlock(&dev->mode_config.mutex);
return ret;
@@ -1995,15 +1865,17 @@ struct drm_property *drm_property_create(struct drm_device *dev, int flags,
property = kzalloc(sizeof(struct drm_output), GFP_KERNEL);
if (!property)
return NULL;
-
- property->values = kzalloc(sizeof(uint32_t)*num_values, GFP_KERNEL);
- if (!property->values)
- goto fail;
+
+ if (num_values) {
+ property->values = kzalloc(sizeof(uint64_t)*num_values, GFP_KERNEL);
+ if (!property->values)
+ goto fail;
+ }
property->id = drm_idr_get(dev, property);
property->flags = flags;
property->num_values = num_values;
- INIT_LIST_HEAD(&property->enum_list);
+ INIT_LIST_HEAD(&property->enum_blob_list);
if (name)
strncpy(property->name, name, DRM_PROP_NAME_LEN);
@@ -2017,15 +1889,15 @@ fail:
EXPORT_SYMBOL(drm_property_create);
int drm_property_add_enum(struct drm_property *property, int index,
- uint32_t value, const char *name)
+ uint64_t value, const char *name)
{
struct drm_property_enum *prop_enum;
if (!(property->flags & DRM_MODE_PROP_ENUM))
return -EINVAL;
- if (!list_empty(&property->enum_list)) {
- list_for_each_entry(prop_enum, &property->enum_list, head) {
+ if (!list_empty(&property->enum_blob_list)) {
+ list_for_each_entry(prop_enum, &property->enum_blob_list, head) {
if (prop_enum->value == value) {
strncpy(prop_enum->name, name, DRM_PROP_NAME_LEN);
prop_enum->name[DRM_PROP_NAME_LEN-1] = '\0';
@@ -2043,7 +1915,7 @@ int drm_property_add_enum(struct drm_property *property, int index,
prop_enum->value = value;
property->values[index] = value;
- list_add_tail(&prop_enum->head, &property->enum_list);
+ list_add_tail(&prop_enum->head, &property->enum_blob_list);
return 0;
}
EXPORT_SYMBOL(drm_property_add_enum);
@@ -2052,21 +1924,21 @@ void drm_property_destroy(struct drm_device *dev, struct drm_property *property)
{
struct drm_property_enum *prop_enum, *pt;
- list_for_each_entry_safe(prop_enum, pt, &property->enum_list, head) {
+ list_for_each_entry_safe(prop_enum, pt, &property->enum_blob_list, head) {
list_del(&prop_enum->head);
kfree(prop_enum);
}
- kfree(property->values);
+ if (property->num_values)
+ kfree(property->values);
drm_idr_put(dev, property->id);
list_del(&property->head);
kfree(property);
}
EXPORT_SYMBOL(drm_property_destroy);
-
int drm_output_attach_property(struct drm_output *output,
- struct drm_property *property, int init_val)
+ struct drm_property *property, uint64_t init_val)
{
int i;
@@ -2084,16 +1956,40 @@ int drm_output_attach_property(struct drm_output *output,
}
EXPORT_SYMBOL(drm_output_attach_property);
+int drm_output_property_set_value(struct drm_output *output,
+ struct drm_property *property, uint64_t value)
+{
+ int i;
+
+ for (i = 0; i < DRM_OUTPUT_MAX_PROPERTY; i++) {
+ if (output->property_ids[i] == property->id) {
+ output->property_values[i] = value;
+ break;
+ }
+ }
+
+ if (i == DRM_OUTPUT_MAX_PROPERTY)
+ return -EINVAL;
+ return 0;
+}
+EXPORT_SYMBOL(drm_output_property_set_value);
+
int drm_mode_getproperty_ioctl(struct drm_device *dev,
void *data, struct drm_file *file_priv)
{
struct drm_mode_get_property *out_resp = data;
struct drm_property *property;
int enum_count = 0;
+ int blob_count = 0;
int value_count = 0;
int ret = 0, i;
int copied;
struct drm_property_enum *prop_enum;
+ struct drm_property_enum __user *enum_ptr;
+ struct drm_property_blob *prop_blob;
+ uint32_t *blob_id_ptr;
+ uint64_t __user *values_ptr;
+ uint32_t __user *blob_length_ptr;
mutex_lock(&dev->mode_config.mutex);
property = idr_find(&dev->mode_config.crtc_idr, out_resp->prop_id);
@@ -2102,9 +1998,13 @@ int drm_mode_getproperty_ioctl(struct drm_device *dev,
goto done;
}
-
- list_for_each_entry(prop_enum, &property->enum_list, head)
- enum_count++;
+ if (property->flags & DRM_MODE_PROP_ENUM) {
+ list_for_each_entry(prop_enum, &property->enum_blob_list, head)
+ enum_count++;
+ } else if (property->flags & DRM_MODE_PROP_BLOB) {
+ list_for_each_entry(prop_blob, &property->enum_blob_list, head)
+ blob_count++;
+ }
value_count = property->num_values;
@@ -2113,8 +2013,9 @@ int drm_mode_getproperty_ioctl(struct drm_device *dev,
out_resp->flags = property->flags;
if ((out_resp->count_values >= value_count) && value_count) {
+ values_ptr = (uint64_t *)(unsigned long)out_resp->values_ptr;
for (i = 0; i < value_count; i++) {
- if (put_user(property->values[i], out_resp->values + i)) {
+ if (put_user(property->values[i], values_ptr + i)) {
ret = -EFAULT;
goto done;
}
@@ -2122,25 +2023,125 @@ int drm_mode_getproperty_ioctl(struct drm_device *dev,
}
out_resp->count_values = value_count;
- if ((out_resp->count_enums >= enum_count) && enum_count) {
- copied = 0;
- list_for_each_entry(prop_enum, &property->enum_list, head) {
- if (put_user(prop_enum->value, &out_resp->enums[copied].value)) {
+ if (property->flags & DRM_MODE_PROP_ENUM) {
+ if ((out_resp->count_enum_blobs >= enum_count) && enum_count) {
+ copied = 0;
+ enum_ptr = (struct drm_property_enum *)(unsigned long)out_resp->enum_blob_ptr;
+ list_for_each_entry(prop_enum, &property->enum_blob_list, head) {
+ if (put_user(prop_enum->value, &enum_ptr[copied].value)) {
+ ret = -EFAULT;
+ goto done;
+ }
+
+ if (copy_to_user(&enum_ptr[copied].name,
+ prop_enum->name, DRM_PROP_NAME_LEN)) {
ret = -EFAULT;
goto done;
+ }
+ copied++;
}
+ }
+ out_resp->count_enum_blobs = enum_count;
+ }
- if (copy_to_user(&out_resp->enums[copied].name,
- prop_enum->name, DRM_PROP_NAME_LEN)) {
- ret = -EFAULT;
- goto done;
+ if (property->flags & DRM_MODE_PROP_BLOB) {
+ if ((out_resp->count_enum_blobs >= blob_count) && blob_count) {
+ copied = 0;
+ blob_id_ptr = (uint32_t *)(unsigned long)out_resp->enum_blob_ptr;
+ blob_length_ptr = (uint32_t *)(unsigned long)out_resp->values_ptr;
+
+ list_for_each_entry(prop_blob, &property->enum_blob_list, head) {
+ if (put_user(prop_blob->id, blob_id_ptr + copied)) {
+ ret = -EFAULT;
+ goto done;
+ }
+
+ if (put_user(prop_blob->length, blob_length_ptr + copied)) {
+ ret = -EFAULT;
+ goto done;
+ }
+
+ copied++;
}
- copied++;
}
+ out_resp->count_enum_blobs = enum_count;
}
- out_resp->count_enums = enum_count;
+done:
+ mutex_unlock(&dev->mode_config.mutex);
+ return ret;
+}
+
+static struct drm_property_blob *drm_property_create_blob(struct drm_device *dev, int length,
+ void *data)
+{
+ struct drm_property_blob *blob;
+
+ if (!length || !data)
+ return NULL;
+
+ blob = kzalloc(sizeof(struct drm_property_blob)+length, GFP_KERNEL);
+ if (!blob)
+ return NULL;
+
+ blob->data = (void *)((char *)blob + sizeof(struct drm_property_blob));
+ blob->length = length;
+
+ memcpy(blob->data, data, length);
+
+ blob->id = drm_idr_get(dev, blob);
+
+ list_add_tail(&blob->head, &dev->mode_config.property_blob_list);
+ return blob;
+}
+
+static void drm_property_destroy_blob(struct drm_device *dev,
+ struct drm_property_blob *blob)
+{
+ drm_idr_put(dev, blob->id);
+ list_del(&blob->head);
+ kfree(blob);
+}
+
+int drm_mode_getblob_ioctl(struct drm_device *dev,
+ void *data, struct drm_file *file_priv)
+{
+ struct drm_mode_get_blob *out_resp = data;
+ struct drm_property_blob *blob;
+ int ret = 0;
+ void *blob_ptr;
+
+ mutex_lock(&dev->mode_config.mutex);
+
+ blob = idr_find(&dev->mode_config.crtc_idr, out_resp->blob_id);
+ if (!blob || (blob->id != out_resp->blob_id)) {
+ ret = -EINVAL;
+ goto done;
+ }
+
+ if (out_resp->length == blob->length) {
+ blob_ptr = (void *)(unsigned long)out_resp->data;
+ if (copy_to_user(blob_ptr, blob->data, blob->length)){
+ ret = -EFAULT;
+ goto done;
+ }
+ }
+ out_resp->length = blob->length;
done:
mutex_unlock(&dev->mode_config.mutex);
return ret;
}
+
+int drm_mode_output_update_edid_property(struct drm_output *output, unsigned char *edid)
+{
+ struct drm_device *dev = output->dev;
+ int ret = 0;
+ if (output->edid_blob_ptr)
+ drm_property_destroy_blob(dev, output->edid_blob_ptr);
+
+ output->edid_blob_ptr = drm_property_create_blob(output->dev, 128, edid);
+
+ ret = drm_output_property_set_value(output, dev->mode_config.edid_property, output->edid_blob_ptr->id);
+ return ret;
+}
+EXPORT_SYMBOL(drm_mode_output_update_edid_property);
diff --git a/linux-core/drm_crtc.h b/linux-core/drm_crtc.h
index 011903ce..2c77d9d7 100644
--- a/linux-core/drm_crtc.h
+++ b/linux-core/drm_crtc.h
@@ -234,9 +234,16 @@ struct drm_framebuffer {
struct list_head filp_head;
};
+struct drm_property_blob {
+ struct list_head head;
+ unsigned int length;
+ unsigned int id;
+ void *data;
+};
+
struct drm_property_enum {
struct list_head head;
- uint32_t value;
+ uint64_t value;
unsigned char name[DRM_PROP_NAME_LEN];
};
@@ -246,9 +253,9 @@ struct drm_property {
uint32_t flags;
char name[DRM_PROP_NAME_LEN];
uint32_t num_values;
- uint32_t *values;
+ uint64_t *values;
- struct list_head enum_list;
+ struct list_head enum_blob_list;
};
struct drm_crtc;
@@ -448,10 +455,10 @@ struct drm_output {
const struct drm_output_funcs *funcs;
void *driver_private;
- u32 user_mode_ids[DRM_OUTPUT_MAX_UMODES];
-
+ struct list_head user_modes;
+ struct drm_property_blob *edid_blob_ptr;
u32 property_ids[DRM_OUTPUT_MAX_PROPERTY];
- u32 property_values[DRM_OUTPUT_MAX_PROPERTY];
+ uint64_t property_values[DRM_OUTPUT_MAX_PROPERTY];
};
/**
@@ -484,8 +491,6 @@ struct drm_mode_config {
int num_crtc;
struct list_head crtc_list;
- struct list_head usermode_list;
-
struct list_head property_list;
int min_width, min_height;
@@ -494,6 +499,10 @@ struct drm_mode_config {
/* DGA stuff? */
struct drm_mode_config_funcs *funcs;
unsigned long fb_base;
+
+ /* pointers to standard properties */
+ struct list_head property_blob_list;
+ struct drm_property *edid_property;
};
struct drm_output *drm_output_create(struct drm_device *dev,
@@ -518,9 +527,6 @@ extern void drm_mode_set_name(struct drm_display_mode *mode);
extern bool drm_mode_equal(struct drm_display_mode *mode1, struct drm_display_mode *mode2);
extern void drm_disable_unused_functions(struct drm_device *dev);
-extern void drm_mode_addmode(struct drm_device *dev, struct drm_display_mode *user_mode);
-extern int drm_mode_rmmode(struct drm_device *dev, struct drm_display_mode *mode);
-
/* for us by fb module */
extern int drm_mode_attachmode_crtc(struct drm_device *dev,
struct drm_crtc *crtc,
@@ -541,7 +547,7 @@ extern int drm_mode_vrefresh(struct drm_display_mode *mode);
extern void drm_mode_set_crtcinfo(struct drm_display_mode *p,
int adjust_flags);
extern void drm_mode_output_list_update(struct drm_output *output);
-
+extern int drm_mode_output_update_edid_property(struct drm_output *output, unsigned char *edid);
extern struct drm_display_mode *drm_crtc_mode_create(struct drm_device *dev);
extern bool drm_initial_config(struct drm_device *dev, bool cangrow);
extern void drm_framebuffer_set_object(struct drm_device *dev,
@@ -554,12 +560,12 @@ extern bool drm_crtc_set_mode(struct drm_crtc *crtc, struct drm_display_mode *mo
int x, int y);
extern int drm_output_attach_property(struct drm_output *output,
- struct drm_property *property, int init_val);
+ struct drm_property *property, uint64_t init_val);
extern struct drm_property *drm_property_create(struct drm_device *dev, int flags,
const char *name, int num_values);
extern void drm_property_destroy(struct drm_device *dev, struct drm_property *property);
extern int drm_property_add_enum(struct drm_property *property, int index,
- uint32_t value, const char *name);
+ uint64_t value, const char *name);
/* IOCTLs */
extern int drm_mode_getresources(struct drm_device *dev,
@@ -588,5 +594,7 @@ extern int drm_mode_detachmode_ioctl(struct drm_device *dev,
extern int drm_mode_getproperty_ioctl(struct drm_device *dev,
void *data, struct drm_file *file_priv);
+extern int drm_mode_getblob_ioctl(struct drm_device *dev,
+ void *data, struct drm_file *file_priv);
#endif /* __DRM_CRTC_H__ */
diff --git a/linux-core/drm_drv.c b/linux-core/drm_drv.c
index b3e00e84..f8665be7 100644
--- a/linux-core/drm_drv.c
+++ b/linux-core/drm_drv.c
@@ -124,8 +124,8 @@ static struct drm_ioctl_desc drm_ioctls[] = {
DRM_IOCTL_DEF(DRM_IOCTL_MODE_ADDFB, drm_mode_addfb, DRM_MASTER|DRM_ROOT_ONLY),
DRM_IOCTL_DEF(DRM_IOCTL_MODE_RMFB, drm_mode_rmfb, DRM_MASTER|DRM_ROOT_ONLY),
DRM_IOCTL_DEF(DRM_IOCTL_MODE_GETFB, drm_mode_getfb, DRM_MASTER|DRM_ROOT_ONLY),
- DRM_IOCTL_DEF(DRM_IOCTL_MODE_ADDMODE, drm_mode_addmode_ioctl, DRM_MASTER|DRM_ROOT_ONLY),
- DRM_IOCTL_DEF(DRM_IOCTL_MODE_RMMODE, drm_mode_rmmode_ioctl, DRM_MASTER|DRM_ROOT_ONLY),
+
+ DRM_IOCTL_DEF(DRM_IOCTL_MODE_GETPROPBLOB, drm_mode_getblob_ioctl, DRM_MASTER|DRM_ROOT_ONLY),
DRM_IOCTL_DEF(DRM_IOCTL_MODE_ATTACHMODE, drm_mode_attachmode_ioctl, DRM_MASTER|DRM_ROOT_ONLY),
DRM_IOCTL_DEF(DRM_IOCTL_MODE_DETACHMODE, drm_mode_detachmode_ioctl, DRM_MASTER|DRM_ROOT_ONLY),
DRM_IOCTL_DEF(DRM_IOCTL_MODE_GETPROPERTY, drm_mode_getproperty_ioctl, DRM_MASTER | DRM_ROOT_ONLY),
@@ -277,11 +277,6 @@ int drm_lastclose(struct drm_device * dev)
if (drm_core_check_feature(dev, DRIVER_HAVE_DMA))
drm_dma_takedown(dev);
- if (dev->lock.hw_lock) {
- dev->sigdata.lock = dev->lock.hw_lock = NULL; /* SHM removed */
- dev->lock.file_priv = NULL;
- wake_up_interruptible(&dev->lock.lock_queue);
- }
dev->dev_mapping = NULL;
mutex_unlock(&dev->struct_mutex);
diff --git a/linux-core/drm_modes.c b/linux-core/drm_modes.c
index fd00841e..3763ca69 100644
--- a/linux-core/drm_modes.c
+++ b/linux-core/drm_modes.c
@@ -46,12 +46,12 @@
void drm_mode_debug_printmodeline(struct drm_device *dev,
struct drm_display_mode *mode)
{
- DRM_DEBUG("Modeline %d:\"%s\" %d %d %d %d %d %d %d %d %d %d 0x%x\n",
+ DRM_DEBUG("Modeline %d:\"%s\" %d %d %d %d %d %d %d %d %d %d 0x%x 0x%x\n",
mode->mode_id, mode->name, mode->vrefresh, mode->clock,
mode->hdisplay, mode->hsync_start,
mode->hsync_end, mode->htotal,
mode->vdisplay, mode->vsync_start,
- mode->vsync_end, mode->vtotal, mode->type);
+ mode->vsync_end, mode->vtotal, mode->type, mode->flags);
}
EXPORT_SYMBOL(drm_mode_debug_printmodeline);
diff --git a/linux-core/intel_crt.c b/linux-core/intel_crt.c
index 29c2e611..2ab6a27b 100644
--- a/linux-core/intel_crt.c
+++ b/linux-core/intel_crt.c
@@ -245,4 +245,5 @@ void intel_crt_init(struct drm_device *dev)
output->driver_private = intel_output;
output->interlace_allowed = 0;
output->doublescan_allowed = 0;
+
}
diff --git a/linux-core/intel_fb.c b/linux-core/intel_fb.c
index 5f43f291..32c7dc31 100644
--- a/linux-core/intel_fb.c
+++ b/linux-core/intel_fb.c
@@ -216,6 +216,32 @@ static int intelfb_check_var(struct fb_var_screeninfo *var,
return 0;
}
+bool i915_drmfb_mode_equal(struct drm_display_mode *mode1, struct drm_display_mode *mode2, unsigned int pixclock)
+{
+
+ if (mode1->hdisplay == mode2->hdisplay &&
+ mode1->hsync_start == mode2->hsync_start &&
+ mode1->hsync_end == mode2->hsync_end &&
+ mode1->htotal == mode2->htotal &&
+ mode1->hskew == mode2->hskew &&
+ mode1->vdisplay == mode2->vdisplay &&
+ mode1->vsync_start == mode2->vsync_start &&
+ mode1->vsync_end == mode2->vsync_end &&
+ mode1->vtotal == mode2->vtotal &&
+ mode1->vscan == mode2->vscan &&
+ mode1->flags == mode2->flags)
+ {
+ if (mode1->clock == mode2->clock)
+ return true;
+
+ if (KHZ2PICOS(mode2->clock) == pixclock)
+ return true;
+ return false;
+ }
+
+ return false;
+}
+
/* this will let fbcon do the mode init */
/* FIXME: take mode config lock? */
static int intelfb_set_par(struct fb_info *info)
@@ -260,6 +286,10 @@ static int intelfb_set_par(struct fb_info *info)
drm_mode->vtotal = drm_mode->vsync_end + var->upper_margin;
drm_mode->clock = PICOS2KHZ(var->pixclock);
drm_mode->vrefresh = drm_mode_vrefresh(drm_mode);
+ drm_mode->flags = 0;
+ drm_mode->flags |= var->sync & FB_SYNC_HOR_HIGH_ACT ? V_PHSYNC : V_NHSYNC;
+ drm_mode->flags |= var->sync & FB_SYNC_VERT_HIGH_ACT ? V_PVSYNC : V_NVSYNC;
+
drm_mode_set_name(drm_mode);
drm_mode_set_crtcinfo(drm_mode, CRTC_INTERLACE_HALVE_V);
@@ -270,9 +300,8 @@ static int intelfb_set_par(struct fb_info *info)
drm_mode_debug_printmodeline(dev, drm_mode);
list_for_each_entry(search_mode, &output->modes, head) {
- DRM_ERROR("mode %s : %s\n", drm_mode->name, search_mode->name);
drm_mode_debug_printmodeline(dev, search_mode);
- if (drm_mode_equal(drm_mode, search_mode)) {
+ if (i915_drmfb_mode_equal(drm_mode, search_mode, var->pixclock)) {
drm_mode_destroy(dev, drm_mode);
drm_mode = search_mode;
found = 1;
@@ -281,10 +310,8 @@ static int intelfb_set_par(struct fb_info *info)
}
if (!found) {
- drm_mode_addmode(dev, drm_mode);
if (par->fb_mode) {
drm_mode_detachmode_crtc(dev, par->fb_mode);
- drm_mode_rmmode(dev, par->fb_mode);
}
par->fb_mode = drm_mode;
@@ -293,9 +320,11 @@ static int intelfb_set_par(struct fb_info *info)
drm_mode_attachmode_crtc(dev, par->crtc, par->fb_mode);
}
- if (!drm_crtc_set_mode(par->crtc, drm_mode, 0, 0))
- return -EINVAL;
-
+ if (par->crtc->enabled) {
+ if (!drm_mode_equal(&par->crtc->mode, drm_mode))
+ if (!drm_crtc_set_mode(par->crtc, drm_mode, 0, 0))
+ return -EINVAL;
+ }
return 0;
}
@@ -552,7 +581,6 @@ int intelfb_probe(struct drm_device *dev, struct drm_crtc *crtc)
info->var.activate = FB_ACTIVATE_NOW;
info->var.height = -1;
info->var.width = -1;
- info->var.vmode = FB_VMODE_NONINTERLACED;
info->var.xres = mode->hdisplay;
info->var.right_margin = mode->hsync_start - mode->hdisplay;
@@ -562,10 +590,20 @@ int intelfb_probe(struct drm_device *dev, struct drm_crtc *crtc)
info->var.lower_margin = mode->vsync_start - mode->vdisplay;
info->var.vsync_len = mode->vsync_end - mode->vsync_start;
info->var.upper_margin = mode->vtotal - mode->vsync_end;
- info->var.pixclock = 10000000 / mode->htotal * 1000 /
- mode->vtotal * 100;
- /* avoid overflow */
- info->var.pixclock = info->var.pixclock * 1000 / mode->vrefresh;
+ info->var.pixclock = KHZ2PICOS(mode->clock);
+
+ if (mode->flags & V_PHSYNC)
+ info->var.sync |= FB_SYNC_HOR_HIGH_ACT;
+
+ if (mode->flags & V_PVSYNC)
+ info->var.sync |= FB_SYNC_VERT_HIGH_ACT;
+
+ if (mode->flags & V_INTERLACE)
+ info->var.vmode = FB_VMODE_INTERLACED;
+ else if (mode->flags & V_DBLSCAN)
+ info->var.vmode = FB_VMODE_DOUBLE;
+ else
+ info->var.vmode = FB_VMODE_NONINTERLACED;
info->pixmap.size = 64*1024;
info->pixmap.buf_align = 8;
diff --git a/linux-core/intel_modes.c b/linux-core/intel_modes.c
index 346cf1ac..f8bf496c 100644
--- a/linux-core/intel_modes.c
+++ b/linux-core/intel_modes.c
@@ -55,6 +55,7 @@ int intel_ddc_get_modes(struct drm_output *output)
edid = drm_get_edid(output, &intel_output->ddc_bus->adapter);
if (edid) {
+ drm_mode_output_update_edid_property(output, edid);
ret = drm_add_edid_modes(output, edid);
kfree(edid);
}
diff --git a/shared-core/drm.h b/shared-core/drm.h
index 9219b456..0c66f85c 100644
--- a/shared-core/drm.h
+++ b/shared-core/drm.h
@@ -908,9 +908,6 @@ struct drm_mm_init_arg {
#define DRM_MODE_TYPE_DRIVER (1<<6)
struct drm_mode_modeinfo {
-
- unsigned int id;
-
unsigned int clock;
unsigned short hdisplay, hsync_start, hsync_end, htotal, hskew;
unsigned short vdisplay, vsync_start, vsync_end, vtotal, vscan;
@@ -923,43 +920,42 @@ struct drm_mode_modeinfo {
};
struct drm_mode_card_res {
-
+ uint64_t fb_id_ptr;
+ uint64_t crtc_id_ptr;
+ uint64_t output_id_ptr;
int count_fbs;
- unsigned int __user *fb_id;
-
int count_crtcs;
- unsigned int __user *crtc_id;
-
int count_outputs;
- unsigned int __user *output_id;
-
- int count_modes;
- struct drm_mode_modeinfo __user *modes;
-
+ int min_width, max_width;
+ int min_height, max_height;
};
struct drm_mode_crtc {
+ uint64_t set_outputs_ptr;
+
unsigned int crtc_id; /**< Id */
unsigned int fb_id; /**< Id of framebuffer */
int x, y; /**< Position on the frameuffer */
- unsigned int mode; /**< Current mode used */
-
int count_outputs;
unsigned int outputs; /**< Outputs that are connected */
int count_possibles;
unsigned int possibles; /**< Outputs that can be connected */
-
- unsigned int __user *set_outputs; /**< Outputs to be connected */
-
int gamma_size;
-
+ int mode_valid;
+ struct drm_mode_modeinfo mode;
};
struct drm_mode_get_output {
+ uint64_t modes_ptr;
+ uint64_t props_ptr;
+ uint64_t prop_values_ptr;
+
+ int count_modes;
+ int count_props;
unsigned int output; /**< Id */
unsigned int crtc; /**< Id of crtc */
unsigned char name[DRM_OUTPUT_NAME_LEN];
@@ -967,42 +963,39 @@ struct drm_mode_get_output {
unsigned int connection;
unsigned int mm_width, mm_height; /**< HxW in millimeters */
unsigned int subpixel;
-
int count_crtcs;
- unsigned int crtcs; /**< possible crtc to connect to */
-
int count_clones;
+ unsigned int crtcs; /**< possible crtc to connect to */
unsigned int clones; /**< list of clones */
-
- int count_modes;
- unsigned int __user *modes; /**< list of modes it supports */
-
- int count_props;
- unsigned int __user *props;
- unsigned int __user *prop_values;
};
#define DRM_MODE_PROP_PENDING (1<<0)
#define DRM_MODE_PROP_RANGE (1<<1)
#define DRM_MODE_PROP_IMMUTABLE (1<<2)
#define DRM_MODE_PROP_ENUM (1<<3) // enumerated type with text strings
+#define DRM_MODE_PROP_BLOB (1<<4)
struct drm_mode_property_enum {
- uint32_t value;
+ uint64_t value;
unsigned char name[DRM_PROP_NAME_LEN];
};
-
+
struct drm_mode_get_property {
+ uint64_t values_ptr; /* values and blob lengths */
+ uint64_t enum_blob_ptr; /* enum and blob id ptrs */
unsigned int prop_id;
unsigned int flags;
unsigned char name[DRM_PROP_NAME_LEN];
int count_values;
- uint32_t __user *values;
+ int count_enum_blobs;
+};
- int count_enums;
- struct drm_mode_property_enum *enums;
+struct drm_mode_get_blob {
+ uint32_t blob_id;
+ uint32_t length;
+ uint64_t data;
};
struct drm_mode_fb_cmd {
@@ -1016,7 +1009,7 @@ struct drm_mode_fb_cmd {
struct drm_mode_mode_cmd {
unsigned int output_id;
- unsigned int mode_id;
+ struct drm_mode_modeinfo mode;
};
/**
@@ -1119,8 +1112,7 @@ struct drm_mode_mode_cmd {
#define DRM_IOCTL_MODE_RMFB DRM_IOWR(0xA5, unsigned int)
#define DRM_IOCTL_MODE_GETFB DRM_IOWR(0xA6, struct drm_mode_fb_cmd)
-#define DRM_IOCTL_MODE_ADDMODE DRM_IOWR(0xA7, struct drm_mode_modeinfo)
-#define DRM_IOCTL_MODE_RMMODE DRM_IOWR(0xA8, unsigned int)
+#define DRM_IOCTL_MODE_GETPROPBLOB DRM_IOWR(0xA8, struct drm_mode_get_blob)
#define DRM_IOCTL_MODE_ATTACHMODE DRM_IOWR(0xA9, struct drm_mode_mode_cmd)
#define DRM_IOCTL_MODE_DETACHMODE DRM_IOWR(0xAA, struct drm_mode_mode_cmd)
diff --git a/tests/mode/modetest.c b/tests/mode/modetest.c
index 50271af9..c396da41 100644
--- a/tests/mode/modetest.c
+++ b/tests/mode/modetest.c
@@ -20,20 +20,9 @@ const char* getConnectionText(drmModeConnection conn)
}
-struct drm_mode_modeinfo* findMode(drmModeResPtr res, uint32_t id)
-{
- int i;
- for (i = 0; i < res->count_modes; i++) {
- if (res->modes[i].id == id)
- return &res->modes[i];
- }
-
- return 0;
-}
-
int printMode(struct drm_mode_modeinfo *mode)
{
-#if 0
+#if 1
printf("Mode: %s\n", mode->name);
printf("\tclock : %i\n", mode->clock);
printf("\thdisplay : %i\n", mode->hdisplay);
@@ -49,7 +38,7 @@ int printMode(struct drm_mode_modeinfo *mode)
printf("\tvrefresh : %i\n", mode->vrefresh);
printf("\tflags : %i\n", mode->flags);
#else
- printf("Mode: %i \"%s\" %ix%i %.0f\n", mode->id, mode->name,
+ printf("Mode: \"%s\" %ix%i %.0f\n", mode->name,
mode->hdisplay, mode->vdisplay, mode->vrefresh / 1000.0);
#endif
return 0;
@@ -86,17 +75,27 @@ int printOutput(int fd, drmModeResPtr res, drmModeOutputPtr output, uint32_t id)
printf("%d ", props->values[j]);
printf("\n\tenums %d: \n", props->count_enums);
+
+ if (props->flags & DRM_MODE_PROP_BLOB) {
+ drmModePropertyBlobPtr blob;
- for (j = 0; j < props->count_enums; j++) {
- if (output->prop_values[i] == props->enums[j].value)
- name = props->enums[j].name;
- printf("\t\t%d = %s\n", props->enums[j].value, props->enums[j].name);
- }
+ blob = drmModeGetPropertyBlob(fd, output->prop_values[i]);
+
+ printf("blob is %d length, %08X\n", blob->length, *(uint32_t *)blob->data);
+ drmModeFreePropertyBlob(blob);
- if (props->count_enums && name) {
- printf("\toutput property name %s %s\n", props->name, name);
} else {
- printf("\toutput property id %s %i\n", props->name, output->prop_values[i]);
+ for (j = 0; j < props->count_enums; j++) {
+ if (output->prop_values[i] == props->enums[j].value)
+ name = props->enums[j].name;
+ printf("\t\t%d = %s\n", props->enums[j].value, props->enums[j].name);
+ }
+
+ if (props->count_enums && name) {
+ printf("\toutput property name %s %s\n", props->name, name);
+ } else {
+ printf("\toutput property id %s %i\n", props->name, output->prop_values[i]);
+ }
}
drmModeFreeProperty(props);
@@ -104,11 +103,9 @@ int printOutput(int fd, drmModeResPtr res, drmModeOutputPtr output, uint32_t id)
}
for (i = 0; i < output->count_modes; i++) {
- mode = findMode(res, output->modes[i]);
-
+ mode = &output->modes[i];
if (mode)
- printf("\t\tmode: %i \"%s\" %ix%i %.0f\n", mode->id, mode->name,
- mode->hdisplay, mode->vdisplay, mode->vrefresh / 1000.0);
+ printMode(mode);
else
printf("\t\tmode: Invalid mode %i\n", output->modes[i]);
}
@@ -154,10 +151,6 @@ int printRes(int fd, drmModeResPtr res)
drmModeCrtcPtr crtc;
drmModeFBPtr fb;
- for (i = 0; i < res->count_modes; i++) {
- printMode(&res->modes[i]);
- }
-
for (i = 0; i < res->count_outputs; i++) {
output = drmModeGetOutput(fd, res->outputs[i]);
@@ -222,40 +215,26 @@ int testMode(int fd, drmModeResPtr res)
/* printMode(&mode); */
- printf("\tAdding mode\n");
- newMode = drmModeAddMode(fd, &mode);
- if (!newMode)
- goto err;
-
printf("\tAttaching mode %i to output %i\n", newMode, output);
- ret = drmModeAttachMode(fd, output, newMode);
+ ret = drmModeAttachMode(fd, output, &mode);
if (ret)
goto err_mode;
printf("\tDetaching mode %i from output %i\n", newMode, output);
- ret = drmModeDetachMode(fd, output, newMode);
+ ret = drmModeDetachMode(fd, output, &mode);
if (ret)
goto err_mode;
-
- printf("\tRemoveing new mode %i\n", newMode);
- ret = drmModeRmMode(fd, newMode);
- if (ret)
- goto err;
-
return 0;
err_mode:
- error = drmModeRmMode(fd, newMode);
-err:
printf("\tFailed\n");
if (error)
printf("\tFailed to delete mode %i\n", newMode);
-
return 1;
}
generated by cgit v1.2.3 (git 2.25.1) at 2025-11-04 09:28:32 +0000