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

Subversion Repositories Kolibri OS

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