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;
1404	serge	944	bool dret = false;
1123	serge	945
2997	Serge	946	if (!force && radeon_check_hpd_status_unchanged(connector))
		947	return connector->status;
		948
1430	serge	949	if (radeon_connector->ddc_bus)
2997	Serge	950	dret = radeon_ddc_probe(radeon_connector);
1179	serge	951	if (dret) {
2997	Serge	952	radeon_connector->detected_by_load = false;
1268	serge	953	if (radeon_connector->edid) {
		954	kfree(radeon_connector->edid);
		955	radeon_connector->edid = NULL;
		956	}
1179	serge	957	radeon_connector->edid = drm_get_edid(&radeon_connector->base, &radeon_connector->ddc_bus->adapter);
		958
		959	if (!radeon_connector->edid) {
1313	serge	960	DRM_ERROR("%s: probed a monitor but no\|invalid EDID\n",
1179	serge	961	drm_get_connector_name(connector));
1986	serge	962	/* rs690 seems to have a problem with connectors not existing and always
		963	* return a block of 0's. If we see this just stop polling on this output */
		964	if ((rdev->family == CHIP_RS690 \|\| rdev->family == CHIP_RS740) && radeon_connector->base.null_edid_counter) {
		965	ret = connector_status_disconnected;
		966	DRM_ERROR("%s: detected RS690 floating bus bug, stopping ddc detect\n", drm_get_connector_name(connector));
		967	radeon_connector->ddc_bus = NULL;
		968	}
1179	serge	969	} else {
		970	radeon_connector->use_digital = !!(radeon_connector->edid->input & DRM_EDID_INPUT_DIGITAL);
		971
1268	serge	972	/* some oems have boards with separate digital and analog connectors
		973	* with a shared ddc line (often vga + hdmi)
		974	*/
		975	if ((!radeon_connector->use_digital) && radeon_connector->shared_ddc) {
		976	kfree(radeon_connector->edid);
		977	radeon_connector->edid = NULL;
		978	ret = connector_status_disconnected;
		979	} else
1123	serge	980	ret = connector_status_connected;
1321	serge	981
1963	serge	982	/* This gets complicated. We have boards with VGA + HDMI with a
		983	* shared DDC line and we have boards with DVI-D + HDMI with a shared
		984	* DDC line. The latter is more complex because with DVI<->HDMI adapters
		985	* you don't really know what's connected to which port as both are digital.
1321	serge	986	*/
1428	serge	987	if (radeon_connector->shared_ddc && (ret == connector_status_connected)) {
1321	serge	988	struct drm_connector *list_connector;
		989	struct radeon_connector *list_radeon_connector;
		990	list_for_each_entry(list_connector, &dev->mode_config.connector_list, head) {
		991	if (connector == list_connector)
		992	continue;
		993	list_radeon_connector = to_radeon_connector(list_connector);
1963	serge	994	if (list_radeon_connector->shared_ddc &&
		995	(list_radeon_connector->ddc_bus->rec.i2c_id ==
		996	radeon_connector->ddc_bus->rec.i2c_id)) {
		997	/* cases where both connectors are digital */
		998	if (list_connector->connector_type != DRM_MODE_CONNECTOR_VGA) {
		999	/* hpd is our only option in this case */
		1000	if (!radeon_hpd_sense(rdev, radeon_connector->hpd.hpd)) {
1321	serge	1001	kfree(radeon_connector->edid);
		1002	radeon_connector->edid = NULL;
		1003	ret = connector_status_disconnected;
		1004	}
		1005	}
		1006	}
		1007	}
		1008	}
1179	serge	1009	}
		1010	}
		1011
		1012	if ((ret == connector_status_connected) && (radeon_connector->use_digital == true))
		1013	goto out;
		1014
2997	Serge	1015	/* DVI-D and HDMI-A are digital only */
		1016	if ((connector->connector_type == DRM_MODE_CONNECTOR_DVID) \|\|
		1017	(connector->connector_type == DRM_MODE_CONNECTOR_HDMIA))
		1018	goto out;
		1019
		1020	/* if we aren't forcing don't do destructive polling */
1963	serge	1021	if (!force) {
2997	Serge	1022	/* only return the previous status if we last
		1023	* detected a monitor via load.
		1024	*/
		1025	if (radeon_connector->detected_by_load)
1963	serge	1026	ret = connector->status;
		1027	goto out;
		1028	}
		1029
1179	serge	1030	/* find analog encoder */
		1031	if (radeon_connector->dac_load_detect) {
1123	serge	1032	for (i = 0; i < DRM_CONNECTOR_MAX_ENCODER; i++) {
		1033	if (connector->encoder_ids[i] == 0)
		1034	break;
		1035
		1036	obj = drm_mode_object_find(connector->dev,
		1037	connector->encoder_ids[i],
		1038	DRM_MODE_OBJECT_ENCODER);
		1039	if (!obj)
		1040	continue;
		1041
		1042	encoder = obj_to_encoder(obj);
		1043
2997	Serge	1044	if (encoder->encoder_type != DRM_MODE_ENCODER_DAC &&
		1045	encoder->encoder_type != DRM_MODE_ENCODER_TVDAC)
		1046	continue;
		1047
1123	serge	1048	encoder_funcs = encoder->helper_private;
		1049	if (encoder_funcs->detect) {
1179	serge	1050	if (ret != connector_status_connected) {
1123	serge	1051	ret = encoder_funcs->detect(encoder, connector);
		1052	if (ret == connector_status_connected) {
1179	serge	1053	radeon_connector->use_digital = false;
		1054	}
2997	Serge	1055	if (ret != connector_status_disconnected)
		1056	radeon_connector->detected_by_load = true;
1179	serge	1057	}
1123	serge	1058	break;
		1059	}
		1060	}
		1061	}
1179	serge	1062
		1063	if ((ret == connector_status_connected) && (radeon_connector->use_digital == false) &&
		1064	encoder) {
		1065	ret = radeon_connector_analog_encoder_conflict_solve(connector, encoder, ret, true);
1123	serge	1066	}
		1067
1963	serge	1068	/* RN50 and some RV100 asics in servers often have a hardcoded EDID in the
		1069	* vbios to deal with KVMs. If we have one and are not able to detect a monitor
		1070	* by other means, assume the DFP is connected and use that EDID. In most
		1071	* cases the DVI port is actually a virtual KVM port connected to the service
		1072	* processor.
		1073	*/
2997	Serge	1074	out:
1963	serge	1075	if ((!rdev->is_atom_bios) &&
		1076	(ret == connector_status_disconnected) &&
		1077	rdev->mode_info.bios_hardcoded_edid_size) {
		1078	radeon_connector->use_digital = true;
		1079	ret = connector_status_connected;
		1080	}
		1081
1123	serge	1082	/* updated in get modes as well since we need to know if it's analog or digital */
		1083	radeon_connector_update_scratch_regs(connector, ret);
		1084	return ret;
		1085	}
		1086
		1087	/* okay need to be smart in here about which encoder to pick */
2997	Serge	1088	static struct drm_encoder radeon_dvi_encoder(struct drm_connector connector)
1123	serge	1089	{
		1090	int enc_id = connector->encoder_ids[0];
		1091	struct radeon_connector *radeon_connector = to_radeon_connector(connector);
		1092	struct drm_mode_object *obj;
		1093	struct drm_encoder *encoder;
		1094	int i;
		1095	for (i = 0; i < DRM_CONNECTOR_MAX_ENCODER; i++) {
		1096	if (connector->encoder_ids[i] == 0)
		1097	break;
		1098
		1099	obj = drm_mode_object_find(connector->dev, connector->encoder_ids[i], DRM_MODE_OBJECT_ENCODER);
		1100	if (!obj)
		1101	continue;
		1102
		1103	encoder = obj_to_encoder(obj);
		1104
1179	serge	1105	if (radeon_connector->use_digital == true) {
1123	serge	1106	if (encoder->encoder_type == DRM_MODE_ENCODER_TMDS)
		1107	return encoder;
		1108	} else {
		1109	if (encoder->encoder_type == DRM_MODE_ENCODER_DAC \|\|
		1110	encoder->encoder_type == DRM_MODE_ENCODER_TVDAC)
		1111	return encoder;
		1112	}
		1113	}
		1114
		1115	/* see if we have a default encoder TODO */
		1116
		1117	/* then check use digitial */
		1118	/* pick the first one */
		1119	if (enc_id) {
		1120	obj = drm_mode_object_find(connector->dev, enc_id, DRM_MODE_OBJECT_ENCODER);
		1121	if (!obj)
		1122	return NULL;
		1123	encoder = obj_to_encoder(obj);
		1124	return encoder;
		1125	}
		1126	return NULL;
		1127	}
		1128
1221	serge	1129	static void radeon_dvi_force(struct drm_connector *connector)
		1130	{
		1131	struct radeon_connector *radeon_connector = to_radeon_connector(connector);
		1132	if (connector->force == DRM_FORCE_ON)
		1133	radeon_connector->use_digital = false;
		1134	if (connector->force == DRM_FORCE_ON_DIGITAL)
		1135	radeon_connector->use_digital = true;
		1136	}
		1137
1268	serge	1138	static int radeon_dvi_mode_valid(struct drm_connector *connector,
		1139	struct drm_display_mode *mode)
		1140	{
1403	serge	1141	struct drm_device *dev = connector->dev;
		1142	struct radeon_device *rdev = dev->dev_private;
1268	serge	1143	struct radeon_connector *radeon_connector = to_radeon_connector(connector);
		1144
		1145	/* XXX check mode bandwidth */
		1146
1403	serge	1147	/* clocks over 135 MHz have heat issues with DVI on RV100 */
		1148	if (radeon_connector->use_digital &&
		1149	(rdev->family == CHIP_RV100) &&
		1150	(mode->clock > 135000))
		1151	return MODE_CLOCK_HIGH;
		1152
1268	serge	1153	if (radeon_connector->use_digital && (mode->clock > 165000)) {
		1154	if ((radeon_connector->connector_object_id == CONNECTOR_OBJECT_ID_DUAL_LINK_DVI_I) \|\|
		1155	(radeon_connector->connector_object_id == CONNECTOR_OBJECT_ID_DUAL_LINK_DVI_D) \|\|
		1156	(radeon_connector->connector_object_id == CONNECTOR_OBJECT_ID_HDMI_TYPE_B))
		1157	return MODE_OK;
1963	serge	1158	else if (radeon_connector->connector_object_id == CONNECTOR_OBJECT_ID_HDMI_TYPE_A) {
2997	Serge	1159	if (ASIC_IS_DCE6(rdev)) {
1963	serge	1160	/* HDMI 1.3+ supports max clock of 340 Mhz */
		1161	if (mode->clock > 340000)
		1162	return MODE_CLOCK_HIGH;
1268	serge	1163	else
1963	serge	1164	return MODE_OK;
		1165	} else
		1166	return MODE_CLOCK_HIGH;
		1167	} else
1268	serge	1168	return MODE_CLOCK_HIGH;
		1169	}
1963	serge	1170
		1171	/* check against the max pixel clock */
		1172	if ((mode->clock / 10) > rdev->clock.max_pixel_clock)
		1173	return MODE_CLOCK_HIGH;
		1174
1268	serge	1175	return MODE_OK;
		1176	}
		1177
2997	Serge	1178	static const struct drm_connector_helper_funcs radeon_dvi_connector_helper_funcs = {
1123	serge	1179	.get_modes = radeon_dvi_get_modes,
1268	serge	1180	.mode_valid = radeon_dvi_mode_valid,
1123	serge	1181	.best_encoder = radeon_dvi_encoder,
		1182	};
		1183
2997	Serge	1184	static const struct drm_connector_funcs radeon_dvi_connector_funcs = {
1123	serge	1185	.dpms = drm_helper_connector_dpms,
		1186	.detect = radeon_dvi_detect,
		1187	.fill_modes = drm_helper_probe_single_connector_modes,
		1188	.set_property = radeon_connector_set_property,
		1189	.destroy = radeon_connector_destroy,
1221	serge	1190	.force = radeon_dvi_force,
1123	serge	1191	};
		1192
1321	serge	1193	static void radeon_dp_connector_destroy(struct drm_connector *connector)
		1194	{
		1195	struct radeon_connector *radeon_connector = to_radeon_connector(connector);
		1196	struct radeon_connector_atom_dig *radeon_dig_connector = radeon_connector->con_priv;
		1197
		1198	if (radeon_connector->edid)
		1199	kfree(radeon_connector->edid);
		1200	if (radeon_dig_connector->dp_i2c_bus)
1963	serge	1201	radeon_i2c_destroy(radeon_dig_connector->dp_i2c_bus);
1321	serge	1202	kfree(radeon_connector->con_priv);
2997	Serge	1203	// drm_sysfs_connector_remove(connector);
1321	serge	1204	drm_connector_cleanup(connector);
		1205	kfree(connector);
		1206	}
		1207
		1208	static int radeon_dp_get_modes(struct drm_connector *connector)
		1209	{
		1210	struct radeon_connector *radeon_connector = to_radeon_connector(connector);
1963	serge	1211	struct radeon_connector_atom_dig *radeon_dig_connector = radeon_connector->con_priv;
1986	serge	1212	struct drm_encoder *encoder = radeon_best_single_encoder(connector);
1321	serge	1213	int ret;
		1214
1986	serge	1215	if ((connector->connector_type == DRM_MODE_CONNECTOR_eDP) \|\|
		1216	(connector->connector_type == DRM_MODE_CONNECTOR_LVDS)) {
1963	serge	1217	struct drm_display_mode *mode;
		1218
2997	Serge	1219	if (connector->connector_type == DRM_MODE_CONNECTOR_eDP) {
1963	serge	1220	if (!radeon_dig_connector->edp_on)
		1221	atombios_set_edp_panel_power(connector,
		1222	ATOM_TRANSMITTER_ACTION_POWER_ON);
1321	serge	1223	ret = radeon_ddc_get_modes(radeon_connector);
1963	serge	1224	if (!radeon_dig_connector->edp_on)
		1225	atombios_set_edp_panel_power(connector,
		1226	ATOM_TRANSMITTER_ACTION_POWER_OFF);
2997	Serge	1227	} else {
		1228	/* need to setup ddc on the bridge */
		1229	if (radeon_connector_encoder_get_dp_bridge_encoder_id(connector) !=
		1230	ENCODER_OBJECT_ID_NONE) {
		1231	if (encoder)
		1232	radeon_atom_ext_encoder_setup_ddc(encoder);
		1233	}
		1234	ret = radeon_ddc_get_modes(radeon_connector);
		1235	}
1963	serge	1236
		1237	if (ret > 0) {
		1238	if (encoder) {
		1239	radeon_fixup_lvds_native_mode(encoder, connector);
		1240	/* add scaled modes */
		1241	radeon_add_common_modes(encoder, connector);
		1242	}
		1243	return ret;
		1244	}
		1245
		1246	if (!encoder)
		1247	return 0;
		1248
		1249	/* we have no EDID modes */
		1250	mode = radeon_fp_native_mode(encoder);
		1251	if (mode) {
		1252	ret = 1;
		1253	drm_mode_probed_add(connector, mode);
		1254	/* add the width/height from vbios tables if available */
		1255	connector->display_info.width_mm = mode->width_mm;
		1256	connector->display_info.height_mm = mode->height_mm;
		1257	/* add scaled modes */
		1258	radeon_add_common_modes(encoder, connector);
		1259	}
1986	serge	1260	} else {
		1261	/* need to setup ddc on the bridge */
2997	Serge	1262	if (radeon_connector_encoder_get_dp_bridge_encoder_id(connector) !=
		1263	ENCODER_OBJECT_ID_NONE) {
1986	serge	1264	if (encoder)
		1265	radeon_atom_ext_encoder_setup_ddc(encoder);
		1266	}
1963	serge	1267	ret = radeon_ddc_get_modes(radeon_connector);
1986	serge	1268	}
1963	serge	1269
1321	serge	1270	return ret;
		1271	}
		1272
2997	Serge	1273	u16 radeon_connector_encoder_get_dp_bridge_encoder_id(struct drm_connector *connector)
1321	serge	1274	{
1963	serge	1275	struct drm_mode_object *obj;
		1276	struct drm_encoder *encoder;
		1277	struct radeon_encoder *radeon_encoder;
		1278	int i;
		1279
		1280	for (i = 0; i < DRM_CONNECTOR_MAX_ENCODER; i++) {
		1281	if (connector->encoder_ids[i] == 0)
		1282	break;
		1283
		1284	obj = drm_mode_object_find(connector->dev, connector->encoder_ids[i], DRM_MODE_OBJECT_ENCODER);
		1285	if (!obj)
		1286	continue;
		1287
		1288	encoder = obj_to_encoder(obj);
		1289	radeon_encoder = to_radeon_encoder(encoder);
		1290
		1291	switch (radeon_encoder->encoder_id) {
		1292	case ENCODER_OBJECT_ID_TRAVIS:
		1293	case ENCODER_OBJECT_ID_NUTMEG:
2997	Serge	1294	return radeon_encoder->encoder_id;
1963	serge	1295	default:
		1296	break;
		1297	}
		1298	}
		1299
2997	Serge	1300	return ENCODER_OBJECT_ID_NONE;
1963	serge	1301	}
		1302
		1303	bool radeon_connector_encoder_is_hbr2(struct drm_connector *connector)
		1304	{
		1305	struct drm_mode_object *obj;
		1306	struct drm_encoder *encoder;
		1307	struct radeon_encoder *radeon_encoder;
		1308	int i;
		1309	bool found = false;
		1310
		1311	for (i = 0; i < DRM_CONNECTOR_MAX_ENCODER; i++) {
		1312	if (connector->encoder_ids[i] == 0)
		1313	break;
		1314
		1315	obj = drm_mode_object_find(connector->dev, connector->encoder_ids[i], DRM_MODE_OBJECT_ENCODER);
		1316	if (!obj)
		1317	continue;
		1318
		1319	encoder = obj_to_encoder(obj);
		1320	radeon_encoder = to_radeon_encoder(encoder);
		1321	if (radeon_encoder->caps & ATOM_ENCODER_CAP_RECORD_HBR2)
		1322	found = true;
		1323	}
		1324
		1325	return found;
		1326	}
		1327
		1328	bool radeon_connector_is_dp12_capable(struct drm_connector *connector)
		1329	{
		1330	struct drm_device *dev = connector->dev;
		1331	struct radeon_device *rdev = dev->dev_private;
		1332
		1333	if (ASIC_IS_DCE5(rdev) &&
		1334	(rdev->clock.dp_extclk >= 53900) &&
		1335	radeon_connector_encoder_is_hbr2(connector)) {
		1336	return true;
		1337	}
		1338
		1339	return false;
		1340	}
		1341
		1342	static enum drm_connector_status
		1343	radeon_dp_detect(struct drm_connector *connector, bool force)
		1344	{
		1345	struct drm_device *dev = connector->dev;
		1346	struct radeon_device *rdev = dev->dev_private;
1321	serge	1347	struct radeon_connector *radeon_connector = to_radeon_connector(connector);
		1348	enum drm_connector_status ret = connector_status_disconnected;
		1349	struct radeon_connector_atom_dig *radeon_dig_connector = radeon_connector->con_priv;
1986	serge	1350	struct drm_encoder *encoder = radeon_best_single_encoder(connector);
1321	serge	1351
2997	Serge	1352	if (!force && radeon_check_hpd_status_unchanged(connector))
		1353	return connector->status;
		1354
1321	serge	1355	if (radeon_connector->edid) {
		1356	kfree(radeon_connector->edid);
		1357	radeon_connector->edid = NULL;
		1358	}
		1359
1986	serge	1360	if ((connector->connector_type == DRM_MODE_CONNECTOR_eDP) \|\|
		1361	(connector->connector_type == DRM_MODE_CONNECTOR_LVDS)) {
1963	serge	1362	if (encoder) {
		1363	struct radeon_encoder *radeon_encoder = to_radeon_encoder(encoder);
		1364	struct drm_display_mode *native_mode = &radeon_encoder->native_mode;
		1365
		1366	/* check if panel is valid */
		1367	if (native_mode->hdisplay >= 320 && native_mode->vdisplay >= 240)
		1368	ret = connector_status_connected;
		1369	}
		1370	/* eDP is always DP */
		1371	radeon_dig_connector->dp_sink_type = CONNECTOR_OBJECT_ID_DISPLAYPORT;
		1372	if (!radeon_dig_connector->edp_on)
		1373	atombios_set_edp_panel_power(connector,
		1374	ATOM_TRANSMITTER_ACTION_POWER_ON);
		1375	if (radeon_dp_getdpcd(radeon_connector))
1321	serge	1376	ret = connector_status_connected;
1963	serge	1377	if (!radeon_dig_connector->edp_on)
		1378	atombios_set_edp_panel_power(connector,
		1379	ATOM_TRANSMITTER_ACTION_POWER_OFF);
2997	Serge	1380	} else if (radeon_connector_encoder_get_dp_bridge_encoder_id(connector) !=
		1381	ENCODER_OBJECT_ID_NONE) {
		1382	/* DP bridges are always DP */
		1383	radeon_dig_connector->dp_sink_type = CONNECTOR_OBJECT_ID_DISPLAYPORT;
		1384	/* get the DPCD from the bridge */
		1385	radeon_dp_getdpcd(radeon_connector);
		1386
		1387	if (encoder) {
		1388	/* setup ddc on the bridge */
1986	serge	1389	radeon_atom_ext_encoder_setup_ddc(encoder);
2997	Serge	1390	if (radeon_ddc_probe(radeon_connector)) /* try DDC */
		1391	ret = connector_status_connected;
		1392	else if (radeon_connector->dac_load_detect) { /* try load detection */
		1393	struct drm_encoder_helper_funcs *encoder_funcs = encoder->helper_private;
		1394	ret = encoder_funcs->detect(encoder, connector);
1986	serge	1395	}
2997	Serge	1396	}
		1397	} else {
1963	serge	1398	radeon_dig_connector->dp_sink_type = radeon_dp_getsinktype(radeon_connector);
		1399	if (radeon_hpd_sense(rdev, radeon_connector->hpd.hpd)) {
1321	serge	1400	ret = connector_status_connected;
1963	serge	1401	if (radeon_dig_connector->dp_sink_type == CONNECTOR_OBJECT_ID_DISPLAYPORT)
		1402	radeon_dp_getdpcd(radeon_connector);
		1403	} else {
		1404	if (radeon_dig_connector->dp_sink_type == CONNECTOR_OBJECT_ID_DISPLAYPORT) {
		1405	if (radeon_dp_getdpcd(radeon_connector))
		1406	ret = connector_status_connected;
		1407	} else {
2997	Serge	1408	if (radeon_ddc_probe(radeon_connector))
1963	serge	1409	ret = connector_status_connected;
1321	serge	1410	}
		1411	}
1963	serge	1412	}
1321	serge	1413
1963	serge	1414	radeon_connector_update_scratch_regs(connector, ret);
1321	serge	1415	return ret;
		1416	}
		1417
		1418	static int radeon_dp_mode_valid(struct drm_connector *connector,
		1419	struct drm_display_mode *mode)
		1420	{
		1421	struct radeon_connector *radeon_connector = to_radeon_connector(connector);
		1422	struct radeon_connector_atom_dig *radeon_dig_connector = radeon_connector->con_priv;
		1423
		1424	/* XXX check mode bandwidth */
		1425
1986	serge	1426	if ((connector->connector_type == DRM_MODE_CONNECTOR_eDP) \|\|
		1427	(connector->connector_type == DRM_MODE_CONNECTOR_LVDS)) {
1963	serge	1428	struct drm_encoder *encoder = radeon_best_single_encoder(connector);
		1429
		1430	if ((mode->hdisplay < 320) \|\| (mode->vdisplay < 240))
		1431	return MODE_PANEL;
		1432
		1433	if (encoder) {
		1434	struct radeon_encoder *radeon_encoder = to_radeon_encoder(encoder);
		1435	struct drm_display_mode *native_mode = &radeon_encoder->native_mode;
		1436
		1437	/* AVIVO hardware supports downscaling modes larger than the panel
		1438	* to the panel size, but I'm not sure this is desirable.
		1439	*/
		1440	if ((mode->hdisplay > native_mode->hdisplay) \|\|
		1441	(mode->vdisplay > native_mode->vdisplay))
		1442	return MODE_PANEL;
		1443
		1444	/* if scaling is disabled, block non-native modes */
		1445	if (radeon_encoder->rmx_type == RMX_OFF) {
		1446	if ((mode->hdisplay != native_mode->hdisplay) \|\|
		1447	(mode->vdisplay != native_mode->vdisplay))
		1448	return MODE_PANEL;
		1449	}
		1450	}
		1451	return MODE_OK;
		1452	} else {
1403	serge	1453	if ((radeon_dig_connector->dp_sink_type == CONNECTOR_OBJECT_ID_DISPLAYPORT) \|\|
		1454	(radeon_dig_connector->dp_sink_type == CONNECTOR_OBJECT_ID_eDP))
1963	serge	1455	return radeon_dp_mode_valid_helper(connector, mode);
1321	serge	1456	else
		1457	return MODE_OK;
1963	serge	1458	}
1321	serge	1459	}
		1460
2997	Serge	1461	static const struct drm_connector_helper_funcs radeon_dp_connector_helper_funcs = {
1321	serge	1462	.get_modes = radeon_dp_get_modes,
		1463	.mode_valid = radeon_dp_mode_valid,
		1464	.best_encoder = radeon_dvi_encoder,
		1465	};
		1466
2997	Serge	1467	static const struct drm_connector_funcs radeon_dp_connector_funcs = {
1321	serge	1468	.dpms = drm_helper_connector_dpms,
		1469	.detect = radeon_dp_detect,
		1470	.fill_modes = drm_helper_probe_single_connector_modes,
		1471	.set_property = radeon_connector_set_property,
		1472	.destroy = radeon_dp_connector_destroy,
		1473	.force = radeon_dvi_force,
		1474	};
		1475
1123	serge	1476	void
		1477	radeon_add_atom_connector(struct drm_device *dev,
		1478	uint32_t connector_id,
		1479	uint32_t supported_device,
		1480	int connector_type,
		1481	struct radeon_i2c_bus_rec *i2c_bus,
1268	serge	1482	uint32_t igp_lane_info,
1321	serge	1483	uint16_t connector_object_id,
1963	serge	1484	struct radeon_hpd *hpd,
		1485	struct radeon_router *router)
1123	serge	1486	{
1179	serge	1487	struct radeon_device *rdev = dev->dev_private;
1123	serge	1488	struct drm_connector *connector;
		1489	struct radeon_connector *radeon_connector;
		1490	struct radeon_connector_atom_dig *radeon_dig_connector;
1963	serge	1491	struct drm_encoder *encoder;
		1492	struct radeon_encoder *radeon_encoder;
1123	serge	1493	uint32_t subpixel_order = SubPixelNone;
1268	serge	1494	bool shared_ddc = false;
1963	serge	1495	bool is_dp_bridge = false;
1123	serge	1496
1179	serge	1497	if (connector_type == DRM_MODE_CONNECTOR_Unknown)
1123	serge	1498	return;
		1499
1963	serge	1500	/* if the user selected tv=0 don't try and add the connector */
		1501	if (((connector_type == DRM_MODE_CONNECTOR_SVIDEO) \|\|
		1502	(connector_type == DRM_MODE_CONNECTOR_Composite) \|\|
		1503	(connector_type == DRM_MODE_CONNECTOR_9PinDIN)) &&
		1504	(radeon_tv == 0))
		1505	return;
		1506
1123	serge	1507	/* see if we already added it */
		1508	list_for_each_entry(connector, &dev->mode_config.connector_list, head) {
		1509	radeon_connector = to_radeon_connector(connector);
		1510	if (radeon_connector->connector_id == connector_id) {
		1511	radeon_connector->devices \|= supported_device;
		1512	return;
		1513	}
1268	serge	1514	if (radeon_connector->ddc_bus && i2c_bus->valid) {
1428	serge	1515	if (radeon_connector->ddc_bus->rec.i2c_id == i2c_bus->i2c_id) {
1268	serge	1516	radeon_connector->shared_ddc = true;
		1517	shared_ddc = true;
		1518	}
1963	serge	1519	if (radeon_connector->router_bus && router->ddc_valid &&
		1520	(radeon_connector->router.router_id == router->router_id)) {
		1521	radeon_connector->shared_ddc = false;
		1522	shared_ddc = false;
		1523	}
1268	serge	1524	}
1123	serge	1525	}
		1526
1963	serge	1527	/* check if it's a dp bridge */
		1528	list_for_each_entry(encoder, &dev->mode_config.encoder_list, head) {
		1529	radeon_encoder = to_radeon_encoder(encoder);
		1530	if (radeon_encoder->devices & supported_device) {
		1531	switch (radeon_encoder->encoder_id) {
		1532	case ENCODER_OBJECT_ID_TRAVIS:
		1533	case ENCODER_OBJECT_ID_NUTMEG:
		1534	is_dp_bridge = true;
		1535	break;
		1536	default:
		1537	break;
		1538	}
		1539	}
		1540	}
		1541
1123	serge	1542	radeon_connector = kzalloc(sizeof(struct radeon_connector), GFP_KERNEL);
		1543	if (!radeon_connector)
		1544	return;
		1545
		1546	connector = &radeon_connector->base;
		1547
		1548	radeon_connector->connector_id = connector_id;
		1549	radeon_connector->devices = supported_device;
1268	serge	1550	radeon_connector->shared_ddc = shared_ddc;
		1551	radeon_connector->connector_object_id = connector_object_id;
1321	serge	1552	radeon_connector->hpd = *hpd;
2997	Serge	1553
1963	serge	1554	radeon_connector->router = *router;
		1555	if (router->ddc_valid \|\| router->cd_valid) {
		1556	radeon_connector->router_bus = radeon_i2c_lookup(rdev, &router->i2c_info);
		1557	if (!radeon_connector->router_bus)
		1558	DRM_ERROR("Failed to assign router i2c bus! Check dmesg for i2c errors.\n");
		1559	}
		1560
		1561	if (is_dp_bridge) {
		1562	radeon_dig_connector = kzalloc(sizeof(struct radeon_connector_atom_dig), GFP_KERNEL);
		1563	if (!radeon_dig_connector)
		1564	goto failed;
		1565	radeon_dig_connector->igp_lane_info = igp_lane_info;
		1566	radeon_connector->con_priv = radeon_dig_connector;
		1567	drm_connector_init(dev, &radeon_connector->base, &radeon_dp_connector_funcs, connector_type);
		1568	drm_connector_helper_add(&radeon_connector->base, &radeon_dp_connector_helper_funcs);
		1569	if (i2c_bus->valid) {
		1570	/* add DP i2c bus */
		1571	if (connector_type == DRM_MODE_CONNECTOR_eDP)
		1572	radeon_dig_connector->dp_i2c_bus = radeon_i2c_create_dp(dev, i2c_bus, "eDP-auxch");
		1573	else
		1574	radeon_dig_connector->dp_i2c_bus = radeon_i2c_create_dp(dev, i2c_bus, "DP-auxch");
		1575	if (!radeon_dig_connector->dp_i2c_bus)
		1576	DRM_ERROR("DP: Failed to assign dp ddc bus! Check dmesg for i2c errors.\n");
		1577	radeon_connector->ddc_bus = radeon_i2c_lookup(rdev, i2c_bus);
		1578	if (!radeon_connector->ddc_bus)
		1579	DRM_ERROR("DP: Failed to assign ddc bus! Check dmesg for i2c errors.\n");
		1580	}
1123	serge	1581	switch (connector_type) {
		1582	case DRM_MODE_CONNECTOR_VGA:
1963	serge	1583	case DRM_MODE_CONNECTOR_DVIA:
		1584	default:
		1585	connector->interlace_allowed = true;
		1586	connector->doublescan_allowed = true;
1986	serge	1587	radeon_connector->dac_load_detect = true;
		1588	drm_connector_attach_property(&radeon_connector->base,
		1589	rdev->mode_info.load_detect_property,
		1590	1);
1963	serge	1591	break;
		1592	case DRM_MODE_CONNECTOR_DVII:
		1593	case DRM_MODE_CONNECTOR_DVID:
		1594	case DRM_MODE_CONNECTOR_HDMIA:
		1595	case DRM_MODE_CONNECTOR_HDMIB:
		1596	case DRM_MODE_CONNECTOR_DisplayPort:
		1597	drm_connector_attach_property(&radeon_connector->base,
		1598	rdev->mode_info.underscan_property,
		1599	UNDERSCAN_OFF);
		1600	drm_connector_attach_property(&radeon_connector->base,
		1601	rdev->mode_info.underscan_hborder_property,
		1602	0);
		1603	drm_connector_attach_property(&radeon_connector->base,
		1604	rdev->mode_info.underscan_vborder_property,
		1605	0);
		1606	subpixel_order = SubPixelHorizontalRGB;
		1607	connector->interlace_allowed = true;
		1608	if (connector_type == DRM_MODE_CONNECTOR_HDMIB)
		1609	connector->doublescan_allowed = true;
		1610	else
		1611	connector->doublescan_allowed = false;
1986	serge	1612	if (connector_type == DRM_MODE_CONNECTOR_DVII) {
		1613	radeon_connector->dac_load_detect = true;
		1614	drm_connector_attach_property(&radeon_connector->base,
		1615	rdev->mode_info.load_detect_property,
		1616	1);
		1617	}
1963	serge	1618	break;
		1619	case DRM_MODE_CONNECTOR_LVDS:
		1620	case DRM_MODE_CONNECTOR_eDP:
		1621	drm_connector_attach_property(&radeon_connector->base,
		1622	dev->mode_config.scaling_mode_property,
		1623	DRM_MODE_SCALE_FULLSCREEN);
		1624	subpixel_order = SubPixelHorizontalRGB;
		1625	connector->interlace_allowed = false;
		1626	connector->doublescan_allowed = false;
		1627	break;
		1628	}
		1629	} else {
		1630	switch (connector_type) {
		1631	case DRM_MODE_CONNECTOR_VGA:
1123	serge	1632	drm_connector_init(dev, &radeon_connector->base, &radeon_vga_connector_funcs, connector_type);
1963	serge	1633	drm_connector_helper_add(&radeon_connector->base, &radeon_vga_connector_helper_funcs);
1123	serge	1634	if (i2c_bus->valid) {
1963	serge	1635	radeon_connector->ddc_bus = radeon_i2c_lookup(rdev, i2c_bus);
1123	serge	1636	if (!radeon_connector->ddc_bus)
1963	serge	1637	DRM_ERROR("VGA: Failed to assign ddc bus! Check dmesg for i2c errors.\n");
1123	serge	1638	}
1221	serge	1639	radeon_connector->dac_load_detect = true;
1179	serge	1640	drm_connector_attach_property(&radeon_connector->base,
		1641	rdev->mode_info.load_detect_property,
		1642	1);
1963	serge	1643	/* no HPD on analog connectors */
		1644	radeon_connector->hpd.hpd = RADEON_HPD_NONE;
		1645	connector->polled = DRM_CONNECTOR_POLL_CONNECT;
		1646	connector->interlace_allowed = true;
		1647	connector->doublescan_allowed = true;
1123	serge	1648	break;
		1649	case DRM_MODE_CONNECTOR_DVIA:
		1650	drm_connector_init(dev, &radeon_connector->base, &radeon_vga_connector_funcs, connector_type);
1963	serge	1651	drm_connector_helper_add(&radeon_connector->base, &radeon_vga_connector_helper_funcs);
1123	serge	1652	if (i2c_bus->valid) {
1963	serge	1653	radeon_connector->ddc_bus = radeon_i2c_lookup(rdev, i2c_bus);
1123	serge	1654	if (!radeon_connector->ddc_bus)
1963	serge	1655	DRM_ERROR("DVIA: Failed to assign ddc bus! Check dmesg for i2c errors.\n");
1123	serge	1656	}
1221	serge	1657	radeon_connector->dac_load_detect = true;
1179	serge	1658	drm_connector_attach_property(&radeon_connector->base,
		1659	rdev->mode_info.load_detect_property,
		1660	1);
1963	serge	1661	/* no HPD on analog connectors */
		1662	radeon_connector->hpd.hpd = RADEON_HPD_NONE;
		1663	connector->interlace_allowed = true;
		1664	connector->doublescan_allowed = true;
1123	serge	1665	break;
		1666	case DRM_MODE_CONNECTOR_DVII:
		1667	case DRM_MODE_CONNECTOR_DVID:
		1668	radeon_dig_connector = kzalloc(sizeof(struct radeon_connector_atom_dig), GFP_KERNEL);
		1669	if (!radeon_dig_connector)
		1670	goto failed;
		1671	radeon_dig_connector->igp_lane_info = igp_lane_info;
		1672	radeon_connector->con_priv = radeon_dig_connector;
		1673	drm_connector_init(dev, &radeon_connector->base, &radeon_dvi_connector_funcs, connector_type);
1963	serge	1674	drm_connector_helper_add(&radeon_connector->base, &radeon_dvi_connector_helper_funcs);
1123	serge	1675	if (i2c_bus->valid) {
1963	serge	1676	radeon_connector->ddc_bus = radeon_i2c_lookup(rdev, i2c_bus);
1123	serge	1677	if (!radeon_connector->ddc_bus)
1963	serge	1678	DRM_ERROR("DVI: Failed to assign ddc bus! Check dmesg for i2c errors.\n");
1123	serge	1679	}
		1680	subpixel_order = SubPixelHorizontalRGB;
1179	serge	1681	drm_connector_attach_property(&radeon_connector->base,
		1682	rdev->mode_info.coherent_mode_property,
		1683	1);
1963	serge	1684	if (ASIC_IS_AVIVO(rdev)) {
		1685	drm_connector_attach_property(&radeon_connector->base,
		1686	rdev->mode_info.underscan_property,
		1687	UNDERSCAN_OFF);
		1688	drm_connector_attach_property(&radeon_connector->base,
		1689	rdev->mode_info.underscan_hborder_property,
		1690	0);
		1691	drm_connector_attach_property(&radeon_connector->base,
		1692	rdev->mode_info.underscan_vborder_property,
		1693	0);
		1694	}
1321	serge	1695	if (connector_type == DRM_MODE_CONNECTOR_DVII) {
1221	serge	1696	radeon_connector->dac_load_detect = true;
1179	serge	1697	drm_connector_attach_property(&radeon_connector->base,
		1698	rdev->mode_info.load_detect_property,
		1699	1);
1321	serge	1700	}
1963	serge	1701	connector->interlace_allowed = true;
		1702	if (connector_type == DRM_MODE_CONNECTOR_DVII)
		1703	connector->doublescan_allowed = true;
		1704	else
		1705	connector->doublescan_allowed = false;
1123	serge	1706	break;
		1707	case DRM_MODE_CONNECTOR_HDMIA:
		1708	case DRM_MODE_CONNECTOR_HDMIB:
		1709	radeon_dig_connector = kzalloc(sizeof(struct radeon_connector_atom_dig), GFP_KERNEL);
		1710	if (!radeon_dig_connector)
		1711	goto failed;
		1712	radeon_dig_connector->igp_lane_info = igp_lane_info;
		1713	radeon_connector->con_priv = radeon_dig_connector;
		1714	drm_connector_init(dev, &radeon_connector->base, &radeon_dvi_connector_funcs, connector_type);
1963	serge	1715	drm_connector_helper_add(&radeon_connector->base, &radeon_dvi_connector_helper_funcs);
1123	serge	1716	if (i2c_bus->valid) {
1963	serge	1717	radeon_connector->ddc_bus = radeon_i2c_lookup(rdev, i2c_bus);
1123	serge	1718	if (!radeon_connector->ddc_bus)
1963	serge	1719	DRM_ERROR("HDMI: Failed to assign ddc bus! Check dmesg for i2c errors.\n");
1123	serge	1720	}
1179	serge	1721	drm_connector_attach_property(&radeon_connector->base,
		1722	rdev->mode_info.coherent_mode_property,
		1723	1);
1963	serge	1724	if (ASIC_IS_AVIVO(rdev)) {
		1725	drm_connector_attach_property(&radeon_connector->base,
		1726	rdev->mode_info.underscan_property,
		1727	UNDERSCAN_OFF);
		1728	drm_connector_attach_property(&radeon_connector->base,
		1729	rdev->mode_info.underscan_hborder_property,
		1730	0);
		1731	drm_connector_attach_property(&radeon_connector->base,
		1732	rdev->mode_info.underscan_vborder_property,
		1733	0);
		1734	}
1123	serge	1735	subpixel_order = SubPixelHorizontalRGB;
1963	serge	1736	connector->interlace_allowed = true;
		1737	if (connector_type == DRM_MODE_CONNECTOR_HDMIB)
		1738	connector->doublescan_allowed = true;
		1739	else
		1740	connector->doublescan_allowed = false;
1123	serge	1741	break;
		1742	case DRM_MODE_CONNECTOR_DisplayPort:
		1743	radeon_dig_connector = kzalloc(sizeof(struct radeon_connector_atom_dig), GFP_KERNEL);
		1744	if (!radeon_dig_connector)
		1745	goto failed;
		1746	radeon_dig_connector->igp_lane_info = igp_lane_info;
		1747	radeon_connector->con_priv = radeon_dig_connector;
1321	serge	1748	drm_connector_init(dev, &radeon_connector->base, &radeon_dp_connector_funcs, connector_type);
1963	serge	1749	drm_connector_helper_add(&radeon_connector->base, &radeon_dp_connector_helper_funcs);
1123	serge	1750	if (i2c_bus->valid) {
1321	serge	1751	/* add DP i2c bus */
		1752	radeon_dig_connector->dp_i2c_bus = radeon_i2c_create_dp(dev, i2c_bus, "DP-auxch");
		1753	if (!radeon_dig_connector->dp_i2c_bus)
1963	serge	1754	DRM_ERROR("DP: Failed to assign dp ddc bus! Check dmesg for i2c errors.\n");
		1755	radeon_connector->ddc_bus = radeon_i2c_lookup(rdev, i2c_bus);
1123	serge	1756	if (!radeon_connector->ddc_bus)
1963	serge	1757	DRM_ERROR("DP: Failed to assign ddc bus! Check dmesg for i2c errors.\n");
1123	serge	1758	}
		1759	subpixel_order = SubPixelHorizontalRGB;
1321	serge	1760	drm_connector_attach_property(&radeon_connector->base,
		1761	rdev->mode_info.coherent_mode_property,
		1762	1);
1963	serge	1763	if (ASIC_IS_AVIVO(rdev)) {
		1764	drm_connector_attach_property(&radeon_connector->base,
		1765	rdev->mode_info.underscan_property,
		1766	UNDERSCAN_OFF);
		1767	drm_connector_attach_property(&radeon_connector->base,
		1768	rdev->mode_info.underscan_hborder_property,
		1769	0);
		1770	drm_connector_attach_property(&radeon_connector->base,
		1771	rdev->mode_info.underscan_vborder_property,
		1772	0);
		1773	}
		1774	connector->interlace_allowed = true;
		1775	/* in theory with a DP to VGA converter... */
		1776	connector->doublescan_allowed = false;
1123	serge	1777	break;
1963	serge	1778	case DRM_MODE_CONNECTOR_eDP:
		1779	radeon_dig_connector = kzalloc(sizeof(struct radeon_connector_atom_dig), GFP_KERNEL);
		1780	if (!radeon_dig_connector)
		1781	goto failed;
		1782	radeon_dig_connector->igp_lane_info = igp_lane_info;
		1783	radeon_connector->con_priv = radeon_dig_connector;
		1784	drm_connector_init(dev, &radeon_connector->base, &radeon_dp_connector_funcs, connector_type);
		1785	drm_connector_helper_add(&radeon_connector->base, &radeon_dp_connector_helper_funcs);
		1786	if (i2c_bus->valid) {
		1787	/* add DP i2c bus */
		1788	radeon_dig_connector->dp_i2c_bus = radeon_i2c_create_dp(dev, i2c_bus, "eDP-auxch");
		1789	if (!radeon_dig_connector->dp_i2c_bus)
		1790	DRM_ERROR("DP: Failed to assign dp ddc bus! Check dmesg for i2c errors.\n");
		1791	radeon_connector->ddc_bus = radeon_i2c_lookup(rdev, i2c_bus);
		1792	if (!radeon_connector->ddc_bus)
		1793	DRM_ERROR("DP: Failed to assign ddc bus! Check dmesg for i2c errors.\n");
		1794	}
		1795	drm_connector_attach_property(&radeon_connector->base,
		1796	dev->mode_config.scaling_mode_property,
		1797	DRM_MODE_SCALE_FULLSCREEN);
		1798	subpixel_order = SubPixelHorizontalRGB;
		1799	connector->interlace_allowed = false;
		1800	connector->doublescan_allowed = false;
		1801	break;
1123	serge	1802	case DRM_MODE_CONNECTOR_SVIDEO:
		1803	case DRM_MODE_CONNECTOR_Composite:
		1804	case DRM_MODE_CONNECTOR_9PinDIN:
1179	serge	1805	drm_connector_init(dev, &radeon_connector->base, &radeon_tv_connector_funcs, connector_type);
1963	serge	1806	drm_connector_helper_add(&radeon_connector->base, &radeon_tv_connector_helper_funcs);
1221	serge	1807	radeon_connector->dac_load_detect = true;
1179	serge	1808	drm_connector_attach_property(&radeon_connector->base,
		1809	rdev->mode_info.load_detect_property,
		1810	1);
1321	serge	1811	drm_connector_attach_property(&radeon_connector->base,
		1812	rdev->mode_info.tv_std_property,
1403	serge	1813	radeon_atombios_get_tv_info(rdev));
1963	serge	1814	/* no HPD on analog connectors */
		1815	radeon_connector->hpd.hpd = RADEON_HPD_NONE;
		1816	connector->interlace_allowed = false;
		1817	connector->doublescan_allowed = false;
1123	serge	1818	break;
		1819	case DRM_MODE_CONNECTOR_LVDS:
		1820	radeon_dig_connector = kzalloc(sizeof(struct radeon_connector_atom_dig), GFP_KERNEL);
		1821	if (!radeon_dig_connector)
		1822	goto failed;
		1823	radeon_dig_connector->igp_lane_info = igp_lane_info;
		1824	radeon_connector->con_priv = radeon_dig_connector;
		1825	drm_connector_init(dev, &radeon_connector->base, &radeon_lvds_connector_funcs, connector_type);
1963	serge	1826	drm_connector_helper_add(&radeon_connector->base, &radeon_lvds_connector_helper_funcs);
1123	serge	1827	if (i2c_bus->valid) {
1963	serge	1828	radeon_connector->ddc_bus = radeon_i2c_lookup(rdev, i2c_bus);
1123	serge	1829	if (!radeon_connector->ddc_bus)
1963	serge	1830	DRM_ERROR("LVDS: Failed to assign ddc bus! Check dmesg for i2c errors.\n");
1123	serge	1831	}
1179	serge	1832	drm_connector_attach_property(&radeon_connector->base,
		1833	dev->mode_config.scaling_mode_property,
		1834	DRM_MODE_SCALE_FULLSCREEN);
1123	serge	1835	subpixel_order = SubPixelHorizontalRGB;
1963	serge	1836	connector->interlace_allowed = false;
		1837	connector->doublescan_allowed = false;
1123	serge	1838	break;
		1839	}
1963	serge	1840	}
1123	serge	1841
1963	serge	1842	if (radeon_connector->hpd.hpd == RADEON_HPD_NONE) {
		1843	if (i2c_bus->valid)
		1844	connector->polled = DRM_CONNECTOR_POLL_CONNECT;
		1845	} else
		1846	connector->polled = DRM_CONNECTOR_POLL_HPD;
		1847
1123	serge	1848	connector->display_info.subpixel_order = subpixel_order;
2997	Serge	1849	// drm_sysfs_connector_add(connector);
1123	serge	1850	return;
		1851
		1852	failed:
		1853	drm_connector_cleanup(connector);
		1854	kfree(connector);
		1855	}
		1856
		1857	void
		1858	radeon_add_legacy_connector(struct drm_device *dev,
		1859	uint32_t connector_id,
		1860	uint32_t supported_device,
		1861	int connector_type,
1268	serge	1862	struct radeon_i2c_bus_rec *i2c_bus,
1321	serge	1863	uint16_t connector_object_id,
		1864	struct radeon_hpd *hpd)
1123	serge	1865	{
1179	serge	1866	struct radeon_device *rdev = dev->dev_private;
1123	serge	1867	struct drm_connector *connector;
		1868	struct radeon_connector *radeon_connector;
		1869	uint32_t subpixel_order = SubPixelNone;
		1870
1179	serge	1871	if (connector_type == DRM_MODE_CONNECTOR_Unknown)
1123	serge	1872	return;
		1873
1963	serge	1874	/* if the user selected tv=0 don't try and add the connector */
		1875	if (((connector_type == DRM_MODE_CONNECTOR_SVIDEO) \|\|
		1876	(connector_type == DRM_MODE_CONNECTOR_Composite) \|\|
		1877	(connector_type == DRM_MODE_CONNECTOR_9PinDIN)) &&
		1878	(radeon_tv == 0))
		1879	return;
		1880
1123	serge	1881	/* see if we already added it */
		1882	list_for_each_entry(connector, &dev->mode_config.connector_list, head) {
		1883	radeon_connector = to_radeon_connector(connector);
		1884	if (radeon_connector->connector_id == connector_id) {
		1885	radeon_connector->devices \|= supported_device;
		1886	return;
		1887	}
		1888	}
		1889
		1890	radeon_connector = kzalloc(sizeof(struct radeon_connector), GFP_KERNEL);
		1891	if (!radeon_connector)
		1892	return;
		1893
		1894	connector = &radeon_connector->base;
		1895
		1896	radeon_connector->connector_id = connector_id;
		1897	radeon_connector->devices = supported_device;
1268	serge	1898	radeon_connector->connector_object_id = connector_object_id;
1321	serge	1899	radeon_connector->hpd = *hpd;
2997	Serge	1900
1123	serge	1901	switch (connector_type) {
		1902	case DRM_MODE_CONNECTOR_VGA:
		1903	drm_connector_init(dev, &radeon_connector->base, &radeon_vga_connector_funcs, connector_type);
1963	serge	1904	drm_connector_helper_add(&radeon_connector->base, &radeon_vga_connector_helper_funcs);
1123	serge	1905	if (i2c_bus->valid) {
1963	serge	1906	radeon_connector->ddc_bus = radeon_i2c_lookup(rdev, i2c_bus);
1123	serge	1907	if (!radeon_connector->ddc_bus)
1963	serge	1908	DRM_ERROR("VGA: Failed to assign ddc bus! Check dmesg for i2c errors.\n");
1123	serge	1909	}
1221	serge	1910	radeon_connector->dac_load_detect = true;
1179	serge	1911	drm_connector_attach_property(&radeon_connector->base,
		1912	rdev->mode_info.load_detect_property,
		1913	1);
1963	serge	1914	/* no HPD on analog connectors */
		1915	radeon_connector->hpd.hpd = RADEON_HPD_NONE;
		1916	connector->polled = DRM_CONNECTOR_POLL_CONNECT;
		1917	connector->interlace_allowed = true;
		1918	connector->doublescan_allowed = true;
1123	serge	1919	break;
		1920	case DRM_MODE_CONNECTOR_DVIA:
		1921	drm_connector_init(dev, &radeon_connector->base, &radeon_vga_connector_funcs, connector_type);
1963	serge	1922	drm_connector_helper_add(&radeon_connector->base, &radeon_vga_connector_helper_funcs);
1123	serge	1923	if (i2c_bus->valid) {
1963	serge	1924	radeon_connector->ddc_bus = radeon_i2c_lookup(rdev, i2c_bus);
1123	serge	1925	if (!radeon_connector->ddc_bus)
1963	serge	1926	DRM_ERROR("DVIA: Failed to assign ddc bus! Check dmesg for i2c errors.\n");
1123	serge	1927	}
1221	serge	1928	radeon_connector->dac_load_detect = true;
1179	serge	1929	drm_connector_attach_property(&radeon_connector->base,
		1930	rdev->mode_info.load_detect_property,
		1931	1);
1963	serge	1932	/* no HPD on analog connectors */
		1933	radeon_connector->hpd.hpd = RADEON_HPD_NONE;
		1934	connector->interlace_allowed = true;
		1935	connector->doublescan_allowed = true;
1123	serge	1936	break;
		1937	case DRM_MODE_CONNECTOR_DVII:
		1938	case DRM_MODE_CONNECTOR_DVID:
		1939	drm_connector_init(dev, &radeon_connector->base, &radeon_dvi_connector_funcs, connector_type);
1963	serge	1940	drm_connector_helper_add(&radeon_connector->base, &radeon_dvi_connector_helper_funcs);
1123	serge	1941	if (i2c_bus->valid) {
1963	serge	1942	radeon_connector->ddc_bus = radeon_i2c_lookup(rdev, i2c_bus);
1123	serge	1943	if (!radeon_connector->ddc_bus)
1963	serge	1944	DRM_ERROR("DVI: Failed to assign ddc bus! Check dmesg for i2c errors.\n");
		1945	}
		1946	if (connector_type == DRM_MODE_CONNECTOR_DVII) {
1221	serge	1947	radeon_connector->dac_load_detect = true;
1179	serge	1948	drm_connector_attach_property(&radeon_connector->base,
		1949	rdev->mode_info.load_detect_property,
		1950	1);
1123	serge	1951	}
		1952	subpixel_order = SubPixelHorizontalRGB;
1963	serge	1953	connector->interlace_allowed = true;
		1954	if (connector_type == DRM_MODE_CONNECTOR_DVII)
		1955	connector->doublescan_allowed = true;
		1956	else
		1957	connector->doublescan_allowed = false;
1123	serge	1958	break;
		1959	case DRM_MODE_CONNECTOR_SVIDEO:
		1960	case DRM_MODE_CONNECTOR_Composite:
		1961	case DRM_MODE_CONNECTOR_9PinDIN:
1179	serge	1962	drm_connector_init(dev, &radeon_connector->base, &radeon_tv_connector_funcs, connector_type);
1963	serge	1963	drm_connector_helper_add(&radeon_connector->base, &radeon_tv_connector_helper_funcs);
1221	serge	1964	radeon_connector->dac_load_detect = true;
1313	serge	1965	/* RS400,RC410,RS480 chipset seems to report a lot
		1966	* of false positive on load detect, we haven't yet
		1967	* found a way to make load detect reliable on those
		1968	* chipset, thus just disable it for TV.
		1969	*/
		1970	if (rdev->family == CHIP_RS400 \|\| rdev->family == CHIP_RS480)
		1971	radeon_connector->dac_load_detect = false;
1179	serge	1972	drm_connector_attach_property(&radeon_connector->base,
		1973	rdev->mode_info.load_detect_property,
1404	serge	1974	radeon_connector->dac_load_detect);
1321	serge	1975	drm_connector_attach_property(&radeon_connector->base,
		1976	rdev->mode_info.tv_std_property,
1403	serge	1977	radeon_combios_get_tv_info(rdev));
1963	serge	1978	/* no HPD on analog connectors */
		1979	radeon_connector->hpd.hpd = RADEON_HPD_NONE;
		1980	connector->interlace_allowed = false;
		1981	connector->doublescan_allowed = false;
1123	serge	1982	break;
		1983	case DRM_MODE_CONNECTOR_LVDS:
		1984	drm_connector_init(dev, &radeon_connector->base, &radeon_lvds_connector_funcs, connector_type);
1963	serge	1985	drm_connector_helper_add(&radeon_connector->base, &radeon_lvds_connector_helper_funcs);
1123	serge	1986	if (i2c_bus->valid) {
1963	serge	1987	radeon_connector->ddc_bus = radeon_i2c_lookup(rdev, i2c_bus);
1123	serge	1988	if (!radeon_connector->ddc_bus)
1963	serge	1989	DRM_ERROR("LVDS: Failed to assign ddc bus! Check dmesg for i2c errors.\n");
1123	serge	1990	}
1179	serge	1991	drm_connector_attach_property(&radeon_connector->base,
		1992	dev->mode_config.scaling_mode_property,
		1993	DRM_MODE_SCALE_FULLSCREEN);
1123	serge	1994	subpixel_order = SubPixelHorizontalRGB;
1963	serge	1995	connector->interlace_allowed = false;
		1996	connector->doublescan_allowed = false;
1123	serge	1997	break;
		1998	}
		1999
1963	serge	2000	if (radeon_connector->hpd.hpd == RADEON_HPD_NONE) {
		2001	if (i2c_bus->valid)
		2002	connector->polled = DRM_CONNECTOR_POLL_CONNECT;
		2003	} else
		2004	connector->polled = DRM_CONNECTOR_POLL_HPD;
1123	serge	2005	connector->display_info.subpixel_order = subpixel_order;
2997	Serge	2006	// drm_sysfs_connector_add(connector);
1123	serge	2007	}

Subversion Repositories Kolibri OS

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