WebSVN – Kolibri OS – Blame – /drivers/video/drm/radeon/radeon_connectors.c

Rev	Author	Line No.	Line
1123	serge	1	/*
		2	* Copyright 2007-8 Advanced Micro Devices, Inc.
		3	* Copyright 2008 Red Hat Inc.
		4	*
		5	* Permission is hereby granted, free of charge, to any person obtaining a
		6	* copy of this software and associated documentation files (the "Software"),
		7	* to deal in the Software without restriction, including without limitation
		8	* the rights to use, copy, modify, merge, publish, distribute, sublicense,
		9	* and/or sell copies of the Software, and to permit persons to whom the
		10	* Software is furnished to do so, subject to the following conditions:
		11	*
		12	* The above copyright notice and this permission notice shall be included in
		13	* all copies or substantial portions of the Software.
		14	*
		15	* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
		16	* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
		17	* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
		18	* THE COPYRIGHT HOLDER(S) OR AUTHOR(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR
		19	* OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
		20	* ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
		21	* OTHER DEALINGS IN THE SOFTWARE.
		22	*
		23	* Authors: Dave Airlie
		24	* Alex Deucher
		25	*/
2997	Serge	26	#include
		27	#include
		28	#include
		29	#include
6104	serge	30	#include
2997	Serge	31	#include
1123	serge	32	#include "radeon.h"
6104	serge	33	#include "radeon_audio.h"
1179	serge	34	#include "atom.h"
1123	serge	35
6104	serge	36	#include
3192	Serge	37
6104	serge	38	static int radeon_dp_handle_hpd(struct drm_connector *connector)
		39	{
		40	struct radeon_connector *radeon_connector = to_radeon_connector(connector);
		41	int ret;
3192	Serge	42
6104	serge	43	ret = radeon_dp_mst_check_status(radeon_connector);
		44	if (ret == -EINVAL)
		45	return 1;
		46	return 0;
		47	}
1321	serge	48	void radeon_connector_hotplug(struct drm_connector *connector)
		49	{
		50	struct drm_device *dev = connector->dev;
		51	struct radeon_device *rdev = dev->dev_private;
		52	struct radeon_connector *radeon_connector = to_radeon_connector(connector);
		53
6104	serge	54	if (connector->connector_type == DRM_MODE_CONNECTOR_DisplayPort) {
		55	struct radeon_connector_atom_dig *dig_connector =
		56	radeon_connector->con_priv;
		57
		58	if (radeon_connector->is_mst_connector)
		59	return;
		60	if (dig_connector->is_mst) {
		61	radeon_dp_handle_hpd(connector);
		62	return;
		63	}
		64	}
2005	serge	65	/* bail if the connector does not have hpd pin, e.g.,
		66	* VGA, TV, etc.
		67	*/
		68	if (radeon_connector->hpd.hpd == RADEON_HPD_NONE)
		69	return;
		70
6104	serge	71	radeon_hpd_set_polarity(rdev, radeon_connector->hpd.hpd);
1321	serge	72
2997	Serge	73	/* if the connector is already off, don't turn it back on */
5078	serge	74	/* FIXME: This access isn't protected by any locks. */
2997	Serge	75	if (connector->dpms != DRM_MODE_DPMS_ON)
1963	serge	76	return;
		77
2997	Serge	78	/* just deal with DP (not eDP) here. */
		79	if (connector->connector_type == DRM_MODE_CONNECTOR_DisplayPort) {
		80	struct radeon_connector_atom_dig *dig_connector =
		81	radeon_connector->con_priv;
		82
		83	/* if existing sink type was not DP no need to retrain */
		84	if (dig_connector->dp_sink_type != CONNECTOR_OBJECT_ID_DISPLAYPORT)
		85	return;
		86
		87	/* first get sink type as it may be reset after (un)plug */
		88	dig_connector->dp_sink_type = radeon_dp_getsinktype(radeon_connector);
		89	/* don't do anything if sink is not display port, i.e.,
		90	* passive dp->(dvi\|hdmi) adaptor
		91	*/
		92	if (dig_connector->dp_sink_type == CONNECTOR_OBJECT_ID_DISPLAYPORT) {
6104	serge	93	int saved_dpms = connector->dpms;
2997	Serge	94	/* Only turn off the display if it's physically disconnected */
		95	if (!radeon_hpd_sense(rdev, radeon_connector->hpd.hpd)) {
6104	serge	96	drm_helper_connector_dpms(connector, DRM_MODE_DPMS_OFF);
2997	Serge	97	} else if (radeon_dp_needs_link_train(radeon_connector)) {
6104	serge	98	/* Don't try to start link training before we
		99	* have the dpcd */
		100	if (!radeon_dp_getdpcd(radeon_connector))
		101	return;
		102
2997	Serge	103	/* set it to OFF so that drm_helper_connector_dpms()
		104	* won't return immediately since the current state
		105	* is ON at this point.
		106	*/
		107	connector->dpms = DRM_MODE_DPMS_OFF;
6104	serge	108	drm_helper_connector_dpms(connector, DRM_MODE_DPMS_ON);
1321	serge	109	}
6104	serge	110	connector->dpms = saved_dpms;
		111	}
2997	Serge	112	}
1321	serge	113	}
		114
1179	serge	115	static void radeon_property_change_mode(struct drm_encoder *encoder)
		116	{
		117	struct drm_crtc *crtc = encoder->crtc;
		118
		119	if (crtc && crtc->enabled) {
		120	drm_crtc_helper_set_mode(crtc, &crtc->mode,
5078	serge	121	crtc->x, crtc->y, crtc->primary->fb);
1179	serge	122	}
		123	}
2997	Serge	124
		125	int radeon_get_monitor_bpc(struct drm_connector *connector)
		126	{
		127	struct drm_device *dev = connector->dev;
		128	struct radeon_device *rdev = dev->dev_private;
		129	struct radeon_connector *radeon_connector = to_radeon_connector(connector);
		130	struct radeon_connector_atom_dig *dig_connector;
		131	int bpc = 8;
5078	serge	132	int mode_clock, max_tmds_clock;
2997	Serge	133
		134	switch (connector->connector_type) {
		135	case DRM_MODE_CONNECTOR_DVII:
		136	case DRM_MODE_CONNECTOR_HDMIB:
		137	if (radeon_connector->use_digital) {
5078	serge	138	if (drm_detect_hdmi_monitor(radeon_connector_edid(connector))) {
2997	Serge	139	if (connector->display_info.bpc)
		140	bpc = connector->display_info.bpc;
		141	}
		142	}
		143	break;
		144	case DRM_MODE_CONNECTOR_DVID:
		145	case DRM_MODE_CONNECTOR_HDMIA:
5078	serge	146	if (drm_detect_hdmi_monitor(radeon_connector_edid(connector))) {
2997	Serge	147	if (connector->display_info.bpc)
		148	bpc = connector->display_info.bpc;
		149	}
		150	break;
		151	case DRM_MODE_CONNECTOR_DisplayPort:
		152	dig_connector = radeon_connector->con_priv;
		153	if ((dig_connector->dp_sink_type == CONNECTOR_OBJECT_ID_DISPLAYPORT) \|\|
		154	(dig_connector->dp_sink_type == CONNECTOR_OBJECT_ID_eDP) \|\|
5078	serge	155	drm_detect_hdmi_monitor(radeon_connector_edid(connector))) {
2997	Serge	156	if (connector->display_info.bpc)
		157	bpc = connector->display_info.bpc;
		158	}
		159	break;
		160	case DRM_MODE_CONNECTOR_eDP:
		161	case DRM_MODE_CONNECTOR_LVDS:
		162	if (connector->display_info.bpc)
		163	bpc = connector->display_info.bpc;
		164	else if (ASIC_IS_DCE41(rdev) \|\| ASIC_IS_DCE5(rdev)) {
6104	serge	165	const struct drm_connector_helper_funcs *connector_funcs =
2997	Serge	166	connector->helper_private;
		167	struct drm_encoder *encoder = connector_funcs->best_encoder(connector);
		168	struct radeon_encoder *radeon_encoder = to_radeon_encoder(encoder);
		169	struct radeon_encoder_atom_dig *dig = radeon_encoder->enc_priv;
		170
		171	if (dig->lcd_misc & ATOM_PANEL_MISC_V13_6BIT_PER_COLOR)
		172	bpc = 6;
		173	else if (dig->lcd_misc & ATOM_PANEL_MISC_V13_8BIT_PER_COLOR)
		174	bpc = 8;
		175	}
		176	break;
		177	}
5078	serge	178
		179	if (drm_detect_hdmi_monitor(radeon_connector_edid(connector))) {
		180	/* hdmi deep color only implemented on DCE4+ */
		181	if ((bpc > 8) && !ASIC_IS_DCE4(rdev)) {
		182	DRM_DEBUG("%s: HDMI deep color %d bpc unsupported. Using 8 bpc.\n",
		183	connector->name, bpc);
		184	bpc = 8;
		185	}
		186
		187	/*
		188	* Pre DCE-8 hw can't handle > 12 bpc, and more than 12 bpc doesn't make
		189	* much sense without support for > 12 bpc framebuffers. RGB 4:4:4 at
		190	* 12 bpc is always supported on hdmi deep color sinks, as this is
		191	* required by the HDMI-1.3 spec. Clamp to a safe 12 bpc maximum.
		192	*/
		193	if (bpc > 12) {
		194	DRM_DEBUG("%s: HDMI deep color %d bpc unsupported. Using 12 bpc.\n",
		195	connector->name, bpc);
		196	bpc = 12;
		197	}
		198
		199	/* Any defined maximum tmds clock limit we must not exceed? */
		200	if (connector->max_tmds_clock > 0) {
		201	/* mode_clock is clock in kHz for mode to be modeset on this connector */
		202	mode_clock = radeon_connector->pixelclock_for_modeset;
		203
		204	/* Maximum allowable input clock in kHz */
		205	max_tmds_clock = connector->max_tmds_clock * 1000;
		206
		207	DRM_DEBUG("%s: hdmi mode dotclock %d kHz, max tmds input clock %d kHz.\n",
		208	connector->name, mode_clock, max_tmds_clock);
		209
		210	/* Check if bpc is within clock limit. Try to degrade gracefully otherwise */
		211	if ((bpc == 12) && (mode_clock * 3/2 > max_tmds_clock)) {
		212	if ((connector->display_info.edid_hdmi_dc_modes & DRM_EDID_HDMI_DC_30) &&
		213	(mode_clock * 5/4 <= max_tmds_clock))
		214	bpc = 10;
		215	else
		216	bpc = 8;
		217
		218	DRM_DEBUG("%s: HDMI deep color 12 bpc exceeds max tmds clock. Using %d bpc.\n",
		219	connector->name, bpc);
		220	}
		221
		222	if ((bpc == 10) && (mode_clock * 5/4 > max_tmds_clock)) {
		223	bpc = 8;
		224	DRM_DEBUG("%s: HDMI deep color 10 bpc exceeds max tmds clock. Using %d bpc.\n",
		225	connector->name, bpc);
		226	}
		227	}
		228	else if (bpc > 8) {
		229	/* max_tmds_clock missing, but hdmi spec mandates it for deep color. */
		230	DRM_DEBUG("%s: Required max tmds clock for HDMI deep color missing. Using 8 bpc.\n",
		231	connector->name);
		232	bpc = 8;
		233	}
		234	}
		235
		236	if ((radeon_deep_color == 0) && (bpc > 8)) {
		237	DRM_DEBUG("%s: Deep color disabled. Set radeon module param deep_color=1 to enable.\n",
		238	connector->name);
		239	bpc = 8;
		240	}
		241
		242	DRM_DEBUG("%s: Display bpc=%d, returned bpc=%d\n",
		243	connector->name, connector->display_info.bpc, bpc);
		244
2997	Serge	245	return bpc;
		246	}
		247
1123	serge	248	static void
		249	radeon_connector_update_scratch_regs(struct drm_connector *connector, enum drm_connector_status status)
		250	{
		251	struct drm_device *dev = connector->dev;
		252	struct radeon_device *rdev = dev->dev_private;
		253	struct drm_encoder *best_encoder = NULL;
		254	struct drm_encoder *encoder = NULL;
6104	serge	255	const struct drm_connector_helper_funcs *connector_funcs = connector->helper_private;
1123	serge	256	bool connected;
		257	int i;
		258
		259	best_encoder = connector_funcs->best_encoder(connector);
		260
		261	for (i = 0; i < DRM_CONNECTOR_MAX_ENCODER; i++) {
		262	if (connector->encoder_ids[i] == 0)
		263	break;
		264
5078	serge	265	encoder = drm_encoder_find(connector->dev,
		266	connector->encoder_ids[i]);
		267	if (!encoder)
1123	serge	268	continue;
		269
		270	if ((encoder == best_encoder) && (status == connector_status_connected))
		271	connected = true;
		272	else
		273	connected = false;
		274
		275	if (rdev->is_atom_bios)
		276	radeon_atombios_connected_scratch_regs(connector, encoder, connected);
		277	else
		278	radeon_combios_connected_scratch_regs(connector, encoder, connected);
		279
		280	}
		281	}
		282
2997	Serge	283	static struct drm_encoder radeon_find_encoder(struct drm_connector connector, int encoder_type)
1179	serge	284	{
		285	struct drm_encoder *encoder;
		286	int i;
		287
		288	for (i = 0; i < DRM_CONNECTOR_MAX_ENCODER; i++) {
		289	if (connector->encoder_ids[i] == 0)
		290	break;
		291
5078	serge	292	encoder = drm_encoder_find(connector->dev, connector->encoder_ids[i]);
		293	if (!encoder)
1179	serge	294	continue;
		295
		296	if (encoder->encoder_type == encoder_type)
		297	return encoder;
		298	}
		299	return NULL;
		300	}
		301
5078	serge	302	struct edid radeon_connector_edid(struct drm_connector connector)
		303	{
		304	struct radeon_connector *radeon_connector = to_radeon_connector(connector);
		305	struct drm_property_blob *edid_blob = connector->edid_blob_ptr;
		306
		307	if (radeon_connector->edid) {
		308	return radeon_connector->edid;
		309	} else if (edid_blob) {
		310	struct edid *edid = kmemdup(edid_blob->data, edid_blob->length, GFP_KERNEL);
		311	if (edid)
		312	radeon_connector->edid = edid;
		313	}
		314	return radeon_connector->edid;
		315	}
		316
		317	static void radeon_connector_get_edid(struct drm_connector *connector)
		318	{
		319	struct drm_device *dev = connector->dev;
		320	struct radeon_device *rdev = dev->dev_private;
		321	struct radeon_connector *radeon_connector = to_radeon_connector(connector);
		322
		323	if (radeon_connector->edid)
		324	return;
		325
		326	/* on hw with routers, select right port */
		327	if (radeon_connector->router.ddc_valid)
		328	radeon_router_select_ddc_port(radeon_connector);
		329
		330	if ((radeon_connector_encoder_get_dp_bridge_encoder_id(connector) !=
		331	ENCODER_OBJECT_ID_NONE) &&
		332	radeon_connector->ddc_bus->has_aux) {
		333	radeon_connector->edid = drm_get_edid(connector,
		334	&radeon_connector->ddc_bus->aux.ddc);
		335	} else if ((connector->connector_type == DRM_MODE_CONNECTOR_DisplayPort) \|\|
		336	(connector->connector_type == DRM_MODE_CONNECTOR_eDP)) {
		337	struct radeon_connector_atom_dig *dig = radeon_connector->con_priv;
		338
		339	if ((dig->dp_sink_type == CONNECTOR_OBJECT_ID_DISPLAYPORT \|\|
		340	dig->dp_sink_type == CONNECTOR_OBJECT_ID_eDP) &&
		341	radeon_connector->ddc_bus->has_aux)
		342	radeon_connector->edid = drm_get_edid(&radeon_connector->base,
		343	&radeon_connector->ddc_bus->aux.ddc);
		344	else if (radeon_connector->ddc_bus)
		345	radeon_connector->edid = drm_get_edid(&radeon_connector->base,
		346	&radeon_connector->ddc_bus->adapter);
		347	} else if (radeon_connector->ddc_bus) {
		348	radeon_connector->edid = drm_get_edid(&radeon_connector->base,
		349	&radeon_connector->ddc_bus->adapter);
		350	}
		351
		352	if (!radeon_connector->edid) {
5271	serge	353	/* don't fetch the edid from the vbios if ddc fails and runpm is
		354	* enabled so we report disconnected.
		355	*/
		356	if ((rdev->flags & RADEON_IS_PX) && (radeon_runtime_pm != 0))
		357	return;
		358
5078	serge	359	if (rdev->is_atom_bios) {
		360	/* some laptops provide a hardcoded edid in rom for LCDs */
		361	if (((connector->connector_type == DRM_MODE_CONNECTOR_LVDS) \|\|
		362	(connector->connector_type == DRM_MODE_CONNECTOR_eDP)))
		363	radeon_connector->edid = radeon_bios_get_hardcoded_edid(rdev);
		364	} else {
		365	/* some servers provide a hardcoded edid in rom for KVMs */
		366	radeon_connector->edid = radeon_bios_get_hardcoded_edid(rdev);
		367	}
		368	}
		369	}
		370
		371	static void radeon_connector_free_edid(struct drm_connector *connector)
		372	{
		373	struct radeon_connector *radeon_connector = to_radeon_connector(connector);
		374
		375	if (radeon_connector->edid) {
		376	kfree(radeon_connector->edid);
		377	radeon_connector->edid = NULL;
		378	}
		379	}
		380
		381	static int radeon_ddc_get_modes(struct drm_connector *connector)
		382	{
		383	struct radeon_connector *radeon_connector = to_radeon_connector(connector);
		384	int ret;
		385
		386	if (radeon_connector->edid) {
		387	drm_mode_connector_update_edid_property(connector, radeon_connector->edid);
		388	ret = drm_add_edid_modes(connector, radeon_connector->edid);
		389	drm_edid_to_eld(connector, radeon_connector->edid);
		390	return ret;
		391	}
		392	drm_mode_connector_update_edid_property(connector, NULL);
		393	return 0;
		394	}
		395
2997	Serge	396	static struct drm_encoder radeon_best_single_encoder(struct drm_connector connector)
1123	serge	397	{
		398	int enc_id = connector->encoder_ids[0];
		399	/* pick the encoder ids */
5078	serge	400	if (enc_id)
		401	return drm_encoder_find(connector->dev, enc_id);
6104	serge	402	return NULL;
5078	serge	403	}
		404
		405	static void radeon_get_native_mode(struct drm_connector *connector)
		406	{
		407	struct drm_encoder *encoder = radeon_best_single_encoder(connector);
		408	struct radeon_encoder *radeon_encoder;
		409
		410	if (encoder == NULL)
		411	return;
		412
		413	radeon_encoder = to_radeon_encoder(encoder);
		414
		415	if (!list_empty(&connector->probed_modes)) {
		416	struct drm_display_mode *preferred_mode =
		417	list_first_entry(&connector->probed_modes,
		418	struct drm_display_mode, head);
		419
		420	radeon_encoder->native_mode = *preferred_mode;
		421	} else {
		422	radeon_encoder->native_mode.clock = 0;
1123	serge	423	}
		424	}
		425
1179	serge	426	/*
		427	* radeon_connector_analog_encoder_conflict_solve
		428	* - search for other connectors sharing this encoder
		429	* if priority is true, then set them disconnected if this is connected
		430	* if priority is false, set us disconnected if they are connected
		431	*/
		432	static enum drm_connector_status
		433	radeon_connector_analog_encoder_conflict_solve(struct drm_connector *connector,
		434	struct drm_encoder *encoder,
		435	enum drm_connector_status current_status,
		436	bool priority)
		437	{
		438	struct drm_device *dev = connector->dev;
		439	struct drm_connector *conflict;
1963	serge	440	struct radeon_connector *radeon_conflict;
1179	serge	441	int i;
		442
		443	list_for_each_entry(conflict, &dev->mode_config.connector_list, head) {
		444	if (conflict == connector)
		445	continue;
		446
1963	serge	447	radeon_conflict = to_radeon_connector(conflict);
1179	serge	448	for (i = 0; i < DRM_CONNECTOR_MAX_ENCODER; i++) {
		449	if (conflict->encoder_ids[i] == 0)
		450	break;
		451
		452	/* if the IDs match */
		453	if (conflict->encoder_ids[i] == encoder->base.id) {
		454	if (conflict->status != connector_status_connected)
		455	continue;
		456
1963	serge	457	if (radeon_conflict->use_digital)
		458	continue;
		459
1179	serge	460	if (priority == true) {
5078	serge	461	DRM_DEBUG_KMS("1: conflicting encoders switching off %s\n",
		462	conflict->name);
		463	DRM_DEBUG_KMS("in favor of %s\n",
		464	connector->name);
1179	serge	465	conflict->status = connector_status_disconnected;
		466	radeon_connector_update_scratch_regs(conflict, connector_status_disconnected);
		467	} else {
5078	serge	468	DRM_DEBUG_KMS("2: conflicting encoders switching off %s\n",
		469	connector->name);
		470	DRM_DEBUG_KMS("in favor of %s\n",
		471	conflict->name);
1179	serge	472	current_status = connector_status_disconnected;
		473	}
		474	break;
		475	}
		476	}
		477	}
		478	return current_status;
		479
		480	}
		481
1123	serge	482	static struct drm_display_mode radeon_fp_native_mode(struct drm_encoder encoder)
		483	{
		484	struct drm_device *dev = encoder->dev;
		485	struct radeon_encoder *radeon_encoder = to_radeon_encoder(encoder);
		486	struct drm_display_mode *mode = NULL;
1268	serge	487	struct drm_display_mode *native_mode = &radeon_encoder->native_mode;
1123	serge	488
1268	serge	489	if (native_mode->hdisplay != 0 &&
		490	native_mode->vdisplay != 0 &&
		491	native_mode->clock != 0) {
		492	mode = drm_mode_duplicate(dev, native_mode);
1123	serge	493	mode->type = DRM_MODE_TYPE_PREFERRED \| DRM_MODE_TYPE_DRIVER;
		494	drm_mode_set_name(mode);
		495
1963	serge	496	DRM_DEBUG_KMS("Adding native panel mode %s\n", mode->name);
1403	serge	497	} else if (native_mode->hdisplay != 0 &&
		498	native_mode->vdisplay != 0) {
		499	/* mac laptops without an edid */
		500	/* Note that this is not necessarily the exact panel mode,
		501	* but an approximation based on the cvt formula. For these
		502	* systems we should ideally read the mode info out of the
		503	* registers or add a mode table, but this works and is much
		504	* simpler.
		505	*/
		506	mode = drm_cvt_mode(dev, native_mode->hdisplay, native_mode->vdisplay, 60, true, false, false);
		507	mode->type = DRM_MODE_TYPE_PREFERRED \| DRM_MODE_TYPE_DRIVER;
1963	serge	508	DRM_DEBUG_KMS("Adding cvt approximation of native panel mode %s\n", mode->name);
1123	serge	509	}
		510	return mode;
		511	}
		512
1179	serge	513	static void radeon_add_common_modes(struct drm_encoder encoder, struct drm_connector connector)
		514	{
		515	struct drm_device *dev = encoder->dev;
		516	struct radeon_encoder *radeon_encoder = to_radeon_encoder(encoder);
		517	struct drm_display_mode *mode = NULL;
1268	serge	518	struct drm_display_mode *native_mode = &radeon_encoder->native_mode;
1179	serge	519	int i;
		520	struct mode_size {
		521	int w;
		522	int h;
		523	} common_modes[17] = {
		524	{ 640, 480},
		525	{ 720, 480},
		526	{ 800, 600},
		527	{ 848, 480},
		528	{1024, 768},
		529	{1152, 768},
		530	{1280, 720},
		531	{1280, 800},
		532	{1280, 854},
		533	{1280, 960},
		534	{1280, 1024},
		535	{1440, 900},
		536	{1400, 1050},
		537	{1680, 1050},
		538	{1600, 1200},
		539	{1920, 1080},
		540	{1920, 1200}
		541	};
		542
		543	for (i = 0; i < 17; i++) {
1268	serge	544	if (radeon_encoder->devices & (ATOM_DEVICE_TV_SUPPORT)) {
		545	if (common_modes[i].w > 1024 \|\|
		546	common_modes[i].h > 768)
		547	continue;
		548	}
1179	serge	549	if (radeon_encoder->devices & (ATOM_DEVICE_LCD_SUPPORT)) {
1268	serge	550	if (common_modes[i].w > native_mode->hdisplay \|\|
		551	common_modes[i].h > native_mode->vdisplay \|\|
		552	(common_modes[i].w == native_mode->hdisplay &&
		553	common_modes[i].h == native_mode->vdisplay))
1179	serge	554	continue;
		555	}
		556	if (common_modes[i].w < 320 \|\| common_modes[i].h < 200)
		557	continue;
		558
1221	serge	559	mode = drm_cvt_mode(dev, common_modes[i].w, common_modes[i].h, 60, false, false, false);
1179	serge	560	drm_mode_probed_add(connector, mode);
		561	}
		562	}
		563
2997	Serge	564	static int radeon_connector_set_property(struct drm_connector connector, struct drm_property property,
1123	serge	565	uint64_t val)
		566	{
1179	serge	567	struct drm_device *dev = connector->dev;
		568	struct radeon_device *rdev = dev->dev_private;
		569	struct drm_encoder *encoder;
		570	struct radeon_encoder *radeon_encoder;
		571
		572	if (property == rdev->mode_info.coherent_mode_property) {
		573	struct radeon_encoder_atom_dig *dig;
1963	serge	574	bool new_coherent_mode;
1179	serge	575
		576	/* need to find digital encoder on connector */
		577	encoder = radeon_find_encoder(connector, DRM_MODE_ENCODER_TMDS);
		578	if (!encoder)
		579	return 0;
		580
		581	radeon_encoder = to_radeon_encoder(encoder);
		582
		583	if (!radeon_encoder->enc_priv)
		584	return 0;
		585
		586	dig = radeon_encoder->enc_priv;
1963	serge	587	new_coherent_mode = val ? true : false;
		588	if (dig->coherent_mode != new_coherent_mode) {
		589	dig->coherent_mode = new_coherent_mode;
6104	serge	590	radeon_property_change_mode(&radeon_encoder->base);
		591	}
1179	serge	592	}
		593
5078	serge	594	if (property == rdev->mode_info.audio_property) {
		595	struct radeon_connector *radeon_connector = to_radeon_connector(connector);
		596	/* need to find digital encoder on connector */
		597	encoder = radeon_find_encoder(connector, DRM_MODE_ENCODER_TMDS);
		598	if (!encoder)
		599	return 0;
		600
		601	radeon_encoder = to_radeon_encoder(encoder);
		602
		603	if (radeon_connector->audio != val) {
		604	radeon_connector->audio = val;
		605	radeon_property_change_mode(&radeon_encoder->base);
		606	}
		607	}
		608
		609	if (property == rdev->mode_info.dither_property) {
		610	struct radeon_connector *radeon_connector = to_radeon_connector(connector);
		611	/* need to find digital encoder on connector */
		612	encoder = radeon_find_encoder(connector, DRM_MODE_ENCODER_TMDS);
		613	if (!encoder)
		614	return 0;
		615
		616	radeon_encoder = to_radeon_encoder(encoder);
		617
		618	if (radeon_connector->dither != val) {
		619	radeon_connector->dither = val;
		620	radeon_property_change_mode(&radeon_encoder->base);
		621	}
		622	}
		623
1963	serge	624	if (property == rdev->mode_info.underscan_property) {
		625	/* need to find digital encoder on connector */
		626	encoder = radeon_find_encoder(connector, DRM_MODE_ENCODER_TMDS);
		627	if (!encoder)
		628	return 0;
		629
		630	radeon_encoder = to_radeon_encoder(encoder);
		631
		632	if (radeon_encoder->underscan_type != val) {
		633	radeon_encoder->underscan_type = val;
		634	radeon_property_change_mode(&radeon_encoder->base);
		635	}
		636	}
		637
		638	if (property == rdev->mode_info.underscan_hborder_property) {
		639	/* need to find digital encoder on connector */
		640	encoder = radeon_find_encoder(connector, DRM_MODE_ENCODER_TMDS);
		641	if (!encoder)
		642	return 0;
		643
		644	radeon_encoder = to_radeon_encoder(encoder);
		645
		646	if (radeon_encoder->underscan_hborder != val) {
		647	radeon_encoder->underscan_hborder = val;
		648	radeon_property_change_mode(&radeon_encoder->base);
		649	}
		650	}
		651
		652	if (property == rdev->mode_info.underscan_vborder_property) {
		653	/* need to find digital encoder on connector */
		654	encoder = radeon_find_encoder(connector, DRM_MODE_ENCODER_TMDS);
		655	if (!encoder)
		656	return 0;
		657
		658	radeon_encoder = to_radeon_encoder(encoder);
		659
		660	if (radeon_encoder->underscan_vborder != val) {
		661	radeon_encoder->underscan_vborder = val;
		662	radeon_property_change_mode(&radeon_encoder->base);
		663	}
		664	}
		665
1179	serge	666	if (property == rdev->mode_info.tv_std_property) {
		667	encoder = radeon_find_encoder(connector, DRM_MODE_ENCODER_TVDAC);
		668	if (!encoder) {
		669	encoder = radeon_find_encoder(connector, DRM_MODE_ENCODER_DAC);
		670	}
		671
		672	if (!encoder)
		673	return 0;
		674
		675	radeon_encoder = to_radeon_encoder(encoder);
		676	if (!radeon_encoder->enc_priv)
		677	return 0;
1963	serge	678	if (ASIC_IS_AVIVO(rdev) \|\| radeon_r4xx_atom) {
1179	serge	679	struct radeon_encoder_atom_dac *dac_int;
		680	dac_int = radeon_encoder->enc_priv;
		681	dac_int->tv_std = val;
		682	} else {
		683	struct radeon_encoder_tv_dac *dac_int;
		684	dac_int = radeon_encoder->enc_priv;
		685	dac_int->tv_std = val;
		686	}
		687	radeon_property_change_mode(&radeon_encoder->base);
		688	}
		689
		690	if (property == rdev->mode_info.load_detect_property) {
		691	struct radeon_connector *radeon_connector =
		692	to_radeon_connector(connector);
		693
		694	if (val == 0)
		695	radeon_connector->dac_load_detect = false;
		696	else
		697	radeon_connector->dac_load_detect = true;
		698	}
		699
		700	if (property == rdev->mode_info.tmds_pll_property) {
		701	struct radeon_encoder_int_tmds *tmds = NULL;
		702	bool ret = false;
		703	/* need to find digital encoder on connector */
		704	encoder = radeon_find_encoder(connector, DRM_MODE_ENCODER_TMDS);
		705	if (!encoder)
		706	return 0;
		707
		708	radeon_encoder = to_radeon_encoder(encoder);
		709
		710	tmds = radeon_encoder->enc_priv;
		711	if (!tmds)
		712	return 0;
		713
		714	if (val == 0) {
		715	if (rdev->is_atom_bios)
		716	ret = radeon_atombios_get_tmds_info(radeon_encoder, tmds);
		717	else
		718	ret = radeon_legacy_get_tmds_info_from_combios(radeon_encoder, tmds);
		719	}
		720	if (val == 1 \|\| ret == false) {
		721	radeon_legacy_get_tmds_info_from_table(radeon_encoder, tmds);
		722	}
		723	radeon_property_change_mode(&radeon_encoder->base);
		724	}
		725
5078	serge	726	if (property == dev->mode_config.scaling_mode_property) {
		727	enum radeon_rmx_type rmx_type;
		728
		729	if (connector->encoder)
		730	radeon_encoder = to_radeon_encoder(connector->encoder);
		731	else {
6104	serge	732	const struct drm_connector_helper_funcs *connector_funcs = connector->helper_private;
5078	serge	733	radeon_encoder = to_radeon_encoder(connector_funcs->best_encoder(connector));
		734	}
		735
		736	switch (val) {
		737	default:
		738	case DRM_MODE_SCALE_NONE: rmx_type = RMX_OFF; break;
		739	case DRM_MODE_SCALE_CENTER: rmx_type = RMX_CENTER; break;
		740	case DRM_MODE_SCALE_ASPECT: rmx_type = RMX_ASPECT; break;
		741	case DRM_MODE_SCALE_FULLSCREEN: rmx_type = RMX_FULL; break;
		742	}
		743	if (radeon_encoder->rmx_type == rmx_type)
		744	return 0;
		745
		746	if ((rmx_type != DRM_MODE_SCALE_NONE) &&
		747	(radeon_encoder->native_mode.clock == 0))
		748	return 0;
		749
		750	radeon_encoder->rmx_type = rmx_type;
		751
		752	radeon_property_change_mode(&radeon_encoder->base);
		753	}
		754
6104	serge	755	if (property == rdev->mode_info.output_csc_property) {
		756	if (connector->encoder)
		757	radeon_encoder = to_radeon_encoder(connector->encoder);
		758	else {
		759	const struct drm_connector_helper_funcs *connector_funcs = connector->helper_private;
		760	radeon_encoder = to_radeon_encoder(connector_funcs->best_encoder(connector));
		761	}
		762
		763	if (radeon_encoder->output_csc == val)
		764	return 0;
		765
		766	radeon_encoder->output_csc = val;
		767
		768	if (connector->encoder->crtc) {
		769	struct drm_crtc *crtc = connector->encoder->crtc;
		770	const struct drm_crtc_helper_funcs *crtc_funcs = crtc->helper_private;
		771	struct radeon_crtc *radeon_crtc = to_radeon_crtc(crtc);
		772
		773	radeon_crtc->output_csc = radeon_encoder->output_csc;
		774
		775	(*crtc_funcs->load_lut)(crtc);
		776	}
		777	}
		778
1123	serge	779	return 0;
		780	}
		781
1179	serge	782	static void radeon_fixup_lvds_native_mode(struct drm_encoder *encoder,
		783	struct drm_connector *connector)
		784	{
		785	struct radeon_encoder *radeon_encoder = to_radeon_encoder(encoder);
1268	serge	786	struct drm_display_mode *native_mode = &radeon_encoder->native_mode;
2997	Serge	787	struct drm_display_mode t, mode;
1123	serge	788
2997	Serge	789	/* If the EDID preferred mode doesn't match the native mode, use it */
		790	list_for_each_entry_safe(mode, t, &connector->probed_modes, head) {
		791	if (mode->type & DRM_MODE_TYPE_PREFERRED) {
		792	if (mode->hdisplay != native_mode->hdisplay \|\|
		793	mode->vdisplay != native_mode->vdisplay)
		794	memcpy(native_mode, mode, sizeof(*mode));
		795	}
		796	}
		797
1179	serge	798	/* Try to get native mode details from EDID if necessary */
1268	serge	799	if (!native_mode->clock) {
1179	serge	800	list_for_each_entry_safe(mode, t, &connector->probed_modes, head) {
1268	serge	801	if (mode->hdisplay == native_mode->hdisplay &&
		802	mode->vdisplay == native_mode->vdisplay) {
		803	native_mode = mode;
		804	drm_mode_set_crtcinfo(native_mode, CRTC_INTERLACE_HALVE_V);
1963	serge	805	DRM_DEBUG_KMS("Determined LVDS native mode details from EDID\n");
1179	serge	806	break;
		807	}
		808	}
		809	}
2997	Serge	810
1268	serge	811	if (!native_mode->clock) {
1963	serge	812	DRM_DEBUG_KMS("No LVDS native mode details, disabling RMX\n");
1179	serge	813	radeon_encoder->rmx_type = RMX_OFF;
		814	}
		815	}
		816
1123	serge	817	static int radeon_lvds_get_modes(struct drm_connector *connector)
		818	{
		819	struct drm_encoder *encoder;
		820	int ret = 0;
		821	struct drm_display_mode *mode;
		822
5078	serge	823	radeon_connector_get_edid(connector);
		824	ret = radeon_ddc_get_modes(connector);
6104	serge	825	if (ret > 0) {
		826	encoder = radeon_best_single_encoder(connector);
		827	if (encoder) {
		828	radeon_fixup_lvds_native_mode(encoder, connector);
		829	/* add scaled modes */
		830	radeon_add_common_modes(encoder, connector);
1123	serge	831	}
6104	serge	832	return ret;
		833	}
1123	serge	834
		835	encoder = radeon_best_single_encoder(connector);
		836	if (!encoder)
		837	return 0;
		838
		839	/* we have no EDID modes */
		840	mode = radeon_fp_native_mode(encoder);
		841	if (mode) {
		842	ret = 1;
		843	drm_mode_probed_add(connector, mode);
1963	serge	844	/* add the width/height from vbios tables if available */
		845	connector->display_info.width_mm = mode->width_mm;
		846	connector->display_info.height_mm = mode->height_mm;
1179	serge	847	/* add scaled modes */
		848	radeon_add_common_modes(encoder, connector);
1123	serge	849	}
1179	serge	850
1123	serge	851	return ret;
		852	}
		853
		854	static int radeon_lvds_mode_valid(struct drm_connector *connector,
		855	struct drm_display_mode *mode)
		856	{
1268	serge	857	struct drm_encoder *encoder = radeon_best_single_encoder(connector);
		858
		859	if ((mode->hdisplay < 320) \|\| (mode->vdisplay < 240))
		860	return MODE_PANEL;
		861
		862	if (encoder) {
		863	struct radeon_encoder *radeon_encoder = to_radeon_encoder(encoder);
		864	struct drm_display_mode *native_mode = &radeon_encoder->native_mode;
		865
		866	/* AVIVO hardware supports downscaling modes larger than the panel
		867	* to the panel size, but I'm not sure this is desirable.
		868	*/
		869	if ((mode->hdisplay > native_mode->hdisplay) \|\|
		870	(mode->vdisplay > native_mode->vdisplay))
		871	return MODE_PANEL;
		872
		873	/* if scaling is disabled, block non-native modes */
		874	if (radeon_encoder->rmx_type == RMX_OFF) {
		875	if ((mode->hdisplay != native_mode->hdisplay) \|\|
		876	(mode->vdisplay != native_mode->vdisplay))
		877	return MODE_PANEL;
		878	}
		879	}
		880
1123	serge	881	return MODE_OK;
		882	}
		883
1963	serge	884	static enum drm_connector_status
		885	radeon_lvds_detect(struct drm_connector *connector, bool force)
1123	serge	886	{
5271	serge	887	struct drm_device *dev = connector->dev;
		888	struct radeon_device *rdev = dev->dev_private;
1268	serge	889	struct radeon_connector *radeon_connector = to_radeon_connector(connector);
		890	struct drm_encoder *encoder = radeon_best_single_encoder(connector);
		891	enum drm_connector_status ret = connector_status_disconnected;
		892
		893	if (encoder) {
		894	struct radeon_encoder *radeon_encoder = to_radeon_encoder(encoder);
		895	struct drm_display_mode *native_mode = &radeon_encoder->native_mode;
		896
		897	/* check if panel is valid */
		898	if (native_mode->hdisplay >= 320 && native_mode->vdisplay >= 240)
		899	ret = connector_status_connected;
6104	serge	900	/* don't fetch the edid from the vbios if ddc fails and runpm is
		901	* enabled so we report disconnected.
		902	*/
		903	if ((rdev->flags & RADEON_IS_PX) && (radeon_runtime_pm != 0))
		904	ret = connector_status_disconnected;
1268	serge	905	}
		906
		907	/* check for edid as well */
5078	serge	908	radeon_connector_get_edid(connector);
1268	serge	909	if (radeon_connector->edid)
		910	ret = connector_status_connected;
1123	serge	911	/* check acpi lid status ??? */
1268	serge	912
1123	serge	913	radeon_connector_update_scratch_regs(connector, ret);
		914	return ret;
		915	}
		916
		917	static void radeon_connector_destroy(struct drm_connector *connector)
		918	{
		919	struct radeon_connector *radeon_connector = to_radeon_connector(connector);
		920
5078	serge	921	radeon_connector_free_edid(connector);
1123	serge	922	kfree(radeon_connector->con_priv);
5078	serge	923	drm_connector_unregister(connector);
1123	serge	924	drm_connector_cleanup(connector);
		925	kfree(connector);
		926	}
		927
1179	serge	928	static int radeon_lvds_set_property(struct drm_connector *connector,
		929	struct drm_property *property,
		930	uint64_t value)
		931	{
		932	struct drm_device *dev = connector->dev;
		933	struct radeon_encoder *radeon_encoder;
		934	enum radeon_rmx_type rmx_type;
		935
1963	serge	936	DRM_DEBUG_KMS("\n");
1179	serge	937	if (property != dev->mode_config.scaling_mode_property)
		938	return 0;
		939
		940	if (connector->encoder)
		941	radeon_encoder = to_radeon_encoder(connector->encoder);
		942	else {
6104	serge	943	const struct drm_connector_helper_funcs *connector_funcs = connector->helper_private;
1179	serge	944	radeon_encoder = to_radeon_encoder(connector_funcs->best_encoder(connector));
		945	}
		946
		947	switch (value) {
		948	case DRM_MODE_SCALE_NONE: rmx_type = RMX_OFF; break;
		949	case DRM_MODE_SCALE_CENTER: rmx_type = RMX_CENTER; break;
		950	case DRM_MODE_SCALE_ASPECT: rmx_type = RMX_ASPECT; break;
		951	default:
		952	case DRM_MODE_SCALE_FULLSCREEN: rmx_type = RMX_FULL; break;
		953	}
		954	if (radeon_encoder->rmx_type == rmx_type)
		955	return 0;
		956
		957	radeon_encoder->rmx_type = rmx_type;
		958
		959	radeon_property_change_mode(&radeon_encoder->base);
		960	return 0;
		961	}
		962
		963
2997	Serge	964	static const struct drm_connector_helper_funcs radeon_lvds_connector_helper_funcs = {
1123	serge	965	.get_modes = radeon_lvds_get_modes,
		966	.mode_valid = radeon_lvds_mode_valid,
		967	.best_encoder = radeon_best_single_encoder,
		968	};
		969
2997	Serge	970	static const struct drm_connector_funcs radeon_lvds_connector_funcs = {
1123	serge	971	.dpms = drm_helper_connector_dpms,
		972	.detect = radeon_lvds_detect,
		973	.fill_modes = drm_helper_probe_single_connector_modes,
		974	.destroy = radeon_connector_destroy,
1179	serge	975	.set_property = radeon_lvds_set_property,
1123	serge	976	};
		977
		978	static int radeon_vga_get_modes(struct drm_connector *connector)
		979	{
		980	int ret;
		981
5078	serge	982	radeon_connector_get_edid(connector);
		983	ret = radeon_ddc_get_modes(connector);
1123	serge	984
5078	serge	985	radeon_get_native_mode(connector);
		986
1123	serge	987	return ret;
		988	}
		989
		990	static int radeon_vga_mode_valid(struct drm_connector *connector,
		991	struct drm_display_mode *mode)
		992	{
1963	serge	993	struct drm_device *dev = connector->dev;
		994	struct radeon_device *rdev = dev->dev_private;
		995
1268	serge	996	/* XXX check mode bandwidth */
1963	serge	997
		998	if ((mode->clock / 10) > rdev->clock.max_pixel_clock)
		999	return MODE_CLOCK_HIGH;
		1000
1123	serge	1001	return MODE_OK;
		1002	}
		1003
1963	serge	1004	static enum drm_connector_status
		1005	radeon_vga_detect(struct drm_connector *connector, bool force)
1123	serge	1006	{
1963	serge	1007	struct drm_device *dev = connector->dev;
		1008	struct radeon_device *rdev = dev->dev_private;
1123	serge	1009	struct radeon_connector *radeon_connector = to_radeon_connector(connector);
		1010	struct drm_encoder *encoder;
6104	serge	1011	const struct drm_encoder_helper_funcs *encoder_funcs;
1404	serge	1012	bool dret = false;
1123	serge	1013	enum drm_connector_status ret = connector_status_disconnected;
		1014
1179	serge	1015	encoder = radeon_best_single_encoder(connector);
		1016	if (!encoder)
		1017	ret = connector_status_disconnected;
		1018
1430	serge	1019	if (radeon_connector->ddc_bus)
3192	Serge	1020	dret = radeon_ddc_probe(radeon_connector, false);
1268	serge	1021	if (dret) {
2997	Serge	1022	radeon_connector->detected_by_load = false;
5078	serge	1023	radeon_connector_free_edid(connector);
		1024	radeon_connector_get_edid(connector);
1268	serge	1025
		1026	if (!radeon_connector->edid) {
1313	serge	1027	DRM_ERROR("%s: probed a monitor but no\|invalid EDID\n",
5078	serge	1028	connector->name);
1313	serge	1029	ret = connector_status_connected;
1268	serge	1030	} else {
5078	serge	1031	radeon_connector->use_digital =
		1032	!!(radeon_connector->edid->input & DRM_EDID_INPUT_DIGITAL);
1268	serge	1033
		1034	/* some oems have boards with separate digital and analog connectors
		1035	* with a shared ddc line (often vga + hdmi)
		1036	*/
		1037	if (radeon_connector->use_digital && radeon_connector->shared_ddc) {
5078	serge	1038	radeon_connector_free_edid(connector);
1268	serge	1039	ret = connector_status_disconnected;
5078	serge	1040	} else {
6104	serge	1041	ret = connector_status_connected;
		1042	}
1268	serge	1043	}
		1044	} else {
1963	serge	1045
		1046	/* if we aren't forcing don't do destructive polling */
2997	Serge	1047	if (!force) {
		1048	/* only return the previous status if we last
		1049	* detected a monitor via load.
		1050	*/
		1051	if (radeon_connector->detected_by_load)
5078	serge	1052	ret = connector->status;
		1053	goto out;
2997	Serge	1054	}
1963	serge	1055
1403	serge	1056	if (radeon_connector->dac_load_detect && encoder) {
1123	serge	1057	encoder_funcs = encoder->helper_private;
		1058	ret = encoder_funcs->detect(encoder, connector);
2997	Serge	1059	if (ret != connector_status_disconnected)
		1060	radeon_connector->detected_by_load = true;
1123	serge	1061	}
		1062	}
		1063
1179	serge	1064	if (ret == connector_status_connected)
		1065	ret = radeon_connector_analog_encoder_conflict_solve(connector, encoder, ret, true);
1963	serge	1066
		1067	/* RN50 and some RV100 asics in servers often have a hardcoded EDID in the
		1068	* vbios to deal with KVMs. If we have one and are not able to detect a monitor
		1069	* by other means, assume the CRT is connected and use that EDID.
		1070	*/
		1071	if ((!rdev->is_atom_bios) &&
		1072	(ret == connector_status_disconnected) &&
		1073	rdev->mode_info.bios_hardcoded_edid_size) {
		1074	ret = connector_status_connected;
		1075	}
		1076
1123	serge	1077	radeon_connector_update_scratch_regs(connector, ret);
5078	serge	1078
		1079	out:
1123	serge	1080	return ret;
		1081	}
		1082
2997	Serge	1083	static const struct drm_connector_helper_funcs radeon_vga_connector_helper_funcs = {
1123	serge	1084	.get_modes = radeon_vga_get_modes,
		1085	.mode_valid = radeon_vga_mode_valid,
		1086	.best_encoder = radeon_best_single_encoder,
		1087	};
		1088
2997	Serge	1089	static const struct drm_connector_funcs radeon_vga_connector_funcs = {
1123	serge	1090	.dpms = drm_helper_connector_dpms,
		1091	.detect = radeon_vga_detect,
		1092	.fill_modes = drm_helper_probe_single_connector_modes,
		1093	.destroy = radeon_connector_destroy,
		1094	.set_property = radeon_connector_set_property,
		1095	};
		1096
1179	serge	1097	static int radeon_tv_get_modes(struct drm_connector *connector)
		1098	{
		1099	struct drm_device *dev = connector->dev;
		1100	struct radeon_device *rdev = dev->dev_private;
		1101	struct drm_display_mode *tv_mode;
		1102	struct drm_encoder *encoder;
		1103
		1104	encoder = radeon_best_single_encoder(connector);
		1105	if (!encoder)
		1106	return 0;
		1107
		1108	/* avivo chips can scale any mode */
		1109	if (rdev->family >= CHIP_RS600)
		1110	/* add scaled modes */
		1111	radeon_add_common_modes(encoder, connector);
		1112	else {
		1113	/* only 800x600 is supported right now on pre-avivo chips */
1221	serge	1114	tv_mode = drm_cvt_mode(dev, 800, 600, 60, false, false, false);
1179	serge	1115	tv_mode->type = DRM_MODE_TYPE_DRIVER \| DRM_MODE_TYPE_PREFERRED;
		1116	drm_mode_probed_add(connector, tv_mode);
		1117	}
		1118	return 1;
		1119	}
		1120
		1121	static int radeon_tv_mode_valid(struct drm_connector *connector,
		1122	struct drm_display_mode *mode)
		1123	{
1268	serge	1124	if ((mode->hdisplay > 1024) \|\| (mode->vdisplay > 768))
		1125	return MODE_CLOCK_RANGE;
1179	serge	1126	return MODE_OK;
		1127	}
		1128
1963	serge	1129	static enum drm_connector_status
		1130	radeon_tv_detect(struct drm_connector *connector, bool force)
1179	serge	1131	{
		1132	struct drm_encoder *encoder;
6104	serge	1133	const struct drm_encoder_helper_funcs *encoder_funcs;
1179	serge	1134	struct radeon_connector *radeon_connector = to_radeon_connector(connector);
		1135	enum drm_connector_status ret = connector_status_disconnected;
5078	serge	1136	int r;
1179	serge	1137
		1138	if (!radeon_connector->dac_load_detect)
		1139	return ret;
		1140
		1141	encoder = radeon_best_single_encoder(connector);
		1142	if (!encoder)
		1143	ret = connector_status_disconnected;
		1144	else {
		1145	encoder_funcs = encoder->helper_private;
		1146	ret = encoder_funcs->detect(encoder, connector);
		1147	}
		1148	if (ret == connector_status_connected)
		1149	ret = radeon_connector_analog_encoder_conflict_solve(connector, encoder, ret, false);
		1150	radeon_connector_update_scratch_regs(connector, ret);
		1151	return ret;
		1152	}
		1153
2997	Serge	1154	static const struct drm_connector_helper_funcs radeon_tv_connector_helper_funcs = {
1179	serge	1155	.get_modes = radeon_tv_get_modes,
		1156	.mode_valid = radeon_tv_mode_valid,
		1157	.best_encoder = radeon_best_single_encoder,
		1158	};
		1159
2997	Serge	1160	static const struct drm_connector_funcs radeon_tv_connector_funcs = {
1179	serge	1161	.dpms = drm_helper_connector_dpms,
		1162	.detect = radeon_tv_detect,
		1163	.fill_modes = drm_helper_probe_single_connector_modes,
		1164	.destroy = radeon_connector_destroy,
		1165	.set_property = radeon_connector_set_property,
		1166	};
		1167
2997	Serge	1168	static bool radeon_check_hpd_status_unchanged(struct drm_connector *connector)
		1169	{
		1170	struct drm_device *dev = connector->dev;
		1171	struct radeon_device *rdev = dev->dev_private;
		1172	struct radeon_connector *radeon_connector = to_radeon_connector(connector);
		1173	enum drm_connector_status status;
		1174
		1175	/* We only trust HPD on R600 and newer ASICS. */
		1176	if (rdev->family >= CHIP_R600
		1177	&& radeon_connector->hpd.hpd != RADEON_HPD_NONE) {
		1178	if (radeon_hpd_sense(rdev, radeon_connector->hpd.hpd))
		1179	status = connector_status_connected;
		1180	else
		1181	status = connector_status_disconnected;
		1182	if (connector->status == status)
		1183	return true;
		1184	}
		1185
		1186	return false;
		1187	}
		1188
1179	serge	1189	/*
		1190	* DVI is complicated
		1191	* Do a DDC probe, if DDC probe passes, get the full EDID so
		1192	* we can do analog/digital monitor detection at this point.
		1193	* If the monitor is an analog monitor or we got no DDC,
		1194	* we need to find the DAC encoder object for this connector.
		1195	* If we got no DDC, we do load detection on the DAC encoder object.
		1196	* If we got analog DDC or load detection passes on the DAC encoder
		1197	* we have to check if this analog encoder is shared with anyone else (TV)
		1198	* if its shared we have to set the other connector to disconnected.
		1199	*/
1963	serge	1200	static enum drm_connector_status
		1201	radeon_dvi_detect(struct drm_connector *connector, bool force)
1123	serge	1202	{
1963	serge	1203	struct drm_device *dev = connector->dev;
		1204	struct radeon_device *rdev = dev->dev_private;
1123	serge	1205	struct radeon_connector *radeon_connector = to_radeon_connector(connector);
1179	serge	1206	struct drm_encoder *encoder = NULL;
6104	serge	1207	const struct drm_encoder_helper_funcs *encoder_funcs;
5078	serge	1208	int i, r;
1123	serge	1209	enum drm_connector_status ret = connector_status_disconnected;
3120	serge	1210	bool dret = false, broken_edid = false;
1123	serge	1211
2997	Serge	1212
5078	serge	1213	if (!force && radeon_check_hpd_status_unchanged(connector)) {
		1214	ret = connector->status;
		1215	goto exit;
		1216	}
		1217
6104	serge	1218	if (radeon_connector->ddc_bus) {
3192	Serge	1219	dret = radeon_ddc_probe(radeon_connector, false);
6104	serge	1220	}
1179	serge	1221	if (dret) {
2997	Serge	1222	radeon_connector->detected_by_load = false;
5078	serge	1223	radeon_connector_free_edid(connector);
		1224	radeon_connector_get_edid(connector);
1179	serge	1225
		1226	if (!radeon_connector->edid) {
1313	serge	1227	DRM_ERROR("%s: probed a monitor but no\|invalid EDID\n",
5078	serge	1228	connector->name);
1986	serge	1229	/* rs690 seems to have a problem with connectors not existing and always
		1230	* return a block of 0's. If we see this just stop polling on this output */
5078	serge	1231	if ((rdev->family == CHIP_RS690 \|\| rdev->family == CHIP_RS740) &&
		1232	radeon_connector->base.null_edid_counter) {
1986	serge	1233	ret = connector_status_disconnected;
5078	serge	1234	DRM_ERROR("%s: detected RS690 floating bus bug, stopping ddc detect\n",
		1235	connector->name);
1986	serge	1236	radeon_connector->ddc_bus = NULL;
3120	serge	1237	} else {
		1238	ret = connector_status_connected;
		1239	broken_edid = true; /* defer use_digital to later */
1986	serge	1240	}
1179	serge	1241	} else {
5078	serge	1242	radeon_connector->use_digital =
		1243	!!(radeon_connector->edid->input & DRM_EDID_INPUT_DIGITAL);
1179	serge	1244
1268	serge	1245	/* some oems have boards with separate digital and analog connectors
		1246	* with a shared ddc line (often vga + hdmi)
		1247	*/
		1248	if ((!radeon_connector->use_digital) && radeon_connector->shared_ddc) {
5078	serge	1249	radeon_connector_free_edid(connector);
1268	serge	1250	ret = connector_status_disconnected;
5078	serge	1251	} else {
6104	serge	1252	ret = connector_status_connected;
5078	serge	1253	}
1963	serge	1254	/* This gets complicated. We have boards with VGA + HDMI with a
		1255	* shared DDC line and we have boards with DVI-D + HDMI with a shared
		1256	* DDC line. The latter is more complex because with DVI<->HDMI adapters
		1257	* you don't really know what's connected to which port as both are digital.
1321	serge	1258	*/
1428	serge	1259	if (radeon_connector->shared_ddc && (ret == connector_status_connected)) {
1321	serge	1260	struct drm_connector *list_connector;
		1261	struct radeon_connector *list_radeon_connector;
		1262	list_for_each_entry(list_connector, &dev->mode_config.connector_list, head) {
		1263	if (connector == list_connector)
		1264	continue;
		1265	list_radeon_connector = to_radeon_connector(list_connector);
1963	serge	1266	if (list_radeon_connector->shared_ddc &&
		1267	(list_radeon_connector->ddc_bus->rec.i2c_id ==
		1268	radeon_connector->ddc_bus->rec.i2c_id)) {
		1269	/* cases where both connectors are digital */
		1270	if (list_connector->connector_type != DRM_MODE_CONNECTOR_VGA) {
		1271	/* hpd is our only option in this case */
		1272	if (!radeon_hpd_sense(rdev, radeon_connector->hpd.hpd)) {
5078	serge	1273	radeon_connector_free_edid(connector);
1321	serge	1274	ret = connector_status_disconnected;
		1275	}
		1276	}
		1277	}
		1278	}
		1279	}
1179	serge	1280	}
		1281	}
		1282
		1283	if ((ret == connector_status_connected) && (radeon_connector->use_digital == true))
		1284	goto out;
		1285
2997	Serge	1286	/* DVI-D and HDMI-A are digital only */
		1287	if ((connector->connector_type == DRM_MODE_CONNECTOR_DVID) \|\|
		1288	(connector->connector_type == DRM_MODE_CONNECTOR_HDMIA))
		1289	goto out;
		1290
		1291	/* if we aren't forcing don't do destructive polling */
1963	serge	1292	if (!force) {
2997	Serge	1293	/* only return the previous status if we last
		1294	* detected a monitor via load.
		1295	*/
		1296	if (radeon_connector->detected_by_load)
6104	serge	1297	ret = connector->status;
1963	serge	1298	goto out;
		1299	}
		1300
1179	serge	1301	/* find analog encoder */
		1302	if (radeon_connector->dac_load_detect) {
1123	serge	1303	for (i = 0; i < DRM_CONNECTOR_MAX_ENCODER; i++) {
		1304	if (connector->encoder_ids[i] == 0)
		1305	break;
		1306
5078	serge	1307	encoder = drm_encoder_find(connector->dev,
		1308	connector->encoder_ids[i]);
		1309	if (!encoder)
1123	serge	1310	continue;
		1311
2997	Serge	1312	if (encoder->encoder_type != DRM_MODE_ENCODER_DAC &&
		1313	encoder->encoder_type != DRM_MODE_ENCODER_TVDAC)
		1314	continue;
		1315
1123	serge	1316	encoder_funcs = encoder->helper_private;
		1317	if (encoder_funcs->detect) {
3120	serge	1318	if (!broken_edid) {
6104	serge	1319	if (ret != connector_status_connected) {
3120	serge	1320	/* deal with analog monitors without DDC */
6104	serge	1321	ret = encoder_funcs->detect(encoder, connector);
		1322	if (ret == connector_status_connected) {
		1323	radeon_connector->use_digital = false;
		1324	}
		1325	if (ret != connector_status_disconnected)
		1326	radeon_connector->detected_by_load = true;
1179	serge	1327	}
3120	serge	1328	} else {
		1329	enum drm_connector_status lret;
		1330	/* assume digital unless load detected otherwise */
		1331	radeon_connector->use_digital = true;
		1332	lret = encoder_funcs->detect(encoder, connector);
		1333	DRM_DEBUG_KMS("load_detect %x returned: %x\n",encoder->encoder_type,lret);
		1334	if (lret == connector_status_connected)
		1335	radeon_connector->use_digital = false;
		1336	}
6104	serge	1337	break;
1123	serge	1338	}
		1339	}
6104	serge	1340	}
1179	serge	1341
		1342	if ((ret == connector_status_connected) && (radeon_connector->use_digital == false) &&
		1343	encoder) {
		1344	ret = radeon_connector_analog_encoder_conflict_solve(connector, encoder, ret, true);
1123	serge	1345	}
		1346
1963	serge	1347	/* RN50 and some RV100 asics in servers often have a hardcoded EDID in the
		1348	* vbios to deal with KVMs. If we have one and are not able to detect a monitor
		1349	* by other means, assume the DFP is connected and use that EDID. In most
		1350	* cases the DVI port is actually a virtual KVM port connected to the service
		1351	* processor.
		1352	*/
2997	Serge	1353	out:
1963	serge	1354	if ((!rdev->is_atom_bios) &&
		1355	(ret == connector_status_disconnected) &&
		1356	rdev->mode_info.bios_hardcoded_edid_size) {
		1357	radeon_connector->use_digital = true;
		1358	ret = connector_status_connected;
		1359	}
		1360
1123	serge	1361	/* updated in get modes as well since we need to know if it's analog or digital */
		1362	radeon_connector_update_scratch_regs(connector, ret);
5078	serge	1363
6104	serge	1364	if ((radeon_audio != 0) && radeon_connector->use_digital) {
		1365	const struct drm_connector_helper_funcs *connector_funcs =
		1366	connector->helper_private;
		1367
		1368	encoder = connector_funcs->best_encoder(connector);
		1369	if (encoder && (encoder->encoder_type == DRM_MODE_ENCODER_TMDS)) {
		1370	radeon_connector_get_edid(connector);
		1371	radeon_audio_detect(connector, encoder, ret);
		1372	}
		1373	}
		1374
5078	serge	1375	exit:
1123	serge	1376	return ret;
		1377	}
		1378
		1379	/* okay need to be smart in here about which encoder to pick */
2997	Serge	1380	static struct drm_encoder radeon_dvi_encoder(struct drm_connector connector)
1123	serge	1381	{
		1382	int enc_id = connector->encoder_ids[0];
		1383	struct radeon_connector *radeon_connector = to_radeon_connector(connector);
		1384	struct drm_encoder *encoder;
		1385	int i;
		1386	for (i = 0; i < DRM_CONNECTOR_MAX_ENCODER; i++) {
		1387	if (connector->encoder_ids[i] == 0)
		1388	break;
		1389
5078	serge	1390	encoder = drm_encoder_find(connector->dev, connector->encoder_ids[i]);
		1391	if (!encoder)
1123	serge	1392	continue;
		1393
1179	serge	1394	if (radeon_connector->use_digital == true) {
1123	serge	1395	if (encoder->encoder_type == DRM_MODE_ENCODER_TMDS)
		1396	return encoder;
		1397	} else {
		1398	if (encoder->encoder_type == DRM_MODE_ENCODER_DAC \|\|
		1399	encoder->encoder_type == DRM_MODE_ENCODER_TVDAC)
		1400	return encoder;
		1401	}
		1402	}
		1403
		1404	/* see if we have a default encoder TODO */
		1405
		1406	/* then check use digitial */
		1407	/* pick the first one */
5078	serge	1408	if (enc_id)
		1409	return drm_encoder_find(connector->dev, enc_id);
1123	serge	1410	return NULL;
		1411	}
		1412
1221	serge	1413	static void radeon_dvi_force(struct drm_connector *connector)
		1414	{
		1415	struct radeon_connector *radeon_connector = to_radeon_connector(connector);
		1416	if (connector->force == DRM_FORCE_ON)
		1417	radeon_connector->use_digital = false;
		1418	if (connector->force == DRM_FORCE_ON_DIGITAL)
		1419	radeon_connector->use_digital = true;
		1420	}
		1421
1268	serge	1422	static int radeon_dvi_mode_valid(struct drm_connector *connector,
		1423	struct drm_display_mode *mode)
		1424	{
1403	serge	1425	struct drm_device *dev = connector->dev;
		1426	struct radeon_device *rdev = dev->dev_private;
1268	serge	1427	struct radeon_connector *radeon_connector = to_radeon_connector(connector);
		1428
		1429	/* XXX check mode bandwidth */
		1430
1403	serge	1431	/* clocks over 135 MHz have heat issues with DVI on RV100 */
		1432	if (radeon_connector->use_digital &&
		1433	(rdev->family == CHIP_RV100) &&
		1434	(mode->clock > 135000))
		1435	return MODE_CLOCK_HIGH;
		1436
1268	serge	1437	if (radeon_connector->use_digital && (mode->clock > 165000)) {
		1438	if ((radeon_connector->connector_object_id == CONNECTOR_OBJECT_ID_DUAL_LINK_DVI_I) \|\|
		1439	(radeon_connector->connector_object_id == CONNECTOR_OBJECT_ID_DUAL_LINK_DVI_D) \|\|
		1440	(radeon_connector->connector_object_id == CONNECTOR_OBJECT_ID_HDMI_TYPE_B))
		1441	return MODE_OK;
5078	serge	1442	else if (ASIC_IS_DCE6(rdev) && drm_detect_hdmi_monitor(radeon_connector_edid(connector))) {
6104	serge	1443	/* HDMI 1.3+ supports max clock of 340 Mhz */
		1444	if (mode->clock > 340000)
		1445	return MODE_CLOCK_HIGH;
		1446	else
		1447	return MODE_OK;
5078	serge	1448	} else {
1268	serge	1449	return MODE_CLOCK_HIGH;
6104	serge	1450	}
1268	serge	1451	}
1963	serge	1452
		1453	/* check against the max pixel clock */
		1454	if ((mode->clock / 10) > rdev->clock.max_pixel_clock)
		1455	return MODE_CLOCK_HIGH;
		1456
1268	serge	1457	return MODE_OK;
		1458	}
		1459
2997	Serge	1460	static const struct drm_connector_helper_funcs radeon_dvi_connector_helper_funcs = {
5078	serge	1461	.get_modes = radeon_vga_get_modes,
1268	serge	1462	.mode_valid = radeon_dvi_mode_valid,
1123	serge	1463	.best_encoder = radeon_dvi_encoder,
		1464	};
		1465
2997	Serge	1466	static const struct drm_connector_funcs radeon_dvi_connector_funcs = {
1123	serge	1467	.dpms = drm_helper_connector_dpms,
		1468	.detect = radeon_dvi_detect,
		1469	.fill_modes = drm_helper_probe_single_connector_modes,
		1470	.set_property = radeon_connector_set_property,
		1471	.destroy = radeon_connector_destroy,
1221	serge	1472	.force = radeon_dvi_force,
1123	serge	1473	};
		1474
1321	serge	1475	static int radeon_dp_get_modes(struct drm_connector *connector)
		1476	{
		1477	struct radeon_connector *radeon_connector = to_radeon_connector(connector);
1963	serge	1478	struct radeon_connector_atom_dig *radeon_dig_connector = radeon_connector->con_priv;
1986	serge	1479	struct drm_encoder *encoder = radeon_best_single_encoder(connector);
1321	serge	1480	int ret;
		1481
1986	serge	1482	if ((connector->connector_type == DRM_MODE_CONNECTOR_eDP) \|\|
		1483	(connector->connector_type == DRM_MODE_CONNECTOR_LVDS)) {
1963	serge	1484	struct drm_display_mode *mode;
		1485
2997	Serge	1486	if (connector->connector_type == DRM_MODE_CONNECTOR_eDP) {
6104	serge	1487	if (!radeon_dig_connector->edp_on)
		1488	atombios_set_edp_panel_power(connector,
		1489	ATOM_TRANSMITTER_ACTION_POWER_ON);
5078	serge	1490	radeon_connector_get_edid(connector);
		1491	ret = radeon_ddc_get_modes(connector);
6104	serge	1492	if (!radeon_dig_connector->edp_on)
		1493	atombios_set_edp_panel_power(connector,
		1494	ATOM_TRANSMITTER_ACTION_POWER_OFF);
2997	Serge	1495	} else {
		1496	/* need to setup ddc on the bridge */
		1497	if (radeon_connector_encoder_get_dp_bridge_encoder_id(connector) !=
		1498	ENCODER_OBJECT_ID_NONE) {
		1499	if (encoder)
		1500	radeon_atom_ext_encoder_setup_ddc(encoder);
		1501	}
5078	serge	1502	radeon_connector_get_edid(connector);
		1503	ret = radeon_ddc_get_modes(connector);
2997	Serge	1504	}
1963	serge	1505
		1506	if (ret > 0) {
		1507	if (encoder) {
		1508	radeon_fixup_lvds_native_mode(encoder, connector);
		1509	/* add scaled modes */
		1510	radeon_add_common_modes(encoder, connector);
		1511	}
		1512	return ret;
		1513	}
		1514
		1515	if (!encoder)
		1516	return 0;
		1517
		1518	/* we have no EDID modes */
		1519	mode = radeon_fp_native_mode(encoder);
		1520	if (mode) {
		1521	ret = 1;
		1522	drm_mode_probed_add(connector, mode);
		1523	/* add the width/height from vbios tables if available */
		1524	connector->display_info.width_mm = mode->width_mm;
		1525	connector->display_info.height_mm = mode->height_mm;
		1526	/* add scaled modes */
		1527	radeon_add_common_modes(encoder, connector);
6104	serge	1528	}
1986	serge	1529	} else {
		1530	/* need to setup ddc on the bridge */
2997	Serge	1531	if (radeon_connector_encoder_get_dp_bridge_encoder_id(connector) !=
		1532	ENCODER_OBJECT_ID_NONE) {
1986	serge	1533	if (encoder)
		1534	radeon_atom_ext_encoder_setup_ddc(encoder);
		1535	}
5078	serge	1536	radeon_connector_get_edid(connector);
		1537	ret = radeon_ddc_get_modes(connector);
		1538
		1539	radeon_get_native_mode(connector);
1986	serge	1540	}
1963	serge	1541
1321	serge	1542	return ret;
		1543	}
		1544
2997	Serge	1545	u16 radeon_connector_encoder_get_dp_bridge_encoder_id(struct drm_connector *connector)
1321	serge	1546	{
1963	serge	1547	struct drm_encoder *encoder;
		1548	struct radeon_encoder *radeon_encoder;
		1549	int i;
		1550
		1551	for (i = 0; i < DRM_CONNECTOR_MAX_ENCODER; i++) {
		1552	if (connector->encoder_ids[i] == 0)
		1553	break;
		1554
5078	serge	1555	encoder = drm_encoder_find(connector->dev, connector->encoder_ids[i]);
		1556	if (!encoder)
1963	serge	1557	continue;
		1558
		1559	radeon_encoder = to_radeon_encoder(encoder);
		1560
		1561	switch (radeon_encoder->encoder_id) {
		1562	case ENCODER_OBJECT_ID_TRAVIS:
		1563	case ENCODER_OBJECT_ID_NUTMEG:
2997	Serge	1564	return radeon_encoder->encoder_id;
1963	serge	1565	default:
		1566	break;
		1567	}
		1568	}
		1569
2997	Serge	1570	return ENCODER_OBJECT_ID_NONE;
1963	serge	1571	}
		1572
5078	serge	1573	static bool radeon_connector_encoder_is_hbr2(struct drm_connector *connector)
1963	serge	1574	{
		1575	struct drm_encoder *encoder;
		1576	struct radeon_encoder *radeon_encoder;
		1577	int i;
		1578	bool found = false;
		1579
		1580	for (i = 0; i < DRM_CONNECTOR_MAX_ENCODER; i++) {
		1581	if (connector->encoder_ids[i] == 0)
		1582	break;
		1583
5078	serge	1584	encoder = drm_encoder_find(connector->dev, connector->encoder_ids[i]);
		1585	if (!encoder)
1963	serge	1586	continue;
		1587
		1588	radeon_encoder = to_radeon_encoder(encoder);
		1589	if (radeon_encoder->caps & ATOM_ENCODER_CAP_RECORD_HBR2)
		1590	found = true;
		1591	}
		1592
		1593	return found;
		1594	}
		1595
		1596	bool radeon_connector_is_dp12_capable(struct drm_connector *connector)
		1597	{
		1598	struct drm_device *dev = connector->dev;
		1599	struct radeon_device *rdev = dev->dev_private;
		1600
		1601	if (ASIC_IS_DCE5(rdev) &&
5078	serge	1602	(rdev->clock.default_dispclk >= 53900) &&
1963	serge	1603	radeon_connector_encoder_is_hbr2(connector)) {
		1604	return true;
		1605	}
		1606
		1607	return false;
		1608	}
		1609
		1610	static enum drm_connector_status
		1611	radeon_dp_detect(struct drm_connector *connector, bool force)
		1612	{
		1613	struct drm_device *dev = connector->dev;
		1614	struct radeon_device *rdev = dev->dev_private;
1321	serge	1615	struct radeon_connector *radeon_connector = to_radeon_connector(connector);
		1616	enum drm_connector_status ret = connector_status_disconnected;
		1617	struct radeon_connector_atom_dig *radeon_dig_connector = radeon_connector->con_priv;
1986	serge	1618	struct drm_encoder *encoder = radeon_best_single_encoder(connector);
5078	serge	1619	int r;
1321	serge	1620
6104	serge	1621	if (radeon_dig_connector->is_mst)
		1622	return connector_status_disconnected;
3192	Serge	1623
5078	serge	1624	if (!force && radeon_check_hpd_status_unchanged(connector)) {
		1625	ret = connector->status;
		1626	goto out;
		1627	}
3192	Serge	1628
5078	serge	1629	radeon_connector_free_edid(connector);
2997	Serge	1630
1986	serge	1631	if ((connector->connector_type == DRM_MODE_CONNECTOR_eDP) \|\|
		1632	(connector->connector_type == DRM_MODE_CONNECTOR_LVDS)) {
1963	serge	1633	if (encoder) {
		1634	struct radeon_encoder *radeon_encoder = to_radeon_encoder(encoder);
		1635	struct drm_display_mode *native_mode = &radeon_encoder->native_mode;
		1636
		1637	/* check if panel is valid */
		1638	if (native_mode->hdisplay >= 320 && native_mode->vdisplay >= 240)
		1639	ret = connector_status_connected;
6104	serge	1640	/* don't fetch the edid from the vbios if ddc fails and runpm is
		1641	* enabled so we report disconnected.
		1642	*/
		1643	if ((rdev->flags & RADEON_IS_PX) && (radeon_runtime_pm != 0))
		1644	ret = connector_status_disconnected;
1963	serge	1645	}
		1646	/* eDP is always DP */
		1647	radeon_dig_connector->dp_sink_type = CONNECTOR_OBJECT_ID_DISPLAYPORT;
		1648	if (!radeon_dig_connector->edp_on)
		1649	atombios_set_edp_panel_power(connector,
		1650	ATOM_TRANSMITTER_ACTION_POWER_ON);
		1651	if (radeon_dp_getdpcd(radeon_connector))
1321	serge	1652	ret = connector_status_connected;
1963	serge	1653	if (!radeon_dig_connector->edp_on)
		1654	atombios_set_edp_panel_power(connector,
		1655	ATOM_TRANSMITTER_ACTION_POWER_OFF);
2997	Serge	1656	} else if (radeon_connector_encoder_get_dp_bridge_encoder_id(connector) !=
		1657	ENCODER_OBJECT_ID_NONE) {
		1658	/* DP bridges are always DP */
		1659	radeon_dig_connector->dp_sink_type = CONNECTOR_OBJECT_ID_DISPLAYPORT;
		1660	/* get the DPCD from the bridge */
		1661	radeon_dp_getdpcd(radeon_connector);
		1662
		1663	if (encoder) {
		1664	/* setup ddc on the bridge */
6104	serge	1665	radeon_atom_ext_encoder_setup_ddc(encoder);
3192	Serge	1666	/* bridge chips are always aux */
		1667	if (radeon_ddc_probe(radeon_connector, true)) /* try DDC */
2997	Serge	1668	ret = connector_status_connected;
		1669	else if (radeon_connector->dac_load_detect) { /* try load detection */
6104	serge	1670	const struct drm_encoder_helper_funcs *encoder_funcs = encoder->helper_private;
2997	Serge	1671	ret = encoder_funcs->detect(encoder, connector);
6104	serge	1672	}
1986	serge	1673	}
2997	Serge	1674	} else {
1963	serge	1675	radeon_dig_connector->dp_sink_type = radeon_dp_getsinktype(radeon_connector);
		1676	if (radeon_hpd_sense(rdev, radeon_connector->hpd.hpd)) {
1321	serge	1677	ret = connector_status_connected;
6104	serge	1678	if (radeon_dig_connector->dp_sink_type == CONNECTOR_OBJECT_ID_DISPLAYPORT) {
1963	serge	1679	radeon_dp_getdpcd(radeon_connector);
6104	serge	1680	r = radeon_dp_mst_probe(radeon_connector);
		1681	if (r == 1)
		1682	ret = connector_status_disconnected;
		1683	}
1963	serge	1684	} else {
6104	serge	1685	if (radeon_dig_connector->dp_sink_type == CONNECTOR_OBJECT_ID_DISPLAYPORT) {
		1686	if (radeon_dp_getdpcd(radeon_connector)) {
		1687	r = radeon_dp_mst_probe(radeon_connector);
		1688	if (r == 1)
		1689	ret = connector_status_disconnected;
		1690	else
		1691	ret = connector_status_connected;
		1692	}
		1693	} else {
5078	serge	1694	/* try non-aux ddc (DP to DVI/HDMI/etc. adapter) */
3192	Serge	1695	if (radeon_ddc_probe(radeon_connector, false))
6104	serge	1696	ret = connector_status_connected;
		1697	}
1321	serge	1698	}
		1699	}
6104	serge	1700
		1701	radeon_connector_update_scratch_regs(connector, ret);
		1702
		1703	if ((radeon_audio != 0) && encoder) {
		1704	radeon_connector_get_edid(connector);
		1705	radeon_audio_detect(connector, encoder, ret);
1963	serge	1706	}
1321	serge	1707
5078	serge	1708	out:
1321	serge	1709	return ret;
		1710	}
		1711
		1712	static int radeon_dp_mode_valid(struct drm_connector *connector,
		1713	struct drm_display_mode *mode)
		1714	{
5078	serge	1715	struct drm_device *dev = connector->dev;
		1716	struct radeon_device *rdev = dev->dev_private;
1321	serge	1717	struct radeon_connector *radeon_connector = to_radeon_connector(connector);
		1718	struct radeon_connector_atom_dig *radeon_dig_connector = radeon_connector->con_priv;
		1719
		1720	/* XXX check mode bandwidth */
		1721
1986	serge	1722	if ((connector->connector_type == DRM_MODE_CONNECTOR_eDP) \|\|
		1723	(connector->connector_type == DRM_MODE_CONNECTOR_LVDS)) {
1963	serge	1724	struct drm_encoder *encoder = radeon_best_single_encoder(connector);
		1725
		1726	if ((mode->hdisplay < 320) \|\| (mode->vdisplay < 240))
		1727	return MODE_PANEL;
		1728
		1729	if (encoder) {
		1730	struct radeon_encoder *radeon_encoder = to_radeon_encoder(encoder);
		1731	struct drm_display_mode *native_mode = &radeon_encoder->native_mode;
		1732
6104	serge	1733	/* AVIVO hardware supports downscaling modes larger than the panel
1963	serge	1734	* to the panel size, but I'm not sure this is desirable.
		1735	*/
		1736	if ((mode->hdisplay > native_mode->hdisplay) \|\|
		1737	(mode->vdisplay > native_mode->vdisplay))
		1738	return MODE_PANEL;
		1739
		1740	/* if scaling is disabled, block non-native modes */
		1741	if (radeon_encoder->rmx_type == RMX_OFF) {
		1742	if ((mode->hdisplay != native_mode->hdisplay) \|\|
		1743	(mode->vdisplay != native_mode->vdisplay))
		1744	return MODE_PANEL;
		1745	}
		1746	}
		1747	} else {
6104	serge	1748	if ((radeon_dig_connector->dp_sink_type == CONNECTOR_OBJECT_ID_DISPLAYPORT) \|\|
5078	serge	1749	(radeon_dig_connector->dp_sink_type == CONNECTOR_OBJECT_ID_eDP)) {
1963	serge	1750	return radeon_dp_mode_valid_helper(connector, mode);
5078	serge	1751	} else {
		1752	if (ASIC_IS_DCE6(rdev) && drm_detect_hdmi_monitor(radeon_connector_edid(connector))) {
		1753	/* HDMI 1.3+ supports max clock of 340 Mhz */
		1754	if (mode->clock > 340000)
		1755	return MODE_CLOCK_HIGH;
		1756	} else {
		1757	if (mode->clock > 165000)
		1758	return MODE_CLOCK_HIGH;
		1759	}
		1760	}
		1761	}
		1762
6104	serge	1763	return MODE_OK;
1321	serge	1764	}
		1765
2997	Serge	1766	static const struct drm_connector_helper_funcs radeon_dp_connector_helper_funcs = {
1321	serge	1767	.get_modes = radeon_dp_get_modes,
		1768	.mode_valid = radeon_dp_mode_valid,
		1769	.best_encoder = radeon_dvi_encoder,
		1770	};
		1771
2997	Serge	1772	static const struct drm_connector_funcs radeon_dp_connector_funcs = {
1321	serge	1773	.dpms = drm_helper_connector_dpms,
		1774	.detect = radeon_dp_detect,
		1775	.fill_modes = drm_helper_probe_single_connector_modes,
		1776	.set_property = radeon_connector_set_property,
5078	serge	1777	.destroy = radeon_connector_destroy,
1321	serge	1778	.force = radeon_dvi_force,
		1779	};
		1780
5078	serge	1781	static const struct drm_connector_funcs radeon_edp_connector_funcs = {
		1782	.dpms = drm_helper_connector_dpms,
		1783	.detect = radeon_dp_detect,
		1784	.fill_modes = drm_helper_probe_single_connector_modes,
		1785	.set_property = radeon_lvds_set_property,
		1786	.destroy = radeon_connector_destroy,
		1787	.force = radeon_dvi_force,
		1788	};
		1789
		1790	static const struct drm_connector_funcs radeon_lvds_bridge_connector_funcs = {
		1791	.dpms = drm_helper_connector_dpms,
		1792	.detect = radeon_dp_detect,
		1793	.fill_modes = drm_helper_probe_single_connector_modes,
		1794	.set_property = radeon_lvds_set_property,
		1795	.destroy = radeon_connector_destroy,
		1796	.force = radeon_dvi_force,
		1797	};
		1798
1123	serge	1799	void
		1800	radeon_add_atom_connector(struct drm_device *dev,
		1801	uint32_t connector_id,
		1802	uint32_t supported_device,
		1803	int connector_type,
		1804	struct radeon_i2c_bus_rec *i2c_bus,
1268	serge	1805	uint32_t igp_lane_info,
1321	serge	1806	uint16_t connector_object_id,
1963	serge	1807	struct radeon_hpd *hpd,
		1808	struct radeon_router *router)
1123	serge	1809	{
1179	serge	1810	struct radeon_device *rdev = dev->dev_private;
1123	serge	1811	struct drm_connector *connector;
		1812	struct radeon_connector *radeon_connector;
		1813	struct radeon_connector_atom_dig *radeon_dig_connector;
1963	serge	1814	struct drm_encoder *encoder;
		1815	struct radeon_encoder *radeon_encoder;
1123	serge	1816	uint32_t subpixel_order = SubPixelNone;
1268	serge	1817	bool shared_ddc = false;
1963	serge	1818	bool is_dp_bridge = false;
5078	serge	1819	bool has_aux = false;
1123	serge	1820
1179	serge	1821	if (connector_type == DRM_MODE_CONNECTOR_Unknown)
1123	serge	1822	return;
		1823
1963	serge	1824	/* if the user selected tv=0 don't try and add the connector */
		1825	if (((connector_type == DRM_MODE_CONNECTOR_SVIDEO) \|\|
		1826	(connector_type == DRM_MODE_CONNECTOR_Composite) \|\|
		1827	(connector_type == DRM_MODE_CONNECTOR_9PinDIN)) &&
		1828	(radeon_tv == 0))
		1829	return;
		1830
1123	serge	1831	/* see if we already added it */
		1832	list_for_each_entry(connector, &dev->mode_config.connector_list, head) {
		1833	radeon_connector = to_radeon_connector(connector);
		1834	if (radeon_connector->connector_id == connector_id) {
		1835	radeon_connector->devices \|= supported_device;
		1836	return;
		1837	}
1268	serge	1838	if (radeon_connector->ddc_bus && i2c_bus->valid) {
1428	serge	1839	if (radeon_connector->ddc_bus->rec.i2c_id == i2c_bus->i2c_id) {
1268	serge	1840	radeon_connector->shared_ddc = true;
		1841	shared_ddc = true;
		1842	}
1963	serge	1843	if (radeon_connector->router_bus && router->ddc_valid &&
		1844	(radeon_connector->router.router_id == router->router_id)) {
		1845	radeon_connector->shared_ddc = false;
		1846	shared_ddc = false;
		1847	}
1268	serge	1848	}
1123	serge	1849	}
		1850
1963	serge	1851	/* check if it's a dp bridge */
		1852	list_for_each_entry(encoder, &dev->mode_config.encoder_list, head) {
		1853	radeon_encoder = to_radeon_encoder(encoder);
		1854	if (radeon_encoder->devices & supported_device) {
		1855	switch (radeon_encoder->encoder_id) {
		1856	case ENCODER_OBJECT_ID_TRAVIS:
		1857	case ENCODER_OBJECT_ID_NUTMEG:
		1858	is_dp_bridge = true;
		1859	break;
		1860	default:
		1861	break;
		1862	}
		1863	}
		1864	}
		1865
1123	serge	1866	radeon_connector = kzalloc(sizeof(struct radeon_connector), GFP_KERNEL);
		1867	if (!radeon_connector)
		1868	return;
		1869
		1870	connector = &radeon_connector->base;
		1871
		1872	radeon_connector->connector_id = connector_id;
		1873	radeon_connector->devices = supported_device;
1268	serge	1874	radeon_connector->shared_ddc = shared_ddc;
		1875	radeon_connector->connector_object_id = connector_object_id;
1321	serge	1876	radeon_connector->hpd = *hpd;
2997	Serge	1877
1963	serge	1878	radeon_connector->router = *router;
		1879	if (router->ddc_valid \|\| router->cd_valid) {
		1880	radeon_connector->router_bus = radeon_i2c_lookup(rdev, &router->i2c_info);
		1881	if (!radeon_connector->router_bus)
		1882	DRM_ERROR("Failed to assign router i2c bus! Check dmesg for i2c errors.\n");
		1883	}
		1884
		1885	if (is_dp_bridge) {
		1886	radeon_dig_connector = kzalloc(sizeof(struct radeon_connector_atom_dig), GFP_KERNEL);
		1887	if (!radeon_dig_connector)
		1888	goto failed;
		1889	radeon_dig_connector->igp_lane_info = igp_lane_info;
		1890	radeon_connector->con_priv = radeon_dig_connector;
		1891	if (i2c_bus->valid) {
5078	serge	1892	radeon_connector->ddc_bus = radeon_i2c_lookup(rdev, i2c_bus);
		1893	if (radeon_connector->ddc_bus)
		1894	has_aux = true;
1963	serge	1895	else
		1896	DRM_ERROR("DP: Failed to assign ddc bus! Check dmesg for i2c errors.\n");
		1897	}
6104	serge	1898	switch (connector_type) {
		1899	case DRM_MODE_CONNECTOR_VGA:
1963	serge	1900	case DRM_MODE_CONNECTOR_DVIA:
		1901	default:
5078	serge	1902	drm_connector_init(dev, &radeon_connector->base,
		1903	&radeon_dp_connector_funcs, connector_type);
		1904	drm_connector_helper_add(&radeon_connector->base,
		1905	&radeon_dp_connector_helper_funcs);
1963	serge	1906	connector->interlace_allowed = true;
		1907	connector->doublescan_allowed = true;
1986	serge	1908	radeon_connector->dac_load_detect = true;
3192	Serge	1909	drm_object_attach_property(&radeon_connector->base.base,
1986	serge	1910	rdev->mode_info.load_detect_property,
		1911	1);
5078	serge	1912	drm_object_attach_property(&radeon_connector->base.base,
		1913	dev->mode_config.scaling_mode_property,
		1914	DRM_MODE_SCALE_NONE);
6104	serge	1915	if (ASIC_IS_DCE5(rdev))
		1916	drm_object_attach_property(&radeon_connector->base.base,
		1917	rdev->mode_info.output_csc_property,
		1918	RADEON_OUTPUT_CSC_BYPASS);
1963	serge	1919	break;
		1920	case DRM_MODE_CONNECTOR_DVII:
		1921	case DRM_MODE_CONNECTOR_DVID:
		1922	case DRM_MODE_CONNECTOR_HDMIA:
		1923	case DRM_MODE_CONNECTOR_HDMIB:
		1924	case DRM_MODE_CONNECTOR_DisplayPort:
5078	serge	1925	drm_connector_init(dev, &radeon_connector->base,
		1926	&radeon_dp_connector_funcs, connector_type);
		1927	drm_connector_helper_add(&radeon_connector->base,
		1928	&radeon_dp_connector_helper_funcs);
3192	Serge	1929	drm_object_attach_property(&radeon_connector->base.base,
1963	serge	1930	rdev->mode_info.underscan_property,
		1931	UNDERSCAN_OFF);
3192	Serge	1932	drm_object_attach_property(&radeon_connector->base.base,
1963	serge	1933	rdev->mode_info.underscan_hborder_property,
		1934	0);
3192	Serge	1935	drm_object_attach_property(&radeon_connector->base.base,
1963	serge	1936	rdev->mode_info.underscan_vborder_property,
		1937	0);
5078	serge	1938
		1939	drm_object_attach_property(&radeon_connector->base.base,
		1940	dev->mode_config.scaling_mode_property,
		1941	DRM_MODE_SCALE_NONE);
		1942
		1943	drm_object_attach_property(&radeon_connector->base.base,
		1944	rdev->mode_info.dither_property,
		1945	RADEON_FMT_DITHER_DISABLE);
		1946
		1947	if (radeon_audio != 0)
6104	serge	1948	drm_object_attach_property(&radeon_connector->base.base,
		1949	rdev->mode_info.audio_property,
5078	serge	1950	RADEON_AUDIO_AUTO);
6104	serge	1951	if (ASIC_IS_DCE5(rdev))
		1952	drm_object_attach_property(&radeon_connector->base.base,
		1953	rdev->mode_info.output_csc_property,
		1954	RADEON_OUTPUT_CSC_BYPASS);
5078	serge	1955
1963	serge	1956	subpixel_order = SubPixelHorizontalRGB;
		1957	connector->interlace_allowed = true;
		1958	if (connector_type == DRM_MODE_CONNECTOR_HDMIB)
		1959	connector->doublescan_allowed = true;
		1960	else
		1961	connector->doublescan_allowed = false;
1986	serge	1962	if (connector_type == DRM_MODE_CONNECTOR_DVII) {
		1963	radeon_connector->dac_load_detect = true;
3192	Serge	1964	drm_object_attach_property(&radeon_connector->base.base,
1986	serge	1965	rdev->mode_info.load_detect_property,
		1966	1);
		1967	}
1963	serge	1968	break;
		1969	case DRM_MODE_CONNECTOR_LVDS:
		1970	case DRM_MODE_CONNECTOR_eDP:
5078	serge	1971	drm_connector_init(dev, &radeon_connector->base,
		1972	&radeon_lvds_bridge_connector_funcs, connector_type);
		1973	drm_connector_helper_add(&radeon_connector->base,
		1974	&radeon_dp_connector_helper_funcs);
3192	Serge	1975	drm_object_attach_property(&radeon_connector->base.base,
1963	serge	1976	dev->mode_config.scaling_mode_property,
		1977	DRM_MODE_SCALE_FULLSCREEN);
		1978	subpixel_order = SubPixelHorizontalRGB;
		1979	connector->interlace_allowed = false;
		1980	connector->doublescan_allowed = false;
		1981	break;
		1982	}
		1983	} else {
		1984	switch (connector_type) {
		1985	case DRM_MODE_CONNECTOR_VGA:
6104	serge	1986	drm_connector_init(dev, &radeon_connector->base, &radeon_vga_connector_funcs, connector_type);
		1987	drm_connector_helper_add(&radeon_connector->base, &radeon_vga_connector_helper_funcs);
		1988	if (i2c_bus->valid) {
		1989	radeon_connector->ddc_bus = radeon_i2c_lookup(rdev, i2c_bus);
		1990	if (!radeon_connector->ddc_bus)
		1991	DRM_ERROR("VGA: Failed to assign ddc bus! Check dmesg for i2c errors.\n");
		1992	}
		1993	radeon_connector->dac_load_detect = true;
3192	Serge	1994	drm_object_attach_property(&radeon_connector->base.base,
6104	serge	1995	rdev->mode_info.load_detect_property,
		1996	1);
5078	serge	1997	if (ASIC_IS_AVIVO(rdev))
		1998	drm_object_attach_property(&radeon_connector->base.base,
		1999	dev->mode_config.scaling_mode_property,
		2000	DRM_MODE_SCALE_NONE);
6104	serge	2001	if (ASIC_IS_DCE5(rdev))
		2002	drm_object_attach_property(&radeon_connector->base.base,
		2003	rdev->mode_info.output_csc_property,
		2004	RADEON_OUTPUT_CSC_BYPASS);
		2005	/* no HPD on analog connectors */
		2006	radeon_connector->hpd.hpd = RADEON_HPD_NONE;
		2007	connector->polled = DRM_CONNECTOR_POLL_CONNECT;
		2008	connector->interlace_allowed = true;
		2009	connector->doublescan_allowed = true;
		2010	break;
		2011	case DRM_MODE_CONNECTOR_DVIA:
		2012	drm_connector_init(dev, &radeon_connector->base, &radeon_vga_connector_funcs, connector_type);
		2013	drm_connector_helper_add(&radeon_connector->base, &radeon_vga_connector_helper_funcs);
		2014	if (i2c_bus->valid) {
		2015	radeon_connector->ddc_bus = radeon_i2c_lookup(rdev, i2c_bus);
		2016	if (!radeon_connector->ddc_bus)
		2017	DRM_ERROR("DVIA: Failed to assign ddc bus! Check dmesg for i2c errors.\n");
		2018	}
		2019	radeon_connector->dac_load_detect = true;
3192	Serge	2020	drm_object_attach_property(&radeon_connector->base.base,
6104	serge	2021	rdev->mode_info.load_detect_property,
		2022	1);
5078	serge	2023	if (ASIC_IS_AVIVO(rdev))
		2024	drm_object_attach_property(&radeon_connector->base.base,
		2025	dev->mode_config.scaling_mode_property,
		2026	DRM_MODE_SCALE_NONE);
6104	serge	2027	if (ASIC_IS_DCE5(rdev))
		2028	drm_object_attach_property(&radeon_connector->base.base,
		2029	rdev->mode_info.output_csc_property,
		2030	RADEON_OUTPUT_CSC_BYPASS);
		2031	/* no HPD on analog connectors */
		2032	radeon_connector->hpd.hpd = RADEON_HPD_NONE;
		2033	connector->interlace_allowed = true;
		2034	connector->doublescan_allowed = true;
		2035	break;
		2036	case DRM_MODE_CONNECTOR_DVII:
		2037	case DRM_MODE_CONNECTOR_DVID:
		2038	radeon_dig_connector = kzalloc(sizeof(struct radeon_connector_atom_dig), GFP_KERNEL);
		2039	if (!radeon_dig_connector)
		2040	goto failed;
		2041	radeon_dig_connector->igp_lane_info = igp_lane_info;
		2042	radeon_connector->con_priv = radeon_dig_connector;
		2043	drm_connector_init(dev, &radeon_connector->base, &radeon_dvi_connector_funcs, connector_type);
		2044	drm_connector_helper_add(&radeon_connector->base, &radeon_dvi_connector_helper_funcs);
		2045	if (i2c_bus->valid) {
		2046	radeon_connector->ddc_bus = radeon_i2c_lookup(rdev, i2c_bus);
		2047	if (!radeon_connector->ddc_bus)
		2048	DRM_ERROR("DVI: Failed to assign ddc bus! Check dmesg for i2c errors.\n");
		2049	}
		2050	subpixel_order = SubPixelHorizontalRGB;
3192	Serge	2051	drm_object_attach_property(&radeon_connector->base.base,
6104	serge	2052	rdev->mode_info.coherent_mode_property,
		2053	1);
		2054	if (ASIC_IS_AVIVO(rdev)) {
3192	Serge	2055	drm_object_attach_property(&radeon_connector->base.base,
6104	serge	2056	rdev->mode_info.underscan_property,
		2057	UNDERSCAN_OFF);
3192	Serge	2058	drm_object_attach_property(&radeon_connector->base.base,
6104	serge	2059	rdev->mode_info.underscan_hborder_property,
		2060	0);
3192	Serge	2061	drm_object_attach_property(&radeon_connector->base.base,
6104	serge	2062	rdev->mode_info.underscan_vborder_property,
		2063	0);
5078	serge	2064	drm_object_attach_property(&radeon_connector->base.base,
		2065	rdev->mode_info.dither_property,
		2066	RADEON_FMT_DITHER_DISABLE);
		2067	drm_object_attach_property(&radeon_connector->base.base,
		2068	dev->mode_config.scaling_mode_property,
		2069	DRM_MODE_SCALE_NONE);
6104	serge	2070	}
5078	serge	2071	if (ASIC_IS_DCE2(rdev) && (radeon_audio != 0)) {
		2072	drm_object_attach_property(&radeon_connector->base.base,
6104	serge	2073	rdev->mode_info.audio_property,
5078	serge	2074	RADEON_AUDIO_AUTO);
		2075	}
6104	serge	2076	if (connector_type == DRM_MODE_CONNECTOR_DVII) {
		2077	radeon_connector->dac_load_detect = true;
3192	Serge	2078	drm_object_attach_property(&radeon_connector->base.base,
6104	serge	2079	rdev->mode_info.load_detect_property,
		2080	1);
		2081	}
		2082	if (ASIC_IS_DCE5(rdev))
		2083	drm_object_attach_property(&radeon_connector->base.base,
		2084	rdev->mode_info.output_csc_property,
		2085	RADEON_OUTPUT_CSC_BYPASS);
		2086	connector->interlace_allowed = true;
		2087	if (connector_type == DRM_MODE_CONNECTOR_DVII)
		2088	connector->doublescan_allowed = true;
		2089	else
		2090	connector->doublescan_allowed = false;
		2091	break;
		2092	case DRM_MODE_CONNECTOR_HDMIA:
		2093	case DRM_MODE_CONNECTOR_HDMIB:
		2094	radeon_dig_connector = kzalloc(sizeof(struct radeon_connector_atom_dig), GFP_KERNEL);
		2095	if (!radeon_dig_connector)
		2096	goto failed;
		2097	radeon_dig_connector->igp_lane_info = igp_lane_info;
		2098	radeon_connector->con_priv = radeon_dig_connector;
		2099	drm_connector_init(dev, &radeon_connector->base, &radeon_dvi_connector_funcs, connector_type);
		2100	drm_connector_helper_add(&radeon_connector->base, &radeon_dvi_connector_helper_funcs);
		2101	if (i2c_bus->valid) {
		2102	radeon_connector->ddc_bus = radeon_i2c_lookup(rdev, i2c_bus);
		2103	if (!radeon_connector->ddc_bus)
		2104	DRM_ERROR("HDMI: Failed to assign ddc bus! Check dmesg for i2c errors.\n");
		2105	}
3192	Serge	2106	drm_object_attach_property(&radeon_connector->base.base,
6104	serge	2107	rdev->mode_info.coherent_mode_property,
		2108	1);
		2109	if (ASIC_IS_AVIVO(rdev)) {
3192	Serge	2110	drm_object_attach_property(&radeon_connector->base.base,
6104	serge	2111	rdev->mode_info.underscan_property,
		2112	UNDERSCAN_OFF);
3192	Serge	2113	drm_object_attach_property(&radeon_connector->base.base,
6104	serge	2114	rdev->mode_info.underscan_hborder_property,
		2115	0);
3192	Serge	2116	drm_object_attach_property(&radeon_connector->base.base,
6104	serge	2117	rdev->mode_info.underscan_vborder_property,
		2118	0);
5078	serge	2119	drm_object_attach_property(&radeon_connector->base.base,
		2120	rdev->mode_info.dither_property,
		2121	RADEON_FMT_DITHER_DISABLE);
		2122	drm_object_attach_property(&radeon_connector->base.base,
		2123	dev->mode_config.scaling_mode_property,
		2124	DRM_MODE_SCALE_NONE);
6104	serge	2125	}
5078	serge	2126	if (ASIC_IS_DCE2(rdev) && (radeon_audio != 0)) {
		2127	drm_object_attach_property(&radeon_connector->base.base,
6104	serge	2128	rdev->mode_info.audio_property,
5078	serge	2129	RADEON_AUDIO_AUTO);
		2130	}
6104	serge	2131	if (ASIC_IS_DCE5(rdev))
		2132	drm_object_attach_property(&radeon_connector->base.base,
		2133	rdev->mode_info.output_csc_property,
		2134	RADEON_OUTPUT_CSC_BYPASS);
		2135	subpixel_order = SubPixelHorizontalRGB;
		2136	connector->interlace_allowed = true;
		2137	if (connector_type == DRM_MODE_CONNECTOR_HDMIB)
		2138	connector->doublescan_allowed = true;
		2139	else
		2140	connector->doublescan_allowed = false;
		2141	break;
		2142	case DRM_MODE_CONNECTOR_DisplayPort:
		2143	radeon_dig_connector = kzalloc(sizeof(struct radeon_connector_atom_dig), GFP_KERNEL);
		2144	if (!radeon_dig_connector)
		2145	goto failed;
		2146	radeon_dig_connector->igp_lane_info = igp_lane_info;
		2147	radeon_connector->con_priv = radeon_dig_connector;
		2148	drm_connector_init(dev, &radeon_connector->base, &radeon_dp_connector_funcs, connector_type);
		2149	drm_connector_helper_add(&radeon_connector->base, &radeon_dp_connector_helper_funcs);
		2150	if (i2c_bus->valid) {
		2151	radeon_connector->ddc_bus = radeon_i2c_lookup(rdev, i2c_bus);
5078	serge	2152	if (radeon_connector->ddc_bus)
		2153	has_aux = true;
		2154	else
6104	serge	2155	DRM_ERROR("DP: Failed to assign ddc bus! Check dmesg for i2c errors.\n");
		2156	}
		2157	subpixel_order = SubPixelHorizontalRGB;
3192	Serge	2158	drm_object_attach_property(&radeon_connector->base.base,
6104	serge	2159	rdev->mode_info.coherent_mode_property,
		2160	1);
		2161	if (ASIC_IS_AVIVO(rdev)) {
3192	Serge	2162	drm_object_attach_property(&radeon_connector->base.base,
6104	serge	2163	rdev->mode_info.underscan_property,
		2164	UNDERSCAN_OFF);
3192	Serge	2165	drm_object_attach_property(&radeon_connector->base.base,
6104	serge	2166	rdev->mode_info.underscan_hborder_property,
		2167	0);
3192	Serge	2168	drm_object_attach_property(&radeon_connector->base.base,
6104	serge	2169	rdev->mode_info.underscan_vborder_property,
		2170	0);
5078	serge	2171	drm_object_attach_property(&radeon_connector->base.base,
		2172	rdev->mode_info.dither_property,
		2173	RADEON_FMT_DITHER_DISABLE);
		2174	drm_object_attach_property(&radeon_connector->base.base,
		2175	dev->mode_config.scaling_mode_property,
		2176	DRM_MODE_SCALE_NONE);
6104	serge	2177	}
5078	serge	2178	if (ASIC_IS_DCE2(rdev) && (radeon_audio != 0)) {
		2179	drm_object_attach_property(&radeon_connector->base.base,
6104	serge	2180	rdev->mode_info.audio_property,
5078	serge	2181	RADEON_AUDIO_AUTO);
		2182	}
6104	serge	2183	if (ASIC_IS_DCE5(rdev))
		2184	drm_object_attach_property(&radeon_connector->base.base,
		2185	rdev->mode_info.output_csc_property,
		2186	RADEON_OUTPUT_CSC_BYPASS);
		2187	connector->interlace_allowed = true;
		2188	/* in theory with a DP to VGA converter... */
		2189	connector->doublescan_allowed = false;
		2190	break;
1963	serge	2191	case DRM_MODE_CONNECTOR_eDP:
		2192	radeon_dig_connector = kzalloc(sizeof(struct radeon_connector_atom_dig), GFP_KERNEL);
		2193	if (!radeon_dig_connector)
		2194	goto failed;
		2195	radeon_dig_connector->igp_lane_info = igp_lane_info;
		2196	radeon_connector->con_priv = radeon_dig_connector;
5078	serge	2197	drm_connector_init(dev, &radeon_connector->base, &radeon_edp_connector_funcs, connector_type);
1963	serge	2198	drm_connector_helper_add(&radeon_connector->base, &radeon_dp_connector_helper_funcs);
		2199	if (i2c_bus->valid) {
		2200	radeon_connector->ddc_bus = radeon_i2c_lookup(rdev, i2c_bus);
5078	serge	2201	if (radeon_connector->ddc_bus)
		2202	has_aux = true;
		2203	else
1963	serge	2204	DRM_ERROR("DP: Failed to assign ddc bus! Check dmesg for i2c errors.\n");
		2205	}
3192	Serge	2206	drm_object_attach_property(&radeon_connector->base.base,
1963	serge	2207	dev->mode_config.scaling_mode_property,
		2208	DRM_MODE_SCALE_FULLSCREEN);
		2209	subpixel_order = SubPixelHorizontalRGB;
		2210	connector->interlace_allowed = false;
		2211	connector->doublescan_allowed = false;
		2212	break;
6104	serge	2213	case DRM_MODE_CONNECTOR_SVIDEO:
		2214	case DRM_MODE_CONNECTOR_Composite:
		2215	case DRM_MODE_CONNECTOR_9PinDIN:
1179	serge	2216	drm_connector_init(dev, &radeon_connector->base, &radeon_tv_connector_funcs, connector_type);
1963	serge	2217	drm_connector_helper_add(&radeon_connector->base, &radeon_tv_connector_helper_funcs);
1221	serge	2218	radeon_connector->dac_load_detect = true;
3192	Serge	2219	drm_object_attach_property(&radeon_connector->base.base,
6104	serge	2220	rdev->mode_info.load_detect_property,
		2221	1);
3192	Serge	2222	drm_object_attach_property(&radeon_connector->base.base,
1321	serge	2223	rdev->mode_info.tv_std_property,
1403	serge	2224	radeon_atombios_get_tv_info(rdev));
1963	serge	2225	/* no HPD on analog connectors */
		2226	radeon_connector->hpd.hpd = RADEON_HPD_NONE;
6104	serge	2227	connector->interlace_allowed = false;
		2228	connector->doublescan_allowed = false;
		2229	break;
		2230	case DRM_MODE_CONNECTOR_LVDS:
		2231	radeon_dig_connector = kzalloc(sizeof(struct radeon_connector_atom_dig), GFP_KERNEL);
		2232	if (!radeon_dig_connector)
		2233	goto failed;
		2234	radeon_dig_connector->igp_lane_info = igp_lane_info;
		2235	radeon_connector->con_priv = radeon_dig_connector;
		2236	drm_connector_init(dev, &radeon_connector->base, &radeon_lvds_connector_funcs, connector_type);
		2237	drm_connector_helper_add(&radeon_connector->base, &radeon_lvds_connector_helper_funcs);
		2238	if (i2c_bus->valid) {
		2239	radeon_connector->ddc_bus = radeon_i2c_lookup(rdev, i2c_bus);
		2240	if (!radeon_connector->ddc_bus)
		2241	DRM_ERROR("LVDS: Failed to assign ddc bus! Check dmesg for i2c errors.\n");
		2242	}
		2243	drm_object_attach_property(&radeon_connector->base.base,
		2244	dev->mode_config.scaling_mode_property,
		2245	DRM_MODE_SCALE_FULLSCREEN);
		2246	subpixel_order = SubPixelHorizontalRGB;
		2247	connector->interlace_allowed = false;
		2248	connector->doublescan_allowed = false;
		2249	break;
1123	serge	2250	}
		2251	}
		2252
1963	serge	2253	if (radeon_connector->hpd.hpd == RADEON_HPD_NONE) {
		2254	if (i2c_bus->valid)
		2255	connector->polled = DRM_CONNECTOR_POLL_CONNECT;
		2256	} else
		2257	connector->polled = DRM_CONNECTOR_POLL_HPD;
		2258
1123	serge	2259	connector->display_info.subpixel_order = subpixel_order;
5078	serge	2260	drm_connector_register(connector);
		2261
		2262	if (has_aux)
		2263	radeon_dp_aux_init(radeon_connector);
		2264
1123	serge	2265	return;
		2266
		2267	failed:
		2268	drm_connector_cleanup(connector);
		2269	kfree(connector);
		2270	}
		2271
		2272	void
		2273	radeon_add_legacy_connector(struct drm_device *dev,
		2274	uint32_t connector_id,
		2275	uint32_t supported_device,
		2276	int connector_type,
1268	serge	2277	struct radeon_i2c_bus_rec *i2c_bus,
1321	serge	2278	uint16_t connector_object_id,
		2279	struct radeon_hpd *hpd)
1123	serge	2280	{
1179	serge	2281	struct radeon_device *rdev = dev->dev_private;
1123	serge	2282	struct drm_connector *connector;
		2283	struct radeon_connector *radeon_connector;
		2284	uint32_t subpixel_order = SubPixelNone;
		2285
1179	serge	2286	if (connector_type == DRM_MODE_CONNECTOR_Unknown)
1123	serge	2287	return;
		2288
1963	serge	2289	/* if the user selected tv=0 don't try and add the connector */
		2290	if (((connector_type == DRM_MODE_CONNECTOR_SVIDEO) \|\|
		2291	(connector_type == DRM_MODE_CONNECTOR_Composite) \|\|
		2292	(connector_type == DRM_MODE_CONNECTOR_9PinDIN)) &&
		2293	(radeon_tv == 0))
		2294	return;
		2295
1123	serge	2296	/* see if we already added it */
		2297	list_for_each_entry(connector, &dev->mode_config.connector_list, head) {
		2298	radeon_connector = to_radeon_connector(connector);
		2299	if (radeon_connector->connector_id == connector_id) {
		2300	radeon_connector->devices \|= supported_device;
		2301	return;
		2302	}
		2303	}
		2304
		2305	radeon_connector = kzalloc(sizeof(struct radeon_connector), GFP_KERNEL);
		2306	if (!radeon_connector)
		2307	return;
		2308
		2309	connector = &radeon_connector->base;
		2310
		2311	radeon_connector->connector_id = connector_id;
		2312	radeon_connector->devices = supported_device;
1268	serge	2313	radeon_connector->connector_object_id = connector_object_id;
1321	serge	2314	radeon_connector->hpd = *hpd;
2997	Serge	2315
1123	serge	2316	switch (connector_type) {
		2317	case DRM_MODE_CONNECTOR_VGA:
		2318	drm_connector_init(dev, &radeon_connector->base, &radeon_vga_connector_funcs, connector_type);
1963	serge	2319	drm_connector_helper_add(&radeon_connector->base, &radeon_vga_connector_helper_funcs);
1123	serge	2320	if (i2c_bus->valid) {
1963	serge	2321	radeon_connector->ddc_bus = radeon_i2c_lookup(rdev, i2c_bus);
1123	serge	2322	if (!radeon_connector->ddc_bus)
1963	serge	2323	DRM_ERROR("VGA: Failed to assign ddc bus! Check dmesg for i2c errors.\n");
1123	serge	2324	}
1221	serge	2325	radeon_connector->dac_load_detect = true;
3192	Serge	2326	drm_object_attach_property(&radeon_connector->base.base,
1179	serge	2327	rdev->mode_info.load_detect_property,
		2328	1);
1963	serge	2329	/* no HPD on analog connectors */
		2330	radeon_connector->hpd.hpd = RADEON_HPD_NONE;
		2331	connector->polled = DRM_CONNECTOR_POLL_CONNECT;
		2332	connector->interlace_allowed = true;
		2333	connector->doublescan_allowed = true;
1123	serge	2334	break;
		2335	case DRM_MODE_CONNECTOR_DVIA:
		2336	drm_connector_init(dev, &radeon_connector->base, &radeon_vga_connector_funcs, connector_type);
1963	serge	2337	drm_connector_helper_add(&radeon_connector->base, &radeon_vga_connector_helper_funcs);
1123	serge	2338	if (i2c_bus->valid) {
1963	serge	2339	radeon_connector->ddc_bus = radeon_i2c_lookup(rdev, i2c_bus);
1123	serge	2340	if (!radeon_connector->ddc_bus)
1963	serge	2341	DRM_ERROR("DVIA: Failed to assign ddc bus! Check dmesg for i2c errors.\n");
1123	serge	2342	}
1221	serge	2343	radeon_connector->dac_load_detect = true;
3192	Serge	2344	drm_object_attach_property(&radeon_connector->base.base,
1179	serge	2345	rdev->mode_info.load_detect_property,
		2346	1);
1963	serge	2347	/* no HPD on analog connectors */
		2348	radeon_connector->hpd.hpd = RADEON_HPD_NONE;
		2349	connector->interlace_allowed = true;
		2350	connector->doublescan_allowed = true;
1123	serge	2351	break;
		2352	case DRM_MODE_CONNECTOR_DVII:
		2353	case DRM_MODE_CONNECTOR_DVID:
		2354	drm_connector_init(dev, &radeon_connector->base, &radeon_dvi_connector_funcs, connector_type);
1963	serge	2355	drm_connector_helper_add(&radeon_connector->base, &radeon_dvi_connector_helper_funcs);
1123	serge	2356	if (i2c_bus->valid) {
1963	serge	2357	radeon_connector->ddc_bus = radeon_i2c_lookup(rdev, i2c_bus);
1123	serge	2358	if (!radeon_connector->ddc_bus)
1963	serge	2359	DRM_ERROR("DVI: Failed to assign ddc bus! Check dmesg for i2c errors.\n");
		2360	}
		2361	if (connector_type == DRM_MODE_CONNECTOR_DVII) {
1221	serge	2362	radeon_connector->dac_load_detect = true;
3192	Serge	2363	drm_object_attach_property(&radeon_connector->base.base,
1179	serge	2364	rdev->mode_info.load_detect_property,
		2365	1);
1123	serge	2366	}
		2367	subpixel_order = SubPixelHorizontalRGB;
1963	serge	2368	connector->interlace_allowed = true;
		2369	if (connector_type == DRM_MODE_CONNECTOR_DVII)
		2370	connector->doublescan_allowed = true;
		2371	else
		2372	connector->doublescan_allowed = false;
1123	serge	2373	break;
		2374	case DRM_MODE_CONNECTOR_SVIDEO:
		2375	case DRM_MODE_CONNECTOR_Composite:
		2376	case DRM_MODE_CONNECTOR_9PinDIN:
6104	serge	2377	drm_connector_init(dev, &radeon_connector->base, &radeon_tv_connector_funcs, connector_type);
		2378	drm_connector_helper_add(&radeon_connector->base, &radeon_tv_connector_helper_funcs);
		2379	radeon_connector->dac_load_detect = true;
		2380	/* RS400,RC410,RS480 chipset seems to report a lot
		2381	* of false positive on load detect, we haven't yet
		2382	* found a way to make load detect reliable on those
		2383	* chipset, thus just disable it for TV.
		2384	*/
		2385	if (rdev->family == CHIP_RS400 \|\| rdev->family == CHIP_RS480)
		2386	radeon_connector->dac_load_detect = false;
3192	Serge	2387	drm_object_attach_property(&radeon_connector->base.base,
6104	serge	2388	rdev->mode_info.load_detect_property,
		2389	radeon_connector->dac_load_detect);
3192	Serge	2390	drm_object_attach_property(&radeon_connector->base.base,
6104	serge	2391	rdev->mode_info.tv_std_property,
		2392	radeon_combios_get_tv_info(rdev));
		2393	/* no HPD on analog connectors */
		2394	radeon_connector->hpd.hpd = RADEON_HPD_NONE;
1963	serge	2395	connector->interlace_allowed = false;
		2396	connector->doublescan_allowed = false;
1123	serge	2397	break;
		2398	case DRM_MODE_CONNECTOR_LVDS:
		2399	drm_connector_init(dev, &radeon_connector->base, &radeon_lvds_connector_funcs, connector_type);
1963	serge	2400	drm_connector_helper_add(&radeon_connector->base, &radeon_lvds_connector_helper_funcs);
1123	serge	2401	if (i2c_bus->valid) {
1963	serge	2402	radeon_connector->ddc_bus = radeon_i2c_lookup(rdev, i2c_bus);
1123	serge	2403	if (!radeon_connector->ddc_bus)
1963	serge	2404	DRM_ERROR("LVDS: Failed to assign ddc bus! Check dmesg for i2c errors.\n");
1123	serge	2405	}
3192	Serge	2406	drm_object_attach_property(&radeon_connector->base.base,
1179	serge	2407	dev->mode_config.scaling_mode_property,
		2408	DRM_MODE_SCALE_FULLSCREEN);
1123	serge	2409	subpixel_order = SubPixelHorizontalRGB;
1963	serge	2410	connector->interlace_allowed = false;
		2411	connector->doublescan_allowed = false;
1123	serge	2412	break;
		2413	}
		2414
1963	serge	2415	if (radeon_connector->hpd.hpd == RADEON_HPD_NONE) {
		2416	if (i2c_bus->valid)
		2417	connector->polled = DRM_CONNECTOR_POLL_CONNECT;
		2418	} else
		2419	connector->polled = DRM_CONNECTOR_POLL_HPD;
1123	serge	2420	connector->display_info.subpixel_order = subpixel_order;
5078	serge	2421	drm_connector_register(connector);
1123	serge	2422	}
6104	serge	2423
		2424	void radeon_setup_mst_connector(struct drm_device *dev)
		2425	{
		2426	struct radeon_device *rdev = dev->dev_private;
		2427	struct drm_connector *connector;
		2428	struct radeon_connector *radeon_connector;
		2429
		2430	if (!ASIC_IS_DCE5(rdev))
		2431	return;
		2432
		2433	if (radeon_mst == 0)
		2434	return;
		2435
		2436	list_for_each_entry(connector, &dev->mode_config.connector_list, head) {
		2437	int ret;
		2438
		2439	radeon_connector = to_radeon_connector(connector);
		2440
		2441	if (connector->connector_type != DRM_MODE_CONNECTOR_DisplayPort)
		2442	continue;
		2443
		2444	ret = radeon_dp_mst_init(radeon_connector);
		2445	}
		2446	}

Subversion Repositories Kolibri OS

(root)/drivers/video/drm/radeon/radeon_connectors.c – Rev 6104