38,11 → 38,13 |
#include <drm/drm_edid.h> |
#include <drm/drm_fourcc.h> |
#include <drm/drm_modeset_lock.h> |
#include <drm/drm_atomic.h> |
|
#include "drm_crtc_internal.h" |
#include "drm_internal.h" |
|
static struct drm_framebuffer *add_framebuffer_internal(struct drm_device *dev, |
static struct drm_framebuffer * |
internal_framebuffer_create(struct drm_device *dev, |
struct drm_mode_fb_cmd2 *r, |
struct drm_file *file_priv); |
|
61,8 → 63,8 |
/* |
* Global properties |
*/ |
static const struct drm_prop_enum_list drm_dpms_enum_list[] = |
{ { DRM_MODE_DPMS_ON, "On" }, |
static const struct drm_prop_enum_list drm_dpms_enum_list[] = { |
{ DRM_MODE_DPMS_ON, "On" }, |
{ DRM_MODE_DPMS_STANDBY, "Standby" }, |
{ DRM_MODE_DPMS_SUSPEND, "Suspend" }, |
{ DRM_MODE_DPMS_OFF, "Off" } |
70,8 → 72,7 |
|
DRM_ENUM_NAME_FN(drm_get_dpms_name, drm_dpms_enum_list) |
|
static const struct drm_prop_enum_list drm_plane_type_enum_list[] = |
{ |
static const struct drm_prop_enum_list drm_plane_type_enum_list[] = { |
{ DRM_PLANE_TYPE_OVERLAY, "Overlay" }, |
{ DRM_PLANE_TYPE_PRIMARY, "Primary" }, |
{ DRM_PLANE_TYPE_CURSOR, "Cursor" }, |
80,8 → 81,7 |
/* |
* Optional properties |
*/ |
static const struct drm_prop_enum_list drm_scaling_mode_enum_list[] = |
{ |
static const struct drm_prop_enum_list drm_scaling_mode_enum_list[] = { |
{ DRM_MODE_SCALE_NONE, "None" }, |
{ DRM_MODE_SCALE_FULLSCREEN, "Full" }, |
{ DRM_MODE_SCALE_CENTER, "Center" }, |
97,8 → 97,7 |
/* |
* Non-global properties, but "required" for certain connectors. |
*/ |
static const struct drm_prop_enum_list drm_dvi_i_select_enum_list[] = |
{ |
static const struct drm_prop_enum_list drm_dvi_i_select_enum_list[] = { |
{ DRM_MODE_SUBCONNECTOR_Automatic, "Automatic" }, /* DVI-I and TV-out */ |
{ DRM_MODE_SUBCONNECTOR_DVID, "DVI-D" }, /* DVI-I */ |
{ DRM_MODE_SUBCONNECTOR_DVIA, "DVI-A" }, /* DVI-I */ |
106,8 → 105,7 |
|
DRM_ENUM_NAME_FN(drm_get_dvi_i_select_name, drm_dvi_i_select_enum_list) |
|
static const struct drm_prop_enum_list drm_dvi_i_subconnector_enum_list[] = |
{ |
static const struct drm_prop_enum_list drm_dvi_i_subconnector_enum_list[] = { |
{ DRM_MODE_SUBCONNECTOR_Unknown, "Unknown" }, /* DVI-I and TV-out */ |
{ DRM_MODE_SUBCONNECTOR_DVID, "DVI-D" }, /* DVI-I */ |
{ DRM_MODE_SUBCONNECTOR_DVIA, "DVI-A" }, /* DVI-I */ |
116,8 → 114,7 |
DRM_ENUM_NAME_FN(drm_get_dvi_i_subconnector_name, |
drm_dvi_i_subconnector_enum_list) |
|
static const struct drm_prop_enum_list drm_tv_select_enum_list[] = |
{ |
static const struct drm_prop_enum_list drm_tv_select_enum_list[] = { |
{ DRM_MODE_SUBCONNECTOR_Automatic, "Automatic" }, /* DVI-I and TV-out */ |
{ DRM_MODE_SUBCONNECTOR_Composite, "Composite" }, /* TV-out */ |
{ DRM_MODE_SUBCONNECTOR_SVIDEO, "SVIDEO" }, /* TV-out */ |
127,8 → 124,7 |
|
DRM_ENUM_NAME_FN(drm_get_tv_select_name, drm_tv_select_enum_list) |
|
static const struct drm_prop_enum_list drm_tv_subconnector_enum_list[] = |
{ |
static const struct drm_prop_enum_list drm_tv_subconnector_enum_list[] = { |
{ DRM_MODE_SUBCONNECTOR_Unknown, "Unknown" }, /* DVI-I and TV-out */ |
{ DRM_MODE_SUBCONNECTOR_Composite, "Composite" }, /* TV-out */ |
{ DRM_MODE_SUBCONNECTOR_SVIDEO, "SVIDEO" }, /* TV-out */ |
154,8 → 150,8 |
/* |
* Connector and encoder types. |
*/ |
static struct drm_conn_prop_enum_list drm_connector_enum_list[] = |
{ { DRM_MODE_CONNECTOR_Unknown, "Unknown" }, |
static struct drm_conn_prop_enum_list drm_connector_enum_list[] = { |
{ DRM_MODE_CONNECTOR_Unknown, "Unknown" }, |
{ DRM_MODE_CONNECTOR_VGA, "VGA" }, |
{ DRM_MODE_CONNECTOR_DVII, "DVI-I" }, |
{ DRM_MODE_CONNECTOR_DVID, "DVI-D" }, |
174,8 → 170,8 |
{ DRM_MODE_CONNECTOR_DSI, "DSI" }, |
}; |
|
static const struct drm_prop_enum_list drm_encoder_enum_list[] = |
{ { DRM_MODE_ENCODER_NONE, "None" }, |
static const struct drm_prop_enum_list drm_encoder_enum_list[] = { |
{ DRM_MODE_ENCODER_NONE, "None" }, |
{ DRM_MODE_ENCODER_DAC, "DAC" }, |
{ DRM_MODE_ENCODER_TMDS, "TMDS" }, |
{ DRM_MODE_ENCODER_LVDS, "LVDS" }, |
185,8 → 181,7 |
{ DRM_MODE_ENCODER_DPMST, "DP MST" }, |
}; |
|
static const struct drm_prop_enum_list drm_subpixel_enum_list[] = |
{ |
static const struct drm_prop_enum_list drm_subpixel_enum_list[] = { |
{ SubPixelUnknown, "Unknown" }, |
{ SubPixelHorizontalRGB, "Horizontal RGB" }, |
{ SubPixelHorizontalBGR, "Horizontal BGR" }, |
311,8 → 306,7 |
* reference counted modeset objects like framebuffers. |
* |
* Returns: |
* New unique (relative to other objects in @dev) integer identifier for the |
* object. |
* Zero on success, error code on failure. |
*/ |
int drm_mode_object_get(struct drm_device *dev, |
struct drm_mode_object *obj, uint32_t obj_type) |
357,7 → 351,9 |
if (obj && obj->id != id) |
obj = NULL; |
/* don't leak out unref'd fb's */ |
if (obj && (obj->type == DRM_MODE_OBJECT_FB)) |
if (obj && |
(obj->type == DRM_MODE_OBJECT_FB || |
obj->type == DRM_MODE_OBJECT_BLOB)) |
obj = NULL; |
mutex_unlock(&dev->mode_config.idr_mutex); |
|
382,7 → 378,7 |
|
/* Framebuffers are reference counted and need their own lookup |
* function.*/ |
WARN_ON(type == DRM_MODE_OBJECT_FB); |
WARN_ON(type == DRM_MODE_OBJECT_FB || type == DRM_MODE_OBJECT_BLOB); |
obj = _object_find(dev, id, type); |
return obj; |
} |
426,7 → 422,7 |
out: |
mutex_unlock(&dev->mode_config.fb_lock); |
|
return 0; |
return ret; |
} |
EXPORT_SYMBOL(drm_framebuffer_init); |
|
494,8 → 490,10 |
|
mutex_lock(&dev->mode_config.fb_lock); |
fb = __drm_framebuffer_lookup(dev, id); |
if (fb) |
drm_framebuffer_reference(fb); |
if (fb) { |
if (!kref_get_unless_zero(&fb->refcount)) |
fb = NULL; |
} |
mutex_unlock(&dev->mode_config.fb_lock); |
|
return fb; |
528,17 → 526,6 |
} |
EXPORT_SYMBOL(drm_framebuffer_reference); |
|
static void drm_framebuffer_free_bug(struct kref *kref) |
{ |
BUG(); |
} |
|
static void __drm_framebuffer_unreference(struct drm_framebuffer *fb) |
{ |
DRM_DEBUG("%p: FB ID: %d (%d)\n", fb, fb->base.id, atomic_read(&fb->refcount.refcount)); |
kref_put(&fb->refcount, drm_framebuffer_free_bug); |
} |
|
/** |
* drm_framebuffer_unregister_private - unregister a private fb from the lookup idr |
* @fb: fb to unregister |
550,8 → 537,13 |
*/ |
void drm_framebuffer_unregister_private(struct drm_framebuffer *fb) |
{ |
struct drm_device *dev = fb->dev; |
struct drm_device *dev; |
|
if (!fb) |
return; |
|
dev = fb->dev; |
|
mutex_lock(&dev->mode_config.fb_lock); |
/* Mark fb as reaped and drop idr ref. */ |
__drm_framebuffer_unregister(dev, fb); |
601,12 → 593,17 |
*/ |
void drm_framebuffer_remove(struct drm_framebuffer *fb) |
{ |
struct drm_device *dev = fb->dev; |
struct drm_device *dev; |
struct drm_crtc *crtc; |
struct drm_plane *plane; |
struct drm_mode_set set; |
int ret; |
|
if (!fb) |
return; |
|
dev = fb->dev; |
|
WARN_ON(!list_empty(&fb->filp_head)); |
|
/* |
627,7 → 624,7 |
if (atomic_read(&fb->refcount.refcount) > 1) { |
drm_modeset_lock_all(dev); |
/* remove from any CRTC */ |
list_for_each_entry(crtc, &dev->mode_config.crtc_list, head) { |
drm_for_each_crtc(crtc, dev) { |
if (crtc->primary->fb == fb) { |
/* should turn off the crtc */ |
memset(&set, 0, sizeof(struct drm_mode_set)); |
639,7 → 636,7 |
} |
} |
|
list_for_each_entry(plane, &dev->mode_config.plane_list, head) { |
drm_for_each_plane(plane, dev) { |
if (plane->fb == fb) |
drm_plane_force_disable(plane); |
} |
674,9 → 671,11 |
struct drm_mode_config *config = &dev->mode_config; |
int ret; |
|
WARN_ON(primary && primary->type != DRM_PLANE_TYPE_PRIMARY); |
WARN_ON(cursor && cursor->type != DRM_PLANE_TYPE_CURSOR); |
|
crtc->dev = dev; |
crtc->funcs = funcs; |
crtc->invert_dimensions = false; |
|
drm_modeset_lock_init(&crtc->mutex); |
ret = drm_mode_object_get(dev, &crtc->base, DRM_MODE_OBJECT_CRTC); |
695,6 → 694,11 |
if (cursor) |
cursor->possible_crtcs = 1 << drm_crtc_index(crtc); |
|
if (drm_core_check_feature(dev, DRIVER_ATOMIC)) { |
drm_object_attach_property(&crtc->base, config->prop_active, 0); |
drm_object_attach_property(&crtc->base, config->prop_mode_id, 0); |
} |
|
return 0; |
} |
EXPORT_SYMBOL(drm_crtc_init_with_planes); |
740,7 → 744,7 |
unsigned int index = 0; |
struct drm_crtc *tmp; |
|
list_for_each_entry(tmp, &crtc->dev->mode_config.crtc_list, head) { |
drm_for_each_crtc(tmp, crtc->dev) { |
if (tmp == crtc) |
return index; |
|
766,6 → 770,95 |
} |
|
/** |
* drm_display_info_set_bus_formats - set the supported bus formats |
* @info: display info to store bus formats in |
* @formats: array containing the supported bus formats |
* @num_formats: the number of entries in the fmts array |
* |
* Store the supported bus formats in display info structure. |
* See MEDIA_BUS_FMT_* definitions in include/uapi/linux/media-bus-format.h for |
* a full list of available formats. |
*/ |
int drm_display_info_set_bus_formats(struct drm_display_info *info, |
const u32 *formats, |
unsigned int num_formats) |
{ |
u32 *fmts = NULL; |
|
if (!formats && num_formats) |
return -EINVAL; |
|
if (formats && num_formats) { |
fmts = kmemdup(formats, sizeof(*formats) * num_formats, |
GFP_KERNEL); |
if (!fmts) |
return -ENOMEM; |
} |
|
kfree(info->bus_formats); |
info->bus_formats = fmts; |
info->num_bus_formats = num_formats; |
|
return 0; |
} |
EXPORT_SYMBOL(drm_display_info_set_bus_formats); |
|
/** |
* drm_connector_get_cmdline_mode - reads the user's cmdline mode |
* @connector: connector to quwery |
* |
* The kernel supports per-connector configration of its consoles through |
* use of the video= parameter. This function parses that option and |
* extracts the user's specified mode (or enable/disable status) for a |
* particular connector. This is typically only used during the early fbdev |
* setup. |
*/ |
static void drm_connector_get_cmdline_mode(struct drm_connector *connector) |
{ |
struct drm_cmdline_mode *mode = &connector->cmdline_mode; |
char *option = NULL; |
|
return; |
#if 0 |
if (fb_get_options(connector->name, &option)) |
return; |
|
if (!drm_mode_parse_command_line_for_connector(option, |
connector, |
mode)) |
return; |
|
if (mode->force) { |
const char *s; |
|
switch (mode->force) { |
case DRM_FORCE_OFF: |
s = "OFF"; |
break; |
case DRM_FORCE_ON_DIGITAL: |
s = "ON - dig"; |
break; |
default: |
case DRM_FORCE_ON: |
s = "ON"; |
break; |
} |
|
DRM_INFO("forcing %s connector %s\n", connector->name, s); |
connector->force = mode->force; |
} |
|
DRM_DEBUG_KMS("cmdline mode for connector %s %dx%d@%dHz%s%s%s\n", |
connector->name, |
mode->xres, mode->yres, |
mode->refresh_specified ? mode->refresh : 60, |
mode->rb ? " reduced blanking" : "", |
mode->margins ? " with margins" : "", |
mode->interlace ? " interlaced" : ""); |
#endif |
} |
|
/** |
* drm_connector_init - Init a preallocated connector |
* @dev: DRM device |
* @connector: the connector to init |
783,6 → 876,7 |
const struct drm_connector_funcs *funcs, |
int connector_type) |
{ |
struct drm_mode_config *config = &dev->mode_config; |
int ret; |
struct ida *connector_ida = |
&drm_connector_enum_list[connector_type].ida; |
817,17 → 911,25 |
connector->edid_blob_ptr = NULL; |
connector->status = connector_status_unknown; |
|
list_add_tail(&connector->head, &dev->mode_config.connector_list); |
dev->mode_config.num_connector++; |
drm_connector_get_cmdline_mode(connector); |
|
/* We should add connectors at the end to avoid upsetting the connector |
* index too much. */ |
list_add_tail(&connector->head, &config->connector_list); |
config->num_connector++; |
|
if (connector_type != DRM_MODE_CONNECTOR_VIRTUAL) |
drm_object_attach_property(&connector->base, |
dev->mode_config.edid_property, |
config->edid_property, |
0); |
|
drm_object_attach_property(&connector->base, |
dev->mode_config.dpms_property, 0); |
config->dpms_property, 0); |
|
if (drm_core_check_feature(dev, DRIVER_ATOMIC)) { |
drm_object_attach_property(&connector->base, config->prop_crtc_id, 0); |
} |
|
connector->debugfs_entry = NULL; |
|
out_put: |
852,6 → 954,11 |
struct drm_device *dev = connector->dev; |
struct drm_display_mode *mode, *t; |
|
if (connector->tile_group) { |
drm_mode_put_tile_group(dev, connector->tile_group); |
connector->tile_group = NULL; |
} |
|
list_for_each_entry_safe(mode, t, &connector->probed_modes, head) |
drm_mode_remove(connector, mode); |
|
861,6 → 968,7 |
ida_remove(&drm_connector_enum_list[connector->connector_type].ida, |
connector->connector_type_id); |
|
kfree(connector->display_info.bus_formats); |
drm_mode_object_put(dev, &connector->base); |
kfree(connector->name); |
connector->name = NULL; |
891,7 → 999,7 |
|
WARN_ON(!drm_modeset_is_locked(&config->connection_mutex)); |
|
list_for_each_entry(tmp, &connector->dev->mode_config.connector_list, head) { |
drm_for_each_connector(tmp, connector->dev) { |
if (tmp == connector) |
return index; |
|
917,6 → 1025,9 |
|
drm_mode_object_register(connector->dev, &connector->base); |
|
ret = drm_sysfs_connector_add(connector); |
if (ret) |
return ret; |
return 0; |
} |
EXPORT_SYMBOL(drm_connector_register); |
929,6 → 1040,7 |
*/ |
void drm_connector_unregister(struct drm_connector *connector) |
{ |
drm_sysfs_connector_remove(connector); |
} |
EXPORT_SYMBOL(drm_connector_unregister); |
|
945,7 → 1057,7 |
{ |
struct drm_connector *connector; |
|
/* taking the mode config mutex ends up in a clash with sysfs */ |
/* FIXME: taking the mode config mutex ends up in a clash with sysfs */ |
list_for_each_entry(connector, &dev->mode_config.connector_list, head) |
drm_connector_unregister(connector); |
|
953,61 → 1065,6 |
EXPORT_SYMBOL(drm_connector_unplug_all); |
|
/** |
* drm_bridge_init - initialize a drm transcoder/bridge |
* @dev: drm device |
* @bridge: transcoder/bridge to set up |
* @funcs: bridge function table |
* |
* Initialises a preallocated bridge. Bridges should be |
* subclassed as part of driver connector objects. |
* |
* Returns: |
* Zero on success, error code on failure. |
*/ |
int drm_bridge_init(struct drm_device *dev, struct drm_bridge *bridge, |
const struct drm_bridge_funcs *funcs) |
{ |
int ret; |
|
drm_modeset_lock_all(dev); |
|
ret = drm_mode_object_get(dev, &bridge->base, DRM_MODE_OBJECT_BRIDGE); |
if (ret) |
goto out; |
|
bridge->dev = dev; |
bridge->funcs = funcs; |
|
list_add_tail(&bridge->head, &dev->mode_config.bridge_list); |
dev->mode_config.num_bridge++; |
|
out: |
drm_modeset_unlock_all(dev); |
return ret; |
} |
EXPORT_SYMBOL(drm_bridge_init); |
|
/** |
* drm_bridge_cleanup - cleans up an initialised bridge |
* @bridge: bridge to cleanup |
* |
* Cleans up the bridge but doesn't free the object. |
*/ |
void drm_bridge_cleanup(struct drm_bridge *bridge) |
{ |
struct drm_device *dev = bridge->dev; |
|
drm_modeset_lock_all(dev); |
drm_mode_object_put(dev, &bridge->base); |
list_del(&bridge->head); |
dev->mode_config.num_bridge--; |
drm_modeset_unlock_all(dev); |
|
memset(bridge, 0, sizeof(*bridge)); |
} |
EXPORT_SYMBOL(drm_bridge_cleanup); |
|
/** |
* drm_encoder_init - Init a preallocated encoder |
* @dev: drm device |
* @encoder: the encoder to init |
1067,6 → 1124,7 |
void drm_encoder_cleanup(struct drm_encoder *encoder) |
{ |
struct drm_device *dev = encoder->dev; |
|
drm_modeset_lock_all(dev); |
drm_mode_object_put(dev, &encoder->base); |
kfree(encoder->name); |
1096,9 → 1154,10 |
int drm_universal_plane_init(struct drm_device *dev, struct drm_plane *plane, |
unsigned long possible_crtcs, |
const struct drm_plane_funcs *funcs, |
const uint32_t *formats, uint32_t format_count, |
const uint32_t *formats, unsigned int format_count, |
enum drm_plane_type type) |
{ |
struct drm_mode_config *config = &dev->mode_config; |
int ret; |
|
ret = drm_mode_object_get(dev, &plane->base, DRM_MODE_OBJECT_PLANE); |
1110,7 → 1169,7 |
plane->base.properties = &plane->properties; |
plane->dev = dev; |
plane->funcs = funcs; |
plane->format_types = kmalloc(sizeof(uint32_t) * format_count, |
plane->format_types = kmalloc_array(format_count, sizeof(uint32_t), |
GFP_KERNEL); |
if (!plane->format_types) { |
DRM_DEBUG_KMS("out of memory when allocating plane\n"); |
1123,15 → 1182,28 |
plane->possible_crtcs = possible_crtcs; |
plane->type = type; |
|
list_add_tail(&plane->head, &dev->mode_config.plane_list); |
dev->mode_config.num_total_plane++; |
list_add_tail(&plane->head, &config->plane_list); |
config->num_total_plane++; |
if (plane->type == DRM_PLANE_TYPE_OVERLAY) |
dev->mode_config.num_overlay_plane++; |
config->num_overlay_plane++; |
|
drm_object_attach_property(&plane->base, |
dev->mode_config.plane_type_property, |
config->plane_type_property, |
plane->type); |
|
if (drm_core_check_feature(dev, DRIVER_ATOMIC)) { |
drm_object_attach_property(&plane->base, config->prop_fb_id, 0); |
drm_object_attach_property(&plane->base, config->prop_crtc_id, 0); |
drm_object_attach_property(&plane->base, config->prop_crtc_x, 0); |
drm_object_attach_property(&plane->base, config->prop_crtc_y, 0); |
drm_object_attach_property(&plane->base, config->prop_crtc_w, 0); |
drm_object_attach_property(&plane->base, config->prop_crtc_h, 0); |
drm_object_attach_property(&plane->base, config->prop_src_x, 0); |
drm_object_attach_property(&plane->base, config->prop_src_y, 0); |
drm_object_attach_property(&plane->base, config->prop_src_w, 0); |
drm_object_attach_property(&plane->base, config->prop_src_h, 0); |
} |
|
return 0; |
} |
EXPORT_SYMBOL(drm_universal_plane_init); |
1156,7 → 1228,7 |
int drm_plane_init(struct drm_device *dev, struct drm_plane *plane, |
unsigned long possible_crtcs, |
const struct drm_plane_funcs *funcs, |
const uint32_t *formats, uint32_t format_count, |
const uint32_t *formats, unsigned int format_count, |
bool is_primary) |
{ |
enum drm_plane_type type; |
1211,7 → 1283,7 |
unsigned int index = 0; |
struct drm_plane *tmp; |
|
list_for_each_entry(tmp, &plane->dev->mode_config.plane_list, head) { |
drm_for_each_plane(tmp, plane->dev) { |
if (tmp == plane) |
return index; |
|
1223,6 → 1295,29 |
EXPORT_SYMBOL(drm_plane_index); |
|
/** |
* drm_plane_from_index - find the registered plane at an index |
* @dev: DRM device |
* @idx: index of registered plane to find for |
* |
* Given a plane index, return the registered plane from DRM device's |
* list of planes with matching index. |
*/ |
struct drm_plane * |
drm_plane_from_index(struct drm_device *dev, int idx) |
{ |
struct drm_plane *plane; |
unsigned int i = 0; |
|
drm_for_each_plane(plane, dev) { |
if (i == idx) |
return plane; |
i++; |
} |
return NULL; |
} |
EXPORT_SYMBOL(drm_plane_from_index); |
|
/** |
* drm_plane_force_disable - Forcibly disable a plane |
* @plane: plane to disable |
* |
1246,7 → 1341,7 |
return; |
} |
/* disconnect the plane from the fb and crtc: */ |
__drm_framebuffer_unreference(plane->old_fb); |
drm_framebuffer_unreference(plane->old_fb); |
plane->old_fb = NULL; |
plane->fb = NULL; |
plane->crtc = NULL; |
1253,51 → 1348,123 |
} |
EXPORT_SYMBOL(drm_plane_force_disable); |
|
static int drm_mode_create_standard_connector_properties(struct drm_device *dev) |
static int drm_mode_create_standard_properties(struct drm_device *dev) |
{ |
struct drm_property *edid; |
struct drm_property *dpms; |
struct drm_property *dev_path; |
struct drm_property *prop; |
|
/* |
* Standard properties (apply to all connectors) |
*/ |
edid = drm_property_create(dev, DRM_MODE_PROP_BLOB | |
prop = drm_property_create(dev, DRM_MODE_PROP_BLOB | |
DRM_MODE_PROP_IMMUTABLE, |
"EDID", 0); |
dev->mode_config.edid_property = edid; |
if (!prop) |
return -ENOMEM; |
dev->mode_config.edid_property = prop; |
|
dpms = drm_property_create_enum(dev, 0, |
prop = drm_property_create_enum(dev, 0, |
"DPMS", drm_dpms_enum_list, |
ARRAY_SIZE(drm_dpms_enum_list)); |
dev->mode_config.dpms_property = dpms; |
if (!prop) |
return -ENOMEM; |
dev->mode_config.dpms_property = prop; |
|
dev_path = drm_property_create(dev, |
prop = drm_property_create(dev, |
DRM_MODE_PROP_BLOB | |
DRM_MODE_PROP_IMMUTABLE, |
"PATH", 0); |
dev->mode_config.path_property = dev_path; |
if (!prop) |
return -ENOMEM; |
dev->mode_config.path_property = prop; |
|
dev->mode_config.tile_property = drm_property_create(dev, |
prop = drm_property_create(dev, |
DRM_MODE_PROP_BLOB | |
DRM_MODE_PROP_IMMUTABLE, |
"TILE", 0); |
if (!prop) |
return -ENOMEM; |
dev->mode_config.tile_property = prop; |
|
return 0; |
} |
|
static int drm_mode_create_standard_plane_properties(struct drm_device *dev) |
{ |
struct drm_property *type; |
|
/* |
* Standard properties (apply to all planes) |
*/ |
type = drm_property_create_enum(dev, DRM_MODE_PROP_IMMUTABLE, |
prop = drm_property_create_enum(dev, DRM_MODE_PROP_IMMUTABLE, |
"type", drm_plane_type_enum_list, |
ARRAY_SIZE(drm_plane_type_enum_list)); |
dev->mode_config.plane_type_property = type; |
if (!prop) |
return -ENOMEM; |
dev->mode_config.plane_type_property = prop; |
|
prop = drm_property_create_range(dev, DRM_MODE_PROP_ATOMIC, |
"SRC_X", 0, UINT_MAX); |
if (!prop) |
return -ENOMEM; |
dev->mode_config.prop_src_x = prop; |
|
prop = drm_property_create_range(dev, DRM_MODE_PROP_ATOMIC, |
"SRC_Y", 0, UINT_MAX); |
if (!prop) |
return -ENOMEM; |
dev->mode_config.prop_src_y = prop; |
|
prop = drm_property_create_range(dev, DRM_MODE_PROP_ATOMIC, |
"SRC_W", 0, UINT_MAX); |
if (!prop) |
return -ENOMEM; |
dev->mode_config.prop_src_w = prop; |
|
prop = drm_property_create_range(dev, DRM_MODE_PROP_ATOMIC, |
"SRC_H", 0, UINT_MAX); |
if (!prop) |
return -ENOMEM; |
dev->mode_config.prop_src_h = prop; |
|
prop = drm_property_create_signed_range(dev, DRM_MODE_PROP_ATOMIC, |
"CRTC_X", INT_MIN, INT_MAX); |
if (!prop) |
return -ENOMEM; |
dev->mode_config.prop_crtc_x = prop; |
|
prop = drm_property_create_signed_range(dev, DRM_MODE_PROP_ATOMIC, |
"CRTC_Y", INT_MIN, INT_MAX); |
if (!prop) |
return -ENOMEM; |
dev->mode_config.prop_crtc_y = prop; |
|
prop = drm_property_create_range(dev, DRM_MODE_PROP_ATOMIC, |
"CRTC_W", 0, INT_MAX); |
if (!prop) |
return -ENOMEM; |
dev->mode_config.prop_crtc_w = prop; |
|
prop = drm_property_create_range(dev, DRM_MODE_PROP_ATOMIC, |
"CRTC_H", 0, INT_MAX); |
if (!prop) |
return -ENOMEM; |
dev->mode_config.prop_crtc_h = prop; |
|
prop = drm_property_create_object(dev, DRM_MODE_PROP_ATOMIC, |
"FB_ID", DRM_MODE_OBJECT_FB); |
if (!prop) |
return -ENOMEM; |
dev->mode_config.prop_fb_id = prop; |
|
prop = drm_property_create_object(dev, DRM_MODE_PROP_ATOMIC, |
"CRTC_ID", DRM_MODE_OBJECT_CRTC); |
if (!prop) |
return -ENOMEM; |
dev->mode_config.prop_crtc_id = prop; |
|
prop = drm_property_create_bool(dev, DRM_MODE_PROP_ATOMIC, |
"ACTIVE"); |
if (!prop) |
return -ENOMEM; |
dev->mode_config.prop_active = prop; |
|
prop = drm_property_create(dev, |
DRM_MODE_PROP_ATOMIC | DRM_MODE_PROP_BLOB, |
"MODE_ID", 0); |
if (!prop) |
return -ENOMEM; |
dev->mode_config.prop_mode_id = prop; |
|
return 0; |
} |
|
1345,7 → 1512,7 |
*/ |
int drm_mode_create_tv_properties(struct drm_device *dev, |
unsigned int num_modes, |
char *modes[]) |
const char * const modes[]) |
{ |
struct drm_property *tv_selector; |
struct drm_property *tv_subconnector; |
1361,6 → 1528,9 |
"select subconnector", |
drm_tv_select_enum_list, |
ARRAY_SIZE(drm_tv_select_enum_list)); |
if (!tv_selector) |
goto nomem; |
|
dev->mode_config.tv_select_subconnector_property = tv_selector; |
|
tv_subconnector = |
1368,6 → 1538,8 |
"subconnector", |
drm_tv_subconnector_enum_list, |
ARRAY_SIZE(drm_tv_subconnector_enum_list)); |
if (!tv_subconnector) |
goto nomem; |
dev->mode_config.tv_subconnector_property = tv_subconnector; |
|
/* |
1375,19 → 1547,30 |
*/ |
dev->mode_config.tv_left_margin_property = |
drm_property_create_range(dev, 0, "left margin", 0, 100); |
if (!dev->mode_config.tv_left_margin_property) |
goto nomem; |
|
dev->mode_config.tv_right_margin_property = |
drm_property_create_range(dev, 0, "right margin", 0, 100); |
if (!dev->mode_config.tv_right_margin_property) |
goto nomem; |
|
dev->mode_config.tv_top_margin_property = |
drm_property_create_range(dev, 0, "top margin", 0, 100); |
if (!dev->mode_config.tv_top_margin_property) |
goto nomem; |
|
dev->mode_config.tv_bottom_margin_property = |
drm_property_create_range(dev, 0, "bottom margin", 0, 100); |
if (!dev->mode_config.tv_bottom_margin_property) |
goto nomem; |
|
dev->mode_config.tv_mode_property = |
drm_property_create(dev, DRM_MODE_PROP_ENUM, |
"mode", num_modes); |
if (!dev->mode_config.tv_mode_property) |
goto nomem; |
|
for (i = 0; i < num_modes; i++) |
drm_property_add_enum(dev->mode_config.tv_mode_property, i, |
i, modes[i]); |
1394,23 → 1577,37 |
|
dev->mode_config.tv_brightness_property = |
drm_property_create_range(dev, 0, "brightness", 0, 100); |
if (!dev->mode_config.tv_brightness_property) |
goto nomem; |
|
dev->mode_config.tv_contrast_property = |
drm_property_create_range(dev, 0, "contrast", 0, 100); |
if (!dev->mode_config.tv_contrast_property) |
goto nomem; |
|
dev->mode_config.tv_flicker_reduction_property = |
drm_property_create_range(dev, 0, "flicker reduction", 0, 100); |
if (!dev->mode_config.tv_flicker_reduction_property) |
goto nomem; |
|
dev->mode_config.tv_overscan_property = |
drm_property_create_range(dev, 0, "overscan", 0, 100); |
if (!dev->mode_config.tv_overscan_property) |
goto nomem; |
|
dev->mode_config.tv_saturation_property = |
drm_property_create_range(dev, 0, "saturation", 0, 100); |
if (!dev->mode_config.tv_saturation_property) |
goto nomem; |
|
dev->mode_config.tv_hue_property = |
drm_property_create_range(dev, 0, "hue", 0, 100); |
if (!dev->mode_config.tv_hue_property) |
goto nomem; |
|
return 0; |
nomem: |
return -ENOMEM; |
} |
EXPORT_SYMBOL(drm_mode_create_tv_properties); |
|
1515,154 → 1712,6 |
} |
EXPORT_SYMBOL(drm_mode_create_suggested_offset_properties); |
|
static int drm_mode_group_init(struct drm_device *dev, struct drm_mode_group *group) |
{ |
uint32_t total_objects = 0; |
|
total_objects += dev->mode_config.num_crtc; |
total_objects += dev->mode_config.num_connector; |
total_objects += dev->mode_config.num_encoder; |
total_objects += dev->mode_config.num_bridge; |
|
group->id_list = kzalloc(total_objects * sizeof(uint32_t), GFP_KERNEL); |
if (!group->id_list) |
return -ENOMEM; |
|
group->num_crtcs = 0; |
group->num_connectors = 0; |
group->num_encoders = 0; |
group->num_bridges = 0; |
return 0; |
} |
|
void drm_mode_group_destroy(struct drm_mode_group *group) |
{ |
kfree(group->id_list); |
group->id_list = NULL; |
} |
|
/* |
* NOTE: Driver's shouldn't ever call drm_mode_group_init_legacy_group - it is |
* the drm core's responsibility to set up mode control groups. |
*/ |
int drm_mode_group_init_legacy_group(struct drm_device *dev, |
struct drm_mode_group *group) |
{ |
struct drm_crtc *crtc; |
struct drm_encoder *encoder; |
struct drm_connector *connector; |
struct drm_bridge *bridge; |
int ret; |
|
if ((ret = drm_mode_group_init(dev, group))) |
return ret; |
|
list_for_each_entry(crtc, &dev->mode_config.crtc_list, head) |
group->id_list[group->num_crtcs++] = crtc->base.id; |
|
list_for_each_entry(encoder, &dev->mode_config.encoder_list, head) |
group->id_list[group->num_crtcs + group->num_encoders++] = |
encoder->base.id; |
|
list_for_each_entry(connector, &dev->mode_config.connector_list, head) |
group->id_list[group->num_crtcs + group->num_encoders + |
group->num_connectors++] = connector->base.id; |
|
list_for_each_entry(bridge, &dev->mode_config.bridge_list, head) |
group->id_list[group->num_crtcs + group->num_encoders + |
group->num_connectors + group->num_bridges++] = |
bridge->base.id; |
|
return 0; |
} |
EXPORT_SYMBOL(drm_mode_group_init_legacy_group); |
|
void drm_reinit_primary_mode_group(struct drm_device *dev) |
{ |
drm_modeset_lock_all(dev); |
drm_mode_group_destroy(&dev->primary->mode_group); |
drm_mode_group_init_legacy_group(dev, &dev->primary->mode_group); |
drm_modeset_unlock_all(dev); |
} |
EXPORT_SYMBOL(drm_reinit_primary_mode_group); |
|
/** |
* drm_crtc_convert_to_umode - convert a drm_display_mode into a modeinfo |
* @out: drm_mode_modeinfo struct to return to the user |
* @in: drm_display_mode to use |
* |
* Convert a drm_display_mode into a drm_mode_modeinfo structure to return to |
* the user. |
*/ |
static void drm_crtc_convert_to_umode(struct drm_mode_modeinfo *out, |
const struct drm_display_mode *in) |
{ |
WARN(in->hdisplay > USHRT_MAX || in->hsync_start > USHRT_MAX || |
in->hsync_end > USHRT_MAX || in->htotal > USHRT_MAX || |
in->hskew > USHRT_MAX || in->vdisplay > USHRT_MAX || |
in->vsync_start > USHRT_MAX || in->vsync_end > USHRT_MAX || |
in->vtotal > USHRT_MAX || in->vscan > USHRT_MAX, |
"timing values too large for mode info\n"); |
|
out->clock = in->clock; |
out->hdisplay = in->hdisplay; |
out->hsync_start = in->hsync_start; |
out->hsync_end = in->hsync_end; |
out->htotal = in->htotal; |
out->hskew = in->hskew; |
out->vdisplay = in->vdisplay; |
out->vsync_start = in->vsync_start; |
out->vsync_end = in->vsync_end; |
out->vtotal = in->vtotal; |
out->vscan = in->vscan; |
out->vrefresh = in->vrefresh; |
out->flags = in->flags; |
out->type = in->type; |
strncpy(out->name, in->name, DRM_DISPLAY_MODE_LEN); |
out->name[DRM_DISPLAY_MODE_LEN-1] = 0; |
} |
|
/** |
* drm_crtc_convert_umode - convert a modeinfo into a drm_display_mode |
* @out: drm_display_mode to return to the user |
* @in: drm_mode_modeinfo to use |
* |
* Convert a drm_mode_modeinfo into a drm_display_mode structure to return to |
* the caller. |
* |
* Returns: |
* Zero on success, negative errno on failure. |
*/ |
static int drm_crtc_convert_umode(struct drm_display_mode *out, |
const struct drm_mode_modeinfo *in) |
{ |
if (in->clock > INT_MAX || in->vrefresh > INT_MAX) |
return -ERANGE; |
|
if ((in->flags & DRM_MODE_FLAG_3D_MASK) > DRM_MODE_FLAG_3D_MAX) |
return -EINVAL; |
|
out->clock = in->clock; |
out->hdisplay = in->hdisplay; |
out->hsync_start = in->hsync_start; |
out->hsync_end = in->hsync_end; |
out->htotal = in->htotal; |
out->hskew = in->hskew; |
out->vdisplay = in->vdisplay; |
out->vsync_start = in->vsync_start; |
out->vsync_end = in->vsync_end; |
out->vtotal = in->vtotal; |
out->vscan = in->vscan; |
out->vrefresh = in->vrefresh; |
out->flags = in->flags; |
out->type = in->type; |
strncpy(out->name, in->name, DRM_DISPLAY_MODE_LEN); |
out->name[DRM_DISPLAY_MODE_LEN-1] = 0; |
|
return 0; |
} |
|
|
#if 0 |
/** |
* drm_mode_getresources - get graphics configuration |
1692,12 → 1741,11 |
int crtc_count = 0; |
int fb_count = 0; |
int encoder_count = 0; |
int copied = 0, i; |
int copied = 0; |
uint32_t __user *fb_id; |
uint32_t __user *crtc_id; |
uint32_t __user *connector_id; |
uint32_t __user *encoder_id; |
struct drm_mode_group *mode_group; |
|
if (!drm_core_check_feature(dev, DRIVER_MODESET)) |
return -EINVAL; |
1730,25 → 1778,15 |
/* mode_config.mutex protects the connector list against e.g. DP MST |
* connector hot-adding. CRTC/Plane lists are invariant. */ |
mutex_lock(&dev->mode_config.mutex); |
if (!drm_is_primary_client(file_priv)) { |
|
mode_group = NULL; |
list_for_each(lh, &dev->mode_config.crtc_list) |
drm_for_each_crtc(crtc, dev) |
crtc_count++; |
|
list_for_each(lh, &dev->mode_config.connector_list) |
drm_for_each_connector(connector, dev) |
connector_count++; |
|
list_for_each(lh, &dev->mode_config.encoder_list) |
drm_for_each_encoder(encoder, dev) |
encoder_count++; |
} else { |
|
mode_group = &file_priv->master->minor->mode_group; |
crtc_count = mode_group->num_crtcs; |
connector_count = mode_group->num_connectors; |
encoder_count = mode_group->num_encoders; |
} |
|
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; |
1758,9 → 1796,7 |
if (card_res->count_crtcs >= crtc_count) { |
copied = 0; |
crtc_id = (uint32_t __user *)(unsigned long)card_res->crtc_id_ptr; |
if (!mode_group) { |
list_for_each_entry(crtc, &dev->mode_config.crtc_list, |
head) { |
drm_for_each_crtc(crtc, dev) { |
DRM_DEBUG_KMS("[CRTC:%d]\n", crtc->base.id); |
if (put_user(crtc->base.id, crtc_id + copied)) { |
ret = -EFAULT; |
1768,17 → 1804,7 |
} |
copied++; |
} |
} else { |
for (i = 0; i < mode_group->num_crtcs; i++) { |
if (put_user(mode_group->id_list[i], |
crtc_id + copied)) { |
ret = -EFAULT; |
goto out; |
} |
copied++; |
} |
} |
} |
card_res->count_crtcs = crtc_count; |
|
/* Encoders */ |
1785,10 → 1811,7 |
if (card_res->count_encoders >= encoder_count) { |
copied = 0; |
encoder_id = (uint32_t __user *)(unsigned long)card_res->encoder_id_ptr; |
if (!mode_group) { |
list_for_each_entry(encoder, |
&dev->mode_config.encoder_list, |
head) { |
drm_for_each_encoder(encoder, dev) { |
DRM_DEBUG_KMS("[ENCODER:%d:%s]\n", encoder->base.id, |
encoder->name); |
if (put_user(encoder->base.id, encoder_id + |
1798,18 → 1821,7 |
} |
copied++; |
} |
} else { |
for (i = mode_group->num_crtcs; i < mode_group->num_crtcs + mode_group->num_encoders; i++) { |
if (put_user(mode_group->id_list[i], |
encoder_id + copied)) { |
ret = -EFAULT; |
goto out; |
} |
copied++; |
} |
|
} |
} |
card_res->count_encoders = encoder_count; |
|
/* Connectors */ |
1816,10 → 1828,7 |
if (card_res->count_connectors >= connector_count) { |
copied = 0; |
connector_id = (uint32_t __user *)(unsigned long)card_res->connector_id_ptr; |
if (!mode_group) { |
list_for_each_entry(connector, |
&dev->mode_config.connector_list, |
head) { |
drm_for_each_connector(connector, dev) { |
DRM_DEBUG_KMS("[CONNECTOR:%d:%s]\n", |
connector->base.id, |
connector->name); |
1830,19 → 1839,7 |
} |
copied++; |
} |
} else { |
int start = mode_group->num_crtcs + |
mode_group->num_encoders; |
for (i = start; i < start + mode_group->num_connectors; i++) { |
if (put_user(mode_group->id_list[i], |
connector_id + copied)) { |
ret = -EFAULT; |
goto out; |
} |
copied++; |
} |
} |
} |
card_res->count_connectors = connector_count; |
|
DRM_DEBUG_KMS("CRTC[%d] CONNECTORS[%d] ENCODERS[%d]\n", card_res->count_crtcs, |
1880,8 → 1877,6 |
return -ENOENT; |
|
drm_modeset_lock_crtc(crtc, crtc->primary); |
crtc_resp->x = crtc->x; |
crtc_resp->y = crtc->y; |
crtc_resp->gamma_size = crtc->gamma_size; |
if (crtc->primary->fb) |
crtc_resp->fb_id = crtc->primary->fb->base.id; |
1888,14 → 1883,27 |
else |
crtc_resp->fb_id = 0; |
|
if (crtc->state) { |
crtc_resp->x = crtc->primary->state->src_x >> 16; |
crtc_resp->y = crtc->primary->state->src_y >> 16; |
if (crtc->state->enable) { |
drm_mode_convert_to_umode(&crtc_resp->mode, &crtc->state->mode); |
crtc_resp->mode_valid = 1; |
|
} else { |
crtc_resp->mode_valid = 0; |
} |
} else { |
crtc_resp->x = crtc->x; |
crtc_resp->y = crtc->y; |
if (crtc->enabled) { |
|
drm_crtc_convert_to_umode(&crtc_resp->mode, &crtc->mode); |
drm_mode_convert_to_umode(&crtc_resp->mode, &crtc->mode); |
crtc_resp->mode_valid = 1; |
|
} else { |
crtc_resp->mode_valid = 0; |
} |
} |
drm_modeset_unlock_crtc(crtc); |
|
return 0; |
1923,6 → 1931,44 |
return connector->encoder; |
} |
|
/* helper for getconnector and getproperties ioctls */ |
static int get_properties(struct drm_mode_object *obj, bool atomic, |
uint32_t __user *prop_ptr, uint64_t __user *prop_values, |
uint32_t *arg_count_props) |
{ |
int props_count; |
int i, ret, copied; |
|
props_count = obj->properties->count; |
if (!atomic) |
props_count -= obj->properties->atomic_count; |
|
if ((*arg_count_props >= props_count) && props_count) { |
for (i = 0, copied = 0; copied < props_count; i++) { |
struct drm_property *prop = obj->properties->properties[i]; |
uint64_t val; |
|
if ((prop->flags & DRM_MODE_PROP_ATOMIC) && !atomic) |
continue; |
|
ret = drm_object_property_get_value(obj, prop, &val); |
if (ret) |
return ret; |
|
if (put_user(prop->base.id, prop_ptr + copied)) |
return -EFAULT; |
|
if (put_user(val, prop_values + copied)) |
return -EFAULT; |
|
copied++; |
} |
} |
*arg_count_props = props_count; |
|
return 0; |
} |
|
/** |
* drm_mode_getconnector - get connector configuration |
* @dev: drm device for the ioctl |
1944,7 → 1990,6 |
struct drm_encoder *encoder; |
struct drm_display_mode *mode; |
int mode_count = 0; |
int props_count = 0; |
int encoders_count = 0; |
int ret = 0; |
int copied = 0; |
1951,8 → 1996,6 |
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; |
uint32_t __user *encoder_ptr; |
|
if (!drm_core_check_feature(dev, DRIVER_MODESET)) |
1967,16 → 2010,12 |
connector = drm_connector_find(dev, out_resp->connector_id); |
if (!connector) { |
ret = -ENOENT; |
goto out; |
goto out_unlock; |
} |
|
props_count = connector->properties.count; |
|
for (i = 0; i < DRM_CONNECTOR_MAX_ENCODER; i++) { |
if (connector->encoder_ids[i] != 0) { |
for (i = 0; i < DRM_CONNECTOR_MAX_ENCODER; i++) |
if (connector->encoder_ids[i] != 0) |
encoders_count++; |
} |
} |
|
if (out_resp->count_modes == 0) { |
connector->funcs->fill_modes(connector, |
1996,14 → 2035,13 |
out_resp->mm_height = connector->display_info.height_mm; |
out_resp->subpixel = connector->display_info.subpixel_order; |
out_resp->connection = connector->status; |
|
drm_modeset_lock(&dev->mode_config.connection_mutex, NULL); |
|
encoder = drm_connector_get_encoder(connector); |
if (encoder) |
out_resp->encoder_id = encoder->base.id; |
else |
out_resp->encoder_id = 0; |
drm_modeset_unlock(&dev->mode_config.connection_mutex); |
|
/* |
* This ioctl is called twice, once to determine how much space is |
2016,7 → 2054,7 |
if (!drm_mode_expose_to_userspace(mode, file_priv)) |
continue; |
|
drm_crtc_convert_to_umode(&u_mode, mode); |
drm_mode_convert_to_umode(&u_mode, mode); |
if (copy_to_user(mode_ptr + copied, |
&u_mode, sizeof(u_mode))) { |
ret = -EFAULT; |
2027,27 → 2065,13 |
} |
out_resp->count_modes = mode_count; |
|
if ((out_resp->count_props >= props_count) && props_count) { |
copied = 0; |
prop_ptr = (uint32_t __user *)(unsigned long)(out_resp->props_ptr); |
prop_values = (uint64_t __user *)(unsigned long)(out_resp->prop_values_ptr); |
for (i = 0; i < connector->properties.count; i++) { |
if (put_user(connector->properties.ids[i], |
prop_ptr + copied)) { |
ret = -EFAULT; |
ret = get_properties(&connector->base, file_priv->atomic, |
(uint32_t __user *)(unsigned long)(out_resp->props_ptr), |
(uint64_t __user *)(unsigned long)(out_resp->prop_values_ptr), |
&out_resp->count_props); |
if (ret) |
goto out; |
} |
|
if (put_user(connector->properties.values[i], |
prop_values + copied)) { |
ret = -EFAULT; |
goto out; |
} |
copied++; |
} |
} |
out_resp->count_props = props_count; |
|
if ((out_resp->count_encoders >= encoders_count) && encoders_count) { |
copied = 0; |
encoder_ptr = (uint32_t __user *)(unsigned long)(out_resp->encoders_ptr); |
2065,6 → 2089,9 |
out_resp->count_encoders = encoders_count; |
|
out: |
drm_modeset_unlock(&dev->mode_config.connection_mutex); |
|
out_unlock: |
mutex_unlock(&dev->mode_config.mutex); |
|
return ret; |
2078,7 → 2105,7 |
|
/* For atomic drivers only state objects are synchronously updated and |
* protected by modeset locks, so check those first. */ |
list_for_each_entry(connector, &dev->mode_config.connector_list, head) { |
drm_for_each_connector(connector, dev) { |
if (!connector->state) |
continue; |
|
2128,8 → 2155,6 |
crtc = drm_encoder_get_crtc(encoder); |
if (crtc) |
enc_resp->crtc_id = crtc->base.id; |
else if (encoder->crtc) |
enc_resp->crtc_id = encoder->crtc->base.id; |
else |
enc_resp->crtc_id = 0; |
drm_modeset_unlock(&dev->mode_config.connection_mutex); |
2184,7 → 2209,7 |
plane_ptr = (uint32_t __user *)(unsigned long)plane_resp->plane_id_ptr; |
|
/* Plane lists are invariant, no locking needed. */ |
list_for_each_entry(plane, &config->plane_list, head) { |
drm_for_each_plane(plane, dev) { |
/* |
* Unless userspace set the 'universal planes' |
* capability bit, only advertise overlays. |
2263,7 → 2288,55 |
|
return 0; |
} |
#endif |
|
/** |
* drm_plane_check_pixel_format - Check if the plane supports the pixel format |
* @plane: plane to check for format support |
* @format: the pixel format |
* |
* Returns: |
* Zero of @plane has @format in its list of supported pixel formats, -EINVAL |
* otherwise. |
*/ |
int drm_plane_check_pixel_format(const struct drm_plane *plane, u32 format) |
{ |
unsigned int i; |
|
for (i = 0; i < plane->format_count; i++) { |
if (format == plane->format_types[i]) |
return 0; |
} |
|
return -EINVAL; |
} |
|
static int check_src_coords(uint32_t src_x, uint32_t src_y, |
uint32_t src_w, uint32_t src_h, |
const struct drm_framebuffer *fb) |
{ |
unsigned int fb_width, fb_height; |
|
fb_width = fb->width << 16; |
fb_height = fb->height << 16; |
|
/* Make sure source coordinates are inside the fb. */ |
if (src_w > fb_width || |
src_x > fb_width - src_w || |
src_h > fb_height || |
src_y > fb_height - src_h) { |
DRM_DEBUG_KMS("Invalid source coordinates " |
"%u.%06ux%u.%06u+%u.%06u+%u.%06u\n", |
src_w >> 16, ((src_w & 0xffff) * 15625) >> 10, |
src_h >> 16, ((src_h & 0xffff) * 15625) >> 10, |
src_x >> 16, ((src_x & 0xffff) * 15625) >> 10, |
src_y >> 16, ((src_y & 0xffff) * 15625) >> 10); |
return -ENOSPC; |
} |
|
return 0; |
} |
|
/* |
* setplane_internal - setplane handler for internal callers |
* |
2283,8 → 2356,6 |
uint32_t src_w, uint32_t src_h) |
{ |
int ret = 0; |
unsigned int fb_width, fb_height; |
unsigned int i; |
|
/* No fb means shut it down */ |
if (!fb) { |
2307,34 → 2378,28 |
} |
|
/* Check whether this plane supports the fb pixel format. */ |
for (i = 0; i < plane->format_count; i++) |
if (fb->pixel_format == plane->format_types[i]) |
break; |
if (i == plane->format_count) { |
ret = drm_plane_check_pixel_format(plane, fb->pixel_format); |
if (ret) { |
DRM_DEBUG_KMS("Invalid pixel format %s\n", |
drm_get_format_name(fb->pixel_format)); |
ret = -EINVAL; |
goto out; |
} |
|
fb_width = fb->width << 16; |
fb_height = fb->height << 16; |
|
/* Make sure source coordinates are inside the fb. */ |
if (src_w > fb_width || |
src_x > fb_width - src_w || |
src_h > fb_height || |
src_y > fb_height - src_h) { |
DRM_DEBUG_KMS("Invalid source coordinates " |
"%u.%06ux%u.%06u+%u.%06u+%u.%06u\n", |
src_w >> 16, ((src_w & 0xffff) * 15625) >> 10, |
src_h >> 16, ((src_h & 0xffff) * 15625) >> 10, |
src_x >> 16, ((src_x & 0xffff) * 15625) >> 10, |
src_y >> 16, ((src_y & 0xffff) * 15625) >> 10); |
ret = -ENOSPC; |
/* Give drivers some help against integer overflows */ |
if (crtc_w > INT_MAX || |
crtc_x > INT_MAX - (int32_t) crtc_w || |
crtc_h > INT_MAX || |
crtc_y > INT_MAX - (int32_t) crtc_h) { |
DRM_DEBUG_KMS("Invalid CRTC coordinates %ux%u+%d+%d\n", |
crtc_w, crtc_h, crtc_x, crtc_y); |
ret = -ERANGE; |
goto out; |
} |
|
ret = check_src_coords(src_x, src_y, src_w, src_h, fb); |
if (ret) |
goto out; |
|
plane->old_fb = plane->fb; |
ret = plane->funcs->update_plane(plane, crtc, fb, |
crtc_x, crtc_y, crtc_w, crtc_h, |
2401,17 → 2466,6 |
if (!drm_core_check_feature(dev, DRIVER_MODESET)) |
return -EINVAL; |
|
/* Give drivers some help against integer overflows */ |
if (plane_req->crtc_w > INT_MAX || |
plane_req->crtc_x > INT_MAX - (int32_t) plane_req->crtc_w || |
plane_req->crtc_h > INT_MAX || |
plane_req->crtc_y > INT_MAX - (int32_t) plane_req->crtc_h) { |
DRM_DEBUG_KMS("Invalid CRTC coordinates %ux%u+%d+%d\n", |
plane_req->crtc_w, plane_req->crtc_h, |
plane_req->crtc_x, plane_req->crtc_y); |
return -ERANGE; |
} |
|
/* |
* First, find the plane, crtc, and fb objects. If not available, |
* we don't bother to call the driver. |
2449,7 → 2503,6 |
plane_req->src_x, plane_req->src_y, |
plane_req->src_w, plane_req->src_h); |
} |
#endif |
|
/** |
* drm_mode_set_config_internal - helper to call ->set_config |
2473,7 → 2526,7 |
* connectors from it), hence we need to refcount the fbs across all |
* crtcs. Atomic modeset will have saner semantics ... |
*/ |
list_for_each_entry(tmp, &crtc->dev->mode_config.crtc_list, head) |
drm_for_each_crtc(tmp, crtc->dev) |
tmp->primary->old_fb = tmp->primary->fb; |
|
fb = set->fb; |
2484,7 → 2537,7 |
crtc->primary->fb = fb; |
} |
|
list_for_each_entry(tmp, &crtc->dev->mode_config.crtc_list, head) { |
drm_for_each_crtc(tmp, crtc->dev) { |
if (tmp->primary->fb) |
drm_framebuffer_reference(tmp->primary->fb); |
// if (tmp->old_fb) |
2495,8 → 2548,28 |
} |
EXPORT_SYMBOL(drm_mode_set_config_internal); |
|
#if 0 |
/** |
* drm_crtc_get_hv_timing - Fetches hdisplay/vdisplay for given mode |
* @mode: mode to query |
* @hdisplay: hdisplay value to fill in |
* @vdisplay: vdisplay value to fill in |
* |
* The vdisplay value will be doubled if the specified mode is a stereo mode of |
* the appropriate layout. |
*/ |
void drm_crtc_get_hv_timing(const struct drm_display_mode *mode, |
int *hdisplay, int *vdisplay) |
{ |
struct drm_display_mode adjusted; |
|
drm_mode_copy(&adjusted, mode); |
drm_mode_set_crtcinfo(&adjusted, CRTC_STEREO_DOUBLE_ONLY); |
*hdisplay = adjusted.crtc_hdisplay; |
*vdisplay = adjusted.crtc_vdisplay; |
} |
EXPORT_SYMBOL(drm_crtc_get_hv_timing); |
|
/** |
* drm_crtc_check_viewport - Checks that a framebuffer is big enough for the |
* CRTC viewport |
* @crtc: CRTC that framebuffer will be displayed on |
2513,34 → 2586,19 |
{ |
int hdisplay, vdisplay; |
|
hdisplay = mode->hdisplay; |
vdisplay = mode->vdisplay; |
drm_crtc_get_hv_timing(mode, &hdisplay, &vdisplay); |
|
if (drm_mode_is_stereo(mode)) { |
struct drm_display_mode adjusted = *mode; |
|
drm_mode_set_crtcinfo(&adjusted, CRTC_STEREO_DOUBLE); |
hdisplay = adjusted.crtc_hdisplay; |
vdisplay = adjusted.crtc_vdisplay; |
} |
|
if (crtc->invert_dimensions) |
if (crtc->state && |
crtc->primary->state->rotation & (BIT(DRM_ROTATE_90) | |
BIT(DRM_ROTATE_270))) |
swap(hdisplay, vdisplay); |
|
if (hdisplay > fb->width || |
vdisplay > fb->height || |
x > fb->width - hdisplay || |
y > fb->height - vdisplay) { |
DRM_DEBUG_KMS("Invalid fb size %ux%u for CRTC viewport %ux%u+%d+%d%s.\n", |
fb->width, fb->height, hdisplay, vdisplay, x, y, |
crtc->invert_dimensions ? " (inverted)" : ""); |
return -ENOSPC; |
return check_src_coords(x << 16, y << 16, |
hdisplay << 16, vdisplay << 16, fb); |
} |
|
return 0; |
} |
EXPORT_SYMBOL(drm_crtc_check_viewport); |
|
#if 0 |
/** |
* drm_mode_setcrtc - set CRTC configuration |
* @dev: drm device for the ioctl |
2571,8 → 2629,11 |
if (!drm_core_check_feature(dev, DRIVER_MODESET)) |
return -EINVAL; |
|
/* For some reason crtc x/y offsets are signed internally. */ |
if (crtc_req->x > INT_MAX || crtc_req->y > INT_MAX) |
/* |
* Universal plane src offsets are only 16.16, prevent havoc for |
* drivers using universal plane code internally. |
*/ |
if (crtc_req->x & 0xffff0000 || crtc_req->y & 0xffff0000) |
return -ERANGE; |
|
drm_modeset_lock_all(dev); |
2612,7 → 2673,7 |
goto out; |
} |
|
ret = drm_crtc_convert_umode(mode, &crtc_req->mode); |
ret = drm_mode_convert_umode(mode, &crtc_req->mode); |
if (ret) { |
DRM_DEBUG_KMS("Invalid mode\n"); |
goto out; |
2620,6 → 2681,23 |
|
drm_mode_set_crtcinfo(mode, CRTC_INTERLACE_HALVE_V); |
|
/* |
* Check whether the primary plane supports the fb pixel format. |
* Drivers not implementing the universal planes API use a |
* default formats list provided by the DRM core which doesn't |
* match real hardware capabilities. Skip the check in that |
* case. |
*/ |
if (!crtc->primary->format_default) { |
ret = drm_plane_check_pixel_format(crtc->primary, |
fb->pixel_format); |
if (ret) { |
DRM_DEBUG_KMS("Invalid pixel format %s\n", |
drm_get_format_name(fb->pixel_format)); |
goto out; |
} |
} |
|
ret = drm_crtc_check_viewport(crtc, crtc_req->x, crtc_req->y, |
mode, fb); |
if (ret) |
2649,7 → 2727,7 |
goto out; |
} |
|
connector_set = kmalloc(crtc_req->count_connectors * |
connector_set = kmalloc_array(crtc_req->count_connectors, |
sizeof(struct drm_connector *), |
GFP_KERNEL); |
if (!connector_set) { |
2659,10 → 2737,10 |
|
for (i = 0; i < crtc_req->count_connectors; i++) { |
set_connectors_ptr = (uint32_t __user *)(unsigned long)crtc_req->set_connectors_ptr; |
if (get_user(out_id, &set_connectors_ptr[i])) { |
ret = -EFAULT; |
goto out; |
} |
// if (get_user(out_id, &set_connectors_ptr[i])) { |
// ret = -EFAULT; |
// goto out; |
// } |
|
connector = drm_connector_find(dev, out_id); |
if (!connector) { |
2801,6 → 2879,7 |
void *data, struct drm_file *file_priv) |
{ |
struct drm_mode_cursor2 *req = data; |
|
return drm_mode_cursor_common(dev, req, file_priv); |
} |
#endif |
3004,12 → 3083,63 |
DRM_DEBUG_KMS("bad pitch %u for plane %d\n", r->pitches[i], i); |
return -EINVAL; |
} |
|
if (r->modifier[i] && !(r->flags & DRM_MODE_FB_MODIFIERS)) { |
DRM_DEBUG_KMS("bad fb modifier %llu for plane %d\n", |
r->modifier[i], i); |
return -EINVAL; |
} |
|
/* modifier specific checks: */ |
switch (r->modifier[i]) { |
case DRM_FORMAT_MOD_SAMSUNG_64_32_TILE: |
/* NOTE: the pitch restriction may be lifted later if it turns |
* out that no hw has this restriction: |
*/ |
if (r->pixel_format != DRM_FORMAT_NV12 || |
width % 128 || height % 32 || |
r->pitches[i] % 128) { |
DRM_DEBUG_KMS("bad modifier data for plane %d\n", i); |
return -EINVAL; |
} |
break; |
|
default: |
break; |
} |
} |
|
for (i = num_planes; i < 4; i++) { |
if (r->modifier[i]) { |
DRM_DEBUG_KMS("non-zero modifier for unused plane %d\n", i); |
return -EINVAL; |
} |
|
/* Pre-FB_MODIFIERS userspace didn't clear the structs properly. */ |
if (!(r->flags & DRM_MODE_FB_MODIFIERS)) |
continue; |
|
if (r->handles[i]) { |
DRM_DEBUG_KMS("buffer object handle for unused plane %d\n", i); |
return -EINVAL; |
} |
|
if (r->pitches[i]) { |
DRM_DEBUG_KMS("non-zero pitch for unused plane %d\n", i); |
return -EINVAL; |
} |
|
if (r->offsets[i]) { |
DRM_DEBUG_KMS("non-zero offset for unused plane %d\n", i); |
return -EINVAL; |
} |
} |
|
return 0; |
} |
|
static struct drm_framebuffer *add_framebuffer_internal(struct drm_device *dev, |
static struct drm_framebuffer * |
internal_framebuffer_create(struct drm_device *dev, |
struct drm_mode_fb_cmd2 *r, |
struct drm_file *file_priv) |
{ |
3017,7 → 3147,7 |
struct drm_framebuffer *fb; |
int ret; |
|
if (r->flags & ~DRM_MODE_FB_INTERLACED) { |
if (r->flags & ~(DRM_MODE_FB_INTERLACED | DRM_MODE_FB_MODIFIERS)) { |
DRM_DEBUG_KMS("bad framebuffer flags 0x%08x\n", r->flags); |
return ERR_PTR(-EINVAL); |
} |
3033,6 → 3163,12 |
return ERR_PTR(-EINVAL); |
} |
|
if (r->flags & DRM_MODE_FB_MODIFIERS && |
!dev->mode_config.allow_fb_modifiers) { |
DRM_DEBUG_KMS("driver does not support fb modifiers\n"); |
return ERR_PTR(-EINVAL); |
} |
|
ret = framebuffer_check(r); |
if (ret) |
return ERR_PTR(ret); |
3043,12 → 3179,6 |
return fb; |
} |
|
mutex_lock(&file_priv->fbs_lock); |
r->fb_id = fb->base.id; |
list_add(&fb->filp_head, &file_priv->fbs); |
DRM_DEBUG_KMS("[FB:%d]\n", fb->base.id); |
mutex_unlock(&file_priv->fbs_lock); |
|
return fb; |
} |
|
3070,15 → 3200,24 |
int drm_mode_addfb2(struct drm_device *dev, |
void *data, struct drm_file *file_priv) |
{ |
struct drm_mode_fb_cmd2 *r = data; |
struct drm_framebuffer *fb; |
|
if (!drm_core_check_feature(dev, DRIVER_MODESET)) |
return -EINVAL; |
|
fb = add_framebuffer_internal(dev, data, file_priv); |
fb = internal_framebuffer_create(dev, r, file_priv); |
if (IS_ERR(fb)) |
return PTR_ERR(fb); |
|
/* Transfer ownership to the filp for reaping on close */ |
|
DRM_DEBUG_KMS("[FB:%d]\n", fb->base.id); |
mutex_lock(&file_priv->fbs_lock); |
r->fb_id = fb->base.id; |
list_add(&fb->filp_head, &file_priv->fbs); |
mutex_unlock(&file_priv->fbs_lock); |
|
return 0; |
} |
|
3118,14 → 3257,11 |
if (!found) |
goto fail_lookup; |
|
/* Mark fb as reaped, we still have a ref from fpriv->fbs. */ |
__drm_framebuffer_unregister(dev, fb); |
|
list_del_init(&fb->filp_head); |
mutex_unlock(&dev->mode_config.fb_lock); |
mutex_unlock(&file_priv->fbs_lock); |
|
drm_framebuffer_remove(fb); |
drm_framebuffer_unreference(fb); |
|
return 0; |
|
3249,7 → 3385,7 |
ret = -EINVAL; |
goto out_err1; |
} |
clips = kzalloc(num_clips * sizeof(*clips), GFP_KERNEL); |
clips = kcalloc(num_clips, sizeof(*clips), GFP_KERNEL); |
if (!clips) { |
ret = -ENOMEM; |
goto out_err1; |
3292,7 → 3428,6 |
*/ |
void drm_fb_release(struct drm_file *priv) |
{ |
struct drm_device *dev = priv->minor->dev; |
struct drm_framebuffer *fb, *tfb; |
|
/* |
3306,16 → 3441,10 |
* at it any more. |
*/ |
list_for_each_entry_safe(fb, tfb, &priv->fbs, filp_head) { |
|
mutex_lock(&dev->mode_config.fb_lock); |
/* Mark fb as reaped, we still have a ref from fpriv->fbs. */ |
__drm_framebuffer_unregister(dev, fb); |
mutex_unlock(&dev->mode_config.fb_lock); |
|
list_del_init(&fb->filp_head); |
|
/* This will also drop the fpriv->fbs reference. */ |
drm_framebuffer_remove(fb); |
/* This drops the fpriv->fbs reference. */ |
drm_framebuffer_unreference(fb); |
} |
} |
#endif |
3352,7 → 3481,8 |
property->dev = dev; |
|
if (num_values) { |
property->values = kzalloc(sizeof(uint64_t)*num_values, GFP_KERNEL); |
property->values = kcalloc(num_values, sizeof(uint64_t), |
GFP_KERNEL); |
if (!property->values) |
goto fail; |
} |
3501,7 → 3631,7 |
} |
|
/** |
* drm_property_create_range - create a new ranged property type |
* drm_property_create_range - create a new unsigned ranged property type |
* @dev: drm device |
* @flags: flags specifying the property type |
* @name: name of the property |
3512,8 → 3642,8 |
* object with drm_object_attach_property. The returned property object must be |
* freed with drm_property_destroy. |
* |
* Userspace is allowed to set any integer value in the (min, max) range |
* inclusive. |
* Userspace is allowed to set any unsigned integer value in the (min, max) |
* range inclusive. |
* |
* Returns: |
* A pointer to the newly created property on success, NULL on failure. |
3527,6 → 3657,24 |
} |
EXPORT_SYMBOL(drm_property_create_range); |
|
/** |
* drm_property_create_signed_range - create a new signed ranged property type |
* @dev: drm device |
* @flags: flags specifying the property type |
* @name: name of the property |
* @min: minimum value of the property |
* @max: maximum value of the property |
* |
* This creates a new generic drm property which can then be attached to a drm |
* object with drm_object_attach_property. The returned property object must be |
* freed with drm_property_destroy. |
* |
* Userspace is allowed to set any signed integer value in the (min, max) |
* range inclusive. |
* |
* Returns: |
* A pointer to the newly created property on success, NULL on failure. |
*/ |
struct drm_property *drm_property_create_signed_range(struct drm_device *dev, |
int flags, const char *name, |
int64_t min, int64_t max) |
3536,6 → 3684,23 |
} |
EXPORT_SYMBOL(drm_property_create_signed_range); |
|
/** |
* drm_property_create_object - create a new object property type |
* @dev: drm device |
* @flags: flags specifying the property type |
* @name: name of the property |
* @type: object type from DRM_MODE_OBJECT_* defines |
* |
* This creates a new generic drm property which can then be attached to a drm |
* object with drm_object_attach_property. The returned property object must be |
* freed with drm_property_destroy. |
* |
* Userspace is only allowed to set this to any property value of the given |
* @type. Only useful for atomic properties, which is enforced. |
* |
* Returns: |
* A pointer to the newly created property on success, NULL on failure. |
*/ |
struct drm_property *drm_property_create_object(struct drm_device *dev, |
int flags, const char *name, uint32_t type) |
{ |
3543,6 → 3708,9 |
|
flags |= DRM_MODE_PROP_OBJECT; |
|
if (WARN_ON(!(flags & DRM_MODE_PROP_ATOMIC))) |
return NULL; |
|
property = drm_property_create(dev, flags, name, 1); |
if (!property) |
return NULL; |
3554,6 → 3722,28 |
EXPORT_SYMBOL(drm_property_create_object); |
|
/** |
* drm_property_create_bool - create a new boolean property type |
* @dev: drm device |
* @flags: flags specifying the property type |
* @name: name of the property |
* |
* This creates a new generic drm property which can then be attached to a drm |
* object with drm_object_attach_property. The returned property object must be |
* freed with drm_property_destroy. |
* |
* This is implemented as a ranged property with only {0, 1} as valid values. |
* |
* Returns: |
* A pointer to the newly created property on success, NULL on failure. |
*/ |
struct drm_property *drm_property_create_bool(struct drm_device *dev, int flags, |
const char *name) |
{ |
return drm_property_create_range(dev, flags, name, 0, 1); |
} |
EXPORT_SYMBOL(drm_property_create_bool); |
|
/** |
* drm_property_add_enum - add a possible value to an enumeration property |
* @property: enumeration property to change |
* @index: index of the new enumeration |
3658,9 → 3848,11 |
return; |
} |
|
obj->properties->ids[count] = property->base.id; |
obj->properties->properties[count] = property; |
obj->properties->values[count] = init_val; |
obj->properties->count++; |
if (property->flags & DRM_MODE_PROP_ATOMIC) |
obj->properties->atomic_count++; |
} |
EXPORT_SYMBOL(drm_object_attach_property); |
|
3683,7 → 3875,7 |
int i; |
|
for (i = 0; i < obj->properties->count; i++) { |
if (obj->properties->ids[i] == property->base.id) { |
if (obj->properties->properties[i] == property) { |
obj->properties->values[i] = val; |
return 0; |
} |
3712,8 → 3904,16 |
{ |
int i; |
|
/* read-only properties bypass atomic mechanism and still store |
* their value in obj->properties->values[].. mostly to avoid |
* having to deal w/ EDID and similar props in atomic paths: |
*/ |
if (drm_core_check_feature(property->dev, DRIVER_ATOMIC) && |
!(property->flags & DRM_MODE_PROP_IMMUTABLE)) |
return drm_atomic_get_property(obj, property, val); |
|
for (i = 0; i < obj->properties->count; i++) { |
if (obj->properties->ids[i] == property->base.id) { |
if (obj->properties->properties[i] == property) { |
*val = obj->properties->values[i]; |
return 0; |
} |
3825,7 → 4025,21 |
} |
#endif |
|
static struct drm_property_blob * |
/** |
* drm_property_create_blob - Create new blob property |
* |
* Creates a new blob property for a specified DRM device, optionally |
* copying data. |
* |
* @dev: DRM device to create property for |
* @length: Length to allocate for blob data |
* @data: If specified, copies data into blob |
* |
* Returns: |
* New blob property with a single reference on success, or an ERR_PTR |
* value on failure. |
*/ |
struct drm_property_blob * |
drm_property_create_blob(struct drm_device *dev, size_t length, |
const void *data) |
{ |
3832,35 → 4046,267 |
struct drm_property_blob *blob; |
int ret; |
|
if (!length || !data) |
return NULL; |
if (!length || length > ULONG_MAX - sizeof(struct drm_property_blob)) |
return ERR_PTR(-EINVAL); |
|
blob = kzalloc(sizeof(struct drm_property_blob)+length, GFP_KERNEL); |
if (!blob) |
return NULL; |
return ERR_PTR(-ENOMEM); |
|
/* This must be explicitly initialised, so we can safely call list_del |
* on it in the removal handler, even if it isn't in a file list. */ |
INIT_LIST_HEAD(&blob->head_file); |
blob->length = length; |
blob->dev = dev; |
|
if (data) |
memcpy(blob->data, data, length); |
|
mutex_lock(&dev->mode_config.blob_lock); |
|
ret = drm_mode_object_get(dev, &blob->base, DRM_MODE_OBJECT_BLOB); |
if (ret) { |
kfree(blob); |
return NULL; |
mutex_unlock(&dev->mode_config.blob_lock); |
return ERR_PTR(-EINVAL); |
} |
|
blob->length = length; |
kref_init(&blob->refcount); |
|
memcpy(blob->data, data, length); |
list_add_tail(&blob->head_global, |
&dev->mode_config.property_blob_list); |
|
list_add_tail(&blob->head, &dev->mode_config.property_blob_list); |
mutex_unlock(&dev->mode_config.blob_lock); |
|
return blob; |
} |
EXPORT_SYMBOL(drm_property_create_blob); |
|
static void drm_property_destroy_blob(struct drm_device *dev, |
struct drm_property_blob *blob) |
/** |
* drm_property_free_blob - Blob property destructor |
* |
* Internal free function for blob properties; must not be used directly. |
* |
* @kref: Reference |
*/ |
static void drm_property_free_blob(struct kref *kref) |
{ |
drm_mode_object_put(dev, &blob->base); |
list_del(&blob->head); |
struct drm_property_blob *blob = |
container_of(kref, struct drm_property_blob, refcount); |
|
WARN_ON(!mutex_is_locked(&blob->dev->mode_config.blob_lock)); |
|
list_del(&blob->head_global); |
list_del(&blob->head_file); |
drm_mode_object_put(blob->dev, &blob->base); |
|
kfree(blob); |
} |
|
/** |
* drm_property_unreference_blob - Unreference a blob property |
* |
* Drop a reference on a blob property. May free the object. |
* |
* @blob: Pointer to blob property |
*/ |
void drm_property_unreference_blob(struct drm_property_blob *blob) |
{ |
struct drm_device *dev; |
|
if (!blob) |
return; |
|
dev = blob->dev; |
|
DRM_DEBUG("%p: blob ID: %d (%d)\n", blob, blob->base.id, atomic_read(&blob->refcount.refcount)); |
|
if (kref_put_mutex(&blob->refcount, drm_property_free_blob, |
&dev->mode_config.blob_lock)) |
mutex_unlock(&dev->mode_config.blob_lock); |
else |
might_lock(&dev->mode_config.blob_lock); |
} |
EXPORT_SYMBOL(drm_property_unreference_blob); |
|
/** |
* drm_property_unreference_blob_locked - Unreference a blob property with blob_lock held |
* |
* Drop a reference on a blob property. May free the object. This must be |
* called with blob_lock held. |
* |
* @blob: Pointer to blob property |
*/ |
static void drm_property_unreference_blob_locked(struct drm_property_blob *blob) |
{ |
if (!blob) |
return; |
|
DRM_DEBUG("%p: blob ID: %d (%d)\n", blob, blob->base.id, atomic_read(&blob->refcount.refcount)); |
|
kref_put(&blob->refcount, drm_property_free_blob); |
} |
|
/** |
* drm_property_destroy_user_blobs - destroy all blobs created by this client |
* @dev: DRM device |
* @file_priv: destroy all blobs owned by this file handle |
*/ |
void drm_property_destroy_user_blobs(struct drm_device *dev, |
struct drm_file *file_priv) |
{ |
struct drm_property_blob *blob, *bt; |
|
mutex_lock(&dev->mode_config.blob_lock); |
|
list_for_each_entry_safe(blob, bt, &file_priv->blobs, head_file) { |
list_del_init(&blob->head_file); |
drm_property_unreference_blob_locked(blob); |
} |
|
mutex_unlock(&dev->mode_config.blob_lock); |
} |
|
/** |
* drm_property_reference_blob - Take a reference on an existing property |
* |
* Take a new reference on an existing blob property. |
* |
* @blob: Pointer to blob property |
*/ |
struct drm_property_blob *drm_property_reference_blob(struct drm_property_blob *blob) |
{ |
DRM_DEBUG("%p: blob ID: %d (%d)\n", blob, blob->base.id, atomic_read(&blob->refcount.refcount)); |
kref_get(&blob->refcount); |
return blob; |
} |
EXPORT_SYMBOL(drm_property_reference_blob); |
|
/* |
* Like drm_property_lookup_blob, but does not return an additional reference. |
* Must be called with blob_lock held. |
*/ |
static struct drm_property_blob *__drm_property_lookup_blob(struct drm_device *dev, |
uint32_t id) |
{ |
struct drm_mode_object *obj = NULL; |
struct drm_property_blob *blob; |
|
WARN_ON(!mutex_is_locked(&dev->mode_config.blob_lock)); |
|
mutex_lock(&dev->mode_config.idr_mutex); |
obj = idr_find(&dev->mode_config.crtc_idr, id); |
if (!obj || (obj->type != DRM_MODE_OBJECT_BLOB) || (obj->id != id)) |
blob = NULL; |
else |
blob = obj_to_blob(obj); |
mutex_unlock(&dev->mode_config.idr_mutex); |
|
return blob; |
} |
|
/** |
* drm_property_lookup_blob - look up a blob property and take a reference |
* @dev: drm device |
* @id: id of the blob property |
* |
* If successful, this takes an additional reference to the blob property. |
* callers need to make sure to eventually unreference the returned property |
* again, using @drm_property_unreference_blob. |
*/ |
struct drm_property_blob *drm_property_lookup_blob(struct drm_device *dev, |
uint32_t id) |
{ |
struct drm_property_blob *blob; |
|
mutex_lock(&dev->mode_config.blob_lock); |
blob = __drm_property_lookup_blob(dev, id); |
if (blob) { |
if (!kref_get_unless_zero(&blob->refcount)) |
blob = NULL; |
} |
mutex_unlock(&dev->mode_config.blob_lock); |
|
return blob; |
} |
EXPORT_SYMBOL(drm_property_lookup_blob); |
|
/** |
* drm_property_replace_global_blob - atomically replace existing blob property |
* @dev: drm device |
* @replace: location of blob property pointer to be replaced |
* @length: length of data for new blob, or 0 for no data |
* @data: content for new blob, or NULL for no data |
* @obj_holds_id: optional object for property holding blob ID |
* @prop_holds_id: optional property holding blob ID |
* @return 0 on success or error on failure |
* |
* This function will atomically replace a global property in the blob list, |
* optionally updating a property which holds the ID of that property. It is |
* guaranteed to be atomic: no caller will be allowed to see intermediate |
* results, and either the entire operation will succeed and clean up the |
* previous property, or it will fail and the state will be unchanged. |
* |
* If length is 0 or data is NULL, no new blob will be created, and the holding |
* property, if specified, will be set to 0. |
* |
* Access to the replace pointer is assumed to be protected by the caller, e.g. |
* by holding the relevant modesetting object lock for its parent. |
* |
* For example, a drm_connector has a 'PATH' property, which contains the ID |
* of a blob property with the value of the MST path information. Calling this |
* function with replace pointing to the connector's path_blob_ptr, length and |
* data set for the new path information, obj_holds_id set to the connector's |
* base object, and prop_holds_id set to the path property name, will perform |
* a completely atomic update. The access to path_blob_ptr is protected by the |
* caller holding a lock on the connector. |
*/ |
static int drm_property_replace_global_blob(struct drm_device *dev, |
struct drm_property_blob **replace, |
size_t length, |
const void *data, |
struct drm_mode_object *obj_holds_id, |
struct drm_property *prop_holds_id) |
{ |
struct drm_property_blob *new_blob = NULL; |
struct drm_property_blob *old_blob = NULL; |
int ret; |
|
WARN_ON(replace == NULL); |
|
old_blob = *replace; |
|
if (length && data) { |
new_blob = drm_property_create_blob(dev, length, data); |
if (IS_ERR(new_blob)) |
return PTR_ERR(new_blob); |
} |
|
/* This does not need to be synchronised with blob_lock, as the |
* get_properties ioctl locks all modesetting objects, and |
* obj_holds_id must be locked before calling here, so we cannot |
* have its value out of sync with the list membership modified |
* below under blob_lock. */ |
if (obj_holds_id) { |
ret = drm_object_property_set_value(obj_holds_id, |
prop_holds_id, |
new_blob ? |
new_blob->base.id : 0); |
if (ret != 0) |
goto err_created; |
} |
|
drm_property_unreference_blob(old_blob); |
*replace = new_blob; |
|
return 0; |
|
err_created: |
drm_property_unreference_blob(new_blob); |
return ret; |
} |
|
|
#if 0 |
/** |
* drm_mode_getblob_ioctl - get the contents of a blob property value |
3888,7 → 4334,8 |
return -EINVAL; |
|
drm_modeset_lock_all(dev); |
blob = drm_property_blob_find(dev, out_resp->blob_id); |
mutex_lock(&dev->mode_config.blob_lock); |
blob = __drm_property_lookup_blob(dev, out_resp->blob_id); |
if (!blob) { |
ret = -ENOENT; |
goto done; |
3904,6 → 4351,7 |
out_resp->length = blob->length; |
|
done: |
mutex_unlock(&dev->mode_config.blob_lock); |
drm_modeset_unlock_all(dev); |
return ret; |
} |
3912,7 → 4360,7 |
/** |
* drm_mode_connector_set_path_property - set tile property on connector |
* @connector: connector to set property on. |
* @path: path to use for property. |
* @path: path to use for property; must not be NULL. |
* |
* This creates a property to expose to userspace to specify a |
* connector path. This is mainly used for DisplayPort MST where |
3926,17 → 4374,14 |
const char *path) |
{ |
struct drm_device *dev = connector->dev; |
size_t size = strlen(path) + 1; |
int ret; |
|
connector->path_blob_ptr = drm_property_create_blob(connector->dev, |
size, path); |
if (!connector->path_blob_ptr) |
return -EINVAL; |
|
ret = drm_object_property_set_value(&connector->base, |
dev->mode_config.path_property, |
connector->path_blob_ptr->base.id); |
ret = drm_property_replace_global_blob(dev, |
&connector->path_blob_ptr, |
strlen(path) + 1, |
path, |
&connector->base, |
dev->mode_config.path_property); |
return ret; |
} |
EXPORT_SYMBOL(drm_mode_connector_set_path_property); |
3955,16 → 4400,16 |
int drm_mode_connector_set_tile_property(struct drm_connector *connector) |
{ |
struct drm_device *dev = connector->dev; |
int ret, size; |
char tile[256]; |
int ret; |
|
if (connector->tile_blob_ptr) |
drm_property_destroy_blob(dev, connector->tile_blob_ptr); |
|
if (!connector->has_tile) { |
connector->tile_blob_ptr = NULL; |
ret = drm_object_property_set_value(&connector->base, |
dev->mode_config.tile_property, 0); |
ret = drm_property_replace_global_blob(dev, |
&connector->tile_blob_ptr, |
0, |
NULL, |
&connector->base, |
dev->mode_config.tile_property); |
return ret; |
} |
|
3973,16 → 4418,13 |
connector->num_h_tile, connector->num_v_tile, |
connector->tile_h_loc, connector->tile_v_loc, |
connector->tile_h_size, connector->tile_v_size); |
size = strlen(tile) + 1; |
|
connector->tile_blob_ptr = drm_property_create_blob(connector->dev, |
size, tile); |
if (!connector->tile_blob_ptr) |
return -EINVAL; |
|
ret = drm_object_property_set_value(&connector->base, |
dev->mode_config.tile_property, |
connector->tile_blob_ptr->base.id); |
ret = drm_property_replace_global_blob(dev, |
&connector->tile_blob_ptr, |
strlen(tile) + 1, |
tile, |
&connector->base, |
dev->mode_config.tile_property); |
return ret; |
} |
EXPORT_SYMBOL(drm_mode_connector_set_tile_property); |
4002,7 → 4444,7 |
const struct edid *edid) |
{ |
struct drm_device *dev = connector->dev; |
size_t size; |
size_t size = 0; |
int ret; |
|
/* ignore requests to set edid when overridden */ |
4009,32 → 4451,108 |
if (connector->override_edid) |
return 0; |
|
if (connector->edid_blob_ptr) |
drm_property_destroy_blob(dev, connector->edid_blob_ptr); |
if (edid) |
size = EDID_LENGTH * (1 + edid->extensions); |
|
/* Delete edid, when there is none. */ |
if (!edid) { |
connector->edid_blob_ptr = NULL; |
ret = drm_object_property_set_value(&connector->base, dev->mode_config.edid_property, 0); |
ret = drm_property_replace_global_blob(dev, |
&connector->edid_blob_ptr, |
size, |
edid, |
&connector->base, |
dev->mode_config.edid_property); |
return ret; |
} |
EXPORT_SYMBOL(drm_mode_connector_update_edid_property); |
|
size = EDID_LENGTH * (1 + edid->extensions); |
connector->edid_blob_ptr = drm_property_create_blob(connector->dev, |
size, edid); |
if (!connector->edid_blob_ptr) |
return -EINVAL; |
/* Some properties could refer to dynamic refcnt'd objects, or things that |
* need special locking to handle lifetime issues (ie. to ensure the prop |
* value doesn't become invalid part way through the property update due to |
* race). The value returned by reference via 'obj' should be passed back |
* to drm_property_change_valid_put() after the property is set (and the |
* object to which the property is attached has a chance to take it's own |
* reference). |
*/ |
bool drm_property_change_valid_get(struct drm_property *property, |
uint64_t value, struct drm_mode_object **ref) |
{ |
int i; |
|
ret = drm_object_property_set_value(&connector->base, |
dev->mode_config.edid_property, |
connector->edid_blob_ptr->base.id); |
if (property->flags & DRM_MODE_PROP_IMMUTABLE) |
return false; |
|
return ret; |
*ref = NULL; |
|
if (drm_property_type_is(property, DRM_MODE_PROP_RANGE)) { |
if (value < property->values[0] || value > property->values[1]) |
return false; |
return true; |
} else if (drm_property_type_is(property, DRM_MODE_PROP_SIGNED_RANGE)) { |
int64_t svalue = U642I64(value); |
|
if (svalue < U642I64(property->values[0]) || |
svalue > U642I64(property->values[1])) |
return false; |
return true; |
} else if (drm_property_type_is(property, DRM_MODE_PROP_BITMASK)) { |
uint64_t valid_mask = 0; |
|
for (i = 0; i < property->num_values; i++) |
valid_mask |= (1ULL << property->values[i]); |
return !(value & ~valid_mask); |
} else if (drm_property_type_is(property, DRM_MODE_PROP_BLOB)) { |
struct drm_property_blob *blob; |
|
if (value == 0) |
return true; |
|
blob = drm_property_lookup_blob(property->dev, value); |
if (blob) { |
*ref = &blob->base; |
return true; |
} else { |
return false; |
} |
EXPORT_SYMBOL(drm_mode_connector_update_edid_property); |
} else if (drm_property_type_is(property, DRM_MODE_PROP_OBJECT)) { |
/* a zero value for an object property translates to null: */ |
if (value == 0) |
return true; |
|
/* handle refcnt'd objects specially: */ |
if (property->values[0] == DRM_MODE_OBJECT_FB) { |
struct drm_framebuffer *fb; |
fb = drm_framebuffer_lookup(property->dev, value); |
if (fb) { |
*ref = &fb->base; |
return true; |
} else { |
return false; |
} |
} else { |
return _object_find(property->dev, value, property->values[0]) != NULL; |
} |
} |
|
for (i = 0; i < property->num_values; i++) |
if (property->values[i] == value) |
return true; |
return false; |
} |
|
void drm_property_change_valid_put(struct drm_property *property, |
struct drm_mode_object *ref) |
{ |
if (!ref) |
return; |
|
if (drm_property_type_is(property, DRM_MODE_PROP_OBJECT)) { |
if (property->values[0] == DRM_MODE_OBJECT_FB) |
drm_framebuffer_unreference(obj_to_fb(ref)); |
} else if (drm_property_type_is(property, DRM_MODE_PROP_BLOB)) |
drm_property_unreference_blob(obj_to_blob(ref)); |
} |
|
|
|
static int drm_mode_connector_set_obj_prop(struct drm_mode_object *obj, |
struct drm_property *property, |
uint64_t value) |
4044,9 → 4562,9 |
|
/* Do DPMS ourselves */ |
if (property == connector->dev->mode_config.dpms_property) { |
ret = 0; |
if (connector->funcs->dpms) |
(*connector->funcs->dpms)(connector, (int)value); |
ret = 0; |
ret = (*connector->funcs->dpms)(connector, (int)value); |
} else if (connector->funcs->set_property) |
ret = connector->funcs->set_property(connector, property, value); |
|
4122,11 → 4640,6 |
struct drm_mode_obj_get_properties *arg = data; |
struct drm_mode_object *obj; |
int ret = 0; |
int i; |
int copied = 0; |
int props_count = 0; |
uint32_t __user *props_ptr; |
uint64_t __user *prop_values_ptr; |
|
if (!drm_core_check_feature(dev, DRIVER_MODESET)) |
return -EINVAL; |
4143,30 → 4656,11 |
goto out; |
} |
|
props_count = obj->properties->count; |
ret = get_properties(obj, file_priv->atomic, |
(uint32_t __user *)(unsigned long)(arg->props_ptr), |
(uint64_t __user *)(unsigned long)(arg->prop_values_ptr), |
&arg->count_props); |
|
/* This ioctl is called twice, once to determine how much space is |
* needed, and the 2nd time to fill it. */ |
if ((arg->count_props >= props_count) && props_count) { |
copied = 0; |
props_ptr = (uint32_t __user *)(unsigned long)(arg->props_ptr); |
prop_values_ptr = (uint64_t __user *)(unsigned long) |
(arg->prop_values_ptr); |
for (i = 0; i < props_count; i++) { |
if (put_user(obj->properties->ids[i], |
props_ptr + copied)) { |
ret = -EFAULT; |
goto out; |
} |
if (put_user(obj->properties->values[i], |
prop_values_ptr + copied)) { |
ret = -EFAULT; |
goto out; |
} |
copied++; |
} |
} |
arg->count_props = props_count; |
out: |
drm_modeset_unlock_all(dev); |
return ret; |
4195,8 → 4689,8 |
struct drm_mode_object *arg_obj; |
struct drm_mode_object *prop_obj; |
struct drm_property *property; |
int ret = -EINVAL; |
int i; |
int i, ret = -EINVAL; |
struct drm_mode_object *ref; |
|
if (!drm_core_check_feature(dev, DRIVER_MODESET)) |
return -EINVAL; |
4212,7 → 4706,7 |
goto out; |
|
for (i = 0; i < arg_obj->properties->count; i++) |
if (arg_obj->properties->ids[i] == arg->prop_id) |
if (arg_obj->properties->properties[i]->base.id == arg->prop_id) |
break; |
|
if (i == arg_obj->properties->count) |
4226,7 → 4720,7 |
} |
property = obj_to_property(prop_obj); |
|
if (!drm_property_change_is_valid(property, arg->value)) |
if (!drm_property_change_valid_get(property, arg->value, &ref)) |
goto out; |
|
switch (arg_obj->type) { |
4243,6 → 4737,8 |
break; |
} |
|
drm_property_change_valid_put(property, ref); |
|
out: |
drm_modeset_unlock_all(dev); |
return ret; |
4293,7 → 4789,8 |
{ |
crtc->gamma_size = gamma_size; |
|
crtc->gamma_store = kzalloc(gamma_size * sizeof(uint16_t) * 3, GFP_KERNEL); |
crtc->gamma_store = kcalloc(gamma_size, sizeof(uint16_t) * 3, |
GFP_KERNEL); |
if (!crtc->gamma_store) { |
crtc->gamma_size = 0; |
return -ENOMEM; |
4456,25 → 4953,24 |
struct drm_encoder *encoder; |
struct drm_connector *connector; |
|
list_for_each_entry(plane, &dev->mode_config.plane_list, head) |
drm_for_each_plane(plane, dev) |
if (plane->funcs->reset) |
plane->funcs->reset(plane); |
|
list_for_each_entry(crtc, &dev->mode_config.crtc_list, head) |
drm_for_each_crtc(crtc, dev) |
if (crtc->funcs->reset) |
crtc->funcs->reset(crtc); |
|
list_for_each_entry(encoder, &dev->mode_config.encoder_list, head) |
drm_for_each_encoder(encoder, dev) |
if (encoder->funcs->reset) |
encoder->funcs->reset(encoder); |
|
list_for_each_entry(connector, &dev->mode_config.connector_list, head) { |
connector->status = connector_status_unknown; |
|
mutex_lock(&dev->mode_config.mutex); |
drm_for_each_connector(connector, dev) |
if (connector->funcs->reset) |
connector->funcs->reset(connector); |
mutex_unlock(&dev->mode_config.mutex); |
} |
} |
EXPORT_SYMBOL(drm_mode_config_reset); |
/* |
* Just need to support RGB formats here for compat with code that doesn't |
4710,7 → 5206,8 |
{ |
if (rotation & ~supported_rotations) { |
rotation ^= BIT(DRM_REFLECT_X) | BIT(DRM_REFLECT_Y); |
rotation = (rotation & ~0xf) | BIT((ffs(rotation & 0xf) + 1) % 4); |
rotation = (rotation & DRM_REFLECT_MASK) | |
BIT((ffs(rotation & DRM_ROTATE_MASK) + 1) % 4); |
} |
|
return rotation; |
4735,10 → 5232,10 |
drm_modeset_lock_init(&dev->mode_config.connection_mutex); |
mutex_init(&dev->mode_config.idr_mutex); |
mutex_init(&dev->mode_config.fb_lock); |
mutex_init(&dev->mode_config.blob_lock); |
INIT_LIST_HEAD(&dev->mode_config.fb_list); |
INIT_LIST_HEAD(&dev->mode_config.crtc_list); |
INIT_LIST_HEAD(&dev->mode_config.connector_list); |
INIT_LIST_HEAD(&dev->mode_config.bridge_list); |
INIT_LIST_HEAD(&dev->mode_config.encoder_list); |
INIT_LIST_HEAD(&dev->mode_config.property_list); |
INIT_LIST_HEAD(&dev->mode_config.property_blob_list); |
4747,8 → 5244,7 |
idr_init(&dev->mode_config.tile_idr); |
|
drm_modeset_lock_all(dev); |
drm_mode_create_standard_connector_properties(dev); |
drm_mode_create_standard_plane_properties(dev); |
drm_mode_create_standard_properties(dev); |
drm_modeset_unlock_all(dev); |
|
/* Just to be sure */ |
4779,7 → 5275,6 |
struct drm_connector *connector, *ot; |
struct drm_crtc *crtc, *ct; |
struct drm_encoder *encoder, *enct; |
struct drm_bridge *bridge, *brt; |
struct drm_framebuffer *fb, *fbt; |
struct drm_property *property, *pt; |
struct drm_property_blob *blob, *bt; |
4790,11 → 5285,6 |
encoder->funcs->destroy(encoder); |
} |
|
list_for_each_entry_safe(bridge, brt, |
&dev->mode_config.bridge_list, head) { |
bridge->funcs->destroy(bridge); |
} |
|
list_for_each_entry_safe(connector, ot, |
&dev->mode_config.connector_list, head) { |
connector->funcs->destroy(connector); |
4806,8 → 5296,8 |
} |
|
list_for_each_entry_safe(blob, bt, &dev->mode_config.property_blob_list, |
head) { |
drm_property_destroy_blob(dev, blob); |
head_global) { |
drm_property_unreference_blob(blob); |
} |
|
/* |
4820,7 → 5310,7 |
*/ |
WARN_ON(!list_empty(&dev->mode_config.fb_list)); |
list_for_each_entry_safe(fb, fbt, &dev->mode_config.fb_list, head) { |
drm_framebuffer_remove(fb); |
drm_framebuffer_free(&fb->refcount); |
} |
|
list_for_each_entry_safe(plane, plt, &dev->mode_config.plane_list, |
4905,8 → 5395,8 |
mutex_lock(&dev->mode_config.idr_mutex); |
idr_for_each_entry(&dev->mode_config.tile_idr, tg, id) { |
if (!memcmp(tg->group_data, topology, 8)) { |
// if (!kref_get_unless_zero(&tg->refcount)) |
// tg = NULL; |
if (!kref_get_unless_zero(&tg->refcount)) |
tg = NULL; |
mutex_unlock(&dev->mode_config.idr_mutex); |
return tg; |
} |
4914,6 → 5404,7 |
mutex_unlock(&dev->mode_config.idr_mutex); |
return NULL; |
} |
EXPORT_SYMBOL(drm_mode_get_tile_group); |
|
/** |
* drm_mode_create_tile_group - create a tile group from a displayid description |
4952,3 → 5443,4 |
mutex_unlock(&dev->mode_config.idr_mutex); |
return tg; |
} |
EXPORT_SYMBOL(drm_mode_create_tile_group); |