2009-06-05 12:42:42 +00:00
|
|
|
/*
|
|
|
|
|
* Copyright 2007-8 Advanced Micro Devices, Inc.
|
|
|
|
|
* Copyright 2008 Red Hat Inc.
|
|
|
|
|
*
|
|
|
|
|
* Permission is hereby granted, free of charge, to any person obtaining a
|
|
|
|
|
* copy of this software and associated documentation files (the "Software"),
|
|
|
|
|
* to deal in the Software without restriction, including without limitation
|
|
|
|
|
* the rights to use, copy, modify, merge, publish, distribute, sublicense,
|
|
|
|
|
* and/or sell copies of the Software, and to permit persons to whom the
|
|
|
|
|
* Software is furnished to do so, subject to the following conditions:
|
|
|
|
|
*
|
|
|
|
|
* The above copyright notice and this permission notice shall be included in
|
|
|
|
|
* all copies or substantial portions of the Software.
|
|
|
|
|
*
|
|
|
|
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
|
|
|
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
|
|
|
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
|
|
|
|
|
* THE COPYRIGHT HOLDER(S) OR AUTHOR(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR
|
|
|
|
|
* OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
|
|
|
|
|
* ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
|
|
|
|
|
* OTHER DEALINGS IN THE SOFTWARE.
|
|
|
|
|
*
|
|
|
|
|
* Authors: Dave Airlie
|
|
|
|
|
* Alex Deucher
|
|
|
|
|
*/
|
2012-10-02 17:01:07 +00:00
|
|
|
#include <drm/drmP.h>
|
|
|
|
|
#include <drm/drm_edid.h>
|
|
|
|
|
#include <drm/drm_crtc_helper.h>
|
|
|
|
|
#include <drm/drm_fb_helper.h>
|
2015-02-23 23:24:04 +00:00
|
|
|
#include <drm/drm_dp_mst_helper.h>
|
2012-10-02 17:01:07 +00:00
|
|
|
#include <drm/radeon_drm.h>
|
2009-06-05 12:42:42 +00:00
|
|
|
#include "radeon.h"
|
2014-12-01 18:49:39 +00:00
|
|
|
#include "radeon_audio.h"
|
2009-09-10 21:53:39 +00:00
|
|
|
#include "atom.h"
|
2009-06-05 12:42:42 +00:00
|
|
|
|
2012-09-17 04:40:31 +00:00
|
|
|
#include <linux/pm_runtime.h>
|
2016-01-11 19:09:20 +00:00
|
|
|
#include <linux/vga_switcheroo.h>
|
2012-09-17 04:40:31 +00:00
|
|
|
|
2015-02-23 23:24:04 +00:00
|
|
|
static int radeon_dp_handle_hpd(struct drm_connector *connector)
|
|
|
|
|
{
|
|
|
|
|
struct radeon_connector *radeon_connector = to_radeon_connector(connector);
|
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
|
|
ret = radeon_dp_mst_check_status(radeon_connector);
|
|
|
|
|
if (ret == -EINVAL)
|
|
|
|
|
return 1;
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
2009-12-04 21:56:37 +00:00
|
|
|
void radeon_connector_hotplug(struct drm_connector *connector)
|
|
|
|
|
{
|
|
|
|
|
struct drm_device *dev = connector->dev;
|
|
|
|
|
struct radeon_device *rdev = dev->dev_private;
|
|
|
|
|
struct radeon_connector *radeon_connector = to_radeon_connector(connector);
|
|
|
|
|
|
2015-02-23 23:24:04 +00:00
|
|
|
if (connector->connector_type == DRM_MODE_CONNECTOR_DisplayPort) {
|
|
|
|
|
struct radeon_connector_atom_dig *dig_connector =
|
|
|
|
|
radeon_connector->con_priv;
|
|
|
|
|
|
|
|
|
|
if (radeon_connector->is_mst_connector)
|
|
|
|
|
return;
|
|
|
|
|
if (dig_connector->is_mst) {
|
|
|
|
|
radeon_dp_handle_hpd(connector);
|
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
}
|
2011-07-11 14:49:28 +00:00
|
|
|
/* bail if the connector does not have hpd pin, e.g.,
|
|
|
|
|
* VGA, TV, etc.
|
|
|
|
|
*/
|
|
|
|
|
if (radeon_connector->hpd.hpd == RADEON_HPD_NONE)
|
|
|
|
|
return;
|
|
|
|
|
|
2011-05-20 08:34:29 +00:00
|
|
|
radeon_hpd_set_polarity(rdev, radeon_connector->hpd.hpd);
|
2009-12-04 21:56:37 +00:00
|
|
|
|
2011-08-09 17:09:06 +00:00
|
|
|
/* if the connector is already off, don't turn it back on */
|
drm: Split connection_mutex out of mode_config.mutex (v3)
After the split-out of crtc locks from the big mode_config.mutex
there's still two major areas it protects:
- Various connector probe states, like connector->status, EDID
properties, probed mode lists and similar information.
- The links from connector->encoder and encoder->crtc and other
modeset-relevant connector state (e.g. properties which control the
panel fitter).
The later is used by modeset operations. But they don't really care
about the former since it's allowed to e.g. enable a disconnected VGA
output or with a mode not in the probed list.
Thus far this hasn't been a problem, but for the atomic modeset
conversion Rob Clark needs to convert all modeset relevant locks into
w/w locks. This is required because the order of acquisition is
determined by how userspace supplies the atomic modeset data. This has
run into troubles in the detect path since the i915 load detect code
needs _both_ protections offered by the mode_config.mutex: It updates
probe state and it needs to change the modeset configuration to enable
the temporary load detect pipe.
The big deal here is that for the probe/detect users of this lock a
plain mutex fits best, but for atomic modesets we really want a w/w
mutex. To fix this lets split out a new connection_mutex lock for the
modeset relevant parts.
For simplicity I've decided to only add one additional lock for all
connector/encoder links and modeset configuration states. We have
piles of different modeset objects in addition to those (like bridges
or panels), so adding per-object locks would be much more effort.
Also, we're guaranteed (at least for now) to do a full modeset if we
need to acquire this lock. Which means that fine-grained locking is
fairly irrelevant compared to the amount of time the full modeset will
take.
I've done a full audit, and there's just a few things that justify
special focus:
- Locking in drm_sysfs.c is almost completely absent. We should
sprinkle mode_config.connection_mutex over this file a bit, but
since it already lacks mode_config.mutex this patch wont make the
situation any worse. This is material for a follow-up patch.
- omap has a omap_framebuffer_flush function which walks the
connector->encoder->crtc links and is called from many contexts.
Some look like they don't acquire mode_config.mutex, so this is
already racy. Again fixing this is material for a separate patch.
- The radeon hot_plug function to retrain DP links looks at
connector->dpms. Currently this happens without any locking, so is
already racy. I think radeon_hotplug_work_func should gain
mutex_lock/unlock calls for the mode_config.connection_mutex.
- Same applies to i915's intel_dp_hot_plug. But again, this is already
racy.
- i915 load_detect code needs to acquire this lock. Which means the
w/w dance due to Rob's work will be nicely contained to _just_ this
function.
I've added fixme comments everywhere where it looks suspicious but in
the sysfs code. After a quick irc discussion with Dave Airlie it
sounds like the lack of locking in there is due to sysfs cleanup fun
at module unload.
v1: original (only compile tested)
v2: missing mutex_init(), etc (from Rob Clark)
v3: i915 needs more care in the conversion:
- Protect the edp pp logic with the connection_mutex.
- Use connection_mutex in the backlight code due to
get_pipe_from_connector.
- Use drm_modeset_lock_all in suspend/resume paths.
- Update lock checks in the overlay code.
Cc: Alex Deucher <alexdeucher@gmail.com>
Cc: Rob Clark <robdclark@gmail.com>
Signed-off-by: Daniel Vetter <daniel.vetter@ffwll.ch>
Reviewed-by: Rob Clark <robdclark@gmail.com>
2014-05-29 21:54:47 +00:00
|
|
|
/* FIXME: This access isn't protected by any locks. */
|
2011-08-09 17:09:06 +00:00
|
|
|
if (connector->dpms != DRM_MODE_DPMS_ON)
|
|
|
|
|
return;
|
|
|
|
|
|
2011-08-13 17:36:13 +00:00
|
|
|
/* just deal with DP (not eDP) here. */
|
|
|
|
|
if (connector->connector_type == DRM_MODE_CONNECTOR_DisplayPort) {
|
2012-07-19 21:15:56 +00:00
|
|
|
struct radeon_connector_atom_dig *dig_connector =
|
|
|
|
|
radeon_connector->con_priv;
|
2011-05-20 08:34:30 +00:00
|
|
|
|
2012-07-19 21:15:56 +00:00
|
|
|
/* if existing sink type was not DP no need to retrain */
|
|
|
|
|
if (dig_connector->dp_sink_type != CONNECTOR_OBJECT_ID_DISPLAYPORT)
|
|
|
|
|
return;
|
|
|
|
|
|
|
|
|
|
/* first get sink type as it may be reset after (un)plug */
|
|
|
|
|
dig_connector->dp_sink_type = radeon_dp_getsinktype(radeon_connector);
|
|
|
|
|
/* don't do anything if sink is not display port, i.e.,
|
|
|
|
|
* passive dp->(dvi|hdmi) adaptor
|
|
|
|
|
*/
|
|
|
|
|
if (dig_connector->dp_sink_type == CONNECTOR_OBJECT_ID_DISPLAYPORT) {
|
|
|
|
|
int saved_dpms = connector->dpms;
|
|
|
|
|
/* Only turn off the display if it's physically disconnected */
|
2012-07-19 21:25:55 +00:00
|
|
|
if (!radeon_hpd_sense(rdev, radeon_connector->hpd.hpd)) {
|
2012-07-19 21:15:56 +00:00
|
|
|
drm_helper_connector_dpms(connector, DRM_MODE_DPMS_OFF);
|
2012-07-19 21:25:55 +00:00
|
|
|
} else if (radeon_dp_needs_link_train(radeon_connector)) {
|
DRM - radeon: Don't link train DisplayPort on HPD until we get the dpcd
Most of the time this isn't an issue since hotplugging an adaptor will
trigger a crtc mode change which in turn, causes the driver to probe
every DisplayPort for a dpcd. However, in cases where hotplugging
doesn't cause a mode change (specifically when one unplugs a monitor
from a DisplayPort connector, then plugs that same monitor back in
seconds later on the same port without any other monitors connected), we
never probe for the dpcd before starting the initial link training. What
happens from there looks like this:
- GPU has only one monitor connected. It's connected via
DisplayPort, and does not go through an adaptor of any sort.
- User unplugs DisplayPort connector from GPU.
- Change in HPD is detected by the driver, we probe every
DisplayPort for a possible connection.
- Probe the port the user originally had the monitor connected
on for it's dpcd. This fails, and we clear the first (and only
the first) byte of the dpcd to indicate we no longer have a
dpcd for this port.
- User plugs the previously disconnected monitor back into the
same DisplayPort.
- radeon_connector_hotplug() is called before everyone else,
and tries to handle the link training. Since only the first
byte of the dpcd is zeroed, the driver is able to complete
link training but does so against the wrong dpcd, causing it
to initialize the link with the wrong settings.
- Display stays blank (usually), dpcd is probed after the
initial link training, and the driver prints no obvious
messages to the log.
In theory, since only one byte of the dpcd is chopped off (specifically,
the byte that contains the revision information for DisplayPort), it's
not entirely impossible that this bug may not show on certain monitors.
For instance, the only reason this bug was visible on my ASUS PB238
monitor was due to the fact that this monitor using the enhanced framing
symbol sequence, the flag for which is ignored if the radeon driver
thinks that the DisplayPort version is below 1.1.
Signed-off-by: Stephen Chandler Paul <cpaul@redhat.com>
Reviewed-by: Jerome Glisse <jglisse@redhat.com>
Signed-off-by: Alex Deucher <alexander.deucher@amd.com>
Cc: stable@vger.kernel.org
2015-08-21 18:16:12 +00:00
|
|
|
/* Don't try to start link training before we
|
|
|
|
|
* have the dpcd */
|
|
|
|
|
if (!radeon_dp_getdpcd(radeon_connector))
|
|
|
|
|
return;
|
|
|
|
|
|
2012-07-19 21:25:55 +00:00
|
|
|
/* set it to OFF so that drm_helper_connector_dpms()
|
|
|
|
|
* won't return immediately since the current state
|
|
|
|
|
* is ON at this point.
|
|
|
|
|
*/
|
|
|
|
|
connector->dpms = DRM_MODE_DPMS_OFF;
|
2012-07-19 21:15:56 +00:00
|
|
|
drm_helper_connector_dpms(connector, DRM_MODE_DPMS_ON);
|
2012-07-19 21:25:55 +00:00
|
|
|
}
|
2012-07-19 21:15:56 +00:00
|
|
|
connector->dpms = saved_dpms;
|
|
|
|
|
}
|
2009-12-04 21:56:37 +00:00
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2009-09-09 07:40:54 +00:00
|
|
|
static void radeon_property_change_mode(struct drm_encoder *encoder)
|
|
|
|
|
{
|
|
|
|
|
struct drm_crtc *crtc = encoder->crtc;
|
|
|
|
|
|
|
|
|
|
if (crtc && crtc->enabled) {
|
|
|
|
|
drm_crtc_helper_set_mode(crtc, &crtc->mode,
|
2014-04-01 22:22:40 +00:00
|
|
|
crtc->x, crtc->y, crtc->primary->fb);
|
2009-09-09 07:40:54 +00:00
|
|
|
}
|
|
|
|
|
}
|
2012-03-26 19:12:54 +00:00
|
|
|
|
|
|
|
|
int radeon_get_monitor_bpc(struct drm_connector *connector)
|
|
|
|
|
{
|
|
|
|
|
struct drm_device *dev = connector->dev;
|
|
|
|
|
struct radeon_device *rdev = dev->dev_private;
|
|
|
|
|
struct radeon_connector *radeon_connector = to_radeon_connector(connector);
|
|
|
|
|
struct radeon_connector_atom_dig *dig_connector;
|
|
|
|
|
int bpc = 8;
|
2014-06-05 13:58:24 +00:00
|
|
|
int mode_clock, max_tmds_clock;
|
2012-03-26 19:12:54 +00:00
|
|
|
|
|
|
|
|
switch (connector->connector_type) {
|
|
|
|
|
case DRM_MODE_CONNECTOR_DVII:
|
|
|
|
|
case DRM_MODE_CONNECTOR_HDMIB:
|
|
|
|
|
if (radeon_connector->use_digital) {
|
2014-07-15 15:00:47 +00:00
|
|
|
if (drm_detect_hdmi_monitor(radeon_connector_edid(connector))) {
|
2012-03-26 19:12:54 +00:00
|
|
|
if (connector->display_info.bpc)
|
|
|
|
|
bpc = connector->display_info.bpc;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
break;
|
|
|
|
|
case DRM_MODE_CONNECTOR_DVID:
|
|
|
|
|
case DRM_MODE_CONNECTOR_HDMIA:
|
2014-07-15 15:00:47 +00:00
|
|
|
if (drm_detect_hdmi_monitor(radeon_connector_edid(connector))) {
|
2012-03-26 19:12:54 +00:00
|
|
|
if (connector->display_info.bpc)
|
|
|
|
|
bpc = connector->display_info.bpc;
|
|
|
|
|
}
|
|
|
|
|
break;
|
|
|
|
|
case DRM_MODE_CONNECTOR_DisplayPort:
|
|
|
|
|
dig_connector = radeon_connector->con_priv;
|
|
|
|
|
if ((dig_connector->dp_sink_type == CONNECTOR_OBJECT_ID_DISPLAYPORT) ||
|
|
|
|
|
(dig_connector->dp_sink_type == CONNECTOR_OBJECT_ID_eDP) ||
|
2014-07-15 15:00:47 +00:00
|
|
|
drm_detect_hdmi_monitor(radeon_connector_edid(connector))) {
|
2012-03-26 19:12:54 +00:00
|
|
|
if (connector->display_info.bpc)
|
|
|
|
|
bpc = connector->display_info.bpc;
|
|
|
|
|
}
|
|
|
|
|
break;
|
|
|
|
|
case DRM_MODE_CONNECTOR_eDP:
|
|
|
|
|
case DRM_MODE_CONNECTOR_LVDS:
|
|
|
|
|
if (connector->display_info.bpc)
|
|
|
|
|
bpc = connector->display_info.bpc;
|
|
|
|
|
else if (ASIC_IS_DCE41(rdev) || ASIC_IS_DCE5(rdev)) {
|
2015-03-11 09:51:02 +00:00
|
|
|
const struct drm_connector_helper_funcs *connector_funcs =
|
2012-03-26 19:12:54 +00:00
|
|
|
connector->helper_private;
|
|
|
|
|
struct drm_encoder *encoder = connector_funcs->best_encoder(connector);
|
|
|
|
|
struct radeon_encoder *radeon_encoder = to_radeon_encoder(encoder);
|
|
|
|
|
struct radeon_encoder_atom_dig *dig = radeon_encoder->enc_priv;
|
|
|
|
|
|
|
|
|
|
if (dig->lcd_misc & ATOM_PANEL_MISC_V13_6BIT_PER_COLOR)
|
|
|
|
|
bpc = 6;
|
|
|
|
|
else if (dig->lcd_misc & ATOM_PANEL_MISC_V13_8BIT_PER_COLOR)
|
|
|
|
|
bpc = 8;
|
|
|
|
|
}
|
|
|
|
|
break;
|
|
|
|
|
}
|
2014-05-05 21:03:18 +00:00
|
|
|
|
2014-07-15 15:00:47 +00:00
|
|
|
if (drm_detect_hdmi_monitor(radeon_connector_edid(connector))) {
|
2014-05-05 21:03:18 +00:00
|
|
|
/* hdmi deep color only implemented on DCE4+ */
|
|
|
|
|
if ((bpc > 8) && !ASIC_IS_DCE4(rdev)) {
|
|
|
|
|
DRM_DEBUG("%s: HDMI deep color %d bpc unsupported. Using 8 bpc.\n",
|
2014-06-03 11:56:19 +00:00
|
|
|
connector->name, bpc);
|
2014-05-05 21:03:18 +00:00
|
|
|
bpc = 8;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* Pre DCE-8 hw can't handle > 12 bpc, and more than 12 bpc doesn't make
|
|
|
|
|
* much sense without support for > 12 bpc framebuffers. RGB 4:4:4 at
|
|
|
|
|
* 12 bpc is always supported on hdmi deep color sinks, as this is
|
|
|
|
|
* required by the HDMI-1.3 spec. Clamp to a safe 12 bpc maximum.
|
|
|
|
|
*/
|
|
|
|
|
if (bpc > 12) {
|
|
|
|
|
DRM_DEBUG("%s: HDMI deep color %d bpc unsupported. Using 12 bpc.\n",
|
2014-06-03 11:56:19 +00:00
|
|
|
connector->name, bpc);
|
2014-05-05 21:03:18 +00:00
|
|
|
bpc = 12;
|
|
|
|
|
}
|
2014-06-05 13:58:24 +00:00
|
|
|
|
|
|
|
|
/* Any defined maximum tmds clock limit we must not exceed? */
|
2016-09-28 13:51:37 +00:00
|
|
|
if (connector->display_info.max_tmds_clock > 0) {
|
2014-06-05 13:58:24 +00:00
|
|
|
/* mode_clock is clock in kHz for mode to be modeset on this connector */
|
|
|
|
|
mode_clock = radeon_connector->pixelclock_for_modeset;
|
|
|
|
|
|
|
|
|
|
/* Maximum allowable input clock in kHz */
|
2016-09-28 13:51:37 +00:00
|
|
|
max_tmds_clock = connector->display_info.max_tmds_clock;
|
2014-06-05 13:58:24 +00:00
|
|
|
|
|
|
|
|
DRM_DEBUG("%s: hdmi mode dotclock %d kHz, max tmds input clock %d kHz.\n",
|
|
|
|
|
connector->name, mode_clock, max_tmds_clock);
|
|
|
|
|
|
|
|
|
|
/* Check if bpc is within clock limit. Try to degrade gracefully otherwise */
|
|
|
|
|
if ((bpc == 12) && (mode_clock * 3/2 > max_tmds_clock)) {
|
|
|
|
|
if ((connector->display_info.edid_hdmi_dc_modes & DRM_EDID_HDMI_DC_30) &&
|
|
|
|
|
(mode_clock * 5/4 <= max_tmds_clock))
|
|
|
|
|
bpc = 10;
|
|
|
|
|
else
|
|
|
|
|
bpc = 8;
|
|
|
|
|
|
|
|
|
|
DRM_DEBUG("%s: HDMI deep color 12 bpc exceeds max tmds clock. Using %d bpc.\n",
|
|
|
|
|
connector->name, bpc);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if ((bpc == 10) && (mode_clock * 5/4 > max_tmds_clock)) {
|
|
|
|
|
bpc = 8;
|
|
|
|
|
DRM_DEBUG("%s: HDMI deep color 10 bpc exceeds max tmds clock. Using %d bpc.\n",
|
|
|
|
|
connector->name, bpc);
|
|
|
|
|
}
|
|
|
|
|
}
|
2014-08-05 03:23:11 +00:00
|
|
|
else if (bpc > 8) {
|
|
|
|
|
/* max_tmds_clock missing, but hdmi spec mandates it for deep color. */
|
|
|
|
|
DRM_DEBUG("%s: Required max tmds clock for HDMI deep color missing. Using 8 bpc.\n",
|
|
|
|
|
connector->name);
|
|
|
|
|
bpc = 8;
|
|
|
|
|
}
|
2014-05-05 21:03:18 +00:00
|
|
|
}
|
|
|
|
|
|
2014-08-05 03:23:11 +00:00
|
|
|
if ((radeon_deep_color == 0) && (bpc > 8)) {
|
|
|
|
|
DRM_DEBUG("%s: Deep color disabled. Set radeon module param deep_color=1 to enable.\n",
|
|
|
|
|
connector->name);
|
2014-07-01 15:23:03 +00:00
|
|
|
bpc = 8;
|
2014-08-05 03:23:11 +00:00
|
|
|
}
|
2014-07-01 15:23:03 +00:00
|
|
|
|
2014-05-05 21:03:18 +00:00
|
|
|
DRM_DEBUG("%s: Display bpc=%d, returned bpc=%d\n",
|
2014-06-03 11:56:19 +00:00
|
|
|
connector->name, connector->display_info.bpc, bpc);
|
2014-05-05 21:03:18 +00:00
|
|
|
|
2012-03-26 19:12:54 +00:00
|
|
|
return bpc;
|
|
|
|
|
}
|
|
|
|
|
|
2009-06-05 12:42:42 +00:00
|
|
|
static void
|
|
|
|
|
radeon_connector_update_scratch_regs(struct drm_connector *connector, enum drm_connector_status status)
|
|
|
|
|
{
|
|
|
|
|
struct drm_device *dev = connector->dev;
|
|
|
|
|
struct radeon_device *rdev = dev->dev_private;
|
|
|
|
|
struct drm_encoder *best_encoder = NULL;
|
|
|
|
|
struct drm_encoder *encoder = NULL;
|
2015-03-11 09:51:02 +00:00
|
|
|
const struct drm_connector_helper_funcs *connector_funcs = connector->helper_private;
|
2009-06-05 12:42:42 +00:00
|
|
|
bool connected;
|
|
|
|
|
int i;
|
|
|
|
|
|
|
|
|
|
best_encoder = connector_funcs->best_encoder(connector);
|
|
|
|
|
|
|
|
|
|
for (i = 0; i < DRM_CONNECTOR_MAX_ENCODER; i++) {
|
|
|
|
|
if (connector->encoder_ids[i] == 0)
|
|
|
|
|
break;
|
|
|
|
|
|
2014-07-18 03:30:05 +00:00
|
|
|
encoder = drm_encoder_find(connector->dev,
|
|
|
|
|
connector->encoder_ids[i]);
|
|
|
|
|
if (!encoder)
|
2009-06-05 12:42:42 +00:00
|
|
|
continue;
|
|
|
|
|
|
|
|
|
|
if ((encoder == best_encoder) && (status == connector_status_connected))
|
|
|
|
|
connected = true;
|
|
|
|
|
else
|
|
|
|
|
connected = false;
|
|
|
|
|
|
|
|
|
|
if (rdev->is_atom_bios)
|
|
|
|
|
radeon_atombios_connected_scratch_regs(connector, encoder, connected);
|
|
|
|
|
else
|
|
|
|
|
radeon_combios_connected_scratch_regs(connector, encoder, connected);
|
|
|
|
|
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2012-08-31 17:43:50 +00:00
|
|
|
static struct drm_encoder *radeon_find_encoder(struct drm_connector *connector, int encoder_type)
|
2009-09-09 07:40:54 +00:00
|
|
|
{
|
|
|
|
|
struct drm_encoder *encoder;
|
|
|
|
|
int i;
|
|
|
|
|
|
|
|
|
|
for (i = 0; i < DRM_CONNECTOR_MAX_ENCODER; i++) {
|
|
|
|
|
if (connector->encoder_ids[i] == 0)
|
|
|
|
|
break;
|
|
|
|
|
|
2014-07-18 03:30:05 +00:00
|
|
|
encoder = drm_encoder_find(connector->dev, connector->encoder_ids[i]);
|
|
|
|
|
if (!encoder)
|
2009-09-09 07:40:54 +00:00
|
|
|
continue;
|
|
|
|
|
|
|
|
|
|
if (encoder->encoder_type == encoder_type)
|
|
|
|
|
return encoder;
|
|
|
|
|
}
|
|
|
|
|
return NULL;
|
|
|
|
|
}
|
|
|
|
|
|
2014-07-15 15:00:47 +00:00
|
|
|
struct edid *radeon_connector_edid(struct drm_connector *connector)
|
|
|
|
|
{
|
|
|
|
|
struct radeon_connector *radeon_connector = to_radeon_connector(connector);
|
|
|
|
|
struct drm_property_blob *edid_blob = connector->edid_blob_ptr;
|
|
|
|
|
|
|
|
|
|
if (radeon_connector->edid) {
|
|
|
|
|
return radeon_connector->edid;
|
|
|
|
|
} else if (edid_blob) {
|
|
|
|
|
struct edid *edid = kmemdup(edid_blob->data, edid_blob->length, GFP_KERNEL);
|
|
|
|
|
if (edid)
|
|
|
|
|
radeon_connector->edid = edid;
|
|
|
|
|
}
|
|
|
|
|
return radeon_connector->edid;
|
|
|
|
|
}
|
|
|
|
|
|
2014-07-15 14:38:10 +00:00
|
|
|
static void radeon_connector_get_edid(struct drm_connector *connector)
|
|
|
|
|
{
|
|
|
|
|
struct drm_device *dev = connector->dev;
|
|
|
|
|
struct radeon_device *rdev = dev->dev_private;
|
|
|
|
|
struct radeon_connector *radeon_connector = to_radeon_connector(connector);
|
|
|
|
|
|
|
|
|
|
if (radeon_connector->edid)
|
|
|
|
|
return;
|
|
|
|
|
|
|
|
|
|
/* on hw with routers, select right port */
|
|
|
|
|
if (radeon_connector->router.ddc_valid)
|
|
|
|
|
radeon_router_select_ddc_port(radeon_connector);
|
|
|
|
|
|
|
|
|
|
if ((radeon_connector_encoder_get_dp_bridge_encoder_id(connector) !=
|
|
|
|
|
ENCODER_OBJECT_ID_NONE) &&
|
|
|
|
|
radeon_connector->ddc_bus->has_aux) {
|
|
|
|
|
radeon_connector->edid = drm_get_edid(connector,
|
|
|
|
|
&radeon_connector->ddc_bus->aux.ddc);
|
|
|
|
|
} else if ((connector->connector_type == DRM_MODE_CONNECTOR_DisplayPort) ||
|
|
|
|
|
(connector->connector_type == DRM_MODE_CONNECTOR_eDP)) {
|
|
|
|
|
struct radeon_connector_atom_dig *dig = radeon_connector->con_priv;
|
|
|
|
|
|
|
|
|
|
if ((dig->dp_sink_type == CONNECTOR_OBJECT_ID_DISPLAYPORT ||
|
|
|
|
|
dig->dp_sink_type == CONNECTOR_OBJECT_ID_eDP) &&
|
|
|
|
|
radeon_connector->ddc_bus->has_aux)
|
|
|
|
|
radeon_connector->edid = drm_get_edid(&radeon_connector->base,
|
|
|
|
|
&radeon_connector->ddc_bus->aux.ddc);
|
|
|
|
|
else if (radeon_connector->ddc_bus)
|
|
|
|
|
radeon_connector->edid = drm_get_edid(&radeon_connector->base,
|
|
|
|
|
&radeon_connector->ddc_bus->adapter);
|
2016-01-11 19:09:20 +00:00
|
|
|
} else if (vga_switcheroo_handler_flags() & VGA_SWITCHEROO_CAN_SWITCH_DDC &&
|
|
|
|
|
connector->connector_type == DRM_MODE_CONNECTOR_LVDS &&
|
|
|
|
|
radeon_connector->ddc_bus) {
|
|
|
|
|
radeon_connector->edid = drm_get_edid_switcheroo(&radeon_connector->base,
|
|
|
|
|
&radeon_connector->ddc_bus->adapter);
|
2014-07-15 14:38:10 +00:00
|
|
|
} else if (radeon_connector->ddc_bus) {
|
|
|
|
|
radeon_connector->edid = drm_get_edid(&radeon_connector->base,
|
|
|
|
|
&radeon_connector->ddc_bus->adapter);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (!radeon_connector->edid) {
|
2014-11-14 17:08:34 +00:00
|
|
|
/* don't fetch the edid from the vbios if ddc fails and runpm is
|
|
|
|
|
* enabled so we report disconnected.
|
|
|
|
|
*/
|
|
|
|
|
if ((rdev->flags & RADEON_IS_PX) && (radeon_runtime_pm != 0))
|
|
|
|
|
return;
|
|
|
|
|
|
2014-07-15 14:38:10 +00:00
|
|
|
if (rdev->is_atom_bios) {
|
|
|
|
|
/* some laptops provide a hardcoded edid in rom for LCDs */
|
|
|
|
|
if (((connector->connector_type == DRM_MODE_CONNECTOR_LVDS) ||
|
|
|
|
|
(connector->connector_type == DRM_MODE_CONNECTOR_eDP)))
|
|
|
|
|
radeon_connector->edid = radeon_bios_get_hardcoded_edid(rdev);
|
|
|
|
|
} else {
|
|
|
|
|
/* some servers provide a hardcoded edid in rom for KVMs */
|
|
|
|
|
radeon_connector->edid = radeon_bios_get_hardcoded_edid(rdev);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void radeon_connector_free_edid(struct drm_connector *connector)
|
|
|
|
|
{
|
|
|
|
|
struct radeon_connector *radeon_connector = to_radeon_connector(connector);
|
|
|
|
|
|
|
|
|
|
if (radeon_connector->edid) {
|
|
|
|
|
kfree(radeon_connector->edid);
|
|
|
|
|
radeon_connector->edid = NULL;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static int radeon_ddc_get_modes(struct drm_connector *connector)
|
|
|
|
|
{
|
|
|
|
|
struct radeon_connector *radeon_connector = to_radeon_connector(connector);
|
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
|
|
if (radeon_connector->edid) {
|
|
|
|
|
drm_mode_connector_update_edid_property(connector, radeon_connector->edid);
|
|
|
|
|
ret = drm_add_edid_modes(connector, radeon_connector->edid);
|
|
|
|
|
drm_edid_to_eld(connector, radeon_connector->edid);
|
|
|
|
|
return ret;
|
|
|
|
|
}
|
|
|
|
|
drm_mode_connector_update_edid_property(connector, NULL);
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
2012-08-31 17:43:50 +00:00
|
|
|
static struct drm_encoder *radeon_best_single_encoder(struct drm_connector *connector)
|
2009-06-05 12:42:42 +00:00
|
|
|
{
|
|
|
|
|
int enc_id = connector->encoder_ids[0];
|
|
|
|
|
/* pick the encoder ids */
|
2014-07-18 03:30:05 +00:00
|
|
|
if (enc_id)
|
|
|
|
|
return drm_encoder_find(connector->dev, enc_id);
|
2009-06-05 12:42:42 +00:00
|
|
|
return NULL;
|
|
|
|
|
}
|
|
|
|
|
|
2014-07-09 17:21:59 +00:00
|
|
|
static void radeon_get_native_mode(struct drm_connector *connector)
|
|
|
|
|
{
|
|
|
|
|
struct drm_encoder *encoder = radeon_best_single_encoder(connector);
|
|
|
|
|
struct radeon_encoder *radeon_encoder;
|
|
|
|
|
|
|
|
|
|
if (encoder == NULL)
|
|
|
|
|
return;
|
|
|
|
|
|
|
|
|
|
radeon_encoder = to_radeon_encoder(encoder);
|
|
|
|
|
|
|
|
|
|
if (!list_empty(&connector->probed_modes)) {
|
|
|
|
|
struct drm_display_mode *preferred_mode =
|
|
|
|
|
list_first_entry(&connector->probed_modes,
|
|
|
|
|
struct drm_display_mode, head);
|
|
|
|
|
|
|
|
|
|
radeon_encoder->native_mode = *preferred_mode;
|
|
|
|
|
} else {
|
|
|
|
|
radeon_encoder->native_mode.clock = 0;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2009-08-13 06:32:14 +00:00
|
|
|
/*
|
|
|
|
|
* radeon_connector_analog_encoder_conflict_solve
|
|
|
|
|
* - search for other connectors sharing this encoder
|
|
|
|
|
* if priority is true, then set them disconnected if this is connected
|
|
|
|
|
* if priority is false, set us disconnected if they are connected
|
|
|
|
|
*/
|
|
|
|
|
static enum drm_connector_status
|
|
|
|
|
radeon_connector_analog_encoder_conflict_solve(struct drm_connector *connector,
|
|
|
|
|
struct drm_encoder *encoder,
|
|
|
|
|
enum drm_connector_status current_status,
|
|
|
|
|
bool priority)
|
|
|
|
|
{
|
|
|
|
|
struct drm_device *dev = connector->dev;
|
|
|
|
|
struct drm_connector *conflict;
|
2010-04-15 17:31:12 +00:00
|
|
|
struct radeon_connector *radeon_conflict;
|
2009-08-13 06:32:14 +00:00
|
|
|
int i;
|
|
|
|
|
|
|
|
|
|
list_for_each_entry(conflict, &dev->mode_config.connector_list, head) {
|
|
|
|
|
if (conflict == connector)
|
|
|
|
|
continue;
|
|
|
|
|
|
2010-04-15 17:31:12 +00:00
|
|
|
radeon_conflict = to_radeon_connector(conflict);
|
2009-08-13 06:32:14 +00:00
|
|
|
for (i = 0; i < DRM_CONNECTOR_MAX_ENCODER; i++) {
|
|
|
|
|
if (conflict->encoder_ids[i] == 0)
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
/* if the IDs match */
|
|
|
|
|
if (conflict->encoder_ids[i] == encoder->base.id) {
|
|
|
|
|
if (conflict->status != connector_status_connected)
|
|
|
|
|
continue;
|
2010-04-15 17:31:12 +00:00
|
|
|
|
|
|
|
|
if (radeon_conflict->use_digital)
|
|
|
|
|
continue;
|
2009-08-13 06:32:14 +00:00
|
|
|
|
|
|
|
|
if (priority == true) {
|
2014-06-03 11:56:19 +00:00
|
|
|
DRM_DEBUG_KMS("1: conflicting encoders switching off %s\n",
|
|
|
|
|
conflict->name);
|
|
|
|
|
DRM_DEBUG_KMS("in favor of %s\n",
|
|
|
|
|
connector->name);
|
2009-08-13 06:32:14 +00:00
|
|
|
conflict->status = connector_status_disconnected;
|
|
|
|
|
radeon_connector_update_scratch_regs(conflict, connector_status_disconnected);
|
|
|
|
|
} else {
|
2014-06-03 11:56:19 +00:00
|
|
|
DRM_DEBUG_KMS("2: conflicting encoders switching off %s\n",
|
|
|
|
|
connector->name);
|
|
|
|
|
DRM_DEBUG_KMS("in favor of %s\n",
|
|
|
|
|
conflict->name);
|
2009-08-13 06:32:14 +00:00
|
|
|
current_status = connector_status_disconnected;
|
|
|
|
|
}
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
return current_status;
|
|
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
2009-06-05 12:42:42 +00:00
|
|
|
static struct drm_display_mode *radeon_fp_native_mode(struct drm_encoder *encoder)
|
|
|
|
|
{
|
|
|
|
|
struct drm_device *dev = encoder->dev;
|
|
|
|
|
struct radeon_encoder *radeon_encoder = to_radeon_encoder(encoder);
|
|
|
|
|
struct drm_display_mode *mode = NULL;
|
2009-10-09 19:14:30 +00:00
|
|
|
struct drm_display_mode *native_mode = &radeon_encoder->native_mode;
|
2009-06-05 12:42:42 +00:00
|
|
|
|
2009-10-09 19:14:30 +00:00
|
|
|
if (native_mode->hdisplay != 0 &&
|
|
|
|
|
native_mode->vdisplay != 0 &&
|
|
|
|
|
native_mode->clock != 0) {
|
2009-10-12 15:25:05 +00:00
|
|
|
mode = drm_mode_duplicate(dev, native_mode);
|
2009-06-05 12:42:42 +00:00
|
|
|
mode->type = DRM_MODE_TYPE_PREFERRED | DRM_MODE_TYPE_DRIVER;
|
|
|
|
|
drm_mode_set_name(mode);
|
|
|
|
|
|
2010-08-02 00:42:55 +00:00
|
|
|
DRM_DEBUG_KMS("Adding native panel mode %s\n", mode->name);
|
2009-12-22 15:06:49 +00:00
|
|
|
} else if (native_mode->hdisplay != 0 &&
|
|
|
|
|
native_mode->vdisplay != 0) {
|
|
|
|
|
/* mac laptops without an edid */
|
|
|
|
|
/* Note that this is not necessarily the exact panel mode,
|
|
|
|
|
* but an approximation based on the cvt formula. For these
|
|
|
|
|
* systems we should ideally read the mode info out of the
|
|
|
|
|
* registers or add a mode table, but this works and is much
|
|
|
|
|
* simpler.
|
|
|
|
|
*/
|
|
|
|
|
mode = drm_cvt_mode(dev, native_mode->hdisplay, native_mode->vdisplay, 60, true, false, false);
|
|
|
|
|
mode->type = DRM_MODE_TYPE_PREFERRED | DRM_MODE_TYPE_DRIVER;
|
2010-08-02 00:42:55 +00:00
|
|
|
DRM_DEBUG_KMS("Adding cvt approximation of native panel mode %s\n", mode->name);
|
2009-06-05 12:42:42 +00:00
|
|
|
}
|
|
|
|
|
return mode;
|
|
|
|
|
}
|
|
|
|
|
|
2009-09-10 21:53:39 +00:00
|
|
|
static void radeon_add_common_modes(struct drm_encoder *encoder, struct drm_connector *connector)
|
|
|
|
|
{
|
|
|
|
|
struct drm_device *dev = encoder->dev;
|
|
|
|
|
struct radeon_encoder *radeon_encoder = to_radeon_encoder(encoder);
|
|
|
|
|
struct drm_display_mode *mode = NULL;
|
2009-10-09 19:14:30 +00:00
|
|
|
struct drm_display_mode *native_mode = &radeon_encoder->native_mode;
|
2009-09-10 21:53:39 +00:00
|
|
|
int i;
|
|
|
|
|
struct mode_size {
|
|
|
|
|
int w;
|
|
|
|
|
int h;
|
|
|
|
|
} common_modes[17] = {
|
|
|
|
|
{ 640, 480},
|
|
|
|
|
{ 720, 480},
|
|
|
|
|
{ 800, 600},
|
|
|
|
|
{ 848, 480},
|
|
|
|
|
{1024, 768},
|
|
|
|
|
{1152, 768},
|
|
|
|
|
{1280, 720},
|
|
|
|
|
{1280, 800},
|
|
|
|
|
{1280, 854},
|
|
|
|
|
{1280, 960},
|
|
|
|
|
{1280, 1024},
|
|
|
|
|
{1440, 900},
|
|
|
|
|
{1400, 1050},
|
|
|
|
|
{1680, 1050},
|
|
|
|
|
{1600, 1200},
|
|
|
|
|
{1920, 1080},
|
|
|
|
|
{1920, 1200}
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
for (i = 0; i < 17; i++) {
|
2009-10-13 16:48:44 +00:00
|
|
|
if (radeon_encoder->devices & (ATOM_DEVICE_TV_SUPPORT)) {
|
|
|
|
|
if (common_modes[i].w > 1024 ||
|
|
|
|
|
common_modes[i].h > 768)
|
|
|
|
|
continue;
|
|
|
|
|
}
|
2009-09-10 21:53:39 +00:00
|
|
|
if (radeon_encoder->devices & (ATOM_DEVICE_LCD_SUPPORT)) {
|
2009-10-09 19:14:30 +00:00
|
|
|
if (common_modes[i].w > native_mode->hdisplay ||
|
|
|
|
|
common_modes[i].h > native_mode->vdisplay ||
|
|
|
|
|
(common_modes[i].w == native_mode->hdisplay &&
|
|
|
|
|
common_modes[i].h == native_mode->vdisplay))
|
2009-09-10 21:53:39 +00:00
|
|
|
continue;
|
|
|
|
|
}
|
|
|
|
|
if (common_modes[i].w < 320 || common_modes[i].h < 200)
|
|
|
|
|
continue;
|
|
|
|
|
|
drm/kms: start adding command line interface using fb.
[note this requires an fb patch posted to linux-fbdev-devel already]
This uses the normal video= command line option to control the kms
output setup at boot time. It is used to override the autodetection
done by kms.
video= normally takes a framebuffer as the first parameter, in kms
it will take a connector name, DVI-I-1, or LVDS-1 etc. If no output
connector is specified the mode string will apply to all connectors.
The mode specification used will match down the probed modes, and if
no mode is found it will add a CVT mode that matches.
video=1024x768 - all connectors match a 1024x768 mode or add a CVT on
video=VGA-1:1024x768, VGA-1 connector gets mode only.
The same strings as used in current fb modedb.c are used, except I've
added three more letters, e, D, d, e = enable, D = enable Digital,
d = disable, which allow a connector to be forced into a certain state.
Signed-off-by: Dave Airlie <airlied@redhat.com>
2009-09-23 04:44:08 +00:00
|
|
|
mode = drm_cvt_mode(dev, common_modes[i].w, common_modes[i].h, 60, false, false, false);
|
2009-09-10 21:53:39 +00:00
|
|
|
drm_mode_probed_add(connector, mode);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2012-08-31 17:43:50 +00:00
|
|
|
static int radeon_connector_set_property(struct drm_connector *connector, struct drm_property *property,
|
2009-06-05 12:42:42 +00:00
|
|
|
uint64_t val)
|
|
|
|
|
{
|
2009-09-09 07:40:54 +00:00
|
|
|
struct drm_device *dev = connector->dev;
|
|
|
|
|
struct radeon_device *rdev = dev->dev_private;
|
|
|
|
|
struct drm_encoder *encoder;
|
|
|
|
|
struct radeon_encoder *radeon_encoder;
|
|
|
|
|
|
|
|
|
|
if (property == rdev->mode_info.coherent_mode_property) {
|
|
|
|
|
struct radeon_encoder_atom_dig *dig;
|
2010-04-09 06:27:00 +00:00
|
|
|
bool new_coherent_mode;
|
2009-09-09 07:40:54 +00:00
|
|
|
|
|
|
|
|
/* need to find digital encoder on connector */
|
|
|
|
|
encoder = radeon_find_encoder(connector, DRM_MODE_ENCODER_TMDS);
|
|
|
|
|
if (!encoder)
|
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
|
|
radeon_encoder = to_radeon_encoder(encoder);
|
|
|
|
|
|
|
|
|
|
if (!radeon_encoder->enc_priv)
|
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
|
|
dig = radeon_encoder->enc_priv;
|
2010-04-09 06:27:00 +00:00
|
|
|
new_coherent_mode = val ? true : false;
|
|
|
|
|
if (dig->coherent_mode != new_coherent_mode) {
|
|
|
|
|
dig->coherent_mode = new_coherent_mode;
|
|
|
|
|
radeon_property_change_mode(&radeon_encoder->base);
|
|
|
|
|
}
|
2009-09-09 07:40:54 +00:00
|
|
|
}
|
|
|
|
|
|
2013-09-03 18:58:44 +00:00
|
|
|
if (property == rdev->mode_info.audio_property) {
|
|
|
|
|
struct radeon_connector *radeon_connector = to_radeon_connector(connector);
|
|
|
|
|
/* need to find digital encoder on connector */
|
|
|
|
|
encoder = radeon_find_encoder(connector, DRM_MODE_ENCODER_TMDS);
|
|
|
|
|
if (!encoder)
|
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
|
|
radeon_encoder = to_radeon_encoder(encoder);
|
|
|
|
|
|
|
|
|
|
if (radeon_connector->audio != val) {
|
|
|
|
|
radeon_connector->audio = val;
|
|
|
|
|
radeon_property_change_mode(&radeon_encoder->base);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2013-09-24 21:26:26 +00:00
|
|
|
if (property == rdev->mode_info.dither_property) {
|
|
|
|
|
struct radeon_connector *radeon_connector = to_radeon_connector(connector);
|
|
|
|
|
/* need to find digital encoder on connector */
|
|
|
|
|
encoder = radeon_find_encoder(connector, DRM_MODE_ENCODER_TMDS);
|
|
|
|
|
if (!encoder)
|
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
|
|
radeon_encoder = to_radeon_encoder(encoder);
|
|
|
|
|
|
|
|
|
|
if (radeon_connector->dither != val) {
|
|
|
|
|
radeon_connector->dither = val;
|
|
|
|
|
radeon_property_change_mode(&radeon_encoder->base);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2010-08-03 23:59:20 +00:00
|
|
|
if (property == rdev->mode_info.underscan_property) {
|
|
|
|
|
/* need to find digital encoder on connector */
|
|
|
|
|
encoder = radeon_find_encoder(connector, DRM_MODE_ENCODER_TMDS);
|
|
|
|
|
if (!encoder)
|
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
|
|
radeon_encoder = to_radeon_encoder(encoder);
|
|
|
|
|
|
|
|
|
|
if (radeon_encoder->underscan_type != val) {
|
|
|
|
|
radeon_encoder->underscan_type = val;
|
|
|
|
|
radeon_property_change_mode(&radeon_encoder->base);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2010-09-21 19:30:59 +00:00
|
|
|
if (property == rdev->mode_info.underscan_hborder_property) {
|
|
|
|
|
/* need to find digital encoder on connector */
|
|
|
|
|
encoder = radeon_find_encoder(connector, DRM_MODE_ENCODER_TMDS);
|
|
|
|
|
if (!encoder)
|
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
|
|
radeon_encoder = to_radeon_encoder(encoder);
|
|
|
|
|
|
|
|
|
|
if (radeon_encoder->underscan_hborder != val) {
|
|
|
|
|
radeon_encoder->underscan_hborder = val;
|
|
|
|
|
radeon_property_change_mode(&radeon_encoder->base);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (property == rdev->mode_info.underscan_vborder_property) {
|
|
|
|
|
/* need to find digital encoder on connector */
|
|
|
|
|
encoder = radeon_find_encoder(connector, DRM_MODE_ENCODER_TMDS);
|
|
|
|
|
if (!encoder)
|
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
|
|
radeon_encoder = to_radeon_encoder(encoder);
|
|
|
|
|
|
|
|
|
|
if (radeon_encoder->underscan_vborder != val) {
|
|
|
|
|
radeon_encoder->underscan_vborder = val;
|
|
|
|
|
radeon_property_change_mode(&radeon_encoder->base);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2009-09-09 07:40:54 +00:00
|
|
|
if (property == rdev->mode_info.tv_std_property) {
|
|
|
|
|
encoder = radeon_find_encoder(connector, DRM_MODE_ENCODER_TVDAC);
|
|
|
|
|
if (!encoder) {
|
|
|
|
|
encoder = radeon_find_encoder(connector, DRM_MODE_ENCODER_DAC);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (!encoder)
|
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
|
|
radeon_encoder = to_radeon_encoder(encoder);
|
|
|
|
|
if (!radeon_encoder->enc_priv)
|
|
|
|
|
return 0;
|
2010-04-06 03:57:52 +00:00
|
|
|
if (ASIC_IS_AVIVO(rdev) || radeon_r4xx_atom) {
|
2009-09-09 07:40:54 +00:00
|
|
|
struct radeon_encoder_atom_dac *dac_int;
|
|
|
|
|
dac_int = radeon_encoder->enc_priv;
|
|
|
|
|
dac_int->tv_std = val;
|
|
|
|
|
} else {
|
|
|
|
|
struct radeon_encoder_tv_dac *dac_int;
|
|
|
|
|
dac_int = radeon_encoder->enc_priv;
|
|
|
|
|
dac_int->tv_std = val;
|
|
|
|
|
}
|
|
|
|
|
radeon_property_change_mode(&radeon_encoder->base);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (property == rdev->mode_info.load_detect_property) {
|
|
|
|
|
struct radeon_connector *radeon_connector =
|
|
|
|
|
to_radeon_connector(connector);
|
|
|
|
|
|
|
|
|
|
if (val == 0)
|
|
|
|
|
radeon_connector->dac_load_detect = false;
|
|
|
|
|
else
|
|
|
|
|
radeon_connector->dac_load_detect = true;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (property == rdev->mode_info.tmds_pll_property) {
|
|
|
|
|
struct radeon_encoder_int_tmds *tmds = NULL;
|
|
|
|
|
bool ret = false;
|
|
|
|
|
/* need to find digital encoder on connector */
|
|
|
|
|
encoder = radeon_find_encoder(connector, DRM_MODE_ENCODER_TMDS);
|
|
|
|
|
if (!encoder)
|
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
|
|
radeon_encoder = to_radeon_encoder(encoder);
|
|
|
|
|
|
|
|
|
|
tmds = radeon_encoder->enc_priv;
|
|
|
|
|
if (!tmds)
|
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
|
|
if (val == 0) {
|
|
|
|
|
if (rdev->is_atom_bios)
|
|
|
|
|
ret = radeon_atombios_get_tmds_info(radeon_encoder, tmds);
|
|
|
|
|
else
|
|
|
|
|
ret = radeon_legacy_get_tmds_info_from_combios(radeon_encoder, tmds);
|
|
|
|
|
}
|
|
|
|
|
if (val == 1 || ret == false) {
|
|
|
|
|
radeon_legacy_get_tmds_info_from_table(radeon_encoder, tmds);
|
|
|
|
|
}
|
|
|
|
|
radeon_property_change_mode(&radeon_encoder->base);
|
|
|
|
|
}
|
|
|
|
|
|
2014-07-09 17:21:59 +00:00
|
|
|
if (property == dev->mode_config.scaling_mode_property) {
|
|
|
|
|
enum radeon_rmx_type rmx_type;
|
|
|
|
|
|
|
|
|
|
if (connector->encoder)
|
|
|
|
|
radeon_encoder = to_radeon_encoder(connector->encoder);
|
|
|
|
|
else {
|
2015-03-11 09:51:02 +00:00
|
|
|
const struct drm_connector_helper_funcs *connector_funcs = connector->helper_private;
|
2014-07-09 17:21:59 +00:00
|
|
|
radeon_encoder = to_radeon_encoder(connector_funcs->best_encoder(connector));
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
switch (val) {
|
|
|
|
|
default:
|
|
|
|
|
case DRM_MODE_SCALE_NONE: rmx_type = RMX_OFF; break;
|
|
|
|
|
case DRM_MODE_SCALE_CENTER: rmx_type = RMX_CENTER; break;
|
|
|
|
|
case DRM_MODE_SCALE_ASPECT: rmx_type = RMX_ASPECT; break;
|
|
|
|
|
case DRM_MODE_SCALE_FULLSCREEN: rmx_type = RMX_FULL; break;
|
|
|
|
|
}
|
|
|
|
|
if (radeon_encoder->rmx_type == rmx_type)
|
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
|
|
if ((rmx_type != DRM_MODE_SCALE_NONE) &&
|
|
|
|
|
(radeon_encoder->native_mode.clock == 0))
|
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
|
|
radeon_encoder->rmx_type = rmx_type;
|
|
|
|
|
|
|
|
|
|
radeon_property_change_mode(&radeon_encoder->base);
|
|
|
|
|
}
|
|
|
|
|
|
2015-02-23 15:59:36 +00:00
|
|
|
if (property == rdev->mode_info.output_csc_property) {
|
|
|
|
|
if (connector->encoder)
|
|
|
|
|
radeon_encoder = to_radeon_encoder(connector->encoder);
|
|
|
|
|
else {
|
2015-04-13 08:21:40 +00:00
|
|
|
const struct drm_connector_helper_funcs *connector_funcs = connector->helper_private;
|
2015-02-23 15:59:36 +00:00
|
|
|
radeon_encoder = to_radeon_encoder(connector_funcs->best_encoder(connector));
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (radeon_encoder->output_csc == val)
|
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
|
|
radeon_encoder->output_csc = val;
|
|
|
|
|
|
|
|
|
|
if (connector->encoder->crtc) {
|
|
|
|
|
struct drm_crtc *crtc = connector->encoder->crtc;
|
2015-04-13 08:21:40 +00:00
|
|
|
const struct drm_crtc_helper_funcs *crtc_funcs = crtc->helper_private;
|
2015-02-23 15:59:36 +00:00
|
|
|
struct radeon_crtc *radeon_crtc = to_radeon_crtc(crtc);
|
|
|
|
|
|
|
|
|
|
radeon_crtc->output_csc = radeon_encoder->output_csc;
|
|
|
|
|
|
|
|
|
|
(*crtc_funcs->load_lut)(crtc);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2009-06-05 12:42:42 +00:00
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
2009-09-15 15:09:27 +00:00
|
|
|
static void radeon_fixup_lvds_native_mode(struct drm_encoder *encoder,
|
|
|
|
|
struct drm_connector *connector)
|
|
|
|
|
{
|
|
|
|
|
struct radeon_encoder *radeon_encoder = to_radeon_encoder(encoder);
|
2009-10-09 19:14:30 +00:00
|
|
|
struct drm_display_mode *native_mode = &radeon_encoder->native_mode;
|
2011-08-08 16:21:15 +00:00
|
|
|
struct drm_display_mode *t, *mode;
|
|
|
|
|
|
|
|
|
|
/* If the EDID preferred mode doesn't match the native mode, use it */
|
|
|
|
|
list_for_each_entry_safe(mode, t, &connector->probed_modes, head) {
|
|
|
|
|
if (mode->type & DRM_MODE_TYPE_PREFERRED) {
|
|
|
|
|
if (mode->hdisplay != native_mode->hdisplay ||
|
|
|
|
|
mode->vdisplay != native_mode->vdisplay)
|
|
|
|
|
memcpy(native_mode, mode, sizeof(*mode));
|
|
|
|
|
}
|
|
|
|
|
}
|
2009-09-15 15:09:27 +00:00
|
|
|
|
|
|
|
|
/* Try to get native mode details from EDID if necessary */
|
2009-10-09 19:14:30 +00:00
|
|
|
if (!native_mode->clock) {
|
2009-09-15 15:09:27 +00:00
|
|
|
list_for_each_entry_safe(mode, t, &connector->probed_modes, head) {
|
2009-10-09 19:14:30 +00:00
|
|
|
if (mode->hdisplay == native_mode->hdisplay &&
|
|
|
|
|
mode->vdisplay == native_mode->vdisplay) {
|
|
|
|
|
*native_mode = *mode;
|
|
|
|
|
drm_mode_set_crtcinfo(native_mode, CRTC_INTERLACE_HALVE_V);
|
2010-10-29 17:49:25 +00:00
|
|
|
DRM_DEBUG_KMS("Determined LVDS native mode details from EDID\n");
|
2009-09-15 15:09:27 +00:00
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
2011-08-08 16:21:15 +00:00
|
|
|
|
2009-10-09 19:14:30 +00:00
|
|
|
if (!native_mode->clock) {
|
2010-10-29 17:49:25 +00:00
|
|
|
DRM_DEBUG_KMS("No LVDS native mode details, disabling RMX\n");
|
2009-09-15 15:09:27 +00:00
|
|
|
radeon_encoder->rmx_type = RMX_OFF;
|
|
|
|
|
}
|
|
|
|
|
}
|
2009-06-05 12:42:42 +00:00
|
|
|
|
|
|
|
|
static int radeon_lvds_get_modes(struct drm_connector *connector)
|
|
|
|
|
{
|
|
|
|
|
struct drm_encoder *encoder;
|
|
|
|
|
int ret = 0;
|
|
|
|
|
struct drm_display_mode *mode;
|
|
|
|
|
|
2014-07-15 14:38:10 +00:00
|
|
|
radeon_connector_get_edid(connector);
|
|
|
|
|
ret = radeon_ddc_get_modes(connector);
|
|
|
|
|
if (ret > 0) {
|
|
|
|
|
encoder = radeon_best_single_encoder(connector);
|
|
|
|
|
if (encoder) {
|
|
|
|
|
radeon_fixup_lvds_native_mode(encoder, connector);
|
|
|
|
|
/* add scaled modes */
|
|
|
|
|
radeon_add_common_modes(encoder, connector);
|
2009-06-05 12:42:42 +00:00
|
|
|
}
|
2014-07-15 14:38:10 +00:00
|
|
|
return ret;
|
2009-06-05 12:42:42 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
encoder = radeon_best_single_encoder(connector);
|
|
|
|
|
if (!encoder)
|
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
|
|
/* we have no EDID modes */
|
|
|
|
|
mode = radeon_fp_native_mode(encoder);
|
|
|
|
|
if (mode) {
|
|
|
|
|
ret = 1;
|
|
|
|
|
drm_mode_probed_add(connector, mode);
|
2010-12-09 03:13:05 +00:00
|
|
|
/* add the width/height from vbios tables if available */
|
|
|
|
|
connector->display_info.width_mm = mode->width_mm;
|
|
|
|
|
connector->display_info.height_mm = mode->height_mm;
|
2009-09-11 15:15:43 +00:00
|
|
|
/* add scaled modes */
|
|
|
|
|
radeon_add_common_modes(encoder, connector);
|
2009-06-05 12:42:42 +00:00
|
|
|
}
|
2009-09-10 21:53:39 +00:00
|
|
|
|
2009-06-05 12:42:42 +00:00
|
|
|
return ret;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static int radeon_lvds_mode_valid(struct drm_connector *connector,
|
|
|
|
|
struct drm_display_mode *mode)
|
|
|
|
|
{
|
2009-11-05 16:57:07 +00:00
|
|
|
struct drm_encoder *encoder = radeon_best_single_encoder(connector);
|
|
|
|
|
|
|
|
|
|
if ((mode->hdisplay < 320) || (mode->vdisplay < 240))
|
|
|
|
|
return MODE_PANEL;
|
|
|
|
|
|
|
|
|
|
if (encoder) {
|
|
|
|
|
struct radeon_encoder *radeon_encoder = to_radeon_encoder(encoder);
|
|
|
|
|
struct drm_display_mode *native_mode = &radeon_encoder->native_mode;
|
|
|
|
|
|
|
|
|
|
/* AVIVO hardware supports downscaling modes larger than the panel
|
|
|
|
|
* to the panel size, but I'm not sure this is desirable.
|
|
|
|
|
*/
|
|
|
|
|
if ((mode->hdisplay > native_mode->hdisplay) ||
|
|
|
|
|
(mode->vdisplay > native_mode->vdisplay))
|
|
|
|
|
return MODE_PANEL;
|
|
|
|
|
|
|
|
|
|
/* if scaling is disabled, block non-native modes */
|
|
|
|
|
if (radeon_encoder->rmx_type == RMX_OFF) {
|
|
|
|
|
if ((mode->hdisplay != native_mode->hdisplay) ||
|
|
|
|
|
(mode->vdisplay != native_mode->vdisplay))
|
|
|
|
|
return MODE_PANEL;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2009-06-05 12:42:42 +00:00
|
|
|
return MODE_OK;
|
|
|
|
|
}
|
|
|
|
|
|
2010-09-09 22:51:02 +00:00
|
|
|
static enum drm_connector_status
|
2010-09-14 10:07:23 +00:00
|
|
|
radeon_lvds_detect(struct drm_connector *connector, bool force)
|
2009-06-05 12:42:42 +00:00
|
|
|
{
|
2014-11-14 17:08:34 +00:00
|
|
|
struct drm_device *dev = connector->dev;
|
|
|
|
|
struct radeon_device *rdev = dev->dev_private;
|
2009-10-09 22:41:19 +00:00
|
|
|
struct radeon_connector *radeon_connector = to_radeon_connector(connector);
|
2009-10-08 17:02:19 +00:00
|
|
|
struct drm_encoder *encoder = radeon_best_single_encoder(connector);
|
2009-10-09 22:41:19 +00:00
|
|
|
enum drm_connector_status ret = connector_status_disconnected;
|
2012-09-17 04:40:31 +00:00
|
|
|
int r;
|
|
|
|
|
|
|
|
|
|
r = pm_runtime_get_sync(connector->dev->dev);
|
|
|
|
|
if (r < 0)
|
|
|
|
|
return connector_status_disconnected;
|
2009-10-08 17:02:19 +00:00
|
|
|
|
|
|
|
|
if (encoder) {
|
|
|
|
|
struct radeon_encoder *radeon_encoder = to_radeon_encoder(encoder);
|
2009-10-09 19:14:30 +00:00
|
|
|
struct drm_display_mode *native_mode = &radeon_encoder->native_mode;
|
2009-10-08 17:02:19 +00:00
|
|
|
|
|
|
|
|
/* check if panel is valid */
|
2009-10-09 19:14:30 +00:00
|
|
|
if (native_mode->hdisplay >= 320 && native_mode->vdisplay >= 240)
|
2009-10-08 17:02:19 +00:00
|
|
|
ret = connector_status_connected;
|
2014-11-14 17:08:34 +00:00
|
|
|
/* don't fetch the edid from the vbios if ddc fails and runpm is
|
|
|
|
|
* enabled so we report disconnected.
|
|
|
|
|
*/
|
|
|
|
|
if ((rdev->flags & RADEON_IS_PX) && (radeon_runtime_pm != 0))
|
|
|
|
|
ret = connector_status_disconnected;
|
2009-10-08 17:02:19 +00:00
|
|
|
}
|
2009-10-09 22:41:19 +00:00
|
|
|
|
|
|
|
|
/* check for edid as well */
|
2014-07-15 14:38:10 +00:00
|
|
|
radeon_connector_get_edid(connector);
|
2009-10-15 20:16:35 +00:00
|
|
|
if (radeon_connector->edid)
|
|
|
|
|
ret = connector_status_connected;
|
2009-06-05 12:42:42 +00:00
|
|
|
/* check acpi lid status ??? */
|
2009-10-08 17:02:19 +00:00
|
|
|
|
2009-06-05 12:42:42 +00:00
|
|
|
radeon_connector_update_scratch_regs(connector, ret);
|
2012-09-17 04:40:31 +00:00
|
|
|
pm_runtime_mark_last_busy(connector->dev->dev);
|
|
|
|
|
pm_runtime_put_autosuspend(connector->dev->dev);
|
2009-06-05 12:42:42 +00:00
|
|
|
return ret;
|
|
|
|
|
}
|
|
|
|
|
|
2016-10-11 14:44:24 +00:00
|
|
|
static void radeon_connector_unregister(struct drm_connector *connector)
|
|
|
|
|
{
|
|
|
|
|
struct radeon_connector *radeon_connector = to_radeon_connector(connector);
|
|
|
|
|
|
2016-10-31 16:19:39 +00:00
|
|
|
if (radeon_connector->ddc_bus && radeon_connector->ddc_bus->has_aux) {
|
2016-10-11 14:44:24 +00:00
|
|
|
drm_dp_aux_unregister(&radeon_connector->ddc_bus->aux);
|
|
|
|
|
radeon_connector->ddc_bus->has_aux = false;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2009-06-05 12:42:42 +00:00
|
|
|
static void radeon_connector_destroy(struct drm_connector *connector)
|
|
|
|
|
{
|
|
|
|
|
struct radeon_connector *radeon_connector = to_radeon_connector(connector);
|
|
|
|
|
|
2014-07-15 14:38:10 +00:00
|
|
|
radeon_connector_free_edid(connector);
|
2009-06-05 12:42:42 +00:00
|
|
|
kfree(radeon_connector->con_priv);
|
2014-05-29 15:57:41 +00:00
|
|
|
drm_connector_unregister(connector);
|
2009-06-05 12:42:42 +00:00
|
|
|
drm_connector_cleanup(connector);
|
|
|
|
|
kfree(connector);
|
|
|
|
|
}
|
|
|
|
|
|
2009-09-09 07:40:54 +00:00
|
|
|
static int radeon_lvds_set_property(struct drm_connector *connector,
|
|
|
|
|
struct drm_property *property,
|
|
|
|
|
uint64_t value)
|
|
|
|
|
{
|
|
|
|
|
struct drm_device *dev = connector->dev;
|
|
|
|
|
struct radeon_encoder *radeon_encoder;
|
|
|
|
|
enum radeon_rmx_type rmx_type;
|
|
|
|
|
|
2010-08-02 00:42:55 +00:00
|
|
|
DRM_DEBUG_KMS("\n");
|
2009-09-09 07:40:54 +00:00
|
|
|
if (property != dev->mode_config.scaling_mode_property)
|
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
|
|
if (connector->encoder)
|
|
|
|
|
radeon_encoder = to_radeon_encoder(connector->encoder);
|
|
|
|
|
else {
|
2015-03-11 09:51:02 +00:00
|
|
|
const struct drm_connector_helper_funcs *connector_funcs = connector->helper_private;
|
2009-09-09 07:40:54 +00:00
|
|
|
radeon_encoder = to_radeon_encoder(connector_funcs->best_encoder(connector));
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
switch (value) {
|
|
|
|
|
case DRM_MODE_SCALE_NONE: rmx_type = RMX_OFF; break;
|
|
|
|
|
case DRM_MODE_SCALE_CENTER: rmx_type = RMX_CENTER; break;
|
|
|
|
|
case DRM_MODE_SCALE_ASPECT: rmx_type = RMX_ASPECT; break;
|
|
|
|
|
default:
|
|
|
|
|
case DRM_MODE_SCALE_FULLSCREEN: rmx_type = RMX_FULL; break;
|
|
|
|
|
}
|
|
|
|
|
if (radeon_encoder->rmx_type == rmx_type)
|
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
|
|
radeon_encoder->rmx_type = rmx_type;
|
|
|
|
|
|
|
|
|
|
radeon_property_change_mode(&radeon_encoder->base);
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2012-08-31 17:43:50 +00:00
|
|
|
static const struct drm_connector_helper_funcs radeon_lvds_connector_helper_funcs = {
|
2009-06-05 12:42:42 +00:00
|
|
|
.get_modes = radeon_lvds_get_modes,
|
|
|
|
|
.mode_valid = radeon_lvds_mode_valid,
|
|
|
|
|
.best_encoder = radeon_best_single_encoder,
|
|
|
|
|
};
|
|
|
|
|
|
2012-08-31 17:43:50 +00:00
|
|
|
static const struct drm_connector_funcs radeon_lvds_connector_funcs = {
|
2009-06-05 12:42:42 +00:00
|
|
|
.dpms = drm_helper_connector_dpms,
|
|
|
|
|
.detect = radeon_lvds_detect,
|
|
|
|
|
.fill_modes = drm_helper_probe_single_connector_modes,
|
2016-10-11 14:44:24 +00:00
|
|
|
.early_unregister = radeon_connector_unregister,
|
2009-06-05 12:42:42 +00:00
|
|
|
.destroy = radeon_connector_destroy,
|
2009-09-09 07:40:54 +00:00
|
|
|
.set_property = radeon_lvds_set_property,
|
2009-06-05 12:42:42 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
|
|
static int radeon_vga_get_modes(struct drm_connector *connector)
|
|
|
|
|
{
|
|
|
|
|
int ret;
|
|
|
|
|
|
2014-07-15 14:38:10 +00:00
|
|
|
radeon_connector_get_edid(connector);
|
|
|
|
|
ret = radeon_ddc_get_modes(connector);
|
2009-06-05 12:42:42 +00:00
|
|
|
|
2014-07-09 17:21:59 +00:00
|
|
|
radeon_get_native_mode(connector);
|
|
|
|
|
|
2009-06-05 12:42:42 +00:00
|
|
|
return ret;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static int radeon_vga_mode_valid(struct drm_connector *connector,
|
|
|
|
|
struct drm_display_mode *mode)
|
|
|
|
|
{
|
2011-06-08 17:01:11 +00:00
|
|
|
struct drm_device *dev = connector->dev;
|
|
|
|
|
struct radeon_device *rdev = dev->dev_private;
|
|
|
|
|
|
2009-11-05 16:57:07 +00:00
|
|
|
/* XXX check mode bandwidth */
|
2011-06-08 17:01:11 +00:00
|
|
|
|
|
|
|
|
if ((mode->clock / 10) > rdev->clock.max_pixel_clock)
|
|
|
|
|
return MODE_CLOCK_HIGH;
|
|
|
|
|
|
2009-06-05 12:42:42 +00:00
|
|
|
return MODE_OK;
|
|
|
|
|
}
|
|
|
|
|
|
2010-09-09 22:51:02 +00:00
|
|
|
static enum drm_connector_status
|
2010-09-14 10:07:23 +00:00
|
|
|
radeon_vga_detect(struct drm_connector *connector, bool force)
|
2009-06-05 12:42:42 +00:00
|
|
|
{
|
2011-03-23 08:10:10 +00:00
|
|
|
struct drm_device *dev = connector->dev;
|
|
|
|
|
struct radeon_device *rdev = dev->dev_private;
|
2009-06-05 12:42:42 +00:00
|
|
|
struct radeon_connector *radeon_connector = to_radeon_connector(connector);
|
|
|
|
|
struct drm_encoder *encoder;
|
2015-03-11 09:51:02 +00:00
|
|
|
const struct drm_encoder_helper_funcs *encoder_funcs;
|
2010-02-08 03:16:55 +00:00
|
|
|
bool dret = false;
|
2009-06-05 12:42:42 +00:00
|
|
|
enum drm_connector_status ret = connector_status_disconnected;
|
2012-09-17 04:40:31 +00:00
|
|
|
int r;
|
|
|
|
|
|
|
|
|
|
r = pm_runtime_get_sync(connector->dev->dev);
|
|
|
|
|
if (r < 0)
|
|
|
|
|
return connector_status_disconnected;
|
2009-06-05 12:42:42 +00:00
|
|
|
|
2009-08-13 06:32:14 +00:00
|
|
|
encoder = radeon_best_single_encoder(connector);
|
|
|
|
|
if (!encoder)
|
|
|
|
|
ret = connector_status_disconnected;
|
|
|
|
|
|
2010-02-25 03:44:04 +00:00
|
|
|
if (radeon_connector->ddc_bus)
|
2013-01-03 18:09:28 +00:00
|
|
|
dret = radeon_ddc_probe(radeon_connector, false);
|
2009-10-15 20:16:35 +00:00
|
|
|
if (dret) {
|
2011-10-07 18:23:48 +00:00
|
|
|
radeon_connector->detected_by_load = false;
|
2014-07-15 14:38:10 +00:00
|
|
|
radeon_connector_free_edid(connector);
|
|
|
|
|
radeon_connector_get_edid(connector);
|
2009-10-15 20:16:35 +00:00
|
|
|
|
|
|
|
|
if (!radeon_connector->edid) {
|
2009-11-12 13:13:53 +00:00
|
|
|
DRM_ERROR("%s: probed a monitor but no|invalid EDID\n",
|
2014-06-03 11:56:19 +00:00
|
|
|
connector->name);
|
2009-11-12 13:13:53 +00:00
|
|
|
ret = connector_status_connected;
|
2009-10-15 20:16:35 +00:00
|
|
|
} else {
|
2014-07-15 14:38:10 +00:00
|
|
|
radeon_connector->use_digital =
|
|
|
|
|
!!(radeon_connector->edid->input & DRM_EDID_INPUT_DIGITAL);
|
2009-10-15 20:16:35 +00:00
|
|
|
|
|
|
|
|
/* some oems have boards with separate digital and analog connectors
|
|
|
|
|
* with a shared ddc line (often vga + hdmi)
|
|
|
|
|
*/
|
|
|
|
|
if (radeon_connector->use_digital && radeon_connector->shared_ddc) {
|
2014-07-15 14:38:10 +00:00
|
|
|
radeon_connector_free_edid(connector);
|
2009-10-15 20:16:35 +00:00
|
|
|
ret = connector_status_disconnected;
|
2014-07-15 14:38:10 +00:00
|
|
|
} else {
|
2009-10-15 20:16:35 +00:00
|
|
|
ret = connector_status_connected;
|
2014-07-15 14:38:10 +00:00
|
|
|
}
|
2009-10-15 20:16:35 +00:00
|
|
|
}
|
|
|
|
|
} else {
|
2010-10-26 02:55:52 +00:00
|
|
|
|
|
|
|
|
/* if we aren't forcing don't do destructive polling */
|
2011-10-07 18:23:48 +00:00
|
|
|
if (!force) {
|
|
|
|
|
/* only return the previous status if we last
|
|
|
|
|
* detected a monitor via load.
|
|
|
|
|
*/
|
|
|
|
|
if (radeon_connector->detected_by_load)
|
2012-09-17 04:40:31 +00:00
|
|
|
ret = connector->status;
|
|
|
|
|
goto out;
|
2011-10-07 18:23:48 +00:00
|
|
|
}
|
2010-10-26 02:55:52 +00:00
|
|
|
|
2009-12-30 01:22:55 +00:00
|
|
|
if (radeon_connector->dac_load_detect && encoder) {
|
2009-09-09 07:40:54 +00:00
|
|
|
encoder_funcs = encoder->helper_private;
|
|
|
|
|
ret = encoder_funcs->detect(encoder, connector);
|
2011-10-24 22:16:34 +00:00
|
|
|
if (ret != connector_status_disconnected)
|
2011-10-07 18:23:48 +00:00
|
|
|
radeon_connector->detected_by_load = true;
|
2009-09-09 07:40:54 +00:00
|
|
|
}
|
2009-06-05 12:42:42 +00:00
|
|
|
}
|
|
|
|
|
|
2009-08-13 06:32:14 +00:00
|
|
|
if (ret == connector_status_connected)
|
|
|
|
|
ret = radeon_connector_analog_encoder_conflict_solve(connector, encoder, ret, true);
|
2011-03-23 08:10:10 +00:00
|
|
|
|
|
|
|
|
/* RN50 and some RV100 asics in servers often have a hardcoded EDID in the
|
|
|
|
|
* vbios to deal with KVMs. If we have one and are not able to detect a monitor
|
|
|
|
|
* by other means, assume the CRT is connected and use that EDID.
|
|
|
|
|
*/
|
|
|
|
|
if ((!rdev->is_atom_bios) &&
|
|
|
|
|
(ret == connector_status_disconnected) &&
|
|
|
|
|
rdev->mode_info.bios_hardcoded_edid_size) {
|
|
|
|
|
ret = connector_status_connected;
|
|
|
|
|
}
|
|
|
|
|
|
2009-06-05 12:42:42 +00:00
|
|
|
radeon_connector_update_scratch_regs(connector, ret);
|
2012-09-17 04:40:31 +00:00
|
|
|
|
|
|
|
|
out:
|
|
|
|
|
pm_runtime_mark_last_busy(connector->dev->dev);
|
|
|
|
|
pm_runtime_put_autosuspend(connector->dev->dev);
|
|
|
|
|
|
2009-06-05 12:42:42 +00:00
|
|
|
return ret;
|
|
|
|
|
}
|
|
|
|
|
|
2012-08-31 17:43:50 +00:00
|
|
|
static const struct drm_connector_helper_funcs radeon_vga_connector_helper_funcs = {
|
2009-06-05 12:42:42 +00:00
|
|
|
.get_modes = radeon_vga_get_modes,
|
|
|
|
|
.mode_valid = radeon_vga_mode_valid,
|
|
|
|
|
.best_encoder = radeon_best_single_encoder,
|
|
|
|
|
};
|
|
|
|
|
|
2012-08-31 17:43:50 +00:00
|
|
|
static const struct drm_connector_funcs radeon_vga_connector_funcs = {
|
2009-06-05 12:42:42 +00:00
|
|
|
.dpms = drm_helper_connector_dpms,
|
|
|
|
|
.detect = radeon_vga_detect,
|
|
|
|
|
.fill_modes = drm_helper_probe_single_connector_modes,
|
2016-10-11 14:44:24 +00:00
|
|
|
.early_unregister = radeon_connector_unregister,
|
2009-06-05 12:42:42 +00:00
|
|
|
.destroy = radeon_connector_destroy,
|
|
|
|
|
.set_property = radeon_connector_set_property,
|
|
|
|
|
};
|
|
|
|
|
|
2009-08-13 06:32:14 +00:00
|
|
|
static int radeon_tv_get_modes(struct drm_connector *connector)
|
|
|
|
|
{
|
|
|
|
|
struct drm_device *dev = connector->dev;
|
2009-09-10 21:53:39 +00:00
|
|
|
struct radeon_device *rdev = dev->dev_private;
|
2009-08-13 06:32:14 +00:00
|
|
|
struct drm_display_mode *tv_mode;
|
2009-09-10 21:53:39 +00:00
|
|
|
struct drm_encoder *encoder;
|
2009-08-13 06:32:14 +00:00
|
|
|
|
2009-09-10 21:53:39 +00:00
|
|
|
encoder = radeon_best_single_encoder(connector);
|
|
|
|
|
if (!encoder)
|
|
|
|
|
return 0;
|
2009-08-13 06:32:14 +00:00
|
|
|
|
2009-09-10 21:53:39 +00:00
|
|
|
/* avivo chips can scale any mode */
|
|
|
|
|
if (rdev->family >= CHIP_RS600)
|
|
|
|
|
/* add scaled modes */
|
|
|
|
|
radeon_add_common_modes(encoder, connector);
|
|
|
|
|
else {
|
|
|
|
|
/* only 800x600 is supported right now on pre-avivo chips */
|
drm/kms: start adding command line interface using fb.
[note this requires an fb patch posted to linux-fbdev-devel already]
This uses the normal video= command line option to control the kms
output setup at boot time. It is used to override the autodetection
done by kms.
video= normally takes a framebuffer as the first parameter, in kms
it will take a connector name, DVI-I-1, or LVDS-1 etc. If no output
connector is specified the mode string will apply to all connectors.
The mode specification used will match down the probed modes, and if
no mode is found it will add a CVT mode that matches.
video=1024x768 - all connectors match a 1024x768 mode or add a CVT on
video=VGA-1:1024x768, VGA-1 connector gets mode only.
The same strings as used in current fb modedb.c are used, except I've
added three more letters, e, D, d, e = enable, D = enable Digital,
d = disable, which allow a connector to be forced into a certain state.
Signed-off-by: Dave Airlie <airlied@redhat.com>
2009-09-23 04:44:08 +00:00
|
|
|
tv_mode = drm_cvt_mode(dev, 800, 600, 60, false, false, false);
|
2009-09-10 21:53:39 +00:00
|
|
|
tv_mode->type = DRM_MODE_TYPE_DRIVER | DRM_MODE_TYPE_PREFERRED;
|
|
|
|
|
drm_mode_probed_add(connector, tv_mode);
|
|
|
|
|
}
|
2009-08-13 06:32:14 +00:00
|
|
|
return 1;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static int radeon_tv_mode_valid(struct drm_connector *connector,
|
|
|
|
|
struct drm_display_mode *mode)
|
|
|
|
|
{
|
2009-11-05 16:57:07 +00:00
|
|
|
if ((mode->hdisplay > 1024) || (mode->vdisplay > 768))
|
|
|
|
|
return MODE_CLOCK_RANGE;
|
2009-08-13 06:32:14 +00:00
|
|
|
return MODE_OK;
|
|
|
|
|
}
|
|
|
|
|
|
2010-09-09 22:51:02 +00:00
|
|
|
static enum drm_connector_status
|
2010-09-14 10:07:23 +00:00
|
|
|
radeon_tv_detect(struct drm_connector *connector, bool force)
|
2009-08-13 06:32:14 +00:00
|
|
|
{
|
|
|
|
|
struct drm_encoder *encoder;
|
2015-03-11 09:51:02 +00:00
|
|
|
const struct drm_encoder_helper_funcs *encoder_funcs;
|
2009-09-09 07:40:54 +00:00
|
|
|
struct radeon_connector *radeon_connector = to_radeon_connector(connector);
|
|
|
|
|
enum drm_connector_status ret = connector_status_disconnected;
|
2012-09-17 04:40:31 +00:00
|
|
|
int r;
|
2009-09-09 07:40:54 +00:00
|
|
|
|
|
|
|
|
if (!radeon_connector->dac_load_detect)
|
|
|
|
|
return ret;
|
2009-08-13 06:32:14 +00:00
|
|
|
|
2012-09-17 04:40:31 +00:00
|
|
|
r = pm_runtime_get_sync(connector->dev->dev);
|
|
|
|
|
if (r < 0)
|
|
|
|
|
return connector_status_disconnected;
|
|
|
|
|
|
2009-08-13 06:32:14 +00:00
|
|
|
encoder = radeon_best_single_encoder(connector);
|
|
|
|
|
if (!encoder)
|
|
|
|
|
ret = connector_status_disconnected;
|
|
|
|
|
else {
|
|
|
|
|
encoder_funcs = encoder->helper_private;
|
|
|
|
|
ret = encoder_funcs->detect(encoder, connector);
|
|
|
|
|
}
|
|
|
|
|
if (ret == connector_status_connected)
|
|
|
|
|
ret = radeon_connector_analog_encoder_conflict_solve(connector, encoder, ret, false);
|
|
|
|
|
radeon_connector_update_scratch_regs(connector, ret);
|
2012-09-17 04:40:31 +00:00
|
|
|
pm_runtime_mark_last_busy(connector->dev->dev);
|
|
|
|
|
pm_runtime_put_autosuspend(connector->dev->dev);
|
2009-08-13 06:32:14 +00:00
|
|
|
return ret;
|
|
|
|
|
}
|
|
|
|
|
|
2012-08-31 17:43:50 +00:00
|
|
|
static const struct drm_connector_helper_funcs radeon_tv_connector_helper_funcs = {
|
2009-08-13 06:32:14 +00:00
|
|
|
.get_modes = radeon_tv_get_modes,
|
|
|
|
|
.mode_valid = radeon_tv_mode_valid,
|
|
|
|
|
.best_encoder = radeon_best_single_encoder,
|
|
|
|
|
};
|
|
|
|
|
|
2012-08-31 17:43:50 +00:00
|
|
|
static const struct drm_connector_funcs radeon_tv_connector_funcs = {
|
2009-08-13 06:32:14 +00:00
|
|
|
.dpms = drm_helper_connector_dpms,
|
|
|
|
|
.detect = radeon_tv_detect,
|
|
|
|
|
.fill_modes = drm_helper_probe_single_connector_modes,
|
2016-10-11 14:44:24 +00:00
|
|
|
.early_unregister = radeon_connector_unregister,
|
2009-08-13 06:32:14 +00:00
|
|
|
.destroy = radeon_connector_destroy,
|
|
|
|
|
.set_property = radeon_connector_set_property,
|
|
|
|
|
};
|
|
|
|
|
|
2012-03-16 16:22:11 +00:00
|
|
|
static bool radeon_check_hpd_status_unchanged(struct drm_connector *connector)
|
|
|
|
|
{
|
|
|
|
|
struct drm_device *dev = connector->dev;
|
|
|
|
|
struct radeon_device *rdev = dev->dev_private;
|
|
|
|
|
struct radeon_connector *radeon_connector = to_radeon_connector(connector);
|
|
|
|
|
enum drm_connector_status status;
|
|
|
|
|
|
|
|
|
|
/* We only trust HPD on R600 and newer ASICS. */
|
|
|
|
|
if (rdev->family >= CHIP_R600
|
|
|
|
|
&& radeon_connector->hpd.hpd != RADEON_HPD_NONE) {
|
|
|
|
|
if (radeon_hpd_sense(rdev, radeon_connector->hpd.hpd))
|
|
|
|
|
status = connector_status_connected;
|
|
|
|
|
else
|
|
|
|
|
status = connector_status_disconnected;
|
|
|
|
|
if (connector->status == status)
|
|
|
|
|
return true;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return false;
|
|
|
|
|
}
|
|
|
|
|
|
2009-08-13 06:32:14 +00:00
|
|
|
/*
|
|
|
|
|
* DVI is complicated
|
|
|
|
|
* Do a DDC probe, if DDC probe passes, get the full EDID so
|
|
|
|
|
* we can do analog/digital monitor detection at this point.
|
|
|
|
|
* If the monitor is an analog monitor or we got no DDC,
|
|
|
|
|
* we need to find the DAC encoder object for this connector.
|
|
|
|
|
* If we got no DDC, we do load detection on the DAC encoder object.
|
|
|
|
|
* If we got analog DDC or load detection passes on the DAC encoder
|
|
|
|
|
* we have to check if this analog encoder is shared with anyone else (TV)
|
|
|
|
|
* if its shared we have to set the other connector to disconnected.
|
|
|
|
|
*/
|
2010-09-09 22:51:02 +00:00
|
|
|
static enum drm_connector_status
|
2010-09-14 10:07:23 +00:00
|
|
|
radeon_dvi_detect(struct drm_connector *connector, bool force)
|
2009-06-05 12:42:42 +00:00
|
|
|
{
|
2011-03-23 08:10:10 +00:00
|
|
|
struct drm_device *dev = connector->dev;
|
|
|
|
|
struct radeon_device *rdev = dev->dev_private;
|
2009-06-05 12:42:42 +00:00
|
|
|
struct radeon_connector *radeon_connector = to_radeon_connector(connector);
|
2009-08-13 06:32:14 +00:00
|
|
|
struct drm_encoder *encoder = NULL;
|
2015-03-11 09:51:02 +00:00
|
|
|
const struct drm_encoder_helper_funcs *encoder_funcs;
|
2012-09-17 04:40:31 +00:00
|
|
|
int i, r;
|
2009-06-05 12:42:42 +00:00
|
|
|
enum drm_connector_status ret = connector_status_disconnected;
|
2012-10-24 16:32:52 +00:00
|
|
|
bool dret = false, broken_edid = false;
|
2009-06-05 12:42:42 +00:00
|
|
|
|
2012-09-17 04:40:31 +00:00
|
|
|
r = pm_runtime_get_sync(connector->dev->dev);
|
|
|
|
|
if (r < 0)
|
|
|
|
|
return connector_status_disconnected;
|
|
|
|
|
|
2015-12-03 23:26:07 +00:00
|
|
|
if (radeon_connector->detected_hpd_without_ddc) {
|
|
|
|
|
force = true;
|
|
|
|
|
radeon_connector->detected_hpd_without_ddc = false;
|
|
|
|
|
}
|
|
|
|
|
|
2012-09-17 04:40:31 +00:00
|
|
|
if (!force && radeon_check_hpd_status_unchanged(connector)) {
|
|
|
|
|
ret = connector->status;
|
|
|
|
|
goto exit;
|
|
|
|
|
}
|
2012-03-16 16:22:11 +00:00
|
|
|
|
2015-12-03 23:26:07 +00:00
|
|
|
if (radeon_connector->ddc_bus) {
|
2013-01-03 18:09:28 +00:00
|
|
|
dret = radeon_ddc_probe(radeon_connector, false);
|
2015-12-03 23:26:07 +00:00
|
|
|
|
|
|
|
|
/* Sometimes the pins required for the DDC probe on DVI
|
|
|
|
|
* connectors don't make contact at the same time that the ones
|
|
|
|
|
* for HPD do. If the DDC probe fails even though we had an HPD
|
|
|
|
|
* signal, try again later */
|
|
|
|
|
if (!dret && !force &&
|
|
|
|
|
connector->status != connector_status_connected) {
|
|
|
|
|
DRM_DEBUG_KMS("hpd detected without ddc, retrying in 1 second\n");
|
|
|
|
|
radeon_connector->detected_hpd_without_ddc = true;
|
|
|
|
|
schedule_delayed_work(&rdev->hotplug_work,
|
|
|
|
|
msecs_to_jiffies(1000));
|
|
|
|
|
goto exit;
|
|
|
|
|
}
|
|
|
|
|
}
|
2009-08-13 06:32:14 +00:00
|
|
|
if (dret) {
|
2011-10-07 18:23:48 +00:00
|
|
|
radeon_connector->detected_by_load = false;
|
2014-07-15 14:38:10 +00:00
|
|
|
radeon_connector_free_edid(connector);
|
|
|
|
|
radeon_connector_get_edid(connector);
|
2009-08-13 06:32:14 +00:00
|
|
|
|
|
|
|
|
if (!radeon_connector->edid) {
|
2009-11-12 13:13:53 +00:00
|
|
|
DRM_ERROR("%s: probed a monitor but no|invalid EDID\n",
|
2014-06-03 11:56:19 +00:00
|
|
|
connector->name);
|
2011-06-14 06:13:55 +00:00
|
|
|
/* rs690 seems to have a problem with connectors not existing and always
|
|
|
|
|
* return a block of 0's. If we see this just stop polling on this output */
|
2014-07-15 14:38:10 +00:00
|
|
|
if ((rdev->family == CHIP_RS690 || rdev->family == CHIP_RS740) &&
|
|
|
|
|
radeon_connector->base.null_edid_counter) {
|
2011-06-14 06:13:55 +00:00
|
|
|
ret = connector_status_disconnected;
|
2014-06-03 11:56:19 +00:00
|
|
|
DRM_ERROR("%s: detected RS690 floating bus bug, stopping ddc detect\n",
|
|
|
|
|
connector->name);
|
2011-06-14 06:13:55 +00:00
|
|
|
radeon_connector->ddc_bus = NULL;
|
2012-10-24 16:32:52 +00:00
|
|
|
} else {
|
|
|
|
|
ret = connector_status_connected;
|
|
|
|
|
broken_edid = true; /* defer use_digital to later */
|
2011-06-14 06:13:55 +00:00
|
|
|
}
|
2009-08-13 06:32:14 +00:00
|
|
|
} else {
|
2014-07-15 14:38:10 +00:00
|
|
|
radeon_connector->use_digital =
|
|
|
|
|
!!(radeon_connector->edid->input & DRM_EDID_INPUT_DIGITAL);
|
2009-08-13 06:32:14 +00:00
|
|
|
|
2009-10-15 20:16:35 +00:00
|
|
|
/* some oems have boards with separate digital and analog connectors
|
|
|
|
|
* with a shared ddc line (often vga + hdmi)
|
|
|
|
|
*/
|
|
|
|
|
if ((!radeon_connector->use_digital) && radeon_connector->shared_ddc) {
|
2014-07-15 14:38:10 +00:00
|
|
|
radeon_connector_free_edid(connector);
|
2009-10-15 20:16:35 +00:00
|
|
|
ret = connector_status_disconnected;
|
2014-07-15 14:38:10 +00:00
|
|
|
} else {
|
2009-10-15 20:16:35 +00:00
|
|
|
ret = connector_status_connected;
|
2014-07-15 14:38:10 +00:00
|
|
|
}
|
2010-07-20 15:27:54 +00:00
|
|
|
/* This gets complicated. We have boards with VGA + HDMI with a
|
|
|
|
|
* shared DDC line and we have boards with DVI-D + HDMI with a shared
|
|
|
|
|
* DDC line. The latter is more complex because with DVI<->HDMI adapters
|
|
|
|
|
* you don't really know what's connected to which port as both are digital.
|
2009-11-17 20:44:01 +00:00
|
|
|
*/
|
2010-02-19 07:13:56 +00:00
|
|
|
if (radeon_connector->shared_ddc && (ret == connector_status_connected)) {
|
2009-11-17 20:44:01 +00:00
|
|
|
struct drm_connector *list_connector;
|
|
|
|
|
struct radeon_connector *list_radeon_connector;
|
|
|
|
|
list_for_each_entry(list_connector, &dev->mode_config.connector_list, head) {
|
|
|
|
|
if (connector == list_connector)
|
|
|
|
|
continue;
|
|
|
|
|
list_radeon_connector = to_radeon_connector(list_connector);
|
2010-07-01 14:34:56 +00:00
|
|
|
if (list_radeon_connector->shared_ddc &&
|
|
|
|
|
(list_radeon_connector->ddc_bus->rec.i2c_id ==
|
|
|
|
|
radeon_connector->ddc_bus->rec.i2c_id)) {
|
2010-07-20 15:27:54 +00:00
|
|
|
/* cases where both connectors are digital */
|
|
|
|
|
if (list_connector->connector_type != DRM_MODE_CONNECTOR_VGA) {
|
|
|
|
|
/* hpd is our only option in this case */
|
|
|
|
|
if (!radeon_hpd_sense(rdev, radeon_connector->hpd.hpd)) {
|
2014-07-15 14:38:10 +00:00
|
|
|
radeon_connector_free_edid(connector);
|
2009-11-17 20:44:01 +00:00
|
|
|
ret = connector_status_disconnected;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
2009-08-13 06:32:14 +00:00
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if ((ret == connector_status_connected) && (radeon_connector->use_digital == true))
|
|
|
|
|
goto out;
|
|
|
|
|
|
2011-10-07 18:23:47 +00:00
|
|
|
/* DVI-D and HDMI-A are digital only */
|
|
|
|
|
if ((connector->connector_type == DRM_MODE_CONNECTOR_DVID) ||
|
|
|
|
|
(connector->connector_type == DRM_MODE_CONNECTOR_HDMIA))
|
|
|
|
|
goto out;
|
|
|
|
|
|
2011-10-07 18:23:48 +00:00
|
|
|
/* if we aren't forcing don't do destructive polling */
|
2010-10-26 02:55:52 +00:00
|
|
|
if (!force) {
|
2011-10-07 18:23:48 +00:00
|
|
|
/* only return the previous status if we last
|
|
|
|
|
* detected a monitor via load.
|
|
|
|
|
*/
|
|
|
|
|
if (radeon_connector->detected_by_load)
|
|
|
|
|
ret = connector->status;
|
2010-10-26 02:55:52 +00:00
|
|
|
goto out;
|
|
|
|
|
}
|
|
|
|
|
|
2009-08-13 06:32:14 +00:00
|
|
|
/* find analog encoder */
|
2009-09-09 07:40:54 +00:00
|
|
|
if (radeon_connector->dac_load_detect) {
|
|
|
|
|
for (i = 0; i < DRM_CONNECTOR_MAX_ENCODER; i++) {
|
|
|
|
|
if (connector->encoder_ids[i] == 0)
|
|
|
|
|
break;
|
2009-06-05 12:42:42 +00:00
|
|
|
|
2014-07-18 03:30:05 +00:00
|
|
|
encoder = drm_encoder_find(connector->dev,
|
|
|
|
|
connector->encoder_ids[i]);
|
|
|
|
|
if (!encoder)
|
2009-09-09 07:40:54 +00:00
|
|
|
continue;
|
2009-06-05 12:42:42 +00:00
|
|
|
|
2012-04-18 13:21:07 +00:00
|
|
|
if (encoder->encoder_type != DRM_MODE_ENCODER_DAC &&
|
2012-03-16 16:22:09 +00:00
|
|
|
encoder->encoder_type != DRM_MODE_ENCODER_TVDAC)
|
|
|
|
|
continue;
|
|
|
|
|
|
2009-09-09 07:40:54 +00:00
|
|
|
encoder_funcs = encoder->helper_private;
|
|
|
|
|
if (encoder_funcs->detect) {
|
2012-10-24 16:32:52 +00:00
|
|
|
if (!broken_edid) {
|
|
|
|
|
if (ret != connector_status_connected) {
|
|
|
|
|
/* deal with analog monitors without DDC */
|
|
|
|
|
ret = encoder_funcs->detect(encoder, connector);
|
|
|
|
|
if (ret == connector_status_connected) {
|
|
|
|
|
radeon_connector->use_digital = false;
|
|
|
|
|
}
|
|
|
|
|
if (ret != connector_status_disconnected)
|
|
|
|
|
radeon_connector->detected_by_load = true;
|
2009-09-09 07:40:54 +00:00
|
|
|
}
|
2012-10-24 16:32:52 +00:00
|
|
|
} else {
|
|
|
|
|
enum drm_connector_status lret;
|
|
|
|
|
/* assume digital unless load detected otherwise */
|
|
|
|
|
radeon_connector->use_digital = true;
|
|
|
|
|
lret = encoder_funcs->detect(encoder, connector);
|
|
|
|
|
DRM_DEBUG_KMS("load_detect %x returned: %x\n",encoder->encoder_type,lret);
|
|
|
|
|
if (lret == connector_status_connected)
|
|
|
|
|
radeon_connector->use_digital = false;
|
2009-06-05 12:42:42 +00:00
|
|
|
}
|
2009-09-09 07:40:54 +00:00
|
|
|
break;
|
2009-06-05 12:42:42 +00:00
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2009-08-13 06:32:14 +00:00
|
|
|
if ((ret == connector_status_connected) && (radeon_connector->use_digital == false) &&
|
|
|
|
|
encoder) {
|
|
|
|
|
ret = radeon_connector_analog_encoder_conflict_solve(connector, encoder, ret, true);
|
|
|
|
|
}
|
|
|
|
|
|
2011-03-23 08:10:10 +00:00
|
|
|
/* RN50 and some RV100 asics in servers often have a hardcoded EDID in the
|
|
|
|
|
* vbios to deal with KVMs. If we have one and are not able to detect a monitor
|
|
|
|
|
* by other means, assume the DFP is connected and use that EDID. In most
|
|
|
|
|
* cases the DVI port is actually a virtual KVM port connected to the service
|
|
|
|
|
* processor.
|
|
|
|
|
*/
|
2012-04-19 14:42:58 +00:00
|
|
|
out:
|
2011-03-23 08:10:10 +00:00
|
|
|
if ((!rdev->is_atom_bios) &&
|
|
|
|
|
(ret == connector_status_disconnected) &&
|
|
|
|
|
rdev->mode_info.bios_hardcoded_edid_size) {
|
|
|
|
|
radeon_connector->use_digital = true;
|
|
|
|
|
ret = connector_status_connected;
|
|
|
|
|
}
|
|
|
|
|
|
2009-06-05 12:42:42 +00:00
|
|
|
/* updated in get modes as well since we need to know if it's analog or digital */
|
|
|
|
|
radeon_connector_update_scratch_regs(connector, ret);
|
2012-09-17 04:40:31 +00:00
|
|
|
|
2015-07-23 14:01:09 +00:00
|
|
|
if ((radeon_audio != 0) && radeon_connector->use_digital) {
|
|
|
|
|
const struct drm_connector_helper_funcs *connector_funcs =
|
|
|
|
|
connector->helper_private;
|
|
|
|
|
|
|
|
|
|
encoder = connector_funcs->best_encoder(connector);
|
|
|
|
|
if (encoder && (encoder->encoder_type == DRM_MODE_ENCODER_TMDS)) {
|
|
|
|
|
radeon_connector_get_edid(connector);
|
|
|
|
|
radeon_audio_detect(connector, encoder, ret);
|
|
|
|
|
}
|
|
|
|
|
}
|
2014-12-01 18:49:39 +00:00
|
|
|
|
2012-09-17 04:40:31 +00:00
|
|
|
exit:
|
|
|
|
|
pm_runtime_mark_last_busy(connector->dev->dev);
|
|
|
|
|
pm_runtime_put_autosuspend(connector->dev->dev);
|
|
|
|
|
|
2009-06-05 12:42:42 +00:00
|
|
|
return ret;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* okay need to be smart in here about which encoder to pick */
|
2012-08-31 17:43:50 +00:00
|
|
|
static struct drm_encoder *radeon_dvi_encoder(struct drm_connector *connector)
|
2009-06-05 12:42:42 +00:00
|
|
|
{
|
|
|
|
|
int enc_id = connector->encoder_ids[0];
|
|
|
|
|
struct radeon_connector *radeon_connector = to_radeon_connector(connector);
|
|
|
|
|
struct drm_encoder *encoder;
|
|
|
|
|
int i;
|
|
|
|
|
for (i = 0; i < DRM_CONNECTOR_MAX_ENCODER; i++) {
|
|
|
|
|
if (connector->encoder_ids[i] == 0)
|
|
|
|
|
break;
|
|
|
|
|
|
2014-07-18 03:30:05 +00:00
|
|
|
encoder = drm_encoder_find(connector->dev, connector->encoder_ids[i]);
|
|
|
|
|
if (!encoder)
|
2009-06-05 12:42:42 +00:00
|
|
|
continue;
|
|
|
|
|
|
2009-08-13 06:32:14 +00:00
|
|
|
if (radeon_connector->use_digital == true) {
|
2009-06-05 12:42:42 +00:00
|
|
|
if (encoder->encoder_type == DRM_MODE_ENCODER_TMDS)
|
|
|
|
|
return encoder;
|
|
|
|
|
} else {
|
|
|
|
|
if (encoder->encoder_type == DRM_MODE_ENCODER_DAC ||
|
|
|
|
|
encoder->encoder_type == DRM_MODE_ENCODER_TVDAC)
|
|
|
|
|
return encoder;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* see if we have a default encoder TODO */
|
|
|
|
|
|
|
|
|
|
/* then check use digitial */
|
|
|
|
|
/* pick the first one */
|
2014-07-18 03:30:05 +00:00
|
|
|
if (enc_id)
|
|
|
|
|
return drm_encoder_find(connector->dev, enc_id);
|
2009-06-05 12:42:42 +00:00
|
|
|
return NULL;
|
|
|
|
|
}
|
|
|
|
|
|
drm/kms: start adding command line interface using fb.
[note this requires an fb patch posted to linux-fbdev-devel already]
This uses the normal video= command line option to control the kms
output setup at boot time. It is used to override the autodetection
done by kms.
video= normally takes a framebuffer as the first parameter, in kms
it will take a connector name, DVI-I-1, or LVDS-1 etc. If no output
connector is specified the mode string will apply to all connectors.
The mode specification used will match down the probed modes, and if
no mode is found it will add a CVT mode that matches.
video=1024x768 - all connectors match a 1024x768 mode or add a CVT on
video=VGA-1:1024x768, VGA-1 connector gets mode only.
The same strings as used in current fb modedb.c are used, except I've
added three more letters, e, D, d, e = enable, D = enable Digital,
d = disable, which allow a connector to be forced into a certain state.
Signed-off-by: Dave Airlie <airlied@redhat.com>
2009-09-23 04:44:08 +00:00
|
|
|
static void radeon_dvi_force(struct drm_connector *connector)
|
|
|
|
|
{
|
|
|
|
|
struct radeon_connector *radeon_connector = to_radeon_connector(connector);
|
|
|
|
|
if (connector->force == DRM_FORCE_ON)
|
|
|
|
|
radeon_connector->use_digital = false;
|
|
|
|
|
if (connector->force == DRM_FORCE_ON_DIGITAL)
|
|
|
|
|
radeon_connector->use_digital = true;
|
|
|
|
|
}
|
|
|
|
|
|
2009-11-05 16:57:07 +00:00
|
|
|
static int radeon_dvi_mode_valid(struct drm_connector *connector,
|
|
|
|
|
struct drm_display_mode *mode)
|
|
|
|
|
{
|
2010-01-11 20:02:31 +00:00
|
|
|
struct drm_device *dev = connector->dev;
|
|
|
|
|
struct radeon_device *rdev = dev->dev_private;
|
2009-11-05 16:57:07 +00:00
|
|
|
struct radeon_connector *radeon_connector = to_radeon_connector(connector);
|
|
|
|
|
|
|
|
|
|
/* XXX check mode bandwidth */
|
|
|
|
|
|
2010-01-11 20:02:31 +00:00
|
|
|
/* clocks over 135 MHz have heat issues with DVI on RV100 */
|
|
|
|
|
if (radeon_connector->use_digital &&
|
|
|
|
|
(rdev->family == CHIP_RV100) &&
|
|
|
|
|
(mode->clock > 135000))
|
|
|
|
|
return MODE_CLOCK_HIGH;
|
|
|
|
|
|
2009-11-05 16:57:07 +00:00
|
|
|
if (radeon_connector->use_digital && (mode->clock > 165000)) {
|
|
|
|
|
if ((radeon_connector->connector_object_id == CONNECTOR_OBJECT_ID_DUAL_LINK_DVI_I) ||
|
|
|
|
|
(radeon_connector->connector_object_id == CONNECTOR_OBJECT_ID_DUAL_LINK_DVI_D) ||
|
|
|
|
|
(radeon_connector->connector_object_id == CONNECTOR_OBJECT_ID_HDMI_TYPE_B))
|
|
|
|
|
return MODE_OK;
|
2014-07-15 15:00:47 +00:00
|
|
|
else if (ASIC_IS_DCE6(rdev) && drm_detect_hdmi_monitor(radeon_connector_edid(connector))) {
|
2014-06-16 21:46:57 +00:00
|
|
|
/* HDMI 1.3+ supports max clock of 340 Mhz */
|
|
|
|
|
if (mode->clock > 340000)
|
2011-03-02 15:21:05 +00:00
|
|
|
return MODE_CLOCK_HIGH;
|
2014-06-16 21:46:57 +00:00
|
|
|
else
|
|
|
|
|
return MODE_OK;
|
|
|
|
|
} else {
|
2009-11-05 16:57:07 +00:00
|
|
|
return MODE_CLOCK_HIGH;
|
2014-06-16 21:46:57 +00:00
|
|
|
}
|
2009-11-05 16:57:07 +00:00
|
|
|
}
|
2011-06-08 17:01:11 +00:00
|
|
|
|
|
|
|
|
/* check against the max pixel clock */
|
|
|
|
|
if ((mode->clock / 10) > rdev->clock.max_pixel_clock)
|
|
|
|
|
return MODE_CLOCK_HIGH;
|
|
|
|
|
|
2009-11-05 16:57:07 +00:00
|
|
|
return MODE_OK;
|
|
|
|
|
}
|
|
|
|
|
|
2012-08-31 17:43:50 +00:00
|
|
|
static const struct drm_connector_helper_funcs radeon_dvi_connector_helper_funcs = {
|
2014-07-10 17:07:19 +00:00
|
|
|
.get_modes = radeon_vga_get_modes,
|
2009-11-05 16:57:07 +00:00
|
|
|
.mode_valid = radeon_dvi_mode_valid,
|
2009-06-05 12:42:42 +00:00
|
|
|
.best_encoder = radeon_dvi_encoder,
|
|
|
|
|
};
|
|
|
|
|
|
2012-08-31 17:43:50 +00:00
|
|
|
static const struct drm_connector_funcs radeon_dvi_connector_funcs = {
|
2009-06-05 12:42:42 +00:00
|
|
|
.dpms = drm_helper_connector_dpms,
|
|
|
|
|
.detect = radeon_dvi_detect,
|
|
|
|
|
.fill_modes = drm_helper_probe_single_connector_modes,
|
|
|
|
|
.set_property = radeon_connector_set_property,
|
2016-10-11 14:44:24 +00:00
|
|
|
.early_unregister = radeon_connector_unregister,
|
2009-06-05 12:42:42 +00:00
|
|
|
.destroy = radeon_connector_destroy,
|
drm/kms: start adding command line interface using fb.
[note this requires an fb patch posted to linux-fbdev-devel already]
This uses the normal video= command line option to control the kms
output setup at boot time. It is used to override the autodetection
done by kms.
video= normally takes a framebuffer as the first parameter, in kms
it will take a connector name, DVI-I-1, or LVDS-1 etc. If no output
connector is specified the mode string will apply to all connectors.
The mode specification used will match down the probed modes, and if
no mode is found it will add a CVT mode that matches.
video=1024x768 - all connectors match a 1024x768 mode or add a CVT on
video=VGA-1:1024x768, VGA-1 connector gets mode only.
The same strings as used in current fb modedb.c are used, except I've
added three more letters, e, D, d, e = enable, D = enable Digital,
d = disable, which allow a connector to be forced into a certain state.
Signed-off-by: Dave Airlie <airlied@redhat.com>
2009-09-23 04:44:08 +00:00
|
|
|
.force = radeon_dvi_force,
|
2009-06-05 12:42:42 +00:00
|
|
|
};
|
|
|
|
|
|
2009-12-07 21:07:28 +00:00
|
|
|
static int radeon_dp_get_modes(struct drm_connector *connector)
|
|
|
|
|
{
|
|
|
|
|
struct radeon_connector *radeon_connector = to_radeon_connector(connector);
|
2010-11-17 07:54:42 +00:00
|
|
|
struct radeon_connector_atom_dig *radeon_dig_connector = radeon_connector->con_priv;
|
2011-06-13 21:13:34 +00:00
|
|
|
struct drm_encoder *encoder = radeon_best_single_encoder(connector);
|
2009-12-07 21:07:28 +00:00
|
|
|
int ret;
|
|
|
|
|
|
2011-06-13 21:13:35 +00:00
|
|
|
if ((connector->connector_type == DRM_MODE_CONNECTOR_eDP) ||
|
|
|
|
|
(connector->connector_type == DRM_MODE_CONNECTOR_LVDS)) {
|
2011-05-20 08:34:31 +00:00
|
|
|
struct drm_display_mode *mode;
|
|
|
|
|
|
2012-02-28 16:08:22 +00:00
|
|
|
if (connector->connector_type == DRM_MODE_CONNECTOR_eDP) {
|
|
|
|
|
if (!radeon_dig_connector->edp_on)
|
|
|
|
|
atombios_set_edp_panel_power(connector,
|
|
|
|
|
ATOM_TRANSMITTER_ACTION_POWER_ON);
|
2014-07-15 14:38:10 +00:00
|
|
|
radeon_connector_get_edid(connector);
|
|
|
|
|
ret = radeon_ddc_get_modes(connector);
|
2012-02-28 16:08:22 +00:00
|
|
|
if (!radeon_dig_connector->edp_on)
|
|
|
|
|
atombios_set_edp_panel_power(connector,
|
|
|
|
|
ATOM_TRANSMITTER_ACTION_POWER_OFF);
|
|
|
|
|
} else {
|
|
|
|
|
/* need to setup ddc on the bridge */
|
|
|
|
|
if (radeon_connector_encoder_get_dp_bridge_encoder_id(connector) !=
|
|
|
|
|
ENCODER_OBJECT_ID_NONE) {
|
|
|
|
|
if (encoder)
|
|
|
|
|
radeon_atom_ext_encoder_setup_ddc(encoder);
|
|
|
|
|
}
|
2014-07-15 14:38:10 +00:00
|
|
|
radeon_connector_get_edid(connector);
|
|
|
|
|
ret = radeon_ddc_get_modes(connector);
|
2012-02-28 16:08:22 +00:00
|
|
|
}
|
2011-05-20 08:34:31 +00:00
|
|
|
|
|
|
|
|
if (ret > 0) {
|
|
|
|
|
if (encoder) {
|
|
|
|
|
radeon_fixup_lvds_native_mode(encoder, connector);
|
|
|
|
|
/* add scaled modes */
|
|
|
|
|
radeon_add_common_modes(encoder, connector);
|
|
|
|
|
}
|
|
|
|
|
return ret;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (!encoder)
|
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
|
|
/* we have no EDID modes */
|
|
|
|
|
mode = radeon_fp_native_mode(encoder);
|
|
|
|
|
if (mode) {
|
|
|
|
|
ret = 1;
|
|
|
|
|
drm_mode_probed_add(connector, mode);
|
|
|
|
|
/* add the width/height from vbios tables if available */
|
|
|
|
|
connector->display_info.width_mm = mode->width_mm;
|
|
|
|
|
connector->display_info.height_mm = mode->height_mm;
|
|
|
|
|
/* add scaled modes */
|
|
|
|
|
radeon_add_common_modes(encoder, connector);
|
|
|
|
|
}
|
2011-06-13 21:13:34 +00:00
|
|
|
} else {
|
|
|
|
|
/* need to setup ddc on the bridge */
|
2011-10-31 12:58:47 +00:00
|
|
|
if (radeon_connector_encoder_get_dp_bridge_encoder_id(connector) !=
|
|
|
|
|
ENCODER_OBJECT_ID_NONE) {
|
2011-06-13 21:13:34 +00:00
|
|
|
if (encoder)
|
|
|
|
|
radeon_atom_ext_encoder_setup_ddc(encoder);
|
|
|
|
|
}
|
2014-07-15 14:38:10 +00:00
|
|
|
radeon_connector_get_edid(connector);
|
|
|
|
|
ret = radeon_ddc_get_modes(connector);
|
2014-07-09 17:21:59 +00:00
|
|
|
|
|
|
|
|
radeon_get_native_mode(connector);
|
2011-06-13 21:13:34 +00:00
|
|
|
}
|
2010-11-17 07:54:42 +00:00
|
|
|
|
2009-12-07 21:07:28 +00:00
|
|
|
return ret;
|
|
|
|
|
}
|
|
|
|
|
|
2011-10-31 12:58:47 +00:00
|
|
|
u16 radeon_connector_encoder_get_dp_bridge_encoder_id(struct drm_connector *connector)
|
2011-05-20 08:34:21 +00:00
|
|
|
{
|
|
|
|
|
struct drm_encoder *encoder;
|
|
|
|
|
struct radeon_encoder *radeon_encoder;
|
|
|
|
|
int i;
|
|
|
|
|
|
|
|
|
|
for (i = 0; i < DRM_CONNECTOR_MAX_ENCODER; i++) {
|
|
|
|
|
if (connector->encoder_ids[i] == 0)
|
|
|
|
|
break;
|
|
|
|
|
|
2014-07-18 03:30:05 +00:00
|
|
|
encoder = drm_encoder_find(connector->dev, connector->encoder_ids[i]);
|
|
|
|
|
if (!encoder)
|
2011-05-20 08:34:21 +00:00
|
|
|
continue;
|
|
|
|
|
|
|
|
|
|
radeon_encoder = to_radeon_encoder(encoder);
|
|
|
|
|
|
|
|
|
|
switch (radeon_encoder->encoder_id) {
|
|
|
|
|
case ENCODER_OBJECT_ID_TRAVIS:
|
|
|
|
|
case ENCODER_OBJECT_ID_NUTMEG:
|
2011-10-31 12:58:47 +00:00
|
|
|
return radeon_encoder->encoder_id;
|
2011-05-20 08:34:21 +00:00
|
|
|
default:
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2011-10-31 12:58:47 +00:00
|
|
|
return ENCODER_OBJECT_ID_NONE;
|
2011-05-20 08:34:21 +00:00
|
|
|
}
|
|
|
|
|
|
2014-07-24 20:06:57 +00:00
|
|
|
static bool radeon_connector_encoder_is_hbr2(struct drm_connector *connector)
|
2011-05-20 08:34:21 +00:00
|
|
|
{
|
|
|
|
|
struct drm_encoder *encoder;
|
|
|
|
|
struct radeon_encoder *radeon_encoder;
|
|
|
|
|
int i;
|
|
|
|
|
bool found = false;
|
|
|
|
|
|
|
|
|
|
for (i = 0; i < DRM_CONNECTOR_MAX_ENCODER; i++) {
|
|
|
|
|
if (connector->encoder_ids[i] == 0)
|
|
|
|
|
break;
|
|
|
|
|
|
2014-07-18 03:30:05 +00:00
|
|
|
encoder = drm_encoder_find(connector->dev, connector->encoder_ids[i]);
|
|
|
|
|
if (!encoder)
|
2011-05-20 08:34:21 +00:00
|
|
|
continue;
|
|
|
|
|
|
|
|
|
|
radeon_encoder = to_radeon_encoder(encoder);
|
|
|
|
|
if (radeon_encoder->caps & ATOM_ENCODER_CAP_RECORD_HBR2)
|
|
|
|
|
found = true;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return found;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
bool radeon_connector_is_dp12_capable(struct drm_connector *connector)
|
|
|
|
|
{
|
|
|
|
|
struct drm_device *dev = connector->dev;
|
|
|
|
|
struct radeon_device *rdev = dev->dev_private;
|
|
|
|
|
|
|
|
|
|
if (ASIC_IS_DCE5(rdev) &&
|
2014-05-27 17:11:36 +00:00
|
|
|
(rdev->clock.default_dispclk >= 53900) &&
|
2011-05-20 08:34:21 +00:00
|
|
|
radeon_connector_encoder_is_hbr2(connector)) {
|
|
|
|
|
return true;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return false;
|
|
|
|
|
}
|
|
|
|
|
|
2010-09-09 22:51:02 +00:00
|
|
|
static enum drm_connector_status
|
2010-09-14 10:07:23 +00:00
|
|
|
radeon_dp_detect(struct drm_connector *connector, bool force)
|
2009-12-07 21:07:28 +00:00
|
|
|
{
|
2011-05-20 08:34:23 +00:00
|
|
|
struct drm_device *dev = connector->dev;
|
|
|
|
|
struct radeon_device *rdev = dev->dev_private;
|
2009-12-07 21:07:28 +00:00
|
|
|
struct radeon_connector *radeon_connector = to_radeon_connector(connector);
|
|
|
|
|
enum drm_connector_status ret = connector_status_disconnected;
|
2009-11-23 23:02:35 +00:00
|
|
|
struct radeon_connector_atom_dig *radeon_dig_connector = radeon_connector->con_priv;
|
2011-06-13 21:13:34 +00:00
|
|
|
struct drm_encoder *encoder = radeon_best_single_encoder(connector);
|
2012-09-17 04:40:31 +00:00
|
|
|
int r;
|
2009-12-07 21:07:28 +00:00
|
|
|
|
2015-02-23 23:24:04 +00:00
|
|
|
if (radeon_dig_connector->is_mst)
|
|
|
|
|
return connector_status_disconnected;
|
|
|
|
|
|
2012-09-17 04:40:31 +00:00
|
|
|
r = pm_runtime_get_sync(connector->dev->dev);
|
|
|
|
|
if (r < 0)
|
|
|
|
|
return connector_status_disconnected;
|
|
|
|
|
|
|
|
|
|
if (!force && radeon_check_hpd_status_unchanged(connector)) {
|
|
|
|
|
ret = connector->status;
|
|
|
|
|
goto out;
|
|
|
|
|
}
|
2012-03-16 16:22:11 +00:00
|
|
|
|
2014-07-15 14:38:10 +00:00
|
|
|
radeon_connector_free_edid(connector);
|
2009-12-07 21:07:28 +00:00
|
|
|
|
2011-06-13 21:13:35 +00:00
|
|
|
if ((connector->connector_type == DRM_MODE_CONNECTOR_eDP) ||
|
|
|
|
|
(connector->connector_type == DRM_MODE_CONNECTOR_LVDS)) {
|
2011-05-20 08:34:31 +00:00
|
|
|
if (encoder) {
|
|
|
|
|
struct radeon_encoder *radeon_encoder = to_radeon_encoder(encoder);
|
|
|
|
|
struct drm_display_mode *native_mode = &radeon_encoder->native_mode;
|
|
|
|
|
|
|
|
|
|
/* check if panel is valid */
|
|
|
|
|
if (native_mode->hdisplay >= 320 && native_mode->vdisplay >= 240)
|
|
|
|
|
ret = connector_status_connected;
|
2014-11-14 17:08:34 +00:00
|
|
|
/* don't fetch the edid from the vbios if ddc fails and runpm is
|
|
|
|
|
* enabled so we report disconnected.
|
|
|
|
|
*/
|
|
|
|
|
if ((rdev->flags & RADEON_IS_PX) && (radeon_runtime_pm != 0))
|
|
|
|
|
ret = connector_status_disconnected;
|
2011-05-20 08:34:31 +00:00
|
|
|
}
|
2010-08-19 21:29:03 +00:00
|
|
|
/* eDP is always DP */
|
|
|
|
|
radeon_dig_connector->dp_sink_type = CONNECTOR_OBJECT_ID_DISPLAYPORT;
|
2010-11-17 07:54:42 +00:00
|
|
|
if (!radeon_dig_connector->edp_on)
|
|
|
|
|
atombios_set_edp_panel_power(connector,
|
|
|
|
|
ATOM_TRANSMITTER_ACTION_POWER_ON);
|
2010-08-19 21:29:03 +00:00
|
|
|
if (radeon_dp_getdpcd(radeon_connector))
|
2009-11-27 18:01:46 +00:00
|
|
|
ret = connector_status_connected;
|
2010-11-17 07:54:42 +00:00
|
|
|
if (!radeon_dig_connector->edp_on)
|
|
|
|
|
atombios_set_edp_panel_power(connector,
|
|
|
|
|
ATOM_TRANSMITTER_ACTION_POWER_OFF);
|
2011-10-31 12:58:47 +00:00
|
|
|
} else if (radeon_connector_encoder_get_dp_bridge_encoder_id(connector) !=
|
|
|
|
|
ENCODER_OBJECT_ID_NONE) {
|
2011-09-02 14:23:09 +00:00
|
|
|
/* DP bridges are always DP */
|
|
|
|
|
radeon_dig_connector->dp_sink_type = CONNECTOR_OBJECT_ID_DISPLAYPORT;
|
|
|
|
|
/* get the DPCD from the bridge */
|
|
|
|
|
radeon_dp_getdpcd(radeon_connector);
|
|
|
|
|
|
2011-10-04 16:23:24 +00:00
|
|
|
if (encoder) {
|
|
|
|
|
/* setup ddc on the bridge */
|
|
|
|
|
radeon_atom_ext_encoder_setup_ddc(encoder);
|
2013-01-03 18:09:28 +00:00
|
|
|
/* bridge chips are always aux */
|
|
|
|
|
if (radeon_ddc_probe(radeon_connector, true)) /* try DDC */
|
2011-09-02 14:23:09 +00:00
|
|
|
ret = connector_status_connected;
|
2011-10-04 16:23:24 +00:00
|
|
|
else if (radeon_connector->dac_load_detect) { /* try load detection */
|
2015-03-11 09:51:02 +00:00
|
|
|
const struct drm_encoder_helper_funcs *encoder_funcs = encoder->helper_private;
|
2011-09-02 14:23:09 +00:00
|
|
|
ret = encoder_funcs->detect(encoder, connector);
|
|
|
|
|
}
|
2011-06-13 21:13:34 +00:00
|
|
|
}
|
2011-09-02 14:23:09 +00:00
|
|
|
} else {
|
2010-08-19 21:29:03 +00:00
|
|
|
radeon_dig_connector->dp_sink_type = radeon_dp_getsinktype(radeon_connector);
|
2011-05-20 08:34:23 +00:00
|
|
|
if (radeon_hpd_sense(rdev, radeon_connector->hpd.hpd)) {
|
|
|
|
|
ret = connector_status_connected;
|
2015-02-23 23:24:04 +00:00
|
|
|
if (radeon_dig_connector->dp_sink_type == CONNECTOR_OBJECT_ID_DISPLAYPORT) {
|
2011-05-20 08:34:23 +00:00
|
|
|
radeon_dp_getdpcd(radeon_connector);
|
2015-02-23 23:24:04 +00:00
|
|
|
r = radeon_dp_mst_probe(radeon_connector);
|
|
|
|
|
if (r == 1)
|
|
|
|
|
ret = connector_status_disconnected;
|
|
|
|
|
}
|
2010-08-19 21:29:03 +00:00
|
|
|
} else {
|
2011-05-20 08:34:23 +00:00
|
|
|
if (radeon_dig_connector->dp_sink_type == CONNECTOR_OBJECT_ID_DISPLAYPORT) {
|
2015-02-23 23:24:04 +00:00
|
|
|
if (radeon_dp_getdpcd(radeon_connector)) {
|
|
|
|
|
r = radeon_dp_mst_probe(radeon_connector);
|
|
|
|
|
if (r == 1)
|
|
|
|
|
ret = connector_status_disconnected;
|
|
|
|
|
else
|
|
|
|
|
ret = connector_status_connected;
|
|
|
|
|
}
|
2011-05-20 08:34:23 +00:00
|
|
|
} else {
|
2013-09-13 15:37:28 +00:00
|
|
|
/* try non-aux ddc (DP to DVI/HDMI/etc. adapter) */
|
2013-01-03 18:09:28 +00:00
|
|
|
if (radeon_ddc_probe(radeon_connector, false))
|
2011-05-20 08:34:23 +00:00
|
|
|
ret = connector_status_connected;
|
|
|
|
|
}
|
2009-11-23 23:02:35 +00:00
|
|
|
}
|
2009-12-07 21:07:28 +00:00
|
|
|
}
|
2009-11-23 23:02:35 +00:00
|
|
|
|
2010-08-21 15:09:14 +00:00
|
|
|
radeon_connector_update_scratch_regs(connector, ret);
|
2014-12-01 18:49:39 +00:00
|
|
|
|
2015-07-23 14:01:09 +00:00
|
|
|
if ((radeon_audio != 0) && encoder) {
|
|
|
|
|
radeon_connector_get_edid(connector);
|
|
|
|
|
radeon_audio_detect(connector, encoder, ret);
|
|
|
|
|
}
|
2014-12-01 18:49:39 +00:00
|
|
|
|
2012-09-17 04:40:31 +00:00
|
|
|
out:
|
|
|
|
|
pm_runtime_mark_last_busy(connector->dev->dev);
|
|
|
|
|
pm_runtime_put_autosuspend(connector->dev->dev);
|
|
|
|
|
|
2009-12-07 21:07:28 +00:00
|
|
|
return ret;
|
|
|
|
|
}
|
|
|
|
|
|
2009-11-24 18:32:59 +00:00
|
|
|
static int radeon_dp_mode_valid(struct drm_connector *connector,
|
|
|
|
|
struct drm_display_mode *mode)
|
|
|
|
|
{
|
2014-06-16 21:42:34 +00:00
|
|
|
struct drm_device *dev = connector->dev;
|
|
|
|
|
struct radeon_device *rdev = dev->dev_private;
|
2009-11-24 18:32:59 +00:00
|
|
|
struct radeon_connector *radeon_connector = to_radeon_connector(connector);
|
|
|
|
|
struct radeon_connector_atom_dig *radeon_dig_connector = radeon_connector->con_priv;
|
|
|
|
|
|
|
|
|
|
/* XXX check mode bandwidth */
|
|
|
|
|
|
2011-06-13 21:13:35 +00:00
|
|
|
if ((connector->connector_type == DRM_MODE_CONNECTOR_eDP) ||
|
|
|
|
|
(connector->connector_type == DRM_MODE_CONNECTOR_LVDS)) {
|
2011-05-20 08:34:31 +00:00
|
|
|
struct drm_encoder *encoder = radeon_best_single_encoder(connector);
|
|
|
|
|
|
|
|
|
|
if ((mode->hdisplay < 320) || (mode->vdisplay < 240))
|
|
|
|
|
return MODE_PANEL;
|
|
|
|
|
|
|
|
|
|
if (encoder) {
|
|
|
|
|
struct radeon_encoder *radeon_encoder = to_radeon_encoder(encoder);
|
|
|
|
|
struct drm_display_mode *native_mode = &radeon_encoder->native_mode;
|
|
|
|
|
|
2011-06-13 21:13:35 +00:00
|
|
|
/* AVIVO hardware supports downscaling modes larger than the panel
|
2011-05-20 08:34:31 +00:00
|
|
|
* to the panel size, but I'm not sure this is desirable.
|
|
|
|
|
*/
|
|
|
|
|
if ((mode->hdisplay > native_mode->hdisplay) ||
|
|
|
|
|
(mode->vdisplay > native_mode->vdisplay))
|
|
|
|
|
return MODE_PANEL;
|
|
|
|
|
|
|
|
|
|
/* if scaling is disabled, block non-native modes */
|
|
|
|
|
if (radeon_encoder->rmx_type == RMX_OFF) {
|
|
|
|
|
if ((mode->hdisplay != native_mode->hdisplay) ||
|
|
|
|
|
(mode->vdisplay != native_mode->vdisplay))
|
|
|
|
|
return MODE_PANEL;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
} else {
|
|
|
|
|
if ((radeon_dig_connector->dp_sink_type == CONNECTOR_OBJECT_ID_DISPLAYPORT) ||
|
2014-06-16 21:42:34 +00:00
|
|
|
(radeon_dig_connector->dp_sink_type == CONNECTOR_OBJECT_ID_eDP)) {
|
2011-05-20 08:34:31 +00:00
|
|
|
return radeon_dp_mode_valid_helper(connector, mode);
|
2014-06-16 21:42:34 +00:00
|
|
|
} else {
|
2014-07-15 15:00:47 +00:00
|
|
|
if (ASIC_IS_DCE6(rdev) && drm_detect_hdmi_monitor(radeon_connector_edid(connector))) {
|
2014-06-16 21:42:34 +00:00
|
|
|
/* HDMI 1.3+ supports max clock of 340 Mhz */
|
|
|
|
|
if (mode->clock > 340000)
|
|
|
|
|
return MODE_CLOCK_HIGH;
|
|
|
|
|
} else {
|
|
|
|
|
if (mode->clock > 165000)
|
|
|
|
|
return MODE_CLOCK_HIGH;
|
|
|
|
|
}
|
|
|
|
|
}
|
2011-05-20 08:34:31 +00:00
|
|
|
}
|
2014-06-16 21:42:34 +00:00
|
|
|
|
|
|
|
|
return MODE_OK;
|
2009-11-24 18:32:59 +00:00
|
|
|
}
|
|
|
|
|
|
2012-08-31 17:43:50 +00:00
|
|
|
static const struct drm_connector_helper_funcs radeon_dp_connector_helper_funcs = {
|
2009-12-07 21:07:28 +00:00
|
|
|
.get_modes = radeon_dp_get_modes,
|
2009-11-24 18:32:59 +00:00
|
|
|
.mode_valid = radeon_dp_mode_valid,
|
2009-12-07 21:07:28 +00:00
|
|
|
.best_encoder = radeon_dvi_encoder,
|
|
|
|
|
};
|
|
|
|
|
|
2012-08-31 17:43:50 +00:00
|
|
|
static const struct drm_connector_funcs radeon_dp_connector_funcs = {
|
2009-12-07 21:07:28 +00:00
|
|
|
.dpms = drm_helper_connector_dpms,
|
|
|
|
|
.detect = radeon_dp_detect,
|
|
|
|
|
.fill_modes = drm_helper_probe_single_connector_modes,
|
|
|
|
|
.set_property = radeon_connector_set_property,
|
2016-10-11 14:44:24 +00:00
|
|
|
.early_unregister = radeon_connector_unregister,
|
2014-04-07 14:33:46 +00:00
|
|
|
.destroy = radeon_connector_destroy,
|
2009-12-07 21:07:28 +00:00
|
|
|
.force = radeon_dvi_force,
|
|
|
|
|
};
|
|
|
|
|
|
2013-09-13 22:33:16 +00:00
|
|
|
static const struct drm_connector_funcs radeon_edp_connector_funcs = {
|
|
|
|
|
.dpms = drm_helper_connector_dpms,
|
|
|
|
|
.detect = radeon_dp_detect,
|
|
|
|
|
.fill_modes = drm_helper_probe_single_connector_modes,
|
|
|
|
|
.set_property = radeon_lvds_set_property,
|
2016-10-11 14:44:24 +00:00
|
|
|
.early_unregister = radeon_connector_unregister,
|
2014-04-07 14:33:46 +00:00
|
|
|
.destroy = radeon_connector_destroy,
|
2013-09-13 22:33:16 +00:00
|
|
|
.force = radeon_dvi_force,
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
static const struct drm_connector_funcs radeon_lvds_bridge_connector_funcs = {
|
|
|
|
|
.dpms = drm_helper_connector_dpms,
|
|
|
|
|
.detect = radeon_dp_detect,
|
|
|
|
|
.fill_modes = drm_helper_probe_single_connector_modes,
|
|
|
|
|
.set_property = radeon_lvds_set_property,
|
2016-10-11 14:44:24 +00:00
|
|
|
.early_unregister = radeon_connector_unregister,
|
2014-04-07 14:33:46 +00:00
|
|
|
.destroy = radeon_connector_destroy,
|
2013-09-13 22:33:16 +00:00
|
|
|
.force = radeon_dvi_force,
|
|
|
|
|
};
|
|
|
|
|
|
2009-06-05 12:42:42 +00:00
|
|
|
void
|
|
|
|
|
radeon_add_atom_connector(struct drm_device *dev,
|
|
|
|
|
uint32_t connector_id,
|
|
|
|
|
uint32_t supported_device,
|
|
|
|
|
int connector_type,
|
|
|
|
|
struct radeon_i2c_bus_rec *i2c_bus,
|
2009-11-05 18:16:01 +00:00
|
|
|
uint32_t igp_lane_info,
|
2009-12-04 19:45:27 +00:00
|
|
|
uint16_t connector_object_id,
|
2010-08-06 01:21:18 +00:00
|
|
|
struct radeon_hpd *hpd,
|
|
|
|
|
struct radeon_router *router)
|
2009-06-05 12:42:42 +00:00
|
|
|
{
|
2009-09-09 07:40:54 +00:00
|
|
|
struct radeon_device *rdev = dev->dev_private;
|
2009-06-05 12:42:42 +00:00
|
|
|
struct drm_connector *connector;
|
|
|
|
|
struct radeon_connector *radeon_connector;
|
|
|
|
|
struct radeon_connector_atom_dig *radeon_dig_connector;
|
2011-05-20 08:34:22 +00:00
|
|
|
struct drm_encoder *encoder;
|
|
|
|
|
struct radeon_encoder *radeon_encoder;
|
2009-06-05 12:42:42 +00:00
|
|
|
uint32_t subpixel_order = SubPixelNone;
|
2009-10-15 20:16:35 +00:00
|
|
|
bool shared_ddc = false;
|
2011-05-20 08:34:22 +00:00
|
|
|
bool is_dp_bridge = false;
|
2014-03-21 14:34:07 +00:00
|
|
|
bool has_aux = false;
|
2009-06-05 12:42:42 +00:00
|
|
|
|
2009-08-13 06:32:14 +00:00
|
|
|
if (connector_type == DRM_MODE_CONNECTOR_Unknown)
|
2009-06-05 12:42:42 +00:00
|
|
|
return;
|
|
|
|
|
|
2010-09-01 21:15:06 +00:00
|
|
|
/* if the user selected tv=0 don't try and add the connector */
|
|
|
|
|
if (((connector_type == DRM_MODE_CONNECTOR_SVIDEO) ||
|
|
|
|
|
(connector_type == DRM_MODE_CONNECTOR_Composite) ||
|
|
|
|
|
(connector_type == DRM_MODE_CONNECTOR_9PinDIN)) &&
|
|
|
|
|
(radeon_tv == 0))
|
|
|
|
|
return;
|
|
|
|
|
|
2009-06-05 12:42:42 +00:00
|
|
|
/* see if we already added it */
|
|
|
|
|
list_for_each_entry(connector, &dev->mode_config.connector_list, head) {
|
|
|
|
|
radeon_connector = to_radeon_connector(connector);
|
|
|
|
|
if (radeon_connector->connector_id == connector_id) {
|
|
|
|
|
radeon_connector->devices |= supported_device;
|
|
|
|
|
return;
|
|
|
|
|
}
|
2009-10-15 20:16:35 +00:00
|
|
|
if (radeon_connector->ddc_bus && i2c_bus->valid) {
|
2010-02-19 07:13:56 +00:00
|
|
|
if (radeon_connector->ddc_bus->rec.i2c_id == i2c_bus->i2c_id) {
|
2009-10-15 20:16:35 +00:00
|
|
|
radeon_connector->shared_ddc = true;
|
|
|
|
|
shared_ddc = true;
|
|
|
|
|
}
|
2010-11-08 16:08:29 +00:00
|
|
|
if (radeon_connector->router_bus && router->ddc_valid &&
|
2010-08-06 01:21:18 +00:00
|
|
|
(radeon_connector->router.router_id == router->router_id)) {
|
|
|
|
|
radeon_connector->shared_ddc = false;
|
|
|
|
|
shared_ddc = false;
|
|
|
|
|
}
|
2009-10-15 20:16:35 +00:00
|
|
|
}
|
2009-06-05 12:42:42 +00:00
|
|
|
}
|
|
|
|
|
|
2011-05-20 08:34:22 +00:00
|
|
|
/* check if it's a dp bridge */
|
|
|
|
|
list_for_each_entry(encoder, &dev->mode_config.encoder_list, head) {
|
|
|
|
|
radeon_encoder = to_radeon_encoder(encoder);
|
|
|
|
|
if (radeon_encoder->devices & supported_device) {
|
|
|
|
|
switch (radeon_encoder->encoder_id) {
|
|
|
|
|
case ENCODER_OBJECT_ID_TRAVIS:
|
|
|
|
|
case ENCODER_OBJECT_ID_NUTMEG:
|
|
|
|
|
is_dp_bridge = true;
|
|
|
|
|
break;
|
|
|
|
|
default:
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2009-06-05 12:42:42 +00:00
|
|
|
radeon_connector = kzalloc(sizeof(struct radeon_connector), GFP_KERNEL);
|
|
|
|
|
if (!radeon_connector)
|
|
|
|
|
return;
|
|
|
|
|
|
|
|
|
|
connector = &radeon_connector->base;
|
|
|
|
|
|
|
|
|
|
radeon_connector->connector_id = connector_id;
|
|
|
|
|
radeon_connector->devices = supported_device;
|
2009-10-15 20:16:35 +00:00
|
|
|
radeon_connector->shared_ddc = shared_ddc;
|
2009-11-05 18:16:01 +00:00
|
|
|
radeon_connector->connector_object_id = connector_object_id;
|
2009-12-04 19:45:27 +00:00
|
|
|
radeon_connector->hpd = *hpd;
|
2011-10-30 20:54:27 +00:00
|
|
|
|
2010-08-06 01:21:18 +00:00
|
|
|
radeon_connector->router = *router;
|
2010-11-08 16:08:29 +00:00
|
|
|
if (router->ddc_valid || router->cd_valid) {
|
2010-08-06 01:21:18 +00:00
|
|
|
radeon_connector->router_bus = radeon_i2c_lookup(rdev, &router->i2c_info);
|
|
|
|
|
if (!radeon_connector->router_bus)
|
2011-04-14 21:24:07 +00:00
|
|
|
DRM_ERROR("Failed to assign router i2c bus! Check dmesg for i2c errors.\n");
|
2010-08-06 01:21:18 +00:00
|
|
|
}
|
2011-05-20 08:34:22 +00:00
|
|
|
|
|
|
|
|
if (is_dp_bridge) {
|
2009-06-05 12:42:42 +00:00
|
|
|
radeon_dig_connector = kzalloc(sizeof(struct radeon_connector_atom_dig), GFP_KERNEL);
|
|
|
|
|
if (!radeon_dig_connector)
|
|
|
|
|
goto failed;
|
|
|
|
|
radeon_dig_connector->igp_lane_info = igp_lane_info;
|
|
|
|
|
radeon_connector->con_priv = radeon_dig_connector;
|
|
|
|
|
if (i2c_bus->valid) {
|
2014-04-07 14:33:46 +00:00
|
|
|
radeon_connector->ddc_bus = radeon_i2c_lookup(rdev, i2c_bus);
|
|
|
|
|
if (radeon_connector->ddc_bus)
|
2014-03-21 14:34:07 +00:00
|
|
|
has_aux = true;
|
|
|
|
|
else
|
2011-05-20 08:34:22 +00:00
|
|
|
DRM_ERROR("DP: Failed to assign ddc bus! Check dmesg for i2c errors.\n");
|
2009-06-05 12:42:42 +00:00
|
|
|
}
|
2011-05-20 08:34:22 +00:00
|
|
|
switch (connector_type) {
|
|
|
|
|
case DRM_MODE_CONNECTOR_VGA:
|
|
|
|
|
case DRM_MODE_CONNECTOR_DVIA:
|
|
|
|
|
default:
|
2013-09-13 22:33:16 +00:00
|
|
|
drm_connector_init(dev, &radeon_connector->base,
|
|
|
|
|
&radeon_dp_connector_funcs, connector_type);
|
|
|
|
|
drm_connector_helper_add(&radeon_connector->base,
|
|
|
|
|
&radeon_dp_connector_helper_funcs);
|
2011-05-20 08:34:22 +00:00
|
|
|
connector->interlace_allowed = true;
|
|
|
|
|
connector->doublescan_allowed = true;
|
2011-06-13 21:13:33 +00:00
|
|
|
radeon_connector->dac_load_detect = true;
|
2012-10-12 01:44:52 +00:00
|
|
|
drm_object_attach_property(&radeon_connector->base.base,
|
2011-06-13 21:13:33 +00:00
|
|
|
rdev->mode_info.load_detect_property,
|
|
|
|
|
1);
|
2014-07-09 17:21:59 +00:00
|
|
|
drm_object_attach_property(&radeon_connector->base.base,
|
|
|
|
|
dev->mode_config.scaling_mode_property,
|
|
|
|
|
DRM_MODE_SCALE_NONE);
|
2015-02-23 15:59:36 +00:00
|
|
|
if (ASIC_IS_DCE5(rdev))
|
|
|
|
|
drm_object_attach_property(&radeon_connector->base.base,
|
|
|
|
|
rdev->mode_info.output_csc_property,
|
|
|
|
|
RADEON_OUTPUT_CSC_BYPASS);
|
2011-05-20 08:34:22 +00:00
|
|
|
break;
|
|
|
|
|
case DRM_MODE_CONNECTOR_DVII:
|
|
|
|
|
case DRM_MODE_CONNECTOR_DVID:
|
|
|
|
|
case DRM_MODE_CONNECTOR_HDMIA:
|
|
|
|
|
case DRM_MODE_CONNECTOR_HDMIB:
|
|
|
|
|
case DRM_MODE_CONNECTOR_DisplayPort:
|
2013-09-13 22:33:16 +00:00
|
|
|
drm_connector_init(dev, &radeon_connector->base,
|
|
|
|
|
&radeon_dp_connector_funcs, connector_type);
|
|
|
|
|
drm_connector_helper_add(&radeon_connector->base,
|
|
|
|
|
&radeon_dp_connector_helper_funcs);
|
2012-10-12 01:44:52 +00:00
|
|
|
drm_object_attach_property(&radeon_connector->base.base,
|
2010-08-04 07:45:04 +00:00
|
|
|
rdev->mode_info.underscan_property,
|
2011-01-05 16:57:52 +00:00
|
|
|
UNDERSCAN_OFF);
|
2012-10-12 01:44:52 +00:00
|
|
|
drm_object_attach_property(&radeon_connector->base.base,
|
2010-09-21 19:30:59 +00:00
|
|
|
rdev->mode_info.underscan_hborder_property,
|
|
|
|
|
0);
|
2012-10-12 01:44:52 +00:00
|
|
|
drm_object_attach_property(&radeon_connector->base.base,
|
2010-09-21 19:30:59 +00:00
|
|
|
rdev->mode_info.underscan_vborder_property,
|
|
|
|
|
0);
|
2013-11-08 06:34:39 +00:00
|
|
|
|
2014-07-09 17:21:59 +00:00
|
|
|
drm_object_attach_property(&radeon_connector->base.base,
|
|
|
|
|
dev->mode_config.scaling_mode_property,
|
|
|
|
|
DRM_MODE_SCALE_NONE);
|
|
|
|
|
|
2013-09-24 21:26:26 +00:00
|
|
|
drm_object_attach_property(&radeon_connector->base.base,
|
|
|
|
|
rdev->mode_info.dither_property,
|
|
|
|
|
RADEON_FMT_DITHER_DISABLE);
|
2013-11-08 06:34:39 +00:00
|
|
|
|
2016-04-13 16:08:27 +00:00
|
|
|
if (radeon_audio != 0) {
|
2013-10-14 17:17:50 +00:00
|
|
|
drm_object_attach_property(&radeon_connector->base.base,
|
|
|
|
|
rdev->mode_info.audio_property,
|
2013-11-08 18:03:47 +00:00
|
|
|
RADEON_AUDIO_AUTO);
|
2016-04-13 16:08:27 +00:00
|
|
|
radeon_connector->audio = RADEON_AUDIO_AUTO;
|
|
|
|
|
}
|
2015-02-23 15:59:36 +00:00
|
|
|
if (ASIC_IS_DCE5(rdev))
|
|
|
|
|
drm_object_attach_property(&radeon_connector->base.base,
|
|
|
|
|
rdev->mode_info.output_csc_property,
|
|
|
|
|
RADEON_OUTPUT_CSC_BYPASS);
|
2013-11-08 06:34:39 +00:00
|
|
|
|
2011-05-20 08:34:22 +00:00
|
|
|
subpixel_order = SubPixelHorizontalRGB;
|
|
|
|
|
connector->interlace_allowed = true;
|
|
|
|
|
if (connector_type == DRM_MODE_CONNECTOR_HDMIB)
|
|
|
|
|
connector->doublescan_allowed = true;
|
|
|
|
|
else
|
|
|
|
|
connector->doublescan_allowed = false;
|
2011-06-13 21:13:33 +00:00
|
|
|
if (connector_type == DRM_MODE_CONNECTOR_DVII) {
|
|
|
|
|
radeon_connector->dac_load_detect = true;
|
2012-10-12 01:44:52 +00:00
|
|
|
drm_object_attach_property(&radeon_connector->base.base,
|
2011-06-13 21:13:33 +00:00
|
|
|
rdev->mode_info.load_detect_property,
|
|
|
|
|
1);
|
|
|
|
|
}
|
2011-05-20 08:34:22 +00:00
|
|
|
break;
|
|
|
|
|
case DRM_MODE_CONNECTOR_LVDS:
|
|
|
|
|
case DRM_MODE_CONNECTOR_eDP:
|
2013-09-13 22:33:16 +00:00
|
|
|
drm_connector_init(dev, &radeon_connector->base,
|
|
|
|
|
&radeon_lvds_bridge_connector_funcs, connector_type);
|
|
|
|
|
drm_connector_helper_add(&radeon_connector->base,
|
|
|
|
|
&radeon_dp_connector_helper_funcs);
|
2012-10-12 01:44:52 +00:00
|
|
|
drm_object_attach_property(&radeon_connector->base.base,
|
2011-05-20 08:34:22 +00:00
|
|
|
dev->mode_config.scaling_mode_property,
|
|
|
|
|
DRM_MODE_SCALE_FULLSCREEN);
|
|
|
|
|
subpixel_order = SubPixelHorizontalRGB;
|
|
|
|
|
connector->interlace_allowed = false;
|
|
|
|
|
connector->doublescan_allowed = false;
|
|
|
|
|
break;
|
2010-09-21 19:30:59 +00:00
|
|
|
}
|
2011-05-20 08:34:22 +00:00
|
|
|
} else {
|
|
|
|
|
switch (connector_type) {
|
|
|
|
|
case DRM_MODE_CONNECTOR_VGA:
|
|
|
|
|
drm_connector_init(dev, &radeon_connector->base, &radeon_vga_connector_funcs, connector_type);
|
|
|
|
|
drm_connector_helper_add(&radeon_connector->base, &radeon_vga_connector_helper_funcs);
|
|
|
|
|
if (i2c_bus->valid) {
|
|
|
|
|
radeon_connector->ddc_bus = radeon_i2c_lookup(rdev, i2c_bus);
|
|
|
|
|
if (!radeon_connector->ddc_bus)
|
|
|
|
|
DRM_ERROR("VGA: Failed to assign ddc bus! Check dmesg for i2c errors.\n");
|
|
|
|
|
}
|
2009-12-08 17:48:20 +00:00
|
|
|
radeon_connector->dac_load_detect = true;
|
2012-10-12 01:44:52 +00:00
|
|
|
drm_object_attach_property(&radeon_connector->base.base,
|
2009-12-08 17:48:20 +00:00
|
|
|
rdev->mode_info.load_detect_property,
|
|
|
|
|
1);
|
2014-07-09 17:21:59 +00:00
|
|
|
if (ASIC_IS_AVIVO(rdev))
|
|
|
|
|
drm_object_attach_property(&radeon_connector->base.base,
|
|
|
|
|
dev->mode_config.scaling_mode_property,
|
|
|
|
|
DRM_MODE_SCALE_NONE);
|
2015-02-23 15:59:36 +00:00
|
|
|
if (ASIC_IS_DCE5(rdev))
|
|
|
|
|
drm_object_attach_property(&radeon_connector->base.base,
|
|
|
|
|
rdev->mode_info.output_csc_property,
|
|
|
|
|
RADEON_OUTPUT_CSC_BYPASS);
|
2011-05-20 08:34:22 +00:00
|
|
|
/* no HPD on analog connectors */
|
|
|
|
|
radeon_connector->hpd.hpd = RADEON_HPD_NONE;
|
|
|
|
|
connector->interlace_allowed = true;
|
2010-11-30 20:46:47 +00:00
|
|
|
connector->doublescan_allowed = true;
|
2011-05-20 08:34:22 +00:00
|
|
|
break;
|
|
|
|
|
case DRM_MODE_CONNECTOR_DVIA:
|
|
|
|
|
drm_connector_init(dev, &radeon_connector->base, &radeon_vga_connector_funcs, connector_type);
|
|
|
|
|
drm_connector_helper_add(&radeon_connector->base, &radeon_vga_connector_helper_funcs);
|
|
|
|
|
if (i2c_bus->valid) {
|
|
|
|
|
radeon_connector->ddc_bus = radeon_i2c_lookup(rdev, i2c_bus);
|
|
|
|
|
if (!radeon_connector->ddc_bus)
|
|
|
|
|
DRM_ERROR("DVIA: Failed to assign ddc bus! Check dmesg for i2c errors.\n");
|
|
|
|
|
}
|
|
|
|
|
radeon_connector->dac_load_detect = true;
|
2012-10-12 01:44:52 +00:00
|
|
|
drm_object_attach_property(&radeon_connector->base.base,
|
2011-05-20 08:34:22 +00:00
|
|
|
rdev->mode_info.load_detect_property,
|
|
|
|
|
1);
|
2014-07-09 17:21:59 +00:00
|
|
|
if (ASIC_IS_AVIVO(rdev))
|
|
|
|
|
drm_object_attach_property(&radeon_connector->base.base,
|
|
|
|
|
dev->mode_config.scaling_mode_property,
|
|
|
|
|
DRM_MODE_SCALE_NONE);
|
2015-02-23 15:59:36 +00:00
|
|
|
if (ASIC_IS_DCE5(rdev))
|
|
|
|
|
drm_object_attach_property(&radeon_connector->base.base,
|
|
|
|
|
rdev->mode_info.output_csc_property,
|
|
|
|
|
RADEON_OUTPUT_CSC_BYPASS);
|
2011-05-20 08:34:22 +00:00
|
|
|
/* no HPD on analog connectors */
|
|
|
|
|
radeon_connector->hpd.hpd = RADEON_HPD_NONE;
|
|
|
|
|
connector->interlace_allowed = true;
|
|
|
|
|
connector->doublescan_allowed = true;
|
|
|
|
|
break;
|
|
|
|
|
case DRM_MODE_CONNECTOR_DVII:
|
|
|
|
|
case DRM_MODE_CONNECTOR_DVID:
|
|
|
|
|
radeon_dig_connector = kzalloc(sizeof(struct radeon_connector_atom_dig), GFP_KERNEL);
|
|
|
|
|
if (!radeon_dig_connector)
|
|
|
|
|
goto failed;
|
|
|
|
|
radeon_dig_connector->igp_lane_info = igp_lane_info;
|
|
|
|
|
radeon_connector->con_priv = radeon_dig_connector;
|
|
|
|
|
drm_connector_init(dev, &radeon_connector->base, &radeon_dvi_connector_funcs, connector_type);
|
|
|
|
|
drm_connector_helper_add(&radeon_connector->base, &radeon_dvi_connector_helper_funcs);
|
|
|
|
|
if (i2c_bus->valid) {
|
|
|
|
|
radeon_connector->ddc_bus = radeon_i2c_lookup(rdev, i2c_bus);
|
|
|
|
|
if (!radeon_connector->ddc_bus)
|
|
|
|
|
DRM_ERROR("DVI: Failed to assign ddc bus! Check dmesg for i2c errors.\n");
|
|
|
|
|
}
|
|
|
|
|
subpixel_order = SubPixelHorizontalRGB;
|
2012-10-12 01:44:52 +00:00
|
|
|
drm_object_attach_property(&radeon_connector->base.base,
|
2011-05-20 08:34:22 +00:00
|
|
|
rdev->mode_info.coherent_mode_property,
|
|
|
|
|
1);
|
|
|
|
|
if (ASIC_IS_AVIVO(rdev)) {
|
2012-10-12 01:44:52 +00:00
|
|
|
drm_object_attach_property(&radeon_connector->base.base,
|
2011-05-20 08:34:22 +00:00
|
|
|
rdev->mode_info.underscan_property,
|
|
|
|
|
UNDERSCAN_OFF);
|
2012-10-12 01:44:52 +00:00
|
|
|
drm_object_attach_property(&radeon_connector->base.base,
|
2011-05-20 08:34:22 +00:00
|
|
|
rdev->mode_info.underscan_hborder_property,
|
|
|
|
|
0);
|
2012-10-12 01:44:52 +00:00
|
|
|
drm_object_attach_property(&radeon_connector->base.base,
|
2011-05-20 08:34:22 +00:00
|
|
|
rdev->mode_info.underscan_vborder_property,
|
|
|
|
|
0);
|
2014-07-09 17:21:59 +00:00
|
|
|
drm_object_attach_property(&radeon_connector->base.base,
|
|
|
|
|
rdev->mode_info.dither_property,
|
|
|
|
|
RADEON_FMT_DITHER_DISABLE);
|
|
|
|
|
drm_object_attach_property(&radeon_connector->base.base,
|
|
|
|
|
dev->mode_config.scaling_mode_property,
|
|
|
|
|
DRM_MODE_SCALE_NONE);
|
2011-05-20 08:34:22 +00:00
|
|
|
}
|
2013-10-14 17:17:50 +00:00
|
|
|
if (ASIC_IS_DCE2(rdev) && (radeon_audio != 0)) {
|
2013-09-03 18:58:44 +00:00
|
|
|
drm_object_attach_property(&radeon_connector->base.base,
|
2013-10-14 17:17:50 +00:00
|
|
|
rdev->mode_info.audio_property,
|
2013-11-08 18:03:47 +00:00
|
|
|
RADEON_AUDIO_AUTO);
|
2016-04-13 16:08:27 +00:00
|
|
|
radeon_connector->audio = RADEON_AUDIO_AUTO;
|
2013-09-03 18:58:44 +00:00
|
|
|
}
|
2011-05-20 08:34:22 +00:00
|
|
|
if (connector_type == DRM_MODE_CONNECTOR_DVII) {
|
|
|
|
|
radeon_connector->dac_load_detect = true;
|
2012-10-12 01:44:52 +00:00
|
|
|
drm_object_attach_property(&radeon_connector->base.base,
|
2011-05-20 08:34:22 +00:00
|
|
|
rdev->mode_info.load_detect_property,
|
|
|
|
|
1);
|
|
|
|
|
}
|
2015-02-23 15:59:36 +00:00
|
|
|
if (ASIC_IS_DCE5(rdev))
|
|
|
|
|
drm_object_attach_property(&radeon_connector->base.base,
|
|
|
|
|
rdev->mode_info.output_csc_property,
|
|
|
|
|
RADEON_OUTPUT_CSC_BYPASS);
|
2011-05-20 08:34:22 +00:00
|
|
|
connector->interlace_allowed = true;
|
|
|
|
|
if (connector_type == DRM_MODE_CONNECTOR_DVII)
|
|
|
|
|
connector->doublescan_allowed = true;
|
|
|
|
|
else
|
|
|
|
|
connector->doublescan_allowed = false;
|
|
|
|
|
break;
|
|
|
|
|
case DRM_MODE_CONNECTOR_HDMIA:
|
|
|
|
|
case DRM_MODE_CONNECTOR_HDMIB:
|
|
|
|
|
radeon_dig_connector = kzalloc(sizeof(struct radeon_connector_atom_dig), GFP_KERNEL);
|
|
|
|
|
if (!radeon_dig_connector)
|
|
|
|
|
goto failed;
|
|
|
|
|
radeon_dig_connector->igp_lane_info = igp_lane_info;
|
|
|
|
|
radeon_connector->con_priv = radeon_dig_connector;
|
|
|
|
|
drm_connector_init(dev, &radeon_connector->base, &radeon_dvi_connector_funcs, connector_type);
|
|
|
|
|
drm_connector_helper_add(&radeon_connector->base, &radeon_dvi_connector_helper_funcs);
|
|
|
|
|
if (i2c_bus->valid) {
|
|
|
|
|
radeon_connector->ddc_bus = radeon_i2c_lookup(rdev, i2c_bus);
|
|
|
|
|
if (!radeon_connector->ddc_bus)
|
|
|
|
|
DRM_ERROR("HDMI: Failed to assign ddc bus! Check dmesg for i2c errors.\n");
|
|
|
|
|
}
|
2012-10-12 01:44:52 +00:00
|
|
|
drm_object_attach_property(&radeon_connector->base.base,
|
2011-05-20 08:34:22 +00:00
|
|
|
rdev->mode_info.coherent_mode_property,
|
|
|
|
|
1);
|
|
|
|
|
if (ASIC_IS_AVIVO(rdev)) {
|
2012-10-12 01:44:52 +00:00
|
|
|
drm_object_attach_property(&radeon_connector->base.base,
|
2011-05-20 08:34:22 +00:00
|
|
|
rdev->mode_info.underscan_property,
|
|
|
|
|
UNDERSCAN_OFF);
|
2012-10-12 01:44:52 +00:00
|
|
|
drm_object_attach_property(&radeon_connector->base.base,
|
2011-05-20 08:34:22 +00:00
|
|
|
rdev->mode_info.underscan_hborder_property,
|
|
|
|
|
0);
|
2012-10-12 01:44:52 +00:00
|
|
|
drm_object_attach_property(&radeon_connector->base.base,
|
2011-05-20 08:34:22 +00:00
|
|
|
rdev->mode_info.underscan_vborder_property,
|
|
|
|
|
0);
|
2014-07-09 17:21:59 +00:00
|
|
|
drm_object_attach_property(&radeon_connector->base.base,
|
|
|
|
|
rdev->mode_info.dither_property,
|
|
|
|
|
RADEON_FMT_DITHER_DISABLE);
|
|
|
|
|
drm_object_attach_property(&radeon_connector->base.base,
|
|
|
|
|
dev->mode_config.scaling_mode_property,
|
|
|
|
|
DRM_MODE_SCALE_NONE);
|
2011-05-20 08:34:22 +00:00
|
|
|
}
|
2013-10-14 17:17:50 +00:00
|
|
|
if (ASIC_IS_DCE2(rdev) && (radeon_audio != 0)) {
|
2013-09-03 18:58:44 +00:00
|
|
|
drm_object_attach_property(&radeon_connector->base.base,
|
2013-10-14 17:17:50 +00:00
|
|
|
rdev->mode_info.audio_property,
|
2013-11-08 18:03:47 +00:00
|
|
|
RADEON_AUDIO_AUTO);
|
2016-04-13 16:08:27 +00:00
|
|
|
radeon_connector->audio = RADEON_AUDIO_AUTO;
|
2013-09-03 18:58:44 +00:00
|
|
|
}
|
2015-02-23 15:59:36 +00:00
|
|
|
if (ASIC_IS_DCE5(rdev))
|
|
|
|
|
drm_object_attach_property(&radeon_connector->base.base,
|
|
|
|
|
rdev->mode_info.output_csc_property,
|
|
|
|
|
RADEON_OUTPUT_CSC_BYPASS);
|
2011-05-20 08:34:22 +00:00
|
|
|
subpixel_order = SubPixelHorizontalRGB;
|
|
|
|
|
connector->interlace_allowed = true;
|
|
|
|
|
if (connector_type == DRM_MODE_CONNECTOR_HDMIB)
|
|
|
|
|
connector->doublescan_allowed = true;
|
|
|
|
|
else
|
|
|
|
|
connector->doublescan_allowed = false;
|
|
|
|
|
break;
|
|
|
|
|
case DRM_MODE_CONNECTOR_DisplayPort:
|
|
|
|
|
radeon_dig_connector = kzalloc(sizeof(struct radeon_connector_atom_dig), GFP_KERNEL);
|
|
|
|
|
if (!radeon_dig_connector)
|
|
|
|
|
goto failed;
|
|
|
|
|
radeon_dig_connector->igp_lane_info = igp_lane_info;
|
|
|
|
|
radeon_connector->con_priv = radeon_dig_connector;
|
|
|
|
|
drm_connector_init(dev, &radeon_connector->base, &radeon_dp_connector_funcs, connector_type);
|
|
|
|
|
drm_connector_helper_add(&radeon_connector->base, &radeon_dp_connector_helper_funcs);
|
|
|
|
|
if (i2c_bus->valid) {
|
|
|
|
|
radeon_connector->ddc_bus = radeon_i2c_lookup(rdev, i2c_bus);
|
2014-03-21 14:34:07 +00:00
|
|
|
if (radeon_connector->ddc_bus)
|
|
|
|
|
has_aux = true;
|
|
|
|
|
else
|
2011-05-20 08:34:22 +00:00
|
|
|
DRM_ERROR("DP: Failed to assign ddc bus! Check dmesg for i2c errors.\n");
|
|
|
|
|
}
|
|
|
|
|
subpixel_order = SubPixelHorizontalRGB;
|
2012-10-12 01:44:52 +00:00
|
|
|
drm_object_attach_property(&radeon_connector->base.base,
|
2011-05-20 08:34:22 +00:00
|
|
|
rdev->mode_info.coherent_mode_property,
|
|
|
|
|
1);
|
|
|
|
|
if (ASIC_IS_AVIVO(rdev)) {
|
2012-10-12 01:44:52 +00:00
|
|
|
drm_object_attach_property(&radeon_connector->base.base,
|
2011-05-20 08:34:22 +00:00
|
|
|
rdev->mode_info.underscan_property,
|
|
|
|
|
UNDERSCAN_OFF);
|
2012-10-12 01:44:52 +00:00
|
|
|
drm_object_attach_property(&radeon_connector->base.base,
|
2011-05-20 08:34:22 +00:00
|
|
|
rdev->mode_info.underscan_hborder_property,
|
|
|
|
|
0);
|
2012-10-12 01:44:52 +00:00
|
|
|
drm_object_attach_property(&radeon_connector->base.base,
|
2011-05-20 08:34:22 +00:00
|
|
|
rdev->mode_info.underscan_vborder_property,
|
|
|
|
|
0);
|
2014-07-09 17:21:59 +00:00
|
|
|
drm_object_attach_property(&radeon_connector->base.base,
|
|
|
|
|
rdev->mode_info.dither_property,
|
|
|
|
|
RADEON_FMT_DITHER_DISABLE);
|
|
|
|
|
drm_object_attach_property(&radeon_connector->base.base,
|
|
|
|
|
dev->mode_config.scaling_mode_property,
|
|
|
|
|
DRM_MODE_SCALE_NONE);
|
2011-05-20 08:34:22 +00:00
|
|
|
}
|
2013-10-14 17:17:50 +00:00
|
|
|
if (ASIC_IS_DCE2(rdev) && (radeon_audio != 0)) {
|
2013-09-03 18:58:44 +00:00
|
|
|
drm_object_attach_property(&radeon_connector->base.base,
|
2013-10-14 17:17:50 +00:00
|
|
|
rdev->mode_info.audio_property,
|
2013-11-08 18:03:47 +00:00
|
|
|
RADEON_AUDIO_AUTO);
|
2016-04-13 16:08:27 +00:00
|
|
|
radeon_connector->audio = RADEON_AUDIO_AUTO;
|
2013-09-03 18:58:44 +00:00
|
|
|
}
|
2015-02-23 15:59:36 +00:00
|
|
|
if (ASIC_IS_DCE5(rdev))
|
|
|
|
|
drm_object_attach_property(&radeon_connector->base.base,
|
|
|
|
|
rdev->mode_info.output_csc_property,
|
|
|
|
|
RADEON_OUTPUT_CSC_BYPASS);
|
2011-05-20 08:34:22 +00:00
|
|
|
connector->interlace_allowed = true;
|
|
|
|
|
/* in theory with a DP to VGA converter... */
|
2010-11-30 20:46:47 +00:00
|
|
|
connector->doublescan_allowed = false;
|
2011-05-20 08:34:22 +00:00
|
|
|
break;
|
|
|
|
|
case DRM_MODE_CONNECTOR_eDP:
|
|
|
|
|
radeon_dig_connector = kzalloc(sizeof(struct radeon_connector_atom_dig), GFP_KERNEL);
|
|
|
|
|
if (!radeon_dig_connector)
|
|
|
|
|
goto failed;
|
|
|
|
|
radeon_dig_connector->igp_lane_info = igp_lane_info;
|
|
|
|
|
radeon_connector->con_priv = radeon_dig_connector;
|
2013-09-13 22:33:16 +00:00
|
|
|
drm_connector_init(dev, &radeon_connector->base, &radeon_edp_connector_funcs, connector_type);
|
2011-05-20 08:34:22 +00:00
|
|
|
drm_connector_helper_add(&radeon_connector->base, &radeon_dp_connector_helper_funcs);
|
|
|
|
|
if (i2c_bus->valid) {
|
2014-04-07 14:33:46 +00:00
|
|
|
radeon_connector->ddc_bus = radeon_i2c_lookup(rdev, i2c_bus);
|
|
|
|
|
if (radeon_connector->ddc_bus)
|
2014-03-21 14:34:07 +00:00
|
|
|
has_aux = true;
|
|
|
|
|
else
|
2011-05-20 08:34:22 +00:00
|
|
|
DRM_ERROR("DP: Failed to assign ddc bus! Check dmesg for i2c errors.\n");
|
|
|
|
|
}
|
2012-10-12 01:44:52 +00:00
|
|
|
drm_object_attach_property(&radeon_connector->base.base,
|
2011-05-20 08:34:22 +00:00
|
|
|
dev->mode_config.scaling_mode_property,
|
|
|
|
|
DRM_MODE_SCALE_FULLSCREEN);
|
|
|
|
|
subpixel_order = SubPixelHorizontalRGB;
|
|
|
|
|
connector->interlace_allowed = false;
|
|
|
|
|
connector->doublescan_allowed = false;
|
|
|
|
|
break;
|
|
|
|
|
case DRM_MODE_CONNECTOR_SVIDEO:
|
|
|
|
|
case DRM_MODE_CONNECTOR_Composite:
|
|
|
|
|
case DRM_MODE_CONNECTOR_9PinDIN:
|
|
|
|
|
drm_connector_init(dev, &radeon_connector->base, &radeon_tv_connector_funcs, connector_type);
|
|
|
|
|
drm_connector_helper_add(&radeon_connector->base, &radeon_tv_connector_helper_funcs);
|
|
|
|
|
radeon_connector->dac_load_detect = true;
|
2012-10-12 01:44:52 +00:00
|
|
|
drm_object_attach_property(&radeon_connector->base.base,
|
2011-05-20 08:34:22 +00:00
|
|
|
rdev->mode_info.load_detect_property,
|
|
|
|
|
1);
|
2012-10-12 01:44:52 +00:00
|
|
|
drm_object_attach_property(&radeon_connector->base.base,
|
2011-05-20 08:34:22 +00:00
|
|
|
rdev->mode_info.tv_std_property,
|
|
|
|
|
radeon_atombios_get_tv_info(rdev));
|
|
|
|
|
/* no HPD on analog connectors */
|
|
|
|
|
radeon_connector->hpd.hpd = RADEON_HPD_NONE;
|
|
|
|
|
connector->interlace_allowed = false;
|
|
|
|
|
connector->doublescan_allowed = false;
|
|
|
|
|
break;
|
|
|
|
|
case DRM_MODE_CONNECTOR_LVDS:
|
|
|
|
|
radeon_dig_connector = kzalloc(sizeof(struct radeon_connector_atom_dig), GFP_KERNEL);
|
|
|
|
|
if (!radeon_dig_connector)
|
|
|
|
|
goto failed;
|
|
|
|
|
radeon_dig_connector->igp_lane_info = igp_lane_info;
|
|
|
|
|
radeon_connector->con_priv = radeon_dig_connector;
|
|
|
|
|
drm_connector_init(dev, &radeon_connector->base, &radeon_lvds_connector_funcs, connector_type);
|
|
|
|
|
drm_connector_helper_add(&radeon_connector->base, &radeon_lvds_connector_helper_funcs);
|
|
|
|
|
if (i2c_bus->valid) {
|
|
|
|
|
radeon_connector->ddc_bus = radeon_i2c_lookup(rdev, i2c_bus);
|
|
|
|
|
if (!radeon_connector->ddc_bus)
|
|
|
|
|
DRM_ERROR("LVDS: Failed to assign ddc bus! Check dmesg for i2c errors.\n");
|
|
|
|
|
}
|
2012-10-12 01:44:52 +00:00
|
|
|
drm_object_attach_property(&radeon_connector->base.base,
|
2011-05-20 08:34:22 +00:00
|
|
|
dev->mode_config.scaling_mode_property,
|
|
|
|
|
DRM_MODE_SCALE_FULLSCREEN);
|
|
|
|
|
subpixel_order = SubPixelHorizontalRGB;
|
|
|
|
|
connector->interlace_allowed = false;
|
|
|
|
|
connector->doublescan_allowed = false;
|
|
|
|
|
break;
|
2009-06-05 12:42:42 +00:00
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2010-07-20 07:24:11 +00:00
|
|
|
if (radeon_connector->hpd.hpd == RADEON_HPD_NONE) {
|
2016-06-24 21:54:31 +00:00
|
|
|
if (i2c_bus->valid) {
|
|
|
|
|
connector->polled = DRM_CONNECTOR_POLL_CONNECT |
|
|
|
|
|
DRM_CONNECTOR_POLL_DISCONNECT;
|
|
|
|
|
}
|
2010-05-07 06:42:51 +00:00
|
|
|
} else
|
|
|
|
|
connector->polled = DRM_CONNECTOR_POLL_HPD;
|
|
|
|
|
|
2009-06-05 12:42:42 +00:00
|
|
|
connector->display_info.subpixel_order = subpixel_order;
|
2014-05-29 15:57:41 +00:00
|
|
|
drm_connector_register(connector);
|
2014-03-21 14:34:07 +00:00
|
|
|
|
|
|
|
|
if (has_aux)
|
|
|
|
|
radeon_dp_aux_init(radeon_connector);
|
|
|
|
|
|
2009-06-05 12:42:42 +00:00
|
|
|
return;
|
|
|
|
|
|
|
|
|
|
failed:
|
|
|
|
|
drm_connector_cleanup(connector);
|
|
|
|
|
kfree(connector);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void
|
|
|
|
|
radeon_add_legacy_connector(struct drm_device *dev,
|
|
|
|
|
uint32_t connector_id,
|
|
|
|
|
uint32_t supported_device,
|
|
|
|
|
int connector_type,
|
2009-11-05 18:16:01 +00:00
|
|
|
struct radeon_i2c_bus_rec *i2c_bus,
|
2009-12-04 19:45:27 +00:00
|
|
|
uint16_t connector_object_id,
|
|
|
|
|
struct radeon_hpd *hpd)
|
2009-06-05 12:42:42 +00:00
|
|
|
{
|
2009-09-09 07:40:54 +00:00
|
|
|
struct radeon_device *rdev = dev->dev_private;
|
2009-06-05 12:42:42 +00:00
|
|
|
struct drm_connector *connector;
|
|
|
|
|
struct radeon_connector *radeon_connector;
|
|
|
|
|
uint32_t subpixel_order = SubPixelNone;
|
|
|
|
|
|
2009-08-13 06:32:14 +00:00
|
|
|
if (connector_type == DRM_MODE_CONNECTOR_Unknown)
|
2009-06-05 12:42:42 +00:00
|
|
|
return;
|
|
|
|
|
|
2010-09-01 21:15:06 +00:00
|
|
|
/* if the user selected tv=0 don't try and add the connector */
|
|
|
|
|
if (((connector_type == DRM_MODE_CONNECTOR_SVIDEO) ||
|
|
|
|
|
(connector_type == DRM_MODE_CONNECTOR_Composite) ||
|
|
|
|
|
(connector_type == DRM_MODE_CONNECTOR_9PinDIN)) &&
|
|
|
|
|
(radeon_tv == 0))
|
|
|
|
|
return;
|
|
|
|
|
|
2009-06-05 12:42:42 +00:00
|
|
|
/* see if we already added it */
|
|
|
|
|
list_for_each_entry(connector, &dev->mode_config.connector_list, head) {
|
|
|
|
|
radeon_connector = to_radeon_connector(connector);
|
|
|
|
|
if (radeon_connector->connector_id == connector_id) {
|
|
|
|
|
radeon_connector->devices |= supported_device;
|
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
radeon_connector = kzalloc(sizeof(struct radeon_connector), GFP_KERNEL);
|
|
|
|
|
if (!radeon_connector)
|
|
|
|
|
return;
|
|
|
|
|
|
|
|
|
|
connector = &radeon_connector->base;
|
|
|
|
|
|
|
|
|
|
radeon_connector->connector_id = connector_id;
|
|
|
|
|
radeon_connector->devices = supported_device;
|
2009-11-05 18:16:01 +00:00
|
|
|
radeon_connector->connector_object_id = connector_object_id;
|
2009-12-04 19:45:27 +00:00
|
|
|
radeon_connector->hpd = *hpd;
|
2011-10-30 20:54:27 +00:00
|
|
|
|
2009-06-05 12:42:42 +00:00
|
|
|
switch (connector_type) {
|
|
|
|
|
case DRM_MODE_CONNECTOR_VGA:
|
|
|
|
|
drm_connector_init(dev, &radeon_connector->base, &radeon_vga_connector_funcs, connector_type);
|
2010-03-30 05:34:15 +00:00
|
|
|
drm_connector_helper_add(&radeon_connector->base, &radeon_vga_connector_helper_funcs);
|
2009-06-05 12:42:42 +00:00
|
|
|
if (i2c_bus->valid) {
|
2010-08-06 01:21:16 +00:00
|
|
|
radeon_connector->ddc_bus = radeon_i2c_lookup(rdev, i2c_bus);
|
2009-06-05 12:42:42 +00:00
|
|
|
if (!radeon_connector->ddc_bus)
|
2011-04-14 21:24:07 +00:00
|
|
|
DRM_ERROR("VGA: Failed to assign ddc bus! Check dmesg for i2c errors.\n");
|
2009-06-05 12:42:42 +00:00
|
|
|
}
|
2009-09-25 01:56:50 +00:00
|
|
|
radeon_connector->dac_load_detect = true;
|
2012-10-12 01:44:52 +00:00
|
|
|
drm_object_attach_property(&radeon_connector->base.base,
|
2009-09-09 07:40:54 +00:00
|
|
|
rdev->mode_info.load_detect_property,
|
|
|
|
|
1);
|
2010-07-20 07:24:11 +00:00
|
|
|
/* no HPD on analog connectors */
|
|
|
|
|
radeon_connector->hpd.hpd = RADEON_HPD_NONE;
|
2010-11-30 20:46:47 +00:00
|
|
|
connector->interlace_allowed = true;
|
|
|
|
|
connector->doublescan_allowed = true;
|
2009-06-05 12:42:42 +00:00
|
|
|
break;
|
|
|
|
|
case DRM_MODE_CONNECTOR_DVIA:
|
|
|
|
|
drm_connector_init(dev, &radeon_connector->base, &radeon_vga_connector_funcs, connector_type);
|
2010-03-30 05:34:15 +00:00
|
|
|
drm_connector_helper_add(&radeon_connector->base, &radeon_vga_connector_helper_funcs);
|
2009-06-05 12:42:42 +00:00
|
|
|
if (i2c_bus->valid) {
|
2010-08-06 01:21:16 +00:00
|
|
|
radeon_connector->ddc_bus = radeon_i2c_lookup(rdev, i2c_bus);
|
2009-06-05 12:42:42 +00:00
|
|
|
if (!radeon_connector->ddc_bus)
|
2011-04-14 21:24:07 +00:00
|
|
|
DRM_ERROR("DVIA: Failed to assign ddc bus! Check dmesg for i2c errors.\n");
|
2009-06-05 12:42:42 +00:00
|
|
|
}
|
2009-09-25 01:56:50 +00:00
|
|
|
radeon_connector->dac_load_detect = true;
|
2012-10-12 01:44:52 +00:00
|
|
|
drm_object_attach_property(&radeon_connector->base.base,
|
2009-09-09 07:40:54 +00:00
|
|
|
rdev->mode_info.load_detect_property,
|
|
|
|
|
1);
|
2010-07-20 07:24:11 +00:00
|
|
|
/* no HPD on analog connectors */
|
|
|
|
|
radeon_connector->hpd.hpd = RADEON_HPD_NONE;
|
2010-11-30 20:46:47 +00:00
|
|
|
connector->interlace_allowed = true;
|
|
|
|
|
connector->doublescan_allowed = true;
|
2009-06-05 12:42:42 +00:00
|
|
|
break;
|
|
|
|
|
case DRM_MODE_CONNECTOR_DVII:
|
|
|
|
|
case DRM_MODE_CONNECTOR_DVID:
|
|
|
|
|
drm_connector_init(dev, &radeon_connector->base, &radeon_dvi_connector_funcs, connector_type);
|
2010-03-30 05:34:15 +00:00
|
|
|
drm_connector_helper_add(&radeon_connector->base, &radeon_dvi_connector_helper_funcs);
|
2009-06-05 12:42:42 +00:00
|
|
|
if (i2c_bus->valid) {
|
2010-08-06 01:21:16 +00:00
|
|
|
radeon_connector->ddc_bus = radeon_i2c_lookup(rdev, i2c_bus);
|
2009-06-05 12:42:42 +00:00
|
|
|
if (!radeon_connector->ddc_bus)
|
2011-04-14 21:24:07 +00:00
|
|
|
DRM_ERROR("DVI: Failed to assign ddc bus! Check dmesg for i2c errors.\n");
|
2010-04-30 16:37:31 +00:00
|
|
|
}
|
|
|
|
|
if (connector_type == DRM_MODE_CONNECTOR_DVII) {
|
2009-09-25 01:56:50 +00:00
|
|
|
radeon_connector->dac_load_detect = true;
|
2012-10-12 01:44:52 +00:00
|
|
|
drm_object_attach_property(&radeon_connector->base.base,
|
2009-09-09 07:40:54 +00:00
|
|
|
rdev->mode_info.load_detect_property,
|
|
|
|
|
1);
|
2009-06-05 12:42:42 +00:00
|
|
|
}
|
|
|
|
|
subpixel_order = SubPixelHorizontalRGB;
|
2010-11-30 20:46:47 +00:00
|
|
|
connector->interlace_allowed = true;
|
|
|
|
|
if (connector_type == DRM_MODE_CONNECTOR_DVII)
|
|
|
|
|
connector->doublescan_allowed = true;
|
|
|
|
|
else
|
|
|
|
|
connector->doublescan_allowed = false;
|
2009-06-05 12:42:42 +00:00
|
|
|
break;
|
|
|
|
|
case DRM_MODE_CONNECTOR_SVIDEO:
|
|
|
|
|
case DRM_MODE_CONNECTOR_Composite:
|
|
|
|
|
case DRM_MODE_CONNECTOR_9PinDIN:
|
2010-09-01 21:15:06 +00:00
|
|
|
drm_connector_init(dev, &radeon_connector->base, &radeon_tv_connector_funcs, connector_type);
|
|
|
|
|
drm_connector_helper_add(&radeon_connector->base, &radeon_tv_connector_helper_funcs);
|
|
|
|
|
radeon_connector->dac_load_detect = true;
|
|
|
|
|
/* RS400,RC410,RS480 chipset seems to report a lot
|
|
|
|
|
* of false positive on load detect, we haven't yet
|
|
|
|
|
* found a way to make load detect reliable on those
|
|
|
|
|
* chipset, thus just disable it for TV.
|
|
|
|
|
*/
|
|
|
|
|
if (rdev->family == CHIP_RS400 || rdev->family == CHIP_RS480)
|
|
|
|
|
radeon_connector->dac_load_detect = false;
|
2012-10-12 01:44:52 +00:00
|
|
|
drm_object_attach_property(&radeon_connector->base.base,
|
2010-09-01 21:15:06 +00:00
|
|
|
rdev->mode_info.load_detect_property,
|
|
|
|
|
radeon_connector->dac_load_detect);
|
2012-10-12 01:44:52 +00:00
|
|
|
drm_object_attach_property(&radeon_connector->base.base,
|
2010-09-01 21:15:06 +00:00
|
|
|
rdev->mode_info.tv_std_property,
|
|
|
|
|
radeon_combios_get_tv_info(rdev));
|
|
|
|
|
/* no HPD on analog connectors */
|
|
|
|
|
radeon_connector->hpd.hpd = RADEON_HPD_NONE;
|
2010-11-30 20:46:47 +00:00
|
|
|
connector->interlace_allowed = false;
|
|
|
|
|
connector->doublescan_allowed = false;
|
2009-06-05 12:42:42 +00:00
|
|
|
break;
|
|
|
|
|
case DRM_MODE_CONNECTOR_LVDS:
|
|
|
|
|
drm_connector_init(dev, &radeon_connector->base, &radeon_lvds_connector_funcs, connector_type);
|
2010-03-30 05:34:15 +00:00
|
|
|
drm_connector_helper_add(&radeon_connector->base, &radeon_lvds_connector_helper_funcs);
|
2009-06-05 12:42:42 +00:00
|
|
|
if (i2c_bus->valid) {
|
2010-08-06 01:21:16 +00:00
|
|
|
radeon_connector->ddc_bus = radeon_i2c_lookup(rdev, i2c_bus);
|
2009-06-05 12:42:42 +00:00
|
|
|
if (!radeon_connector->ddc_bus)
|
2011-04-14 21:24:07 +00:00
|
|
|
DRM_ERROR("LVDS: Failed to assign ddc bus! Check dmesg for i2c errors.\n");
|
2009-06-05 12:42:42 +00:00
|
|
|
}
|
2012-10-12 01:44:52 +00:00
|
|
|
drm_object_attach_property(&radeon_connector->base.base,
|
2009-09-09 07:40:54 +00:00
|
|
|
dev->mode_config.scaling_mode_property,
|
|
|
|
|
DRM_MODE_SCALE_FULLSCREEN);
|
2009-06-05 12:42:42 +00:00
|
|
|
subpixel_order = SubPixelHorizontalRGB;
|
2010-11-30 20:46:47 +00:00
|
|
|
connector->interlace_allowed = false;
|
|
|
|
|
connector->doublescan_allowed = false;
|
2009-06-05 12:42:42 +00:00
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
|
2010-07-20 07:24:11 +00:00
|
|
|
if (radeon_connector->hpd.hpd == RADEON_HPD_NONE) {
|
2016-06-24 21:54:31 +00:00
|
|
|
if (i2c_bus->valid) {
|
|
|
|
|
connector->polled = DRM_CONNECTOR_POLL_CONNECT |
|
|
|
|
|
DRM_CONNECTOR_POLL_DISCONNECT;
|
|
|
|
|
}
|
2010-05-07 06:42:51 +00:00
|
|
|
} else
|
|
|
|
|
connector->polled = DRM_CONNECTOR_POLL_HPD;
|
2016-06-24 21:54:31 +00:00
|
|
|
|
2009-06-05 12:42:42 +00:00
|
|
|
connector->display_info.subpixel_order = subpixel_order;
|
2014-05-29 15:57:41 +00:00
|
|
|
drm_connector_register(connector);
|
2009-06-05 12:42:42 +00:00
|
|
|
}
|
2015-02-23 23:24:04 +00:00
|
|
|
|
|
|
|
|
void radeon_setup_mst_connector(struct drm_device *dev)
|
|
|
|
|
{
|
|
|
|
|
struct radeon_device *rdev = dev->dev_private;
|
|
|
|
|
struct drm_connector *connector;
|
|
|
|
|
struct radeon_connector *radeon_connector;
|
|
|
|
|
|
|
|
|
|
if (!ASIC_IS_DCE5(rdev))
|
|
|
|
|
return;
|
|
|
|
|
|
|
|
|
|
if (radeon_mst == 0)
|
|
|
|
|
return;
|
|
|
|
|
|
|
|
|
|
list_for_each_entry(connector, &dev->mode_config.connector_list, head) {
|
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
|
|
radeon_connector = to_radeon_connector(connector);
|
|
|
|
|
|
|
|
|
|
if (connector->connector_type != DRM_MODE_CONNECTOR_DisplayPort)
|
|
|
|
|
continue;
|
|
|
|
|
|
|
|
|
|
ret = radeon_dp_mst_init(radeon_connector);
|
|
|
|
|
}
|
|
|
|
|
}
|