2016-08-12 14:48:50 -06:00
|
|
|
/*
|
|
|
|
* Copyright (c) 2016 Intel Corporation
|
|
|
|
*
|
|
|
|
* Permission to use, copy, modify, distribute, and sell this software and its
|
|
|
|
* documentation for any purpose is hereby granted without fee, provided that
|
|
|
|
* the above copyright notice appear in all copies and that both that copyright
|
|
|
|
* notice and this permission notice appear in supporting documentation, and
|
|
|
|
* that the name of the copyright holders not be used in advertising or
|
|
|
|
* publicity pertaining to distribution of the software without specific,
|
|
|
|
* written prior permission. The copyright holders make no representations
|
|
|
|
* about the suitability of this software for any purpose. It is provided "as
|
|
|
|
* is" without express or implied warranty.
|
|
|
|
*
|
|
|
|
* THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
|
|
|
|
* INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
|
|
|
|
* EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY SPECIAL, INDIRECT OR
|
|
|
|
* CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
|
|
|
|
* DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
|
|
|
|
* TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE
|
|
|
|
* OF THIS SOFTWARE.
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include <drm/drmP.h>
|
|
|
|
#include <drm/drm_connector.h>
|
|
|
|
#include <drm/drm_edid.h>
|
2016-11-28 11:51:09 -07:00
|
|
|
#include <drm/drm_encoder.h>
|
2016-08-12 14:48:50 -06:00
|
|
|
|
|
|
|
#include "drm_crtc_internal.h"
|
|
|
|
#include "drm_internal.h"
|
|
|
|
|
2016-08-12 14:48:53 -06:00
|
|
|
/**
|
|
|
|
* DOC: overview
|
|
|
|
*
|
|
|
|
* In DRM connectors are the general abstraction for display sinks, and include
|
|
|
|
* als fixed panels or anything else that can display pixels in some form. As
|
|
|
|
* opposed to all other KMS objects representing hardware (like CRTC, encoder or
|
|
|
|
* plane abstractions) connectors can be hotplugged and unplugged at runtime.
|
2017-02-28 07:46:39 -07:00
|
|
|
* Hence they are reference-counted using drm_connector_get() and
|
|
|
|
* drm_connector_put().
|
2016-08-12 14:48:53 -06:00
|
|
|
*
|
2017-01-24 23:26:45 -07:00
|
|
|
* KMS driver must create, initialize, register and attach at a &struct
|
|
|
|
* drm_connector for each such sink. The instance is created as other KMS
|
2017-01-24 23:26:48 -07:00
|
|
|
* objects and initialized by setting the following fields. The connector is
|
|
|
|
* initialized with a call to drm_connector_init() with a pointer to the
|
|
|
|
* &struct drm_connector_funcs and a connector type, and then exposed to
|
|
|
|
* userspace with a call to drm_connector_register().
|
2016-08-12 14:48:53 -06:00
|
|
|
*
|
|
|
|
* Connectors must be attached to an encoder to be used. For devices that map
|
|
|
|
* connectors to encoders 1:1, the connector should be attached at
|
|
|
|
* initialization time with a call to drm_mode_connector_attach_encoder(). The
|
2017-01-24 23:26:45 -07:00
|
|
|
* driver must also set the &drm_connector.encoder field to point to the
|
2016-08-12 14:48:53 -06:00
|
|
|
* attached encoder.
|
|
|
|
*
|
|
|
|
* For connectors which are not fixed (like built-in panels) the driver needs to
|
|
|
|
* support hotplug notifications. The simplest way to do that is by using the
|
|
|
|
* probe helpers, see drm_kms_helper_poll_init() for connectors which don't have
|
|
|
|
* hardware support for hotplug interrupts. Connectors with hardware hotplug
|
|
|
|
* support can instead use e.g. drm_helper_hpd_irq_event().
|
|
|
|
*/
|
|
|
|
|
2016-08-12 14:48:50 -06:00
|
|
|
struct drm_conn_prop_enum_list {
|
|
|
|
int type;
|
|
|
|
const char *name;
|
|
|
|
struct ida ida;
|
|
|
|
};
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Connector and encoder types.
|
|
|
|
*/
|
|
|
|
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" },
|
|
|
|
{ DRM_MODE_CONNECTOR_DVIA, "DVI-A" },
|
|
|
|
{ DRM_MODE_CONNECTOR_Composite, "Composite" },
|
|
|
|
{ DRM_MODE_CONNECTOR_SVIDEO, "SVIDEO" },
|
|
|
|
{ DRM_MODE_CONNECTOR_LVDS, "LVDS" },
|
|
|
|
{ DRM_MODE_CONNECTOR_Component, "Component" },
|
|
|
|
{ DRM_MODE_CONNECTOR_9PinDIN, "DIN" },
|
|
|
|
{ DRM_MODE_CONNECTOR_DisplayPort, "DP" },
|
|
|
|
{ DRM_MODE_CONNECTOR_HDMIA, "HDMI-A" },
|
|
|
|
{ DRM_MODE_CONNECTOR_HDMIB, "HDMI-B" },
|
|
|
|
{ DRM_MODE_CONNECTOR_TV, "TV" },
|
|
|
|
{ DRM_MODE_CONNECTOR_eDP, "eDP" },
|
|
|
|
{ DRM_MODE_CONNECTOR_VIRTUAL, "Virtual" },
|
|
|
|
{ DRM_MODE_CONNECTOR_DSI, "DSI" },
|
|
|
|
{ DRM_MODE_CONNECTOR_DPI, "DPI" },
|
|
|
|
};
|
|
|
|
|
|
|
|
void drm_connector_ida_init(void)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
|
|
|
for (i = 0; i < ARRAY_SIZE(drm_connector_enum_list); i++)
|
|
|
|
ida_init(&drm_connector_enum_list[i].ida);
|
|
|
|
}
|
|
|
|
|
|
|
|
void drm_connector_ida_destroy(void)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
|
|
|
for (i = 0; i < ARRAY_SIZE(drm_connector_enum_list); i++)
|
|
|
|
ida_destroy(&drm_connector_enum_list[i].ida);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* drm_connector_get_cmdline_mode - reads the user's cmdline mode
|
|
|
|
* @connector: connector to quwery
|
|
|
|
*
|
2016-08-12 14:48:53 -06:00
|
|
|
* The kernel supports per-connector configuration of its consoles through
|
2016-08-12 14:48:50 -06:00
|
|
|
* 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;
|
|
|
|
|
|
|
|
if (fb_get_options(connector->name, &option))
|
|
|
|
return;
|
|
|
|
|
|
|
|
if (!drm_mode_parse_command_line_for_connector(option,
|
|
|
|
connector,
|
|
|
|
mode))
|
|
|
|
return;
|
|
|
|
|
|
|
|
if (mode->force) {
|
2017-02-20 01:51:48 -07:00
|
|
|
DRM_INFO("forcing %s connector %s\n", connector->name,
|
|
|
|
drm_get_connector_force_name(mode->force));
|
2016-08-12 14:48:50 -06:00
|
|
|
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" : "");
|
|
|
|
}
|
|
|
|
|
|
|
|
static void drm_connector_free(struct kref *kref)
|
|
|
|
{
|
|
|
|
struct drm_connector *connector =
|
|
|
|
container_of(kref, struct drm_connector, base.refcount);
|
|
|
|
struct drm_device *dev = connector->dev;
|
|
|
|
|
|
|
|
drm_mode_object_unregister(dev, &connector->base);
|
|
|
|
connector->funcs->destroy(connector);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* drm_connector_init - Init a preallocated connector
|
|
|
|
* @dev: DRM device
|
|
|
|
* @connector: the connector to init
|
|
|
|
* @funcs: callbacks for this connector
|
|
|
|
* @connector_type: user visible type of the connector
|
|
|
|
*
|
|
|
|
* Initialises a preallocated connector. Connectors should be
|
|
|
|
* subclassed as part of driver connector objects.
|
|
|
|
*
|
|
|
|
* Returns:
|
|
|
|
* Zero on success, error code on failure.
|
|
|
|
*/
|
|
|
|
int drm_connector_init(struct drm_device *dev,
|
|
|
|
struct drm_connector *connector,
|
|
|
|
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;
|
|
|
|
|
2017-02-28 07:46:37 -07:00
|
|
|
ret = __drm_mode_object_add(dev, &connector->base,
|
|
|
|
DRM_MODE_OBJECT_CONNECTOR,
|
|
|
|
false, drm_connector_free);
|
2016-08-12 14:48:50 -06:00
|
|
|
if (ret)
|
drm: locking&new iterators for connector_list
The requirements for connector_list locking are a bit tricky:
- We need to be able to jump over zombie conectors (i.e. with refcount
== 0, but not yet removed from the list). If instead we require that
there's no zombies on the list then the final kref_put must happen
under the list protection lock, which means that locking context
leaks all over the place. Not pretty - better to deal with zombies
and wrap the locking just around the list_del in the destructor.
- When we walk the list we must _not_ hold the connector list lock. We
walk the connector list at an absolutely massive amounts of places,
if all those places can't ever call drm_connector_unreference the
code would get unecessarily complicated.
- connector_list needs it own lock, again too many places that walk it
that we could reuse e.g. mode_config.mutex without resulting in
inversions.
- Lots of code uses these loops to look-up a connector, i.e. they want
to be able to call drm_connector_reference. But on the other hand we
want connectors to stay on that list until they're dead (i.e.
connector_list can't hold a full reference), which means despite the
"can't hold lock for the loop body" rule we need to make sure a
connector doesn't suddenly become a zombie.
At first Dave&I discussed various horror-show approaches using srcu,
but turns out it's fairly easy:
- For the loop body we always hold an additional reference to the
current connector. That means it can't zombify, and it also means
it'll stay on the list, which means we can use it as our iterator to
find the next connector.
- When we try to find the next connector we only have to jump over
zombies. To make sure we don't chase bad pointers that entire loop
is protected with the new connect_list_lock spinlock. And because we
know that we're starting out with a non-zombie (need to drop our
reference for the old connector only after we have our new one),
we're guranteed to still be on the connector_list and either find
the next non-zombie or complete the iteration.
- Only downside is that we need to make sure that the temporary
reference for the loop body doesn't leak. iter_get/put() functions +
lockdep make sure that's the case.
- To avoid a flag day the new iterator macro has an _iter postfix. We
can rename it back once all the users of the unsafe version are gone
(there's about 100 list walkers for the connector_list).
For now this patch only converts all the list walking in the core,
leaving helpers and drivers for later patches. The nice thing is that
we can now finally remove 2 FIXME comments from the
register/unregister functions.
v2:
- use irqsafe spinlocks, so that we can use this in drm_state_dump
too.
- nuke drm_modeset_lock_all from drm_connector_init, now entirely
cargo-culted nonsense.
v3:
- do {} while (!kref_get_unless_zero), makes for a tidier loop (Dave).
- pretty kerneldoc
- add EXPORT_SYMBOL, helpers&drivers are supposed to use this.
v4: Change lockdep annotations to only check whether we release the
iter fake lock again (i.e. make sure that iter_put is called), but
not check any locking dependecies itself. That seams to require a
recursive read lock in trylock mode.
Cc: Dave Airlie <airlied@gmail.com>
Cc: Chris Wilson <chris@chris-wilson.co.uk>
Reviewed-by: Chris Wilson <chris@chris-wilson.co.uk>
Reviewed-by: Sean Paul <seanpaul@chromium.org>
Signed-off-by: Daniel Vetter <daniel.vetter@intel.com>
Link: http://patchwork.freedesktop.org/patch/msgid/20161213230814.19598-6-daniel.vetter@ffwll.ch
2016-12-13 16:08:06 -07:00
|
|
|
return ret;
|
2016-08-12 14:48:50 -06:00
|
|
|
|
|
|
|
connector->base.properties = &connector->properties;
|
|
|
|
connector->dev = dev;
|
|
|
|
connector->funcs = funcs;
|
|
|
|
|
|
|
|
ret = ida_simple_get(&config->connector_ida, 0, 0, GFP_KERNEL);
|
|
|
|
if (ret < 0)
|
|
|
|
goto out_put;
|
|
|
|
connector->index = ret;
|
|
|
|
ret = 0;
|
|
|
|
|
|
|
|
connector->connector_type = connector_type;
|
|
|
|
connector->connector_type_id =
|
|
|
|
ida_simple_get(connector_ida, 1, 0, GFP_KERNEL);
|
|
|
|
if (connector->connector_type_id < 0) {
|
|
|
|
ret = connector->connector_type_id;
|
|
|
|
goto out_put_id;
|
|
|
|
}
|
|
|
|
connector->name =
|
|
|
|
kasprintf(GFP_KERNEL, "%s-%d",
|
|
|
|
drm_connector_enum_list[connector_type].name,
|
|
|
|
connector->connector_type_id);
|
|
|
|
if (!connector->name) {
|
|
|
|
ret = -ENOMEM;
|
|
|
|
goto out_put_type_id;
|
|
|
|
}
|
|
|
|
|
|
|
|
INIT_LIST_HEAD(&connector->probed_modes);
|
|
|
|
INIT_LIST_HEAD(&connector->modes);
|
2016-12-18 06:35:45 -07:00
|
|
|
mutex_init(&connector->mutex);
|
2016-08-12 14:48:50 -06:00
|
|
|
connector->edid_blob_ptr = NULL;
|
|
|
|
connector->status = connector_status_unknown;
|
|
|
|
|
|
|
|
drm_connector_get_cmdline_mode(connector);
|
|
|
|
|
|
|
|
/* We should add connectors at the end to avoid upsetting the connector
|
|
|
|
* index too much. */
|
drm: locking&new iterators for connector_list
The requirements for connector_list locking are a bit tricky:
- We need to be able to jump over zombie conectors (i.e. with refcount
== 0, but not yet removed from the list). If instead we require that
there's no zombies on the list then the final kref_put must happen
under the list protection lock, which means that locking context
leaks all over the place. Not pretty - better to deal with zombies
and wrap the locking just around the list_del in the destructor.
- When we walk the list we must _not_ hold the connector list lock. We
walk the connector list at an absolutely massive amounts of places,
if all those places can't ever call drm_connector_unreference the
code would get unecessarily complicated.
- connector_list needs it own lock, again too many places that walk it
that we could reuse e.g. mode_config.mutex without resulting in
inversions.
- Lots of code uses these loops to look-up a connector, i.e. they want
to be able to call drm_connector_reference. But on the other hand we
want connectors to stay on that list until they're dead (i.e.
connector_list can't hold a full reference), which means despite the
"can't hold lock for the loop body" rule we need to make sure a
connector doesn't suddenly become a zombie.
At first Dave&I discussed various horror-show approaches using srcu,
but turns out it's fairly easy:
- For the loop body we always hold an additional reference to the
current connector. That means it can't zombify, and it also means
it'll stay on the list, which means we can use it as our iterator to
find the next connector.
- When we try to find the next connector we only have to jump over
zombies. To make sure we don't chase bad pointers that entire loop
is protected with the new connect_list_lock spinlock. And because we
know that we're starting out with a non-zombie (need to drop our
reference for the old connector only after we have our new one),
we're guranteed to still be on the connector_list and either find
the next non-zombie or complete the iteration.
- Only downside is that we need to make sure that the temporary
reference for the loop body doesn't leak. iter_get/put() functions +
lockdep make sure that's the case.
- To avoid a flag day the new iterator macro has an _iter postfix. We
can rename it back once all the users of the unsafe version are gone
(there's about 100 list walkers for the connector_list).
For now this patch only converts all the list walking in the core,
leaving helpers and drivers for later patches. The nice thing is that
we can now finally remove 2 FIXME comments from the
register/unregister functions.
v2:
- use irqsafe spinlocks, so that we can use this in drm_state_dump
too.
- nuke drm_modeset_lock_all from drm_connector_init, now entirely
cargo-culted nonsense.
v3:
- do {} while (!kref_get_unless_zero), makes for a tidier loop (Dave).
- pretty kerneldoc
- add EXPORT_SYMBOL, helpers&drivers are supposed to use this.
v4: Change lockdep annotations to only check whether we release the
iter fake lock again (i.e. make sure that iter_put is called), but
not check any locking dependecies itself. That seams to require a
recursive read lock in trylock mode.
Cc: Dave Airlie <airlied@gmail.com>
Cc: Chris Wilson <chris@chris-wilson.co.uk>
Reviewed-by: Chris Wilson <chris@chris-wilson.co.uk>
Reviewed-by: Sean Paul <seanpaul@chromium.org>
Signed-off-by: Daniel Vetter <daniel.vetter@intel.com>
Link: http://patchwork.freedesktop.org/patch/msgid/20161213230814.19598-6-daniel.vetter@ffwll.ch
2016-12-13 16:08:06 -07:00
|
|
|
spin_lock_irq(&config->connector_list_lock);
|
2016-08-12 14:48:50 -06:00
|
|
|
list_add_tail(&connector->head, &config->connector_list);
|
|
|
|
config->num_connector++;
|
drm: locking&new iterators for connector_list
The requirements for connector_list locking are a bit tricky:
- We need to be able to jump over zombie conectors (i.e. with refcount
== 0, but not yet removed from the list). If instead we require that
there's no zombies on the list then the final kref_put must happen
under the list protection lock, which means that locking context
leaks all over the place. Not pretty - better to deal with zombies
and wrap the locking just around the list_del in the destructor.
- When we walk the list we must _not_ hold the connector list lock. We
walk the connector list at an absolutely massive amounts of places,
if all those places can't ever call drm_connector_unreference the
code would get unecessarily complicated.
- connector_list needs it own lock, again too many places that walk it
that we could reuse e.g. mode_config.mutex without resulting in
inversions.
- Lots of code uses these loops to look-up a connector, i.e. they want
to be able to call drm_connector_reference. But on the other hand we
want connectors to stay on that list until they're dead (i.e.
connector_list can't hold a full reference), which means despite the
"can't hold lock for the loop body" rule we need to make sure a
connector doesn't suddenly become a zombie.
At first Dave&I discussed various horror-show approaches using srcu,
but turns out it's fairly easy:
- For the loop body we always hold an additional reference to the
current connector. That means it can't zombify, and it also means
it'll stay on the list, which means we can use it as our iterator to
find the next connector.
- When we try to find the next connector we only have to jump over
zombies. To make sure we don't chase bad pointers that entire loop
is protected with the new connect_list_lock spinlock. And because we
know that we're starting out with a non-zombie (need to drop our
reference for the old connector only after we have our new one),
we're guranteed to still be on the connector_list and either find
the next non-zombie or complete the iteration.
- Only downside is that we need to make sure that the temporary
reference for the loop body doesn't leak. iter_get/put() functions +
lockdep make sure that's the case.
- To avoid a flag day the new iterator macro has an _iter postfix. We
can rename it back once all the users of the unsafe version are gone
(there's about 100 list walkers for the connector_list).
For now this patch only converts all the list walking in the core,
leaving helpers and drivers for later patches. The nice thing is that
we can now finally remove 2 FIXME comments from the
register/unregister functions.
v2:
- use irqsafe spinlocks, so that we can use this in drm_state_dump
too.
- nuke drm_modeset_lock_all from drm_connector_init, now entirely
cargo-culted nonsense.
v3:
- do {} while (!kref_get_unless_zero), makes for a tidier loop (Dave).
- pretty kerneldoc
- add EXPORT_SYMBOL, helpers&drivers are supposed to use this.
v4: Change lockdep annotations to only check whether we release the
iter fake lock again (i.e. make sure that iter_put is called), but
not check any locking dependecies itself. That seams to require a
recursive read lock in trylock mode.
Cc: Dave Airlie <airlied@gmail.com>
Cc: Chris Wilson <chris@chris-wilson.co.uk>
Reviewed-by: Chris Wilson <chris@chris-wilson.co.uk>
Reviewed-by: Sean Paul <seanpaul@chromium.org>
Signed-off-by: Daniel Vetter <daniel.vetter@intel.com>
Link: http://patchwork.freedesktop.org/patch/msgid/20161213230814.19598-6-daniel.vetter@ffwll.ch
2016-12-13 16:08:06 -07:00
|
|
|
spin_unlock_irq(&config->connector_list_lock);
|
2016-08-12 14:48:50 -06:00
|
|
|
|
|
|
|
if (connector_type != DRM_MODE_CONNECTOR_VIRTUAL)
|
|
|
|
drm_object_attach_property(&connector->base,
|
|
|
|
config->edid_property,
|
|
|
|
0);
|
|
|
|
|
|
|
|
drm_object_attach_property(&connector->base,
|
|
|
|
config->dpms_property, 0);
|
|
|
|
|
drm: Add a new connector atomic property for link status
At the time userspace does setcrtc, we've already promised the mode
would work. The promise is based on the theoretical capabilities of
the link, but it's possible we can't reach this in practice. The DP
spec describes how the link should be reduced, but we can't reduce
the link below the requirements of the mode. Black screen follows.
One idea would be to have setcrtc return a failure. However, it
already should not fail as the atomic checks have passed. It would
also conflict with the idea of making setcrtc asynchronous in the
future, returning before the actual mode setting and link training.
Another idea is to train the link "upfront" at hotplug time, before
pruning the mode list, so that we can do the pruning based on
practical not theoretical capabilities. However, the changes for link
training are pretty drastic, all for the sake of error handling and
DP compliance, when the most common happy day scenario is the current
approach of link training at mode setting time, using the optimal
parameters for the mode. It is also not certain all hardware could do
this without the pipe on; not even all our hardware can do this. Some
of this can be solved, but not trivially.
Both of the above ideas also fail to address link degradation *during*
operation.
The solution is to add a new "link-status" connector property in order
to address link training failure in a way that:
a) changes the current happy day scenario as little as possible, to
avoid regressions, b) can be implemented the same way by all drm
drivers, c) is still opt-in for the drivers and userspace, and opting
out doesn't regress the user experience, d) doesn't prevent drivers
from implementing better or alternate approaches, possibly without
userspace involvement. And, of course, handles all the issues presented.
In the usual happy day scenario, this is always "good". If something
fails during or after a mode set, the kernel driver can set the link
status to "bad" and issue a hotplug uevent for userspace to have it
re-check the valid modes through GET_CONNECTOR IOCTL, and try modeset
again. If the theoretical capabilities of the link can't be reached,
the mode list is trimmed based on that.
v7 by Jani:
* Rebase, simplify set property while at it, checkpatch fix
v6:
* Fix a typo in kernel doc (Sean Paul)
v5:
* Clarify doc for silent rejection of atomic properties by driver (Daniel Vetter)
v4:
* Add comments in kernel-doc format (Daniel Vetter)
* Update the kernel-doc for link-status (Sean Paul)
v3:
* Fixed a build error (Jani Saarinen)
v2:
* Removed connector->link_status (Daniel Vetter)
* Set connector->state->link_status in drm_mode_connector_set_link_status_property
(Daniel Vetter)
* Set the connector_changed flag to true if connector->state->link_status changed.
* Reset link_status to GOOD in update_output_state (Daniel Vetter)
* Never allow userspace to set link status from Good To Bad (Daniel Vetter)
Reviewed-by: Sean Paul <seanpaul@chromium.org>
Reviewed-by: Daniel Vetter <daniel.vetter@ffwll.ch>
Reviewed-by: Jani Nikula <jani.nikula@intel.com>
Acked-by: Tony Cheng <tony.cheng@amd.com>
Acked-by: Harry Wentland <harry.wentland@amd.com>
Cc: Jani Nikula <jani.nikula@linux.intel.com>
Cc: Daniel Vetter <daniel.vetter@intel.com>
Cc: Ville Syrjala <ville.syrjala@linux.intel.com>
Cc: Chris Wilson <chris@chris-wilson.co.uk>
Cc: Sean Paul <seanpaul@chromium.org>
Signed-off-by: Manasi Navare <manasi.d.navare@intel.com>
Signed-off-by: Jani Nikula <jani.nikula@intel.com>
Acked-by: Eric Anholt <eric@anholt.net> (for the -modesetting patch)
Signed-off-by: Daniel Vetter <daniel.vetter@ffwll.ch>
Link: http://patchwork.freedesktop.org/patch/msgid/0182487051aa9f1594820e35a4853de2f8747b4e.1481883920.git.jani.nikula@intel.com
2016-12-16 03:29:06 -07:00
|
|
|
drm_object_attach_property(&connector->base,
|
|
|
|
config->link_status_property,
|
|
|
|
0);
|
|
|
|
|
2016-08-12 14:48:50 -06:00
|
|
|
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_type_id:
|
|
|
|
if (ret)
|
2016-10-02 00:01:22 -06:00
|
|
|
ida_simple_remove(connector_ida, connector->connector_type_id);
|
2016-08-12 14:48:50 -06:00
|
|
|
out_put_id:
|
|
|
|
if (ret)
|
2016-10-02 00:01:22 -06:00
|
|
|
ida_simple_remove(&config->connector_ida, connector->index);
|
2016-08-12 14:48:50 -06:00
|
|
|
out_put:
|
|
|
|
if (ret)
|
|
|
|
drm_mode_object_unregister(dev, &connector->base);
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(drm_connector_init);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* drm_mode_connector_attach_encoder - attach a connector to an encoder
|
|
|
|
* @connector: connector to attach
|
|
|
|
* @encoder: encoder to attach @connector to
|
|
|
|
*
|
|
|
|
* This function links up a connector to an encoder. Note that the routing
|
|
|
|
* restrictions between encoders and crtcs are exposed to userspace through the
|
|
|
|
* possible_clones and possible_crtcs bitmasks.
|
|
|
|
*
|
|
|
|
* Returns:
|
|
|
|
* Zero on success, negative errno on failure.
|
|
|
|
*/
|
|
|
|
int drm_mode_connector_attach_encoder(struct drm_connector *connector,
|
|
|
|
struct drm_encoder *encoder)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* In the past, drivers have attempted to model the static association
|
|
|
|
* of connector to encoder in simple connector/encoder devices using a
|
|
|
|
* direct assignment of connector->encoder = encoder. This connection
|
|
|
|
* is a logical one and the responsibility of the core, so drivers are
|
|
|
|
* expected not to mess with this.
|
|
|
|
*
|
|
|
|
* Note that the error return should've been enough here, but a large
|
|
|
|
* majority of drivers ignores the return value, so add in a big WARN
|
|
|
|
* to get people's attention.
|
|
|
|
*/
|
|
|
|
if (WARN_ON(connector->encoder))
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
for (i = 0; i < DRM_CONNECTOR_MAX_ENCODER; i++) {
|
|
|
|
if (connector->encoder_ids[i] == 0) {
|
|
|
|
connector->encoder_ids[i] = encoder->base.id;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return -ENOMEM;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(drm_mode_connector_attach_encoder);
|
|
|
|
|
|
|
|
static void drm_mode_remove(struct drm_connector *connector,
|
|
|
|
struct drm_display_mode *mode)
|
|
|
|
{
|
|
|
|
list_del(&mode->head);
|
|
|
|
drm_mode_destroy(connector->dev, mode);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* drm_connector_cleanup - cleans up an initialised connector
|
|
|
|
* @connector: connector to cleanup
|
|
|
|
*
|
|
|
|
* Cleans up the connector but doesn't free the object.
|
|
|
|
*/
|
|
|
|
void drm_connector_cleanup(struct drm_connector *connector)
|
|
|
|
{
|
|
|
|
struct drm_device *dev = connector->dev;
|
|
|
|
struct drm_display_mode *mode, *t;
|
|
|
|
|
|
|
|
/* The connector should have been removed from userspace long before
|
|
|
|
* it is finally destroyed.
|
|
|
|
*/
|
|
|
|
if (WARN_ON(connector->registered))
|
|
|
|
drm_connector_unregister(connector);
|
|
|
|
|
|
|
|
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);
|
|
|
|
|
|
|
|
list_for_each_entry_safe(mode, t, &connector->modes, head)
|
|
|
|
drm_mode_remove(connector, mode);
|
|
|
|
|
2016-10-07 01:27:41 -06:00
|
|
|
ida_simple_remove(&drm_connector_enum_list[connector->connector_type].ida,
|
|
|
|
connector->connector_type_id);
|
2016-08-12 14:48:50 -06:00
|
|
|
|
2016-10-07 01:27:41 -06:00
|
|
|
ida_simple_remove(&dev->mode_config.connector_ida,
|
|
|
|
connector->index);
|
2016-08-12 14:48:50 -06:00
|
|
|
|
|
|
|
kfree(connector->display_info.bus_formats);
|
|
|
|
drm_mode_object_unregister(dev, &connector->base);
|
|
|
|
kfree(connector->name);
|
|
|
|
connector->name = NULL;
|
drm: locking&new iterators for connector_list
The requirements for connector_list locking are a bit tricky:
- We need to be able to jump over zombie conectors (i.e. with refcount
== 0, but not yet removed from the list). If instead we require that
there's no zombies on the list then the final kref_put must happen
under the list protection lock, which means that locking context
leaks all over the place. Not pretty - better to deal with zombies
and wrap the locking just around the list_del in the destructor.
- When we walk the list we must _not_ hold the connector list lock. We
walk the connector list at an absolutely massive amounts of places,
if all those places can't ever call drm_connector_unreference the
code would get unecessarily complicated.
- connector_list needs it own lock, again too many places that walk it
that we could reuse e.g. mode_config.mutex without resulting in
inversions.
- Lots of code uses these loops to look-up a connector, i.e. they want
to be able to call drm_connector_reference. But on the other hand we
want connectors to stay on that list until they're dead (i.e.
connector_list can't hold a full reference), which means despite the
"can't hold lock for the loop body" rule we need to make sure a
connector doesn't suddenly become a zombie.
At first Dave&I discussed various horror-show approaches using srcu,
but turns out it's fairly easy:
- For the loop body we always hold an additional reference to the
current connector. That means it can't zombify, and it also means
it'll stay on the list, which means we can use it as our iterator to
find the next connector.
- When we try to find the next connector we only have to jump over
zombies. To make sure we don't chase bad pointers that entire loop
is protected with the new connect_list_lock spinlock. And because we
know that we're starting out with a non-zombie (need to drop our
reference for the old connector only after we have our new one),
we're guranteed to still be on the connector_list and either find
the next non-zombie or complete the iteration.
- Only downside is that we need to make sure that the temporary
reference for the loop body doesn't leak. iter_get/put() functions +
lockdep make sure that's the case.
- To avoid a flag day the new iterator macro has an _iter postfix. We
can rename it back once all the users of the unsafe version are gone
(there's about 100 list walkers for the connector_list).
For now this patch only converts all the list walking in the core,
leaving helpers and drivers for later patches. The nice thing is that
we can now finally remove 2 FIXME comments from the
register/unregister functions.
v2:
- use irqsafe spinlocks, so that we can use this in drm_state_dump
too.
- nuke drm_modeset_lock_all from drm_connector_init, now entirely
cargo-culted nonsense.
v3:
- do {} while (!kref_get_unless_zero), makes for a tidier loop (Dave).
- pretty kerneldoc
- add EXPORT_SYMBOL, helpers&drivers are supposed to use this.
v4: Change lockdep annotations to only check whether we release the
iter fake lock again (i.e. make sure that iter_put is called), but
not check any locking dependecies itself. That seams to require a
recursive read lock in trylock mode.
Cc: Dave Airlie <airlied@gmail.com>
Cc: Chris Wilson <chris@chris-wilson.co.uk>
Reviewed-by: Chris Wilson <chris@chris-wilson.co.uk>
Reviewed-by: Sean Paul <seanpaul@chromium.org>
Signed-off-by: Daniel Vetter <daniel.vetter@intel.com>
Link: http://patchwork.freedesktop.org/patch/msgid/20161213230814.19598-6-daniel.vetter@ffwll.ch
2016-12-13 16:08:06 -07:00
|
|
|
spin_lock_irq(&dev->mode_config.connector_list_lock);
|
2016-08-12 14:48:50 -06:00
|
|
|
list_del(&connector->head);
|
|
|
|
dev->mode_config.num_connector--;
|
drm: locking&new iterators for connector_list
The requirements for connector_list locking are a bit tricky:
- We need to be able to jump over zombie conectors (i.e. with refcount
== 0, but not yet removed from the list). If instead we require that
there's no zombies on the list then the final kref_put must happen
under the list protection lock, which means that locking context
leaks all over the place. Not pretty - better to deal with zombies
and wrap the locking just around the list_del in the destructor.
- When we walk the list we must _not_ hold the connector list lock. We
walk the connector list at an absolutely massive amounts of places,
if all those places can't ever call drm_connector_unreference the
code would get unecessarily complicated.
- connector_list needs it own lock, again too many places that walk it
that we could reuse e.g. mode_config.mutex without resulting in
inversions.
- Lots of code uses these loops to look-up a connector, i.e. they want
to be able to call drm_connector_reference. But on the other hand we
want connectors to stay on that list until they're dead (i.e.
connector_list can't hold a full reference), which means despite the
"can't hold lock for the loop body" rule we need to make sure a
connector doesn't suddenly become a zombie.
At first Dave&I discussed various horror-show approaches using srcu,
but turns out it's fairly easy:
- For the loop body we always hold an additional reference to the
current connector. That means it can't zombify, and it also means
it'll stay on the list, which means we can use it as our iterator to
find the next connector.
- When we try to find the next connector we only have to jump over
zombies. To make sure we don't chase bad pointers that entire loop
is protected with the new connect_list_lock spinlock. And because we
know that we're starting out with a non-zombie (need to drop our
reference for the old connector only after we have our new one),
we're guranteed to still be on the connector_list and either find
the next non-zombie or complete the iteration.
- Only downside is that we need to make sure that the temporary
reference for the loop body doesn't leak. iter_get/put() functions +
lockdep make sure that's the case.
- To avoid a flag day the new iterator macro has an _iter postfix. We
can rename it back once all the users of the unsafe version are gone
(there's about 100 list walkers for the connector_list).
For now this patch only converts all the list walking in the core,
leaving helpers and drivers for later patches. The nice thing is that
we can now finally remove 2 FIXME comments from the
register/unregister functions.
v2:
- use irqsafe spinlocks, so that we can use this in drm_state_dump
too.
- nuke drm_modeset_lock_all from drm_connector_init, now entirely
cargo-culted nonsense.
v3:
- do {} while (!kref_get_unless_zero), makes for a tidier loop (Dave).
- pretty kerneldoc
- add EXPORT_SYMBOL, helpers&drivers are supposed to use this.
v4: Change lockdep annotations to only check whether we release the
iter fake lock again (i.e. make sure that iter_put is called), but
not check any locking dependecies itself. That seams to require a
recursive read lock in trylock mode.
Cc: Dave Airlie <airlied@gmail.com>
Cc: Chris Wilson <chris@chris-wilson.co.uk>
Reviewed-by: Chris Wilson <chris@chris-wilson.co.uk>
Reviewed-by: Sean Paul <seanpaul@chromium.org>
Signed-off-by: Daniel Vetter <daniel.vetter@intel.com>
Link: http://patchwork.freedesktop.org/patch/msgid/20161213230814.19598-6-daniel.vetter@ffwll.ch
2016-12-13 16:08:06 -07:00
|
|
|
spin_unlock_irq(&dev->mode_config.connector_list_lock);
|
2016-08-12 14:48:50 -06:00
|
|
|
|
|
|
|
WARN_ON(connector->state && !connector->funcs->atomic_destroy_state);
|
|
|
|
if (connector->state && connector->funcs->atomic_destroy_state)
|
|
|
|
connector->funcs->atomic_destroy_state(connector,
|
|
|
|
connector->state);
|
|
|
|
|
2016-12-18 06:35:45 -07:00
|
|
|
mutex_destroy(&connector->mutex);
|
|
|
|
|
2016-08-12 14:48:50 -06:00
|
|
|
memset(connector, 0, sizeof(*connector));
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(drm_connector_cleanup);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* drm_connector_register - register a connector
|
|
|
|
* @connector: the connector to register
|
|
|
|
*
|
|
|
|
* Register userspace interfaces for a connector
|
|
|
|
*
|
|
|
|
* Returns:
|
|
|
|
* Zero on success, error code on failure.
|
|
|
|
*/
|
|
|
|
int drm_connector_register(struct drm_connector *connector)
|
|
|
|
{
|
2016-12-18 06:35:45 -07:00
|
|
|
int ret = 0;
|
2016-08-12 14:48:50 -06:00
|
|
|
|
2017-01-12 09:15:56 -07:00
|
|
|
if (!connector->dev->registered)
|
|
|
|
return 0;
|
|
|
|
|
2016-12-18 06:35:45 -07:00
|
|
|
mutex_lock(&connector->mutex);
|
2016-08-12 14:48:50 -06:00
|
|
|
if (connector->registered)
|
2016-12-18 06:35:45 -07:00
|
|
|
goto unlock;
|
2016-08-12 14:48:50 -06:00
|
|
|
|
|
|
|
ret = drm_sysfs_connector_add(connector);
|
|
|
|
if (ret)
|
2016-12-18 06:35:45 -07:00
|
|
|
goto unlock;
|
2016-08-12 14:48:50 -06:00
|
|
|
|
|
|
|
ret = drm_debugfs_connector_add(connector);
|
|
|
|
if (ret) {
|
|
|
|
goto err_sysfs;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (connector->funcs->late_register) {
|
|
|
|
ret = connector->funcs->late_register(connector);
|
|
|
|
if (ret)
|
|
|
|
goto err_debugfs;
|
|
|
|
}
|
|
|
|
|
|
|
|
drm_mode_object_register(connector->dev, &connector->base);
|
|
|
|
|
|
|
|
connector->registered = true;
|
2016-12-18 06:35:45 -07:00
|
|
|
goto unlock;
|
2016-08-12 14:48:50 -06:00
|
|
|
|
|
|
|
err_debugfs:
|
|
|
|
drm_debugfs_connector_remove(connector);
|
|
|
|
err_sysfs:
|
|
|
|
drm_sysfs_connector_remove(connector);
|
2016-12-18 06:35:45 -07:00
|
|
|
unlock:
|
|
|
|
mutex_unlock(&connector->mutex);
|
2016-08-12 14:48:50 -06:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(drm_connector_register);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* drm_connector_unregister - unregister a connector
|
|
|
|
* @connector: the connector to unregister
|
|
|
|
*
|
|
|
|
* Unregister userspace interfaces for a connector
|
|
|
|
*/
|
|
|
|
void drm_connector_unregister(struct drm_connector *connector)
|
|
|
|
{
|
2016-12-18 06:35:45 -07:00
|
|
|
mutex_lock(&connector->mutex);
|
|
|
|
if (!connector->registered) {
|
|
|
|
mutex_unlock(&connector->mutex);
|
2016-08-12 14:48:50 -06:00
|
|
|
return;
|
2016-12-18 06:35:45 -07:00
|
|
|
}
|
2016-08-12 14:48:50 -06:00
|
|
|
|
|
|
|
if (connector->funcs->early_unregister)
|
|
|
|
connector->funcs->early_unregister(connector);
|
|
|
|
|
|
|
|
drm_sysfs_connector_remove(connector);
|
|
|
|
drm_debugfs_connector_remove(connector);
|
|
|
|
|
|
|
|
connector->registered = false;
|
2016-12-18 06:35:45 -07:00
|
|
|
mutex_unlock(&connector->mutex);
|
2016-08-12 14:48:50 -06:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(drm_connector_unregister);
|
|
|
|
|
|
|
|
void drm_connector_unregister_all(struct drm_device *dev)
|
|
|
|
{
|
|
|
|
struct drm_connector *connector;
|
drm: locking&new iterators for connector_list
The requirements for connector_list locking are a bit tricky:
- We need to be able to jump over zombie conectors (i.e. with refcount
== 0, but not yet removed from the list). If instead we require that
there's no zombies on the list then the final kref_put must happen
under the list protection lock, which means that locking context
leaks all over the place. Not pretty - better to deal with zombies
and wrap the locking just around the list_del in the destructor.
- When we walk the list we must _not_ hold the connector list lock. We
walk the connector list at an absolutely massive amounts of places,
if all those places can't ever call drm_connector_unreference the
code would get unecessarily complicated.
- connector_list needs it own lock, again too many places that walk it
that we could reuse e.g. mode_config.mutex without resulting in
inversions.
- Lots of code uses these loops to look-up a connector, i.e. they want
to be able to call drm_connector_reference. But on the other hand we
want connectors to stay on that list until they're dead (i.e.
connector_list can't hold a full reference), which means despite the
"can't hold lock for the loop body" rule we need to make sure a
connector doesn't suddenly become a zombie.
At first Dave&I discussed various horror-show approaches using srcu,
but turns out it's fairly easy:
- For the loop body we always hold an additional reference to the
current connector. That means it can't zombify, and it also means
it'll stay on the list, which means we can use it as our iterator to
find the next connector.
- When we try to find the next connector we only have to jump over
zombies. To make sure we don't chase bad pointers that entire loop
is protected with the new connect_list_lock spinlock. And because we
know that we're starting out with a non-zombie (need to drop our
reference for the old connector only after we have our new one),
we're guranteed to still be on the connector_list and either find
the next non-zombie or complete the iteration.
- Only downside is that we need to make sure that the temporary
reference for the loop body doesn't leak. iter_get/put() functions +
lockdep make sure that's the case.
- To avoid a flag day the new iterator macro has an _iter postfix. We
can rename it back once all the users of the unsafe version are gone
(there's about 100 list walkers for the connector_list).
For now this patch only converts all the list walking in the core,
leaving helpers and drivers for later patches. The nice thing is that
we can now finally remove 2 FIXME comments from the
register/unregister functions.
v2:
- use irqsafe spinlocks, so that we can use this in drm_state_dump
too.
- nuke drm_modeset_lock_all from drm_connector_init, now entirely
cargo-culted nonsense.
v3:
- do {} while (!kref_get_unless_zero), makes for a tidier loop (Dave).
- pretty kerneldoc
- add EXPORT_SYMBOL, helpers&drivers are supposed to use this.
v4: Change lockdep annotations to only check whether we release the
iter fake lock again (i.e. make sure that iter_put is called), but
not check any locking dependecies itself. That seams to require a
recursive read lock in trylock mode.
Cc: Dave Airlie <airlied@gmail.com>
Cc: Chris Wilson <chris@chris-wilson.co.uk>
Reviewed-by: Chris Wilson <chris@chris-wilson.co.uk>
Reviewed-by: Sean Paul <seanpaul@chromium.org>
Signed-off-by: Daniel Vetter <daniel.vetter@intel.com>
Link: http://patchwork.freedesktop.org/patch/msgid/20161213230814.19598-6-daniel.vetter@ffwll.ch
2016-12-13 16:08:06 -07:00
|
|
|
struct drm_connector_list_iter conn_iter;
|
2016-08-12 14:48:50 -06:00
|
|
|
|
2017-02-28 07:46:43 -07:00
|
|
|
drm_connector_list_iter_begin(dev, &conn_iter);
|
drm: locking&new iterators for connector_list
The requirements for connector_list locking are a bit tricky:
- We need to be able to jump over zombie conectors (i.e. with refcount
== 0, but not yet removed from the list). If instead we require that
there's no zombies on the list then the final kref_put must happen
under the list protection lock, which means that locking context
leaks all over the place. Not pretty - better to deal with zombies
and wrap the locking just around the list_del in the destructor.
- When we walk the list we must _not_ hold the connector list lock. We
walk the connector list at an absolutely massive amounts of places,
if all those places can't ever call drm_connector_unreference the
code would get unecessarily complicated.
- connector_list needs it own lock, again too many places that walk it
that we could reuse e.g. mode_config.mutex without resulting in
inversions.
- Lots of code uses these loops to look-up a connector, i.e. they want
to be able to call drm_connector_reference. But on the other hand we
want connectors to stay on that list until they're dead (i.e.
connector_list can't hold a full reference), which means despite the
"can't hold lock for the loop body" rule we need to make sure a
connector doesn't suddenly become a zombie.
At first Dave&I discussed various horror-show approaches using srcu,
but turns out it's fairly easy:
- For the loop body we always hold an additional reference to the
current connector. That means it can't zombify, and it also means
it'll stay on the list, which means we can use it as our iterator to
find the next connector.
- When we try to find the next connector we only have to jump over
zombies. To make sure we don't chase bad pointers that entire loop
is protected with the new connect_list_lock spinlock. And because we
know that we're starting out with a non-zombie (need to drop our
reference for the old connector only after we have our new one),
we're guranteed to still be on the connector_list and either find
the next non-zombie or complete the iteration.
- Only downside is that we need to make sure that the temporary
reference for the loop body doesn't leak. iter_get/put() functions +
lockdep make sure that's the case.
- To avoid a flag day the new iterator macro has an _iter postfix. We
can rename it back once all the users of the unsafe version are gone
(there's about 100 list walkers for the connector_list).
For now this patch only converts all the list walking in the core,
leaving helpers and drivers for later patches. The nice thing is that
we can now finally remove 2 FIXME comments from the
register/unregister functions.
v2:
- use irqsafe spinlocks, so that we can use this in drm_state_dump
too.
- nuke drm_modeset_lock_all from drm_connector_init, now entirely
cargo-culted nonsense.
v3:
- do {} while (!kref_get_unless_zero), makes for a tidier loop (Dave).
- pretty kerneldoc
- add EXPORT_SYMBOL, helpers&drivers are supposed to use this.
v4: Change lockdep annotations to only check whether we release the
iter fake lock again (i.e. make sure that iter_put is called), but
not check any locking dependecies itself. That seams to require a
recursive read lock in trylock mode.
Cc: Dave Airlie <airlied@gmail.com>
Cc: Chris Wilson <chris@chris-wilson.co.uk>
Reviewed-by: Chris Wilson <chris@chris-wilson.co.uk>
Reviewed-by: Sean Paul <seanpaul@chromium.org>
Signed-off-by: Daniel Vetter <daniel.vetter@intel.com>
Link: http://patchwork.freedesktop.org/patch/msgid/20161213230814.19598-6-daniel.vetter@ffwll.ch
2016-12-13 16:08:06 -07:00
|
|
|
drm_for_each_connector_iter(connector, &conn_iter)
|
2016-08-12 14:48:50 -06:00
|
|
|
drm_connector_unregister(connector);
|
2017-02-28 07:46:43 -07:00
|
|
|
drm_connector_list_iter_end(&conn_iter);
|
2016-08-12 14:48:50 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
int drm_connector_register_all(struct drm_device *dev)
|
|
|
|
{
|
|
|
|
struct drm_connector *connector;
|
drm: locking&new iterators for connector_list
The requirements for connector_list locking are a bit tricky:
- We need to be able to jump over zombie conectors (i.e. with refcount
== 0, but not yet removed from the list). If instead we require that
there's no zombies on the list then the final kref_put must happen
under the list protection lock, which means that locking context
leaks all over the place. Not pretty - better to deal with zombies
and wrap the locking just around the list_del in the destructor.
- When we walk the list we must _not_ hold the connector list lock. We
walk the connector list at an absolutely massive amounts of places,
if all those places can't ever call drm_connector_unreference the
code would get unecessarily complicated.
- connector_list needs it own lock, again too many places that walk it
that we could reuse e.g. mode_config.mutex without resulting in
inversions.
- Lots of code uses these loops to look-up a connector, i.e. they want
to be able to call drm_connector_reference. But on the other hand we
want connectors to stay on that list until they're dead (i.e.
connector_list can't hold a full reference), which means despite the
"can't hold lock for the loop body" rule we need to make sure a
connector doesn't suddenly become a zombie.
At first Dave&I discussed various horror-show approaches using srcu,
but turns out it's fairly easy:
- For the loop body we always hold an additional reference to the
current connector. That means it can't zombify, and it also means
it'll stay on the list, which means we can use it as our iterator to
find the next connector.
- When we try to find the next connector we only have to jump over
zombies. To make sure we don't chase bad pointers that entire loop
is protected with the new connect_list_lock spinlock. And because we
know that we're starting out with a non-zombie (need to drop our
reference for the old connector only after we have our new one),
we're guranteed to still be on the connector_list and either find
the next non-zombie or complete the iteration.
- Only downside is that we need to make sure that the temporary
reference for the loop body doesn't leak. iter_get/put() functions +
lockdep make sure that's the case.
- To avoid a flag day the new iterator macro has an _iter postfix. We
can rename it back once all the users of the unsafe version are gone
(there's about 100 list walkers for the connector_list).
For now this patch only converts all the list walking in the core,
leaving helpers and drivers for later patches. The nice thing is that
we can now finally remove 2 FIXME comments from the
register/unregister functions.
v2:
- use irqsafe spinlocks, so that we can use this in drm_state_dump
too.
- nuke drm_modeset_lock_all from drm_connector_init, now entirely
cargo-culted nonsense.
v3:
- do {} while (!kref_get_unless_zero), makes for a tidier loop (Dave).
- pretty kerneldoc
- add EXPORT_SYMBOL, helpers&drivers are supposed to use this.
v4: Change lockdep annotations to only check whether we release the
iter fake lock again (i.e. make sure that iter_put is called), but
not check any locking dependecies itself. That seams to require a
recursive read lock in trylock mode.
Cc: Dave Airlie <airlied@gmail.com>
Cc: Chris Wilson <chris@chris-wilson.co.uk>
Reviewed-by: Chris Wilson <chris@chris-wilson.co.uk>
Reviewed-by: Sean Paul <seanpaul@chromium.org>
Signed-off-by: Daniel Vetter <daniel.vetter@intel.com>
Link: http://patchwork.freedesktop.org/patch/msgid/20161213230814.19598-6-daniel.vetter@ffwll.ch
2016-12-13 16:08:06 -07:00
|
|
|
struct drm_connector_list_iter conn_iter;
|
|
|
|
int ret = 0;
|
2016-08-12 14:48:50 -06:00
|
|
|
|
2017-02-28 07:46:43 -07:00
|
|
|
drm_connector_list_iter_begin(dev, &conn_iter);
|
drm: locking&new iterators for connector_list
The requirements for connector_list locking are a bit tricky:
- We need to be able to jump over zombie conectors (i.e. with refcount
== 0, but not yet removed from the list). If instead we require that
there's no zombies on the list then the final kref_put must happen
under the list protection lock, which means that locking context
leaks all over the place. Not pretty - better to deal with zombies
and wrap the locking just around the list_del in the destructor.
- When we walk the list we must _not_ hold the connector list lock. We
walk the connector list at an absolutely massive amounts of places,
if all those places can't ever call drm_connector_unreference the
code would get unecessarily complicated.
- connector_list needs it own lock, again too many places that walk it
that we could reuse e.g. mode_config.mutex without resulting in
inversions.
- Lots of code uses these loops to look-up a connector, i.e. they want
to be able to call drm_connector_reference. But on the other hand we
want connectors to stay on that list until they're dead (i.e.
connector_list can't hold a full reference), which means despite the
"can't hold lock for the loop body" rule we need to make sure a
connector doesn't suddenly become a zombie.
At first Dave&I discussed various horror-show approaches using srcu,
but turns out it's fairly easy:
- For the loop body we always hold an additional reference to the
current connector. That means it can't zombify, and it also means
it'll stay on the list, which means we can use it as our iterator to
find the next connector.
- When we try to find the next connector we only have to jump over
zombies. To make sure we don't chase bad pointers that entire loop
is protected with the new connect_list_lock spinlock. And because we
know that we're starting out with a non-zombie (need to drop our
reference for the old connector only after we have our new one),
we're guranteed to still be on the connector_list and either find
the next non-zombie or complete the iteration.
- Only downside is that we need to make sure that the temporary
reference for the loop body doesn't leak. iter_get/put() functions +
lockdep make sure that's the case.
- To avoid a flag day the new iterator macro has an _iter postfix. We
can rename it back once all the users of the unsafe version are gone
(there's about 100 list walkers for the connector_list).
For now this patch only converts all the list walking in the core,
leaving helpers and drivers for later patches. The nice thing is that
we can now finally remove 2 FIXME comments from the
register/unregister functions.
v2:
- use irqsafe spinlocks, so that we can use this in drm_state_dump
too.
- nuke drm_modeset_lock_all from drm_connector_init, now entirely
cargo-culted nonsense.
v3:
- do {} while (!kref_get_unless_zero), makes for a tidier loop (Dave).
- pretty kerneldoc
- add EXPORT_SYMBOL, helpers&drivers are supposed to use this.
v4: Change lockdep annotations to only check whether we release the
iter fake lock again (i.e. make sure that iter_put is called), but
not check any locking dependecies itself. That seams to require a
recursive read lock in trylock mode.
Cc: Dave Airlie <airlied@gmail.com>
Cc: Chris Wilson <chris@chris-wilson.co.uk>
Reviewed-by: Chris Wilson <chris@chris-wilson.co.uk>
Reviewed-by: Sean Paul <seanpaul@chromium.org>
Signed-off-by: Daniel Vetter <daniel.vetter@intel.com>
Link: http://patchwork.freedesktop.org/patch/msgid/20161213230814.19598-6-daniel.vetter@ffwll.ch
2016-12-13 16:08:06 -07:00
|
|
|
drm_for_each_connector_iter(connector, &conn_iter) {
|
2016-08-12 14:48:50 -06:00
|
|
|
ret = drm_connector_register(connector);
|
|
|
|
if (ret)
|
drm: locking&new iterators for connector_list
The requirements for connector_list locking are a bit tricky:
- We need to be able to jump over zombie conectors (i.e. with refcount
== 0, but not yet removed from the list). If instead we require that
there's no zombies on the list then the final kref_put must happen
under the list protection lock, which means that locking context
leaks all over the place. Not pretty - better to deal with zombies
and wrap the locking just around the list_del in the destructor.
- When we walk the list we must _not_ hold the connector list lock. We
walk the connector list at an absolutely massive amounts of places,
if all those places can't ever call drm_connector_unreference the
code would get unecessarily complicated.
- connector_list needs it own lock, again too many places that walk it
that we could reuse e.g. mode_config.mutex without resulting in
inversions.
- Lots of code uses these loops to look-up a connector, i.e. they want
to be able to call drm_connector_reference. But on the other hand we
want connectors to stay on that list until they're dead (i.e.
connector_list can't hold a full reference), which means despite the
"can't hold lock for the loop body" rule we need to make sure a
connector doesn't suddenly become a zombie.
At first Dave&I discussed various horror-show approaches using srcu,
but turns out it's fairly easy:
- For the loop body we always hold an additional reference to the
current connector. That means it can't zombify, and it also means
it'll stay on the list, which means we can use it as our iterator to
find the next connector.
- When we try to find the next connector we only have to jump over
zombies. To make sure we don't chase bad pointers that entire loop
is protected with the new connect_list_lock spinlock. And because we
know that we're starting out with a non-zombie (need to drop our
reference for the old connector only after we have our new one),
we're guranteed to still be on the connector_list and either find
the next non-zombie or complete the iteration.
- Only downside is that we need to make sure that the temporary
reference for the loop body doesn't leak. iter_get/put() functions +
lockdep make sure that's the case.
- To avoid a flag day the new iterator macro has an _iter postfix. We
can rename it back once all the users of the unsafe version are gone
(there's about 100 list walkers for the connector_list).
For now this patch only converts all the list walking in the core,
leaving helpers and drivers for later patches. The nice thing is that
we can now finally remove 2 FIXME comments from the
register/unregister functions.
v2:
- use irqsafe spinlocks, so that we can use this in drm_state_dump
too.
- nuke drm_modeset_lock_all from drm_connector_init, now entirely
cargo-culted nonsense.
v3:
- do {} while (!kref_get_unless_zero), makes for a tidier loop (Dave).
- pretty kerneldoc
- add EXPORT_SYMBOL, helpers&drivers are supposed to use this.
v4: Change lockdep annotations to only check whether we release the
iter fake lock again (i.e. make sure that iter_put is called), but
not check any locking dependecies itself. That seams to require a
recursive read lock in trylock mode.
Cc: Dave Airlie <airlied@gmail.com>
Cc: Chris Wilson <chris@chris-wilson.co.uk>
Reviewed-by: Chris Wilson <chris@chris-wilson.co.uk>
Reviewed-by: Sean Paul <seanpaul@chromium.org>
Signed-off-by: Daniel Vetter <daniel.vetter@intel.com>
Link: http://patchwork.freedesktop.org/patch/msgid/20161213230814.19598-6-daniel.vetter@ffwll.ch
2016-12-13 16:08:06 -07:00
|
|
|
break;
|
2016-08-12 14:48:50 -06:00
|
|
|
}
|
2017-02-28 07:46:43 -07:00
|
|
|
drm_connector_list_iter_end(&conn_iter);
|
2016-08-12 14:48:50 -06:00
|
|
|
|
drm: locking&new iterators for connector_list
The requirements for connector_list locking are a bit tricky:
- We need to be able to jump over zombie conectors (i.e. with refcount
== 0, but not yet removed from the list). If instead we require that
there's no zombies on the list then the final kref_put must happen
under the list protection lock, which means that locking context
leaks all over the place. Not pretty - better to deal with zombies
and wrap the locking just around the list_del in the destructor.
- When we walk the list we must _not_ hold the connector list lock. We
walk the connector list at an absolutely massive amounts of places,
if all those places can't ever call drm_connector_unreference the
code would get unecessarily complicated.
- connector_list needs it own lock, again too many places that walk it
that we could reuse e.g. mode_config.mutex without resulting in
inversions.
- Lots of code uses these loops to look-up a connector, i.e. they want
to be able to call drm_connector_reference. But on the other hand we
want connectors to stay on that list until they're dead (i.e.
connector_list can't hold a full reference), which means despite the
"can't hold lock for the loop body" rule we need to make sure a
connector doesn't suddenly become a zombie.
At first Dave&I discussed various horror-show approaches using srcu,
but turns out it's fairly easy:
- For the loop body we always hold an additional reference to the
current connector. That means it can't zombify, and it also means
it'll stay on the list, which means we can use it as our iterator to
find the next connector.
- When we try to find the next connector we only have to jump over
zombies. To make sure we don't chase bad pointers that entire loop
is protected with the new connect_list_lock spinlock. And because we
know that we're starting out with a non-zombie (need to drop our
reference for the old connector only after we have our new one),
we're guranteed to still be on the connector_list and either find
the next non-zombie or complete the iteration.
- Only downside is that we need to make sure that the temporary
reference for the loop body doesn't leak. iter_get/put() functions +
lockdep make sure that's the case.
- To avoid a flag day the new iterator macro has an _iter postfix. We
can rename it back once all the users of the unsafe version are gone
(there's about 100 list walkers for the connector_list).
For now this patch only converts all the list walking in the core,
leaving helpers and drivers for later patches. The nice thing is that
we can now finally remove 2 FIXME comments from the
register/unregister functions.
v2:
- use irqsafe spinlocks, so that we can use this in drm_state_dump
too.
- nuke drm_modeset_lock_all from drm_connector_init, now entirely
cargo-culted nonsense.
v3:
- do {} while (!kref_get_unless_zero), makes for a tidier loop (Dave).
- pretty kerneldoc
- add EXPORT_SYMBOL, helpers&drivers are supposed to use this.
v4: Change lockdep annotations to only check whether we release the
iter fake lock again (i.e. make sure that iter_put is called), but
not check any locking dependecies itself. That seams to require a
recursive read lock in trylock mode.
Cc: Dave Airlie <airlied@gmail.com>
Cc: Chris Wilson <chris@chris-wilson.co.uk>
Reviewed-by: Chris Wilson <chris@chris-wilson.co.uk>
Reviewed-by: Sean Paul <seanpaul@chromium.org>
Signed-off-by: Daniel Vetter <daniel.vetter@intel.com>
Link: http://patchwork.freedesktop.org/patch/msgid/20161213230814.19598-6-daniel.vetter@ffwll.ch
2016-12-13 16:08:06 -07:00
|
|
|
if (ret)
|
|
|
|
drm_connector_unregister_all(dev);
|
2016-08-12 14:48:50 -06:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* drm_get_connector_status_name - return a string for connector status
|
|
|
|
* @status: connector status to compute name of
|
|
|
|
*
|
|
|
|
* In contrast to the other drm_get_*_name functions this one here returns a
|
|
|
|
* const pointer and hence is threadsafe.
|
|
|
|
*/
|
|
|
|
const char *drm_get_connector_status_name(enum drm_connector_status status)
|
|
|
|
{
|
|
|
|
if (status == connector_status_connected)
|
|
|
|
return "connected";
|
|
|
|
else if (status == connector_status_disconnected)
|
|
|
|
return "disconnected";
|
|
|
|
else
|
|
|
|
return "unknown";
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(drm_get_connector_status_name);
|
|
|
|
|
2017-02-20 01:51:48 -07:00
|
|
|
/**
|
|
|
|
* drm_get_connector_force_name - return a string for connector force
|
|
|
|
* @force: connector force to get name of
|
|
|
|
*
|
|
|
|
* Returns: const pointer to name.
|
|
|
|
*/
|
|
|
|
const char *drm_get_connector_force_name(enum drm_connector_force force)
|
|
|
|
{
|
|
|
|
switch (force) {
|
|
|
|
case DRM_FORCE_UNSPECIFIED:
|
|
|
|
return "unspecified";
|
|
|
|
case DRM_FORCE_OFF:
|
|
|
|
return "off";
|
|
|
|
case DRM_FORCE_ON:
|
|
|
|
return "on";
|
|
|
|
case DRM_FORCE_ON_DIGITAL:
|
|
|
|
return "digital";
|
|
|
|
default:
|
|
|
|
return "unknown";
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
drm: locking&new iterators for connector_list
The requirements for connector_list locking are a bit tricky:
- We need to be able to jump over zombie conectors (i.e. with refcount
== 0, but not yet removed from the list). If instead we require that
there's no zombies on the list then the final kref_put must happen
under the list protection lock, which means that locking context
leaks all over the place. Not pretty - better to deal with zombies
and wrap the locking just around the list_del in the destructor.
- When we walk the list we must _not_ hold the connector list lock. We
walk the connector list at an absolutely massive amounts of places,
if all those places can't ever call drm_connector_unreference the
code would get unecessarily complicated.
- connector_list needs it own lock, again too many places that walk it
that we could reuse e.g. mode_config.mutex without resulting in
inversions.
- Lots of code uses these loops to look-up a connector, i.e. they want
to be able to call drm_connector_reference. But on the other hand we
want connectors to stay on that list until they're dead (i.e.
connector_list can't hold a full reference), which means despite the
"can't hold lock for the loop body" rule we need to make sure a
connector doesn't suddenly become a zombie.
At first Dave&I discussed various horror-show approaches using srcu,
but turns out it's fairly easy:
- For the loop body we always hold an additional reference to the
current connector. That means it can't zombify, and it also means
it'll stay on the list, which means we can use it as our iterator to
find the next connector.
- When we try to find the next connector we only have to jump over
zombies. To make sure we don't chase bad pointers that entire loop
is protected with the new connect_list_lock spinlock. And because we
know that we're starting out with a non-zombie (need to drop our
reference for the old connector only after we have our new one),
we're guranteed to still be on the connector_list and either find
the next non-zombie or complete the iteration.
- Only downside is that we need to make sure that the temporary
reference for the loop body doesn't leak. iter_get/put() functions +
lockdep make sure that's the case.
- To avoid a flag day the new iterator macro has an _iter postfix. We
can rename it back once all the users of the unsafe version are gone
(there's about 100 list walkers for the connector_list).
For now this patch only converts all the list walking in the core,
leaving helpers and drivers for later patches. The nice thing is that
we can now finally remove 2 FIXME comments from the
register/unregister functions.
v2:
- use irqsafe spinlocks, so that we can use this in drm_state_dump
too.
- nuke drm_modeset_lock_all from drm_connector_init, now entirely
cargo-culted nonsense.
v3:
- do {} while (!kref_get_unless_zero), makes for a tidier loop (Dave).
- pretty kerneldoc
- add EXPORT_SYMBOL, helpers&drivers are supposed to use this.
v4: Change lockdep annotations to only check whether we release the
iter fake lock again (i.e. make sure that iter_put is called), but
not check any locking dependecies itself. That seams to require a
recursive read lock in trylock mode.
Cc: Dave Airlie <airlied@gmail.com>
Cc: Chris Wilson <chris@chris-wilson.co.uk>
Reviewed-by: Chris Wilson <chris@chris-wilson.co.uk>
Reviewed-by: Sean Paul <seanpaul@chromium.org>
Signed-off-by: Daniel Vetter <daniel.vetter@intel.com>
Link: http://patchwork.freedesktop.org/patch/msgid/20161213230814.19598-6-daniel.vetter@ffwll.ch
2016-12-13 16:08:06 -07:00
|
|
|
#ifdef CONFIG_LOCKDEP
|
|
|
|
static struct lockdep_map connector_list_iter_dep_map = {
|
|
|
|
.name = "drm_connector_list_iter"
|
|
|
|
};
|
|
|
|
#endif
|
|
|
|
|
|
|
|
/**
|
2017-02-28 07:46:43 -07:00
|
|
|
* drm_connector_list_iter_begin - initialize a connector_list iterator
|
drm: locking&new iterators for connector_list
The requirements for connector_list locking are a bit tricky:
- We need to be able to jump over zombie conectors (i.e. with refcount
== 0, but not yet removed from the list). If instead we require that
there's no zombies on the list then the final kref_put must happen
under the list protection lock, which means that locking context
leaks all over the place. Not pretty - better to deal with zombies
and wrap the locking just around the list_del in the destructor.
- When we walk the list we must _not_ hold the connector list lock. We
walk the connector list at an absolutely massive amounts of places,
if all those places can't ever call drm_connector_unreference the
code would get unecessarily complicated.
- connector_list needs it own lock, again too many places that walk it
that we could reuse e.g. mode_config.mutex without resulting in
inversions.
- Lots of code uses these loops to look-up a connector, i.e. they want
to be able to call drm_connector_reference. But on the other hand we
want connectors to stay on that list until they're dead (i.e.
connector_list can't hold a full reference), which means despite the
"can't hold lock for the loop body" rule we need to make sure a
connector doesn't suddenly become a zombie.
At first Dave&I discussed various horror-show approaches using srcu,
but turns out it's fairly easy:
- For the loop body we always hold an additional reference to the
current connector. That means it can't zombify, and it also means
it'll stay on the list, which means we can use it as our iterator to
find the next connector.
- When we try to find the next connector we only have to jump over
zombies. To make sure we don't chase bad pointers that entire loop
is protected with the new connect_list_lock spinlock. And because we
know that we're starting out with a non-zombie (need to drop our
reference for the old connector only after we have our new one),
we're guranteed to still be on the connector_list and either find
the next non-zombie or complete the iteration.
- Only downside is that we need to make sure that the temporary
reference for the loop body doesn't leak. iter_get/put() functions +
lockdep make sure that's the case.
- To avoid a flag day the new iterator macro has an _iter postfix. We
can rename it back once all the users of the unsafe version are gone
(there's about 100 list walkers for the connector_list).
For now this patch only converts all the list walking in the core,
leaving helpers and drivers for later patches. The nice thing is that
we can now finally remove 2 FIXME comments from the
register/unregister functions.
v2:
- use irqsafe spinlocks, so that we can use this in drm_state_dump
too.
- nuke drm_modeset_lock_all from drm_connector_init, now entirely
cargo-culted nonsense.
v3:
- do {} while (!kref_get_unless_zero), makes for a tidier loop (Dave).
- pretty kerneldoc
- add EXPORT_SYMBOL, helpers&drivers are supposed to use this.
v4: Change lockdep annotations to only check whether we release the
iter fake lock again (i.e. make sure that iter_put is called), but
not check any locking dependecies itself. That seams to require a
recursive read lock in trylock mode.
Cc: Dave Airlie <airlied@gmail.com>
Cc: Chris Wilson <chris@chris-wilson.co.uk>
Reviewed-by: Chris Wilson <chris@chris-wilson.co.uk>
Reviewed-by: Sean Paul <seanpaul@chromium.org>
Signed-off-by: Daniel Vetter <daniel.vetter@intel.com>
Link: http://patchwork.freedesktop.org/patch/msgid/20161213230814.19598-6-daniel.vetter@ffwll.ch
2016-12-13 16:08:06 -07:00
|
|
|
* @dev: DRM device
|
|
|
|
* @iter: connector_list iterator
|
|
|
|
*
|
2017-01-24 23:26:45 -07:00
|
|
|
* Sets @iter up to walk the &drm_mode_config.connector_list of @dev. @iter
|
2017-02-28 07:46:43 -07:00
|
|
|
* must always be cleaned up again by calling drm_connector_list_iter_end().
|
drm: locking&new iterators for connector_list
The requirements for connector_list locking are a bit tricky:
- We need to be able to jump over zombie conectors (i.e. with refcount
== 0, but not yet removed from the list). If instead we require that
there's no zombies on the list then the final kref_put must happen
under the list protection lock, which means that locking context
leaks all over the place. Not pretty - better to deal with zombies
and wrap the locking just around the list_del in the destructor.
- When we walk the list we must _not_ hold the connector list lock. We
walk the connector list at an absolutely massive amounts of places,
if all those places can't ever call drm_connector_unreference the
code would get unecessarily complicated.
- connector_list needs it own lock, again too many places that walk it
that we could reuse e.g. mode_config.mutex without resulting in
inversions.
- Lots of code uses these loops to look-up a connector, i.e. they want
to be able to call drm_connector_reference. But on the other hand we
want connectors to stay on that list until they're dead (i.e.
connector_list can't hold a full reference), which means despite the
"can't hold lock for the loop body" rule we need to make sure a
connector doesn't suddenly become a zombie.
At first Dave&I discussed various horror-show approaches using srcu,
but turns out it's fairly easy:
- For the loop body we always hold an additional reference to the
current connector. That means it can't zombify, and it also means
it'll stay on the list, which means we can use it as our iterator to
find the next connector.
- When we try to find the next connector we only have to jump over
zombies. To make sure we don't chase bad pointers that entire loop
is protected with the new connect_list_lock spinlock. And because we
know that we're starting out with a non-zombie (need to drop our
reference for the old connector only after we have our new one),
we're guranteed to still be on the connector_list and either find
the next non-zombie or complete the iteration.
- Only downside is that we need to make sure that the temporary
reference for the loop body doesn't leak. iter_get/put() functions +
lockdep make sure that's the case.
- To avoid a flag day the new iterator macro has an _iter postfix. We
can rename it back once all the users of the unsafe version are gone
(there's about 100 list walkers for the connector_list).
For now this patch only converts all the list walking in the core,
leaving helpers and drivers for later patches. The nice thing is that
we can now finally remove 2 FIXME comments from the
register/unregister functions.
v2:
- use irqsafe spinlocks, so that we can use this in drm_state_dump
too.
- nuke drm_modeset_lock_all from drm_connector_init, now entirely
cargo-culted nonsense.
v3:
- do {} while (!kref_get_unless_zero), makes for a tidier loop (Dave).
- pretty kerneldoc
- add EXPORT_SYMBOL, helpers&drivers are supposed to use this.
v4: Change lockdep annotations to only check whether we release the
iter fake lock again (i.e. make sure that iter_put is called), but
not check any locking dependecies itself. That seams to require a
recursive read lock in trylock mode.
Cc: Dave Airlie <airlied@gmail.com>
Cc: Chris Wilson <chris@chris-wilson.co.uk>
Reviewed-by: Chris Wilson <chris@chris-wilson.co.uk>
Reviewed-by: Sean Paul <seanpaul@chromium.org>
Signed-off-by: Daniel Vetter <daniel.vetter@intel.com>
Link: http://patchwork.freedesktop.org/patch/msgid/20161213230814.19598-6-daniel.vetter@ffwll.ch
2016-12-13 16:08:06 -07:00
|
|
|
* Iteration itself happens using drm_connector_list_iter_next() or
|
|
|
|
* drm_for_each_connector_iter().
|
|
|
|
*/
|
2017-02-28 07:46:43 -07:00
|
|
|
void drm_connector_list_iter_begin(struct drm_device *dev,
|
|
|
|
struct drm_connector_list_iter *iter)
|
drm: locking&new iterators for connector_list
The requirements for connector_list locking are a bit tricky:
- We need to be able to jump over zombie conectors (i.e. with refcount
== 0, but not yet removed from the list). If instead we require that
there's no zombies on the list then the final kref_put must happen
under the list protection lock, which means that locking context
leaks all over the place. Not pretty - better to deal with zombies
and wrap the locking just around the list_del in the destructor.
- When we walk the list we must _not_ hold the connector list lock. We
walk the connector list at an absolutely massive amounts of places,
if all those places can't ever call drm_connector_unreference the
code would get unecessarily complicated.
- connector_list needs it own lock, again too many places that walk it
that we could reuse e.g. mode_config.mutex without resulting in
inversions.
- Lots of code uses these loops to look-up a connector, i.e. they want
to be able to call drm_connector_reference. But on the other hand we
want connectors to stay on that list until they're dead (i.e.
connector_list can't hold a full reference), which means despite the
"can't hold lock for the loop body" rule we need to make sure a
connector doesn't suddenly become a zombie.
At first Dave&I discussed various horror-show approaches using srcu,
but turns out it's fairly easy:
- For the loop body we always hold an additional reference to the
current connector. That means it can't zombify, and it also means
it'll stay on the list, which means we can use it as our iterator to
find the next connector.
- When we try to find the next connector we only have to jump over
zombies. To make sure we don't chase bad pointers that entire loop
is protected with the new connect_list_lock spinlock. And because we
know that we're starting out with a non-zombie (need to drop our
reference for the old connector only after we have our new one),
we're guranteed to still be on the connector_list and either find
the next non-zombie or complete the iteration.
- Only downside is that we need to make sure that the temporary
reference for the loop body doesn't leak. iter_get/put() functions +
lockdep make sure that's the case.
- To avoid a flag day the new iterator macro has an _iter postfix. We
can rename it back once all the users of the unsafe version are gone
(there's about 100 list walkers for the connector_list).
For now this patch only converts all the list walking in the core,
leaving helpers and drivers for later patches. The nice thing is that
we can now finally remove 2 FIXME comments from the
register/unregister functions.
v2:
- use irqsafe spinlocks, so that we can use this in drm_state_dump
too.
- nuke drm_modeset_lock_all from drm_connector_init, now entirely
cargo-culted nonsense.
v3:
- do {} while (!kref_get_unless_zero), makes for a tidier loop (Dave).
- pretty kerneldoc
- add EXPORT_SYMBOL, helpers&drivers are supposed to use this.
v4: Change lockdep annotations to only check whether we release the
iter fake lock again (i.e. make sure that iter_put is called), but
not check any locking dependecies itself. That seams to require a
recursive read lock in trylock mode.
Cc: Dave Airlie <airlied@gmail.com>
Cc: Chris Wilson <chris@chris-wilson.co.uk>
Reviewed-by: Chris Wilson <chris@chris-wilson.co.uk>
Reviewed-by: Sean Paul <seanpaul@chromium.org>
Signed-off-by: Daniel Vetter <daniel.vetter@intel.com>
Link: http://patchwork.freedesktop.org/patch/msgid/20161213230814.19598-6-daniel.vetter@ffwll.ch
2016-12-13 16:08:06 -07:00
|
|
|
{
|
|
|
|
iter->dev = dev;
|
|
|
|
iter->conn = NULL;
|
|
|
|
lock_acquire_shared_recursive(&connector_list_iter_dep_map, 0, 1, NULL, _RET_IP_);
|
|
|
|
}
|
2017-02-28 07:46:43 -07:00
|
|
|
EXPORT_SYMBOL(drm_connector_list_iter_begin);
|
drm: locking&new iterators for connector_list
The requirements for connector_list locking are a bit tricky:
- We need to be able to jump over zombie conectors (i.e. with refcount
== 0, but not yet removed from the list). If instead we require that
there's no zombies on the list then the final kref_put must happen
under the list protection lock, which means that locking context
leaks all over the place. Not pretty - better to deal with zombies
and wrap the locking just around the list_del in the destructor.
- When we walk the list we must _not_ hold the connector list lock. We
walk the connector list at an absolutely massive amounts of places,
if all those places can't ever call drm_connector_unreference the
code would get unecessarily complicated.
- connector_list needs it own lock, again too many places that walk it
that we could reuse e.g. mode_config.mutex without resulting in
inversions.
- Lots of code uses these loops to look-up a connector, i.e. they want
to be able to call drm_connector_reference. But on the other hand we
want connectors to stay on that list until they're dead (i.e.
connector_list can't hold a full reference), which means despite the
"can't hold lock for the loop body" rule we need to make sure a
connector doesn't suddenly become a zombie.
At first Dave&I discussed various horror-show approaches using srcu,
but turns out it's fairly easy:
- For the loop body we always hold an additional reference to the
current connector. That means it can't zombify, and it also means
it'll stay on the list, which means we can use it as our iterator to
find the next connector.
- When we try to find the next connector we only have to jump over
zombies. To make sure we don't chase bad pointers that entire loop
is protected with the new connect_list_lock spinlock. And because we
know that we're starting out with a non-zombie (need to drop our
reference for the old connector only after we have our new one),
we're guranteed to still be on the connector_list and either find
the next non-zombie or complete the iteration.
- Only downside is that we need to make sure that the temporary
reference for the loop body doesn't leak. iter_get/put() functions +
lockdep make sure that's the case.
- To avoid a flag day the new iterator macro has an _iter postfix. We
can rename it back once all the users of the unsafe version are gone
(there's about 100 list walkers for the connector_list).
For now this patch only converts all the list walking in the core,
leaving helpers and drivers for later patches. The nice thing is that
we can now finally remove 2 FIXME comments from the
register/unregister functions.
v2:
- use irqsafe spinlocks, so that we can use this in drm_state_dump
too.
- nuke drm_modeset_lock_all from drm_connector_init, now entirely
cargo-culted nonsense.
v3:
- do {} while (!kref_get_unless_zero), makes for a tidier loop (Dave).
- pretty kerneldoc
- add EXPORT_SYMBOL, helpers&drivers are supposed to use this.
v4: Change lockdep annotations to only check whether we release the
iter fake lock again (i.e. make sure that iter_put is called), but
not check any locking dependecies itself. That seams to require a
recursive read lock in trylock mode.
Cc: Dave Airlie <airlied@gmail.com>
Cc: Chris Wilson <chris@chris-wilson.co.uk>
Reviewed-by: Chris Wilson <chris@chris-wilson.co.uk>
Reviewed-by: Sean Paul <seanpaul@chromium.org>
Signed-off-by: Daniel Vetter <daniel.vetter@intel.com>
Link: http://patchwork.freedesktop.org/patch/msgid/20161213230814.19598-6-daniel.vetter@ffwll.ch
2016-12-13 16:08:06 -07:00
|
|
|
|
|
|
|
/**
|
|
|
|
* drm_connector_list_iter_next - return next connector
|
|
|
|
* @iter: connectr_list iterator
|
|
|
|
*
|
|
|
|
* Returns the next connector for @iter, or NULL when the list walk has
|
|
|
|
* completed.
|
|
|
|
*/
|
|
|
|
struct drm_connector *
|
|
|
|
drm_connector_list_iter_next(struct drm_connector_list_iter *iter)
|
|
|
|
{
|
|
|
|
struct drm_connector *old_conn = iter->conn;
|
|
|
|
struct drm_mode_config *config = &iter->dev->mode_config;
|
|
|
|
struct list_head *lhead;
|
|
|
|
unsigned long flags;
|
|
|
|
|
|
|
|
spin_lock_irqsave(&config->connector_list_lock, flags);
|
|
|
|
lhead = old_conn ? &old_conn->head : &config->connector_list;
|
|
|
|
|
|
|
|
do {
|
|
|
|
if (lhead->next == &config->connector_list) {
|
|
|
|
iter->conn = NULL;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
lhead = lhead->next;
|
|
|
|
iter->conn = list_entry(lhead, struct drm_connector, head);
|
|
|
|
|
|
|
|
/* loop until it's not a zombie connector */
|
|
|
|
} while (!kref_get_unless_zero(&iter->conn->base.refcount));
|
|
|
|
spin_unlock_irqrestore(&config->connector_list_lock, flags);
|
|
|
|
|
|
|
|
if (old_conn)
|
2017-02-28 07:46:39 -07:00
|
|
|
drm_connector_put(old_conn);
|
drm: locking&new iterators for connector_list
The requirements for connector_list locking are a bit tricky:
- We need to be able to jump over zombie conectors (i.e. with refcount
== 0, but not yet removed from the list). If instead we require that
there's no zombies on the list then the final kref_put must happen
under the list protection lock, which means that locking context
leaks all over the place. Not pretty - better to deal with zombies
and wrap the locking just around the list_del in the destructor.
- When we walk the list we must _not_ hold the connector list lock. We
walk the connector list at an absolutely massive amounts of places,
if all those places can't ever call drm_connector_unreference the
code would get unecessarily complicated.
- connector_list needs it own lock, again too many places that walk it
that we could reuse e.g. mode_config.mutex without resulting in
inversions.
- Lots of code uses these loops to look-up a connector, i.e. they want
to be able to call drm_connector_reference. But on the other hand we
want connectors to stay on that list until they're dead (i.e.
connector_list can't hold a full reference), which means despite the
"can't hold lock for the loop body" rule we need to make sure a
connector doesn't suddenly become a zombie.
At first Dave&I discussed various horror-show approaches using srcu,
but turns out it's fairly easy:
- For the loop body we always hold an additional reference to the
current connector. That means it can't zombify, and it also means
it'll stay on the list, which means we can use it as our iterator to
find the next connector.
- When we try to find the next connector we only have to jump over
zombies. To make sure we don't chase bad pointers that entire loop
is protected with the new connect_list_lock spinlock. And because we
know that we're starting out with a non-zombie (need to drop our
reference for the old connector only after we have our new one),
we're guranteed to still be on the connector_list and either find
the next non-zombie or complete the iteration.
- Only downside is that we need to make sure that the temporary
reference for the loop body doesn't leak. iter_get/put() functions +
lockdep make sure that's the case.
- To avoid a flag day the new iterator macro has an _iter postfix. We
can rename it back once all the users of the unsafe version are gone
(there's about 100 list walkers for the connector_list).
For now this patch only converts all the list walking in the core,
leaving helpers and drivers for later patches. The nice thing is that
we can now finally remove 2 FIXME comments from the
register/unregister functions.
v2:
- use irqsafe spinlocks, so that we can use this in drm_state_dump
too.
- nuke drm_modeset_lock_all from drm_connector_init, now entirely
cargo-culted nonsense.
v3:
- do {} while (!kref_get_unless_zero), makes for a tidier loop (Dave).
- pretty kerneldoc
- add EXPORT_SYMBOL, helpers&drivers are supposed to use this.
v4: Change lockdep annotations to only check whether we release the
iter fake lock again (i.e. make sure that iter_put is called), but
not check any locking dependecies itself. That seams to require a
recursive read lock in trylock mode.
Cc: Dave Airlie <airlied@gmail.com>
Cc: Chris Wilson <chris@chris-wilson.co.uk>
Reviewed-by: Chris Wilson <chris@chris-wilson.co.uk>
Reviewed-by: Sean Paul <seanpaul@chromium.org>
Signed-off-by: Daniel Vetter <daniel.vetter@intel.com>
Link: http://patchwork.freedesktop.org/patch/msgid/20161213230814.19598-6-daniel.vetter@ffwll.ch
2016-12-13 16:08:06 -07:00
|
|
|
|
|
|
|
return iter->conn;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(drm_connector_list_iter_next);
|
|
|
|
|
|
|
|
/**
|
2017-02-28 07:46:43 -07:00
|
|
|
* drm_connector_list_iter_end - tear down a connector_list iterator
|
drm: locking&new iterators for connector_list
The requirements for connector_list locking are a bit tricky:
- We need to be able to jump over zombie conectors (i.e. with refcount
== 0, but not yet removed from the list). If instead we require that
there's no zombies on the list then the final kref_put must happen
under the list protection lock, which means that locking context
leaks all over the place. Not pretty - better to deal with zombies
and wrap the locking just around the list_del in the destructor.
- When we walk the list we must _not_ hold the connector list lock. We
walk the connector list at an absolutely massive amounts of places,
if all those places can't ever call drm_connector_unreference the
code would get unecessarily complicated.
- connector_list needs it own lock, again too many places that walk it
that we could reuse e.g. mode_config.mutex without resulting in
inversions.
- Lots of code uses these loops to look-up a connector, i.e. they want
to be able to call drm_connector_reference. But on the other hand we
want connectors to stay on that list until they're dead (i.e.
connector_list can't hold a full reference), which means despite the
"can't hold lock for the loop body" rule we need to make sure a
connector doesn't suddenly become a zombie.
At first Dave&I discussed various horror-show approaches using srcu,
but turns out it's fairly easy:
- For the loop body we always hold an additional reference to the
current connector. That means it can't zombify, and it also means
it'll stay on the list, which means we can use it as our iterator to
find the next connector.
- When we try to find the next connector we only have to jump over
zombies. To make sure we don't chase bad pointers that entire loop
is protected with the new connect_list_lock spinlock. And because we
know that we're starting out with a non-zombie (need to drop our
reference for the old connector only after we have our new one),
we're guranteed to still be on the connector_list and either find
the next non-zombie or complete the iteration.
- Only downside is that we need to make sure that the temporary
reference for the loop body doesn't leak. iter_get/put() functions +
lockdep make sure that's the case.
- To avoid a flag day the new iterator macro has an _iter postfix. We
can rename it back once all the users of the unsafe version are gone
(there's about 100 list walkers for the connector_list).
For now this patch only converts all the list walking in the core,
leaving helpers and drivers for later patches. The nice thing is that
we can now finally remove 2 FIXME comments from the
register/unregister functions.
v2:
- use irqsafe spinlocks, so that we can use this in drm_state_dump
too.
- nuke drm_modeset_lock_all from drm_connector_init, now entirely
cargo-culted nonsense.
v3:
- do {} while (!kref_get_unless_zero), makes for a tidier loop (Dave).
- pretty kerneldoc
- add EXPORT_SYMBOL, helpers&drivers are supposed to use this.
v4: Change lockdep annotations to only check whether we release the
iter fake lock again (i.e. make sure that iter_put is called), but
not check any locking dependecies itself. That seams to require a
recursive read lock in trylock mode.
Cc: Dave Airlie <airlied@gmail.com>
Cc: Chris Wilson <chris@chris-wilson.co.uk>
Reviewed-by: Chris Wilson <chris@chris-wilson.co.uk>
Reviewed-by: Sean Paul <seanpaul@chromium.org>
Signed-off-by: Daniel Vetter <daniel.vetter@intel.com>
Link: http://patchwork.freedesktop.org/patch/msgid/20161213230814.19598-6-daniel.vetter@ffwll.ch
2016-12-13 16:08:06 -07:00
|
|
|
* @iter: connector_list iterator
|
|
|
|
*
|
|
|
|
* Tears down @iter and releases any resources (like &drm_connector references)
|
|
|
|
* acquired while walking the list. This must always be called, both when the
|
|
|
|
* iteration completes fully or when it was aborted without walking the entire
|
|
|
|
* list.
|
|
|
|
*/
|
2017-02-28 07:46:43 -07:00
|
|
|
void drm_connector_list_iter_end(struct drm_connector_list_iter *iter)
|
drm: locking&new iterators for connector_list
The requirements for connector_list locking are a bit tricky:
- We need to be able to jump over zombie conectors (i.e. with refcount
== 0, but not yet removed from the list). If instead we require that
there's no zombies on the list then the final kref_put must happen
under the list protection lock, which means that locking context
leaks all over the place. Not pretty - better to deal with zombies
and wrap the locking just around the list_del in the destructor.
- When we walk the list we must _not_ hold the connector list lock. We
walk the connector list at an absolutely massive amounts of places,
if all those places can't ever call drm_connector_unreference the
code would get unecessarily complicated.
- connector_list needs it own lock, again too many places that walk it
that we could reuse e.g. mode_config.mutex without resulting in
inversions.
- Lots of code uses these loops to look-up a connector, i.e. they want
to be able to call drm_connector_reference. But on the other hand we
want connectors to stay on that list until they're dead (i.e.
connector_list can't hold a full reference), which means despite the
"can't hold lock for the loop body" rule we need to make sure a
connector doesn't suddenly become a zombie.
At first Dave&I discussed various horror-show approaches using srcu,
but turns out it's fairly easy:
- For the loop body we always hold an additional reference to the
current connector. That means it can't zombify, and it also means
it'll stay on the list, which means we can use it as our iterator to
find the next connector.
- When we try to find the next connector we only have to jump over
zombies. To make sure we don't chase bad pointers that entire loop
is protected with the new connect_list_lock spinlock. And because we
know that we're starting out with a non-zombie (need to drop our
reference for the old connector only after we have our new one),
we're guranteed to still be on the connector_list and either find
the next non-zombie or complete the iteration.
- Only downside is that we need to make sure that the temporary
reference for the loop body doesn't leak. iter_get/put() functions +
lockdep make sure that's the case.
- To avoid a flag day the new iterator macro has an _iter postfix. We
can rename it back once all the users of the unsafe version are gone
(there's about 100 list walkers for the connector_list).
For now this patch only converts all the list walking in the core,
leaving helpers and drivers for later patches. The nice thing is that
we can now finally remove 2 FIXME comments from the
register/unregister functions.
v2:
- use irqsafe spinlocks, so that we can use this in drm_state_dump
too.
- nuke drm_modeset_lock_all from drm_connector_init, now entirely
cargo-culted nonsense.
v3:
- do {} while (!kref_get_unless_zero), makes for a tidier loop (Dave).
- pretty kerneldoc
- add EXPORT_SYMBOL, helpers&drivers are supposed to use this.
v4: Change lockdep annotations to only check whether we release the
iter fake lock again (i.e. make sure that iter_put is called), but
not check any locking dependecies itself. That seams to require a
recursive read lock in trylock mode.
Cc: Dave Airlie <airlied@gmail.com>
Cc: Chris Wilson <chris@chris-wilson.co.uk>
Reviewed-by: Chris Wilson <chris@chris-wilson.co.uk>
Reviewed-by: Sean Paul <seanpaul@chromium.org>
Signed-off-by: Daniel Vetter <daniel.vetter@intel.com>
Link: http://patchwork.freedesktop.org/patch/msgid/20161213230814.19598-6-daniel.vetter@ffwll.ch
2016-12-13 16:08:06 -07:00
|
|
|
{
|
|
|
|
iter->dev = NULL;
|
|
|
|
if (iter->conn)
|
2017-02-28 07:46:39 -07:00
|
|
|
drm_connector_put(iter->conn);
|
drm: locking&new iterators for connector_list
The requirements for connector_list locking are a bit tricky:
- We need to be able to jump over zombie conectors (i.e. with refcount
== 0, but not yet removed from the list). If instead we require that
there's no zombies on the list then the final kref_put must happen
under the list protection lock, which means that locking context
leaks all over the place. Not pretty - better to deal with zombies
and wrap the locking just around the list_del in the destructor.
- When we walk the list we must _not_ hold the connector list lock. We
walk the connector list at an absolutely massive amounts of places,
if all those places can't ever call drm_connector_unreference the
code would get unecessarily complicated.
- connector_list needs it own lock, again too many places that walk it
that we could reuse e.g. mode_config.mutex without resulting in
inversions.
- Lots of code uses these loops to look-up a connector, i.e. they want
to be able to call drm_connector_reference. But on the other hand we
want connectors to stay on that list until they're dead (i.e.
connector_list can't hold a full reference), which means despite the
"can't hold lock for the loop body" rule we need to make sure a
connector doesn't suddenly become a zombie.
At first Dave&I discussed various horror-show approaches using srcu,
but turns out it's fairly easy:
- For the loop body we always hold an additional reference to the
current connector. That means it can't zombify, and it also means
it'll stay on the list, which means we can use it as our iterator to
find the next connector.
- When we try to find the next connector we only have to jump over
zombies. To make sure we don't chase bad pointers that entire loop
is protected with the new connect_list_lock spinlock. And because we
know that we're starting out with a non-zombie (need to drop our
reference for the old connector only after we have our new one),
we're guranteed to still be on the connector_list and either find
the next non-zombie or complete the iteration.
- Only downside is that we need to make sure that the temporary
reference for the loop body doesn't leak. iter_get/put() functions +
lockdep make sure that's the case.
- To avoid a flag day the new iterator macro has an _iter postfix. We
can rename it back once all the users of the unsafe version are gone
(there's about 100 list walkers for the connector_list).
For now this patch only converts all the list walking in the core,
leaving helpers and drivers for later patches. The nice thing is that
we can now finally remove 2 FIXME comments from the
register/unregister functions.
v2:
- use irqsafe spinlocks, so that we can use this in drm_state_dump
too.
- nuke drm_modeset_lock_all from drm_connector_init, now entirely
cargo-culted nonsense.
v3:
- do {} while (!kref_get_unless_zero), makes for a tidier loop (Dave).
- pretty kerneldoc
- add EXPORT_SYMBOL, helpers&drivers are supposed to use this.
v4: Change lockdep annotations to only check whether we release the
iter fake lock again (i.e. make sure that iter_put is called), but
not check any locking dependecies itself. That seams to require a
recursive read lock in trylock mode.
Cc: Dave Airlie <airlied@gmail.com>
Cc: Chris Wilson <chris@chris-wilson.co.uk>
Reviewed-by: Chris Wilson <chris@chris-wilson.co.uk>
Reviewed-by: Sean Paul <seanpaul@chromium.org>
Signed-off-by: Daniel Vetter <daniel.vetter@intel.com>
Link: http://patchwork.freedesktop.org/patch/msgid/20161213230814.19598-6-daniel.vetter@ffwll.ch
2016-12-13 16:08:06 -07:00
|
|
|
lock_release(&connector_list_iter_dep_map, 0, _RET_IP_);
|
|
|
|
}
|
2017-02-28 07:46:43 -07:00
|
|
|
EXPORT_SYMBOL(drm_connector_list_iter_end);
|
drm: locking&new iterators for connector_list
The requirements for connector_list locking are a bit tricky:
- We need to be able to jump over zombie conectors (i.e. with refcount
== 0, but not yet removed from the list). If instead we require that
there's no zombies on the list then the final kref_put must happen
under the list protection lock, which means that locking context
leaks all over the place. Not pretty - better to deal with zombies
and wrap the locking just around the list_del in the destructor.
- When we walk the list we must _not_ hold the connector list lock. We
walk the connector list at an absolutely massive amounts of places,
if all those places can't ever call drm_connector_unreference the
code would get unecessarily complicated.
- connector_list needs it own lock, again too many places that walk it
that we could reuse e.g. mode_config.mutex without resulting in
inversions.
- Lots of code uses these loops to look-up a connector, i.e. they want
to be able to call drm_connector_reference. But on the other hand we
want connectors to stay on that list until they're dead (i.e.
connector_list can't hold a full reference), which means despite the
"can't hold lock for the loop body" rule we need to make sure a
connector doesn't suddenly become a zombie.
At first Dave&I discussed various horror-show approaches using srcu,
but turns out it's fairly easy:
- For the loop body we always hold an additional reference to the
current connector. That means it can't zombify, and it also means
it'll stay on the list, which means we can use it as our iterator to
find the next connector.
- When we try to find the next connector we only have to jump over
zombies. To make sure we don't chase bad pointers that entire loop
is protected with the new connect_list_lock spinlock. And because we
know that we're starting out with a non-zombie (need to drop our
reference for the old connector only after we have our new one),
we're guranteed to still be on the connector_list and either find
the next non-zombie or complete the iteration.
- Only downside is that we need to make sure that the temporary
reference for the loop body doesn't leak. iter_get/put() functions +
lockdep make sure that's the case.
- To avoid a flag day the new iterator macro has an _iter postfix. We
can rename it back once all the users of the unsafe version are gone
(there's about 100 list walkers for the connector_list).
For now this patch only converts all the list walking in the core,
leaving helpers and drivers for later patches. The nice thing is that
we can now finally remove 2 FIXME comments from the
register/unregister functions.
v2:
- use irqsafe spinlocks, so that we can use this in drm_state_dump
too.
- nuke drm_modeset_lock_all from drm_connector_init, now entirely
cargo-culted nonsense.
v3:
- do {} while (!kref_get_unless_zero), makes for a tidier loop (Dave).
- pretty kerneldoc
- add EXPORT_SYMBOL, helpers&drivers are supposed to use this.
v4: Change lockdep annotations to only check whether we release the
iter fake lock again (i.e. make sure that iter_put is called), but
not check any locking dependecies itself. That seams to require a
recursive read lock in trylock mode.
Cc: Dave Airlie <airlied@gmail.com>
Cc: Chris Wilson <chris@chris-wilson.co.uk>
Reviewed-by: Chris Wilson <chris@chris-wilson.co.uk>
Reviewed-by: Sean Paul <seanpaul@chromium.org>
Signed-off-by: Daniel Vetter <daniel.vetter@intel.com>
Link: http://patchwork.freedesktop.org/patch/msgid/20161213230814.19598-6-daniel.vetter@ffwll.ch
2016-12-13 16:08:06 -07:00
|
|
|
|
2016-08-12 14:48:50 -06:00
|
|
|
static const struct drm_prop_enum_list drm_subpixel_enum_list[] = {
|
|
|
|
{ SubPixelUnknown, "Unknown" },
|
|
|
|
{ SubPixelHorizontalRGB, "Horizontal RGB" },
|
|
|
|
{ SubPixelHorizontalBGR, "Horizontal BGR" },
|
|
|
|
{ SubPixelVerticalRGB, "Vertical RGB" },
|
|
|
|
{ SubPixelVerticalBGR, "Vertical BGR" },
|
|
|
|
{ SubPixelNone, "None" },
|
|
|
|
};
|
|
|
|
|
|
|
|
/**
|
|
|
|
* drm_get_subpixel_order_name - return a string for a given subpixel enum
|
|
|
|
* @order: enum of subpixel_order
|
|
|
|
*
|
|
|
|
* Note you could abuse this and return something out of bounds, but that
|
|
|
|
* would be a caller error. No unscrubbed user data should make it here.
|
|
|
|
*/
|
|
|
|
const char *drm_get_subpixel_order_name(enum subpixel_order order)
|
|
|
|
{
|
|
|
|
return drm_subpixel_enum_list[order].name;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(drm_get_subpixel_order_name);
|
|
|
|
|
|
|
|
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" }
|
|
|
|
};
|
|
|
|
DRM_ENUM_NAME_FN(drm_get_dpms_name, drm_dpms_enum_list)
|
|
|
|
|
drm: Add a new connector atomic property for link status
At the time userspace does setcrtc, we've already promised the mode
would work. The promise is based on the theoretical capabilities of
the link, but it's possible we can't reach this in practice. The DP
spec describes how the link should be reduced, but we can't reduce
the link below the requirements of the mode. Black screen follows.
One idea would be to have setcrtc return a failure. However, it
already should not fail as the atomic checks have passed. It would
also conflict with the idea of making setcrtc asynchronous in the
future, returning before the actual mode setting and link training.
Another idea is to train the link "upfront" at hotplug time, before
pruning the mode list, so that we can do the pruning based on
practical not theoretical capabilities. However, the changes for link
training are pretty drastic, all for the sake of error handling and
DP compliance, when the most common happy day scenario is the current
approach of link training at mode setting time, using the optimal
parameters for the mode. It is also not certain all hardware could do
this without the pipe on; not even all our hardware can do this. Some
of this can be solved, but not trivially.
Both of the above ideas also fail to address link degradation *during*
operation.
The solution is to add a new "link-status" connector property in order
to address link training failure in a way that:
a) changes the current happy day scenario as little as possible, to
avoid regressions, b) can be implemented the same way by all drm
drivers, c) is still opt-in for the drivers and userspace, and opting
out doesn't regress the user experience, d) doesn't prevent drivers
from implementing better or alternate approaches, possibly without
userspace involvement. And, of course, handles all the issues presented.
In the usual happy day scenario, this is always "good". If something
fails during or after a mode set, the kernel driver can set the link
status to "bad" and issue a hotplug uevent for userspace to have it
re-check the valid modes through GET_CONNECTOR IOCTL, and try modeset
again. If the theoretical capabilities of the link can't be reached,
the mode list is trimmed based on that.
v7 by Jani:
* Rebase, simplify set property while at it, checkpatch fix
v6:
* Fix a typo in kernel doc (Sean Paul)
v5:
* Clarify doc for silent rejection of atomic properties by driver (Daniel Vetter)
v4:
* Add comments in kernel-doc format (Daniel Vetter)
* Update the kernel-doc for link-status (Sean Paul)
v3:
* Fixed a build error (Jani Saarinen)
v2:
* Removed connector->link_status (Daniel Vetter)
* Set connector->state->link_status in drm_mode_connector_set_link_status_property
(Daniel Vetter)
* Set the connector_changed flag to true if connector->state->link_status changed.
* Reset link_status to GOOD in update_output_state (Daniel Vetter)
* Never allow userspace to set link status from Good To Bad (Daniel Vetter)
Reviewed-by: Sean Paul <seanpaul@chromium.org>
Reviewed-by: Daniel Vetter <daniel.vetter@ffwll.ch>
Reviewed-by: Jani Nikula <jani.nikula@intel.com>
Acked-by: Tony Cheng <tony.cheng@amd.com>
Acked-by: Harry Wentland <harry.wentland@amd.com>
Cc: Jani Nikula <jani.nikula@linux.intel.com>
Cc: Daniel Vetter <daniel.vetter@intel.com>
Cc: Ville Syrjala <ville.syrjala@linux.intel.com>
Cc: Chris Wilson <chris@chris-wilson.co.uk>
Cc: Sean Paul <seanpaul@chromium.org>
Signed-off-by: Manasi Navare <manasi.d.navare@intel.com>
Signed-off-by: Jani Nikula <jani.nikula@intel.com>
Acked-by: Eric Anholt <eric@anholt.net> (for the -modesetting patch)
Signed-off-by: Daniel Vetter <daniel.vetter@ffwll.ch>
Link: http://patchwork.freedesktop.org/patch/msgid/0182487051aa9f1594820e35a4853de2f8747b4e.1481883920.git.jani.nikula@intel.com
2016-12-16 03:29:06 -07:00
|
|
|
static const struct drm_prop_enum_list drm_link_status_enum_list[] = {
|
|
|
|
{ DRM_MODE_LINK_STATUS_GOOD, "Good" },
|
|
|
|
{ DRM_MODE_LINK_STATUS_BAD, "Bad" },
|
|
|
|
};
|
|
|
|
DRM_ENUM_NAME_FN(drm_get_link_status_name, drm_link_status_enum_list)
|
|
|
|
|
2016-08-12 14:48:55 -06:00
|
|
|
/**
|
|
|
|
* 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);
|
|
|
|
|
2016-08-12 14:48:50 -06:00
|
|
|
/* Optional connector properties. */
|
|
|
|
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" },
|
|
|
|
{ DRM_MODE_SCALE_ASPECT, "Full aspect" },
|
|
|
|
};
|
|
|
|
|
|
|
|
static const struct drm_prop_enum_list drm_aspect_ratio_enum_list[] = {
|
|
|
|
{ DRM_MODE_PICTURE_ASPECT_NONE, "Automatic" },
|
|
|
|
{ DRM_MODE_PICTURE_ASPECT_4_3, "4:3" },
|
|
|
|
{ DRM_MODE_PICTURE_ASPECT_16_9, "16:9" },
|
|
|
|
};
|
|
|
|
|
|
|
|
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 */
|
|
|
|
};
|
|
|
|
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[] = {
|
|
|
|
{ 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 */
|
|
|
|
};
|
|
|
|
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[] = {
|
|
|
|
{ DRM_MODE_SUBCONNECTOR_Automatic, "Automatic" }, /* DVI-I and TV-out */
|
|
|
|
{ DRM_MODE_SUBCONNECTOR_Composite, "Composite" }, /* TV-out */
|
|
|
|
{ DRM_MODE_SUBCONNECTOR_SVIDEO, "SVIDEO" }, /* TV-out */
|
|
|
|
{ DRM_MODE_SUBCONNECTOR_Component, "Component" }, /* TV-out */
|
|
|
|
{ DRM_MODE_SUBCONNECTOR_SCART, "SCART" }, /* TV-out */
|
|
|
|
};
|
|
|
|
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[] = {
|
|
|
|
{ DRM_MODE_SUBCONNECTOR_Unknown, "Unknown" }, /* DVI-I and TV-out */
|
|
|
|
{ DRM_MODE_SUBCONNECTOR_Composite, "Composite" }, /* TV-out */
|
|
|
|
{ DRM_MODE_SUBCONNECTOR_SVIDEO, "SVIDEO" }, /* TV-out */
|
|
|
|
{ DRM_MODE_SUBCONNECTOR_Component, "Component" }, /* TV-out */
|
|
|
|
{ DRM_MODE_SUBCONNECTOR_SCART, "SCART" }, /* TV-out */
|
|
|
|
};
|
|
|
|
DRM_ENUM_NAME_FN(drm_get_tv_subconnector_name,
|
|
|
|
drm_tv_subconnector_enum_list)
|
|
|
|
|
2016-11-17 01:56:48 -07:00
|
|
|
/**
|
|
|
|
* DOC: standard connector properties
|
|
|
|
*
|
|
|
|
* DRM connectors have a few standardized properties:
|
|
|
|
*
|
|
|
|
* EDID:
|
|
|
|
* Blob property which contains the current EDID read from the sink. This
|
|
|
|
* is useful to parse sink identification information like vendor, model
|
|
|
|
* and serial. Drivers should update this property by calling
|
|
|
|
* drm_mode_connector_update_edid_property(), usually after having parsed
|
|
|
|
* the EDID using drm_add_edid_modes(). Userspace cannot change this
|
|
|
|
* property.
|
|
|
|
* DPMS:
|
|
|
|
* Legacy property for setting the power state of the connector. For atomic
|
|
|
|
* drivers this is only provided for backwards compatibility with existing
|
|
|
|
* drivers, it remaps to controlling the "ACTIVE" property on the CRTC the
|
|
|
|
* connector is linked to. Drivers should never set this property directly,
|
2017-01-24 23:26:45 -07:00
|
|
|
* it is handled by the DRM core by calling the &drm_connector_funcs.dpms
|
|
|
|
* callback. Atomic drivers should implement this hook using
|
2016-11-17 01:56:48 -07:00
|
|
|
* drm_atomic_helper_connector_dpms(). This is the only property standard
|
|
|
|
* connector property that userspace can change.
|
|
|
|
* PATH:
|
|
|
|
* Connector path property to identify how this sink is physically
|
|
|
|
* connected. Used by DP MST. This should be set by calling
|
|
|
|
* drm_mode_connector_set_path_property(), in the case of DP MST with the
|
|
|
|
* path property the MST manager created. Userspace cannot change this
|
|
|
|
* property.
|
|
|
|
* TILE:
|
|
|
|
* Connector tile group property to indicate how a set of DRM connector
|
|
|
|
* compose together into one logical screen. This is used by both high-res
|
|
|
|
* external screens (often only using a single cable, but exposing multiple
|
|
|
|
* DP MST sinks), or high-res integrated panels (like dual-link DSI) which
|
|
|
|
* are not gen-locked. Note that for tiled panels which are genlocked, like
|
|
|
|
* dual-link LVDS or dual-link DSI, the driver should try to not expose the
|
|
|
|
* tiling and virtualize both &drm_crtc and &drm_plane if needed. Drivers
|
|
|
|
* should update this value using drm_mode_connector_set_tile_property().
|
|
|
|
* Userspace cannot change this property.
|
drm: Add a new connector atomic property for link status
At the time userspace does setcrtc, we've already promised the mode
would work. The promise is based on the theoretical capabilities of
the link, but it's possible we can't reach this in practice. The DP
spec describes how the link should be reduced, but we can't reduce
the link below the requirements of the mode. Black screen follows.
One idea would be to have setcrtc return a failure. However, it
already should not fail as the atomic checks have passed. It would
also conflict with the idea of making setcrtc asynchronous in the
future, returning before the actual mode setting and link training.
Another idea is to train the link "upfront" at hotplug time, before
pruning the mode list, so that we can do the pruning based on
practical not theoretical capabilities. However, the changes for link
training are pretty drastic, all for the sake of error handling and
DP compliance, when the most common happy day scenario is the current
approach of link training at mode setting time, using the optimal
parameters for the mode. It is also not certain all hardware could do
this without the pipe on; not even all our hardware can do this. Some
of this can be solved, but not trivially.
Both of the above ideas also fail to address link degradation *during*
operation.
The solution is to add a new "link-status" connector property in order
to address link training failure in a way that:
a) changes the current happy day scenario as little as possible, to
avoid regressions, b) can be implemented the same way by all drm
drivers, c) is still opt-in for the drivers and userspace, and opting
out doesn't regress the user experience, d) doesn't prevent drivers
from implementing better or alternate approaches, possibly without
userspace involvement. And, of course, handles all the issues presented.
In the usual happy day scenario, this is always "good". If something
fails during or after a mode set, the kernel driver can set the link
status to "bad" and issue a hotplug uevent for userspace to have it
re-check the valid modes through GET_CONNECTOR IOCTL, and try modeset
again. If the theoretical capabilities of the link can't be reached,
the mode list is trimmed based on that.
v7 by Jani:
* Rebase, simplify set property while at it, checkpatch fix
v6:
* Fix a typo in kernel doc (Sean Paul)
v5:
* Clarify doc for silent rejection of atomic properties by driver (Daniel Vetter)
v4:
* Add comments in kernel-doc format (Daniel Vetter)
* Update the kernel-doc for link-status (Sean Paul)
v3:
* Fixed a build error (Jani Saarinen)
v2:
* Removed connector->link_status (Daniel Vetter)
* Set connector->state->link_status in drm_mode_connector_set_link_status_property
(Daniel Vetter)
* Set the connector_changed flag to true if connector->state->link_status changed.
* Reset link_status to GOOD in update_output_state (Daniel Vetter)
* Never allow userspace to set link status from Good To Bad (Daniel Vetter)
Reviewed-by: Sean Paul <seanpaul@chromium.org>
Reviewed-by: Daniel Vetter <daniel.vetter@ffwll.ch>
Reviewed-by: Jani Nikula <jani.nikula@intel.com>
Acked-by: Tony Cheng <tony.cheng@amd.com>
Acked-by: Harry Wentland <harry.wentland@amd.com>
Cc: Jani Nikula <jani.nikula@linux.intel.com>
Cc: Daniel Vetter <daniel.vetter@intel.com>
Cc: Ville Syrjala <ville.syrjala@linux.intel.com>
Cc: Chris Wilson <chris@chris-wilson.co.uk>
Cc: Sean Paul <seanpaul@chromium.org>
Signed-off-by: Manasi Navare <manasi.d.navare@intel.com>
Signed-off-by: Jani Nikula <jani.nikula@intel.com>
Acked-by: Eric Anholt <eric@anholt.net> (for the -modesetting patch)
Signed-off-by: Daniel Vetter <daniel.vetter@ffwll.ch>
Link: http://patchwork.freedesktop.org/patch/msgid/0182487051aa9f1594820e35a4853de2f8747b4e.1481883920.git.jani.nikula@intel.com
2016-12-16 03:29:06 -07:00
|
|
|
* link-status:
|
|
|
|
* Connector link-status property to indicate the status of link. The default
|
|
|
|
* value of link-status is "GOOD". If something fails during or after modeset,
|
|
|
|
* the kernel driver may set this to "BAD" and issue a hotplug uevent. Drivers
|
|
|
|
* should update this value using drm_mode_connector_set_link_status_property().
|
2016-11-17 01:56:48 -07:00
|
|
|
*
|
|
|
|
* Connectors also have one standardized atomic property:
|
|
|
|
*
|
|
|
|
* CRTC_ID:
|
|
|
|
* Mode object ID of the &drm_crtc this connector should be connected to.
|
|
|
|
*/
|
|
|
|
|
2016-08-12 14:48:50 -06:00
|
|
|
int drm_connector_create_standard_properties(struct drm_device *dev)
|
|
|
|
{
|
|
|
|
struct drm_property *prop;
|
|
|
|
|
|
|
|
prop = drm_property_create(dev, DRM_MODE_PROP_BLOB |
|
|
|
|
DRM_MODE_PROP_IMMUTABLE,
|
|
|
|
"EDID", 0);
|
|
|
|
if (!prop)
|
|
|
|
return -ENOMEM;
|
|
|
|
dev->mode_config.edid_property = prop;
|
|
|
|
|
|
|
|
prop = drm_property_create_enum(dev, 0,
|
|
|
|
"DPMS", drm_dpms_enum_list,
|
|
|
|
ARRAY_SIZE(drm_dpms_enum_list));
|
|
|
|
if (!prop)
|
|
|
|
return -ENOMEM;
|
|
|
|
dev->mode_config.dpms_property = prop;
|
|
|
|
|
|
|
|
prop = drm_property_create(dev,
|
|
|
|
DRM_MODE_PROP_BLOB |
|
|
|
|
DRM_MODE_PROP_IMMUTABLE,
|
|
|
|
"PATH", 0);
|
|
|
|
if (!prop)
|
|
|
|
return -ENOMEM;
|
|
|
|
dev->mode_config.path_property = prop;
|
|
|
|
|
|
|
|
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;
|
|
|
|
|
drm: Add a new connector atomic property for link status
At the time userspace does setcrtc, we've already promised the mode
would work. The promise is based on the theoretical capabilities of
the link, but it's possible we can't reach this in practice. The DP
spec describes how the link should be reduced, but we can't reduce
the link below the requirements of the mode. Black screen follows.
One idea would be to have setcrtc return a failure. However, it
already should not fail as the atomic checks have passed. It would
also conflict with the idea of making setcrtc asynchronous in the
future, returning before the actual mode setting and link training.
Another idea is to train the link "upfront" at hotplug time, before
pruning the mode list, so that we can do the pruning based on
practical not theoretical capabilities. However, the changes for link
training are pretty drastic, all for the sake of error handling and
DP compliance, when the most common happy day scenario is the current
approach of link training at mode setting time, using the optimal
parameters for the mode. It is also not certain all hardware could do
this without the pipe on; not even all our hardware can do this. Some
of this can be solved, but not trivially.
Both of the above ideas also fail to address link degradation *during*
operation.
The solution is to add a new "link-status" connector property in order
to address link training failure in a way that:
a) changes the current happy day scenario as little as possible, to
avoid regressions, b) can be implemented the same way by all drm
drivers, c) is still opt-in for the drivers and userspace, and opting
out doesn't regress the user experience, d) doesn't prevent drivers
from implementing better or alternate approaches, possibly without
userspace involvement. And, of course, handles all the issues presented.
In the usual happy day scenario, this is always "good". If something
fails during or after a mode set, the kernel driver can set the link
status to "bad" and issue a hotplug uevent for userspace to have it
re-check the valid modes through GET_CONNECTOR IOCTL, and try modeset
again. If the theoretical capabilities of the link can't be reached,
the mode list is trimmed based on that.
v7 by Jani:
* Rebase, simplify set property while at it, checkpatch fix
v6:
* Fix a typo in kernel doc (Sean Paul)
v5:
* Clarify doc for silent rejection of atomic properties by driver (Daniel Vetter)
v4:
* Add comments in kernel-doc format (Daniel Vetter)
* Update the kernel-doc for link-status (Sean Paul)
v3:
* Fixed a build error (Jani Saarinen)
v2:
* Removed connector->link_status (Daniel Vetter)
* Set connector->state->link_status in drm_mode_connector_set_link_status_property
(Daniel Vetter)
* Set the connector_changed flag to true if connector->state->link_status changed.
* Reset link_status to GOOD in update_output_state (Daniel Vetter)
* Never allow userspace to set link status from Good To Bad (Daniel Vetter)
Reviewed-by: Sean Paul <seanpaul@chromium.org>
Reviewed-by: Daniel Vetter <daniel.vetter@ffwll.ch>
Reviewed-by: Jani Nikula <jani.nikula@intel.com>
Acked-by: Tony Cheng <tony.cheng@amd.com>
Acked-by: Harry Wentland <harry.wentland@amd.com>
Cc: Jani Nikula <jani.nikula@linux.intel.com>
Cc: Daniel Vetter <daniel.vetter@intel.com>
Cc: Ville Syrjala <ville.syrjala@linux.intel.com>
Cc: Chris Wilson <chris@chris-wilson.co.uk>
Cc: Sean Paul <seanpaul@chromium.org>
Signed-off-by: Manasi Navare <manasi.d.navare@intel.com>
Signed-off-by: Jani Nikula <jani.nikula@intel.com>
Acked-by: Eric Anholt <eric@anholt.net> (for the -modesetting patch)
Signed-off-by: Daniel Vetter <daniel.vetter@ffwll.ch>
Link: http://patchwork.freedesktop.org/patch/msgid/0182487051aa9f1594820e35a4853de2f8747b4e.1481883920.git.jani.nikula@intel.com
2016-12-16 03:29:06 -07:00
|
|
|
prop = drm_property_create_enum(dev, 0, "link-status",
|
|
|
|
drm_link_status_enum_list,
|
|
|
|
ARRAY_SIZE(drm_link_status_enum_list));
|
|
|
|
if (!prop)
|
|
|
|
return -ENOMEM;
|
|
|
|
dev->mode_config.link_status_property = prop;
|
|
|
|
|
2016-08-12 14:48:50 -06:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* drm_mode_create_dvi_i_properties - create DVI-I specific connector properties
|
|
|
|
* @dev: DRM device
|
|
|
|
*
|
|
|
|
* Called by a driver the first time a DVI-I connector is made.
|
|
|
|
*/
|
|
|
|
int drm_mode_create_dvi_i_properties(struct drm_device *dev)
|
|
|
|
{
|
|
|
|
struct drm_property *dvi_i_selector;
|
|
|
|
struct drm_property *dvi_i_subconnector;
|
|
|
|
|
|
|
|
if (dev->mode_config.dvi_i_select_subconnector_property)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
dvi_i_selector =
|
|
|
|
drm_property_create_enum(dev, 0,
|
|
|
|
"select subconnector",
|
|
|
|
drm_dvi_i_select_enum_list,
|
|
|
|
ARRAY_SIZE(drm_dvi_i_select_enum_list));
|
|
|
|
dev->mode_config.dvi_i_select_subconnector_property = dvi_i_selector;
|
|
|
|
|
|
|
|
dvi_i_subconnector = drm_property_create_enum(dev, DRM_MODE_PROP_IMMUTABLE,
|
|
|
|
"subconnector",
|
|
|
|
drm_dvi_i_subconnector_enum_list,
|
|
|
|
ARRAY_SIZE(drm_dvi_i_subconnector_enum_list));
|
|
|
|
dev->mode_config.dvi_i_subconnector_property = dvi_i_subconnector;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(drm_mode_create_dvi_i_properties);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* drm_create_tv_properties - create TV specific connector properties
|
|
|
|
* @dev: DRM device
|
|
|
|
* @num_modes: number of different TV formats (modes) supported
|
|
|
|
* @modes: array of pointers to strings containing name of each format
|
|
|
|
*
|
|
|
|
* Called by a driver's TV initialization routine, this function creates
|
|
|
|
* the TV specific connector properties for a given device. Caller is
|
|
|
|
* responsible for allocating a list of format names and passing them to
|
|
|
|
* this routine.
|
|
|
|
*/
|
|
|
|
int drm_mode_create_tv_properties(struct drm_device *dev,
|
|
|
|
unsigned int num_modes,
|
|
|
|
const char * const modes[])
|
|
|
|
{
|
|
|
|
struct drm_property *tv_selector;
|
|
|
|
struct drm_property *tv_subconnector;
|
|
|
|
unsigned int i;
|
|
|
|
|
|
|
|
if (dev->mode_config.tv_select_subconnector_property)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Basic connector properties
|
|
|
|
*/
|
|
|
|
tv_selector = drm_property_create_enum(dev, 0,
|
|
|
|
"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 =
|
|
|
|
drm_property_create_enum(dev, DRM_MODE_PROP_IMMUTABLE,
|
|
|
|
"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;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Other, TV specific properties: margins & TV modes.
|
|
|
|
*/
|
|
|
|
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]);
|
|
|
|
|
|
|
|
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);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* drm_mode_create_scaling_mode_property - create scaling mode property
|
|
|
|
* @dev: DRM device
|
|
|
|
*
|
|
|
|
* Called by a driver the first time it's needed, must be attached to desired
|
|
|
|
* connectors.
|
|
|
|
*/
|
|
|
|
int drm_mode_create_scaling_mode_property(struct drm_device *dev)
|
|
|
|
{
|
|
|
|
struct drm_property *scaling_mode;
|
|
|
|
|
|
|
|
if (dev->mode_config.scaling_mode_property)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
scaling_mode =
|
|
|
|
drm_property_create_enum(dev, 0, "scaling mode",
|
|
|
|
drm_scaling_mode_enum_list,
|
|
|
|
ARRAY_SIZE(drm_scaling_mode_enum_list));
|
|
|
|
|
|
|
|
dev->mode_config.scaling_mode_property = scaling_mode;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(drm_mode_create_scaling_mode_property);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* drm_mode_create_aspect_ratio_property - create aspect ratio property
|
|
|
|
* @dev: DRM device
|
|
|
|
*
|
|
|
|
* Called by a driver the first time it's needed, must be attached to desired
|
|
|
|
* connectors.
|
|
|
|
*
|
|
|
|
* Returns:
|
|
|
|
* Zero on success, negative errno on failure.
|
|
|
|
*/
|
|
|
|
int drm_mode_create_aspect_ratio_property(struct drm_device *dev)
|
|
|
|
{
|
|
|
|
if (dev->mode_config.aspect_ratio_property)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
dev->mode_config.aspect_ratio_property =
|
|
|
|
drm_property_create_enum(dev, 0, "aspect ratio",
|
|
|
|
drm_aspect_ratio_enum_list,
|
|
|
|
ARRAY_SIZE(drm_aspect_ratio_enum_list));
|
|
|
|
|
|
|
|
if (dev->mode_config.aspect_ratio_property == NULL)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(drm_mode_create_aspect_ratio_property);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* drm_mode_create_suggested_offset_properties - create suggests offset properties
|
|
|
|
* @dev: DRM device
|
|
|
|
*
|
|
|
|
* Create the the suggested x/y offset property for connectors.
|
|
|
|
*/
|
|
|
|
int drm_mode_create_suggested_offset_properties(struct drm_device *dev)
|
|
|
|
{
|
|
|
|
if (dev->mode_config.suggested_x_property && dev->mode_config.suggested_y_property)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
dev->mode_config.suggested_x_property =
|
|
|
|
drm_property_create_range(dev, DRM_MODE_PROP_IMMUTABLE, "suggested X", 0, 0xffffffff);
|
|
|
|
|
|
|
|
dev->mode_config.suggested_y_property =
|
|
|
|
drm_property_create_range(dev, DRM_MODE_PROP_IMMUTABLE, "suggested Y", 0, 0xffffffff);
|
|
|
|
|
|
|
|
if (dev->mode_config.suggested_x_property == NULL ||
|
|
|
|
dev->mode_config.suggested_y_property == NULL)
|
|
|
|
return -ENOMEM;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(drm_mode_create_suggested_offset_properties);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* drm_mode_connector_set_path_property - set tile property on connector
|
|
|
|
* @connector: connector to set property on.
|
|
|
|
* @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
|
|
|
|
* connectors have a topology and we want to allow userspace to give
|
|
|
|
* them more meaningful names.
|
|
|
|
*
|
|
|
|
* Returns:
|
|
|
|
* Zero on success, negative errno on failure.
|
|
|
|
*/
|
|
|
|
int drm_mode_connector_set_path_property(struct drm_connector *connector,
|
|
|
|
const char *path)
|
|
|
|
{
|
|
|
|
struct drm_device *dev = connector->dev;
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
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);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* drm_mode_connector_set_tile_property - set tile property on connector
|
|
|
|
* @connector: connector to set property on.
|
|
|
|
*
|
|
|
|
* This looks up the tile information for a connector, and creates a
|
|
|
|
* property for userspace to parse if it exists. The property is of
|
|
|
|
* the form of 8 integers using ':' as a separator.
|
|
|
|
*
|
|
|
|
* Returns:
|
|
|
|
* Zero on success, errno on failure.
|
|
|
|
*/
|
|
|
|
int drm_mode_connector_set_tile_property(struct drm_connector *connector)
|
|
|
|
{
|
|
|
|
struct drm_device *dev = connector->dev;
|
|
|
|
char tile[256];
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
if (!connector->has_tile) {
|
|
|
|
ret = drm_property_replace_global_blob(dev,
|
|
|
|
&connector->tile_blob_ptr,
|
|
|
|
0,
|
|
|
|
NULL,
|
|
|
|
&connector->base,
|
|
|
|
dev->mode_config.tile_property);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
snprintf(tile, 256, "%d:%d:%d:%d:%d:%d:%d:%d",
|
|
|
|
connector->tile_group->id, connector->tile_is_single_monitor,
|
|
|
|
connector->num_h_tile, connector->num_v_tile,
|
|
|
|
connector->tile_h_loc, connector->tile_v_loc,
|
|
|
|
connector->tile_h_size, connector->tile_v_size);
|
|
|
|
|
|
|
|
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);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* drm_mode_connector_update_edid_property - update the edid property of a connector
|
|
|
|
* @connector: drm connector
|
|
|
|
* @edid: new value of the edid property
|
|
|
|
*
|
|
|
|
* This function creates a new blob modeset object and assigns its id to the
|
|
|
|
* connector's edid property.
|
|
|
|
*
|
|
|
|
* Returns:
|
|
|
|
* Zero on success, negative errno on failure.
|
|
|
|
*/
|
|
|
|
int drm_mode_connector_update_edid_property(struct drm_connector *connector,
|
|
|
|
const struct edid *edid)
|
|
|
|
{
|
|
|
|
struct drm_device *dev = connector->dev;
|
|
|
|
size_t size = 0;
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
/* ignore requests to set edid when overridden */
|
|
|
|
if (connector->override_edid)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
if (edid)
|
|
|
|
size = EDID_LENGTH * (1 + edid->extensions);
|
|
|
|
|
|
|
|
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);
|
|
|
|
|
drm: Add a new connector atomic property for link status
At the time userspace does setcrtc, we've already promised the mode
would work. The promise is based on the theoretical capabilities of
the link, but it's possible we can't reach this in practice. The DP
spec describes how the link should be reduced, but we can't reduce
the link below the requirements of the mode. Black screen follows.
One idea would be to have setcrtc return a failure. However, it
already should not fail as the atomic checks have passed. It would
also conflict with the idea of making setcrtc asynchronous in the
future, returning before the actual mode setting and link training.
Another idea is to train the link "upfront" at hotplug time, before
pruning the mode list, so that we can do the pruning based on
practical not theoretical capabilities. However, the changes for link
training are pretty drastic, all for the sake of error handling and
DP compliance, when the most common happy day scenario is the current
approach of link training at mode setting time, using the optimal
parameters for the mode. It is also not certain all hardware could do
this without the pipe on; not even all our hardware can do this. Some
of this can be solved, but not trivially.
Both of the above ideas also fail to address link degradation *during*
operation.
The solution is to add a new "link-status" connector property in order
to address link training failure in a way that:
a) changes the current happy day scenario as little as possible, to
avoid regressions, b) can be implemented the same way by all drm
drivers, c) is still opt-in for the drivers and userspace, and opting
out doesn't regress the user experience, d) doesn't prevent drivers
from implementing better or alternate approaches, possibly without
userspace involvement. And, of course, handles all the issues presented.
In the usual happy day scenario, this is always "good". If something
fails during or after a mode set, the kernel driver can set the link
status to "bad" and issue a hotplug uevent for userspace to have it
re-check the valid modes through GET_CONNECTOR IOCTL, and try modeset
again. If the theoretical capabilities of the link can't be reached,
the mode list is trimmed based on that.
v7 by Jani:
* Rebase, simplify set property while at it, checkpatch fix
v6:
* Fix a typo in kernel doc (Sean Paul)
v5:
* Clarify doc for silent rejection of atomic properties by driver (Daniel Vetter)
v4:
* Add comments in kernel-doc format (Daniel Vetter)
* Update the kernel-doc for link-status (Sean Paul)
v3:
* Fixed a build error (Jani Saarinen)
v2:
* Removed connector->link_status (Daniel Vetter)
* Set connector->state->link_status in drm_mode_connector_set_link_status_property
(Daniel Vetter)
* Set the connector_changed flag to true if connector->state->link_status changed.
* Reset link_status to GOOD in update_output_state (Daniel Vetter)
* Never allow userspace to set link status from Good To Bad (Daniel Vetter)
Reviewed-by: Sean Paul <seanpaul@chromium.org>
Reviewed-by: Daniel Vetter <daniel.vetter@ffwll.ch>
Reviewed-by: Jani Nikula <jani.nikula@intel.com>
Acked-by: Tony Cheng <tony.cheng@amd.com>
Acked-by: Harry Wentland <harry.wentland@amd.com>
Cc: Jani Nikula <jani.nikula@linux.intel.com>
Cc: Daniel Vetter <daniel.vetter@intel.com>
Cc: Ville Syrjala <ville.syrjala@linux.intel.com>
Cc: Chris Wilson <chris@chris-wilson.co.uk>
Cc: Sean Paul <seanpaul@chromium.org>
Signed-off-by: Manasi Navare <manasi.d.navare@intel.com>
Signed-off-by: Jani Nikula <jani.nikula@intel.com>
Acked-by: Eric Anholt <eric@anholt.net> (for the -modesetting patch)
Signed-off-by: Daniel Vetter <daniel.vetter@ffwll.ch>
Link: http://patchwork.freedesktop.org/patch/msgid/0182487051aa9f1594820e35a4853de2f8747b4e.1481883920.git.jani.nikula@intel.com
2016-12-16 03:29:06 -07:00
|
|
|
/**
|
|
|
|
* drm_mode_connector_set_link_status_property - Set link status property of a connector
|
|
|
|
* @connector: drm connector
|
|
|
|
* @link_status: new value of link status property (0: Good, 1: Bad)
|
|
|
|
*
|
|
|
|
* In usual working scenario, this link status property will always be set to
|
|
|
|
* "GOOD". If something fails during or after a mode set, the kernel driver
|
|
|
|
* may set this link status property to "BAD". The caller then needs to send a
|
|
|
|
* hotplug uevent for userspace to re-check the valid modes through
|
|
|
|
* GET_CONNECTOR_IOCTL and retry modeset.
|
|
|
|
*
|
|
|
|
* Note: Drivers cannot rely on userspace to support this property and
|
|
|
|
* issue a modeset. As such, they may choose to handle issues (like
|
|
|
|
* re-training a link) without userspace's intervention.
|
|
|
|
*
|
|
|
|
* The reason for adding this property is to handle link training failures, but
|
|
|
|
* it is not limited to DP or link training. For example, if we implement
|
|
|
|
* asynchronous setcrtc, this property can be used to report any failures in that.
|
|
|
|
*/
|
|
|
|
void drm_mode_connector_set_link_status_property(struct drm_connector *connector,
|
|
|
|
uint64_t link_status)
|
|
|
|
{
|
|
|
|
struct drm_device *dev = connector->dev;
|
|
|
|
|
|
|
|
drm_modeset_lock(&dev->mode_config.connection_mutex, NULL);
|
|
|
|
connector->state->link_status = link_status;
|
|
|
|
drm_modeset_unlock(&dev->mode_config.connection_mutex);
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(drm_mode_connector_set_link_status_property);
|
|
|
|
|
2016-08-12 14:48:50 -06:00
|
|
|
int drm_mode_connector_set_obj_prop(struct drm_mode_object *obj,
|
|
|
|
struct drm_property *property,
|
|
|
|
uint64_t value)
|
|
|
|
{
|
|
|
|
int ret = -EINVAL;
|
|
|
|
struct drm_connector *connector = obj_to_connector(obj);
|
|
|
|
|
|
|
|
/* Do DPMS ourselves */
|
|
|
|
if (property == connector->dev->mode_config.dpms_property) {
|
|
|
|
ret = (*connector->funcs->dpms)(connector, (int)value);
|
|
|
|
} else if (connector->funcs->set_property)
|
|
|
|
ret = connector->funcs->set_property(connector, property, value);
|
|
|
|
|
|
|
|
/* store the property value if successful */
|
|
|
|
if (!ret)
|
|
|
|
drm_object_property_set_value(&connector->base, property, value);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
int drm_mode_connector_property_set_ioctl(struct drm_device *dev,
|
|
|
|
void *data, struct drm_file *file_priv)
|
|
|
|
{
|
|
|
|
struct drm_mode_connector_set_property *conn_set_prop = data;
|
|
|
|
struct drm_mode_obj_set_property obj_set_prop = {
|
|
|
|
.value = conn_set_prop->value,
|
|
|
|
.prop_id = conn_set_prop->prop_id,
|
|
|
|
.obj_id = conn_set_prop->connector_id,
|
|
|
|
.obj_type = DRM_MODE_OBJECT_CONNECTOR
|
|
|
|
};
|
|
|
|
|
|
|
|
/* It does all the locking and checking we need */
|
|
|
|
return drm_mode_obj_set_property_ioctl(dev, &obj_set_prop, file_priv);
|
|
|
|
}
|
|
|
|
|
|
|
|
static struct drm_encoder *drm_connector_get_encoder(struct drm_connector *connector)
|
|
|
|
{
|
|
|
|
/* For atomic drivers only state objects are synchronously updated and
|
|
|
|
* protected by modeset locks, so check those first. */
|
|
|
|
if (connector->state)
|
|
|
|
return connector->state->best_encoder;
|
|
|
|
return connector->encoder;
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool drm_mode_expose_to_userspace(const struct drm_display_mode *mode,
|
|
|
|
const struct drm_file *file_priv)
|
|
|
|
{
|
|
|
|
/*
|
|
|
|
* If user-space hasn't configured the driver to expose the stereo 3D
|
|
|
|
* modes, don't expose them.
|
|
|
|
*/
|
|
|
|
if (!file_priv->stereo_allowed && drm_mode_is_stereo(mode))
|
|
|
|
return false;
|
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
int drm_mode_getconnector(struct drm_device *dev, void *data,
|
|
|
|
struct drm_file *file_priv)
|
|
|
|
{
|
|
|
|
struct drm_mode_get_connector *out_resp = data;
|
|
|
|
struct drm_connector *connector;
|
|
|
|
struct drm_encoder *encoder;
|
|
|
|
struct drm_display_mode *mode;
|
|
|
|
int mode_count = 0;
|
|
|
|
int encoders_count = 0;
|
|
|
|
int ret = 0;
|
|
|
|
int copied = 0;
|
|
|
|
int i;
|
|
|
|
struct drm_mode_modeinfo u_mode;
|
|
|
|
struct drm_mode_modeinfo __user *mode_ptr;
|
|
|
|
uint32_t __user *encoder_ptr;
|
|
|
|
|
|
|
|
if (!drm_core_check_feature(dev, DRIVER_MODESET))
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
memset(&u_mode, 0, sizeof(struct drm_mode_modeinfo));
|
|
|
|
|
|
|
|
connector = drm_connector_lookup(dev, out_resp->connector_id);
|
2016-12-13 16:08:10 -07:00
|
|
|
if (!connector)
|
|
|
|
return -ENOENT;
|
|
|
|
|
|
|
|
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;
|
|
|
|
|
|
|
|
ret = drm_mode_object_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);
|
|
|
|
drm_modeset_unlock(&dev->mode_config.connection_mutex);
|
|
|
|
if (ret)
|
|
|
|
goto out_unref;
|
2016-08-12 14:48:50 -06:00
|
|
|
|
|
|
|
for (i = 0; i < DRM_CONNECTOR_MAX_ENCODER; i++)
|
|
|
|
if (connector->encoder_ids[i] != 0)
|
|
|
|
encoders_count++;
|
|
|
|
|
2016-12-13 16:08:10 -07:00
|
|
|
if ((out_resp->count_encoders >= encoders_count) && encoders_count) {
|
|
|
|
copied = 0;
|
|
|
|
encoder_ptr = (uint32_t __user *)(unsigned long)(out_resp->encoders_ptr);
|
|
|
|
for (i = 0; i < DRM_CONNECTOR_MAX_ENCODER; i++) {
|
|
|
|
if (connector->encoder_ids[i] != 0) {
|
|
|
|
if (put_user(connector->encoder_ids[i],
|
|
|
|
encoder_ptr + copied)) {
|
|
|
|
ret = -EFAULT;
|
|
|
|
goto out_unref;
|
|
|
|
}
|
|
|
|
copied++;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
out_resp->count_encoders = encoders_count;
|
|
|
|
|
|
|
|
out_resp->connector_id = connector->base.id;
|
|
|
|
out_resp->connector_type = connector->connector_type;
|
|
|
|
out_resp->connector_type_id = connector->connector_type_id;
|
|
|
|
|
|
|
|
mutex_lock(&dev->mode_config.mutex);
|
2016-08-12 14:48:50 -06:00
|
|
|
if (out_resp->count_modes == 0) {
|
|
|
|
connector->funcs->fill_modes(connector,
|
|
|
|
dev->mode_config.max_width,
|
|
|
|
dev->mode_config.max_height);
|
|
|
|
}
|
|
|
|
|
|
|
|
out_resp->mm_width = connector->display_info.width_mm;
|
|
|
|
out_resp->mm_height = connector->display_info.height_mm;
|
|
|
|
out_resp->subpixel = connector->display_info.subpixel_order;
|
|
|
|
out_resp->connection = connector->status;
|
|
|
|
|
2016-12-13 16:08:10 -07:00
|
|
|
/* delayed so we get modes regardless of pre-fill_modes state */
|
|
|
|
list_for_each_entry(mode, &connector->modes, head)
|
|
|
|
if (drm_mode_expose_to_userspace(mode, file_priv))
|
|
|
|
mode_count++;
|
2016-08-12 14:48:50 -06:00
|
|
|
|
|
|
|
/*
|
|
|
|
* This ioctl is called twice, once to determine how much space is
|
|
|
|
* needed, and the 2nd time to fill it.
|
|
|
|
*/
|
|
|
|
if ((out_resp->count_modes >= mode_count) && mode_count) {
|
|
|
|
copied = 0;
|
|
|
|
mode_ptr = (struct drm_mode_modeinfo __user *)(unsigned long)out_resp->modes_ptr;
|
|
|
|
list_for_each_entry(mode, &connector->modes, head) {
|
|
|
|
if (!drm_mode_expose_to_userspace(mode, file_priv))
|
|
|
|
continue;
|
|
|
|
|
|
|
|
drm_mode_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;
|
|
|
|
out:
|
|
|
|
mutex_unlock(&dev->mode_config.mutex);
|
2016-12-13 16:08:10 -07:00
|
|
|
out_unref:
|
2017-02-28 07:46:39 -07:00
|
|
|
drm_connector_put(connector);
|
2016-08-12 14:48:50 -06:00
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2016-11-14 04:58:24 -07:00
|
|
|
|
|
|
|
/**
|
|
|
|
* DOC: Tile group
|
|
|
|
*
|
|
|
|
* Tile groups are used to represent tiled monitors with a unique integer
|
|
|
|
* identifier. Tiled monitors using DisplayID v1.3 have a unique 8-byte handle,
|
|
|
|
* we store this in a tile group, so we have a common identifier for all tiles
|
|
|
|
* in a monitor group. The property is called "TILE". Drivers can manage tile
|
|
|
|
* groups using drm_mode_create_tile_group(), drm_mode_put_tile_group() and
|
|
|
|
* drm_mode_get_tile_group(). But this is only needed for internal panels where
|
|
|
|
* the tile group information is exposed through a non-standard way.
|
|
|
|
*/
|
|
|
|
|
|
|
|
static void drm_tile_group_free(struct kref *kref)
|
|
|
|
{
|
|
|
|
struct drm_tile_group *tg = container_of(kref, struct drm_tile_group, refcount);
|
|
|
|
struct drm_device *dev = tg->dev;
|
|
|
|
mutex_lock(&dev->mode_config.idr_mutex);
|
|
|
|
idr_remove(&dev->mode_config.tile_idr, tg->id);
|
|
|
|
mutex_unlock(&dev->mode_config.idr_mutex);
|
|
|
|
kfree(tg);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* drm_mode_put_tile_group - drop a reference to a tile group.
|
|
|
|
* @dev: DRM device
|
|
|
|
* @tg: tile group to drop reference to.
|
|
|
|
*
|
|
|
|
* drop reference to tile group and free if 0.
|
|
|
|
*/
|
|
|
|
void drm_mode_put_tile_group(struct drm_device *dev,
|
|
|
|
struct drm_tile_group *tg)
|
|
|
|
{
|
|
|
|
kref_put(&tg->refcount, drm_tile_group_free);
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(drm_mode_put_tile_group);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* drm_mode_get_tile_group - get a reference to an existing tile group
|
|
|
|
* @dev: DRM device
|
|
|
|
* @topology: 8-bytes unique per monitor.
|
|
|
|
*
|
|
|
|
* Use the unique bytes to get a reference to an existing tile group.
|
|
|
|
*
|
|
|
|
* RETURNS:
|
|
|
|
* tile group or NULL if not found.
|
|
|
|
*/
|
|
|
|
struct drm_tile_group *drm_mode_get_tile_group(struct drm_device *dev,
|
|
|
|
char topology[8])
|
|
|
|
{
|
|
|
|
struct drm_tile_group *tg;
|
|
|
|
int id;
|
|
|
|
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;
|
|
|
|
mutex_unlock(&dev->mode_config.idr_mutex);
|
|
|
|
return tg;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
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
|
|
|
|
* @dev: DRM device
|
|
|
|
* @topology: 8-bytes unique per monitor.
|
|
|
|
*
|
|
|
|
* Create a tile group for the unique monitor, and get a unique
|
|
|
|
* identifier for the tile group.
|
|
|
|
*
|
|
|
|
* RETURNS:
|
|
|
|
* new tile group or error.
|
|
|
|
*/
|
|
|
|
struct drm_tile_group *drm_mode_create_tile_group(struct drm_device *dev,
|
|
|
|
char topology[8])
|
|
|
|
{
|
|
|
|
struct drm_tile_group *tg;
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
tg = kzalloc(sizeof(*tg), GFP_KERNEL);
|
|
|
|
if (!tg)
|
|
|
|
return ERR_PTR(-ENOMEM);
|
|
|
|
|
|
|
|
kref_init(&tg->refcount);
|
|
|
|
memcpy(tg->group_data, topology, 8);
|
|
|
|
tg->dev = dev;
|
|
|
|
|
|
|
|
mutex_lock(&dev->mode_config.idr_mutex);
|
|
|
|
ret = idr_alloc(&dev->mode_config.tile_idr, tg, 1, 0, GFP_KERNEL);
|
|
|
|
if (ret >= 0) {
|
|
|
|
tg->id = ret;
|
|
|
|
} else {
|
|
|
|
kfree(tg);
|
|
|
|
tg = ERR_PTR(ret);
|
|
|
|
}
|
|
|
|
|
|
|
|
mutex_unlock(&dev->mode_config.idr_mutex);
|
|
|
|
return tg;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(drm_mode_create_tile_group);
|