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);
|
|
|
|
|
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;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
list_for_each_entry(conflict, &dev->mode_config.connector_list, head) {
|
|
|
|
if (conflict == connector)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
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;
|
|
|
|
|
|
|
|
if (priority == true) {
|
|
|
|
DRM_INFO("1: conflicting encoders switching off %s\n", drm_get_connector_name(conflict));
|
|
|
|
DRM_INFO("in favor of %s\n", drm_get_connector_name(connector));
|
|
|
|
conflict->status = connector_status_disconnected;
|
|
|
|
radeon_connector_update_scratch_regs(conflict, connector_status_disconnected);
|
|
|
|
} else {
|
|
|
|
DRM_INFO("2: conflicting encoders switching off %s\n", drm_get_connector_name(connector));
|
|
|
|
DRM_INFO("in favor of %s\n", drm_get_connector_name(conflict));
|
|
|
|
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);
|
|
|
|
|
|
|
|
DRM_DEBUG("Adding native panel mode %s\n", mode->name);
|
|
|
|
}
|
|
|
|
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++) {
|
|
|
|
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;
|
|
|
|
|
|
|
|
/* 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;
|
|
|
|
dig->coherent_mode = val ? true : false;
|
|
|
|
radeon_property_change_mode(&radeon_encoder->base);
|
|
|
|
}
|
|
|
|
|
|
|
|
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;
|
|
|
|
if (rdev->is_atom_bios) {
|
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
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;
|
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
|
|
|
struct drm_display_mode *t, *mode;
|
|
|
|
|
|
|
|
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);
|
2009-09-15 09:09:27 -06:00
|
|
|
DRM_INFO("Determined LVDS native mode details from EDID\n");
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2009-10-09 13:14:30 -06:00
|
|
|
if (!native_mode->clock) {
|
2009-09-15 09:09:27 -06:00
|
|
|
DRM_INFO("No LVDS native mode details, disabling RMX\n");
|
|
|
|
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);
|
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)
|
|
|
|
{
|
|
|
|
return MODE_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
static enum drm_connector_status radeon_lvds_detect(struct drm_connector *connector)
|
|
|
|
{
|
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_i2c_do_lock(radeon_connector, 1);
|
|
|
|
radeon_connector->edid = drm_get_edid(&radeon_connector->base,
|
|
|
|
&radeon_connector->ddc_bus->adapter);
|
|
|
|
radeon_i2c_do_lock(radeon_connector, 0);
|
|
|
|
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);
|
|
|
|
|
|
|
|
if (radeon_connector->ddc_bus)
|
|
|
|
radeon_i2c_destroy(radeon_connector->ddc_bus);
|
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;
|
|
|
|
|
|
|
|
DRM_DEBUG("\n");
|
|
|
|
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)
|
|
|
|
{
|
|
|
|
return MODE_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
static enum drm_connector_status radeon_vga_detect(struct drm_connector *connector)
|
|
|
|
{
|
|
|
|
struct radeon_connector *radeon_connector = to_radeon_connector(connector);
|
|
|
|
struct drm_encoder *encoder;
|
|
|
|
struct drm_encoder_helper_funcs *encoder_funcs;
|
|
|
|
bool dret;
|
|
|
|
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;
|
|
|
|
|
2009-06-05 06:42:42 -06:00
|
|
|
radeon_i2c_do_lock(radeon_connector, 1);
|
|
|
|
dret = radeon_ddc_probe(radeon_connector);
|
|
|
|
radeon_i2c_do_lock(radeon_connector, 0);
|
2009-10-15 14:16:35 -06:00
|
|
|
if (dret) {
|
|
|
|
if (radeon_connector->edid) {
|
|
|
|
kfree(radeon_connector->edid);
|
|
|
|
radeon_connector->edid = NULL;
|
|
|
|
}
|
|
|
|
radeon_i2c_do_lock(radeon_connector, 1);
|
|
|
|
radeon_connector->edid = drm_get_edid(&radeon_connector->base, &radeon_connector->ddc_bus->adapter);
|
|
|
|
radeon_i2c_do_lock(radeon_connector, 0);
|
|
|
|
|
|
|
|
if (!radeon_connector->edid) {
|
|
|
|
DRM_ERROR("DDC responded but not EDID found for %s\n",
|
|
|
|
drm_get_connector_name(connector));
|
|
|
|
} 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 {
|
2009-09-09 01:40:54 -06:00
|
|
|
if (radeon_connector->dac_load_detect) {
|
|
|
|
encoder_funcs = encoder->helper_private;
|
|
|
|
ret = encoder_funcs->detect(encoder, connector);
|
|
|
|
}
|
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);
|
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)
|
|
|
|
{
|
|
|
|
return MODE_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
static enum drm_connector_status radeon_tv_detect(struct drm_connector *connector)
|
|
|
|
{
|
|
|
|
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.
|
|
|
|
*/
|
2009-06-05 06:42:42 -06:00
|
|
|
static enum drm_connector_status radeon_dvi_detect(struct drm_connector *connector)
|
|
|
|
{
|
|
|
|
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;
|
|
|
|
bool dret;
|
|
|
|
|
|
|
|
radeon_i2c_do_lock(radeon_connector, 1);
|
|
|
|
dret = radeon_ddc_probe(radeon_connector);
|
|
|
|
radeon_i2c_do_lock(radeon_connector, 0);
|
2009-08-13 00:32:14 -06:00
|
|
|
if (dret) {
|
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_i2c_do_lock(radeon_connector, 1);
|
|
|
|
radeon_connector->edid = drm_get_edid(&radeon_connector->base, &radeon_connector->ddc_bus->adapter);
|
|
|
|
radeon_i2c_do_lock(radeon_connector, 0);
|
|
|
|
|
|
|
|
if (!radeon_connector->edid) {
|
|
|
|
DRM_ERROR("DDC responded but not EDID found for %s\n",
|
|
|
|
drm_get_connector_name(connector));
|
|
|
|
} 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-08-13 00:32:14 -06:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if ((ret == connector_status_connected) && (radeon_connector->use_digital == true))
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
/* 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;
|
|
|
|
}
|
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);
|
|
|
|
}
|
|
|
|
|
|
|
|
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-06-05 06:42:42 -06:00
|
|
|
struct drm_connector_helper_funcs radeon_dvi_connector_helper_funcs = {
|
|
|
|
.get_modes = radeon_dvi_get_modes,
|
|
|
|
.mode_valid = radeon_vga_mode_valid,
|
|
|
|
.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
|
|
|
};
|
|
|
|
|
|
|
|
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,
|
|
|
|
bool linkb,
|
|
|
|
uint32_t igp_lane_info)
|
|
|
|
{
|
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;
|
|
|
|
uint32_t subpixel_order = SubPixelNone;
|
2009-10-15 14:16:35 -06:00
|
|
|
bool shared_ddc = false;
|
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
|
|
|
int ret;
|
2009-06-05 06:42:42 -06:00
|
|
|
|
|
|
|
/* fixme - tv/cv/din */
|
2009-08-13 00:32:14 -06:00
|
|
|
if (connector_type == DRM_MODE_CONNECTOR_Unknown)
|
2009-06-05 06:42:42 -06:00
|
|
|
return;
|
|
|
|
|
|
|
|
/* 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) {
|
|
|
|
if (memcmp(&radeon_connector->ddc_bus->rec, i2c_bus,
|
|
|
|
sizeof(struct radeon_i2c_bus_rec)) == 0) {
|
|
|
|
radeon_connector->shared_ddc = true;
|
|
|
|
shared_ddc = true;
|
|
|
|
}
|
|
|
|
}
|
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-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);
|
2009-09-27 23:31:10 -06:00
|
|
|
ret = drm_connector_helper_add(&radeon_connector->base, &radeon_vga_connector_helper_funcs);
|
|
|
|
if (ret)
|
|
|
|
goto failed;
|
2009-06-05 06:42:42 -06:00
|
|
|
if (i2c_bus->valid) {
|
|
|
|
radeon_connector->ddc_bus = radeon_i2c_create(dev, i2c_bus, "VGA");
|
|
|
|
if (!radeon_connector->ddc_bus)
|
|
|
|
goto failed;
|
|
|
|
}
|
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
|
|
|
break;
|
|
|
|
case DRM_MODE_CONNECTOR_DVIA:
|
|
|
|
drm_connector_init(dev, &radeon_connector->base, &radeon_vga_connector_funcs, connector_type);
|
2009-09-27 23:31:10 -06:00
|
|
|
ret = drm_connector_helper_add(&radeon_connector->base, &radeon_vga_connector_helper_funcs);
|
|
|
|
if (ret)
|
|
|
|
goto failed;
|
2009-06-05 06:42:42 -06:00
|
|
|
if (i2c_bus->valid) {
|
|
|
|
radeon_connector->ddc_bus = radeon_i2c_create(dev, i2c_bus, "DVI");
|
|
|
|
if (!radeon_connector->ddc_bus)
|
|
|
|
goto failed;
|
|
|
|
}
|
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
|
|
|
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->linkb = linkb;
|
|
|
|
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);
|
2009-09-27 23:31:10 -06:00
|
|
|
ret = drm_connector_helper_add(&radeon_connector->base, &radeon_dvi_connector_helper_funcs);
|
|
|
|
if (ret)
|
|
|
|
goto failed;
|
2009-06-05 06:42:42 -06:00
|
|
|
if (i2c_bus->valid) {
|
|
|
|
radeon_connector->ddc_bus = radeon_i2c_create(dev, i2c_bus, "DVI");
|
|
|
|
if (!radeon_connector->ddc_bus)
|
|
|
|
goto failed;
|
|
|
|
}
|
|
|
|
subpixel_order = SubPixelHorizontalRGB;
|
2009-09-09 01:40:54 -06:00
|
|
|
drm_connector_attach_property(&radeon_connector->base,
|
|
|
|
rdev->mode_info.coherent_mode_property,
|
|
|
|
1);
|
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
|
|
|
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->linkb = linkb;
|
|
|
|
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);
|
2009-09-27 23:31:10 -06:00
|
|
|
ret = drm_connector_helper_add(&radeon_connector->base, &radeon_dvi_connector_helper_funcs);
|
|
|
|
if (ret)
|
|
|
|
goto failed;
|
2009-06-05 06:42:42 -06:00
|
|
|
if (i2c_bus->valid) {
|
|
|
|
radeon_connector->ddc_bus = radeon_i2c_create(dev, i2c_bus, "HDMI");
|
|
|
|
if (!radeon_connector->ddc_bus)
|
|
|
|
goto failed;
|
|
|
|
}
|
2009-09-09 01:40:54 -06:00
|
|
|
drm_connector_attach_property(&radeon_connector->base,
|
|
|
|
rdev->mode_info.coherent_mode_property,
|
|
|
|
1);
|
2009-06-05 06:42:42 -06:00
|
|
|
subpixel_order = SubPixelHorizontalRGB;
|
|
|
|
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->linkb = linkb;
|
|
|
|
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);
|
2009-09-27 23:31:10 -06:00
|
|
|
ret = drm_connector_helper_add(&radeon_connector->base, &radeon_dvi_connector_helper_funcs);
|
|
|
|
if (ret)
|
|
|
|
goto failed;
|
2009-06-05 06:42:42 -06:00
|
|
|
if (i2c_bus->valid) {
|
|
|
|
radeon_connector->ddc_bus = radeon_i2c_create(dev, i2c_bus, "DP");
|
|
|
|
if (!radeon_connector->ddc_bus)
|
|
|
|
goto failed;
|
|
|
|
}
|
|
|
|
subpixel_order = SubPixelHorizontalRGB;
|
|
|
|
break;
|
|
|
|
case DRM_MODE_CONNECTOR_SVIDEO:
|
|
|
|
case DRM_MODE_CONNECTOR_Composite:
|
|
|
|
case DRM_MODE_CONNECTOR_9PinDIN:
|
2009-08-13 00:32:14 -06:00
|
|
|
if (radeon_tv == 1) {
|
|
|
|
drm_connector_init(dev, &radeon_connector->base, &radeon_tv_connector_funcs, connector_type);
|
2009-09-27 23:31:10 -06:00
|
|
|
ret = drm_connector_helper_add(&radeon_connector->base, &radeon_tv_connector_helper_funcs);
|
|
|
|
if (ret)
|
|
|
|
goto failed;
|
|
|
|
radeon_connector->dac_load_detect = true;
|
|
|
|
drm_connector_attach_property(&radeon_connector->base,
|
|
|
|
rdev->mode_info.load_detect_property,
|
|
|
|
1);
|
2009-08-13 00:32:14 -06:00
|
|
|
}
|
2009-06-05 06:42:42 -06:00
|
|
|
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->linkb = linkb;
|
|
|
|
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);
|
2009-09-27 23:31:10 -06:00
|
|
|
ret = drm_connector_helper_add(&radeon_connector->base, &radeon_lvds_connector_helper_funcs);
|
|
|
|
if (ret)
|
|
|
|
goto failed;
|
2009-06-05 06:42:42 -06:00
|
|
|
if (i2c_bus->valid) {
|
|
|
|
radeon_connector->ddc_bus = radeon_i2c_create(dev, i2c_bus, "LVDS");
|
|
|
|
if (!radeon_connector->ddc_bus)
|
|
|
|
goto failed;
|
|
|
|
}
|
2009-09-09 01:40:54 -06:00
|
|
|
drm_mode_create_scaling_mode_property(dev);
|
|
|
|
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;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
connector->display_info.subpixel_order = subpixel_order;
|
|
|
|
drm_sysfs_connector_add(connector);
|
|
|
|
return;
|
|
|
|
|
|
|
|
failed:
|
|
|
|
if (radeon_connector->ddc_bus)
|
|
|
|
radeon_i2c_destroy(radeon_connector->ddc_bus);
|
|
|
|
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,
|
|
|
|
struct radeon_i2c_bus_rec *i2c_bus)
|
|
|
|
{
|
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;
|
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
|
|
|
int ret;
|
2009-06-05 06:42:42 -06:00
|
|
|
|
|
|
|
/* fixme - tv/cv/din */
|
2009-08-13 00:32:14 -06:00
|
|
|
if (connector_type == DRM_MODE_CONNECTOR_Unknown)
|
2009-06-05 06:42:42 -06:00
|
|
|
return;
|
|
|
|
|
|
|
|
/* 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;
|
|
|
|
switch (connector_type) {
|
|
|
|
case DRM_MODE_CONNECTOR_VGA:
|
|
|
|
drm_connector_init(dev, &radeon_connector->base, &radeon_vga_connector_funcs, connector_type);
|
2009-09-27 23:31:10 -06:00
|
|
|
ret = drm_connector_helper_add(&radeon_connector->base, &radeon_vga_connector_helper_funcs);
|
|
|
|
if (ret)
|
|
|
|
goto failed;
|
2009-06-05 06:42:42 -06:00
|
|
|
if (i2c_bus->valid) {
|
|
|
|
radeon_connector->ddc_bus = radeon_i2c_create(dev, i2c_bus, "VGA");
|
|
|
|
if (!radeon_connector->ddc_bus)
|
|
|
|
goto failed;
|
|
|
|
}
|
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
|
|
|
break;
|
|
|
|
case DRM_MODE_CONNECTOR_DVIA:
|
|
|
|
drm_connector_init(dev, &radeon_connector->base, &radeon_vga_connector_funcs, connector_type);
|
2009-09-27 23:31:10 -06:00
|
|
|
ret = drm_connector_helper_add(&radeon_connector->base, &radeon_vga_connector_helper_funcs);
|
|
|
|
if (ret)
|
|
|
|
goto failed;
|
2009-06-05 06:42:42 -06:00
|
|
|
if (i2c_bus->valid) {
|
|
|
|
radeon_connector->ddc_bus = radeon_i2c_create(dev, i2c_bus, "DVI");
|
|
|
|
if (!radeon_connector->ddc_bus)
|
|
|
|
goto failed;
|
|
|
|
}
|
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
|
|
|
break;
|
|
|
|
case DRM_MODE_CONNECTOR_DVII:
|
|
|
|
case DRM_MODE_CONNECTOR_DVID:
|
|
|
|
drm_connector_init(dev, &radeon_connector->base, &radeon_dvi_connector_funcs, connector_type);
|
2009-09-27 23:31:10 -06:00
|
|
|
ret = drm_connector_helper_add(&radeon_connector->base, &radeon_dvi_connector_helper_funcs);
|
|
|
|
if (ret)
|
|
|
|
goto failed;
|
2009-06-05 06:42:42 -06:00
|
|
|
if (i2c_bus->valid) {
|
|
|
|
radeon_connector->ddc_bus = radeon_i2c_create(dev, i2c_bus, "DVI");
|
|
|
|
if (!radeon_connector->ddc_bus)
|
|
|
|
goto failed;
|
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;
|
|
|
|
break;
|
|
|
|
case DRM_MODE_CONNECTOR_SVIDEO:
|
|
|
|
case DRM_MODE_CONNECTOR_Composite:
|
|
|
|
case DRM_MODE_CONNECTOR_9PinDIN:
|
2009-08-13 00:32:14 -06:00
|
|
|
if (radeon_tv == 1) {
|
|
|
|
drm_connector_init(dev, &radeon_connector->base, &radeon_tv_connector_funcs, connector_type);
|
2009-09-27 23:31:10 -06:00
|
|
|
ret = drm_connector_helper_add(&radeon_connector->base, &radeon_tv_connector_helper_funcs);
|
|
|
|
if (ret)
|
|
|
|
goto failed;
|
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-08-13 00:32:14 -06:00
|
|
|
}
|
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);
|
2009-09-27 23:31:10 -06:00
|
|
|
ret = drm_connector_helper_add(&radeon_connector->base, &radeon_lvds_connector_helper_funcs);
|
|
|
|
if (ret)
|
|
|
|
goto failed;
|
2009-06-05 06:42:42 -06:00
|
|
|
if (i2c_bus->valid) {
|
|
|
|
radeon_connector->ddc_bus = radeon_i2c_create(dev, i2c_bus, "LVDS");
|
|
|
|
if (!radeon_connector->ddc_bus)
|
|
|
|
goto failed;
|
|
|
|
}
|
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;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
connector->display_info.subpixel_order = subpixel_order;
|
|
|
|
drm_sysfs_connector_add(connector);
|
|
|
|
return;
|
|
|
|
|
|
|
|
failed:
|
|
|
|
if (radeon_connector->ddc_bus)
|
|
|
|
radeon_i2c_destroy(radeon_connector->ddc_bus);
|
|
|
|
drm_connector_cleanup(connector);
|
|
|
|
kfree(connector);
|
|
|
|
}
|