drm/radeon/kms: initial radeon displayport porting (746c1aa4) · Commits · EulixOS / Software / Kernel

drivers/gpu/drm/radeon/Makefile

+1 −1

Original line number	Diff line number	Diff line
		@@ -49,7 +49,7 @@ radeon-y += radeon_device.o radeon_kms.o \
		radeon_cs.o radeon_bios.o radeon_benchmark.o r100.o r300.o r420.o \
		rs400.o rs600.o rs690.o rv515.o r520.o r600.o rv770.o radeon_test.o \
		r200.o radeon_legacy_tv.o r600_cs.o r600_blit.o r600_blit_shaders.o \
		r600_blit_kms.o radeon_pm.o
		r600_blit_kms.o radeon_pm.o atombios_dp.o

		radeon-$(CONFIG_COMPAT) += radeon_ioc32.o

drivers/gpu/drm/radeon/atombios_dp.c

0 → 100644

+275 −0

Original line number	Diff line number	Diff line
		/*
		* Copyright 2007-8 Advanced Micro Devices, Inc.
		* Copyright 2008 Red Hat Inc.
		*
		* Permission is hereby granted, free of charge, to any person obtaining a
		* copy of this software and associated documentation files (the "Software"),
		* to deal in the Software without restriction, including without limitation
		* the rights to use, copy, modify, merge, publish, distribute, sublicense,
		* and/or sell copies of the Software, and to permit persons to whom the
		* Software is furnished to do so, subject to the following conditions:
		*
		* The above copyright notice and this permission notice shall be included in
		* all copies or substantial portions of the Software.
		*
		* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
		* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
		* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
		* THE COPYRIGHT HOLDER(S) OR AUTHOR(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR
		* OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
		* ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
		* OTHER DEALINGS IN THE SOFTWARE.
		*
		* Authors: Dave Airlie
		* Alex Deucher
		*/
		#include "drmP.h"
		#include "radeon_drm.h"
		#include "radeon.h"

		#include "atom.h"
		#include "atom-bits.h"
		#include "drm_dp_helper.h"

		#define DP_LINK_STATUS_SIZE 6

		bool radeon_process_aux_ch(struct radeon_i2c_chan chan, u8 req_bytes,
		int num_bytes, u8 *read_byte,
		u8 read_buf_len, u8 delay)
		{
		struct drm_device *dev = chan->dev;
		struct radeon_device *rdev = dev->dev_private;
		PROCESS_AUX_CHANNEL_TRANSACTION_PS_ALLOCATION args;
		int index = GetIndexIntoMasterTable(COMMAND, ProcessAuxChannelTransaction);
		unsigned char *base;

		memset(&args, 0, sizeof(args));

		base = (unsigned char *)rdev->mode_info.atom_context->scratch;

		memcpy(base, req_bytes, num_bytes);

		args.lpAuxRequest = 0;
		args.lpDataOut = 16;
		args.ucDataOutLen = 0;
		args.ucChannelID = chan->i2c_id;
		args.ucDelay = delay;

		atom_execute_table(rdev->mode_info.atom_context, index, (uint32_t *)&args);

		if (args.ucReplyStatus) {
		DRM_ERROR("failed to get auxch %02x%02x %02x %02x 0x%02x %02x\n",
		req_bytes[1], req_bytes[0], req_bytes[2], req_bytes[3],
		chan->i2c_id, args.ucReplyStatus);
		return false;
		}

		if (args.ucDataOutLen && read_byte && read_buf_len) {
		if (read_buf_len < args.ucDataOutLen) {
		DRM_ERROR("Buffer to small for return answer %d %d\n",
		read_buf_len, args.ucDataOutLen);
		return false;
		}
		{
		int len = min(read_buf_len, args.ucDataOutLen);
		memcpy(read_byte, base + 16, len);
		}
		}
		return true;
		}

		int radeon_dp_encoder_service(struct radeon_device *rdev, int action, int dp_clock,
		uint8_t ucconfig, uint8_t lane_num)
		{
		DP_ENCODER_SERVICE_PARAMETERS args;
		int index = GetIndexIntoMasterTable(COMMAND, DPEncoderService);

		memset(&args, 0, sizeof(args));
		args.ucLinkClock = dp_clock / 10;
		args.ucConfig = ucconfig;
		args.ucAction = action;
		args.ucLaneNum = lane_num;
		args.ucStatus = 0;

		atom_execute_table(rdev->mode_info.atom_context, index, (uint32_t *)&args);
		return args.ucStatus;
		}

		int radeon_dp_getsinktype(struct radeon_connector *radeon_connector)
		{
		struct radeon_connector_atom_dig *radeon_dig_connector = radeon_connector->con_priv;
		struct drm_device *dev = radeon_connector->base.dev;
		struct radeon_device *rdev = dev->dev_private;

		return radeon_dp_encoder_service(rdev, ATOM_DP_ACTION_GET_SINK_TYPE, 0,
		radeon_dig_connector->uc_i2c_id, 0);
		}

		union dig_transmitter_control {
		DIG_TRANSMITTER_CONTROL_PS_ALLOCATION v1;
		DIG_TRANSMITTER_CONTROL_PARAMETERS_V2 v2;
		};

		bool radeon_dp_aux_native_write(struct radeon_connector *radeon_connector, uint16_t address,
		uint8_t send_bytes, uint8_t *send)
		{
		struct radeon_connector_atom_dig *radeon_dig_connector = radeon_connector->con_priv;
		struct drm_device *dev = radeon_connector->base.dev;
		struct radeon_device *rdev = dev->dev_private;
		u8 msg[20];
		u8 msg_len, dp_msg_len;
		bool ret;

		dp_msg_len = 4;
		msg[0] = address;
		msg[1] = address >> 8;
		msg[2] = AUX_NATIVE_WRITE << 4;
		dp_msg_len += send_bytes;
		msg[3] = (dp_msg_len << 4) \| (send_bytes - 1);

		if (send_bytes > 16)
		return false;

		memcpy(&msg[4], send, send_bytes);
		msg_len = 4 + send_bytes;
		ret = radeon_process_aux_ch(radeon_dig_connector->dp_i2c_bus, msg, msg_len, NULL, 0, 0);
		return ret;
		}

		bool radeon_dp_aux_native_read(struct radeon_connector *radeon_connector, uint16_t address,
		uint8_t delay, uint8_t expected_bytes,
		uint8_t *read_p)
		{
		struct radeon_connector_atom_dig *radeon_dig_connector = radeon_connector->con_priv;
		struct drm_device *dev = radeon_connector->base.dev;
		struct radeon_device *rdev = dev->dev_private;
		u8 msg[20];
		u8 msg_len, dp_msg_len;
		bool ret = false;
		msg_len = 4;
		dp_msg_len = 4;
		msg[0] = address;
		msg[1] = address >> 8;
		msg[2] = AUX_NATIVE_READ << 4;
		msg[3] = (dp_msg_len) << 4;
		msg[3] \|= expected_bytes - 1;

		ret = radeon_process_aux_ch(radeon_dig_connector->dp_i2c_bus, msg, msg_len, read_p, expected_bytes, delay);
		return ret;
		}

		void radeon_dp_getdpcp(struct radeon_connector *radeon_connector)
		{
		struct radeon_connector_atom_dig *radeon_dig_connector = radeon_connector->con_priv;
		u8 msg[25];
		int ret;

		ret = radeon_dp_aux_native_read(radeon_connector, DP_DPCP_REV, 0, 8, msg);
		if (ret) {
		memcpy(radeon_dig_connector->dpcp, msg, 8);
		{
		int i;
		printk("DPCP: ");
		for (i = 0; i < 8; i++)
		printk("%02x ", msg[i]);
		printk("\n");
		}
		}
		radeon_dig_connector->dpcp[0] = 0;
		return;
		}

		static bool atom_dp_get_link_status(struct radeon_connector *radeon_connector,
		u8 link_status[DP_LINK_STATUS_SIZE])
		{
		int ret;
		ret = radeon_dp_aux_native_read(radeon_connector, DP_LANE0_1_STATUS, 100,
		DP_LINK_STATUS_SIZE, link_status);
		if (!ret) {
		DRM_ERROR("displayport link status failed\n");
		return false;
		}

		DRM_INFO("link status %02x %02x %02x %02x %02x %02x\n",
		link_status[0], link_status[1], link_status[2],
		link_status[3], link_status[4], link_status[5]);
		return true;
		}

		static void dp_set_power(struct radeon_connector *radeon_connector, u8 power_state)
		{
		struct radeon_connector_atom_dig *radeon_dig_connector = radeon_connector->con_priv;
		if (radeon_dig_connector->dpcp[0] >= 0x11) {
		radeon_dp_aux_native_write(radeon_connector, 0x600, 1,
		&power_state);
		}
		}

		static void dp_update_dpvs_emph(struct radeon_connector *radeon_connector,
		u8 train_set[4])
		{
		struct radeon_connector_atom_dig *radeon_dig_connector = radeon_connector->con_priv;

		// radeon_dp_digtransmitter_setup_vsemph();
		radeon_dp_aux_native_write(radeon_connector, DP_TRAINING_LANE0_SET,
		0/* lc */, train_set);
		}

		static void dp_set_training(struct radeon_connector *radeon_connector,
		u8 training)
		{
		radeon_dp_aux_native_write(radeon_connector, DP_TRAINING_PATTERN_SET,
		1, &training);
		}

		int radeon_dp_i2c_aux_ch(struct i2c_adapter *adapter, int mode,
		uint8_t write_byte, uint8_t *read_byte)
		{
		struct i2c_algo_dp_aux_data *algo_data = adapter->algo_data;
		struct radeon_i2c_chan auxch = (struct radeon_i2c_chan )adapter;
		int ret = 0;
		uint16_t address = algo_data->address;
		uint8_t msg[5];
		uint8_t reply[2];
		int msg_len, dp_msg_len;
		int reply_bytes;

		/* Set up the command byte */
		if (mode & MODE_I2C_READ)
		msg[2] = AUX_I2C_READ << 4;
		else
		msg[2] = AUX_I2C_WRITE << 4;

		if (!(mode & MODE_I2C_STOP))
		msg[2] \|= AUX_I2C_MOT << 4;

		msg[0] = address;
		msg[1] = address >> 8;

		reply_bytes = 1;

		msg_len = 4;
		dp_msg_len = 3;
		switch (mode) {
		case MODE_I2C_WRITE:
		msg[4] = write_byte;
		msg_len++;
		dp_msg_len += 2;
		break;
		case MODE_I2C_READ:
		dp_msg_len += 1;
		break;
		default:
		break;
		}

		msg[3] = (dp_msg_len) << 4;
		ret = radeon_process_aux_ch(auxch, msg, msg_len, reply, reply_bytes, 0);

		if (ret) {
		if (read_byte)
		*read_byte = reply[0];
		return reply_bytes;
		}
		return -EREMOTEIO;
		}

drivers/gpu/drm/radeon/radeon_atombios.c

+9 −8

Original line number	Diff line number	Diff line
		@@ -47,7 +47,7 @@ radeon_add_atom_connector(struct drm_device *dev,
		int connector_type,
		struct radeon_i2c_bus_rec *i2c_bus,
		bool linkb, uint32_t igp_lane_info,
		uint16_t connector_object_id);
		uint16_t connector_object_id, uint8_t uc_i2c_id);

		/* from radeon_legacy_encoder.c */
		extern void
		@@ -60,8 +60,8 @@ union atom_supported_devices {
		struct _ATOM_SUPPORTED_DEVICES_INFO_2d1 info_2d1;
		};

		static inline struct radeon_i2c_bus_rec radeon_lookup_gpio(struct drm_device
		*dev, uint8_t id)
		static inline struct radeon_i2c_bus_rec radeon_lookup_gpio(struct drm_device *dev,
		uint8_t id)
		{
		struct radeon_device *rdev = dev->dev_private;
		struct atom_context *ctx = rdev->mode_info.atom_context;
		@@ -276,7 +276,7 @@ bool radeon_get_atom_connector_info_from_object_table(struct drm_device *dev)
		uint16_t igp_lane_info, conn_id, connector_object_id;
		bool linkb;
		struct radeon_i2c_bus_rec ddc_bus;

		ATOM_I2C_ID_CONFIG_ACCESS i2c_id;
		atom_parse_data_header(ctx, index, &size, &frev, &crev, &data_offset);

		if (data_offset == 0)
		@@ -302,7 +302,7 @@ bool radeon_get_atom_connector_info_from_object_table(struct drm_device *dev)
		path = (ATOM_DISPLAY_OBJECT_PATH *) addr;
		path_size += le16_to_cpu(path->usSize);
		linkb = false;

		i2c_id.ucAccess = 0;
		if (device_support & le16_to_cpu(path->usDeviceTag)) {
		uint8_t con_obj_id, con_obj_num, con_obj_type;

		@@ -431,6 +431,7 @@ bool radeon_get_atom_connector_info_from_object_table(struct drm_device *dev)
		i2c_record =
		(ATOM_I2C_RECORD
		*) record;
		i2c_id.sbfAccess = i2c_record->sucI2cId;
		line_mux =
		i2c_record->
		sucI2cId.
		@@ -473,7 +474,7 @@ bool radeon_get_atom_connector_info_from_object_table(struct drm_device *dev)
		usDeviceTag),
		connector_type, &ddc_bus,
		linkb, igp_lane_info,
		connector_object_id);
		connector_object_id, i2c_id.ucAccess);

		}
		}
		@@ -692,7 +693,7 @@ bool radeon_get_atom_connector_info_from_supported_devices_table(struct
		connector_type,
		&bios_connectors[i].ddc_bus,
		false, 0,
		connector_object_id);
		connector_object_id, 0);
		}
		}

drivers/gpu/drm/radeon/radeon_connectors.c

+54 −3

Original line number	Diff line number	Diff line
		@@ -896,6 +896,54 @@ struct drm_connector_funcs radeon_dvi_connector_funcs = {
		.force = radeon_dvi_force,
		};

		static int radeon_dp_get_modes(struct drm_connector *connector)
		{
		struct radeon_connector *radeon_connector = to_radeon_connector(connector);
		int ret;

		ret = radeon_ddc_get_modes(radeon_connector);
		return ret;
		}

		static enum drm_connector_status radeon_dp_detect(struct drm_connector *connector)
		{
		struct radeon_connector *radeon_connector = to_radeon_connector(connector);
		struct drm_encoder *encoder = NULL;
		struct drm_encoder_helper_funcs *encoder_funcs;
		struct drm_mode_object *obj;
		int i;
		enum drm_connector_status ret = connector_status_disconnected;
		int sink_type;
		bool dret;

		if (radeon_connector->edid) {
		kfree(radeon_connector->edid);
		radeon_connector->edid = NULL;
		}

		sink_type = radeon_dp_getsinktype(radeon_connector);
		if (sink_type == CONNECTOR_OBJECT_ID_DISPLAYPORT) {
		radeon_dp_getdpcp(radeon_connector);
		ret = connector_status_connected;
		}
		return ret;
		}

		struct drm_connector_helper_funcs radeon_dp_connector_helper_funcs = {
		.get_modes = radeon_dp_get_modes,
		.mode_valid = radeon_dvi_mode_valid,
		.best_encoder = radeon_dvi_encoder,
		};

		struct drm_connector_funcs radeon_dp_connector_funcs = {
		.dpms = drm_helper_connector_dpms,
		.detect = radeon_dp_detect,
		.fill_modes = drm_helper_probe_single_connector_modes,
		.set_property = radeon_connector_set_property,
		.destroy = radeon_connector_destroy,
		.force = radeon_dvi_force,
		};

		void
		radeon_add_atom_connector(struct drm_device *dev,
		uint32_t connector_id,
		@@ -904,7 +952,7 @@ radeon_add_atom_connector(struct drm_device *dev,
		struct radeon_i2c_bus_rec *i2c_bus,
		bool linkb,
		uint32_t igp_lane_info,
		uint16_t connector_object_id)
		uint16_t connector_object_id, uint8_t uc_i2c_id)
		{
		struct radeon_device *rdev = dev->dev_private;
		struct drm_connector *connector;
		@@ -1030,10 +1078,13 @@ radeon_add_atom_connector(struct drm_device *dev,
		radeon_dig_connector->linkb = linkb;
		radeon_dig_connector->igp_lane_info = igp_lane_info;
		radeon_connector->con_priv = radeon_dig_connector;
		drm_connector_init(dev, &radeon_connector->base, &radeon_dvi_connector_funcs, connector_type);
		ret = drm_connector_helper_add(&radeon_connector->base, &radeon_dvi_connector_helper_funcs);
		drm_connector_init(dev, &radeon_connector->base, &radeon_dp_connector_funcs, connector_type);
		ret = drm_connector_helper_add(&radeon_connector->base, &radeon_dp_connector_helper_funcs);
		if (ret)
		goto failed;
		/* add DP i2c bus */
		radeon_dig_connector->uc_i2c_id = uc_i2c_id;
		radeon_dig_connector->dp_i2c_bus = radeon_i2c_create_dp(dev, "DP-auxch", true, uc_i2c_id);
		if (i2c_bus->valid) {
		radeon_connector->ddc_bus = radeon_i2c_create(dev, i2c_bus, "DP");
		if (!radeon_connector->ddc_bus)

drivers/gpu/drm/radeon/radeon_display.c

+7 −0

Original line number	Diff line number	Diff line
		@@ -337,6 +337,13 @@ int radeon_ddc_get_modes(struct radeon_connector *radeon_connector)
		{
		int ret = 0;

		if (radeon_connector->base.connector_type == DRM_MODE_CONNECTOR_DisplayPort) {
		struct radeon_connector_atom_dig *dig = radeon_connector->con_priv;
		if (dig->dp_i2c_bus) {
		radeon_connector->edid = drm_get_edid(&radeon_connector->base, &dig->dp_i2c_bus->adapter);
		DRM_INFO("got edid %p from DP\n", radeon_connector->edid);
		}
		}
		if (!radeon_connector->ddc_bus)
		return -1;
		if (!radeon_connector->edid) {