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

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

Subversion Repositories Kolibri OS

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