2009-06-05 06:42:42 -06: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
|
|
|
|
*/
|
|
|
|
#include "drmP.h"
|
|
|
|
#include "drm_edid.h"
|
|
|
|
#include "drm_crtc_helper.h"
|
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-22 22:44:08 -06:00
|
|
|
#include "drm_fb_helper.h"
|
2009-06-05 06:42:42 -06:00
|
|
|
#include "radeon_drm.h"
|
|
|
|
#include "radeon.h"
|
2009-09-10 15:53:39 -06:00
|
|
|
#include "atom.h"
|
2009-06-05 06:42:42 -06:00
|
|
|
|
|
|
|
extern void
|
|
|
|
radeon_combios_connected_scratch_regs(struct drm_connector *connector,
|
|
|
|
struct drm_encoder *encoder,
|
|
|
|
bool connected);
|
|
|
|
extern void
|
|
|
|
radeon_atombios_connected_scratch_regs(struct drm_connector *connector,
|
|
|
|
struct drm_encoder *encoder,
|
|
|
|
bool connected);
|
|
|
|
|
2011-03-22 17:30:23 -06:00
|
|
|
extern void
|
|
|
|
radeon_legacy_backlight_init(struct radeon_encoder *radeon_encoder,
|
|
|
|
struct drm_connector *drm_connector);
|
|
|
|
|
2011-06-13 15:13:34 -06:00
|
|
|
bool radeon_connector_encoder_is_dp_bridge(struct drm_connector *connector);
|
|
|
|
|
2009-12-04 14:56:37 -07: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);
|
|
|
|
|
2011-07-11 08:49:28 -06: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 02:34:29 -06:00
|
|
|
radeon_hpd_set_polarity(rdev, radeon_connector->hpd.hpd);
|
2009-12-04 14:56:37 -07:00
|
|
|
|
2011-08-09 11:09:06 -06:00
|
|
|
/* if the connector is already off, don't turn it back on */
|
|
|
|
if (connector->dpms != DRM_MODE_DPMS_ON)
|
|
|
|
return;
|
|
|
|
|
2011-08-13 11:36:13 -06:00
|
|
|
/* just deal with DP (not eDP) here. */
|
|
|
|
if (connector->connector_type == DRM_MODE_CONNECTOR_DisplayPort) {
|
|
|
|
int saved_dpms = connector->dpms;
|
2011-05-20 02:34:30 -06:00
|
|
|
|
2011-10-03 06:37:33 -06:00
|
|
|
/* Only turn off the display it it's physically disconnected */
|
|
|
|
if (!radeon_hpd_sense(rdev, radeon_connector->hpd.hpd))
|
2011-05-20 02:34:29 -06:00
|
|
|
drm_helper_connector_dpms(connector, DRM_MODE_DPMS_OFF);
|
2011-10-03 06:37:33 -06:00
|
|
|
else if (radeon_dp_needs_link_train(radeon_connector))
|
|
|
|
drm_helper_connector_dpms(connector, DRM_MODE_DPMS_ON);
|
2011-08-13 11:36:13 -06:00
|
|
|
connector->dpms = saved_dpms;
|
2009-12-04 14:56:37 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-09-09 01:40:54 -06: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,
|
|
|
|
crtc->x, crtc->y, crtc->fb);
|
|
|
|
}
|
|
|
|
}
|
2009-06-05 06:42:42 -06: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;
|
|
|
|
struct drm_connector_helper_funcs *connector_funcs = connector->helper_private;
|
|
|
|
struct drm_mode_object *obj;
|
|
|
|
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;
|
|
|
|
|
|
|
|
obj = drm_mode_object_find(connector->dev,
|
|
|
|
connector->encoder_ids[i],
|
|
|
|
DRM_MODE_OBJECT_ENCODER);
|
|
|
|
if (!obj)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
encoder = obj_to_encoder(obj);
|
|
|
|
|
|
|
|
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);
|
|
|
|
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-09-09 01:40:54 -06:00
|
|
|
struct drm_encoder *radeon_find_encoder(struct drm_connector *connector, int encoder_type)
|
|
|
|
{
|
|
|
|
struct drm_mode_object *obj;
|
|
|
|
struct drm_encoder *encoder;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
for (i = 0; i < DRM_CONNECTOR_MAX_ENCODER; i++) {
|
|
|
|
if (connector->encoder_ids[i] == 0)
|
|
|
|
break;
|
|
|
|
|
|
|
|
obj = drm_mode_object_find(connector->dev, connector->encoder_ids[i], DRM_MODE_OBJECT_ENCODER);
|
|
|
|
if (!obj)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
encoder = obj_to_encoder(obj);
|
|
|
|
if (encoder->encoder_type == encoder_type)
|
|
|
|
return encoder;
|
|
|
|
}
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2009-06-05 06:42:42 -06:00
|
|
|
struct drm_encoder *radeon_best_single_encoder(struct drm_connector *connector)
|
|
|
|
{
|
|
|
|
int enc_id = connector->encoder_ids[0];
|
|
|
|
struct drm_mode_object *obj;
|
|
|
|
struct drm_encoder *encoder;
|
|
|
|
|
|
|
|
/* pick the encoder ids */
|
|
|
|
if (enc_id) {
|
|
|
|
obj = drm_mode_object_find(connector->dev, enc_id, DRM_MODE_OBJECT_ENCODER);
|
|
|
|
if (!obj)
|
|
|
|
return NULL;
|
|
|
|
encoder = obj_to_encoder(obj);
|
|
|
|
return encoder;
|
|
|
|
}
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2009-08-13 00:32:14 -06: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 11:31:12 -06:00
|
|
|
struct radeon_connector *radeon_conflict;
|
2009-08-13 00:32:14 -06:00
|
|
|
int i;
|
|
|
|
|
|
|
|
list_for_each_entry(conflict, &dev->mode_config.connector_list, head) {
|
|
|
|
if (conflict == connector)
|
|
|
|
continue;
|
|
|
|
|
2010-04-15 11:31:12 -06:00
|
|
|
radeon_conflict = to_radeon_connector(conflict);
|
2009-08-13 00:32:14 -06: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 11:31:12 -06:00
|
|
|
|
|
|
|
if (radeon_conflict->use_digital)
|
|
|
|
continue;
|
2009-08-13 00:32:14 -06:00
|
|
|
|
|
|
|
if (priority == true) {
|
2010-10-29 11:49:25 -06:00
|
|
|
DRM_DEBUG_KMS("1: conflicting encoders switching off %s\n", drm_get_connector_name(conflict));
|
|
|
|
DRM_DEBUG_KMS("in favor of %s\n", drm_get_connector_name(connector));
|
2009-08-13 00:32:14 -06:00
|
|
|
conflict->status = connector_status_disconnected;
|
|
|
|
radeon_connector_update_scratch_regs(conflict, connector_status_disconnected);
|
|
|
|
} else {
|
2010-10-29 11:49:25 -06:00
|
|
|
DRM_DEBUG_KMS("2: conflicting encoders switching off %s\n", drm_get_connector_name(connector));
|
|
|
|
DRM_DEBUG_KMS("in favor of %s\n", drm_get_connector_name(conflict));
|
2009-08-13 00:32:14 -06:00
|
|
|
current_status = connector_status_disconnected;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return current_status;
|
|
|
|
|
|
|
|
}
|
|
|
|
|
2009-06-05 06:42:42 -06: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 13:14:30 -06:00
|
|
|
struct drm_display_mode *native_mode = &radeon_encoder->native_mode;
|
2009-06-05 06:42:42 -06:00
|
|
|
|
2009-10-09 13:14:30 -06:00
|
|
|
if (native_mode->hdisplay != 0 &&
|
|
|
|
native_mode->vdisplay != 0 &&
|
|
|
|
native_mode->clock != 0) {
|
2009-10-12 09:25:05 -06:00
|
|
|
mode = drm_mode_duplicate(dev, native_mode);
|
2009-06-05 06:42:42 -06:00
|
|
|
mode->type = DRM_MODE_TYPE_PREFERRED | DRM_MODE_TYPE_DRIVER;
|
|
|
|
drm_mode_set_name(mode);
|
|
|
|
|
2010-08-01 18:42:55 -06:00
|
|
|
DRM_DEBUG_KMS("Adding native panel mode %s\n", mode->name);
|
2009-12-22 08:06:49 -07: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-01 18:42:55 -06:00
|
|
|
DRM_DEBUG_KMS("Adding cvt approximation of native panel mode %s\n", mode->name);
|
2009-06-05 06:42:42 -06:00
|
|
|
}
|
|
|
|
return mode;
|
|
|
|
}
|
|
|
|
|
2009-09-10 15:53:39 -06: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 13:14:30 -06:00
|
|
|
struct drm_display_mode *native_mode = &radeon_encoder->native_mode;
|
2009-09-10 15:53:39 -06: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 10:48:44 -06:00
|
|
|
if (radeon_encoder->devices & (ATOM_DEVICE_TV_SUPPORT)) {
|
|
|
|
if (common_modes[i].w > 1024 ||
|
|
|
|
common_modes[i].h > 768)
|
|
|
|
continue;
|
|
|
|
}
|
2009-09-10 15:53:39 -06:00
|
|
|
if (radeon_encoder->devices & (ATOM_DEVICE_LCD_SUPPORT)) {
|
2009-10-09 13:14:30 -06: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 15:53:39 -06: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-22 22:44:08 -06:00
|
|
|
mode = drm_cvt_mode(dev, common_modes[i].w, common_modes[i].h, 60, false, false, false);
|
2009-09-10 15:53:39 -06:00
|
|
|
drm_mode_probed_add(connector, mode);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-06-05 06:42:42 -06:00
|
|
|
int radeon_connector_set_property(struct drm_connector *connector, struct drm_property *property,
|
|
|
|
uint64_t val)
|
|
|
|
{
|
2009-09-09 01:40:54 -06: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 00:27:00 -06:00
|
|
|
bool new_coherent_mode;
|
2009-09-09 01:40:54 -06: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 00:27:00 -06: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 01:40:54 -06:00
|
|
|
}
|
|
|
|
|
2010-08-03 17:59:20 -06: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 13:30:59 -06: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 01:40:54 -06: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-05 21:57:52 -06:00
|
|
|
if (ASIC_IS_AVIVO(rdev) || radeon_r4xx_atom) {
|
2009-09-09 01:40:54 -06: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);
|
|
|
|
}
|
|
|
|
|
2009-06-05 06:42:42 -06:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2011-07-29 08:28:58 -06:00
|
|
|
/*
|
|
|
|
* Some integrated ATI Radeon chipset implementations (e. g.
|
|
|
|
* Asus M2A-VM HDMI) may indicate the availability of a DDC,
|
|
|
|
* even when there's no monitor connected. For these connectors
|
|
|
|
* following DDC probe extension will be applied: check also for the
|
|
|
|
* availability of EDID with at least a correct EDID header. Only then,
|
|
|
|
* DDC is assumed to be available. This prevents drm_get_edid() and
|
|
|
|
* drm_edid_block_valid() from periodically dumping data and kernel
|
|
|
|
* errors into the logs and onto the terminal.
|
|
|
|
*/
|
|
|
|
static bool radeon_connector_needs_extended_probe(struct radeon_device *dev,
|
|
|
|
uint32_t supported_device,
|
|
|
|
int connector_type)
|
|
|
|
{
|
|
|
|
/* Asus M2A-VM HDMI board sends data to i2c bus even,
|
|
|
|
* if HDMI add-on card is not plugged in or HDMI is disabled in
|
|
|
|
* BIOS. Valid DDC can only be assumed, if also a valid EDID header
|
|
|
|
* can be retrieved via i2c bus during DDC probe */
|
|
|
|
if ((dev->pdev->device == 0x791e) &&
|
|
|
|
(dev->pdev->subsystem_vendor == 0x1043) &&
|
|
|
|
(dev->pdev->subsystem_device == 0x826d)) {
|
|
|
|
if ((connector_type == DRM_MODE_CONNECTOR_HDMIA) &&
|
|
|
|
(supported_device == ATOM_DEVICE_DFP2_SUPPORT))
|
|
|
|
return true;
|
|
|
|
}
|
2011-07-29 08:29:00 -06:00
|
|
|
/* ECS A740GM-M with ATI RADEON 2100 sends data to i2c bus
|
|
|
|
* for a DVI connector that is not implemented */
|
|
|
|
if ((dev->pdev->device == 0x796e) &&
|
|
|
|
(dev->pdev->subsystem_vendor == 0x1019) &&
|
|
|
|
(dev->pdev->subsystem_device == 0x2615)) {
|
|
|
|
if ((connector_type == DRM_MODE_CONNECTOR_DVID) &&
|
|
|
|
(supported_device == ATOM_DEVICE_DFP2_SUPPORT))
|
|
|
|
return true;
|
|
|
|
}
|
2011-08-17 03:03:32 -06:00
|
|
|
/* TOSHIBA Satellite L300D with ATI Mobility Radeon x1100
|
|
|
|
* (RS690M) sends data to i2c bus for a HDMI connector that
|
|
|
|
* is not implemented */
|
|
|
|
if ((dev->pdev->device == 0x791f) &&
|
|
|
|
(dev->pdev->subsystem_vendor == 0x1179) &&
|
|
|
|
(dev->pdev->subsystem_device == 0xff68)) {
|
|
|
|
if ((connector_type == DRM_MODE_CONNECTOR_HDMIA) &&
|
|
|
|
(supported_device == ATOM_DEVICE_DFP2_SUPPORT))
|
|
|
|
return true;
|
|
|
|
}
|
2011-07-29 08:28:58 -06:00
|
|
|
|
|
|
|
/* Default: no EDID header probe required for DDC probing */
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2009-09-15 09:09:27 -06: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 13:14:30 -06:00
|
|
|
struct drm_display_mode *native_mode = &radeon_encoder->native_mode;
|
2011-08-08 10:21:15 -06: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 09:09:27 -06:00
|
|
|
|
|
|
|
/* Try to get native mode details from EDID if necessary */
|
2009-10-09 13:14:30 -06:00
|
|
|
if (!native_mode->clock) {
|
2009-09-15 09:09:27 -06:00
|
|
|
list_for_each_entry_safe(mode, t, &connector->probed_modes, head) {
|
2009-10-09 13:14:30 -06: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 11:49:25 -06:00
|
|
|
DRM_DEBUG_KMS("Determined LVDS native mode details from EDID\n");
|
2009-09-15 09:09:27 -06:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2011-08-08 10:21:15 -06:00
|
|
|
|
2009-10-09 13:14:30 -06:00
|
|
|
if (!native_mode->clock) {
|
2010-10-29 11:49:25 -06:00
|
|
|
DRM_DEBUG_KMS("No LVDS native mode details, disabling RMX\n");
|
2009-09-15 09:09:27 -06:00
|
|
|
radeon_encoder->rmx_type = RMX_OFF;
|
|
|
|
}
|
|
|
|
}
|
2009-06-05 06:42:42 -06:00
|
|
|
|
|
|
|
static int radeon_lvds_get_modes(struct drm_connector *connector)
|
|
|
|
{
|
|
|
|
struct radeon_connector *radeon_connector = to_radeon_connector(connector);
|
|
|
|
struct drm_encoder *encoder;
|
|
|
|
int ret = 0;
|
|
|
|
struct drm_display_mode *mode;
|
|
|
|
|
|
|
|
if (radeon_connector->ddc_bus) {
|
|
|
|
ret = radeon_ddc_get_modes(radeon_connector);
|
|
|
|
if (ret > 0) {
|
2009-09-11 09:15:43 -06:00
|
|
|
encoder = radeon_best_single_encoder(connector);
|
2009-09-15 09:09:27 -06:00
|
|
|
if (encoder) {
|
|
|
|
radeon_fixup_lvds_native_mode(encoder, connector);
|
2009-09-11 09:15:43 -06:00
|
|
|
/* add scaled modes */
|
|
|
|
radeon_add_common_modes(encoder, connector);
|
2009-09-15 09:09:27 -06:00
|
|
|
}
|
2009-06-05 06:42:42 -06:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
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-08 20:13:05 -07: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 09:15:43 -06:00
|
|
|
/* add scaled modes */
|
|
|
|
radeon_add_common_modes(encoder, connector);
|
2009-06-05 06:42:42 -06:00
|
|
|
}
|
2009-09-10 15:53:39 -06:00
|
|
|
|
2009-06-05 06:42:42 -06:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int radeon_lvds_mode_valid(struct drm_connector *connector,
|
|
|
|
struct drm_display_mode *mode)
|
|
|
|
{
|
2009-11-05 09:57:07 -07: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 06:42:42 -06:00
|
|
|
return MODE_OK;
|
|
|
|
}
|
|
|
|
|
2010-09-09 16:51:02 -06:00
|
|
|
static enum drm_connector_status
|
2010-09-14 04:07:23 -06:00
|
|
|
radeon_lvds_detect(struct drm_connector *connector, bool force)
|
2009-06-05 06:42:42 -06:00
|
|
|
{
|
2009-10-09 16:41:19 -06:00
|
|
|
struct radeon_connector *radeon_connector = to_radeon_connector(connector);
|
2009-10-08 11:02:19 -06:00
|
|
|
struct drm_encoder *encoder = radeon_best_single_encoder(connector);
|
2009-10-09 16:41:19 -06:00
|
|
|
enum drm_connector_status ret = connector_status_disconnected;
|
2009-10-08 11:02:19 -06:00
|
|
|
|
|
|
|
if (encoder) {
|
|
|
|
struct radeon_encoder *radeon_encoder = to_radeon_encoder(encoder);
|
2009-10-09 13:14:30 -06:00
|
|
|
struct drm_display_mode *native_mode = &radeon_encoder->native_mode;
|
2009-10-08 11:02:19 -06:00
|
|
|
|
|
|
|
/* check if panel is valid */
|
2009-10-09 13:14:30 -06:00
|
|
|
if (native_mode->hdisplay >= 320 && native_mode->vdisplay >= 240)
|
2009-10-08 11:02:19 -06:00
|
|
|
ret = connector_status_connected;
|
|
|
|
|
|
|
|
}
|
2009-10-09 16:41:19 -06:00
|
|
|
|
|
|
|
/* check for edid as well */
|
2009-10-15 14:16:35 -06:00
|
|
|
if (radeon_connector->edid)
|
|
|
|
ret = connector_status_connected;
|
|
|
|
else {
|
|
|
|
if (radeon_connector->ddc_bus) {
|
|
|
|
radeon_connector->edid = drm_get_edid(&radeon_connector->base,
|
|
|
|
&radeon_connector->ddc_bus->adapter);
|
|
|
|
if (radeon_connector->edid)
|
|
|
|
ret = connector_status_connected;
|
|
|
|
}
|
2009-10-09 16:41:19 -06:00
|
|
|
}
|
2009-06-05 06:42:42 -06:00
|
|
|
/* check acpi lid status ??? */
|
2009-10-08 11:02:19 -06:00
|
|
|
|
2009-06-05 06:42:42 -06:00
|
|
|
radeon_connector_update_scratch_regs(connector, ret);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void radeon_connector_destroy(struct drm_connector *connector)
|
|
|
|
{
|
|
|
|
struct radeon_connector *radeon_connector = to_radeon_connector(connector);
|
|
|
|
|
2009-10-15 14:16:35 -06:00
|
|
|
if (radeon_connector->edid)
|
|
|
|
kfree(radeon_connector->edid);
|
2009-06-05 06:42:42 -06:00
|
|
|
kfree(radeon_connector->con_priv);
|
|
|
|
drm_sysfs_connector_remove(connector);
|
|
|
|
drm_connector_cleanup(connector);
|
|
|
|
kfree(connector);
|
|
|
|
}
|
|
|
|
|
2009-09-09 01:40:54 -06: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-01 18:42:55 -06:00
|
|
|
DRM_DEBUG_KMS("\n");
|
2009-09-09 01:40:54 -06:00
|
|
|
if (property != dev->mode_config.scaling_mode_property)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
if (connector->encoder)
|
|
|
|
radeon_encoder = to_radeon_encoder(connector->encoder);
|
|
|
|
else {
|
|
|
|
struct drm_connector_helper_funcs *connector_funcs = connector->helper_private;
|
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2009-06-05 06:42:42 -06:00
|
|
|
struct drm_connector_helper_funcs radeon_lvds_connector_helper_funcs = {
|
|
|
|
.get_modes = radeon_lvds_get_modes,
|
|
|
|
.mode_valid = radeon_lvds_mode_valid,
|
|
|
|
.best_encoder = radeon_best_single_encoder,
|
|
|
|
};
|
|
|
|
|
|
|
|
struct drm_connector_funcs radeon_lvds_connector_funcs = {
|
|
|
|
.dpms = drm_helper_connector_dpms,
|
|
|
|
.detect = radeon_lvds_detect,
|
|
|
|
.fill_modes = drm_helper_probe_single_connector_modes,
|
|
|
|
.destroy = radeon_connector_destroy,
|
2009-09-09 01:40:54 -06:00
|
|
|
.set_property = radeon_lvds_set_property,
|
2009-06-05 06:42:42 -06:00
|
|
|
};
|
|
|
|
|
|
|
|
static int radeon_vga_get_modes(struct drm_connector *connector)
|
|
|
|
{
|
|
|
|
struct radeon_connector *radeon_connector = to_radeon_connector(connector);
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
ret = radeon_ddc_get_modes(radeon_connector);
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int radeon_vga_mode_valid(struct drm_connector *connector,
|
|
|
|
struct drm_display_mode *mode)
|
|
|
|
{
|
2011-06-08 11:01:11 -06:00
|
|
|
struct drm_device *dev = connector->dev;
|
|
|
|
struct radeon_device *rdev = dev->dev_private;
|
|
|
|
|
2009-11-05 09:57:07 -07:00
|
|
|
/* XXX check mode bandwidth */
|
2011-06-08 11:01:11 -06:00
|
|
|
|
|
|
|
if ((mode->clock / 10) > rdev->clock.max_pixel_clock)
|
|
|
|
return MODE_CLOCK_HIGH;
|
|
|
|
|
2009-06-05 06:42:42 -06:00
|
|
|
return MODE_OK;
|
|
|
|
}
|
|
|
|
|
2010-09-09 16:51:02 -06:00
|
|
|
static enum drm_connector_status
|
2010-09-14 04:07:23 -06:00
|
|
|
radeon_vga_detect(struct drm_connector *connector, bool force)
|
2009-06-05 06:42:42 -06:00
|
|
|
{
|
2011-03-23 02:10:10 -06:00
|
|
|
struct drm_device *dev = connector->dev;
|
|
|
|
struct radeon_device *rdev = dev->dev_private;
|
2009-06-05 06:42:42 -06:00
|
|
|
struct radeon_connector *radeon_connector = to_radeon_connector(connector);
|
|
|
|
struct drm_encoder *encoder;
|
|
|
|
struct drm_encoder_helper_funcs *encoder_funcs;
|
2010-02-07 20:16:55 -07:00
|
|
|
bool dret = false;
|
2009-06-05 06:42:42 -06:00
|
|
|
enum drm_connector_status ret = connector_status_disconnected;
|
|
|
|
|
2009-08-13 00:32:14 -06:00
|
|
|
encoder = radeon_best_single_encoder(connector);
|
|
|
|
if (!encoder)
|
|
|
|
ret = connector_status_disconnected;
|
|
|
|
|
2010-02-24 20:44:04 -07:00
|
|
|
if (radeon_connector->ddc_bus)
|
2011-07-29 08:28:58 -06:00
|
|
|
dret = radeon_ddc_probe(radeon_connector,
|
|
|
|
radeon_connector->requires_extended_probe);
|
2009-10-15 14:16:35 -06:00
|
|
|
if (dret) {
|
2011-10-07 12:23:48 -06:00
|
|
|
radeon_connector->detected_by_load = false;
|
2009-10-15 14:16:35 -06:00
|
|
|
if (radeon_connector->edid) {
|
|
|
|
kfree(radeon_connector->edid);
|
|
|
|
radeon_connector->edid = NULL;
|
|
|
|
}
|
|
|
|
radeon_connector->edid = drm_get_edid(&radeon_connector->base, &radeon_connector->ddc_bus->adapter);
|
|
|
|
|
|
|
|
if (!radeon_connector->edid) {
|
2009-11-12 06:13:53 -07:00
|
|
|
DRM_ERROR("%s: probed a monitor but no|invalid EDID\n",
|
|
|
|
drm_get_connector_name(connector));
|
|
|
|
ret = connector_status_connected;
|
2009-10-15 14:16:35 -06:00
|
|
|
} else {
|
|
|
|
radeon_connector->use_digital = !!(radeon_connector->edid->input & DRM_EDID_INPUT_DIGITAL);
|
|
|
|
|
|
|
|
/* 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) {
|
|
|
|
kfree(radeon_connector->edid);
|
|
|
|
radeon_connector->edid = NULL;
|
|
|
|
ret = connector_status_disconnected;
|
|
|
|
} else
|
|
|
|
ret = connector_status_connected;
|
|
|
|
}
|
|
|
|
} else {
|
2010-10-25 20:55:52 -06:00
|
|
|
|
|
|
|
/* if we aren't forcing don't do destructive polling */
|
2011-10-07 12:23:48 -06:00
|
|
|
if (!force) {
|
|
|
|
/* only return the previous status if we last
|
|
|
|
* detected a monitor via load.
|
|
|
|
*/
|
|
|
|
if (radeon_connector->detected_by_load)
|
|
|
|
return connector->status;
|
|
|
|
else
|
|
|
|
return ret;
|
|
|
|
}
|
2010-10-25 20:55:52 -06:00
|
|
|
|
2009-12-29 18:22:55 -07:00
|
|
|
if (radeon_connector->dac_load_detect && encoder) {
|
2009-09-09 01:40:54 -06:00
|
|
|
encoder_funcs = encoder->helper_private;
|
|
|
|
ret = encoder_funcs->detect(encoder, connector);
|
2011-10-07 12:23:48 -06:00
|
|
|
if (ret == connector_status_connected)
|
|
|
|
radeon_connector->detected_by_load = true;
|
2009-09-09 01:40:54 -06:00
|
|
|
}
|
2009-06-05 06:42:42 -06:00
|
|
|
}
|
|
|
|
|
2009-08-13 00:32:14 -06:00
|
|
|
if (ret == connector_status_connected)
|
|
|
|
ret = radeon_connector_analog_encoder_conflict_solve(connector, encoder, ret, true);
|
2011-03-23 02:10:10 -06: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 06:42:42 -06:00
|
|
|
radeon_connector_update_scratch_regs(connector, ret);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
struct drm_connector_helper_funcs radeon_vga_connector_helper_funcs = {
|
|
|
|
.get_modes = radeon_vga_get_modes,
|
|
|
|
.mode_valid = radeon_vga_mode_valid,
|
|
|
|
.best_encoder = radeon_best_single_encoder,
|
|
|
|
};
|
|
|
|
|
|
|
|
struct drm_connector_funcs radeon_vga_connector_funcs = {
|
|
|
|
.dpms = drm_helper_connector_dpms,
|
|
|
|
.detect = radeon_vga_detect,
|
|
|
|
.fill_modes = drm_helper_probe_single_connector_modes,
|
|
|
|
.destroy = radeon_connector_destroy,
|
|
|
|
.set_property = radeon_connector_set_property,
|
|
|
|
};
|
|
|
|
|
2009-08-13 00:32:14 -06:00
|
|
|
static int radeon_tv_get_modes(struct drm_connector *connector)
|
|
|
|
{
|
|
|
|
struct drm_device *dev = connector->dev;
|
2009-09-10 15:53:39 -06:00
|
|
|
struct radeon_device *rdev = dev->dev_private;
|
2009-08-13 00:32:14 -06:00
|
|
|
struct drm_display_mode *tv_mode;
|
2009-09-10 15:53:39 -06:00
|
|
|
struct drm_encoder *encoder;
|
2009-08-13 00:32:14 -06:00
|
|
|
|
2009-09-10 15:53:39 -06:00
|
|
|
encoder = radeon_best_single_encoder(connector);
|
|
|
|
if (!encoder)
|
|
|
|
return 0;
|
2009-08-13 00:32:14 -06:00
|
|
|
|
2009-09-10 15:53:39 -06: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-22 22:44:08 -06:00
|
|
|
tv_mode = drm_cvt_mode(dev, 800, 600, 60, false, false, false);
|
2009-09-10 15:53:39 -06:00
|
|
|
tv_mode->type = DRM_MODE_TYPE_DRIVER | DRM_MODE_TYPE_PREFERRED;
|
|
|
|
drm_mode_probed_add(connector, tv_mode);
|
|
|
|
}
|
2009-08-13 00:32:14 -06:00
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int radeon_tv_mode_valid(struct drm_connector *connector,
|
|
|
|
struct drm_display_mode *mode)
|
|
|
|
{
|
2009-11-05 09:57:07 -07:00
|
|
|
if ((mode->hdisplay > 1024) || (mode->vdisplay > 768))
|
|
|
|
return MODE_CLOCK_RANGE;
|
2009-08-13 00:32:14 -06:00
|
|
|
return MODE_OK;
|
|
|
|
}
|
|
|
|
|
2010-09-09 16:51:02 -06:00
|
|
|
static enum drm_connector_status
|
2010-09-14 04:07:23 -06:00
|
|
|
radeon_tv_detect(struct drm_connector *connector, bool force)
|
2009-08-13 00:32:14 -06:00
|
|
|
{
|
|
|
|
struct drm_encoder *encoder;
|
|
|
|
struct drm_encoder_helper_funcs *encoder_funcs;
|
2009-09-09 01:40:54 -06:00
|
|
|
struct radeon_connector *radeon_connector = to_radeon_connector(connector);
|
|
|
|
enum drm_connector_status ret = connector_status_disconnected;
|
|
|
|
|
|
|
|
if (!radeon_connector->dac_load_detect)
|
|
|
|
return ret;
|
2009-08-13 00:32:14 -06: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);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
struct drm_connector_helper_funcs radeon_tv_connector_helper_funcs = {
|
|
|
|
.get_modes = radeon_tv_get_modes,
|
|
|
|
.mode_valid = radeon_tv_mode_valid,
|
|
|
|
.best_encoder = radeon_best_single_encoder,
|
|
|
|
};
|
|
|
|
|
|
|
|
struct drm_connector_funcs radeon_tv_connector_funcs = {
|
|
|
|
.dpms = drm_helper_connector_dpms,
|
|
|
|
.detect = radeon_tv_detect,
|
|
|
|
.fill_modes = drm_helper_probe_single_connector_modes,
|
|
|
|
.destroy = radeon_connector_destroy,
|
|
|
|
.set_property = radeon_connector_set_property,
|
|
|
|
};
|
|
|
|
|
2009-06-05 06:42:42 -06:00
|
|
|
static int radeon_dvi_get_modes(struct drm_connector *connector)
|
|
|
|
{
|
|
|
|
struct radeon_connector *radeon_connector = to_radeon_connector(connector);
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
ret = radeon_ddc_get_modes(radeon_connector);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2009-08-13 00:32:14 -06: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 16:51:02 -06:00
|
|
|
static enum drm_connector_status
|
2010-09-14 04:07:23 -06:00
|
|
|
radeon_dvi_detect(struct drm_connector *connector, bool force)
|
2009-06-05 06:42:42 -06:00
|
|
|
{
|
2011-03-23 02:10:10 -06:00
|
|
|
struct drm_device *dev = connector->dev;
|
|
|
|
struct radeon_device *rdev = dev->dev_private;
|
2009-06-05 06:42:42 -06:00
|
|
|
struct radeon_connector *radeon_connector = to_radeon_connector(connector);
|
2009-08-13 00:32:14 -06:00
|
|
|
struct drm_encoder *encoder = NULL;
|
2009-06-05 06:42:42 -06:00
|
|
|
struct drm_encoder_helper_funcs *encoder_funcs;
|
|
|
|
struct drm_mode_object *obj;
|
|
|
|
int i;
|
|
|
|
enum drm_connector_status ret = connector_status_disconnected;
|
2010-02-07 20:16:55 -07:00
|
|
|
bool dret = false;
|
2009-06-05 06:42:42 -06:00
|
|
|
|
2010-02-24 20:44:04 -07:00
|
|
|
if (radeon_connector->ddc_bus)
|
2011-07-29 08:28:58 -06:00
|
|
|
dret = radeon_ddc_probe(radeon_connector,
|
|
|
|
radeon_connector->requires_extended_probe);
|
2009-08-13 00:32:14 -06:00
|
|
|
if (dret) {
|
2011-10-07 12:23:48 -06:00
|
|
|
radeon_connector->detected_by_load = false;
|
2009-10-15 14:16:35 -06:00
|
|
|
if (radeon_connector->edid) {
|
|
|
|
kfree(radeon_connector->edid);
|
|
|
|
radeon_connector->edid = NULL;
|
|
|
|
}
|
2009-08-13 00:32:14 -06:00
|
|
|
radeon_connector->edid = drm_get_edid(&radeon_connector->base, &radeon_connector->ddc_bus->adapter);
|
|
|
|
|
|
|
|
if (!radeon_connector->edid) {
|
2009-11-12 06:13:53 -07:00
|
|
|
DRM_ERROR("%s: probed a monitor but no|invalid EDID\n",
|
|
|
|
drm_get_connector_name(connector));
|
2011-06-14 00:13:55 -06: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 */
|
|
|
|
if ((rdev->family == CHIP_RS690 || rdev->family == CHIP_RS740) && radeon_connector->base.null_edid_counter) {
|
|
|
|
ret = connector_status_disconnected;
|
|
|
|
DRM_ERROR("%s: detected RS690 floating bus bug, stopping ddc detect\n", drm_get_connector_name(connector));
|
|
|
|
radeon_connector->ddc_bus = NULL;
|
|
|
|
}
|
2009-08-13 00:32:14 -06:00
|
|
|
} else {
|
|
|
|
radeon_connector->use_digital = !!(radeon_connector->edid->input & DRM_EDID_INPUT_DIGITAL);
|
|
|
|
|
2009-10-15 14:16:35 -06: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) {
|
|
|
|
kfree(radeon_connector->edid);
|
|
|
|
radeon_connector->edid = NULL;
|
|
|
|
ret = connector_status_disconnected;
|
|
|
|
} else
|
|
|
|
ret = connector_status_connected;
|
2009-11-17 13:44:01 -07:00
|
|
|
|
2010-07-20 09:27:54 -06: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 13:44:01 -07:00
|
|
|
*/
|
2010-02-19 00:13:56 -07:00
|
|
|
if (radeon_connector->shared_ddc && (ret == connector_status_connected)) {
|
2009-11-17 13:44:01 -07: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 08:34:56 -06: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 09:27:54 -06: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)) {
|
2009-11-17 13:44:01 -07:00
|
|
|
kfree(radeon_connector->edid);
|
|
|
|
radeon_connector->edid = NULL;
|
|
|
|
ret = connector_status_disconnected;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2009-08-13 00:32:14 -06:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if ((ret == connector_status_connected) && (radeon_connector->use_digital == true))
|
|
|
|
goto out;
|
|
|
|
|
2011-10-07 12:23:47 -06: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 12:23:48 -06:00
|
|
|
/* if we aren't forcing don't do destructive polling */
|
2010-10-25 20:55:52 -06:00
|
|
|
if (!force) {
|
2011-10-07 12:23:48 -06: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-25 20:55:52 -06:00
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
2009-08-13 00:32:14 -06:00
|
|
|
/* find analog encoder */
|
2009-09-09 01:40:54 -06: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 06:42:42 -06:00
|
|
|
|
2009-09-09 01:40:54 -06:00
|
|
|
obj = drm_mode_object_find(connector->dev,
|
|
|
|
connector->encoder_ids[i],
|
|
|
|
DRM_MODE_OBJECT_ENCODER);
|
|
|
|
if (!obj)
|
|
|
|
continue;
|
2009-06-05 06:42:42 -06:00
|
|
|
|
2009-09-09 01:40:54 -06:00
|
|
|
encoder = obj_to_encoder(obj);
|
2009-06-05 06:42:42 -06:00
|
|
|
|
2009-09-09 01:40:54 -06:00
|
|
|
encoder_funcs = encoder->helper_private;
|
|
|
|
if (encoder_funcs->detect) {
|
|
|
|
if (ret != connector_status_connected) {
|
|
|
|
ret = encoder_funcs->detect(encoder, connector);
|
|
|
|
if (ret == connector_status_connected) {
|
|
|
|
radeon_connector->use_digital = false;
|
2011-10-07 12:23:48 -06:00
|
|
|
radeon_connector->detected_by_load = true;
|
2009-09-09 01:40:54 -06:00
|
|
|
}
|
2009-06-05 06:42:42 -06:00
|
|
|
}
|
2009-09-09 01:40:54 -06:00
|
|
|
break;
|
2009-06-05 06:42:42 -06:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-08-13 00:32:14 -06: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 02:10:10 -06: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.
|
|
|
|
*/
|
|
|
|
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-08-13 00:32:14 -06:00
|
|
|
out:
|
2009-06-05 06:42:42 -06: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);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* okay need to be smart in here about which encoder to pick */
|
|
|
|
struct drm_encoder *radeon_dvi_encoder(struct drm_connector *connector)
|
|
|
|
{
|
|
|
|
int enc_id = connector->encoder_ids[0];
|
|
|
|
struct radeon_connector *radeon_connector = to_radeon_connector(connector);
|
|
|
|
struct drm_mode_object *obj;
|
|
|
|
struct drm_encoder *encoder;
|
|
|
|
int i;
|
|
|
|
for (i = 0; i < DRM_CONNECTOR_MAX_ENCODER; i++) {
|
|
|
|
if (connector->encoder_ids[i] == 0)
|
|
|
|
break;
|
|
|
|
|
|
|
|
obj = drm_mode_object_find(connector->dev, connector->encoder_ids[i], DRM_MODE_OBJECT_ENCODER);
|
|
|
|
if (!obj)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
encoder = obj_to_encoder(obj);
|
|
|
|
|
2009-08-13 00:32:14 -06:00
|
|
|
if (radeon_connector->use_digital == true) {
|
2009-06-05 06:42:42 -06: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 */
|
|
|
|
if (enc_id) {
|
|
|
|
obj = drm_mode_object_find(connector->dev, enc_id, DRM_MODE_OBJECT_ENCODER);
|
|
|
|
if (!obj)
|
|
|
|
return NULL;
|
|
|
|
encoder = obj_to_encoder(obj);
|
|
|
|
return encoder;
|
|
|
|
}
|
|
|
|
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-22 22:44:08 -06: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 09:57:07 -07:00
|
|
|
static int radeon_dvi_mode_valid(struct drm_connector *connector,
|
|
|
|
struct drm_display_mode *mode)
|
|
|
|
{
|
2010-01-11 13:02:31 -07:00
|
|
|
struct drm_device *dev = connector->dev;
|
|
|
|
struct radeon_device *rdev = dev->dev_private;
|
2009-11-05 09:57:07 -07:00
|
|
|
struct radeon_connector *radeon_connector = to_radeon_connector(connector);
|
|
|
|
|
|
|
|
/* XXX check mode bandwidth */
|
|
|
|
|
2010-01-11 13:02:31 -07: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 09:57:07 -07: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;
|
2011-03-02 08:21:05 -07:00
|
|
|
else if (radeon_connector->connector_object_id == CONNECTOR_OBJECT_ID_HDMI_TYPE_A) {
|
|
|
|
if (ASIC_IS_DCE3(rdev)) {
|
|
|
|
/* HDMI 1.3+ supports max clock of 340 Mhz */
|
|
|
|
if (mode->clock > 340000)
|
|
|
|
return MODE_CLOCK_HIGH;
|
|
|
|
else
|
|
|
|
return MODE_OK;
|
|
|
|
} else
|
|
|
|
return MODE_CLOCK_HIGH;
|
|
|
|
} else
|
2009-11-05 09:57:07 -07:00
|
|
|
return MODE_CLOCK_HIGH;
|
|
|
|
}
|
2011-06-08 11:01:11 -06:00
|
|
|
|
|
|
|
/* check against the max pixel clock */
|
|
|
|
if ((mode->clock / 10) > rdev->clock.max_pixel_clock)
|
|
|
|
return MODE_CLOCK_HIGH;
|
|
|
|
|
2009-11-05 09:57:07 -07:00
|
|
|
return MODE_OK;
|
|
|
|
}
|
|
|
|
|
2009-06-05 06:42:42 -06:00
|
|
|
struct drm_connector_helper_funcs radeon_dvi_connector_helper_funcs = {
|
|
|
|
.get_modes = radeon_dvi_get_modes,
|
2009-11-05 09:57:07 -07:00
|
|
|
.mode_valid = radeon_dvi_mode_valid,
|
2009-06-05 06:42:42 -06:00
|
|
|
.best_encoder = radeon_dvi_encoder,
|
|
|
|
};
|
|
|
|
|
|
|
|
struct drm_connector_funcs radeon_dvi_connector_funcs = {
|
|
|
|
.dpms = drm_helper_connector_dpms,
|
|
|
|
.detect = radeon_dvi_detect,
|
|
|
|
.fill_modes = drm_helper_probe_single_connector_modes,
|
|
|
|
.set_property = radeon_connector_set_property,
|
|
|
|
.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-22 22:44:08 -06:00
|
|
|
.force = radeon_dvi_force,
|
2009-06-05 06:42:42 -06:00
|
|
|
};
|
|
|
|
|
2009-11-24 14:13:23 -07:00
|
|
|
static void radeon_dp_connector_destroy(struct drm_connector *connector)
|
|
|
|
{
|
|
|
|
struct radeon_connector *radeon_connector = to_radeon_connector(connector);
|
|
|
|
struct radeon_connector_atom_dig *radeon_dig_connector = radeon_connector->con_priv;
|
|
|
|
|
|
|
|
if (radeon_connector->edid)
|
|
|
|
kfree(radeon_connector->edid);
|
|
|
|
if (radeon_dig_connector->dp_i2c_bus)
|
2010-03-14 10:22:44 -06:00
|
|
|
radeon_i2c_destroy(radeon_dig_connector->dp_i2c_bus);
|
2009-11-24 14:13:23 -07:00
|
|
|
kfree(radeon_connector->con_priv);
|
|
|
|
drm_sysfs_connector_remove(connector);
|
|
|
|
drm_connector_cleanup(connector);
|
|
|
|
kfree(connector);
|
|
|
|
}
|
|
|
|
|
2009-12-07 14:07:28 -07:00
|
|
|
static int radeon_dp_get_modes(struct drm_connector *connector)
|
|
|
|
{
|
|
|
|
struct radeon_connector *radeon_connector = to_radeon_connector(connector);
|
2010-11-17 00:54:42 -07:00
|
|
|
struct radeon_connector_atom_dig *radeon_dig_connector = radeon_connector->con_priv;
|
2011-06-13 15:13:34 -06:00
|
|
|
struct drm_encoder *encoder = radeon_best_single_encoder(connector);
|
2009-12-07 14:07:28 -07:00
|
|
|
int ret;
|
|
|
|
|
2011-06-13 15:13:35 -06:00
|
|
|
if ((connector->connector_type == DRM_MODE_CONNECTOR_eDP) ||
|
|
|
|
(connector->connector_type == DRM_MODE_CONNECTOR_LVDS)) {
|
2011-05-20 02:34:31 -06:00
|
|
|
struct drm_display_mode *mode;
|
|
|
|
|
2010-11-17 00:54:42 -07:00
|
|
|
if (!radeon_dig_connector->edp_on)
|
|
|
|
atombios_set_edp_panel_power(connector,
|
|
|
|
ATOM_TRANSMITTER_ACTION_POWER_ON);
|
2011-05-20 02:34:31 -06:00
|
|
|
ret = radeon_ddc_get_modes(radeon_connector);
|
2010-11-17 00:54:42 -07:00
|
|
|
if (!radeon_dig_connector->edp_on)
|
|
|
|
atombios_set_edp_panel_power(connector,
|
|
|
|
ATOM_TRANSMITTER_ACTION_POWER_OFF);
|
2011-05-20 02:34:31 -06:00
|
|
|
|
|
|
|
if (ret > 0) {
|
|
|
|
if (encoder) {
|
|
|
|
radeon_fixup_lvds_native_mode(encoder, connector);
|
|
|
|
/* add scaled modes */
|
|
|
|
radeon_add_common_modes(encoder, connector);
|
|
|
|
}
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
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);
|
|
|
|
/* 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 15:13:34 -06:00
|
|
|
} else {
|
|
|
|
/* need to setup ddc on the bridge */
|
|
|
|
if (radeon_connector_encoder_is_dp_bridge(connector)) {
|
|
|
|
if (encoder)
|
|
|
|
radeon_atom_ext_encoder_setup_ddc(encoder);
|
|
|
|
}
|
2011-05-20 02:34:31 -06:00
|
|
|
ret = radeon_ddc_get_modes(radeon_connector);
|
2011-06-13 15:13:34 -06:00
|
|
|
}
|
2010-11-17 00:54:42 -07:00
|
|
|
|
2009-12-07 14:07:28 -07:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2011-05-20 02:34:21 -06:00
|
|
|
bool radeon_connector_encoder_is_dp_bridge(struct drm_connector *connector)
|
|
|
|
{
|
|
|
|
struct drm_mode_object *obj;
|
|
|
|
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;
|
|
|
|
|
|
|
|
obj = drm_mode_object_find(connector->dev, connector->encoder_ids[i], DRM_MODE_OBJECT_ENCODER);
|
|
|
|
if (!obj)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
encoder = obj_to_encoder(obj);
|
|
|
|
radeon_encoder = to_radeon_encoder(encoder);
|
|
|
|
|
|
|
|
switch (radeon_encoder->encoder_id) {
|
|
|
|
case ENCODER_OBJECT_ID_TRAVIS:
|
|
|
|
case ENCODER_OBJECT_ID_NUTMEG:
|
|
|
|
found = true;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return found;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool radeon_connector_encoder_is_hbr2(struct drm_connector *connector)
|
|
|
|
{
|
|
|
|
struct drm_mode_object *obj;
|
|
|
|
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;
|
|
|
|
|
|
|
|
obj = drm_mode_object_find(connector->dev, connector->encoder_ids[i], DRM_MODE_OBJECT_ENCODER);
|
|
|
|
if (!obj)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
encoder = obj_to_encoder(obj);
|
|
|
|
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) &&
|
|
|
|
(rdev->clock.dp_extclk >= 53900) &&
|
|
|
|
radeon_connector_encoder_is_hbr2(connector)) {
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2010-09-09 16:51:02 -06:00
|
|
|
static enum drm_connector_status
|
2010-09-14 04:07:23 -06:00
|
|
|
radeon_dp_detect(struct drm_connector *connector, bool force)
|
2009-12-07 14:07:28 -07:00
|
|
|
{
|
2011-05-20 02:34:23 -06:00
|
|
|
struct drm_device *dev = connector->dev;
|
|
|
|
struct radeon_device *rdev = dev->dev_private;
|
2009-12-07 14:07:28 -07:00
|
|
|
struct radeon_connector *radeon_connector = to_radeon_connector(connector);
|
|
|
|
enum drm_connector_status ret = connector_status_disconnected;
|
2009-11-23 16:02:35 -07:00
|
|
|
struct radeon_connector_atom_dig *radeon_dig_connector = radeon_connector->con_priv;
|
2011-06-13 15:13:34 -06:00
|
|
|
struct drm_encoder *encoder = radeon_best_single_encoder(connector);
|
2009-12-07 14:07:28 -07:00
|
|
|
|
|
|
|
if (radeon_connector->edid) {
|
|
|
|
kfree(radeon_connector->edid);
|
|
|
|
radeon_connector->edid = NULL;
|
|
|
|
}
|
|
|
|
|
2011-06-13 15:13:35 -06:00
|
|
|
if ((connector->connector_type == DRM_MODE_CONNECTOR_eDP) ||
|
|
|
|
(connector->connector_type == DRM_MODE_CONNECTOR_LVDS)) {
|
2011-05-20 02:34:31 -06: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;
|
|
|
|
}
|
2010-08-19 15:29:03 -06:00
|
|
|
/* eDP is always DP */
|
|
|
|
radeon_dig_connector->dp_sink_type = CONNECTOR_OBJECT_ID_DISPLAYPORT;
|
2010-11-17 00:54:42 -07:00
|
|
|
if (!radeon_dig_connector->edp_on)
|
|
|
|
atombios_set_edp_panel_power(connector,
|
|
|
|
ATOM_TRANSMITTER_ACTION_POWER_ON);
|
2010-08-19 15:29:03 -06:00
|
|
|
if (radeon_dp_getdpcd(radeon_connector))
|
2009-11-27 11:01:46 -07:00
|
|
|
ret = connector_status_connected;
|
2010-11-17 00:54:42 -07:00
|
|
|
if (!radeon_dig_connector->edp_on)
|
|
|
|
atombios_set_edp_panel_power(connector,
|
|
|
|
ATOM_TRANSMITTER_ACTION_POWER_OFF);
|
2011-09-02 08:23:09 -06:00
|
|
|
} else if (radeon_connector_encoder_is_dp_bridge(connector)) {
|
|
|
|
/* 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 10:23:24 -06:00
|
|
|
if (encoder) {
|
|
|
|
/* setup ddc on the bridge */
|
|
|
|
radeon_atom_ext_encoder_setup_ddc(encoder);
|
2011-09-02 08:23:09 -06:00
|
|
|
if (radeon_ddc_probe(radeon_connector,
|
2011-10-04 10:23:24 -06:00
|
|
|
radeon_connector->requires_extended_probe)) /* try DDC */
|
2011-09-02 08:23:09 -06:00
|
|
|
ret = connector_status_connected;
|
2011-10-04 10:23:24 -06:00
|
|
|
else if (radeon_connector->dac_load_detect) { /* try load detection */
|
|
|
|
struct drm_encoder_helper_funcs *encoder_funcs = encoder->helper_private;
|
2011-09-02 08:23:09 -06:00
|
|
|
ret = encoder_funcs->detect(encoder, connector);
|
|
|
|
}
|
2011-06-13 15:13:34 -06:00
|
|
|
}
|
2011-09-02 08:23:09 -06:00
|
|
|
} else {
|
2010-08-19 15:29:03 -06:00
|
|
|
radeon_dig_connector->dp_sink_type = radeon_dp_getsinktype(radeon_connector);
|
2011-05-20 02:34:23 -06:00
|
|
|
if (radeon_hpd_sense(rdev, radeon_connector->hpd.hpd)) {
|
|
|
|
ret = connector_status_connected;
|
|
|
|
if (radeon_dig_connector->dp_sink_type == CONNECTOR_OBJECT_ID_DISPLAYPORT)
|
|
|
|
radeon_dp_getdpcd(radeon_connector);
|
2010-08-19 15:29:03 -06:00
|
|
|
} else {
|
2011-05-20 02:34:23 -06:00
|
|
|
if (radeon_dig_connector->dp_sink_type == CONNECTOR_OBJECT_ID_DISPLAYPORT) {
|
|
|
|
if (radeon_dp_getdpcd(radeon_connector))
|
|
|
|
ret = connector_status_connected;
|
|
|
|
} else {
|
2011-07-29 08:28:58 -06:00
|
|
|
if (radeon_ddc_probe(radeon_connector,
|
|
|
|
radeon_connector->requires_extended_probe))
|
2011-05-20 02:34:23 -06:00
|
|
|
ret = connector_status_connected;
|
|
|
|
}
|
2009-11-23 16:02:35 -07:00
|
|
|
}
|
2009-12-07 14:07:28 -07:00
|
|
|
}
|
2009-11-23 16:02:35 -07:00
|
|
|
|
2010-08-21 09:09:14 -06:00
|
|
|
radeon_connector_update_scratch_regs(connector, ret);
|
2009-12-07 14:07:28 -07:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2009-11-24 11:32:59 -07:00
|
|
|
static int radeon_dp_mode_valid(struct drm_connector *connector,
|
|
|
|
struct drm_display_mode *mode)
|
|
|
|
{
|
|
|
|
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 15:13:35 -06:00
|
|
|
if ((connector->connector_type == DRM_MODE_CONNECTOR_eDP) ||
|
|
|
|
(connector->connector_type == DRM_MODE_CONNECTOR_LVDS)) {
|
2011-05-20 02:34:31 -06: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 15:13:35 -06:00
|
|
|
/* AVIVO hardware supports downscaling modes larger than the panel
|
2011-05-20 02:34:31 -06: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;
|
|
|
|
}
|
|
|
|
}
|
2009-11-24 11:32:59 -07:00
|
|
|
return MODE_OK;
|
2011-05-20 02:34:31 -06:00
|
|
|
} else {
|
|
|
|
if ((radeon_dig_connector->dp_sink_type == CONNECTOR_OBJECT_ID_DISPLAYPORT) ||
|
|
|
|
(radeon_dig_connector->dp_sink_type == CONNECTOR_OBJECT_ID_eDP))
|
|
|
|
return radeon_dp_mode_valid_helper(connector, mode);
|
|
|
|
else
|
|
|
|
return MODE_OK;
|
|
|
|
}
|
2009-11-24 11:32:59 -07:00
|
|
|
}
|
|
|
|
|
2009-12-07 14:07:28 -07:00
|
|
|
struct drm_connector_helper_funcs radeon_dp_connector_helper_funcs = {
|
|
|
|
.get_modes = radeon_dp_get_modes,
|
2009-11-24 11:32:59 -07:00
|
|
|
.mode_valid = radeon_dp_mode_valid,
|
2009-12-07 14:07:28 -07:00
|
|
|
.best_encoder = radeon_dvi_encoder,
|
|
|
|
};
|
|
|
|
|
|
|
|
struct drm_connector_funcs radeon_dp_connector_funcs = {
|
|
|
|
.dpms = drm_helper_connector_dpms,
|
|
|
|
.detect = radeon_dp_detect,
|
|
|
|
.fill_modes = drm_helper_probe_single_connector_modes,
|
|
|
|
.set_property = radeon_connector_set_property,
|
2009-11-24 14:13:23 -07:00
|
|
|
.destroy = radeon_dp_connector_destroy,
|
2009-12-07 14:07:28 -07:00
|
|
|
.force = radeon_dvi_force,
|
|
|
|
};
|
|
|
|
|
2009-06-05 06:42:42 -06: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 11:16:01 -07:00
|
|
|
uint32_t igp_lane_info,
|
2009-12-04 12:45:27 -07:00
|
|
|
uint16_t connector_object_id,
|
2010-08-05 19:21:18 -06:00
|
|
|
struct radeon_hpd *hpd,
|
|
|
|
struct radeon_router *router)
|
2009-06-05 06:42:42 -06:00
|
|
|
{
|
2009-09-09 01:40:54 -06:00
|
|
|
struct radeon_device *rdev = dev->dev_private;
|
2009-06-05 06:42:42 -06:00
|
|
|
struct drm_connector *connector;
|
|
|
|
struct radeon_connector *radeon_connector;
|
|
|
|
struct radeon_connector_atom_dig *radeon_dig_connector;
|
2011-05-20 02:34:22 -06:00
|
|
|
struct drm_encoder *encoder;
|
|
|
|
struct radeon_encoder *radeon_encoder;
|
2009-06-05 06:42:42 -06:00
|
|
|
uint32_t subpixel_order = SubPixelNone;
|
2009-10-15 14:16:35 -06:00
|
|
|
bool shared_ddc = false;
|
2011-05-20 02:34:22 -06:00
|
|
|
bool is_dp_bridge = false;
|
2009-06-05 06:42:42 -06:00
|
|
|
|
2009-08-13 00:32:14 -06:00
|
|
|
if (connector_type == DRM_MODE_CONNECTOR_Unknown)
|
2009-06-05 06:42:42 -06:00
|
|
|
return;
|
|
|
|
|
2010-09-01 15:15:06 -06: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 06:42:42 -06: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 14:16:35 -06:00
|
|
|
if (radeon_connector->ddc_bus && i2c_bus->valid) {
|
2010-02-19 00:13:56 -07:00
|
|
|
if (radeon_connector->ddc_bus->rec.i2c_id == i2c_bus->i2c_id) {
|
2009-10-15 14:16:35 -06:00
|
|
|
radeon_connector->shared_ddc = true;
|
|
|
|
shared_ddc = true;
|
|
|
|
}
|
2010-11-08 09:08:29 -07:00
|
|
|
if (radeon_connector->router_bus && router->ddc_valid &&
|
2010-08-05 19:21:18 -06:00
|
|
|
(radeon_connector->router.router_id == router->router_id)) {
|
|
|
|
radeon_connector->shared_ddc = false;
|
|
|
|
shared_ddc = false;
|
|
|
|
}
|
2009-10-15 14:16:35 -06:00
|
|
|
}
|
2009-06-05 06:42:42 -06:00
|
|
|
}
|
|
|
|
|
2011-05-20 02:34:22 -06: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 06:42:42 -06: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 14:16:35 -06:00
|
|
|
radeon_connector->shared_ddc = shared_ddc;
|
2009-11-05 11:16:01 -07:00
|
|
|
radeon_connector->connector_object_id = connector_object_id;
|
2009-12-04 12:45:27 -07:00
|
|
|
radeon_connector->hpd = *hpd;
|
2011-07-29 08:28:58 -06:00
|
|
|
radeon_connector->requires_extended_probe =
|
|
|
|
radeon_connector_needs_extended_probe(rdev, supported_device,
|
|
|
|
connector_type);
|
2010-08-05 19:21:18 -06:00
|
|
|
radeon_connector->router = *router;
|
2010-11-08 09:08:29 -07:00
|
|
|
if (router->ddc_valid || router->cd_valid) {
|
2010-08-05 19:21:18 -06:00
|
|
|
radeon_connector->router_bus = radeon_i2c_lookup(rdev, &router->i2c_info);
|
|
|
|
if (!radeon_connector->router_bus)
|
2011-04-14 15:24:07 -06:00
|
|
|
DRM_ERROR("Failed to assign router i2c bus! Check dmesg for i2c errors.\n");
|
2010-08-05 19:21:18 -06:00
|
|
|
}
|
2011-05-20 02:34:22 -06:00
|
|
|
|
|
|
|
if (is_dp_bridge) {
|
2009-06-05 06:42:42 -06: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;
|
2011-05-20 02:34:22 -06: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);
|
2009-06-05 06:42:42 -06:00
|
|
|
if (i2c_bus->valid) {
|
2011-05-20 02:34:22 -06:00
|
|
|
/* add DP i2c bus */
|
|
|
|
if (connector_type == DRM_MODE_CONNECTOR_eDP)
|
|
|
|
radeon_dig_connector->dp_i2c_bus = radeon_i2c_create_dp(dev, i2c_bus, "eDP-auxch");
|
|
|
|
else
|
|
|
|
radeon_dig_connector->dp_i2c_bus = radeon_i2c_create_dp(dev, i2c_bus, "DP-auxch");
|
|
|
|
if (!radeon_dig_connector->dp_i2c_bus)
|
|
|
|
DRM_ERROR("DP: Failed to assign dp ddc bus! Check dmesg for i2c errors.\n");
|
2010-08-05 19:21:16 -06:00
|
|
|
radeon_connector->ddc_bus = radeon_i2c_lookup(rdev, i2c_bus);
|
2009-06-05 06:42:42 -06:00
|
|
|
if (!radeon_connector->ddc_bus)
|
2011-05-20 02:34:22 -06:00
|
|
|
DRM_ERROR("DP: Failed to assign ddc bus! Check dmesg for i2c errors.\n");
|
2009-06-05 06:42:42 -06:00
|
|
|
}
|
2011-05-20 02:34:22 -06:00
|
|
|
switch (connector_type) {
|
|
|
|
case DRM_MODE_CONNECTOR_VGA:
|
|
|
|
case DRM_MODE_CONNECTOR_DVIA:
|
|
|
|
default:
|
|
|
|
connector->interlace_allowed = true;
|
|
|
|
connector->doublescan_allowed = true;
|
2011-06-13 15:13:33 -06:00
|
|
|
radeon_connector->dac_load_detect = true;
|
|
|
|
drm_connector_attach_property(&radeon_connector->base,
|
|
|
|
rdev->mode_info.load_detect_property,
|
|
|
|
1);
|
2011-05-20 02:34:22 -06: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:
|
2010-08-04 01:45:04 -06:00
|
|
|
drm_connector_attach_property(&radeon_connector->base,
|
|
|
|
rdev->mode_info.underscan_property,
|
2011-01-05 09:57:52 -07:00
|
|
|
UNDERSCAN_OFF);
|
2010-09-21 13:30:59 -06:00
|
|
|
drm_connector_attach_property(&radeon_connector->base,
|
|
|
|
rdev->mode_info.underscan_hborder_property,
|
|
|
|
0);
|
|
|
|
drm_connector_attach_property(&radeon_connector->base,
|
|
|
|
rdev->mode_info.underscan_vborder_property,
|
|
|
|
0);
|
2011-05-20 02:34:22 -06: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 15:13:33 -06:00
|
|
|
if (connector_type == DRM_MODE_CONNECTOR_DVII) {
|
|
|
|
radeon_connector->dac_load_detect = true;
|
|
|
|
drm_connector_attach_property(&radeon_connector->base,
|
|
|
|
rdev->mode_info.load_detect_property,
|
|
|
|
1);
|
|
|
|
}
|
2011-05-20 02:34:22 -06:00
|
|
|
break;
|
|
|
|
case DRM_MODE_CONNECTOR_LVDS:
|
|
|
|
case DRM_MODE_CONNECTOR_eDP:
|
|
|
|
drm_connector_attach_property(&radeon_connector->base,
|
|
|
|
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 13:30:59 -06:00
|
|
|
}
|
2011-05-20 02:34:22 -06: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 10:48:20 -07:00
|
|
|
radeon_connector->dac_load_detect = true;
|
|
|
|
drm_connector_attach_property(&radeon_connector->base,
|
|
|
|
rdev->mode_info.load_detect_property,
|
|
|
|
1);
|
2011-05-20 02:34:22 -06:00
|
|
|
/* no HPD on analog connectors */
|
|
|
|
radeon_connector->hpd.hpd = RADEON_HPD_NONE;
|
|
|
|
connector->polled = DRM_CONNECTOR_POLL_CONNECT;
|
|
|
|
connector->interlace_allowed = true;
|
2010-11-30 13:46:47 -07:00
|
|
|
connector->doublescan_allowed = true;
|
2011-05-20 02:34:22 -06: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;
|
2010-08-04 01:45:04 -06:00
|
|
|
drm_connector_attach_property(&radeon_connector->base,
|
2011-05-20 02:34:22 -06:00
|
|
|
rdev->mode_info.load_detect_property,
|
|
|
|
1);
|
|
|
|
/* 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;
|
2010-09-21 13:30:59 -06:00
|
|
|
drm_connector_attach_property(&radeon_connector->base,
|
2011-05-20 02:34:22 -06:00
|
|
|
rdev->mode_info.coherent_mode_property,
|
|
|
|
1);
|
|
|
|
if (ASIC_IS_AVIVO(rdev)) {
|
|
|
|
drm_connector_attach_property(&radeon_connector->base,
|
|
|
|
rdev->mode_info.underscan_property,
|
|
|
|
UNDERSCAN_OFF);
|
|
|
|
drm_connector_attach_property(&radeon_connector->base,
|
|
|
|
rdev->mode_info.underscan_hborder_property,
|
|
|
|
0);
|
|
|
|
drm_connector_attach_property(&radeon_connector->base,
|
|
|
|
rdev->mode_info.underscan_vborder_property,
|
|
|
|
0);
|
|
|
|
}
|
|
|
|
if (connector_type == DRM_MODE_CONNECTOR_DVII) {
|
|
|
|
radeon_connector->dac_load_detect = true;
|
|
|
|
drm_connector_attach_property(&radeon_connector->base,
|
|
|
|
rdev->mode_info.load_detect_property,
|
|
|
|
1);
|
|
|
|
}
|
|
|
|
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");
|
|
|
|
}
|
2010-09-21 13:30:59 -06:00
|
|
|
drm_connector_attach_property(&radeon_connector->base,
|
2011-05-20 02:34:22 -06:00
|
|
|
rdev->mode_info.coherent_mode_property,
|
|
|
|
1);
|
|
|
|
if (ASIC_IS_AVIVO(rdev)) {
|
|
|
|
drm_connector_attach_property(&radeon_connector->base,
|
|
|
|
rdev->mode_info.underscan_property,
|
|
|
|
UNDERSCAN_OFF);
|
|
|
|
drm_connector_attach_property(&radeon_connector->base,
|
|
|
|
rdev->mode_info.underscan_hborder_property,
|
|
|
|
0);
|
|
|
|
drm_connector_attach_property(&radeon_connector->base,
|
|
|
|
rdev->mode_info.underscan_vborder_property,
|
|
|
|
0);
|
|
|
|
}
|
|
|
|
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) {
|
|
|
|
/* add DP i2c bus */
|
|
|
|
radeon_dig_connector->dp_i2c_bus = radeon_i2c_create_dp(dev, i2c_bus, "DP-auxch");
|
|
|
|
if (!radeon_dig_connector->dp_i2c_bus)
|
|
|
|
DRM_ERROR("DP: Failed to assign dp ddc bus! Check dmesg for i2c errors.\n");
|
|
|
|
radeon_connector->ddc_bus = radeon_i2c_lookup(rdev, i2c_bus);
|
|
|
|
if (!radeon_connector->ddc_bus)
|
|
|
|
DRM_ERROR("DP: Failed to assign ddc bus! Check dmesg for i2c errors.\n");
|
|
|
|
}
|
|
|
|
subpixel_order = SubPixelHorizontalRGB;
|
|
|
|
drm_connector_attach_property(&radeon_connector->base,
|
|
|
|
rdev->mode_info.coherent_mode_property,
|
|
|
|
1);
|
|
|
|
if (ASIC_IS_AVIVO(rdev)) {
|
|
|
|
drm_connector_attach_property(&radeon_connector->base,
|
|
|
|
rdev->mode_info.underscan_property,
|
|
|
|
UNDERSCAN_OFF);
|
|
|
|
drm_connector_attach_property(&radeon_connector->base,
|
|
|
|
rdev->mode_info.underscan_hborder_property,
|
|
|
|
0);
|
|
|
|
drm_connector_attach_property(&radeon_connector->base,
|
|
|
|
rdev->mode_info.underscan_vborder_property,
|
|
|
|
0);
|
|
|
|
}
|
|
|
|
connector->interlace_allowed = true;
|
|
|
|
/* in theory with a DP to VGA converter... */
|
2010-11-30 13:46:47 -07:00
|
|
|
connector->doublescan_allowed = false;
|
2011-05-20 02:34:22 -06: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;
|
|
|
|
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) {
|
|
|
|
/* add DP i2c bus */
|
|
|
|
radeon_dig_connector->dp_i2c_bus = radeon_i2c_create_dp(dev, i2c_bus, "eDP-auxch");
|
|
|
|
if (!radeon_dig_connector->dp_i2c_bus)
|
|
|
|
DRM_ERROR("DP: Failed to assign dp ddc bus! Check dmesg for i2c errors.\n");
|
|
|
|
radeon_connector->ddc_bus = radeon_i2c_lookup(rdev, i2c_bus);
|
|
|
|
if (!radeon_connector->ddc_bus)
|
|
|
|
DRM_ERROR("DP: Failed to assign ddc bus! Check dmesg for i2c errors.\n");
|
|
|
|
}
|
2010-08-04 01:45:04 -06:00
|
|
|
drm_connector_attach_property(&radeon_connector->base,
|
2011-05-20 02:34:22 -06: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;
|
2010-09-21 13:30:59 -06:00
|
|
|
drm_connector_attach_property(&radeon_connector->base,
|
2011-05-20 02:34:22 -06:00
|
|
|
rdev->mode_info.load_detect_property,
|
|
|
|
1);
|
2010-09-21 13:30:59 -06:00
|
|
|
drm_connector_attach_property(&radeon_connector->base,
|
2011-05-20 02:34:22 -06: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");
|
|
|
|
}
|
|
|
|
drm_connector_attach_property(&radeon_connector->base,
|
|
|
|
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 06:42:42 -06:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2010-07-20 01:24:11 -06:00
|
|
|
if (radeon_connector->hpd.hpd == RADEON_HPD_NONE) {
|
2010-05-07 00:42:51 -06:00
|
|
|
if (i2c_bus->valid)
|
|
|
|
connector->polled = DRM_CONNECTOR_POLL_CONNECT;
|
|
|
|
} else
|
|
|
|
connector->polled = DRM_CONNECTOR_POLL_HPD;
|
|
|
|
|
2009-06-05 06:42:42 -06:00
|
|
|
connector->display_info.subpixel_order = subpixel_order;
|
|
|
|
drm_sysfs_connector_add(connector);
|
|
|
|
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 11:16:01 -07:00
|
|
|
struct radeon_i2c_bus_rec *i2c_bus,
|
2009-12-04 12:45:27 -07:00
|
|
|
uint16_t connector_object_id,
|
|
|
|
struct radeon_hpd *hpd)
|
2009-06-05 06:42:42 -06:00
|
|
|
{
|
2009-09-09 01:40:54 -06:00
|
|
|
struct radeon_device *rdev = dev->dev_private;
|
2009-06-05 06:42:42 -06:00
|
|
|
struct drm_connector *connector;
|
|
|
|
struct radeon_connector *radeon_connector;
|
|
|
|
uint32_t subpixel_order = SubPixelNone;
|
|
|
|
|
2009-08-13 00:32:14 -06:00
|
|
|
if (connector_type == DRM_MODE_CONNECTOR_Unknown)
|
2009-06-05 06:42:42 -06:00
|
|
|
return;
|
|
|
|
|
2010-09-01 15:15:06 -06: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 06:42:42 -06: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 11:16:01 -07:00
|
|
|
radeon_connector->connector_object_id = connector_object_id;
|
2009-12-04 12:45:27 -07:00
|
|
|
radeon_connector->hpd = *hpd;
|
2011-07-29 08:28:58 -06:00
|
|
|
radeon_connector->requires_extended_probe =
|
|
|
|
radeon_connector_needs_extended_probe(rdev, supported_device,
|
|
|
|
connector_type);
|
2009-06-05 06:42:42 -06:00
|
|
|
switch (connector_type) {
|
|
|
|
case DRM_MODE_CONNECTOR_VGA:
|
|
|
|
drm_connector_init(dev, &radeon_connector->base, &radeon_vga_connector_funcs, connector_type);
|
2010-03-29 23:34:15 -06:00
|
|
|
drm_connector_helper_add(&radeon_connector->base, &radeon_vga_connector_helper_funcs);
|
2009-06-05 06:42:42 -06:00
|
|
|
if (i2c_bus->valid) {
|
2010-08-05 19:21:16 -06:00
|
|
|
radeon_connector->ddc_bus = radeon_i2c_lookup(rdev, i2c_bus);
|
2009-06-05 06:42:42 -06:00
|
|
|
if (!radeon_connector->ddc_bus)
|
2011-04-14 15:24:07 -06:00
|
|
|
DRM_ERROR("VGA: Failed to assign ddc bus! Check dmesg for i2c errors.\n");
|
2009-06-05 06:42:42 -06:00
|
|
|
}
|
2009-09-24 19:56:50 -06:00
|
|
|
radeon_connector->dac_load_detect = true;
|
2009-09-09 01:40:54 -06:00
|
|
|
drm_connector_attach_property(&radeon_connector->base,
|
|
|
|
rdev->mode_info.load_detect_property,
|
|
|
|
1);
|
2010-07-20 01:24:11 -06:00
|
|
|
/* no HPD on analog connectors */
|
|
|
|
radeon_connector->hpd.hpd = RADEON_HPD_NONE;
|
2010-05-07 00:42:51 -06:00
|
|
|
connector->polled = DRM_CONNECTOR_POLL_CONNECT;
|
2010-11-30 13:46:47 -07:00
|
|
|
connector->interlace_allowed = true;
|
|
|
|
connector->doublescan_allowed = true;
|
2009-06-05 06:42:42 -06:00
|
|
|
break;
|
|
|
|
case DRM_MODE_CONNECTOR_DVIA:
|
|
|
|
drm_connector_init(dev, &radeon_connector->base, &radeon_vga_connector_funcs, connector_type);
|
2010-03-29 23:34:15 -06:00
|
|
|
drm_connector_helper_add(&radeon_connector->base, &radeon_vga_connector_helper_funcs);
|
2009-06-05 06:42:42 -06:00
|
|
|
if (i2c_bus->valid) {
|
2010-08-05 19:21:16 -06:00
|
|
|
radeon_connector->ddc_bus = radeon_i2c_lookup(rdev, i2c_bus);
|
2009-06-05 06:42:42 -06:00
|
|
|
if (!radeon_connector->ddc_bus)
|
2011-04-14 15:24:07 -06:00
|
|
|
DRM_ERROR("DVIA: Failed to assign ddc bus! Check dmesg for i2c errors.\n");
|
2009-06-05 06:42:42 -06:00
|
|
|
}
|
2009-09-24 19:56:50 -06:00
|
|
|
radeon_connector->dac_load_detect = true;
|
2009-09-09 01:40:54 -06:00
|
|
|
drm_connector_attach_property(&radeon_connector->base,
|
|
|
|
rdev->mode_info.load_detect_property,
|
|
|
|
1);
|
2010-07-20 01:24:11 -06:00
|
|
|
/* no HPD on analog connectors */
|
|
|
|
radeon_connector->hpd.hpd = RADEON_HPD_NONE;
|
2010-11-30 13:46:47 -07:00
|
|
|
connector->interlace_allowed = true;
|
|
|
|
connector->doublescan_allowed = true;
|
2009-06-05 06:42:42 -06: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-29 23:34:15 -06:00
|
|
|
drm_connector_helper_add(&radeon_connector->base, &radeon_dvi_connector_helper_funcs);
|
2009-06-05 06:42:42 -06:00
|
|
|
if (i2c_bus->valid) {
|
2010-08-05 19:21:16 -06:00
|
|
|
radeon_connector->ddc_bus = radeon_i2c_lookup(rdev, i2c_bus);
|
2009-06-05 06:42:42 -06:00
|
|
|
if (!radeon_connector->ddc_bus)
|
2011-04-14 15:24:07 -06:00
|
|
|
DRM_ERROR("DVI: Failed to assign ddc bus! Check dmesg for i2c errors.\n");
|
2010-04-30 10:37:31 -06:00
|
|
|
}
|
|
|
|
if (connector_type == DRM_MODE_CONNECTOR_DVII) {
|
2009-09-24 19:56:50 -06:00
|
|
|
radeon_connector->dac_load_detect = true;
|
2009-09-09 01:40:54 -06:00
|
|
|
drm_connector_attach_property(&radeon_connector->base,
|
|
|
|
rdev->mode_info.load_detect_property,
|
|
|
|
1);
|
2009-06-05 06:42:42 -06:00
|
|
|
}
|
|
|
|
subpixel_order = SubPixelHorizontalRGB;
|
2010-11-30 13:46:47 -07:00
|
|
|
connector->interlace_allowed = true;
|
|
|
|
if (connector_type == DRM_MODE_CONNECTOR_DVII)
|
|
|
|
connector->doublescan_allowed = true;
|
|
|
|
else
|
|
|
|
connector->doublescan_allowed = false;
|
2009-06-05 06:42:42 -06:00
|
|
|
break;
|
|
|
|
case DRM_MODE_CONNECTOR_SVIDEO:
|
|
|
|
case DRM_MODE_CONNECTOR_Composite:
|
|
|
|
case DRM_MODE_CONNECTOR_9PinDIN:
|
2010-09-01 15:15:06 -06: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;
|
|
|
|
drm_connector_attach_property(&radeon_connector->base,
|
|
|
|
rdev->mode_info.load_detect_property,
|
|
|
|
radeon_connector->dac_load_detect);
|
|
|
|
drm_connector_attach_property(&radeon_connector->base,
|
|
|
|
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 13:46:47 -07:00
|
|
|
connector->interlace_allowed = false;
|
|
|
|
connector->doublescan_allowed = false;
|
2009-06-05 06:42:42 -06:00
|
|
|
break;
|
|
|
|
case DRM_MODE_CONNECTOR_LVDS:
|
|
|
|
drm_connector_init(dev, &radeon_connector->base, &radeon_lvds_connector_funcs, connector_type);
|
2010-03-29 23:34:15 -06:00
|
|
|
drm_connector_helper_add(&radeon_connector->base, &radeon_lvds_connector_helper_funcs);
|
2009-06-05 06:42:42 -06:00
|
|
|
if (i2c_bus->valid) {
|
2010-08-05 19:21:16 -06:00
|
|
|
radeon_connector->ddc_bus = radeon_i2c_lookup(rdev, i2c_bus);
|
2009-06-05 06:42:42 -06:00
|
|
|
if (!radeon_connector->ddc_bus)
|
2011-04-14 15:24:07 -06:00
|
|
|
DRM_ERROR("LVDS: Failed to assign ddc bus! Check dmesg for i2c errors.\n");
|
2009-06-05 06:42:42 -06:00
|
|
|
}
|
2009-09-09 01:40:54 -06:00
|
|
|
drm_connector_attach_property(&radeon_connector->base,
|
|
|
|
dev->mode_config.scaling_mode_property,
|
|
|
|
DRM_MODE_SCALE_FULLSCREEN);
|
2009-06-05 06:42:42 -06:00
|
|
|
subpixel_order = SubPixelHorizontalRGB;
|
2010-11-30 13:46:47 -07:00
|
|
|
connector->interlace_allowed = false;
|
|
|
|
connector->doublescan_allowed = false;
|
2009-06-05 06:42:42 -06:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2010-07-20 01:24:11 -06:00
|
|
|
if (radeon_connector->hpd.hpd == RADEON_HPD_NONE) {
|
2010-05-07 00:42:51 -06:00
|
|
|
if (i2c_bus->valid)
|
|
|
|
connector->polled = DRM_CONNECTOR_POLL_CONNECT;
|
|
|
|
} else
|
|
|
|
connector->polled = DRM_CONNECTOR_POLL_HPD;
|
2009-06-05 06:42:42 -06:00
|
|
|
connector->display_info.subpixel_order = subpixel_order;
|
|
|
|
drm_sysfs_connector_add(connector);
|
2011-03-22 17:30:23 -06:00
|
|
|
if (connector_type == DRM_MODE_CONNECTOR_LVDS) {
|
|
|
|
struct drm_encoder *drm_encoder;
|
|
|
|
|
|
|
|
list_for_each_entry(drm_encoder, &dev->mode_config.encoder_list, head) {
|
|
|
|
struct radeon_encoder *radeon_encoder;
|
|
|
|
|
|
|
|
radeon_encoder = to_radeon_encoder(drm_encoder);
|
|
|
|
if (radeon_encoder->encoder_id == ENCODER_OBJECT_ID_INTERNAL_LVDS)
|
|
|
|
radeon_legacy_backlight_init(radeon_encoder, connector);
|
|
|
|
}
|
|
|
|
}
|
2009-06-05 06:42:42 -06:00
|
|
|
}
|