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

Subversion Repositories Kolibri OS

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