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

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

Subversion Repositories Kolibri OS

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