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

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

Subversion Repositories Kolibri OS

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