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	*/
		26	#include "drmP.h"
1126	serge	27	#include "drm_edid.h"
1123	serge	28	#include "drm_crtc_helper.h"
1221	serge	29	#include "drm_fb_helper.h"
1123	serge	30	#include "radeon_drm.h"
		31	#include "radeon.h"
1179	serge	32	#include "atom.h"
1123	serge	33
		34	extern void
		35	radeon_combios_connected_scratch_regs(struct drm_connector *connector,
		36	struct drm_encoder *encoder,
		37	bool connected);
		38	extern void
		39	radeon_atombios_connected_scratch_regs(struct drm_connector *connector,
		40	struct drm_encoder *encoder,
		41	bool connected);
		42
1321	serge	43	void radeon_connector_hotplug(struct drm_connector *connector)
		44	{
		45	struct drm_device *dev = connector->dev;
		46	struct radeon_device *rdev = dev->dev_private;
		47	struct radeon_connector *radeon_connector = to_radeon_connector(connector);
		48
		49	if (radeon_connector->hpd.hpd != RADEON_HPD_NONE)
		50	radeon_hpd_set_polarity(rdev, radeon_connector->hpd.hpd);
		51
1403	serge	52	if ((connector->connector_type == DRM_MODE_CONNECTOR_DisplayPort) \|\|
		53	(connector->connector_type == DRM_MODE_CONNECTOR_eDP)) {
		54	if ((radeon_dp_getsinktype(radeon_connector) == CONNECTOR_OBJECT_ID_DISPLAYPORT) \|\|
		55	(radeon_dp_getsinktype(radeon_connector) == CONNECTOR_OBJECT_ID_eDP)) {
1321	serge	56	if (radeon_dp_needs_link_train(radeon_connector)) {
		57	if (connector->encoder)
		58	dp_link_train(connector->encoder, connector);
		59	}
		60	}
		61	}
		62
		63	}
		64
1179	serge	65	static void radeon_property_change_mode(struct drm_encoder *encoder)
		66	{
		67	struct drm_crtc *crtc = encoder->crtc;
		68
		69	if (crtc && crtc->enabled) {
		70	drm_crtc_helper_set_mode(crtc, &crtc->mode,
		71	crtc->x, crtc->y, crtc->fb);
		72	}
		73	}
1123	serge	74	static void
		75	radeon_connector_update_scratch_regs(struct drm_connector *connector, enum drm_connector_status status)
		76	{
		77	struct drm_device *dev = connector->dev;
		78	struct radeon_device *rdev = dev->dev_private;
		79	struct drm_encoder *best_encoder = NULL;
		80	struct drm_encoder *encoder = NULL;
		81	struct drm_connector_helper_funcs *connector_funcs = connector->helper_private;
		82	struct drm_mode_object *obj;
		83	bool connected;
		84	int i;
		85
		86	best_encoder = connector_funcs->best_encoder(connector);
		87
		88	for (i = 0; i < DRM_CONNECTOR_MAX_ENCODER; i++) {
		89	if (connector->encoder_ids[i] == 0)
		90	break;
		91
		92	obj = drm_mode_object_find(connector->dev,
		93	connector->encoder_ids[i],
		94	DRM_MODE_OBJECT_ENCODER);
		95	if (!obj)
		96	continue;
		97
		98	encoder = obj_to_encoder(obj);
		99
		100	if ((encoder == best_encoder) && (status == connector_status_connected))
		101	connected = true;
		102	else
		103	connected = false;
		104
		105	if (rdev->is_atom_bios)
		106	radeon_atombios_connected_scratch_regs(connector, encoder, connected);
		107	else
		108	radeon_combios_connected_scratch_regs(connector, encoder, connected);
		109
		110	}
		111	}
		112
1179	serge	113	struct drm_encoder radeon_find_encoder(struct drm_connector connector, int encoder_type)
		114	{
		115	struct drm_mode_object *obj;
		116	struct drm_encoder *encoder;
		117	int i;
		118
		119	for (i = 0; i < DRM_CONNECTOR_MAX_ENCODER; i++) {
		120	if (connector->encoder_ids[i] == 0)
		121	break;
		122
		123	obj = drm_mode_object_find(connector->dev, connector->encoder_ids[i], DRM_MODE_OBJECT_ENCODER);
		124	if (!obj)
		125	continue;
		126
		127	encoder = obj_to_encoder(obj);
		128	if (encoder->encoder_type == encoder_type)
		129	return encoder;
		130	}
		131	return NULL;
		132	}
		133
1123	serge	134	struct drm_encoder radeon_best_single_encoder(struct drm_connector connector)
		135	{
		136	int enc_id = connector->encoder_ids[0];
		137	struct drm_mode_object *obj;
		138	struct drm_encoder *encoder;
		139
		140	/* pick the encoder ids */
		141	if (enc_id) {
		142	obj = drm_mode_object_find(connector->dev, enc_id, DRM_MODE_OBJECT_ENCODER);
		143	if (!obj)
		144	return NULL;
		145	encoder = obj_to_encoder(obj);
		146	return encoder;
		147	}
		148	return NULL;
		149	}
		150
1179	serge	151	/*
		152	* radeon_connector_analog_encoder_conflict_solve
		153	* - search for other connectors sharing this encoder
		154	* if priority is true, then set them disconnected if this is connected
		155	* if priority is false, set us disconnected if they are connected
		156	*/
		157	static enum drm_connector_status
		158	radeon_connector_analog_encoder_conflict_solve(struct drm_connector *connector,
		159	struct drm_encoder *encoder,
		160	enum drm_connector_status current_status,
		161	bool priority)
		162	{
		163	struct drm_device *dev = connector->dev;
		164	struct drm_connector *conflict;
		165	int i;
		166
		167	list_for_each_entry(conflict, &dev->mode_config.connector_list, head) {
		168	if (conflict == connector)
		169	continue;
		170
		171	for (i = 0; i < DRM_CONNECTOR_MAX_ENCODER; i++) {
		172	if (conflict->encoder_ids[i] == 0)
		173	break;
		174
		175	/* if the IDs match */
		176	if (conflict->encoder_ids[i] == encoder->base.id) {
		177	if (conflict->status != connector_status_connected)
		178	continue;
		179
		180	if (priority == true) {
		181	DRM_INFO("1: conflicting encoders switching off %s\n", drm_get_connector_name(conflict));
		182	DRM_INFO("in favor of %s\n", drm_get_connector_name(connector));
		183	conflict->status = connector_status_disconnected;
		184	radeon_connector_update_scratch_regs(conflict, connector_status_disconnected);
		185	} else {
		186	DRM_INFO("2: conflicting encoders switching off %s\n", drm_get_connector_name(connector));
		187	DRM_INFO("in favor of %s\n", drm_get_connector_name(conflict));
		188	current_status = connector_status_disconnected;
		189	}
		190	break;
		191	}
		192	}
		193	}
		194	return current_status;
		195
		196	}
		197
1123	serge	198	static struct drm_display_mode radeon_fp_native_mode(struct drm_encoder encoder)
		199	{
		200	struct drm_device *dev = encoder->dev;
		201	struct radeon_encoder *radeon_encoder = to_radeon_encoder(encoder);
		202	struct drm_display_mode *mode = NULL;
1268	serge	203	struct drm_display_mode *native_mode = &radeon_encoder->native_mode;
1123	serge	204
1268	serge	205	if (native_mode->hdisplay != 0 &&
		206	native_mode->vdisplay != 0 &&
		207	native_mode->clock != 0) {
		208	mode = drm_mode_duplicate(dev, native_mode);
1123	serge	209	mode->type = DRM_MODE_TYPE_PREFERRED \| DRM_MODE_TYPE_DRIVER;
		210	drm_mode_set_name(mode);
		211
		212	DRM_DEBUG("Adding native panel mode %s\n", mode->name);
1403	serge	213	} else if (native_mode->hdisplay != 0 &&
		214	native_mode->vdisplay != 0) {
		215	/* mac laptops without an edid */
		216	/* Note that this is not necessarily the exact panel mode,
		217	* but an approximation based on the cvt formula. For these
		218	* systems we should ideally read the mode info out of the
		219	* registers or add a mode table, but this works and is much
		220	* simpler.
		221	*/
		222	mode = drm_cvt_mode(dev, native_mode->hdisplay, native_mode->vdisplay, 60, true, false, false);
		223	mode->type = DRM_MODE_TYPE_PREFERRED \| DRM_MODE_TYPE_DRIVER;
		224	DRM_DEBUG("Adding cvt approximation of native panel mode %s\n", mode->name);
1123	serge	225	}
		226	return mode;
		227	}
		228
1179	serge	229	static void radeon_add_common_modes(struct drm_encoder encoder, struct drm_connector connector)
		230	{
		231	struct drm_device *dev = encoder->dev;
		232	struct radeon_encoder *radeon_encoder = to_radeon_encoder(encoder);
		233	struct drm_display_mode *mode = NULL;
1268	serge	234	struct drm_display_mode *native_mode = &radeon_encoder->native_mode;
1179	serge	235	int i;
		236	struct mode_size {
		237	int w;
		238	int h;
		239	} common_modes[17] = {
		240	{ 640, 480},
		241	{ 720, 480},
		242	{ 800, 600},
		243	{ 848, 480},
		244	{1024, 768},
		245	{1152, 768},
		246	{1280, 720},
		247	{1280, 800},
		248	{1280, 854},
		249	{1280, 960},
		250	{1280, 1024},
		251	{1440, 900},
		252	{1400, 1050},
		253	{1680, 1050},
		254	{1600, 1200},
		255	{1920, 1080},
		256	{1920, 1200}
		257	};
		258
		259	for (i = 0; i < 17; i++) {
1268	serge	260	if (radeon_encoder->devices & (ATOM_DEVICE_TV_SUPPORT)) {
		261	if (common_modes[i].w > 1024 \|\|
		262	common_modes[i].h > 768)
		263	continue;
		264	}
1179	serge	265	if (radeon_encoder->devices & (ATOM_DEVICE_LCD_SUPPORT)) {
1268	serge	266	if (common_modes[i].w > native_mode->hdisplay \|\|
		267	common_modes[i].h > native_mode->vdisplay \|\|
		268	(common_modes[i].w == native_mode->hdisplay &&
		269	common_modes[i].h == native_mode->vdisplay))
1179	serge	270	continue;
		271	}
		272	if (common_modes[i].w < 320 \|\| common_modes[i].h < 200)
		273	continue;
		274
1221	serge	275	mode = drm_cvt_mode(dev, common_modes[i].w, common_modes[i].h, 60, false, false, false);
1179	serge	276	drm_mode_probed_add(connector, mode);
		277	}
		278	}
		279
1123	serge	280	int radeon_connector_set_property(struct drm_connector connector, struct drm_property property,
		281	uint64_t val)
		282	{
1179	serge	283	struct drm_device *dev = connector->dev;
		284	struct radeon_device *rdev = dev->dev_private;
		285	struct drm_encoder *encoder;
		286	struct radeon_encoder *radeon_encoder;
		287
		288	if (property == rdev->mode_info.coherent_mode_property) {
		289	struct radeon_encoder_atom_dig *dig;
		290
		291	/* need to find digital encoder on connector */
		292	encoder = radeon_find_encoder(connector, DRM_MODE_ENCODER_TMDS);
		293	if (!encoder)
		294	return 0;
		295
		296	radeon_encoder = to_radeon_encoder(encoder);
		297
		298	if (!radeon_encoder->enc_priv)
		299	return 0;
		300
		301	dig = radeon_encoder->enc_priv;
		302	dig->coherent_mode = val ? true : false;
		303	radeon_property_change_mode(&radeon_encoder->base);
		304	}
		305
		306	if (property == rdev->mode_info.tv_std_property) {
		307	encoder = radeon_find_encoder(connector, DRM_MODE_ENCODER_TVDAC);
		308	if (!encoder) {
		309	encoder = radeon_find_encoder(connector, DRM_MODE_ENCODER_DAC);
		310	}
		311
		312	if (!encoder)
		313	return 0;
		314
		315	radeon_encoder = to_radeon_encoder(encoder);
		316	if (!radeon_encoder->enc_priv)
		317	return 0;
		318	if (rdev->is_atom_bios) {
		319	struct radeon_encoder_atom_dac *dac_int;
		320	dac_int = radeon_encoder->enc_priv;
		321	dac_int->tv_std = val;
		322	} else {
		323	struct radeon_encoder_tv_dac *dac_int;
		324	dac_int = radeon_encoder->enc_priv;
		325	dac_int->tv_std = val;
		326	}
		327	radeon_property_change_mode(&radeon_encoder->base);
		328	}
		329
		330	if (property == rdev->mode_info.load_detect_property) {
		331	struct radeon_connector *radeon_connector =
		332	to_radeon_connector(connector);
		333
		334	if (val == 0)
		335	radeon_connector->dac_load_detect = false;
		336	else
		337	radeon_connector->dac_load_detect = true;
		338	}
		339
		340	if (property == rdev->mode_info.tmds_pll_property) {
		341	struct radeon_encoder_int_tmds *tmds = NULL;
		342	bool ret = false;
		343	/* need to find digital encoder on connector */
		344	encoder = radeon_find_encoder(connector, DRM_MODE_ENCODER_TMDS);
		345	if (!encoder)
		346	return 0;
		347
		348	radeon_encoder = to_radeon_encoder(encoder);
		349
		350	tmds = radeon_encoder->enc_priv;
		351	if (!tmds)
		352	return 0;
		353
		354	if (val == 0) {
		355	if (rdev->is_atom_bios)
		356	ret = radeon_atombios_get_tmds_info(radeon_encoder, tmds);
		357	else
		358	ret = radeon_legacy_get_tmds_info_from_combios(radeon_encoder, tmds);
		359	}
		360	if (val == 1 \|\| ret == false) {
		361	radeon_legacy_get_tmds_info_from_table(radeon_encoder, tmds);
		362	}
		363	radeon_property_change_mode(&radeon_encoder->base);
		364	}
		365
1123	serge	366	return 0;
		367	}
		368
1179	serge	369	static void radeon_fixup_lvds_native_mode(struct drm_encoder *encoder,
		370	struct drm_connector *connector)
		371	{
		372	struct radeon_encoder *radeon_encoder = to_radeon_encoder(encoder);
1268	serge	373	struct drm_display_mode *native_mode = &radeon_encoder->native_mode;
1123	serge	374
1179	serge	375	/* Try to get native mode details from EDID if necessary */
1268	serge	376	if (!native_mode->clock) {
1179	serge	377	struct drm_display_mode t, mode;
		378
		379	list_for_each_entry_safe(mode, t, &connector->probed_modes, head) {
1268	serge	380	if (mode->hdisplay == native_mode->hdisplay &&
		381	mode->vdisplay == native_mode->vdisplay) {
		382	native_mode = mode;
		383	drm_mode_set_crtcinfo(native_mode, CRTC_INTERLACE_HALVE_V);
1179	serge	384	DRM_INFO("Determined LVDS native mode details from EDID\n");
		385	break;
		386	}
		387	}
		388	}
1268	serge	389	if (!native_mode->clock) {
1179	serge	390	DRM_INFO("No LVDS native mode details, disabling RMX\n");
		391	radeon_encoder->rmx_type = RMX_OFF;
		392	}
		393	}
		394
1123	serge	395	static int radeon_lvds_get_modes(struct drm_connector *connector)
		396	{
		397	struct radeon_connector *radeon_connector = to_radeon_connector(connector);
		398	struct drm_encoder *encoder;
		399	int ret = 0;
		400	struct drm_display_mode *mode;
		401
		402	if (radeon_connector->ddc_bus) {
		403	ret = radeon_ddc_get_modes(radeon_connector);
		404	if (ret > 0) {
1179	serge	405	encoder = radeon_best_single_encoder(connector);
		406	if (encoder) {
		407	radeon_fixup_lvds_native_mode(encoder, connector);
		408	/* add scaled modes */
		409	radeon_add_common_modes(encoder, connector);
		410	}
1123	serge	411	return ret;
		412	}
		413	}
		414
		415	encoder = radeon_best_single_encoder(connector);
		416	if (!encoder)
		417	return 0;
		418
		419	/* we have no EDID modes */
		420	mode = radeon_fp_native_mode(encoder);
		421	if (mode) {
		422	ret = 1;
		423	drm_mode_probed_add(connector, mode);
1179	serge	424	/* add scaled modes */
		425	radeon_add_common_modes(encoder, connector);
1123	serge	426	}
1179	serge	427
1123	serge	428	return ret;
		429	}
		430
		431	static int radeon_lvds_mode_valid(struct drm_connector *connector,
		432	struct drm_display_mode *mode)
		433	{
1268	serge	434	struct drm_encoder *encoder = radeon_best_single_encoder(connector);
		435
		436	if ((mode->hdisplay < 320) \|\| (mode->vdisplay < 240))
		437	return MODE_PANEL;
		438
		439	if (encoder) {
		440	struct radeon_encoder *radeon_encoder = to_radeon_encoder(encoder);
		441	struct drm_display_mode *native_mode = &radeon_encoder->native_mode;
		442
		443	/* AVIVO hardware supports downscaling modes larger than the panel
		444	* to the panel size, but I'm not sure this is desirable.
		445	*/
		446	if ((mode->hdisplay > native_mode->hdisplay) \|\|
		447	(mode->vdisplay > native_mode->vdisplay))
		448	return MODE_PANEL;
		449
		450	/* if scaling is disabled, block non-native modes */
		451	if (radeon_encoder->rmx_type == RMX_OFF) {
		452	if ((mode->hdisplay != native_mode->hdisplay) \|\|
		453	(mode->vdisplay != native_mode->vdisplay))
		454	return MODE_PANEL;
		455	}
		456	}
		457
1123	serge	458	return MODE_OK;
		459	}
		460
		461	static enum drm_connector_status radeon_lvds_detect(struct drm_connector *connector)
		462	{
1268	serge	463	struct radeon_connector *radeon_connector = to_radeon_connector(connector);
		464	struct drm_encoder *encoder = radeon_best_single_encoder(connector);
		465	enum drm_connector_status ret = connector_status_disconnected;
		466
		467	if (encoder) {
		468	struct radeon_encoder *radeon_encoder = to_radeon_encoder(encoder);
		469	struct drm_display_mode *native_mode = &radeon_encoder->native_mode;
		470
		471	/* check if panel is valid */
		472	if (native_mode->hdisplay >= 320 && native_mode->vdisplay >= 240)
		473	ret = connector_status_connected;
		474
		475	}
		476
		477	/* check for edid as well */
		478	if (radeon_connector->edid)
		479	ret = connector_status_connected;
		480	else {
		481	if (radeon_connector->ddc_bus) {
1321	serge	482	radeon_i2c_do_lock(radeon_connector->ddc_bus, 1);
1268	serge	483	radeon_connector->edid = drm_get_edid(&radeon_connector->base,
		484	&radeon_connector->ddc_bus->adapter);
1321	serge	485	radeon_i2c_do_lock(radeon_connector->ddc_bus, 0);
1268	serge	486	if (radeon_connector->edid)
		487	ret = connector_status_connected;
		488	}
		489	}
1123	serge	490	/* check acpi lid status ??? */
1268	serge	491
1123	serge	492	radeon_connector_update_scratch_regs(connector, ret);
		493	return ret;
		494	}
		495
		496	static void radeon_connector_destroy(struct drm_connector *connector)
		497	{
		498	struct radeon_connector *radeon_connector = to_radeon_connector(connector);
		499
		500	if (radeon_connector->ddc_bus)
		501	radeon_i2c_destroy(radeon_connector->ddc_bus);
1268	serge	502	if (radeon_connector->edid)
		503	kfree(radeon_connector->edid);
1123	serge	504	kfree(radeon_connector->con_priv);
1233	serge	505	drm_sysfs_connector_remove(connector);
1123	serge	506	drm_connector_cleanup(connector);
		507	kfree(connector);
		508	}
		509
1179	serge	510	static int radeon_lvds_set_property(struct drm_connector *connector,
		511	struct drm_property *property,
		512	uint64_t value)
		513	{
		514	struct drm_device *dev = connector->dev;
		515	struct radeon_encoder *radeon_encoder;
		516	enum radeon_rmx_type rmx_type;
		517
		518	DRM_DEBUG("\n");
		519	if (property != dev->mode_config.scaling_mode_property)
		520	return 0;
		521
		522	if (connector->encoder)
		523	radeon_encoder = to_radeon_encoder(connector->encoder);
		524	else {
		525	struct drm_connector_helper_funcs *connector_funcs = connector->helper_private;
		526	radeon_encoder = to_radeon_encoder(connector_funcs->best_encoder(connector));
		527	}
		528
		529	switch (value) {
		530	case DRM_MODE_SCALE_NONE: rmx_type = RMX_OFF; break;
		531	case DRM_MODE_SCALE_CENTER: rmx_type = RMX_CENTER; break;
		532	case DRM_MODE_SCALE_ASPECT: rmx_type = RMX_ASPECT; break;
		533	default:
		534	case DRM_MODE_SCALE_FULLSCREEN: rmx_type = RMX_FULL; break;
		535	}
		536	if (radeon_encoder->rmx_type == rmx_type)
		537	return 0;
		538
		539	radeon_encoder->rmx_type = rmx_type;
		540
		541	radeon_property_change_mode(&radeon_encoder->base);
		542	return 0;
		543	}
		544
		545
1123	serge	546	struct drm_connector_helper_funcs radeon_lvds_connector_helper_funcs = {
		547	.get_modes = radeon_lvds_get_modes,
		548	.mode_valid = radeon_lvds_mode_valid,
		549	.best_encoder = radeon_best_single_encoder,
		550	};
		551
		552	struct drm_connector_funcs radeon_lvds_connector_funcs = {
		553	.dpms = drm_helper_connector_dpms,
		554	.detect = radeon_lvds_detect,
		555	.fill_modes = drm_helper_probe_single_connector_modes,
		556	.destroy = radeon_connector_destroy,
1179	serge	557	.set_property = radeon_lvds_set_property,
1123	serge	558	};
		559
		560	static int radeon_vga_get_modes(struct drm_connector *connector)
		561	{
		562	struct radeon_connector *radeon_connector = to_radeon_connector(connector);
		563	int ret;
		564
		565	ret = radeon_ddc_get_modes(radeon_connector);
		566
		567	return ret;
		568	}
		569
		570	static int radeon_vga_mode_valid(struct drm_connector *connector,
		571	struct drm_display_mode *mode)
		572	{
1268	serge	573	/* XXX check mode bandwidth */
		574	/* XXX verify against max DAC output frequency */
1123	serge	575	return MODE_OK;
		576	}
		577
		578	static enum drm_connector_status radeon_vga_detect(struct drm_connector *connector)
		579	{
		580	struct radeon_connector *radeon_connector = to_radeon_connector(connector);
		581	struct drm_encoder *encoder;
		582	struct drm_encoder_helper_funcs *encoder_funcs;
		583	bool dret;
		584	enum drm_connector_status ret = connector_status_disconnected;
		585
1179	serge	586	encoder = radeon_best_single_encoder(connector);
		587	if (!encoder)
		588	ret = connector_status_disconnected;
		589
1321	serge	590	radeon_i2c_do_lock(radeon_connector->ddc_bus, 1);
1123	serge	591	dret = radeon_ddc_probe(radeon_connector);
1321	serge	592	radeon_i2c_do_lock(radeon_connector->ddc_bus, 0);
1268	serge	593	if (dret) {
		594	if (radeon_connector->edid) {
		595	kfree(radeon_connector->edid);
		596	radeon_connector->edid = NULL;
		597	}
1321	serge	598	radeon_i2c_do_lock(radeon_connector->ddc_bus, 1);
1268	serge	599	radeon_connector->edid = drm_get_edid(&radeon_connector->base, &radeon_connector->ddc_bus->adapter);
1321	serge	600	radeon_i2c_do_lock(radeon_connector->ddc_bus, 0);
1268	serge	601
		602	if (!radeon_connector->edid) {
1313	serge	603	DRM_ERROR("%s: probed a monitor but no\|invalid EDID\n",
1268	serge	604	drm_get_connector_name(connector));
1313	serge	605	ret = connector_status_connected;
1268	serge	606	} else {
		607	radeon_connector->use_digital = !!(radeon_connector->edid->input & DRM_EDID_INPUT_DIGITAL);
		608
		609	/* some oems have boards with separate digital and analog connectors
		610	* with a shared ddc line (often vga + hdmi)
		611	*/
		612	if (radeon_connector->use_digital && radeon_connector->shared_ddc) {
		613	kfree(radeon_connector->edid);
		614	radeon_connector->edid = NULL;
		615	ret = connector_status_disconnected;
		616	} else
1123	serge	617	ret = connector_status_connected;
1268	serge	618	}
		619	} else {
1403	serge	620	if (radeon_connector->dac_load_detect && encoder) {
1123	serge	621	encoder_funcs = encoder->helper_private;
		622	ret = encoder_funcs->detect(encoder, connector);
		623	}
		624	}
		625
1179	serge	626	if (ret == connector_status_connected)
		627	ret = radeon_connector_analog_encoder_conflict_solve(connector, encoder, ret, true);
1123	serge	628	radeon_connector_update_scratch_regs(connector, ret);
		629	return ret;
		630	}
		631
		632	struct drm_connector_helper_funcs radeon_vga_connector_helper_funcs = {
		633	.get_modes = radeon_vga_get_modes,
		634	.mode_valid = radeon_vga_mode_valid,
		635	.best_encoder = radeon_best_single_encoder,
		636	};
		637
		638	struct drm_connector_funcs radeon_vga_connector_funcs = {
		639	.dpms = drm_helper_connector_dpms,
		640	.detect = radeon_vga_detect,
		641	.fill_modes = drm_helper_probe_single_connector_modes,
		642	.destroy = radeon_connector_destroy,
		643	.set_property = radeon_connector_set_property,
		644	};
		645
1179	serge	646	static int radeon_tv_get_modes(struct drm_connector *connector)
		647	{
		648	struct drm_device *dev = connector->dev;
		649	struct radeon_device *rdev = dev->dev_private;
		650	struct drm_display_mode *tv_mode;
		651	struct drm_encoder *encoder;
		652
		653	encoder = radeon_best_single_encoder(connector);
		654	if (!encoder)
		655	return 0;
		656
		657	/* avivo chips can scale any mode */
		658	if (rdev->family >= CHIP_RS600)
		659	/* add scaled modes */
		660	radeon_add_common_modes(encoder, connector);
		661	else {
		662	/* only 800x600 is supported right now on pre-avivo chips */
1221	serge	663	tv_mode = drm_cvt_mode(dev, 800, 600, 60, false, false, false);
1179	serge	664	tv_mode->type = DRM_MODE_TYPE_DRIVER \| DRM_MODE_TYPE_PREFERRED;
		665	drm_mode_probed_add(connector, tv_mode);
		666	}
		667	return 1;
		668	}
		669
		670	static int radeon_tv_mode_valid(struct drm_connector *connector,
		671	struct drm_display_mode *mode)
		672	{
1268	serge	673	if ((mode->hdisplay > 1024) \|\| (mode->vdisplay > 768))
		674	return MODE_CLOCK_RANGE;
1179	serge	675	return MODE_OK;
		676	}
		677
		678	static enum drm_connector_status radeon_tv_detect(struct drm_connector *connector)
		679	{
		680	struct drm_encoder *encoder;
		681	struct drm_encoder_helper_funcs *encoder_funcs;
		682	struct radeon_connector *radeon_connector = to_radeon_connector(connector);
		683	enum drm_connector_status ret = connector_status_disconnected;
		684
		685	if (!radeon_connector->dac_load_detect)
		686	return ret;
		687
		688	encoder = radeon_best_single_encoder(connector);
		689	if (!encoder)
		690	ret = connector_status_disconnected;
		691	else {
		692	encoder_funcs = encoder->helper_private;
		693	ret = encoder_funcs->detect(encoder, connector);
		694	}
		695	if (ret == connector_status_connected)
		696	ret = radeon_connector_analog_encoder_conflict_solve(connector, encoder, ret, false);
		697	radeon_connector_update_scratch_regs(connector, ret);
		698	return ret;
		699	}
		700
		701	struct drm_connector_helper_funcs radeon_tv_connector_helper_funcs = {
		702	.get_modes = radeon_tv_get_modes,
		703	.mode_valid = radeon_tv_mode_valid,
		704	.best_encoder = radeon_best_single_encoder,
		705	};
		706
		707	struct drm_connector_funcs radeon_tv_connector_funcs = {
		708	.dpms = drm_helper_connector_dpms,
		709	.detect = radeon_tv_detect,
		710	.fill_modes = drm_helper_probe_single_connector_modes,
		711	.destroy = radeon_connector_destroy,
		712	.set_property = radeon_connector_set_property,
		713	};
		714
1123	serge	715	static int radeon_dvi_get_modes(struct drm_connector *connector)
		716	{
		717	struct radeon_connector *radeon_connector = to_radeon_connector(connector);
		718	int ret;
		719
		720	ret = radeon_ddc_get_modes(radeon_connector);
		721	return ret;
		722	}
		723
1179	serge	724	/*
		725	* DVI is complicated
		726	* Do a DDC probe, if DDC probe passes, get the full EDID so
		727	* we can do analog/digital monitor detection at this point.
		728	* If the monitor is an analog monitor or we got no DDC,
		729	* we need to find the DAC encoder object for this connector.
		730	* If we got no DDC, we do load detection on the DAC encoder object.
		731	* If we got analog DDC or load detection passes on the DAC encoder
		732	* we have to check if this analog encoder is shared with anyone else (TV)
		733	* if its shared we have to set the other connector to disconnected.
		734	*/
1123	serge	735	static enum drm_connector_status radeon_dvi_detect(struct drm_connector *connector)
		736	{
		737	struct radeon_connector *radeon_connector = to_radeon_connector(connector);
1179	serge	738	struct drm_encoder *encoder = NULL;
1123	serge	739	struct drm_encoder_helper_funcs *encoder_funcs;
		740	struct drm_mode_object *obj;
		741	int i;
		742	enum drm_connector_status ret = connector_status_disconnected;
		743	bool dret;
		744
1321	serge	745	radeon_i2c_do_lock(radeon_connector->ddc_bus, 1);
1123	serge	746	dret = radeon_ddc_probe(radeon_connector);
1321	serge	747	radeon_i2c_do_lock(radeon_connector->ddc_bus, 0);
1179	serge	748	if (dret) {
1268	serge	749	if (radeon_connector->edid) {
		750	kfree(radeon_connector->edid);
		751	radeon_connector->edid = NULL;
		752	}
1321	serge	753	radeon_i2c_do_lock(radeon_connector->ddc_bus, 1);
1179	serge	754	radeon_connector->edid = drm_get_edid(&radeon_connector->base, &radeon_connector->ddc_bus->adapter);
1321	serge	755	radeon_i2c_do_lock(radeon_connector->ddc_bus, 0);
1179	serge	756
		757	if (!radeon_connector->edid) {
1313	serge	758	DRM_ERROR("%s: probed a monitor but no\|invalid EDID\n",
1179	serge	759	drm_get_connector_name(connector));
		760	} else {
		761	radeon_connector->use_digital = !!(radeon_connector->edid->input & DRM_EDID_INPUT_DIGITAL);
		762
1268	serge	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;
1321	serge	772
		773	/* multiple connectors on the same encoder with the same ddc line
		774	* This tends to be HDMI and DVI on the same encoder with the
		775	* same ddc line. If the edid says HDMI, consider the HDMI port
		776	* connected and the DVI port disconnected. If the edid doesn't
		777	* say HDMI, vice versa.
		778	*/
		779	if (radeon_connector->shared_ddc && connector_status_connected) {
		780	struct drm_device *dev = connector->dev;
		781	struct drm_connector *list_connector;
		782	struct radeon_connector *list_radeon_connector;
		783	list_for_each_entry(list_connector, &dev->mode_config.connector_list, head) {
		784	if (connector == list_connector)
		785	continue;
		786	list_radeon_connector = to_radeon_connector(list_connector);
		787	if (radeon_connector->devices == list_radeon_connector->devices) {
		788	if (drm_detect_hdmi_monitor(radeon_connector->edid)) {
		789	if (connector->connector_type == DRM_MODE_CONNECTOR_DVID) {
		790	kfree(radeon_connector->edid);
		791	radeon_connector->edid = NULL;
		792	ret = connector_status_disconnected;
		793	}
		794	} else {
		795	if ((connector->connector_type == DRM_MODE_CONNECTOR_HDMIA) \|\|
		796	(connector->connector_type == DRM_MODE_CONNECTOR_HDMIB)) {
		797	kfree(radeon_connector->edid);
		798	radeon_connector->edid = NULL;
		799	ret = connector_status_disconnected;
		800	}
		801	}
		802	}
		803	}
		804	}
1179	serge	805	}
		806	}
		807
		808	if ((ret == connector_status_connected) && (radeon_connector->use_digital == true))
		809	goto out;
		810
		811	/* find analog encoder */
		812	if (radeon_connector->dac_load_detect) {
1123	serge	813	for (i = 0; i < DRM_CONNECTOR_MAX_ENCODER; i++) {
		814	if (connector->encoder_ids[i] == 0)
		815	break;
		816
		817	obj = drm_mode_object_find(connector->dev,
		818	connector->encoder_ids[i],
		819	DRM_MODE_OBJECT_ENCODER);
		820	if (!obj)
		821	continue;
		822
		823	encoder = obj_to_encoder(obj);
		824
		825	encoder_funcs = encoder->helper_private;
		826	if (encoder_funcs->detect) {
1179	serge	827	if (ret != connector_status_connected) {
1123	serge	828	ret = encoder_funcs->detect(encoder, connector);
		829	if (ret == connector_status_connected) {
1179	serge	830	radeon_connector->use_digital = false;
		831	}
		832	}
1123	serge	833	break;
		834	}
		835	}
		836	}
1179	serge	837
		838	if ((ret == connector_status_connected) && (radeon_connector->use_digital == false) &&
		839	encoder) {
		840	ret = radeon_connector_analog_encoder_conflict_solve(connector, encoder, ret, true);
1123	serge	841	}
		842
1179	serge	843	out:
1123	serge	844	/* updated in get modes as well since we need to know if it's analog or digital */
		845	radeon_connector_update_scratch_regs(connector, ret);
		846	return ret;
		847	}
		848
		849	/* okay need to be smart in here about which encoder to pick */
		850	struct drm_encoder radeon_dvi_encoder(struct drm_connector connector)
		851	{
		852	int enc_id = connector->encoder_ids[0];
		853	struct radeon_connector *radeon_connector = to_radeon_connector(connector);
		854	struct drm_mode_object *obj;
		855	struct drm_encoder *encoder;
		856	int i;
		857	for (i = 0; i < DRM_CONNECTOR_MAX_ENCODER; i++) {
		858	if (connector->encoder_ids[i] == 0)
		859	break;
		860
		861	obj = drm_mode_object_find(connector->dev, connector->encoder_ids[i], DRM_MODE_OBJECT_ENCODER);
		862	if (!obj)
		863	continue;
		864
		865	encoder = obj_to_encoder(obj);
		866
1179	serge	867	if (radeon_connector->use_digital == true) {
1123	serge	868	if (encoder->encoder_type == DRM_MODE_ENCODER_TMDS)
		869	return encoder;
		870	} else {
		871	if (encoder->encoder_type == DRM_MODE_ENCODER_DAC \|\|
		872	encoder->encoder_type == DRM_MODE_ENCODER_TVDAC)
		873	return encoder;
		874	}
		875	}
		876
		877	/* see if we have a default encoder TODO */
		878
		879	/* then check use digitial */
		880	/* pick the first one */
		881	if (enc_id) {
		882	obj = drm_mode_object_find(connector->dev, enc_id, DRM_MODE_OBJECT_ENCODER);
		883	if (!obj)
		884	return NULL;
		885	encoder = obj_to_encoder(obj);
		886	return encoder;
		887	}
		888	return NULL;
		889	}
		890
1221	serge	891	static void radeon_dvi_force(struct drm_connector *connector)
		892	{
		893	struct radeon_connector *radeon_connector = to_radeon_connector(connector);
		894	if (connector->force == DRM_FORCE_ON)
		895	radeon_connector->use_digital = false;
		896	if (connector->force == DRM_FORCE_ON_DIGITAL)
		897	radeon_connector->use_digital = true;
		898	}
		899
1268	serge	900	static int radeon_dvi_mode_valid(struct drm_connector *connector,
		901	struct drm_display_mode *mode)
		902	{
1403	serge	903	struct drm_device *dev = connector->dev;
		904	struct radeon_device *rdev = dev->dev_private;
1268	serge	905	struct radeon_connector *radeon_connector = to_radeon_connector(connector);
		906
		907	/* XXX check mode bandwidth */
		908
1403	serge	909	/* clocks over 135 MHz have heat issues with DVI on RV100 */
		910	if (radeon_connector->use_digital &&
		911	(rdev->family == CHIP_RV100) &&
		912	(mode->clock > 135000))
		913	return MODE_CLOCK_HIGH;
		914
1268	serge	915	if (radeon_connector->use_digital && (mode->clock > 165000)) {
		916	if ((radeon_connector->connector_object_id == CONNECTOR_OBJECT_ID_DUAL_LINK_DVI_I) \|\|
		917	(radeon_connector->connector_object_id == CONNECTOR_OBJECT_ID_DUAL_LINK_DVI_D) \|\|
		918	(radeon_connector->connector_object_id == CONNECTOR_OBJECT_ID_HDMI_TYPE_B))
		919	return MODE_OK;
		920	else
		921	return MODE_CLOCK_HIGH;
		922	}
		923	return MODE_OK;
		924	}
		925
1123	serge	926	struct drm_connector_helper_funcs radeon_dvi_connector_helper_funcs = {
		927	.get_modes = radeon_dvi_get_modes,
1268	serge	928	.mode_valid = radeon_dvi_mode_valid,
1123	serge	929	.best_encoder = radeon_dvi_encoder,
		930	};
		931
		932	struct drm_connector_funcs radeon_dvi_connector_funcs = {
		933	.dpms = drm_helper_connector_dpms,
		934	.detect = radeon_dvi_detect,
		935	.fill_modes = drm_helper_probe_single_connector_modes,
		936	.set_property = radeon_connector_set_property,
		937	.destroy = radeon_connector_destroy,
1221	serge	938	.force = radeon_dvi_force,
1123	serge	939	};
		940
1321	serge	941	static void radeon_dp_connector_destroy(struct drm_connector *connector)
		942	{
		943	struct radeon_connector *radeon_connector = to_radeon_connector(connector);
		944	struct radeon_connector_atom_dig *radeon_dig_connector = radeon_connector->con_priv;
		945
		946	if (radeon_connector->ddc_bus)
		947	radeon_i2c_destroy(radeon_connector->ddc_bus);
		948	if (radeon_connector->edid)
		949	kfree(radeon_connector->edid);
		950	if (radeon_dig_connector->dp_i2c_bus)
		951	radeon_i2c_destroy(radeon_dig_connector->dp_i2c_bus);
		952	kfree(radeon_connector->con_priv);
		953	drm_sysfs_connector_remove(connector);
		954	drm_connector_cleanup(connector);
		955	kfree(connector);
		956	}
		957
		958	static int radeon_dp_get_modes(struct drm_connector *connector)
		959	{
		960	struct radeon_connector *radeon_connector = to_radeon_connector(connector);
		961	int ret;
		962
		963	ret = radeon_ddc_get_modes(radeon_connector);
		964	return ret;
		965	}
		966
		967	static enum drm_connector_status radeon_dp_detect(struct drm_connector *connector)
		968	{
		969	struct radeon_connector *radeon_connector = to_radeon_connector(connector);
		970	enum drm_connector_status ret = connector_status_disconnected;
		971	struct radeon_connector_atom_dig *radeon_dig_connector = radeon_connector->con_priv;
		972	u8 sink_type;
		973
		974	if (radeon_connector->edid) {
		975	kfree(radeon_connector->edid);
		976	radeon_connector->edid = NULL;
		977	}
		978
		979	sink_type = radeon_dp_getsinktype(radeon_connector);
1403	serge	980	if ((sink_type == CONNECTOR_OBJECT_ID_DISPLAYPORT) \|\|
		981	(sink_type == CONNECTOR_OBJECT_ID_eDP)) {
1321	serge	982	if (radeon_dp_getdpcd(radeon_connector)) {
		983	radeon_dig_connector->dp_sink_type = sink_type;
		984	ret = connector_status_connected;
		985	}
		986	} else {
		987	radeon_i2c_do_lock(radeon_connector->ddc_bus, 1);
		988	if (radeon_ddc_probe(radeon_connector)) {
		989	radeon_dig_connector->dp_sink_type = sink_type;
		990	ret = connector_status_connected;
		991	}
		992	radeon_i2c_do_lock(radeon_connector->ddc_bus, 0);
		993	}
		994
		995	return ret;
		996	}
		997
		998	static int radeon_dp_mode_valid(struct drm_connector *connector,
		999	struct drm_display_mode *mode)
		1000	{
		1001	struct radeon_connector *radeon_connector = to_radeon_connector(connector);
		1002	struct radeon_connector_atom_dig *radeon_dig_connector = radeon_connector->con_priv;
		1003
		1004	/* XXX check mode bandwidth */
		1005
1403	serge	1006	if ((radeon_dig_connector->dp_sink_type == CONNECTOR_OBJECT_ID_DISPLAYPORT) \|\|
		1007	(radeon_dig_connector->dp_sink_type == CONNECTOR_OBJECT_ID_eDP))
1321	serge	1008	return radeon_dp_mode_valid_helper(radeon_connector, mode);
		1009	else
		1010	return MODE_OK;
		1011	}
		1012
		1013	struct drm_connector_helper_funcs radeon_dp_connector_helper_funcs = {
		1014	.get_modes = radeon_dp_get_modes,
		1015	.mode_valid = radeon_dp_mode_valid,
		1016	.best_encoder = radeon_dvi_encoder,
		1017	};
		1018
		1019	struct drm_connector_funcs radeon_dp_connector_funcs = {
		1020	.dpms = drm_helper_connector_dpms,
		1021	.detect = radeon_dp_detect,
		1022	.fill_modes = drm_helper_probe_single_connector_modes,
		1023	.set_property = radeon_connector_set_property,
		1024	.destroy = radeon_dp_connector_destroy,
		1025	.force = radeon_dvi_force,
		1026	};
		1027
1123	serge	1028	void
		1029	radeon_add_atom_connector(struct drm_device *dev,
		1030	uint32_t connector_id,
		1031	uint32_t supported_device,
		1032	int connector_type,
		1033	struct radeon_i2c_bus_rec *i2c_bus,
		1034	bool linkb,
1268	serge	1035	uint32_t igp_lane_info,
1321	serge	1036	uint16_t connector_object_id,
		1037	struct radeon_hpd *hpd)
1123	serge	1038	{
1179	serge	1039	struct radeon_device *rdev = dev->dev_private;
1123	serge	1040	struct drm_connector *connector;
		1041	struct radeon_connector *radeon_connector;
		1042	struct radeon_connector_atom_dig *radeon_dig_connector;
		1043	uint32_t subpixel_order = SubPixelNone;
1268	serge	1044	bool shared_ddc = false;
1221	serge	1045	int ret;
1123	serge	1046
		1047	/* fixme - tv/cv/din */
1179	serge	1048	if (connector_type == DRM_MODE_CONNECTOR_Unknown)
1123	serge	1049	return;
		1050
		1051	/* see if we already added it */
		1052	list_for_each_entry(connector, &dev->mode_config.connector_list, head) {
		1053	radeon_connector = to_radeon_connector(connector);
		1054	if (radeon_connector->connector_id == connector_id) {
		1055	radeon_connector->devices \|= supported_device;
		1056	return;
		1057	}
1268	serge	1058	if (radeon_connector->ddc_bus && i2c_bus->valid) {
		1059	if (memcmp(&radeon_connector->ddc_bus->rec, i2c_bus,
		1060	sizeof(struct radeon_i2c_bus_rec)) == 0) {
		1061	radeon_connector->shared_ddc = true;
		1062	shared_ddc = true;
		1063	}
		1064	}
1123	serge	1065	}
		1066
		1067	radeon_connector = kzalloc(sizeof(struct radeon_connector), GFP_KERNEL);
		1068	if (!radeon_connector)
		1069	return;
		1070
		1071	connector = &radeon_connector->base;
		1072
		1073	radeon_connector->connector_id = connector_id;
		1074	radeon_connector->devices = supported_device;
1268	serge	1075	radeon_connector->shared_ddc = shared_ddc;
		1076	radeon_connector->connector_object_id = connector_object_id;
1321	serge	1077	radeon_connector->hpd = *hpd;
1123	serge	1078	switch (connector_type) {
		1079	case DRM_MODE_CONNECTOR_VGA:
		1080	drm_connector_init(dev, &radeon_connector->base, &radeon_vga_connector_funcs, connector_type);
1221	serge	1081	ret = drm_connector_helper_add(&radeon_connector->base, &radeon_vga_connector_helper_funcs);
		1082	if (ret)
		1083	goto failed;
1123	serge	1084	if (i2c_bus->valid) {
		1085	radeon_connector->ddc_bus = radeon_i2c_create(dev, i2c_bus, "VGA");
		1086	if (!radeon_connector->ddc_bus)
		1087	goto failed;
		1088	}
1221	serge	1089	radeon_connector->dac_load_detect = true;
1179	serge	1090	drm_connector_attach_property(&radeon_connector->base,
		1091	rdev->mode_info.load_detect_property,
		1092	1);
1123	serge	1093	break;
		1094	case DRM_MODE_CONNECTOR_DVIA:
		1095	drm_connector_init(dev, &radeon_connector->base, &radeon_vga_connector_funcs, connector_type);
1221	serge	1096	ret = drm_connector_helper_add(&radeon_connector->base, &radeon_vga_connector_helper_funcs);
		1097	if (ret)
		1098	goto failed;
1123	serge	1099	if (i2c_bus->valid) {
		1100	radeon_connector->ddc_bus = radeon_i2c_create(dev, i2c_bus, "DVI");
		1101	if (!radeon_connector->ddc_bus)
		1102	goto failed;
		1103	}
1221	serge	1104	radeon_connector->dac_load_detect = true;
1179	serge	1105	drm_connector_attach_property(&radeon_connector->base,
		1106	rdev->mode_info.load_detect_property,
		1107	1);
1123	serge	1108	break;
		1109	case DRM_MODE_CONNECTOR_DVII:
		1110	case DRM_MODE_CONNECTOR_DVID:
		1111	radeon_dig_connector = kzalloc(sizeof(struct radeon_connector_atom_dig), GFP_KERNEL);
		1112	if (!radeon_dig_connector)
		1113	goto failed;
		1114	radeon_dig_connector->linkb = linkb;
		1115	radeon_dig_connector->igp_lane_info = igp_lane_info;
		1116	radeon_connector->con_priv = radeon_dig_connector;
		1117	drm_connector_init(dev, &radeon_connector->base, &radeon_dvi_connector_funcs, connector_type);
1221	serge	1118	ret = drm_connector_helper_add(&radeon_connector->base, &radeon_dvi_connector_helper_funcs);
		1119	if (ret)
		1120	goto failed;
1123	serge	1121	if (i2c_bus->valid) {
		1122	radeon_connector->ddc_bus = radeon_i2c_create(dev, i2c_bus, "DVI");
		1123	if (!radeon_connector->ddc_bus)
		1124	goto failed;
		1125	}
		1126	subpixel_order = SubPixelHorizontalRGB;
1179	serge	1127	drm_connector_attach_property(&radeon_connector->base,
		1128	rdev->mode_info.coherent_mode_property,
		1129	1);
1321	serge	1130	if (connector_type == DRM_MODE_CONNECTOR_DVII) {
1221	serge	1131	radeon_connector->dac_load_detect = true;
1179	serge	1132	drm_connector_attach_property(&radeon_connector->base,
		1133	rdev->mode_info.load_detect_property,
		1134	1);
1321	serge	1135	}
1123	serge	1136	break;
		1137	case DRM_MODE_CONNECTOR_HDMIA:
		1138	case DRM_MODE_CONNECTOR_HDMIB:
		1139	radeon_dig_connector = kzalloc(sizeof(struct radeon_connector_atom_dig), GFP_KERNEL);
		1140	if (!radeon_dig_connector)
		1141	goto failed;
		1142	radeon_dig_connector->linkb = linkb;
		1143	radeon_dig_connector->igp_lane_info = igp_lane_info;
		1144	radeon_connector->con_priv = radeon_dig_connector;
		1145	drm_connector_init(dev, &radeon_connector->base, &radeon_dvi_connector_funcs, connector_type);
1221	serge	1146	ret = drm_connector_helper_add(&radeon_connector->base, &radeon_dvi_connector_helper_funcs);
		1147	if (ret)
		1148	goto failed;
1123	serge	1149	if (i2c_bus->valid) {
		1150	radeon_connector->ddc_bus = radeon_i2c_create(dev, i2c_bus, "HDMI");
		1151	if (!radeon_connector->ddc_bus)
		1152	goto failed;
		1153	}
1179	serge	1154	drm_connector_attach_property(&radeon_connector->base,
		1155	rdev->mode_info.coherent_mode_property,
		1156	1);
1123	serge	1157	subpixel_order = SubPixelHorizontalRGB;
		1158	break;
		1159	case DRM_MODE_CONNECTOR_DisplayPort:
1403	serge	1160	case DRM_MODE_CONNECTOR_eDP:
1123	serge	1161	radeon_dig_connector = kzalloc(sizeof(struct radeon_connector_atom_dig), GFP_KERNEL);
		1162	if (!radeon_dig_connector)
		1163	goto failed;
		1164	radeon_dig_connector->linkb = linkb;
		1165	radeon_dig_connector->igp_lane_info = igp_lane_info;
		1166	radeon_connector->con_priv = radeon_dig_connector;
1321	serge	1167	drm_connector_init(dev, &radeon_connector->base, &radeon_dp_connector_funcs, connector_type);
		1168	ret = drm_connector_helper_add(&radeon_connector->base, &radeon_dp_connector_helper_funcs);
1221	serge	1169	if (ret)
		1170	goto failed;
1123	serge	1171	if (i2c_bus->valid) {
1321	serge	1172	/* add DP i2c bus */
1403	serge	1173	if (connector_type == DRM_MODE_CONNECTOR_eDP)
		1174	radeon_dig_connector->dp_i2c_bus = radeon_i2c_create_dp(dev, i2c_bus, "eDP-auxch");
		1175	else
1321	serge	1176	radeon_dig_connector->dp_i2c_bus = radeon_i2c_create_dp(dev, i2c_bus, "DP-auxch");
		1177	if (!radeon_dig_connector->dp_i2c_bus)
		1178	goto failed;
1403	serge	1179	if (connector_type == DRM_MODE_CONNECTOR_eDP)
		1180	radeon_connector->ddc_bus = radeon_i2c_create(dev, i2c_bus, "eDP");
		1181	else
1123	serge	1182	radeon_connector->ddc_bus = radeon_i2c_create(dev, i2c_bus, "DP");
		1183	if (!radeon_connector->ddc_bus)
		1184	goto failed;
		1185	}
		1186	subpixel_order = SubPixelHorizontalRGB;
1321	serge	1187	drm_connector_attach_property(&radeon_connector->base,
		1188	rdev->mode_info.coherent_mode_property,
		1189	1);
1123	serge	1190	break;
		1191	case DRM_MODE_CONNECTOR_SVIDEO:
		1192	case DRM_MODE_CONNECTOR_Composite:
		1193	case DRM_MODE_CONNECTOR_9PinDIN:
1179	serge	1194	if (radeon_tv == 1) {
		1195	drm_connector_init(dev, &radeon_connector->base, &radeon_tv_connector_funcs, connector_type);
1221	serge	1196	ret = drm_connector_helper_add(&radeon_connector->base, &radeon_tv_connector_helper_funcs);
		1197	if (ret)
		1198	goto failed;
		1199	radeon_connector->dac_load_detect = true;
1179	serge	1200	drm_connector_attach_property(&radeon_connector->base,
		1201	rdev->mode_info.load_detect_property,
		1202	1);
1321	serge	1203	drm_connector_attach_property(&radeon_connector->base,
		1204	rdev->mode_info.tv_std_property,
1403	serge	1205	radeon_atombios_get_tv_info(rdev));
1221	serge	1206	}
1123	serge	1207	break;
		1208	case DRM_MODE_CONNECTOR_LVDS:
		1209	radeon_dig_connector = kzalloc(sizeof(struct radeon_connector_atom_dig), GFP_KERNEL);
		1210	if (!radeon_dig_connector)
		1211	goto failed;
		1212	radeon_dig_connector->linkb = linkb;
		1213	radeon_dig_connector->igp_lane_info = igp_lane_info;
		1214	radeon_connector->con_priv = radeon_dig_connector;
		1215	drm_connector_init(dev, &radeon_connector->base, &radeon_lvds_connector_funcs, connector_type);
1221	serge	1216	ret = drm_connector_helper_add(&radeon_connector->base, &radeon_lvds_connector_helper_funcs);
		1217	if (ret)
		1218	goto failed;
1123	serge	1219	if (i2c_bus->valid) {
		1220	radeon_connector->ddc_bus = radeon_i2c_create(dev, i2c_bus, "LVDS");
		1221	if (!radeon_connector->ddc_bus)
		1222	goto failed;
		1223	}
1179	serge	1224	drm_connector_attach_property(&radeon_connector->base,
		1225	dev->mode_config.scaling_mode_property,
		1226	DRM_MODE_SCALE_FULLSCREEN);
1123	serge	1227	subpixel_order = SubPixelHorizontalRGB;
		1228	break;
		1229	}
		1230
		1231	connector->display_info.subpixel_order = subpixel_order;
1233	serge	1232	drm_sysfs_connector_add(connector);
1123	serge	1233	return;
		1234
		1235	failed:
		1236	if (radeon_connector->ddc_bus)
		1237	radeon_i2c_destroy(radeon_connector->ddc_bus);
		1238	drm_connector_cleanup(connector);
		1239	kfree(connector);
		1240	}
		1241
		1242	void
		1243	radeon_add_legacy_connector(struct drm_device *dev,
		1244	uint32_t connector_id,
		1245	uint32_t supported_device,
		1246	int connector_type,
1268	serge	1247	struct radeon_i2c_bus_rec *i2c_bus,
1321	serge	1248	uint16_t connector_object_id,
		1249	struct radeon_hpd *hpd)
1123	serge	1250	{
1179	serge	1251	struct radeon_device *rdev = dev->dev_private;
1123	serge	1252	struct drm_connector *connector;
		1253	struct radeon_connector *radeon_connector;
		1254	uint32_t subpixel_order = SubPixelNone;
1221	serge	1255	int ret;
1123	serge	1256
		1257	/* fixme - tv/cv/din */
1179	serge	1258	if (connector_type == DRM_MODE_CONNECTOR_Unknown)
1123	serge	1259	return;
		1260
		1261	/* see if we already added it */
		1262	list_for_each_entry(connector, &dev->mode_config.connector_list, head) {
		1263	radeon_connector = to_radeon_connector(connector);
		1264	if (radeon_connector->connector_id == connector_id) {
		1265	radeon_connector->devices \|= supported_device;
		1266	return;
		1267	}
		1268	}
		1269
		1270	radeon_connector = kzalloc(sizeof(struct radeon_connector), GFP_KERNEL);
		1271	if (!radeon_connector)
		1272	return;
		1273
		1274	connector = &radeon_connector->base;
		1275
		1276	radeon_connector->connector_id = connector_id;
		1277	radeon_connector->devices = supported_device;
1268	serge	1278	radeon_connector->connector_object_id = connector_object_id;
1321	serge	1279	radeon_connector->hpd = *hpd;
1123	serge	1280	switch (connector_type) {
		1281	case DRM_MODE_CONNECTOR_VGA:
		1282	drm_connector_init(dev, &radeon_connector->base, &radeon_vga_connector_funcs, connector_type);
1221	serge	1283	ret = drm_connector_helper_add(&radeon_connector->base, &radeon_vga_connector_helper_funcs);
		1284	if (ret)
		1285	goto failed;
1123	serge	1286	if (i2c_bus->valid) {
		1287	radeon_connector->ddc_bus = radeon_i2c_create(dev, i2c_bus, "VGA");
		1288	if (!radeon_connector->ddc_bus)
		1289	goto failed;
		1290	}
1221	serge	1291	radeon_connector->dac_load_detect = true;
1179	serge	1292	drm_connector_attach_property(&radeon_connector->base,
		1293	rdev->mode_info.load_detect_property,
		1294	1);
1123	serge	1295	break;
		1296	case DRM_MODE_CONNECTOR_DVIA:
		1297	drm_connector_init(dev, &radeon_connector->base, &radeon_vga_connector_funcs, connector_type);
1221	serge	1298	ret = drm_connector_helper_add(&radeon_connector->base, &radeon_vga_connector_helper_funcs);
		1299	if (ret)
		1300	goto failed;
1123	serge	1301	if (i2c_bus->valid) {
		1302	radeon_connector->ddc_bus = radeon_i2c_create(dev, i2c_bus, "DVI");
		1303	if (!radeon_connector->ddc_bus)
		1304	goto failed;
		1305	}
1221	serge	1306	radeon_connector->dac_load_detect = true;
1179	serge	1307	drm_connector_attach_property(&radeon_connector->base,
		1308	rdev->mode_info.load_detect_property,
		1309	1);
1123	serge	1310	break;
		1311	case DRM_MODE_CONNECTOR_DVII:
		1312	case DRM_MODE_CONNECTOR_DVID:
		1313	drm_connector_init(dev, &radeon_connector->base, &radeon_dvi_connector_funcs, connector_type);
1221	serge	1314	ret = drm_connector_helper_add(&radeon_connector->base, &radeon_dvi_connector_helper_funcs);
		1315	if (ret)
		1316	goto failed;
1123	serge	1317	if (i2c_bus->valid) {
		1318	radeon_connector->ddc_bus = radeon_i2c_create(dev, i2c_bus, "DVI");
		1319	if (!radeon_connector->ddc_bus)
		1320	goto failed;
1221	serge	1321	radeon_connector->dac_load_detect = true;
1179	serge	1322	drm_connector_attach_property(&radeon_connector->base,
		1323	rdev->mode_info.load_detect_property,
		1324	1);
1123	serge	1325	}
		1326	subpixel_order = SubPixelHorizontalRGB;
		1327	break;
		1328	case DRM_MODE_CONNECTOR_SVIDEO:
		1329	case DRM_MODE_CONNECTOR_Composite:
		1330	case DRM_MODE_CONNECTOR_9PinDIN:
1179	serge	1331	if (radeon_tv == 1) {
		1332	drm_connector_init(dev, &radeon_connector->base, &radeon_tv_connector_funcs, connector_type);
1221	serge	1333	ret = drm_connector_helper_add(&radeon_connector->base, &radeon_tv_connector_helper_funcs);
		1334	if (ret)
		1335	goto failed;
		1336	radeon_connector->dac_load_detect = true;
1313	serge	1337	/* RS400,RC410,RS480 chipset seems to report a lot
		1338	* of false positive on load detect, we haven't yet
		1339	* found a way to make load detect reliable on those
		1340	* chipset, thus just disable it for TV.
		1341	*/
		1342	if (rdev->family == CHIP_RS400 \|\| rdev->family == CHIP_RS480)
		1343	radeon_connector->dac_load_detect = false;
1179	serge	1344	drm_connector_attach_property(&radeon_connector->base,
		1345	rdev->mode_info.load_detect_property,
		1346	1);
1321	serge	1347	drm_connector_attach_property(&radeon_connector->base,
		1348	rdev->mode_info.tv_std_property,
1403	serge	1349	radeon_combios_get_tv_info(rdev));
1179	serge	1350	}
1123	serge	1351	break;
		1352	case DRM_MODE_CONNECTOR_LVDS:
		1353	drm_connector_init(dev, &radeon_connector->base, &radeon_lvds_connector_funcs, connector_type);
1221	serge	1354	ret = drm_connector_helper_add(&radeon_connector->base, &radeon_lvds_connector_helper_funcs);
		1355	if (ret)
		1356	goto failed;
1123	serge	1357	if (i2c_bus->valid) {
		1358	radeon_connector->ddc_bus = radeon_i2c_create(dev, i2c_bus, "LVDS");
		1359	if (!radeon_connector->ddc_bus)
		1360	goto failed;
		1361	}
1179	serge	1362	drm_connector_attach_property(&radeon_connector->base,
		1363	dev->mode_config.scaling_mode_property,
		1364	DRM_MODE_SCALE_FULLSCREEN);
1123	serge	1365	subpixel_order = SubPixelHorizontalRGB;
		1366	break;
		1367	}
		1368
		1369	connector->display_info.subpixel_order = subpixel_order;
1233	serge	1370	drm_sysfs_connector_add(connector);
1123	serge	1371	return;
		1372
		1373	failed:
		1374	if (radeon_connector->ddc_bus)
		1375	radeon_i2c_destroy(radeon_connector->ddc_bus);
		1376	drm_connector_cleanup(connector);
		1377	kfree(connector);
		1378	}

Subversion Repositories Kolibri OS

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