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
6321	serge	1141	r = pm_runtime_get_sync(connector->dev->dev);
		1142	if (r < 0)
		1143	return connector_status_disconnected;
		1144
1179	serge	1145	encoder = radeon_best_single_encoder(connector);
		1146	if (!encoder)
		1147	ret = connector_status_disconnected;
		1148	else {
		1149	encoder_funcs = encoder->helper_private;
		1150	ret = encoder_funcs->detect(encoder, connector);
		1151	}
		1152	if (ret == connector_status_connected)
		1153	ret = radeon_connector_analog_encoder_conflict_solve(connector, encoder, ret, false);
		1154	radeon_connector_update_scratch_regs(connector, ret);
6321	serge	1155	pm_runtime_mark_last_busy(connector->dev->dev);
		1156	pm_runtime_put_autosuspend(connector->dev->dev);
1179	serge	1157	return ret;
		1158	}
		1159
2997	Serge	1160	static const struct drm_connector_helper_funcs radeon_tv_connector_helper_funcs = {
1179	serge	1161	.get_modes = radeon_tv_get_modes,
		1162	.mode_valid = radeon_tv_mode_valid,
		1163	.best_encoder = radeon_best_single_encoder,
		1164	};
		1165
2997	Serge	1166	static const struct drm_connector_funcs radeon_tv_connector_funcs = {
1179	serge	1167	.dpms = drm_helper_connector_dpms,
		1168	.detect = radeon_tv_detect,
		1169	.fill_modes = drm_helper_probe_single_connector_modes,
		1170	.destroy = radeon_connector_destroy,
		1171	.set_property = radeon_connector_set_property,
		1172	};
		1173
2997	Serge	1174	static bool radeon_check_hpd_status_unchanged(struct drm_connector *connector)
		1175	{
		1176	struct drm_device *dev = connector->dev;
		1177	struct radeon_device *rdev = dev->dev_private;
		1178	struct radeon_connector *radeon_connector = to_radeon_connector(connector);
		1179	enum drm_connector_status status;
		1180
		1181	/* We only trust HPD on R600 and newer ASICS. */
		1182	if (rdev->family >= CHIP_R600
		1183	&& radeon_connector->hpd.hpd != RADEON_HPD_NONE) {
		1184	if (radeon_hpd_sense(rdev, radeon_connector->hpd.hpd))
		1185	status = connector_status_connected;
		1186	else
		1187	status = connector_status_disconnected;
		1188	if (connector->status == status)
		1189	return true;
		1190	}
		1191
		1192	return false;
		1193	}
		1194
1179	serge	1195	/*
		1196	* DVI is complicated
		1197	* Do a DDC probe, if DDC probe passes, get the full EDID so
		1198	* we can do analog/digital monitor detection at this point.
		1199	* If the monitor is an analog monitor or we got no DDC,
		1200	* we need to find the DAC encoder object for this connector.
		1201	* If we got no DDC, we do load detection on the DAC encoder object.
		1202	* If we got analog DDC or load detection passes on the DAC encoder
		1203	* we have to check if this analog encoder is shared with anyone else (TV)
		1204	* if its shared we have to set the other connector to disconnected.
		1205	*/
1963	serge	1206	static enum drm_connector_status
		1207	radeon_dvi_detect(struct drm_connector *connector, bool force)
1123	serge	1208	{
1963	serge	1209	struct drm_device *dev = connector->dev;
		1210	struct radeon_device *rdev = dev->dev_private;
1123	serge	1211	struct radeon_connector *radeon_connector = to_radeon_connector(connector);
1179	serge	1212	struct drm_encoder *encoder = NULL;
6104	serge	1213	const struct drm_encoder_helper_funcs *encoder_funcs;
5078	serge	1214	int i, r;
1123	serge	1215	enum drm_connector_status ret = connector_status_disconnected;
3120	serge	1216	bool dret = false, broken_edid = false;
1123	serge	1217
6321	serge	1218	r = pm_runtime_get_sync(connector->dev->dev);
		1219	if (r < 0)
		1220	return connector_status_disconnected;
2997	Serge	1221
6321	serge	1222	if (radeon_connector->detected_hpd_without_ddc) {
		1223	force = true;
		1224	radeon_connector->detected_hpd_without_ddc = false;
		1225	}
		1226
5078	serge	1227	if (!force && radeon_check_hpd_status_unchanged(connector)) {
		1228	ret = connector->status;
		1229	goto exit;
		1230	}
		1231
6104	serge	1232	if (radeon_connector->ddc_bus) {
3192	Serge	1233	dret = radeon_ddc_probe(radeon_connector, false);
6104	serge	1234	}
1179	serge	1235	if (dret) {
2997	Serge	1236	radeon_connector->detected_by_load = false;
5078	serge	1237	radeon_connector_free_edid(connector);
		1238	radeon_connector_get_edid(connector);
1179	serge	1239
		1240	if (!radeon_connector->edid) {
1313	serge	1241	DRM_ERROR("%s: probed a monitor but no\|invalid EDID\n",
5078	serge	1242	connector->name);
1986	serge	1243	/* rs690 seems to have a problem with connectors not existing and always
		1244	* return a block of 0's. If we see this just stop polling on this output */
5078	serge	1245	if ((rdev->family == CHIP_RS690 \|\| rdev->family == CHIP_RS740) &&
		1246	radeon_connector->base.null_edid_counter) {
1986	serge	1247	ret = connector_status_disconnected;
5078	serge	1248	DRM_ERROR("%s: detected RS690 floating bus bug, stopping ddc detect\n",
		1249	connector->name);
1986	serge	1250	radeon_connector->ddc_bus = NULL;
3120	serge	1251	} else {
		1252	ret = connector_status_connected;
		1253	broken_edid = true; /* defer use_digital to later */
1986	serge	1254	}
1179	serge	1255	} else {
5078	serge	1256	radeon_connector->use_digital =
		1257	!!(radeon_connector->edid->input & DRM_EDID_INPUT_DIGITAL);
1179	serge	1258
1268	serge	1259	/* some oems have boards with separate digital and analog connectors
		1260	* with a shared ddc line (often vga + hdmi)
		1261	*/
		1262	if ((!radeon_connector->use_digital) && radeon_connector->shared_ddc) {
5078	serge	1263	radeon_connector_free_edid(connector);
1268	serge	1264	ret = connector_status_disconnected;
5078	serge	1265	} else {
6104	serge	1266	ret = connector_status_connected;
5078	serge	1267	}
1963	serge	1268	/* This gets complicated. We have boards with VGA + HDMI with a
		1269	* shared DDC line and we have boards with DVI-D + HDMI with a shared
		1270	* DDC line. The latter is more complex because with DVI<->HDMI adapters
		1271	* you don't really know what's connected to which port as both are digital.
1321	serge	1272	*/
1428	serge	1273	if (radeon_connector->shared_ddc && (ret == connector_status_connected)) {
1321	serge	1274	struct drm_connector *list_connector;
		1275	struct radeon_connector *list_radeon_connector;
		1276	list_for_each_entry(list_connector, &dev->mode_config.connector_list, head) {
		1277	if (connector == list_connector)
		1278	continue;
		1279	list_radeon_connector = to_radeon_connector(list_connector);
1963	serge	1280	if (list_radeon_connector->shared_ddc &&
		1281	(list_radeon_connector->ddc_bus->rec.i2c_id ==
		1282	radeon_connector->ddc_bus->rec.i2c_id)) {
		1283	/* cases where both connectors are digital */
		1284	if (list_connector->connector_type != DRM_MODE_CONNECTOR_VGA) {
		1285	/* hpd is our only option in this case */
		1286	if (!radeon_hpd_sense(rdev, radeon_connector->hpd.hpd)) {
5078	serge	1287	radeon_connector_free_edid(connector);
1321	serge	1288	ret = connector_status_disconnected;
		1289	}
		1290	}
		1291	}
		1292	}
		1293	}
1179	serge	1294	}
		1295	}
		1296
		1297	if ((ret == connector_status_connected) && (radeon_connector->use_digital == true))
		1298	goto out;
		1299
2997	Serge	1300	/* DVI-D and HDMI-A are digital only */
		1301	if ((connector->connector_type == DRM_MODE_CONNECTOR_DVID) \|\|
		1302	(connector->connector_type == DRM_MODE_CONNECTOR_HDMIA))
		1303	goto out;
		1304
		1305	/* if we aren't forcing don't do destructive polling */
1963	serge	1306	if (!force) {
2997	Serge	1307	/* only return the previous status if we last
		1308	* detected a monitor via load.
		1309	*/
		1310	if (radeon_connector->detected_by_load)
6104	serge	1311	ret = connector->status;
1963	serge	1312	goto out;
		1313	}
		1314
1179	serge	1315	/* find analog encoder */
		1316	if (radeon_connector->dac_load_detect) {
1123	serge	1317	for (i = 0; i < DRM_CONNECTOR_MAX_ENCODER; i++) {
		1318	if (connector->encoder_ids[i] == 0)
		1319	break;
		1320
5078	serge	1321	encoder = drm_encoder_find(connector->dev,
		1322	connector->encoder_ids[i]);
		1323	if (!encoder)
1123	serge	1324	continue;
		1325
2997	Serge	1326	if (encoder->encoder_type != DRM_MODE_ENCODER_DAC &&
		1327	encoder->encoder_type != DRM_MODE_ENCODER_TVDAC)
		1328	continue;
		1329
1123	serge	1330	encoder_funcs = encoder->helper_private;
		1331	if (encoder_funcs->detect) {
3120	serge	1332	if (!broken_edid) {
6104	serge	1333	if (ret != connector_status_connected) {
3120	serge	1334	/* deal with analog monitors without DDC */
6104	serge	1335	ret = encoder_funcs->detect(encoder, connector);
		1336	if (ret == connector_status_connected) {
		1337	radeon_connector->use_digital = false;
		1338	}
		1339	if (ret != connector_status_disconnected)
		1340	radeon_connector->detected_by_load = true;
1179	serge	1341	}
3120	serge	1342	} else {
		1343	enum drm_connector_status lret;
		1344	/* assume digital unless load detected otherwise */
		1345	radeon_connector->use_digital = true;
		1346	lret = encoder_funcs->detect(encoder, connector);
		1347	DRM_DEBUG_KMS("load_detect %x returned: %x\n",encoder->encoder_type,lret);
		1348	if (lret == connector_status_connected)
		1349	radeon_connector->use_digital = false;
		1350	}
6104	serge	1351	break;
1123	serge	1352	}
		1353	}
6104	serge	1354	}
1179	serge	1355
		1356	if ((ret == connector_status_connected) && (radeon_connector->use_digital == false) &&
		1357	encoder) {
		1358	ret = radeon_connector_analog_encoder_conflict_solve(connector, encoder, ret, true);
1123	serge	1359	}
		1360
1963	serge	1361	/* RN50 and some RV100 asics in servers often have a hardcoded EDID in the
		1362	* vbios to deal with KVMs. If we have one and are not able to detect a monitor
		1363	* by other means, assume the DFP is connected and use that EDID. In most
		1364	* cases the DVI port is actually a virtual KVM port connected to the service
		1365	* processor.
		1366	*/
2997	Serge	1367	out:
1963	serge	1368	if ((!rdev->is_atom_bios) &&
		1369	(ret == connector_status_disconnected) &&
		1370	rdev->mode_info.bios_hardcoded_edid_size) {
		1371	radeon_connector->use_digital = true;
		1372	ret = connector_status_connected;
		1373	}
		1374
1123	serge	1375	/* updated in get modes as well since we need to know if it's analog or digital */
		1376	radeon_connector_update_scratch_regs(connector, ret);
5078	serge	1377
6104	serge	1378	if ((radeon_audio != 0) && radeon_connector->use_digital) {
		1379	const struct drm_connector_helper_funcs *connector_funcs =
		1380	connector->helper_private;
		1381
		1382	encoder = connector_funcs->best_encoder(connector);
		1383	if (encoder && (encoder->encoder_type == DRM_MODE_ENCODER_TMDS)) {
		1384	radeon_connector_get_edid(connector);
		1385	radeon_audio_detect(connector, encoder, ret);
		1386	}
		1387	}
		1388
5078	serge	1389	exit:
6321	serge	1390	pm_runtime_mark_last_busy(connector->dev->dev);
		1391	pm_runtime_put_autosuspend(connector->dev->dev);
		1392
1123	serge	1393	return ret;
		1394	}
		1395
		1396	/* okay need to be smart in here about which encoder to pick */
2997	Serge	1397	static struct drm_encoder radeon_dvi_encoder(struct drm_connector connector)
1123	serge	1398	{
		1399	int enc_id = connector->encoder_ids[0];
		1400	struct radeon_connector *radeon_connector = to_radeon_connector(connector);
		1401	struct drm_encoder *encoder;
		1402	int i;
		1403	for (i = 0; i < DRM_CONNECTOR_MAX_ENCODER; i++) {
		1404	if (connector->encoder_ids[i] == 0)
		1405	break;
		1406
5078	serge	1407	encoder = drm_encoder_find(connector->dev, connector->encoder_ids[i]);
		1408	if (!encoder)
1123	serge	1409	continue;
		1410
1179	serge	1411	if (radeon_connector->use_digital == true) {
1123	serge	1412	if (encoder->encoder_type == DRM_MODE_ENCODER_TMDS)
		1413	return encoder;
		1414	} else {
		1415	if (encoder->encoder_type == DRM_MODE_ENCODER_DAC \|\|
		1416	encoder->encoder_type == DRM_MODE_ENCODER_TVDAC)
		1417	return encoder;
		1418	}
		1419	}
		1420
		1421	/* see if we have a default encoder TODO */
		1422
		1423	/* then check use digitial */
		1424	/* pick the first one */
5078	serge	1425	if (enc_id)
		1426	return drm_encoder_find(connector->dev, enc_id);
1123	serge	1427	return NULL;
		1428	}
		1429
1221	serge	1430	static void radeon_dvi_force(struct drm_connector *connector)
		1431	{
		1432	struct radeon_connector *radeon_connector = to_radeon_connector(connector);
		1433	if (connector->force == DRM_FORCE_ON)
		1434	radeon_connector->use_digital = false;
		1435	if (connector->force == DRM_FORCE_ON_DIGITAL)
		1436	radeon_connector->use_digital = true;
		1437	}
		1438
1268	serge	1439	static int radeon_dvi_mode_valid(struct drm_connector *connector,
		1440	struct drm_display_mode *mode)
		1441	{
1403	serge	1442	struct drm_device *dev = connector->dev;
		1443	struct radeon_device *rdev = dev->dev_private;
1268	serge	1444	struct radeon_connector *radeon_connector = to_radeon_connector(connector);
		1445
		1446	/* XXX check mode bandwidth */
		1447
1403	serge	1448	/* clocks over 135 MHz have heat issues with DVI on RV100 */
		1449	if (radeon_connector->use_digital &&
		1450	(rdev->family == CHIP_RV100) &&
		1451	(mode->clock > 135000))
		1452	return MODE_CLOCK_HIGH;
		1453
1268	serge	1454	if (radeon_connector->use_digital && (mode->clock > 165000)) {
		1455	if ((radeon_connector->connector_object_id == CONNECTOR_OBJECT_ID_DUAL_LINK_DVI_I) \|\|
		1456	(radeon_connector->connector_object_id == CONNECTOR_OBJECT_ID_DUAL_LINK_DVI_D) \|\|
		1457	(radeon_connector->connector_object_id == CONNECTOR_OBJECT_ID_HDMI_TYPE_B))
		1458	return MODE_OK;
5078	serge	1459	else if (ASIC_IS_DCE6(rdev) && drm_detect_hdmi_monitor(radeon_connector_edid(connector))) {
6104	serge	1460	/* HDMI 1.3+ supports max clock of 340 Mhz */
		1461	if (mode->clock > 340000)
		1462	return MODE_CLOCK_HIGH;
		1463	else
		1464	return MODE_OK;
5078	serge	1465	} else {
1268	serge	1466	return MODE_CLOCK_HIGH;
6104	serge	1467	}
1268	serge	1468	}
1963	serge	1469
		1470	/* check against the max pixel clock */
		1471	if ((mode->clock / 10) > rdev->clock.max_pixel_clock)
		1472	return MODE_CLOCK_HIGH;
		1473
1268	serge	1474	return MODE_OK;
		1475	}
		1476
2997	Serge	1477	static const struct drm_connector_helper_funcs radeon_dvi_connector_helper_funcs = {
5078	serge	1478	.get_modes = radeon_vga_get_modes,
1268	serge	1479	.mode_valid = radeon_dvi_mode_valid,
1123	serge	1480	.best_encoder = radeon_dvi_encoder,
		1481	};
		1482
2997	Serge	1483	static const struct drm_connector_funcs radeon_dvi_connector_funcs = {
1123	serge	1484	.dpms = drm_helper_connector_dpms,
		1485	.detect = radeon_dvi_detect,
		1486	.fill_modes = drm_helper_probe_single_connector_modes,
		1487	.set_property = radeon_connector_set_property,
		1488	.destroy = radeon_connector_destroy,
1221	serge	1489	.force = radeon_dvi_force,
1123	serge	1490	};
		1491
1321	serge	1492	static int radeon_dp_get_modes(struct drm_connector *connector)
		1493	{
		1494	struct radeon_connector *radeon_connector = to_radeon_connector(connector);
1963	serge	1495	struct radeon_connector_atom_dig *radeon_dig_connector = radeon_connector->con_priv;
1986	serge	1496	struct drm_encoder *encoder = radeon_best_single_encoder(connector);
1321	serge	1497	int ret;
		1498
1986	serge	1499	if ((connector->connector_type == DRM_MODE_CONNECTOR_eDP) \|\|
		1500	(connector->connector_type == DRM_MODE_CONNECTOR_LVDS)) {
1963	serge	1501	struct drm_display_mode *mode;
		1502
2997	Serge	1503	if (connector->connector_type == DRM_MODE_CONNECTOR_eDP) {
6104	serge	1504	if (!radeon_dig_connector->edp_on)
		1505	atombios_set_edp_panel_power(connector,
		1506	ATOM_TRANSMITTER_ACTION_POWER_ON);
5078	serge	1507	radeon_connector_get_edid(connector);
		1508	ret = radeon_ddc_get_modes(connector);
6104	serge	1509	if (!radeon_dig_connector->edp_on)
		1510	atombios_set_edp_panel_power(connector,
		1511	ATOM_TRANSMITTER_ACTION_POWER_OFF);
2997	Serge	1512	} else {
		1513	/* need to setup ddc on the bridge */
		1514	if (radeon_connector_encoder_get_dp_bridge_encoder_id(connector) !=
		1515	ENCODER_OBJECT_ID_NONE) {
		1516	if (encoder)
		1517	radeon_atom_ext_encoder_setup_ddc(encoder);
		1518	}
5078	serge	1519	radeon_connector_get_edid(connector);
		1520	ret = radeon_ddc_get_modes(connector);
2997	Serge	1521	}
1963	serge	1522
		1523	if (ret > 0) {
		1524	if (encoder) {
		1525	radeon_fixup_lvds_native_mode(encoder, connector);
		1526	/* add scaled modes */
		1527	radeon_add_common_modes(encoder, connector);
		1528	}
		1529	return ret;
		1530	}
		1531
		1532	if (!encoder)
		1533	return 0;
		1534
		1535	/* we have no EDID modes */
		1536	mode = radeon_fp_native_mode(encoder);
		1537	if (mode) {
		1538	ret = 1;
		1539	drm_mode_probed_add(connector, mode);
		1540	/* add the width/height from vbios tables if available */
		1541	connector->display_info.width_mm = mode->width_mm;
		1542	connector->display_info.height_mm = mode->height_mm;
		1543	/* add scaled modes */
		1544	radeon_add_common_modes(encoder, connector);
6104	serge	1545	}
1986	serge	1546	} else {
		1547	/* need to setup ddc on the bridge */
2997	Serge	1548	if (radeon_connector_encoder_get_dp_bridge_encoder_id(connector) !=
		1549	ENCODER_OBJECT_ID_NONE) {
1986	serge	1550	if (encoder)
		1551	radeon_atom_ext_encoder_setup_ddc(encoder);
		1552	}
5078	serge	1553	radeon_connector_get_edid(connector);
		1554	ret = radeon_ddc_get_modes(connector);
		1555
		1556	radeon_get_native_mode(connector);
1986	serge	1557	}
1963	serge	1558
1321	serge	1559	return ret;
		1560	}
		1561
2997	Serge	1562	u16 radeon_connector_encoder_get_dp_bridge_encoder_id(struct drm_connector *connector)
1321	serge	1563	{
1963	serge	1564	struct drm_encoder *encoder;
		1565	struct radeon_encoder *radeon_encoder;
		1566	int i;
		1567
		1568	for (i = 0; i < DRM_CONNECTOR_MAX_ENCODER; i++) {
		1569	if (connector->encoder_ids[i] == 0)
		1570	break;
		1571
5078	serge	1572	encoder = drm_encoder_find(connector->dev, connector->encoder_ids[i]);
		1573	if (!encoder)
1963	serge	1574	continue;
		1575
		1576	radeon_encoder = to_radeon_encoder(encoder);
		1577
		1578	switch (radeon_encoder->encoder_id) {
		1579	case ENCODER_OBJECT_ID_TRAVIS:
		1580	case ENCODER_OBJECT_ID_NUTMEG:
2997	Serge	1581	return radeon_encoder->encoder_id;
1963	serge	1582	default:
		1583	break;
		1584	}
		1585	}
		1586
2997	Serge	1587	return ENCODER_OBJECT_ID_NONE;
1963	serge	1588	}
		1589
5078	serge	1590	static bool radeon_connector_encoder_is_hbr2(struct drm_connector *connector)
1963	serge	1591	{
		1592	struct drm_encoder *encoder;
		1593	struct radeon_encoder *radeon_encoder;
		1594	int i;
		1595	bool found = false;
		1596
		1597	for (i = 0; i < DRM_CONNECTOR_MAX_ENCODER; i++) {
		1598	if (connector->encoder_ids[i] == 0)
		1599	break;
		1600
5078	serge	1601	encoder = drm_encoder_find(connector->dev, connector->encoder_ids[i]);
		1602	if (!encoder)
1963	serge	1603	continue;
		1604
		1605	radeon_encoder = to_radeon_encoder(encoder);
		1606	if (radeon_encoder->caps & ATOM_ENCODER_CAP_RECORD_HBR2)
		1607	found = true;
		1608	}
		1609
		1610	return found;
		1611	}
		1612
		1613	bool radeon_connector_is_dp12_capable(struct drm_connector *connector)
		1614	{
		1615	struct drm_device *dev = connector->dev;
		1616	struct radeon_device *rdev = dev->dev_private;
		1617
		1618	if (ASIC_IS_DCE5(rdev) &&
5078	serge	1619	(rdev->clock.default_dispclk >= 53900) &&
1963	serge	1620	radeon_connector_encoder_is_hbr2(connector)) {
		1621	return true;
		1622	}
		1623
		1624	return false;
		1625	}
		1626
		1627	static enum drm_connector_status
		1628	radeon_dp_detect(struct drm_connector *connector, bool force)
		1629	{
		1630	struct drm_device *dev = connector->dev;
		1631	struct radeon_device *rdev = dev->dev_private;
1321	serge	1632	struct radeon_connector *radeon_connector = to_radeon_connector(connector);
		1633	enum drm_connector_status ret = connector_status_disconnected;
		1634	struct radeon_connector_atom_dig *radeon_dig_connector = radeon_connector->con_priv;
1986	serge	1635	struct drm_encoder *encoder = radeon_best_single_encoder(connector);
5078	serge	1636	int r;
1321	serge	1637
6104	serge	1638	if (radeon_dig_connector->is_mst)
		1639	return connector_status_disconnected;
3192	Serge	1640
6321	serge	1641	r = pm_runtime_get_sync(connector->dev->dev);
		1642	if (r < 0)
		1643	return connector_status_disconnected;
		1644
5078	serge	1645	if (!force && radeon_check_hpd_status_unchanged(connector)) {
		1646	ret = connector->status;
		1647	goto out;
		1648	}
3192	Serge	1649
5078	serge	1650	radeon_connector_free_edid(connector);
2997	Serge	1651
1986	serge	1652	if ((connector->connector_type == DRM_MODE_CONNECTOR_eDP) \|\|
		1653	(connector->connector_type == DRM_MODE_CONNECTOR_LVDS)) {
1963	serge	1654	if (encoder) {
		1655	struct radeon_encoder *radeon_encoder = to_radeon_encoder(encoder);
		1656	struct drm_display_mode *native_mode = &radeon_encoder->native_mode;
		1657
		1658	/* check if panel is valid */
		1659	if (native_mode->hdisplay >= 320 && native_mode->vdisplay >= 240)
		1660	ret = connector_status_connected;
6104	serge	1661	/* don't fetch the edid from the vbios if ddc fails and runpm is
		1662	* enabled so we report disconnected.
		1663	*/
		1664	if ((rdev->flags & RADEON_IS_PX) && (radeon_runtime_pm != 0))
		1665	ret = connector_status_disconnected;
1963	serge	1666	}
		1667	/* eDP is always DP */
		1668	radeon_dig_connector->dp_sink_type = CONNECTOR_OBJECT_ID_DISPLAYPORT;
		1669	if (!radeon_dig_connector->edp_on)
		1670	atombios_set_edp_panel_power(connector,
		1671	ATOM_TRANSMITTER_ACTION_POWER_ON);
		1672	if (radeon_dp_getdpcd(radeon_connector))
1321	serge	1673	ret = connector_status_connected;
1963	serge	1674	if (!radeon_dig_connector->edp_on)
		1675	atombios_set_edp_panel_power(connector,
		1676	ATOM_TRANSMITTER_ACTION_POWER_OFF);
2997	Serge	1677	} else if (radeon_connector_encoder_get_dp_bridge_encoder_id(connector) !=
		1678	ENCODER_OBJECT_ID_NONE) {
		1679	/* DP bridges are always DP */
		1680	radeon_dig_connector->dp_sink_type = CONNECTOR_OBJECT_ID_DISPLAYPORT;
		1681	/* get the DPCD from the bridge */
		1682	radeon_dp_getdpcd(radeon_connector);
		1683
		1684	if (encoder) {
		1685	/* setup ddc on the bridge */
6104	serge	1686	radeon_atom_ext_encoder_setup_ddc(encoder);
3192	Serge	1687	/* bridge chips are always aux */
		1688	if (radeon_ddc_probe(radeon_connector, true)) /* try DDC */
2997	Serge	1689	ret = connector_status_connected;
		1690	else if (radeon_connector->dac_load_detect) { /* try load detection */
6104	serge	1691	const struct drm_encoder_helper_funcs *encoder_funcs = encoder->helper_private;
2997	Serge	1692	ret = encoder_funcs->detect(encoder, connector);
6104	serge	1693	}
1986	serge	1694	}
2997	Serge	1695	} else {
1963	serge	1696	radeon_dig_connector->dp_sink_type = radeon_dp_getsinktype(radeon_connector);
		1697	if (radeon_hpd_sense(rdev, radeon_connector->hpd.hpd)) {
1321	serge	1698	ret = connector_status_connected;
6104	serge	1699	if (radeon_dig_connector->dp_sink_type == CONNECTOR_OBJECT_ID_DISPLAYPORT) {
1963	serge	1700	radeon_dp_getdpcd(radeon_connector);
6104	serge	1701	r = radeon_dp_mst_probe(radeon_connector);
		1702	if (r == 1)
		1703	ret = connector_status_disconnected;
		1704	}
1963	serge	1705	} else {
6104	serge	1706	if (radeon_dig_connector->dp_sink_type == CONNECTOR_OBJECT_ID_DISPLAYPORT) {
		1707	if (radeon_dp_getdpcd(radeon_connector)) {
		1708	r = radeon_dp_mst_probe(radeon_connector);
		1709	if (r == 1)
		1710	ret = connector_status_disconnected;
		1711	else
		1712	ret = connector_status_connected;
		1713	}
		1714	} else {
5078	serge	1715	/* try non-aux ddc (DP to DVI/HDMI/etc. adapter) */
3192	Serge	1716	if (radeon_ddc_probe(radeon_connector, false))
6104	serge	1717	ret = connector_status_connected;
		1718	}
1321	serge	1719	}
		1720	}
6104	serge	1721
		1722	radeon_connector_update_scratch_regs(connector, ret);
		1723
		1724	if ((radeon_audio != 0) && encoder) {
		1725	radeon_connector_get_edid(connector);
		1726	radeon_audio_detect(connector, encoder, ret);
1963	serge	1727	}
1321	serge	1728
5078	serge	1729	out:
6321	serge	1730	pm_runtime_mark_last_busy(connector->dev->dev);
		1731	pm_runtime_put_autosuspend(connector->dev->dev);
		1732
1321	serge	1733	return ret;
		1734	}
		1735
		1736	static int radeon_dp_mode_valid(struct drm_connector *connector,
		1737	struct drm_display_mode *mode)
		1738	{
5078	serge	1739	struct drm_device *dev = connector->dev;
		1740	struct radeon_device *rdev = dev->dev_private;
1321	serge	1741	struct radeon_connector *radeon_connector = to_radeon_connector(connector);
		1742	struct radeon_connector_atom_dig *radeon_dig_connector = radeon_connector->con_priv;
		1743
		1744	/* XXX check mode bandwidth */
		1745
1986	serge	1746	if ((connector->connector_type == DRM_MODE_CONNECTOR_eDP) \|\|
		1747	(connector->connector_type == DRM_MODE_CONNECTOR_LVDS)) {
1963	serge	1748	struct drm_encoder *encoder = radeon_best_single_encoder(connector);
		1749
		1750	if ((mode->hdisplay < 320) \|\| (mode->vdisplay < 240))
		1751	return MODE_PANEL;
		1752
		1753	if (encoder) {
		1754	struct radeon_encoder *radeon_encoder = to_radeon_encoder(encoder);
		1755	struct drm_display_mode *native_mode = &radeon_encoder->native_mode;
		1756
6104	serge	1757	/* AVIVO hardware supports downscaling modes larger than the panel
1963	serge	1758	* to the panel size, but I'm not sure this is desirable.
		1759	*/
		1760	if ((mode->hdisplay > native_mode->hdisplay) \|\|
		1761	(mode->vdisplay > native_mode->vdisplay))
		1762	return MODE_PANEL;
		1763
		1764	/* if scaling is disabled, block non-native modes */
		1765	if (radeon_encoder->rmx_type == RMX_OFF) {
		1766	if ((mode->hdisplay != native_mode->hdisplay) \|\|
		1767	(mode->vdisplay != native_mode->vdisplay))
		1768	return MODE_PANEL;
		1769	}
		1770	}
		1771	} else {
6104	serge	1772	if ((radeon_dig_connector->dp_sink_type == CONNECTOR_OBJECT_ID_DISPLAYPORT) \|\|
5078	serge	1773	(radeon_dig_connector->dp_sink_type == CONNECTOR_OBJECT_ID_eDP)) {
1963	serge	1774	return radeon_dp_mode_valid_helper(connector, mode);
5078	serge	1775	} else {
		1776	if (ASIC_IS_DCE6(rdev) && drm_detect_hdmi_monitor(radeon_connector_edid(connector))) {
		1777	/* HDMI 1.3+ supports max clock of 340 Mhz */
		1778	if (mode->clock > 340000)
		1779	return MODE_CLOCK_HIGH;
		1780	} else {
		1781	if (mode->clock > 165000)
		1782	return MODE_CLOCK_HIGH;
		1783	}
		1784	}
		1785	}
		1786
6104	serge	1787	return MODE_OK;
1321	serge	1788	}
		1789
2997	Serge	1790	static const struct drm_connector_helper_funcs radeon_dp_connector_helper_funcs = {
1321	serge	1791	.get_modes = radeon_dp_get_modes,
		1792	.mode_valid = radeon_dp_mode_valid,
		1793	.best_encoder = radeon_dvi_encoder,
		1794	};
		1795
2997	Serge	1796	static const struct drm_connector_funcs radeon_dp_connector_funcs = {
1321	serge	1797	.dpms = drm_helper_connector_dpms,
		1798	.detect = radeon_dp_detect,
		1799	.fill_modes = drm_helper_probe_single_connector_modes,
		1800	.set_property = radeon_connector_set_property,
5078	serge	1801	.destroy = radeon_connector_destroy,
1321	serge	1802	.force = radeon_dvi_force,
		1803	};
		1804
5078	serge	1805	static const struct drm_connector_funcs radeon_edp_connector_funcs = {
		1806	.dpms = drm_helper_connector_dpms,
		1807	.detect = radeon_dp_detect,
		1808	.fill_modes = drm_helper_probe_single_connector_modes,
		1809	.set_property = radeon_lvds_set_property,
		1810	.destroy = radeon_connector_destroy,
		1811	.force = radeon_dvi_force,
		1812	};
		1813
		1814	static const struct drm_connector_funcs radeon_lvds_bridge_connector_funcs = {
		1815	.dpms = drm_helper_connector_dpms,
		1816	.detect = radeon_dp_detect,
		1817	.fill_modes = drm_helper_probe_single_connector_modes,
		1818	.set_property = radeon_lvds_set_property,
		1819	.destroy = radeon_connector_destroy,
		1820	.force = radeon_dvi_force,
		1821	};
		1822
1123	serge	1823	void
		1824	radeon_add_atom_connector(struct drm_device *dev,
		1825	uint32_t connector_id,
		1826	uint32_t supported_device,
		1827	int connector_type,
		1828	struct radeon_i2c_bus_rec *i2c_bus,
1268	serge	1829	uint32_t igp_lane_info,
1321	serge	1830	uint16_t connector_object_id,
1963	serge	1831	struct radeon_hpd *hpd,
		1832	struct radeon_router *router)
1123	serge	1833	{
1179	serge	1834	struct radeon_device *rdev = dev->dev_private;
1123	serge	1835	struct drm_connector *connector;
		1836	struct radeon_connector *radeon_connector;
		1837	struct radeon_connector_atom_dig *radeon_dig_connector;
1963	serge	1838	struct drm_encoder *encoder;
		1839	struct radeon_encoder *radeon_encoder;
1123	serge	1840	uint32_t subpixel_order = SubPixelNone;
1268	serge	1841	bool shared_ddc = false;
1963	serge	1842	bool is_dp_bridge = false;
5078	serge	1843	bool has_aux = false;
1123	serge	1844
1179	serge	1845	if (connector_type == DRM_MODE_CONNECTOR_Unknown)
1123	serge	1846	return;
		1847
1963	serge	1848	/* if the user selected tv=0 don't try and add the connector */
		1849	if (((connector_type == DRM_MODE_CONNECTOR_SVIDEO) \|\|
		1850	(connector_type == DRM_MODE_CONNECTOR_Composite) \|\|
		1851	(connector_type == DRM_MODE_CONNECTOR_9PinDIN)) &&
		1852	(radeon_tv == 0))
		1853	return;
		1854
1123	serge	1855	/* see if we already added it */
		1856	list_for_each_entry(connector, &dev->mode_config.connector_list, head) {
		1857	radeon_connector = to_radeon_connector(connector);
		1858	if (radeon_connector->connector_id == connector_id) {
		1859	radeon_connector->devices \|= supported_device;
		1860	return;
		1861	}
1268	serge	1862	if (radeon_connector->ddc_bus && i2c_bus->valid) {
1428	serge	1863	if (radeon_connector->ddc_bus->rec.i2c_id == i2c_bus->i2c_id) {
1268	serge	1864	radeon_connector->shared_ddc = true;
		1865	shared_ddc = true;
		1866	}
1963	serge	1867	if (radeon_connector->router_bus && router->ddc_valid &&
		1868	(radeon_connector->router.router_id == router->router_id)) {
		1869	radeon_connector->shared_ddc = false;
		1870	shared_ddc = false;
		1871	}
1268	serge	1872	}
1123	serge	1873	}
		1874
1963	serge	1875	/* check if it's a dp bridge */
		1876	list_for_each_entry(encoder, &dev->mode_config.encoder_list, head) {
		1877	radeon_encoder = to_radeon_encoder(encoder);
		1878	if (radeon_encoder->devices & supported_device) {
		1879	switch (radeon_encoder->encoder_id) {
		1880	case ENCODER_OBJECT_ID_TRAVIS:
		1881	case ENCODER_OBJECT_ID_NUTMEG:
		1882	is_dp_bridge = true;
		1883	break;
		1884	default:
		1885	break;
		1886	}
		1887	}
		1888	}
		1889
1123	serge	1890	radeon_connector = kzalloc(sizeof(struct radeon_connector), GFP_KERNEL);
		1891	if (!radeon_connector)
		1892	return;
		1893
		1894	connector = &radeon_connector->base;
		1895
		1896	radeon_connector->connector_id = connector_id;
		1897	radeon_connector->devices = supported_device;
1268	serge	1898	radeon_connector->shared_ddc = shared_ddc;
		1899	radeon_connector->connector_object_id = connector_object_id;
1321	serge	1900	radeon_connector->hpd = *hpd;
2997	Serge	1901
1963	serge	1902	radeon_connector->router = *router;
		1903	if (router->ddc_valid \|\| router->cd_valid) {
		1904	radeon_connector->router_bus = radeon_i2c_lookup(rdev, &router->i2c_info);
		1905	if (!radeon_connector->router_bus)
		1906	DRM_ERROR("Failed to assign router i2c bus! Check dmesg for i2c errors.\n");
		1907	}
		1908
		1909	if (is_dp_bridge) {
		1910	radeon_dig_connector = kzalloc(sizeof(struct radeon_connector_atom_dig), GFP_KERNEL);
		1911	if (!radeon_dig_connector)
		1912	goto failed;
		1913	radeon_dig_connector->igp_lane_info = igp_lane_info;
		1914	radeon_connector->con_priv = radeon_dig_connector;
		1915	if (i2c_bus->valid) {
5078	serge	1916	radeon_connector->ddc_bus = radeon_i2c_lookup(rdev, i2c_bus);
		1917	if (radeon_connector->ddc_bus)
		1918	has_aux = true;
1963	serge	1919	else
		1920	DRM_ERROR("DP: Failed to assign ddc bus! Check dmesg for i2c errors.\n");
		1921	}
6104	serge	1922	switch (connector_type) {
		1923	case DRM_MODE_CONNECTOR_VGA:
1963	serge	1924	case DRM_MODE_CONNECTOR_DVIA:
		1925	default:
5078	serge	1926	drm_connector_init(dev, &radeon_connector->base,
		1927	&radeon_dp_connector_funcs, connector_type);
		1928	drm_connector_helper_add(&radeon_connector->base,
		1929	&radeon_dp_connector_helper_funcs);
1963	serge	1930	connector->interlace_allowed = true;
		1931	connector->doublescan_allowed = true;
1986	serge	1932	radeon_connector->dac_load_detect = true;
3192	Serge	1933	drm_object_attach_property(&radeon_connector->base.base,
1986	serge	1934	rdev->mode_info.load_detect_property,
		1935	1);
5078	serge	1936	drm_object_attach_property(&radeon_connector->base.base,
		1937	dev->mode_config.scaling_mode_property,
		1938	DRM_MODE_SCALE_NONE);
6104	serge	1939	if (ASIC_IS_DCE5(rdev))
		1940	drm_object_attach_property(&radeon_connector->base.base,
		1941	rdev->mode_info.output_csc_property,
		1942	RADEON_OUTPUT_CSC_BYPASS);
1963	serge	1943	break;
		1944	case DRM_MODE_CONNECTOR_DVII:
		1945	case DRM_MODE_CONNECTOR_DVID:
		1946	case DRM_MODE_CONNECTOR_HDMIA:
		1947	case DRM_MODE_CONNECTOR_HDMIB:
		1948	case DRM_MODE_CONNECTOR_DisplayPort:
5078	serge	1949	drm_connector_init(dev, &radeon_connector->base,
		1950	&radeon_dp_connector_funcs, connector_type);
		1951	drm_connector_helper_add(&radeon_connector->base,
		1952	&radeon_dp_connector_helper_funcs);
3192	Serge	1953	drm_object_attach_property(&radeon_connector->base.base,
1963	serge	1954	rdev->mode_info.underscan_property,
		1955	UNDERSCAN_OFF);
3192	Serge	1956	drm_object_attach_property(&radeon_connector->base.base,
1963	serge	1957	rdev->mode_info.underscan_hborder_property,
		1958	0);
3192	Serge	1959	drm_object_attach_property(&radeon_connector->base.base,
1963	serge	1960	rdev->mode_info.underscan_vborder_property,
		1961	0);
5078	serge	1962
		1963	drm_object_attach_property(&radeon_connector->base.base,
		1964	dev->mode_config.scaling_mode_property,
		1965	DRM_MODE_SCALE_NONE);
		1966
		1967	drm_object_attach_property(&radeon_connector->base.base,
		1968	rdev->mode_info.dither_property,
		1969	RADEON_FMT_DITHER_DISABLE);
		1970
6661	serge	1971	if (radeon_audio != 0) {
6104	serge	1972	drm_object_attach_property(&radeon_connector->base.base,
		1973	rdev->mode_info.audio_property,
5078	serge	1974	RADEON_AUDIO_AUTO);
6661	serge	1975	radeon_connector->audio = RADEON_AUDIO_AUTO;
		1976	}
6104	serge	1977	if (ASIC_IS_DCE5(rdev))
		1978	drm_object_attach_property(&radeon_connector->base.base,
		1979	rdev->mode_info.output_csc_property,
		1980	RADEON_OUTPUT_CSC_BYPASS);
5078	serge	1981
1963	serge	1982	subpixel_order = SubPixelHorizontalRGB;
		1983	connector->interlace_allowed = true;
		1984	if (connector_type == DRM_MODE_CONNECTOR_HDMIB)
		1985	connector->doublescan_allowed = true;
		1986	else
		1987	connector->doublescan_allowed = false;
1986	serge	1988	if (connector_type == DRM_MODE_CONNECTOR_DVII) {
		1989	radeon_connector->dac_load_detect = true;
3192	Serge	1990	drm_object_attach_property(&radeon_connector->base.base,
1986	serge	1991	rdev->mode_info.load_detect_property,
		1992	1);
		1993	}
1963	serge	1994	break;
		1995	case DRM_MODE_CONNECTOR_LVDS:
		1996	case DRM_MODE_CONNECTOR_eDP:
5078	serge	1997	drm_connector_init(dev, &radeon_connector->base,
		1998	&radeon_lvds_bridge_connector_funcs, connector_type);
		1999	drm_connector_helper_add(&radeon_connector->base,
		2000	&radeon_dp_connector_helper_funcs);
3192	Serge	2001	drm_object_attach_property(&radeon_connector->base.base,
1963	serge	2002	dev->mode_config.scaling_mode_property,
		2003	DRM_MODE_SCALE_FULLSCREEN);
		2004	subpixel_order = SubPixelHorizontalRGB;
		2005	connector->interlace_allowed = false;
		2006	connector->doublescan_allowed = false;
		2007	break;
		2008	}
		2009	} else {
		2010	switch (connector_type) {
		2011	case DRM_MODE_CONNECTOR_VGA:
6104	serge	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("VGA: 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;
6938	serge	2033	connector->polled = DRM_CONNECTOR_POLL_CONNECT;
6104	serge	2034	connector->interlace_allowed = true;
		2035	connector->doublescan_allowed = true;
		2036	break;
		2037	case DRM_MODE_CONNECTOR_DVIA:
		2038	drm_connector_init(dev, &radeon_connector->base, &radeon_vga_connector_funcs, connector_type);
		2039	drm_connector_helper_add(&radeon_connector->base, &radeon_vga_connector_helper_funcs);
		2040	if (i2c_bus->valid) {
		2041	radeon_connector->ddc_bus = radeon_i2c_lookup(rdev, i2c_bus);
		2042	if (!radeon_connector->ddc_bus)
		2043	DRM_ERROR("DVIA: Failed to assign ddc bus! Check dmesg for i2c errors.\n");
		2044	}
		2045	radeon_connector->dac_load_detect = true;
3192	Serge	2046	drm_object_attach_property(&radeon_connector->base.base,
6104	serge	2047	rdev->mode_info.load_detect_property,
		2048	1);
5078	serge	2049	if (ASIC_IS_AVIVO(rdev))
		2050	drm_object_attach_property(&radeon_connector->base.base,
		2051	dev->mode_config.scaling_mode_property,
		2052	DRM_MODE_SCALE_NONE);
6104	serge	2053	if (ASIC_IS_DCE5(rdev))
		2054	drm_object_attach_property(&radeon_connector->base.base,
		2055	rdev->mode_info.output_csc_property,
		2056	RADEON_OUTPUT_CSC_BYPASS);
		2057	/* no HPD on analog connectors */
		2058	radeon_connector->hpd.hpd = RADEON_HPD_NONE;
		2059	connector->interlace_allowed = true;
		2060	connector->doublescan_allowed = true;
		2061	break;
		2062	case DRM_MODE_CONNECTOR_DVII:
		2063	case DRM_MODE_CONNECTOR_DVID:
		2064	radeon_dig_connector = kzalloc(sizeof(struct radeon_connector_atom_dig), GFP_KERNEL);
		2065	if (!radeon_dig_connector)
		2066	goto failed;
		2067	radeon_dig_connector->igp_lane_info = igp_lane_info;
		2068	radeon_connector->con_priv = radeon_dig_connector;
		2069	drm_connector_init(dev, &radeon_connector->base, &radeon_dvi_connector_funcs, connector_type);
		2070	drm_connector_helper_add(&radeon_connector->base, &radeon_dvi_connector_helper_funcs);
		2071	if (i2c_bus->valid) {
		2072	radeon_connector->ddc_bus = radeon_i2c_lookup(rdev, i2c_bus);
		2073	if (!radeon_connector->ddc_bus)
		2074	DRM_ERROR("DVI: Failed to assign ddc bus! Check dmesg for i2c errors.\n");
		2075	}
		2076	subpixel_order = SubPixelHorizontalRGB;
3192	Serge	2077	drm_object_attach_property(&radeon_connector->base.base,
6104	serge	2078	rdev->mode_info.coherent_mode_property,
		2079	1);
		2080	if (ASIC_IS_AVIVO(rdev)) {
3192	Serge	2081	drm_object_attach_property(&radeon_connector->base.base,
6104	serge	2082	rdev->mode_info.underscan_property,
		2083	UNDERSCAN_OFF);
3192	Serge	2084	drm_object_attach_property(&radeon_connector->base.base,
6104	serge	2085	rdev->mode_info.underscan_hborder_property,
		2086	0);
3192	Serge	2087	drm_object_attach_property(&radeon_connector->base.base,
6104	serge	2088	rdev->mode_info.underscan_vborder_property,
		2089	0);
5078	serge	2090	drm_object_attach_property(&radeon_connector->base.base,
		2091	rdev->mode_info.dither_property,
		2092	RADEON_FMT_DITHER_DISABLE);
		2093	drm_object_attach_property(&radeon_connector->base.base,
		2094	dev->mode_config.scaling_mode_property,
		2095	DRM_MODE_SCALE_NONE);
6104	serge	2096	}
5078	serge	2097	if (ASIC_IS_DCE2(rdev) && (radeon_audio != 0)) {
		2098	drm_object_attach_property(&radeon_connector->base.base,
6104	serge	2099	rdev->mode_info.audio_property,
5078	serge	2100	RADEON_AUDIO_AUTO);
6661	serge	2101	radeon_connector->audio = RADEON_AUDIO_AUTO;
5078	serge	2102	}
6104	serge	2103	if (connector_type == DRM_MODE_CONNECTOR_DVII) {
		2104	radeon_connector->dac_load_detect = true;
3192	Serge	2105	drm_object_attach_property(&radeon_connector->base.base,
6104	serge	2106	rdev->mode_info.load_detect_property,
		2107	1);
		2108	}
		2109	if (ASIC_IS_DCE5(rdev))
		2110	drm_object_attach_property(&radeon_connector->base.base,
		2111	rdev->mode_info.output_csc_property,
		2112	RADEON_OUTPUT_CSC_BYPASS);
		2113	connector->interlace_allowed = true;
		2114	if (connector_type == DRM_MODE_CONNECTOR_DVII)
		2115	connector->doublescan_allowed = true;
		2116	else
		2117	connector->doublescan_allowed = false;
		2118	break;
		2119	case DRM_MODE_CONNECTOR_HDMIA:
		2120	case DRM_MODE_CONNECTOR_HDMIB:
		2121	radeon_dig_connector = kzalloc(sizeof(struct radeon_connector_atom_dig), GFP_KERNEL);
		2122	if (!radeon_dig_connector)
		2123	goto failed;
		2124	radeon_dig_connector->igp_lane_info = igp_lane_info;
		2125	radeon_connector->con_priv = radeon_dig_connector;
		2126	drm_connector_init(dev, &radeon_connector->base, &radeon_dvi_connector_funcs, connector_type);
		2127	drm_connector_helper_add(&radeon_connector->base, &radeon_dvi_connector_helper_funcs);
		2128	if (i2c_bus->valid) {
		2129	radeon_connector->ddc_bus = radeon_i2c_lookup(rdev, i2c_bus);
		2130	if (!radeon_connector->ddc_bus)
		2131	DRM_ERROR("HDMI: Failed to assign ddc bus! Check dmesg for i2c errors.\n");
		2132	}
3192	Serge	2133	drm_object_attach_property(&radeon_connector->base.base,
6104	serge	2134	rdev->mode_info.coherent_mode_property,
		2135	1);
		2136	if (ASIC_IS_AVIVO(rdev)) {
3192	Serge	2137	drm_object_attach_property(&radeon_connector->base.base,
6104	serge	2138	rdev->mode_info.underscan_property,
		2139	UNDERSCAN_OFF);
3192	Serge	2140	drm_object_attach_property(&radeon_connector->base.base,
6104	serge	2141	rdev->mode_info.underscan_hborder_property,
		2142	0);
3192	Serge	2143	drm_object_attach_property(&radeon_connector->base.base,
6104	serge	2144	rdev->mode_info.underscan_vborder_property,
		2145	0);
5078	serge	2146	drm_object_attach_property(&radeon_connector->base.base,
		2147	rdev->mode_info.dither_property,
		2148	RADEON_FMT_DITHER_DISABLE);
		2149	drm_object_attach_property(&radeon_connector->base.base,
		2150	dev->mode_config.scaling_mode_property,
		2151	DRM_MODE_SCALE_NONE);
6104	serge	2152	}
5078	serge	2153	if (ASIC_IS_DCE2(rdev) && (radeon_audio != 0)) {
		2154	drm_object_attach_property(&radeon_connector->base.base,
6104	serge	2155	rdev->mode_info.audio_property,
5078	serge	2156	RADEON_AUDIO_AUTO);
6661	serge	2157	radeon_connector->audio = RADEON_AUDIO_AUTO;
5078	serge	2158	}
6104	serge	2159	if (ASIC_IS_DCE5(rdev))
		2160	drm_object_attach_property(&radeon_connector->base.base,
		2161	rdev->mode_info.output_csc_property,
		2162	RADEON_OUTPUT_CSC_BYPASS);
		2163	subpixel_order = SubPixelHorizontalRGB;
		2164	connector->interlace_allowed = true;
		2165	if (connector_type == DRM_MODE_CONNECTOR_HDMIB)
		2166	connector->doublescan_allowed = true;
		2167	else
		2168	connector->doublescan_allowed = false;
		2169	break;
		2170	case DRM_MODE_CONNECTOR_DisplayPort:
		2171	radeon_dig_connector = kzalloc(sizeof(struct radeon_connector_atom_dig), GFP_KERNEL);
		2172	if (!radeon_dig_connector)
		2173	goto failed;
		2174	radeon_dig_connector->igp_lane_info = igp_lane_info;
		2175	radeon_connector->con_priv = radeon_dig_connector;
		2176	drm_connector_init(dev, &radeon_connector->base, &radeon_dp_connector_funcs, connector_type);
		2177	drm_connector_helper_add(&radeon_connector->base, &radeon_dp_connector_helper_funcs);
		2178	if (i2c_bus->valid) {
		2179	radeon_connector->ddc_bus = radeon_i2c_lookup(rdev, i2c_bus);
5078	serge	2180	if (radeon_connector->ddc_bus)
		2181	has_aux = true;
		2182	else
6104	serge	2183	DRM_ERROR("DP: Failed to assign ddc bus! Check dmesg for i2c errors.\n");
		2184	}
		2185	subpixel_order = SubPixelHorizontalRGB;
3192	Serge	2186	drm_object_attach_property(&radeon_connector->base.base,
6104	serge	2187	rdev->mode_info.coherent_mode_property,
		2188	1);
		2189	if (ASIC_IS_AVIVO(rdev)) {
3192	Serge	2190	drm_object_attach_property(&radeon_connector->base.base,
6104	serge	2191	rdev->mode_info.underscan_property,
		2192	UNDERSCAN_OFF);
3192	Serge	2193	drm_object_attach_property(&radeon_connector->base.base,
6104	serge	2194	rdev->mode_info.underscan_hborder_property,
		2195	0);
3192	Serge	2196	drm_object_attach_property(&radeon_connector->base.base,
6104	serge	2197	rdev->mode_info.underscan_vborder_property,
		2198	0);
5078	serge	2199	drm_object_attach_property(&radeon_connector->base.base,
		2200	rdev->mode_info.dither_property,
		2201	RADEON_FMT_DITHER_DISABLE);
		2202	drm_object_attach_property(&radeon_connector->base.base,
		2203	dev->mode_config.scaling_mode_property,
		2204	DRM_MODE_SCALE_NONE);
6104	serge	2205	}
5078	serge	2206	if (ASIC_IS_DCE2(rdev) && (radeon_audio != 0)) {
		2207	drm_object_attach_property(&radeon_connector->base.base,
6104	serge	2208	rdev->mode_info.audio_property,
5078	serge	2209	RADEON_AUDIO_AUTO);
6661	serge	2210	radeon_connector->audio = RADEON_AUDIO_AUTO;
5078	serge	2211	}
6104	serge	2212	if (ASIC_IS_DCE5(rdev))
		2213	drm_object_attach_property(&radeon_connector->base.base,
		2214	rdev->mode_info.output_csc_property,
		2215	RADEON_OUTPUT_CSC_BYPASS);
		2216	connector->interlace_allowed = true;
		2217	/* in theory with a DP to VGA converter... */
		2218	connector->doublescan_allowed = false;
		2219	break;
1963	serge	2220	case DRM_MODE_CONNECTOR_eDP:
		2221	radeon_dig_connector = kzalloc(sizeof(struct radeon_connector_atom_dig), GFP_KERNEL);
		2222	if (!radeon_dig_connector)
		2223	goto failed;
		2224	radeon_dig_connector->igp_lane_info = igp_lane_info;
		2225	radeon_connector->con_priv = radeon_dig_connector;
5078	serge	2226	drm_connector_init(dev, &radeon_connector->base, &radeon_edp_connector_funcs, connector_type);
1963	serge	2227	drm_connector_helper_add(&radeon_connector->base, &radeon_dp_connector_helper_funcs);
		2228	if (i2c_bus->valid) {
		2229	radeon_connector->ddc_bus = radeon_i2c_lookup(rdev, i2c_bus);
5078	serge	2230	if (radeon_connector->ddc_bus)
		2231	has_aux = true;
		2232	else
1963	serge	2233	DRM_ERROR("DP: Failed to assign ddc bus! Check dmesg for i2c errors.\n");
		2234	}
3192	Serge	2235	drm_object_attach_property(&radeon_connector->base.base,
1963	serge	2236	dev->mode_config.scaling_mode_property,
		2237	DRM_MODE_SCALE_FULLSCREEN);
		2238	subpixel_order = SubPixelHorizontalRGB;
		2239	connector->interlace_allowed = false;
		2240	connector->doublescan_allowed = false;
		2241	break;
6104	serge	2242	case DRM_MODE_CONNECTOR_SVIDEO:
		2243	case DRM_MODE_CONNECTOR_Composite:
		2244	case DRM_MODE_CONNECTOR_9PinDIN:
1179	serge	2245	drm_connector_init(dev, &radeon_connector->base, &radeon_tv_connector_funcs, connector_type);
1963	serge	2246	drm_connector_helper_add(&radeon_connector->base, &radeon_tv_connector_helper_funcs);
1221	serge	2247	radeon_connector->dac_load_detect = true;
3192	Serge	2248	drm_object_attach_property(&radeon_connector->base.base,
6104	serge	2249	rdev->mode_info.load_detect_property,
		2250	1);
3192	Serge	2251	drm_object_attach_property(&radeon_connector->base.base,
1321	serge	2252	rdev->mode_info.tv_std_property,
1403	serge	2253	radeon_atombios_get_tv_info(rdev));
1963	serge	2254	/* no HPD on analog connectors */
		2255	radeon_connector->hpd.hpd = RADEON_HPD_NONE;
6104	serge	2256	connector->interlace_allowed = false;
		2257	connector->doublescan_allowed = false;
		2258	break;
		2259	case DRM_MODE_CONNECTOR_LVDS:
		2260	radeon_dig_connector = kzalloc(sizeof(struct radeon_connector_atom_dig), GFP_KERNEL);
		2261	if (!radeon_dig_connector)
		2262	goto failed;
		2263	radeon_dig_connector->igp_lane_info = igp_lane_info;
		2264	radeon_connector->con_priv = radeon_dig_connector;
		2265	drm_connector_init(dev, &radeon_connector->base, &radeon_lvds_connector_funcs, connector_type);
		2266	drm_connector_helper_add(&radeon_connector->base, &radeon_lvds_connector_helper_funcs);
		2267	if (i2c_bus->valid) {
		2268	radeon_connector->ddc_bus = radeon_i2c_lookup(rdev, i2c_bus);
		2269	if (!radeon_connector->ddc_bus)
		2270	DRM_ERROR("LVDS: Failed to assign ddc bus! Check dmesg for i2c errors.\n");
		2271	}
		2272	drm_object_attach_property(&radeon_connector->base.base,
		2273	dev->mode_config.scaling_mode_property,
		2274	DRM_MODE_SCALE_FULLSCREEN);
		2275	subpixel_order = SubPixelHorizontalRGB;
		2276	connector->interlace_allowed = false;
		2277	connector->doublescan_allowed = false;
		2278	break;
1123	serge	2279	}
		2280	}
		2281
1963	serge	2282	if (radeon_connector->hpd.hpd == RADEON_HPD_NONE) {
6938	serge	2283	if (i2c_bus->valid)
		2284	connector->polled = DRM_CONNECTOR_POLL_CONNECT;
1963	serge	2285	} else
		2286	connector->polled = DRM_CONNECTOR_POLL_HPD;
		2287
1123	serge	2288	connector->display_info.subpixel_order = subpixel_order;
5078	serge	2289	drm_connector_register(connector);
		2290
		2291	if (has_aux)
		2292	radeon_dp_aux_init(radeon_connector);
		2293
1123	serge	2294	return;
		2295
		2296	failed:
		2297	drm_connector_cleanup(connector);
		2298	kfree(connector);
		2299	}
		2300
		2301	void
		2302	radeon_add_legacy_connector(struct drm_device *dev,
		2303	uint32_t connector_id,
		2304	uint32_t supported_device,
		2305	int connector_type,
1268	serge	2306	struct radeon_i2c_bus_rec *i2c_bus,
1321	serge	2307	uint16_t connector_object_id,
		2308	struct radeon_hpd *hpd)
1123	serge	2309	{
1179	serge	2310	struct radeon_device *rdev = dev->dev_private;
1123	serge	2311	struct drm_connector *connector;
		2312	struct radeon_connector *radeon_connector;
		2313	uint32_t subpixel_order = SubPixelNone;
		2314
1179	serge	2315	if (connector_type == DRM_MODE_CONNECTOR_Unknown)
1123	serge	2316	return;
		2317
1963	serge	2318	/* if the user selected tv=0 don't try and add the connector */
		2319	if (((connector_type == DRM_MODE_CONNECTOR_SVIDEO) \|\|
		2320	(connector_type == DRM_MODE_CONNECTOR_Composite) \|\|
		2321	(connector_type == DRM_MODE_CONNECTOR_9PinDIN)) &&
		2322	(radeon_tv == 0))
		2323	return;
		2324
1123	serge	2325	/* see if we already added it */
		2326	list_for_each_entry(connector, &dev->mode_config.connector_list, head) {
		2327	radeon_connector = to_radeon_connector(connector);
		2328	if (radeon_connector->connector_id == connector_id) {
		2329	radeon_connector->devices \|= supported_device;
		2330	return;
		2331	}
		2332	}
		2333
		2334	radeon_connector = kzalloc(sizeof(struct radeon_connector), GFP_KERNEL);
		2335	if (!radeon_connector)
		2336	return;
		2337
		2338	connector = &radeon_connector->base;
		2339
		2340	radeon_connector->connector_id = connector_id;
		2341	radeon_connector->devices = supported_device;
1268	serge	2342	radeon_connector->connector_object_id = connector_object_id;
1321	serge	2343	radeon_connector->hpd = *hpd;
2997	Serge	2344
1123	serge	2345	switch (connector_type) {
		2346	case DRM_MODE_CONNECTOR_VGA:
		2347	drm_connector_init(dev, &radeon_connector->base, &radeon_vga_connector_funcs, connector_type);
1963	serge	2348	drm_connector_helper_add(&radeon_connector->base, &radeon_vga_connector_helper_funcs);
1123	serge	2349	if (i2c_bus->valid) {
1963	serge	2350	radeon_connector->ddc_bus = radeon_i2c_lookup(rdev, i2c_bus);
1123	serge	2351	if (!radeon_connector->ddc_bus)
1963	serge	2352	DRM_ERROR("VGA: Failed to assign ddc bus! Check dmesg for i2c errors.\n");
1123	serge	2353	}
1221	serge	2354	radeon_connector->dac_load_detect = true;
3192	Serge	2355	drm_object_attach_property(&radeon_connector->base.base,
1179	serge	2356	rdev->mode_info.load_detect_property,
		2357	1);
1963	serge	2358	/* no HPD on analog connectors */
		2359	radeon_connector->hpd.hpd = RADEON_HPD_NONE;
6938	serge	2360	connector->polled = DRM_CONNECTOR_POLL_CONNECT;
1963	serge	2361	connector->interlace_allowed = true;
		2362	connector->doublescan_allowed = true;
1123	serge	2363	break;
		2364	case DRM_MODE_CONNECTOR_DVIA:
		2365	drm_connector_init(dev, &radeon_connector->base, &radeon_vga_connector_funcs, connector_type);
1963	serge	2366	drm_connector_helper_add(&radeon_connector->base, &radeon_vga_connector_helper_funcs);
1123	serge	2367	if (i2c_bus->valid) {
1963	serge	2368	radeon_connector->ddc_bus = radeon_i2c_lookup(rdev, i2c_bus);
1123	serge	2369	if (!radeon_connector->ddc_bus)
1963	serge	2370	DRM_ERROR("DVIA: Failed to assign ddc bus! Check dmesg for i2c errors.\n");
1123	serge	2371	}
1221	serge	2372	radeon_connector->dac_load_detect = true;
3192	Serge	2373	drm_object_attach_property(&radeon_connector->base.base,
1179	serge	2374	rdev->mode_info.load_detect_property,
		2375	1);
1963	serge	2376	/* no HPD on analog connectors */
		2377	radeon_connector->hpd.hpd = RADEON_HPD_NONE;
		2378	connector->interlace_allowed = true;
		2379	connector->doublescan_allowed = true;
1123	serge	2380	break;
		2381	case DRM_MODE_CONNECTOR_DVII:
		2382	case DRM_MODE_CONNECTOR_DVID:
		2383	drm_connector_init(dev, &radeon_connector->base, &radeon_dvi_connector_funcs, connector_type);
1963	serge	2384	drm_connector_helper_add(&radeon_connector->base, &radeon_dvi_connector_helper_funcs);
1123	serge	2385	if (i2c_bus->valid) {
1963	serge	2386	radeon_connector->ddc_bus = radeon_i2c_lookup(rdev, i2c_bus);
1123	serge	2387	if (!radeon_connector->ddc_bus)
1963	serge	2388	DRM_ERROR("DVI: Failed to assign ddc bus! Check dmesg for i2c errors.\n");
		2389	}
		2390	if (connector_type == DRM_MODE_CONNECTOR_DVII) {
1221	serge	2391	radeon_connector->dac_load_detect = true;
3192	Serge	2392	drm_object_attach_property(&radeon_connector->base.base,
1179	serge	2393	rdev->mode_info.load_detect_property,
		2394	1);
1123	serge	2395	}
		2396	subpixel_order = SubPixelHorizontalRGB;
1963	serge	2397	connector->interlace_allowed = true;
		2398	if (connector_type == DRM_MODE_CONNECTOR_DVII)
		2399	connector->doublescan_allowed = true;
		2400	else
		2401	connector->doublescan_allowed = false;
1123	serge	2402	break;
		2403	case DRM_MODE_CONNECTOR_SVIDEO:
		2404	case DRM_MODE_CONNECTOR_Composite:
		2405	case DRM_MODE_CONNECTOR_9PinDIN:
6104	serge	2406	drm_connector_init(dev, &radeon_connector->base, &radeon_tv_connector_funcs, connector_type);
		2407	drm_connector_helper_add(&radeon_connector->base, &radeon_tv_connector_helper_funcs);
		2408	radeon_connector->dac_load_detect = true;
		2409	/* RS400,RC410,RS480 chipset seems to report a lot
		2410	* of false positive on load detect, we haven't yet
		2411	* found a way to make load detect reliable on those
		2412	* chipset, thus just disable it for TV.
		2413	*/
		2414	if (rdev->family == CHIP_RS400 \|\| rdev->family == CHIP_RS480)
		2415	radeon_connector->dac_load_detect = false;
3192	Serge	2416	drm_object_attach_property(&radeon_connector->base.base,
6104	serge	2417	rdev->mode_info.load_detect_property,
		2418	radeon_connector->dac_load_detect);
3192	Serge	2419	drm_object_attach_property(&radeon_connector->base.base,
6104	serge	2420	rdev->mode_info.tv_std_property,
		2421	radeon_combios_get_tv_info(rdev));
		2422	/* no HPD on analog connectors */
		2423	radeon_connector->hpd.hpd = RADEON_HPD_NONE;
1963	serge	2424	connector->interlace_allowed = false;
		2425	connector->doublescan_allowed = false;
1123	serge	2426	break;
		2427	case DRM_MODE_CONNECTOR_LVDS:
		2428	drm_connector_init(dev, &radeon_connector->base, &radeon_lvds_connector_funcs, connector_type);
1963	serge	2429	drm_connector_helper_add(&radeon_connector->base, &radeon_lvds_connector_helper_funcs);
1123	serge	2430	if (i2c_bus->valid) {
1963	serge	2431	radeon_connector->ddc_bus = radeon_i2c_lookup(rdev, i2c_bus);
1123	serge	2432	if (!radeon_connector->ddc_bus)
1963	serge	2433	DRM_ERROR("LVDS: Failed to assign ddc bus! Check dmesg for i2c errors.\n");
1123	serge	2434	}
3192	Serge	2435	drm_object_attach_property(&radeon_connector->base.base,
1179	serge	2436	dev->mode_config.scaling_mode_property,
		2437	DRM_MODE_SCALE_FULLSCREEN);
1123	serge	2438	subpixel_order = SubPixelHorizontalRGB;
1963	serge	2439	connector->interlace_allowed = false;
		2440	connector->doublescan_allowed = false;
1123	serge	2441	break;
		2442	}
		2443
1963	serge	2444	if (radeon_connector->hpd.hpd == RADEON_HPD_NONE) {
6938	serge	2445	if (i2c_bus->valid)
		2446	connector->polled = DRM_CONNECTOR_POLL_CONNECT;
1963	serge	2447	} else
		2448	connector->polled = DRM_CONNECTOR_POLL_HPD;
1123	serge	2449	connector->display_info.subpixel_order = subpixel_order;
5078	serge	2450	drm_connector_register(connector);
1123	serge	2451	}
6104	serge	2452
		2453	void radeon_setup_mst_connector(struct drm_device *dev)
		2454	{
		2455	struct radeon_device *rdev = dev->dev_private;
		2456	struct drm_connector *connector;
		2457	struct radeon_connector *radeon_connector;
		2458
		2459	if (!ASIC_IS_DCE5(rdev))
		2460	return;
		2461
		2462	if (radeon_mst == 0)
		2463	return;
		2464
		2465	list_for_each_entry(connector, &dev->mode_config.connector_list, head) {
		2466	int ret;
		2467
		2468	radeon_connector = to_radeon_connector(connector);
		2469
		2470	if (connector->connector_type != DRM_MODE_CONNECTOR_DisplayPort)
		2471	continue;
		2472
		2473	ret = radeon_dp_mst_init(radeon_connector);
		2474	}
		2475	}

Subversion Repositories Kolibri OS

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