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
		618	if (encoder) {
		619	struct radeon_encoder *radeon_encoder = to_radeon_encoder(encoder);
		620	struct drm_display_mode *native_mode = &radeon_encoder->native_mode;
		621
		622	/* check if panel is valid */
		623	if (native_mode->hdisplay >= 320 && native_mode->vdisplay >= 240)
		624	ret = connector_status_connected;
		625
		626	}
		627
		628	/* check for edid as well */
		629	if (radeon_connector->edid)
		630	ret = connector_status_connected;
		631	else {
		632	if (radeon_connector->ddc_bus) {
		633	radeon_connector->edid = drm_get_edid(&radeon_connector->base,
		634	&radeon_connector->ddc_bus->adapter);
		635	if (radeon_connector->edid)
		636	ret = connector_status_connected;
		637	}
		638	}
1123	serge	639	/* check acpi lid status ??? */
1268	serge	640
1123	serge	641	radeon_connector_update_scratch_regs(connector, ret);
		642	return ret;
		643	}
		644
		645	static void radeon_connector_destroy(struct drm_connector *connector)
		646	{
		647	struct radeon_connector *radeon_connector = to_radeon_connector(connector);
		648
1268	serge	649	if (radeon_connector->edid)
		650	kfree(radeon_connector->edid);
1123	serge	651	kfree(radeon_connector->con_priv);
2997	Serge	652	// drm_sysfs_connector_remove(connector);
1123	serge	653	drm_connector_cleanup(connector);
		654	kfree(connector);
		655	}
		656
1179	serge	657	static int radeon_lvds_set_property(struct drm_connector *connector,
		658	struct drm_property *property,
		659	uint64_t value)
		660	{
		661	struct drm_device *dev = connector->dev;
		662	struct radeon_encoder *radeon_encoder;
		663	enum radeon_rmx_type rmx_type;
		664
1963	serge	665	DRM_DEBUG_KMS("\n");
1179	serge	666	if (property != dev->mode_config.scaling_mode_property)
		667	return 0;
		668
		669	if (connector->encoder)
		670	radeon_encoder = to_radeon_encoder(connector->encoder);
		671	else {
		672	struct drm_connector_helper_funcs *connector_funcs = connector->helper_private;
		673	radeon_encoder = to_radeon_encoder(connector_funcs->best_encoder(connector));
		674	}
		675
		676	switch (value) {
		677	case DRM_MODE_SCALE_NONE: rmx_type = RMX_OFF; break;
		678	case DRM_MODE_SCALE_CENTER: rmx_type = RMX_CENTER; break;
		679	case DRM_MODE_SCALE_ASPECT: rmx_type = RMX_ASPECT; break;
		680	default:
		681	case DRM_MODE_SCALE_FULLSCREEN: rmx_type = RMX_FULL; break;
		682	}
		683	if (radeon_encoder->rmx_type == rmx_type)
		684	return 0;
		685
		686	radeon_encoder->rmx_type = rmx_type;
		687
		688	radeon_property_change_mode(&radeon_encoder->base);
		689	return 0;
		690	}
		691
		692
2997	Serge	693	static const struct drm_connector_helper_funcs radeon_lvds_connector_helper_funcs = {
1123	serge	694	.get_modes = radeon_lvds_get_modes,
		695	.mode_valid = radeon_lvds_mode_valid,
		696	.best_encoder = radeon_best_single_encoder,
		697	};
		698
2997	Serge	699	static const struct drm_connector_funcs radeon_lvds_connector_funcs = {
1123	serge	700	.dpms = drm_helper_connector_dpms,
		701	.detect = radeon_lvds_detect,
		702	.fill_modes = drm_helper_probe_single_connector_modes,
		703	.destroy = radeon_connector_destroy,
1179	serge	704	.set_property = radeon_lvds_set_property,
1123	serge	705	};
		706
		707	static int radeon_vga_get_modes(struct drm_connector *connector)
		708	{
		709	struct radeon_connector *radeon_connector = to_radeon_connector(connector);
		710	int ret;
		711
		712	ret = radeon_ddc_get_modes(radeon_connector);
		713
		714	return ret;
		715	}
		716
		717	static int radeon_vga_mode_valid(struct drm_connector *connector,
		718	struct drm_display_mode *mode)
		719	{
1963	serge	720	struct drm_device *dev = connector->dev;
		721	struct radeon_device *rdev = dev->dev_private;
		722
1268	serge	723	/* XXX check mode bandwidth */
1963	serge	724
		725	if ((mode->clock / 10) > rdev->clock.max_pixel_clock)
		726	return MODE_CLOCK_HIGH;
		727
1123	serge	728	return MODE_OK;
		729	}
		730
1963	serge	731	static enum drm_connector_status
		732	radeon_vga_detect(struct drm_connector *connector, bool force)
1123	serge	733	{
1963	serge	734	struct drm_device *dev = connector->dev;
		735	struct radeon_device *rdev = dev->dev_private;
1123	serge	736	struct radeon_connector *radeon_connector = to_radeon_connector(connector);
		737	struct drm_encoder *encoder;
		738	struct drm_encoder_helper_funcs *encoder_funcs;
1404	serge	739	bool dret = false;
1123	serge	740	enum drm_connector_status ret = connector_status_disconnected;
		741
1179	serge	742	encoder = radeon_best_single_encoder(connector);
		743	if (!encoder)
		744	ret = connector_status_disconnected;
		745
1430	serge	746	if (radeon_connector->ddc_bus)
3192	Serge	747	dret = radeon_ddc_probe(radeon_connector, false);
1268	serge	748	if (dret) {
2997	Serge	749	radeon_connector->detected_by_load = false;
1268	serge	750	if (radeon_connector->edid) {
		751	kfree(radeon_connector->edid);
		752	radeon_connector->edid = NULL;
		753	}
		754	radeon_connector->edid = drm_get_edid(&radeon_connector->base, &radeon_connector->ddc_bus->adapter);
		755
		756	if (!radeon_connector->edid) {
1313	serge	757	DRM_ERROR("%s: probed a monitor but no\|invalid EDID\n",
1268	serge	758	drm_get_connector_name(connector));
1313	serge	759	ret = connector_status_connected;
1268	serge	760	} else {
		761	radeon_connector->use_digital = !!(radeon_connector->edid->input & DRM_EDID_INPUT_DIGITAL);
		762
		763	/* some oems have boards with separate digital and analog connectors
		764	* with a shared ddc line (often vga + hdmi)
		765	*/
		766	if (radeon_connector->use_digital && radeon_connector->shared_ddc) {
		767	kfree(radeon_connector->edid);
		768	radeon_connector->edid = NULL;
		769	ret = connector_status_disconnected;
		770	} else
1123	serge	771	ret = connector_status_connected;
1268	serge	772	}
		773	} else {
1963	serge	774
		775	/* if we aren't forcing don't do destructive polling */
2997	Serge	776	if (!force) {
		777	/* only return the previous status if we last
		778	* detected a monitor via load.
		779	*/
		780	if (radeon_connector->detected_by_load)
1963	serge	781	return connector->status;
2997	Serge	782	else
		783	return ret;
		784	}
1963	serge	785
1403	serge	786	if (radeon_connector->dac_load_detect && encoder) {
1123	serge	787	encoder_funcs = encoder->helper_private;
		788	ret = encoder_funcs->detect(encoder, connector);
2997	Serge	789	if (ret != connector_status_disconnected)
		790	radeon_connector->detected_by_load = true;
1123	serge	791	}
		792	}
		793
1179	serge	794	if (ret == connector_status_connected)
		795	ret = radeon_connector_analog_encoder_conflict_solve(connector, encoder, ret, true);
1963	serge	796
		797	/* RN50 and some RV100 asics in servers often have a hardcoded EDID in the
		798	* vbios to deal with KVMs. If we have one and are not able to detect a monitor
		799	* by other means, assume the CRT is connected and use that EDID.
		800	*/
		801	if ((!rdev->is_atom_bios) &&
		802	(ret == connector_status_disconnected) &&
		803	rdev->mode_info.bios_hardcoded_edid_size) {
		804	ret = connector_status_connected;
		805	}
		806
1123	serge	807	radeon_connector_update_scratch_regs(connector, ret);
		808	return ret;
		809	}
		810
2997	Serge	811	static const struct drm_connector_helper_funcs radeon_vga_connector_helper_funcs = {
1123	serge	812	.get_modes = radeon_vga_get_modes,
		813	.mode_valid = radeon_vga_mode_valid,
		814	.best_encoder = radeon_best_single_encoder,
		815	};
		816
2997	Serge	817	static const struct drm_connector_funcs radeon_vga_connector_funcs = {
1123	serge	818	.dpms = drm_helper_connector_dpms,
		819	.detect = radeon_vga_detect,
		820	.fill_modes = drm_helper_probe_single_connector_modes,
		821	.destroy = radeon_connector_destroy,
		822	.set_property = radeon_connector_set_property,
		823	};
		824
1179	serge	825	static int radeon_tv_get_modes(struct drm_connector *connector)
		826	{
		827	struct drm_device *dev = connector->dev;
		828	struct radeon_device *rdev = dev->dev_private;
		829	struct drm_display_mode *tv_mode;
		830	struct drm_encoder *encoder;
		831
		832	encoder = radeon_best_single_encoder(connector);
		833	if (!encoder)
		834	return 0;
		835
		836	/* avivo chips can scale any mode */
		837	if (rdev->family >= CHIP_RS600)
		838	/* add scaled modes */
		839	radeon_add_common_modes(encoder, connector);
		840	else {
		841	/* only 800x600 is supported right now on pre-avivo chips */
1221	serge	842	tv_mode = drm_cvt_mode(dev, 800, 600, 60, false, false, false);
1179	serge	843	tv_mode->type = DRM_MODE_TYPE_DRIVER \| DRM_MODE_TYPE_PREFERRED;
		844	drm_mode_probed_add(connector, tv_mode);
		845	}
		846	return 1;
		847	}
		848
		849	static int radeon_tv_mode_valid(struct drm_connector *connector,
		850	struct drm_display_mode *mode)
		851	{
1268	serge	852	if ((mode->hdisplay > 1024) \|\| (mode->vdisplay > 768))
		853	return MODE_CLOCK_RANGE;
1179	serge	854	return MODE_OK;
		855	}
		856
1963	serge	857	static enum drm_connector_status
		858	radeon_tv_detect(struct drm_connector *connector, bool force)
1179	serge	859	{
		860	struct drm_encoder *encoder;
		861	struct drm_encoder_helper_funcs *encoder_funcs;
		862	struct radeon_connector *radeon_connector = to_radeon_connector(connector);
		863	enum drm_connector_status ret = connector_status_disconnected;
		864
		865	if (!radeon_connector->dac_load_detect)
		866	return ret;
		867
		868	encoder = radeon_best_single_encoder(connector);
		869	if (!encoder)
		870	ret = connector_status_disconnected;
		871	else {
		872	encoder_funcs = encoder->helper_private;
		873	ret = encoder_funcs->detect(encoder, connector);
		874	}
		875	if (ret == connector_status_connected)
		876	ret = radeon_connector_analog_encoder_conflict_solve(connector, encoder, ret, false);
		877	radeon_connector_update_scratch_regs(connector, ret);
		878	return ret;
		879	}
		880
2997	Serge	881	static const struct drm_connector_helper_funcs radeon_tv_connector_helper_funcs = {
1179	serge	882	.get_modes = radeon_tv_get_modes,
		883	.mode_valid = radeon_tv_mode_valid,
		884	.best_encoder = radeon_best_single_encoder,
		885	};
		886
2997	Serge	887	static const struct drm_connector_funcs radeon_tv_connector_funcs = {
1179	serge	888	.dpms = drm_helper_connector_dpms,
		889	.detect = radeon_tv_detect,
		890	.fill_modes = drm_helper_probe_single_connector_modes,
		891	.destroy = radeon_connector_destroy,
		892	.set_property = radeon_connector_set_property,
		893	};
		894
1123	serge	895	static int radeon_dvi_get_modes(struct drm_connector *connector)
		896	{
		897	struct radeon_connector *radeon_connector = to_radeon_connector(connector);
		898	int ret;
		899
		900	ret = radeon_ddc_get_modes(radeon_connector);
		901	return ret;
		902	}
		903
2997	Serge	904	static bool radeon_check_hpd_status_unchanged(struct drm_connector *connector)
		905	{
		906	struct drm_device *dev = connector->dev;
		907	struct radeon_device *rdev = dev->dev_private;
		908	struct radeon_connector *radeon_connector = to_radeon_connector(connector);
		909	enum drm_connector_status status;
		910
		911	/* We only trust HPD on R600 and newer ASICS. */
		912	if (rdev->family >= CHIP_R600
		913	&& radeon_connector->hpd.hpd != RADEON_HPD_NONE) {
		914	if (radeon_hpd_sense(rdev, radeon_connector->hpd.hpd))
		915	status = connector_status_connected;
		916	else
		917	status = connector_status_disconnected;
		918	if (connector->status == status)
		919	return true;
		920	}
		921
		922	return false;
		923	}
		924
1179	serge	925	/*
		926	* DVI is complicated
		927	* Do a DDC probe, if DDC probe passes, get the full EDID so
		928	* we can do analog/digital monitor detection at this point.
		929	* If the monitor is an analog monitor or we got no DDC,
		930	* we need to find the DAC encoder object for this connector.
		931	* If we got no DDC, we do load detection on the DAC encoder object.
		932	* If we got analog DDC or load detection passes on the DAC encoder
		933	* we have to check if this analog encoder is shared with anyone else (TV)
		934	* if its shared we have to set the other connector to disconnected.
		935	*/
1963	serge	936	static enum drm_connector_status
		937	radeon_dvi_detect(struct drm_connector *connector, bool force)
1123	serge	938	{
1963	serge	939	struct drm_device *dev = connector->dev;
		940	struct radeon_device *rdev = dev->dev_private;
1123	serge	941	struct radeon_connector *radeon_connector = to_radeon_connector(connector);
1179	serge	942	struct drm_encoder *encoder = NULL;
1123	serge	943	struct drm_encoder_helper_funcs *encoder_funcs;
		944	struct drm_mode_object *obj;
		945	int i;
		946	enum drm_connector_status ret = connector_status_disconnected;
3120	serge	947	bool dret = false, broken_edid = false;
1123	serge	948
2997	Serge	949	if (!force && radeon_check_hpd_status_unchanged(connector))
		950	return connector->status;
		951
1430	serge	952	if (radeon_connector->ddc_bus)
3192	Serge	953	dret = radeon_ddc_probe(radeon_connector, false);
1179	serge	954	if (dret) {
2997	Serge	955	radeon_connector->detected_by_load = false;
1268	serge	956	if (radeon_connector->edid) {
		957	kfree(radeon_connector->edid);
		958	radeon_connector->edid = NULL;
		959	}
1179	serge	960	radeon_connector->edid = drm_get_edid(&radeon_connector->base, &radeon_connector->ddc_bus->adapter);
		961
		962	if (!radeon_connector->edid) {
1313	serge	963	DRM_ERROR("%s: probed a monitor but no\|invalid EDID\n",
1179	serge	964	drm_get_connector_name(connector));
1986	serge	965	/* rs690 seems to have a problem with connectors not existing and always
		966	* return a block of 0's. If we see this just stop polling on this output */
		967	if ((rdev->family == CHIP_RS690 \|\| rdev->family == CHIP_RS740) && radeon_connector->base.null_edid_counter) {
		968	ret = connector_status_disconnected;
		969	DRM_ERROR("%s: detected RS690 floating bus bug, stopping ddc detect\n", drm_get_connector_name(connector));
		970	radeon_connector->ddc_bus = NULL;
3120	serge	971	} else {
		972	ret = connector_status_connected;
		973	broken_edid = true; /* defer use_digital to later */
1986	serge	974	}
1179	serge	975	} else {
		976	radeon_connector->use_digital = !!(radeon_connector->edid->input & DRM_EDID_INPUT_DIGITAL);
		977
1268	serge	978	/* some oems have boards with separate digital and analog connectors
		979	* with a shared ddc line (often vga + hdmi)
		980	*/
		981	if ((!radeon_connector->use_digital) && radeon_connector->shared_ddc) {
		982	kfree(radeon_connector->edid);
		983	radeon_connector->edid = NULL;
		984	ret = connector_status_disconnected;
		985	} else
1123	serge	986	ret = connector_status_connected;
1321	serge	987
1963	serge	988	/* This gets complicated. We have boards with VGA + HDMI with a
		989	* shared DDC line and we have boards with DVI-D + HDMI with a shared
		990	* DDC line. The latter is more complex because with DVI<->HDMI adapters
		991	* you don't really know what's connected to which port as both are digital.
1321	serge	992	*/
1428	serge	993	if (radeon_connector->shared_ddc && (ret == connector_status_connected)) {
1321	serge	994	struct drm_connector *list_connector;
		995	struct radeon_connector *list_radeon_connector;
		996	list_for_each_entry(list_connector, &dev->mode_config.connector_list, head) {
		997	if (connector == list_connector)
		998	continue;
		999	list_radeon_connector = to_radeon_connector(list_connector);
1963	serge	1000	if (list_radeon_connector->shared_ddc &&
		1001	(list_radeon_connector->ddc_bus->rec.i2c_id ==
		1002	radeon_connector->ddc_bus->rec.i2c_id)) {
		1003	/* cases where both connectors are digital */
		1004	if (list_connector->connector_type != DRM_MODE_CONNECTOR_VGA) {
		1005	/* hpd is our only option in this case */
		1006	if (!radeon_hpd_sense(rdev, radeon_connector->hpd.hpd)) {
1321	serge	1007	kfree(radeon_connector->edid);
		1008	radeon_connector->edid = NULL;
		1009	ret = connector_status_disconnected;
		1010	}
		1011	}
		1012	}
		1013	}
		1014	}
1179	serge	1015	}
		1016	}
		1017
		1018	if ((ret == connector_status_connected) && (radeon_connector->use_digital == true))
		1019	goto out;
		1020
2997	Serge	1021	/* DVI-D and HDMI-A are digital only */
		1022	if ((connector->connector_type == DRM_MODE_CONNECTOR_DVID) \|\|
		1023	(connector->connector_type == DRM_MODE_CONNECTOR_HDMIA))
		1024	goto out;
		1025
		1026	/* if we aren't forcing don't do destructive polling */
1963	serge	1027	if (!force) {
2997	Serge	1028	/* only return the previous status if we last
		1029	* detected a monitor via load.
		1030	*/
		1031	if (radeon_connector->detected_by_load)
1963	serge	1032	ret = connector->status;
		1033	goto out;
		1034	}
		1035
1179	serge	1036	/* find analog encoder */
		1037	if (radeon_connector->dac_load_detect) {
1123	serge	1038	for (i = 0; i < DRM_CONNECTOR_MAX_ENCODER; i++) {
		1039	if (connector->encoder_ids[i] == 0)
		1040	break;
		1041
		1042	obj = drm_mode_object_find(connector->dev,
		1043	connector->encoder_ids[i],
		1044	DRM_MODE_OBJECT_ENCODER);
		1045	if (!obj)
		1046	continue;
		1047
		1048	encoder = obj_to_encoder(obj);
		1049
2997	Serge	1050	if (encoder->encoder_type != DRM_MODE_ENCODER_DAC &&
		1051	encoder->encoder_type != DRM_MODE_ENCODER_TVDAC)
		1052	continue;
		1053
1123	serge	1054	encoder_funcs = encoder->helper_private;
		1055	if (encoder_funcs->detect) {
3120	serge	1056	if (!broken_edid) {
1179	serge	1057	if (ret != connector_status_connected) {
3120	serge	1058	/* deal with analog monitors without DDC */
1123	serge	1059	ret = encoder_funcs->detect(encoder, connector);
		1060	if (ret == connector_status_connected) {
1179	serge	1061	radeon_connector->use_digital = false;
		1062	}
2997	Serge	1063	if (ret != connector_status_disconnected)
		1064	radeon_connector->detected_by_load = true;
1179	serge	1065	}
3120	serge	1066	} else {
		1067	enum drm_connector_status lret;
		1068	/* assume digital unless load detected otherwise */
		1069	radeon_connector->use_digital = true;
		1070	lret = encoder_funcs->detect(encoder, connector);
		1071	DRM_DEBUG_KMS("load_detect %x returned: %x\n",encoder->encoder_type,lret);
		1072	if (lret == connector_status_connected)
		1073	radeon_connector->use_digital = false;
		1074	}
1123	serge	1075	break;
		1076	}
		1077	}
		1078	}
1179	serge	1079
		1080	if ((ret == connector_status_connected) && (radeon_connector->use_digital == false) &&
		1081	encoder) {
		1082	ret = radeon_connector_analog_encoder_conflict_solve(connector, encoder, ret, true);
1123	serge	1083	}
		1084
1963	serge	1085	/* RN50 and some RV100 asics in servers often have a hardcoded EDID in the
		1086	* vbios to deal with KVMs. If we have one and are not able to detect a monitor
		1087	* by other means, assume the DFP is connected and use that EDID. In most
		1088	* cases the DVI port is actually a virtual KVM port connected to the service
		1089	* processor.
		1090	*/
2997	Serge	1091	out:
1963	serge	1092	if ((!rdev->is_atom_bios) &&
		1093	(ret == connector_status_disconnected) &&
		1094	rdev->mode_info.bios_hardcoded_edid_size) {
		1095	radeon_connector->use_digital = true;
		1096	ret = connector_status_connected;
		1097	}
		1098
1123	serge	1099	/* updated in get modes as well since we need to know if it's analog or digital */
		1100	radeon_connector_update_scratch_regs(connector, ret);
		1101	return ret;
		1102	}
		1103
		1104	/* okay need to be smart in here about which encoder to pick */
2997	Serge	1105	static struct drm_encoder radeon_dvi_encoder(struct drm_connector connector)
1123	serge	1106	{
		1107	int enc_id = connector->encoder_ids[0];
		1108	struct radeon_connector *radeon_connector = to_radeon_connector(connector);
		1109	struct drm_mode_object *obj;
		1110	struct drm_encoder *encoder;
		1111	int i;
		1112	for (i = 0; i < DRM_CONNECTOR_MAX_ENCODER; i++) {
		1113	if (connector->encoder_ids[i] == 0)
		1114	break;
		1115
		1116	obj = drm_mode_object_find(connector->dev, connector->encoder_ids[i], DRM_MODE_OBJECT_ENCODER);
		1117	if (!obj)
		1118	continue;
		1119
		1120	encoder = obj_to_encoder(obj);
		1121
1179	serge	1122	if (radeon_connector->use_digital == true) {
1123	serge	1123	if (encoder->encoder_type == DRM_MODE_ENCODER_TMDS)
		1124	return encoder;
		1125	} else {
		1126	if (encoder->encoder_type == DRM_MODE_ENCODER_DAC \|\|
		1127	encoder->encoder_type == DRM_MODE_ENCODER_TVDAC)
		1128	return encoder;
		1129	}
		1130	}
		1131
		1132	/* see if we have a default encoder TODO */
		1133
		1134	/* then check use digitial */
		1135	/* pick the first one */
		1136	if (enc_id) {
		1137	obj = drm_mode_object_find(connector->dev, enc_id, DRM_MODE_OBJECT_ENCODER);
		1138	if (!obj)
		1139	return NULL;
		1140	encoder = obj_to_encoder(obj);
		1141	return encoder;
		1142	}
		1143	return NULL;
		1144	}
		1145
1221	serge	1146	static void radeon_dvi_force(struct drm_connector *connector)
		1147	{
		1148	struct radeon_connector *radeon_connector = to_radeon_connector(connector);
		1149	if (connector->force == DRM_FORCE_ON)
		1150	radeon_connector->use_digital = false;
		1151	if (connector->force == DRM_FORCE_ON_DIGITAL)
		1152	radeon_connector->use_digital = true;
		1153	}
		1154
1268	serge	1155	static int radeon_dvi_mode_valid(struct drm_connector *connector,
		1156	struct drm_display_mode *mode)
		1157	{
1403	serge	1158	struct drm_device *dev = connector->dev;
		1159	struct radeon_device *rdev = dev->dev_private;
1268	serge	1160	struct radeon_connector *radeon_connector = to_radeon_connector(connector);
		1161
		1162	/* XXX check mode bandwidth */
		1163
1403	serge	1164	/* clocks over 135 MHz have heat issues with DVI on RV100 */
		1165	if (radeon_connector->use_digital &&
		1166	(rdev->family == CHIP_RV100) &&
		1167	(mode->clock > 135000))
		1168	return MODE_CLOCK_HIGH;
		1169
1268	serge	1170	if (radeon_connector->use_digital && (mode->clock > 165000)) {
		1171	if ((radeon_connector->connector_object_id == CONNECTOR_OBJECT_ID_DUAL_LINK_DVI_I) \|\|
		1172	(radeon_connector->connector_object_id == CONNECTOR_OBJECT_ID_DUAL_LINK_DVI_D) \|\|
		1173	(radeon_connector->connector_object_id == CONNECTOR_OBJECT_ID_HDMI_TYPE_B))
		1174	return MODE_OK;
1963	serge	1175	else if (radeon_connector->connector_object_id == CONNECTOR_OBJECT_ID_HDMI_TYPE_A) {
2997	Serge	1176	if (ASIC_IS_DCE6(rdev)) {
1963	serge	1177	/* HDMI 1.3+ supports max clock of 340 Mhz */
		1178	if (mode->clock > 340000)
		1179	return MODE_CLOCK_HIGH;
1268	serge	1180	else
1963	serge	1181	return MODE_OK;
		1182	} else
		1183	return MODE_CLOCK_HIGH;
		1184	} else
1268	serge	1185	return MODE_CLOCK_HIGH;
		1186	}
1963	serge	1187
		1188	/* check against the max pixel clock */
		1189	if ((mode->clock / 10) > rdev->clock.max_pixel_clock)
		1190	return MODE_CLOCK_HIGH;
		1191
1268	serge	1192	return MODE_OK;
		1193	}
		1194
2997	Serge	1195	static const struct drm_connector_helper_funcs radeon_dvi_connector_helper_funcs = {
1123	serge	1196	.get_modes = radeon_dvi_get_modes,
1268	serge	1197	.mode_valid = radeon_dvi_mode_valid,
1123	serge	1198	.best_encoder = radeon_dvi_encoder,
		1199	};
		1200
2997	Serge	1201	static const struct drm_connector_funcs radeon_dvi_connector_funcs = {
1123	serge	1202	.dpms = drm_helper_connector_dpms,
		1203	.detect = radeon_dvi_detect,
		1204	.fill_modes = drm_helper_probe_single_connector_modes,
		1205	.set_property = radeon_connector_set_property,
		1206	.destroy = radeon_connector_destroy,
1221	serge	1207	.force = radeon_dvi_force,
1123	serge	1208	};
		1209
1321	serge	1210	static void radeon_dp_connector_destroy(struct drm_connector *connector)
		1211	{
		1212	struct radeon_connector *radeon_connector = to_radeon_connector(connector);
		1213	struct radeon_connector_atom_dig *radeon_dig_connector = radeon_connector->con_priv;
		1214
		1215	if (radeon_connector->edid)
		1216	kfree(radeon_connector->edid);
		1217	if (radeon_dig_connector->dp_i2c_bus)
1963	serge	1218	radeon_i2c_destroy(radeon_dig_connector->dp_i2c_bus);
1321	serge	1219	kfree(radeon_connector->con_priv);
2997	Serge	1220	// drm_sysfs_connector_remove(connector);
1321	serge	1221	drm_connector_cleanup(connector);
		1222	kfree(connector);
		1223	}
		1224
		1225	static int radeon_dp_get_modes(struct drm_connector *connector)
		1226	{
		1227	struct radeon_connector *radeon_connector = to_radeon_connector(connector);
1963	serge	1228	struct radeon_connector_atom_dig *radeon_dig_connector = radeon_connector->con_priv;
1986	serge	1229	struct drm_encoder *encoder = radeon_best_single_encoder(connector);
1321	serge	1230	int ret;
		1231
1986	serge	1232	if ((connector->connector_type == DRM_MODE_CONNECTOR_eDP) \|\|
		1233	(connector->connector_type == DRM_MODE_CONNECTOR_LVDS)) {
1963	serge	1234	struct drm_display_mode *mode;
		1235
2997	Serge	1236	if (connector->connector_type == DRM_MODE_CONNECTOR_eDP) {
1963	serge	1237	if (!radeon_dig_connector->edp_on)
		1238	atombios_set_edp_panel_power(connector,
		1239	ATOM_TRANSMITTER_ACTION_POWER_ON);
1321	serge	1240	ret = radeon_ddc_get_modes(radeon_connector);
1963	serge	1241	if (!radeon_dig_connector->edp_on)
		1242	atombios_set_edp_panel_power(connector,
		1243	ATOM_TRANSMITTER_ACTION_POWER_OFF);
2997	Serge	1244	} else {
		1245	/* need to setup ddc on the bridge */
		1246	if (radeon_connector_encoder_get_dp_bridge_encoder_id(connector) !=
		1247	ENCODER_OBJECT_ID_NONE) {
		1248	if (encoder)
		1249	radeon_atom_ext_encoder_setup_ddc(encoder);
		1250	}
		1251	ret = radeon_ddc_get_modes(radeon_connector);
		1252	}
1963	serge	1253
		1254	if (ret > 0) {
		1255	if (encoder) {
		1256	radeon_fixup_lvds_native_mode(encoder, connector);
		1257	/* add scaled modes */
		1258	radeon_add_common_modes(encoder, connector);
		1259	}
		1260	return ret;
		1261	}
		1262
		1263	if (!encoder)
		1264	return 0;
		1265
		1266	/* we have no EDID modes */
		1267	mode = radeon_fp_native_mode(encoder);
		1268	if (mode) {
		1269	ret = 1;
		1270	drm_mode_probed_add(connector, mode);
		1271	/* add the width/height from vbios tables if available */
		1272	connector->display_info.width_mm = mode->width_mm;
		1273	connector->display_info.height_mm = mode->height_mm;
		1274	/* add scaled modes */
		1275	radeon_add_common_modes(encoder, connector);
		1276	}
1986	serge	1277	} else {
		1278	/* need to setup ddc on the bridge */
2997	Serge	1279	if (radeon_connector_encoder_get_dp_bridge_encoder_id(connector) !=
		1280	ENCODER_OBJECT_ID_NONE) {
1986	serge	1281	if (encoder)
		1282	radeon_atom_ext_encoder_setup_ddc(encoder);
		1283	}
1963	serge	1284	ret = radeon_ddc_get_modes(radeon_connector);
1986	serge	1285	}
1963	serge	1286
1321	serge	1287	return ret;
		1288	}
		1289
2997	Serge	1290	u16 radeon_connector_encoder_get_dp_bridge_encoder_id(struct drm_connector *connector)
1321	serge	1291	{
1963	serge	1292	struct drm_mode_object *obj;
		1293	struct drm_encoder *encoder;
		1294	struct radeon_encoder *radeon_encoder;
		1295	int i;
		1296
		1297	for (i = 0; i < DRM_CONNECTOR_MAX_ENCODER; i++) {
		1298	if (connector->encoder_ids[i] == 0)
		1299	break;
		1300
		1301	obj = drm_mode_object_find(connector->dev, connector->encoder_ids[i], DRM_MODE_OBJECT_ENCODER);
		1302	if (!obj)
		1303	continue;
		1304
		1305	encoder = obj_to_encoder(obj);
		1306	radeon_encoder = to_radeon_encoder(encoder);
		1307
		1308	switch (radeon_encoder->encoder_id) {
		1309	case ENCODER_OBJECT_ID_TRAVIS:
		1310	case ENCODER_OBJECT_ID_NUTMEG:
2997	Serge	1311	return radeon_encoder->encoder_id;
1963	serge	1312	default:
		1313	break;
		1314	}
		1315	}
		1316
2997	Serge	1317	return ENCODER_OBJECT_ID_NONE;
1963	serge	1318	}
		1319
		1320	bool radeon_connector_encoder_is_hbr2(struct drm_connector *connector)
		1321	{
		1322	struct drm_mode_object *obj;
		1323	struct drm_encoder *encoder;
		1324	struct radeon_encoder *radeon_encoder;
		1325	int i;
		1326	bool found = false;
		1327
		1328	for (i = 0; i < DRM_CONNECTOR_MAX_ENCODER; i++) {
		1329	if (connector->encoder_ids[i] == 0)
		1330	break;
		1331
		1332	obj = drm_mode_object_find(connector->dev, connector->encoder_ids[i], DRM_MODE_OBJECT_ENCODER);
		1333	if (!obj)
		1334	continue;
		1335
		1336	encoder = obj_to_encoder(obj);
		1337	radeon_encoder = to_radeon_encoder(encoder);
		1338	if (radeon_encoder->caps & ATOM_ENCODER_CAP_RECORD_HBR2)
		1339	found = true;
		1340	}
		1341
		1342	return found;
		1343	}
		1344
		1345	bool radeon_connector_is_dp12_capable(struct drm_connector *connector)
		1346	{
		1347	struct drm_device *dev = connector->dev;
		1348	struct radeon_device *rdev = dev->dev_private;
		1349
		1350	if (ASIC_IS_DCE5(rdev) &&
		1351	(rdev->clock.dp_extclk >= 53900) &&
		1352	radeon_connector_encoder_is_hbr2(connector)) {
		1353	return true;
		1354	}
		1355
		1356	return false;
		1357	}
		1358
		1359	static enum drm_connector_status
		1360	radeon_dp_detect(struct drm_connector *connector, bool force)
		1361	{
		1362	struct drm_device *dev = connector->dev;
		1363	struct radeon_device *rdev = dev->dev_private;
1321	serge	1364	struct radeon_connector *radeon_connector = to_radeon_connector(connector);
		1365	enum drm_connector_status ret = connector_status_disconnected;
		1366	struct radeon_connector_atom_dig *radeon_dig_connector = radeon_connector->con_priv;
1986	serge	1367	struct drm_encoder *encoder = radeon_best_single_encoder(connector);
1321	serge	1368
3192	Serge	1369
		1370	#if DISABLE_DP
		1371	connector->status = connector_status_disconnected;
		1372	return connector->status;
		1373	#endif
		1374
2997	Serge	1375	if (!force && radeon_check_hpd_status_unchanged(connector))
		1376	return connector->status;
		1377
1321	serge	1378	if (radeon_connector->edid) {
		1379	kfree(radeon_connector->edid);
		1380	radeon_connector->edid = NULL;
		1381	}
		1382
1986	serge	1383	if ((connector->connector_type == DRM_MODE_CONNECTOR_eDP) \|\|
		1384	(connector->connector_type == DRM_MODE_CONNECTOR_LVDS)) {
1963	serge	1385	if (encoder) {
		1386	struct radeon_encoder *radeon_encoder = to_radeon_encoder(encoder);
		1387	struct drm_display_mode *native_mode = &radeon_encoder->native_mode;
		1388
		1389	/* check if panel is valid */
		1390	if (native_mode->hdisplay >= 320 && native_mode->vdisplay >= 240)
		1391	ret = connector_status_connected;
		1392	}
		1393	/* eDP is always DP */
		1394	radeon_dig_connector->dp_sink_type = CONNECTOR_OBJECT_ID_DISPLAYPORT;
		1395	if (!radeon_dig_connector->edp_on)
		1396	atombios_set_edp_panel_power(connector,
		1397	ATOM_TRANSMITTER_ACTION_POWER_ON);
		1398	if (radeon_dp_getdpcd(radeon_connector))
1321	serge	1399	ret = connector_status_connected;
1963	serge	1400	if (!radeon_dig_connector->edp_on)
		1401	atombios_set_edp_panel_power(connector,
		1402	ATOM_TRANSMITTER_ACTION_POWER_OFF);
2997	Serge	1403	} else if (radeon_connector_encoder_get_dp_bridge_encoder_id(connector) !=
		1404	ENCODER_OBJECT_ID_NONE) {
		1405	/* DP bridges are always DP */
		1406	radeon_dig_connector->dp_sink_type = CONNECTOR_OBJECT_ID_DISPLAYPORT;
		1407	/* get the DPCD from the bridge */
		1408	radeon_dp_getdpcd(radeon_connector);
		1409
		1410	if (encoder) {
		1411	/* setup ddc on the bridge */
1986	serge	1412	radeon_atom_ext_encoder_setup_ddc(encoder);
3192	Serge	1413	/* bridge chips are always aux */
		1414	if (radeon_ddc_probe(radeon_connector, true)) /* try DDC */
2997	Serge	1415	ret = connector_status_connected;
		1416	else if (radeon_connector->dac_load_detect) { /* try load detection */
		1417	struct drm_encoder_helper_funcs *encoder_funcs = encoder->helper_private;
		1418	ret = encoder_funcs->detect(encoder, connector);
3764	Serge	1419	}
1986	serge	1420	}
2997	Serge	1421	} else {
1963	serge	1422	radeon_dig_connector->dp_sink_type = radeon_dp_getsinktype(radeon_connector);
		1423	if (radeon_hpd_sense(rdev, radeon_connector->hpd.hpd)) {
1321	serge	1424	ret = connector_status_connected;
1963	serge	1425	if (radeon_dig_connector->dp_sink_type == CONNECTOR_OBJECT_ID_DISPLAYPORT)
		1426	radeon_dp_getdpcd(radeon_connector);
		1427	} else {
		1428	if (radeon_dig_connector->dp_sink_type == CONNECTOR_OBJECT_ID_DISPLAYPORT) {
		1429	if (radeon_dp_getdpcd(radeon_connector))
		1430	ret = connector_status_connected;
		1431	} else {
3192	Serge	1432	/* try non-aux ddc (DP to DVI/HMDI/etc. adapter) */
		1433	if (radeon_ddc_probe(radeon_connector, false))
1963	serge	1434	ret = connector_status_connected;
1321	serge	1435	}
		1436	}
1963	serge	1437	}
1321	serge	1438
1963	serge	1439	radeon_connector_update_scratch_regs(connector, ret);
1321	serge	1440	return ret;
		1441	}
		1442
		1443	static int radeon_dp_mode_valid(struct drm_connector *connector,
		1444	struct drm_display_mode *mode)
		1445	{
		1446	struct radeon_connector *radeon_connector = to_radeon_connector(connector);
		1447	struct radeon_connector_atom_dig *radeon_dig_connector = radeon_connector->con_priv;
		1448
		1449	/* XXX check mode bandwidth */
		1450
1986	serge	1451	if ((connector->connector_type == DRM_MODE_CONNECTOR_eDP) \|\|
		1452	(connector->connector_type == DRM_MODE_CONNECTOR_LVDS)) {
1963	serge	1453	struct drm_encoder *encoder = radeon_best_single_encoder(connector);
		1454
		1455	if ((mode->hdisplay < 320) \|\| (mode->vdisplay < 240))
		1456	return MODE_PANEL;
		1457
		1458	if (encoder) {
		1459	struct radeon_encoder *radeon_encoder = to_radeon_encoder(encoder);
		1460	struct drm_display_mode *native_mode = &radeon_encoder->native_mode;
		1461
		1462	/* AVIVO hardware supports downscaling modes larger than the panel
		1463	* to the panel size, but I'm not sure this is desirable.
		1464	*/
		1465	if ((mode->hdisplay > native_mode->hdisplay) \|\|
		1466	(mode->vdisplay > native_mode->vdisplay))
		1467	return MODE_PANEL;
		1468
		1469	/* if scaling is disabled, block non-native modes */
		1470	if (radeon_encoder->rmx_type == RMX_OFF) {
		1471	if ((mode->hdisplay != native_mode->hdisplay) \|\|
		1472	(mode->vdisplay != native_mode->vdisplay))
		1473	return MODE_PANEL;
		1474	}
		1475	}
		1476	return MODE_OK;
		1477	} else {
1403	serge	1478	if ((radeon_dig_connector->dp_sink_type == CONNECTOR_OBJECT_ID_DISPLAYPORT) \|\|
		1479	(radeon_dig_connector->dp_sink_type == CONNECTOR_OBJECT_ID_eDP))
1963	serge	1480	return radeon_dp_mode_valid_helper(connector, mode);
1321	serge	1481	else
		1482	return MODE_OK;
1963	serge	1483	}
1321	serge	1484	}
		1485
2997	Serge	1486	static const struct drm_connector_helper_funcs radeon_dp_connector_helper_funcs = {
1321	serge	1487	.get_modes = radeon_dp_get_modes,
		1488	.mode_valid = radeon_dp_mode_valid,
		1489	.best_encoder = radeon_dvi_encoder,
		1490	};
		1491
2997	Serge	1492	static const struct drm_connector_funcs radeon_dp_connector_funcs = {
1321	serge	1493	.dpms = drm_helper_connector_dpms,
		1494	.detect = radeon_dp_detect,
		1495	.fill_modes = drm_helper_probe_single_connector_modes,
		1496	.set_property = radeon_connector_set_property,
		1497	.destroy = radeon_dp_connector_destroy,
		1498	.force = radeon_dvi_force,
		1499	};
		1500
1123	serge	1501	void
		1502	radeon_add_atom_connector(struct drm_device *dev,
		1503	uint32_t connector_id,
		1504	uint32_t supported_device,
		1505	int connector_type,
		1506	struct radeon_i2c_bus_rec *i2c_bus,
1268	serge	1507	uint32_t igp_lane_info,
1321	serge	1508	uint16_t connector_object_id,
1963	serge	1509	struct radeon_hpd *hpd,
		1510	struct radeon_router *router)
1123	serge	1511	{
1179	serge	1512	struct radeon_device *rdev = dev->dev_private;
1123	serge	1513	struct drm_connector *connector;
		1514	struct radeon_connector *radeon_connector;
		1515	struct radeon_connector_atom_dig *radeon_dig_connector;
1963	serge	1516	struct drm_encoder *encoder;
		1517	struct radeon_encoder *radeon_encoder;
1123	serge	1518	uint32_t subpixel_order = SubPixelNone;
1268	serge	1519	bool shared_ddc = false;
1963	serge	1520	bool is_dp_bridge = false;
1123	serge	1521
1179	serge	1522	if (connector_type == DRM_MODE_CONNECTOR_Unknown)
1123	serge	1523	return;
		1524
1963	serge	1525	/* if the user selected tv=0 don't try and add the connector */
		1526	if (((connector_type == DRM_MODE_CONNECTOR_SVIDEO) \|\|
		1527	(connector_type == DRM_MODE_CONNECTOR_Composite) \|\|
		1528	(connector_type == DRM_MODE_CONNECTOR_9PinDIN)) &&
		1529	(radeon_tv == 0))
		1530	return;
		1531
1123	serge	1532	/* see if we already added it */
		1533	list_for_each_entry(connector, &dev->mode_config.connector_list, head) {
		1534	radeon_connector = to_radeon_connector(connector);
		1535	if (radeon_connector->connector_id == connector_id) {
		1536	radeon_connector->devices \|= supported_device;
		1537	return;
		1538	}
1268	serge	1539	if (radeon_connector->ddc_bus && i2c_bus->valid) {
1428	serge	1540	if (radeon_connector->ddc_bus->rec.i2c_id == i2c_bus->i2c_id) {
1268	serge	1541	radeon_connector->shared_ddc = true;
		1542	shared_ddc = true;
		1543	}
1963	serge	1544	if (radeon_connector->router_bus && router->ddc_valid &&
		1545	(radeon_connector->router.router_id == router->router_id)) {
		1546	radeon_connector->shared_ddc = false;
		1547	shared_ddc = false;
		1548	}
1268	serge	1549	}
1123	serge	1550	}
		1551
1963	serge	1552	/* check if it's a dp bridge */
		1553	list_for_each_entry(encoder, &dev->mode_config.encoder_list, head) {
		1554	radeon_encoder = to_radeon_encoder(encoder);
		1555	if (radeon_encoder->devices & supported_device) {
		1556	switch (radeon_encoder->encoder_id) {
		1557	case ENCODER_OBJECT_ID_TRAVIS:
		1558	case ENCODER_OBJECT_ID_NUTMEG:
		1559	is_dp_bridge = true;
		1560	break;
		1561	default:
		1562	break;
		1563	}
		1564	}
		1565	}
		1566
1123	serge	1567	radeon_connector = kzalloc(sizeof(struct radeon_connector), GFP_KERNEL);
		1568	if (!radeon_connector)
		1569	return;
		1570
		1571	connector = &radeon_connector->base;
		1572
		1573	radeon_connector->connector_id = connector_id;
		1574	radeon_connector->devices = supported_device;
1268	serge	1575	radeon_connector->shared_ddc = shared_ddc;
		1576	radeon_connector->connector_object_id = connector_object_id;
1321	serge	1577	radeon_connector->hpd = *hpd;
2997	Serge	1578
1963	serge	1579	radeon_connector->router = *router;
		1580	if (router->ddc_valid \|\| router->cd_valid) {
		1581	radeon_connector->router_bus = radeon_i2c_lookup(rdev, &router->i2c_info);
		1582	if (!radeon_connector->router_bus)
		1583	DRM_ERROR("Failed to assign router i2c bus! Check dmesg for i2c errors.\n");
		1584	}
		1585
		1586	if (is_dp_bridge) {
		1587	radeon_dig_connector = kzalloc(sizeof(struct radeon_connector_atom_dig), GFP_KERNEL);
		1588	if (!radeon_dig_connector)
		1589	goto failed;
		1590	radeon_dig_connector->igp_lane_info = igp_lane_info;
		1591	radeon_connector->con_priv = radeon_dig_connector;
		1592	drm_connector_init(dev, &radeon_connector->base, &radeon_dp_connector_funcs, connector_type);
		1593	drm_connector_helper_add(&radeon_connector->base, &radeon_dp_connector_helper_funcs);
		1594	if (i2c_bus->valid) {
		1595	/* add DP i2c bus */
		1596	if (connector_type == DRM_MODE_CONNECTOR_eDP)
		1597	radeon_dig_connector->dp_i2c_bus = radeon_i2c_create_dp(dev, i2c_bus, "eDP-auxch");
		1598	else
		1599	radeon_dig_connector->dp_i2c_bus = radeon_i2c_create_dp(dev, i2c_bus, "DP-auxch");
		1600	if (!radeon_dig_connector->dp_i2c_bus)
		1601	DRM_ERROR("DP: Failed to assign dp ddc bus! Check dmesg for i2c errors.\n");
		1602	radeon_connector->ddc_bus = radeon_i2c_lookup(rdev, i2c_bus);
		1603	if (!radeon_connector->ddc_bus)
		1604	DRM_ERROR("DP: Failed to assign ddc bus! Check dmesg for i2c errors.\n");
		1605	}
1123	serge	1606	switch (connector_type) {
		1607	case DRM_MODE_CONNECTOR_VGA:
1963	serge	1608	case DRM_MODE_CONNECTOR_DVIA:
		1609	default:
		1610	connector->interlace_allowed = true;
		1611	connector->doublescan_allowed = true;
1986	serge	1612	radeon_connector->dac_load_detect = true;
3192	Serge	1613	drm_object_attach_property(&radeon_connector->base.base,
1986	serge	1614	rdev->mode_info.load_detect_property,
		1615	1);
1963	serge	1616	break;
		1617	case DRM_MODE_CONNECTOR_DVII:
		1618	case DRM_MODE_CONNECTOR_DVID:
		1619	case DRM_MODE_CONNECTOR_HDMIA:
		1620	case DRM_MODE_CONNECTOR_HDMIB:
		1621	case DRM_MODE_CONNECTOR_DisplayPort:
3192	Serge	1622	drm_object_attach_property(&radeon_connector->base.base,
1963	serge	1623	rdev->mode_info.underscan_property,
		1624	UNDERSCAN_OFF);
3192	Serge	1625	drm_object_attach_property(&radeon_connector->base.base,
1963	serge	1626	rdev->mode_info.underscan_hborder_property,
		1627	0);
3192	Serge	1628	drm_object_attach_property(&radeon_connector->base.base,
1963	serge	1629	rdev->mode_info.underscan_vborder_property,
		1630	0);
		1631	subpixel_order = SubPixelHorizontalRGB;
		1632	connector->interlace_allowed = true;
		1633	if (connector_type == DRM_MODE_CONNECTOR_HDMIB)
		1634	connector->doublescan_allowed = true;
		1635	else
		1636	connector->doublescan_allowed = false;
1986	serge	1637	if (connector_type == DRM_MODE_CONNECTOR_DVII) {
		1638	radeon_connector->dac_load_detect = true;
3192	Serge	1639	drm_object_attach_property(&radeon_connector->base.base,
1986	serge	1640	rdev->mode_info.load_detect_property,
		1641	1);
		1642	}
1963	serge	1643	break;
		1644	case DRM_MODE_CONNECTOR_LVDS:
		1645	case DRM_MODE_CONNECTOR_eDP:
3192	Serge	1646	drm_object_attach_property(&radeon_connector->base.base,
1963	serge	1647	dev->mode_config.scaling_mode_property,
		1648	DRM_MODE_SCALE_FULLSCREEN);
		1649	subpixel_order = SubPixelHorizontalRGB;
		1650	connector->interlace_allowed = false;
		1651	connector->doublescan_allowed = false;
		1652	break;
		1653	}
		1654	} else {
		1655	switch (connector_type) {
		1656	case DRM_MODE_CONNECTOR_VGA:
1123	serge	1657	drm_connector_init(dev, &radeon_connector->base, &radeon_vga_connector_funcs, connector_type);
1963	serge	1658	drm_connector_helper_add(&radeon_connector->base, &radeon_vga_connector_helper_funcs);
1123	serge	1659	if (i2c_bus->valid) {
1963	serge	1660	radeon_connector->ddc_bus = radeon_i2c_lookup(rdev, i2c_bus);
1123	serge	1661	if (!radeon_connector->ddc_bus)
1963	serge	1662	DRM_ERROR("VGA: Failed to assign ddc bus! Check dmesg for i2c errors.\n");
1123	serge	1663	}
1221	serge	1664	radeon_connector->dac_load_detect = true;
3192	Serge	1665	drm_object_attach_property(&radeon_connector->base.base,
1179	serge	1666	rdev->mode_info.load_detect_property,
		1667	1);
1963	serge	1668	/* no HPD on analog connectors */
		1669	radeon_connector->hpd.hpd = RADEON_HPD_NONE;
		1670	connector->polled = DRM_CONNECTOR_POLL_CONNECT;
		1671	connector->interlace_allowed = true;
		1672	connector->doublescan_allowed = true;
1123	serge	1673	break;
		1674	case DRM_MODE_CONNECTOR_DVIA:
		1675	drm_connector_init(dev, &radeon_connector->base, &radeon_vga_connector_funcs, connector_type);
1963	serge	1676	drm_connector_helper_add(&radeon_connector->base, &radeon_vga_connector_helper_funcs);
1123	serge	1677	if (i2c_bus->valid) {
1963	serge	1678	radeon_connector->ddc_bus = radeon_i2c_lookup(rdev, i2c_bus);
1123	serge	1679	if (!radeon_connector->ddc_bus)
1963	serge	1680	DRM_ERROR("DVIA: Failed to assign ddc bus! Check dmesg for i2c errors.\n");
1123	serge	1681	}
1221	serge	1682	radeon_connector->dac_load_detect = true;
3192	Serge	1683	drm_object_attach_property(&radeon_connector->base.base,
1179	serge	1684	rdev->mode_info.load_detect_property,
		1685	1);
1963	serge	1686	/* no HPD on analog connectors */
		1687	radeon_connector->hpd.hpd = RADEON_HPD_NONE;
		1688	connector->interlace_allowed = true;
		1689	connector->doublescan_allowed = true;
1123	serge	1690	break;
		1691	case DRM_MODE_CONNECTOR_DVII:
		1692	case DRM_MODE_CONNECTOR_DVID:
		1693	radeon_dig_connector = kzalloc(sizeof(struct radeon_connector_atom_dig), GFP_KERNEL);
		1694	if (!radeon_dig_connector)
		1695	goto failed;
		1696	radeon_dig_connector->igp_lane_info = igp_lane_info;
		1697	radeon_connector->con_priv = radeon_dig_connector;
		1698	drm_connector_init(dev, &radeon_connector->base, &radeon_dvi_connector_funcs, connector_type);
1963	serge	1699	drm_connector_helper_add(&radeon_connector->base, &radeon_dvi_connector_helper_funcs);
1123	serge	1700	if (i2c_bus->valid) {
1963	serge	1701	radeon_connector->ddc_bus = radeon_i2c_lookup(rdev, i2c_bus);
1123	serge	1702	if (!radeon_connector->ddc_bus)
1963	serge	1703	DRM_ERROR("DVI: Failed to assign ddc bus! Check dmesg for i2c errors.\n");
1123	serge	1704	}
		1705	subpixel_order = SubPixelHorizontalRGB;
3192	Serge	1706	drm_object_attach_property(&radeon_connector->base.base,
1179	serge	1707	rdev->mode_info.coherent_mode_property,
		1708	1);
1963	serge	1709	if (ASIC_IS_AVIVO(rdev)) {
3192	Serge	1710	drm_object_attach_property(&radeon_connector->base.base,
1963	serge	1711	rdev->mode_info.underscan_property,
		1712	UNDERSCAN_OFF);
3192	Serge	1713	drm_object_attach_property(&radeon_connector->base.base,
1963	serge	1714	rdev->mode_info.underscan_hborder_property,
		1715	0);
3192	Serge	1716	drm_object_attach_property(&radeon_connector->base.base,
1963	serge	1717	rdev->mode_info.underscan_vborder_property,
		1718	0);
		1719	}
1321	serge	1720	if (connector_type == DRM_MODE_CONNECTOR_DVII) {
1221	serge	1721	radeon_connector->dac_load_detect = true;
3192	Serge	1722	drm_object_attach_property(&radeon_connector->base.base,
1179	serge	1723	rdev->mode_info.load_detect_property,
		1724	1);
1321	serge	1725	}
1963	serge	1726	connector->interlace_allowed = true;
		1727	if (connector_type == DRM_MODE_CONNECTOR_DVII)
		1728	connector->doublescan_allowed = true;
		1729	else
		1730	connector->doublescan_allowed = false;
1123	serge	1731	break;
		1732	case DRM_MODE_CONNECTOR_HDMIA:
		1733	case DRM_MODE_CONNECTOR_HDMIB:
		1734	radeon_dig_connector = kzalloc(sizeof(struct radeon_connector_atom_dig), GFP_KERNEL);
		1735	if (!radeon_dig_connector)
		1736	goto failed;
		1737	radeon_dig_connector->igp_lane_info = igp_lane_info;
		1738	radeon_connector->con_priv = radeon_dig_connector;
		1739	drm_connector_init(dev, &radeon_connector->base, &radeon_dvi_connector_funcs, connector_type);
1963	serge	1740	drm_connector_helper_add(&radeon_connector->base, &radeon_dvi_connector_helper_funcs);
1123	serge	1741	if (i2c_bus->valid) {
1963	serge	1742	radeon_connector->ddc_bus = radeon_i2c_lookup(rdev, i2c_bus);
1123	serge	1743	if (!radeon_connector->ddc_bus)
1963	serge	1744	DRM_ERROR("HDMI: Failed to assign ddc bus! Check dmesg for i2c errors.\n");
1123	serge	1745	}
3192	Serge	1746	drm_object_attach_property(&radeon_connector->base.base,
1179	serge	1747	rdev->mode_info.coherent_mode_property,
		1748	1);
1963	serge	1749	if (ASIC_IS_AVIVO(rdev)) {
3192	Serge	1750	drm_object_attach_property(&radeon_connector->base.base,
1963	serge	1751	rdev->mode_info.underscan_property,
		1752	UNDERSCAN_OFF);
3192	Serge	1753	drm_object_attach_property(&radeon_connector->base.base,
1963	serge	1754	rdev->mode_info.underscan_hborder_property,
		1755	0);
3192	Serge	1756	drm_object_attach_property(&radeon_connector->base.base,
1963	serge	1757	rdev->mode_info.underscan_vborder_property,
		1758	0);
		1759	}
1123	serge	1760	subpixel_order = SubPixelHorizontalRGB;
1963	serge	1761	connector->interlace_allowed = true;
		1762	if (connector_type == DRM_MODE_CONNECTOR_HDMIB)
		1763	connector->doublescan_allowed = true;
		1764	else
		1765	connector->doublescan_allowed = false;
1123	serge	1766	break;
		1767	case DRM_MODE_CONNECTOR_DisplayPort:
		1768	radeon_dig_connector = kzalloc(sizeof(struct radeon_connector_atom_dig), GFP_KERNEL);
		1769	if (!radeon_dig_connector)
		1770	goto failed;
		1771	radeon_dig_connector->igp_lane_info = igp_lane_info;
		1772	radeon_connector->con_priv = radeon_dig_connector;
1321	serge	1773	drm_connector_init(dev, &radeon_connector->base, &radeon_dp_connector_funcs, connector_type);
1963	serge	1774	drm_connector_helper_add(&radeon_connector->base, &radeon_dp_connector_helper_funcs);
1123	serge	1775	if (i2c_bus->valid) {
1321	serge	1776	/* add DP i2c bus */
		1777	radeon_dig_connector->dp_i2c_bus = radeon_i2c_create_dp(dev, i2c_bus, "DP-auxch");
		1778	if (!radeon_dig_connector->dp_i2c_bus)
1963	serge	1779	DRM_ERROR("DP: Failed to assign dp ddc bus! Check dmesg for i2c errors.\n");
		1780	radeon_connector->ddc_bus = radeon_i2c_lookup(rdev, i2c_bus);
1123	serge	1781	if (!radeon_connector->ddc_bus)
1963	serge	1782	DRM_ERROR("DP: Failed to assign ddc bus! Check dmesg for i2c errors.\n");
1123	serge	1783	}
		1784	subpixel_order = SubPixelHorizontalRGB;
3192	Serge	1785	drm_object_attach_property(&radeon_connector->base.base,
1321	serge	1786	rdev->mode_info.coherent_mode_property,
		1787	1);
1963	serge	1788	if (ASIC_IS_AVIVO(rdev)) {
3192	Serge	1789	drm_object_attach_property(&radeon_connector->base.base,
1963	serge	1790	rdev->mode_info.underscan_property,
		1791	UNDERSCAN_OFF);
3192	Serge	1792	drm_object_attach_property(&radeon_connector->base.base,
1963	serge	1793	rdev->mode_info.underscan_hborder_property,
		1794	0);
3192	Serge	1795	drm_object_attach_property(&radeon_connector->base.base,
1963	serge	1796	rdev->mode_info.underscan_vborder_property,
		1797	0);
		1798	}
		1799	connector->interlace_allowed = true;
		1800	/* in theory with a DP to VGA converter... */
		1801	connector->doublescan_allowed = false;
1123	serge	1802	break;
1963	serge	1803	case DRM_MODE_CONNECTOR_eDP:
		1804	radeon_dig_connector = kzalloc(sizeof(struct radeon_connector_atom_dig), GFP_KERNEL);
		1805	if (!radeon_dig_connector)
		1806	goto failed;
		1807	radeon_dig_connector->igp_lane_info = igp_lane_info;
		1808	radeon_connector->con_priv = radeon_dig_connector;
		1809	drm_connector_init(dev, &radeon_connector->base, &radeon_dp_connector_funcs, connector_type);
		1810	drm_connector_helper_add(&radeon_connector->base, &radeon_dp_connector_helper_funcs);
		1811	if (i2c_bus->valid) {
		1812	/* add DP i2c bus */
		1813	radeon_dig_connector->dp_i2c_bus = radeon_i2c_create_dp(dev, i2c_bus, "eDP-auxch");
		1814	if (!radeon_dig_connector->dp_i2c_bus)
		1815	DRM_ERROR("DP: Failed to assign dp ddc bus! Check dmesg for i2c errors.\n");
		1816	radeon_connector->ddc_bus = radeon_i2c_lookup(rdev, i2c_bus);
		1817	if (!radeon_connector->ddc_bus)
		1818	DRM_ERROR("DP: Failed to assign ddc bus! Check dmesg for i2c errors.\n");
		1819	}
3192	Serge	1820	drm_object_attach_property(&radeon_connector->base.base,
1963	serge	1821	dev->mode_config.scaling_mode_property,
		1822	DRM_MODE_SCALE_FULLSCREEN);
		1823	subpixel_order = SubPixelHorizontalRGB;
		1824	connector->interlace_allowed = false;
		1825	connector->doublescan_allowed = false;
		1826	break;
1123	serge	1827	case DRM_MODE_CONNECTOR_SVIDEO:
		1828	case DRM_MODE_CONNECTOR_Composite:
		1829	case DRM_MODE_CONNECTOR_9PinDIN:
1179	serge	1830	drm_connector_init(dev, &radeon_connector->base, &radeon_tv_connector_funcs, connector_type);
1963	serge	1831	drm_connector_helper_add(&radeon_connector->base, &radeon_tv_connector_helper_funcs);
1221	serge	1832	radeon_connector->dac_load_detect = true;
3192	Serge	1833	drm_object_attach_property(&radeon_connector->base.base,
1179	serge	1834	rdev->mode_info.load_detect_property,
		1835	1);
3192	Serge	1836	drm_object_attach_property(&radeon_connector->base.base,
1321	serge	1837	rdev->mode_info.tv_std_property,
1403	serge	1838	radeon_atombios_get_tv_info(rdev));
1963	serge	1839	/* no HPD on analog connectors */
		1840	radeon_connector->hpd.hpd = RADEON_HPD_NONE;
		1841	connector->interlace_allowed = false;
		1842	connector->doublescan_allowed = false;
1123	serge	1843	break;
		1844	case DRM_MODE_CONNECTOR_LVDS:
		1845	radeon_dig_connector = kzalloc(sizeof(struct radeon_connector_atom_dig), GFP_KERNEL);
		1846	if (!radeon_dig_connector)
		1847	goto failed;
		1848	radeon_dig_connector->igp_lane_info = igp_lane_info;
		1849	radeon_connector->con_priv = radeon_dig_connector;
		1850	drm_connector_init(dev, &radeon_connector->base, &radeon_lvds_connector_funcs, connector_type);
1963	serge	1851	drm_connector_helper_add(&radeon_connector->base, &radeon_lvds_connector_helper_funcs);
1123	serge	1852	if (i2c_bus->valid) {
1963	serge	1853	radeon_connector->ddc_bus = radeon_i2c_lookup(rdev, i2c_bus);
1123	serge	1854	if (!radeon_connector->ddc_bus)
1963	serge	1855	DRM_ERROR("LVDS: Failed to assign ddc bus! Check dmesg for i2c errors.\n");
1123	serge	1856	}
3192	Serge	1857	drm_object_attach_property(&radeon_connector->base.base,
1179	serge	1858	dev->mode_config.scaling_mode_property,
		1859	DRM_MODE_SCALE_FULLSCREEN);
1123	serge	1860	subpixel_order = SubPixelHorizontalRGB;
1963	serge	1861	connector->interlace_allowed = false;
		1862	connector->doublescan_allowed = false;
1123	serge	1863	break;
		1864	}
1963	serge	1865	}
1123	serge	1866
1963	serge	1867	if (radeon_connector->hpd.hpd == RADEON_HPD_NONE) {
		1868	if (i2c_bus->valid)
		1869	connector->polled = DRM_CONNECTOR_POLL_CONNECT;
		1870	} else
		1871	connector->polled = DRM_CONNECTOR_POLL_HPD;
		1872
1123	serge	1873	connector->display_info.subpixel_order = subpixel_order;
3764	Serge	1874	drm_sysfs_connector_add(connector);
1123	serge	1875	return;
		1876
		1877	failed:
		1878	drm_connector_cleanup(connector);
		1879	kfree(connector);
		1880	}
		1881
		1882	void
		1883	radeon_add_legacy_connector(struct drm_device *dev,
		1884	uint32_t connector_id,
		1885	uint32_t supported_device,
		1886	int connector_type,
1268	serge	1887	struct radeon_i2c_bus_rec *i2c_bus,
1321	serge	1888	uint16_t connector_object_id,
		1889	struct radeon_hpd *hpd)
1123	serge	1890	{
1179	serge	1891	struct radeon_device *rdev = dev->dev_private;
1123	serge	1892	struct drm_connector *connector;
		1893	struct radeon_connector *radeon_connector;
		1894	uint32_t subpixel_order = SubPixelNone;
		1895
1179	serge	1896	if (connector_type == DRM_MODE_CONNECTOR_Unknown)
1123	serge	1897	return;
		1898
1963	serge	1899	/* if the user selected tv=0 don't try and add the connector */
		1900	if (((connector_type == DRM_MODE_CONNECTOR_SVIDEO) \|\|
		1901	(connector_type == DRM_MODE_CONNECTOR_Composite) \|\|
		1902	(connector_type == DRM_MODE_CONNECTOR_9PinDIN)) &&
		1903	(radeon_tv == 0))
		1904	return;
		1905
1123	serge	1906	/* see if we already added it */
		1907	list_for_each_entry(connector, &dev->mode_config.connector_list, head) {
		1908	radeon_connector = to_radeon_connector(connector);
		1909	if (radeon_connector->connector_id == connector_id) {
		1910	radeon_connector->devices \|= supported_device;
		1911	return;
		1912	}
		1913	}
		1914
		1915	radeon_connector = kzalloc(sizeof(struct radeon_connector), GFP_KERNEL);
		1916	if (!radeon_connector)
		1917	return;
		1918
		1919	connector = &radeon_connector->base;
		1920
		1921	radeon_connector->connector_id = connector_id;
		1922	radeon_connector->devices = supported_device;
1268	serge	1923	radeon_connector->connector_object_id = connector_object_id;
1321	serge	1924	radeon_connector->hpd = *hpd;
2997	Serge	1925
1123	serge	1926	switch (connector_type) {
		1927	case DRM_MODE_CONNECTOR_VGA:
		1928	drm_connector_init(dev, &radeon_connector->base, &radeon_vga_connector_funcs, connector_type);
1963	serge	1929	drm_connector_helper_add(&radeon_connector->base, &radeon_vga_connector_helper_funcs);
1123	serge	1930	if (i2c_bus->valid) {
1963	serge	1931	radeon_connector->ddc_bus = radeon_i2c_lookup(rdev, i2c_bus);
1123	serge	1932	if (!radeon_connector->ddc_bus)
1963	serge	1933	DRM_ERROR("VGA: Failed to assign ddc bus! Check dmesg for i2c errors.\n");
1123	serge	1934	}
1221	serge	1935	radeon_connector->dac_load_detect = true;
3192	Serge	1936	drm_object_attach_property(&radeon_connector->base.base,
1179	serge	1937	rdev->mode_info.load_detect_property,
		1938	1);
1963	serge	1939	/* no HPD on analog connectors */
		1940	radeon_connector->hpd.hpd = RADEON_HPD_NONE;
		1941	connector->polled = DRM_CONNECTOR_POLL_CONNECT;
		1942	connector->interlace_allowed = true;
		1943	connector->doublescan_allowed = true;
1123	serge	1944	break;
		1945	case DRM_MODE_CONNECTOR_DVIA:
		1946	drm_connector_init(dev, &radeon_connector->base, &radeon_vga_connector_funcs, connector_type);
1963	serge	1947	drm_connector_helper_add(&radeon_connector->base, &radeon_vga_connector_helper_funcs);
1123	serge	1948	if (i2c_bus->valid) {
1963	serge	1949	radeon_connector->ddc_bus = radeon_i2c_lookup(rdev, i2c_bus);
1123	serge	1950	if (!radeon_connector->ddc_bus)
1963	serge	1951	DRM_ERROR("DVIA: Failed to assign ddc bus! Check dmesg for i2c errors.\n");
1123	serge	1952	}
1221	serge	1953	radeon_connector->dac_load_detect = true;
3192	Serge	1954	drm_object_attach_property(&radeon_connector->base.base,
1179	serge	1955	rdev->mode_info.load_detect_property,
		1956	1);
1963	serge	1957	/* no HPD on analog connectors */
		1958	radeon_connector->hpd.hpd = RADEON_HPD_NONE;
		1959	connector->interlace_allowed = true;
		1960	connector->doublescan_allowed = true;
1123	serge	1961	break;
		1962	case DRM_MODE_CONNECTOR_DVII:
		1963	case DRM_MODE_CONNECTOR_DVID:
		1964	drm_connector_init(dev, &radeon_connector->base, &radeon_dvi_connector_funcs, connector_type);
1963	serge	1965	drm_connector_helper_add(&radeon_connector->base, &radeon_dvi_connector_helper_funcs);
1123	serge	1966	if (i2c_bus->valid) {
1963	serge	1967	radeon_connector->ddc_bus = radeon_i2c_lookup(rdev, i2c_bus);
1123	serge	1968	if (!radeon_connector->ddc_bus)
1963	serge	1969	DRM_ERROR("DVI: Failed to assign ddc bus! Check dmesg for i2c errors.\n");
		1970	}
		1971	if (connector_type == DRM_MODE_CONNECTOR_DVII) {
1221	serge	1972	radeon_connector->dac_load_detect = true;
3192	Serge	1973	drm_object_attach_property(&radeon_connector->base.base,
1179	serge	1974	rdev->mode_info.load_detect_property,
		1975	1);
1123	serge	1976	}
		1977	subpixel_order = SubPixelHorizontalRGB;
1963	serge	1978	connector->interlace_allowed = true;
		1979	if (connector_type == DRM_MODE_CONNECTOR_DVII)
		1980	connector->doublescan_allowed = true;
		1981	else
		1982	connector->doublescan_allowed = false;
1123	serge	1983	break;
		1984	case DRM_MODE_CONNECTOR_SVIDEO:
		1985	case DRM_MODE_CONNECTOR_Composite:
		1986	case DRM_MODE_CONNECTOR_9PinDIN:
1179	serge	1987	drm_connector_init(dev, &radeon_connector->base, &radeon_tv_connector_funcs, connector_type);
1963	serge	1988	drm_connector_helper_add(&radeon_connector->base, &radeon_tv_connector_helper_funcs);
1221	serge	1989	radeon_connector->dac_load_detect = true;
1313	serge	1990	/* RS400,RC410,RS480 chipset seems to report a lot
		1991	* of false positive on load detect, we haven't yet
		1992	* found a way to make load detect reliable on those
		1993	* chipset, thus just disable it for TV.
		1994	*/
		1995	if (rdev->family == CHIP_RS400 \|\| rdev->family == CHIP_RS480)
		1996	radeon_connector->dac_load_detect = false;
3192	Serge	1997	drm_object_attach_property(&radeon_connector->base.base,
1179	serge	1998	rdev->mode_info.load_detect_property,
1404	serge	1999	radeon_connector->dac_load_detect);
3192	Serge	2000	drm_object_attach_property(&radeon_connector->base.base,
1321	serge	2001	rdev->mode_info.tv_std_property,
1403	serge	2002	radeon_combios_get_tv_info(rdev));
1963	serge	2003	/* no HPD on analog connectors */
		2004	radeon_connector->hpd.hpd = RADEON_HPD_NONE;
		2005	connector->interlace_allowed = false;
		2006	connector->doublescan_allowed = false;
1123	serge	2007	break;
		2008	case DRM_MODE_CONNECTOR_LVDS:
		2009	drm_connector_init(dev, &radeon_connector->base, &radeon_lvds_connector_funcs, connector_type);
1963	serge	2010	drm_connector_helper_add(&radeon_connector->base, &radeon_lvds_connector_helper_funcs);
1123	serge	2011	if (i2c_bus->valid) {
1963	serge	2012	radeon_connector->ddc_bus = radeon_i2c_lookup(rdev, i2c_bus);
1123	serge	2013	if (!radeon_connector->ddc_bus)
1963	serge	2014	DRM_ERROR("LVDS: Failed to assign ddc bus! Check dmesg for i2c errors.\n");
1123	serge	2015	}
3192	Serge	2016	drm_object_attach_property(&radeon_connector->base.base,
1179	serge	2017	dev->mode_config.scaling_mode_property,
		2018	DRM_MODE_SCALE_FULLSCREEN);
1123	serge	2019	subpixel_order = SubPixelHorizontalRGB;
1963	serge	2020	connector->interlace_allowed = false;
		2021	connector->doublescan_allowed = false;
1123	serge	2022	break;
		2023	}
		2024
1963	serge	2025	if (radeon_connector->hpd.hpd == RADEON_HPD_NONE) {
		2026	if (i2c_bus->valid)
		2027	connector->polled = DRM_CONNECTOR_POLL_CONNECT;
		2028	} else
		2029	connector->polled = DRM_CONNECTOR_POLL_HPD;
1123	serge	2030	connector->display_info.subpixel_order = subpixel_order;
3764	Serge	2031	drm_sysfs_connector_add(connector);
1123	serge	2032	}

Subversion Repositories Kolibri OS

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