Merge tag 'drm-intel-next-fixes-2016-05-25' of... (7fa1d27b) · Commits · 戴 / test

Documentation/DocBook/gpu.tmpl

+6 −0

Original line number	Diff line number	Diff line
		@@ -1626,6 +1626,12 @@ void intel_crt_init(struct drm_device *dev)
		!Pdrivers/gpu/drm/drm_dp_helper.c dp helpers
		!Iinclude/drm/drm_dp_helper.h
		!Edrivers/gpu/drm/drm_dp_helper.c
		</sect2>
		<sect2>
		<title>Display Port Dual Mode Adaptor Helper Functions Reference</title>
		!Pdrivers/gpu/drm/drm_dp_dual_mode_helper.c dp dual mode helpers
		!Iinclude/drm/drm_dp_dual_mode_helper.h
		!Edrivers/gpu/drm/drm_dp_dual_mode_helper.c
		</sect2>
		<sect2>
		<title>Display Port MST Helper Functions Reference</title>

drivers/gpu/drm/Makefile

+1 −1

Original line number	Diff line number	Diff line
		@@ -23,7 +23,7 @@ drm-$(CONFIG_AGP) += drm_agpsupport.o

		drm_kms_helper-y := drm_crtc_helper.o drm_dp_helper.o drm_probe_helper.o \
		drm_plane_helper.o drm_dp_mst_topology.o drm_atomic_helper.o \
		drm_kms_helper_common.o
		drm_kms_helper_common.o drm_dp_dual_mode_helper.o

		drm_kms_helper-$(CONFIG_DRM_LOAD_EDID_FIRMWARE) += drm_edid_load.o
		drm_kms_helper-$(CONFIG_DRM_FBDEV_EMULATION) += drm_fb_helper.o

drivers/gpu/drm/drm_dp_dual_mode_helper.c

0 → 100644

+366 −0

Original line number	Diff line number	Diff line
		/*
		* Copyright © 2016 Intel Corporation
		*
		* 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.
		*/

		#include <linux/errno.h>
		#include <linux/export.h>
		#include <linux/i2c.h>
		#include <linux/slab.h>
		#include <linux/string.h>
		#include <drm/drm_dp_dual_mode_helper.h>
		#include <drm/drmP.h>

		/**
		* DOC: dp dual mode helpers
		*
		* Helper functions to deal with DP dual mode (aka. DP++) adaptors.
		*
		* Type 1:
		* Adaptor registers (if any) and the sink DDC bus may be accessed via I2C.
		*
		* Type 2:
		* Adaptor registers and sink DDC bus can be accessed either via I2C or
		* I2C-over-AUX. Source devices may choose to implement either of these
		* access methods.
		*/

		#define DP_DUAL_MODE_SLAVE_ADDRESS 0x40

		/**
		* drm_dp_dual_mode_read - Read from the DP dual mode adaptor register(s)
		* @adapter: I2C adapter for the DDC bus
		* @offset: register offset
		* @buffer: buffer for return data
		* @size: sizo of the buffer
		*
		* Reads @size bytes from the DP dual mode adaptor registers
		* starting at @offset.
		*
		* Returns:
		* 0 on success, negative error code on failure
		*/
		ssize_t drm_dp_dual_mode_read(struct i2c_adapter *adapter,
		u8 offset, void *buffer, size_t size)
		{
		struct i2c_msg msgs[] = {
		{
		.addr = DP_DUAL_MODE_SLAVE_ADDRESS,
		.flags = 0,
		.len = 1,
		.buf = &offset,
		},
		{
		.addr = DP_DUAL_MODE_SLAVE_ADDRESS,
		.flags = I2C_M_RD,
		.len = size,
		.buf = buffer,
		},
		};
		int ret;

		ret = i2c_transfer(adapter, msgs, ARRAY_SIZE(msgs));
		if (ret < 0)
		return ret;
		if (ret != ARRAY_SIZE(msgs))
		return -EPROTO;

		return 0;
		}
		EXPORT_SYMBOL(drm_dp_dual_mode_read);

		/**
		* drm_dp_dual_mode_write - Write to the DP dual mode adaptor register(s)
		* @adapter: I2C adapter for the DDC bus
		* @offset: register offset
		* @buffer: buffer for write data
		* @size: sizo of the buffer
		*
		* Writes @size bytes to the DP dual mode adaptor registers
		* starting at @offset.
		*
		* Returns:
		* 0 on success, negative error code on failure
		*/
		ssize_t drm_dp_dual_mode_write(struct i2c_adapter *adapter,
		u8 offset, const void *buffer, size_t size)
		{
		struct i2c_msg msg = {
		.addr = DP_DUAL_MODE_SLAVE_ADDRESS,
		.flags = 0,
		.len = 1 + size,
		.buf = NULL,
		};
		void *data;
		int ret;

		data = kmalloc(msg.len, GFP_TEMPORARY);
		if (!data)
		return -ENOMEM;

		msg.buf = data;

		memcpy(data, &offset, 1);
		memcpy(data + 1, buffer, size);

		ret = i2c_transfer(adapter, &msg, 1);

		kfree(data);

		if (ret < 0)
		return ret;
		if (ret != 1)
		return -EPROTO;

		return 0;
		}
		EXPORT_SYMBOL(drm_dp_dual_mode_write);

		static bool is_hdmi_adaptor(const char hdmi_id[DP_DUAL_MODE_HDMI_ID_LEN])
		{
		static const char dp_dual_mode_hdmi_id[DP_DUAL_MODE_HDMI_ID_LEN] =
		"DP-HDMI ADAPTOR\x04";

		return memcmp(hdmi_id, dp_dual_mode_hdmi_id,
		sizeof(dp_dual_mode_hdmi_id)) == 0;
		}

		static bool is_type2_adaptor(uint8_t adaptor_id)
		{
		return adaptor_id == (DP_DUAL_MODE_TYPE_TYPE2 \|
		DP_DUAL_MODE_REV_TYPE2);
		}

		/**
		* drm_dp_dual_mode_detect - Identify the DP dual mode adaptor
		* @adapter: I2C adapter for the DDC bus
		*
		* Attempt to identify the type of the DP dual mode adaptor used.
		*
		* Note that when the answer is @DRM_DP_DUAL_MODE_UNKNOWN it's not
		* certain whether we're dealing with a native HDMI port or
		* a type 1 DVI dual mode adaptor. The driver will have to use
		* some other hardware/driver specific mechanism to make that
		* distinction.
		*
		* Returns:
		* The type of the DP dual mode adaptor used
		*/
		enum drm_dp_dual_mode_type drm_dp_dual_mode_detect(struct i2c_adapter *adapter)
		{
		char hdmi_id[DP_DUAL_MODE_HDMI_ID_LEN] = {};
		uint8_t adaptor_id = 0x00;
		ssize_t ret;

		/*
		* Let's see if the adaptor is there the by reading the
		* HDMI ID registers.
		*
		* Note that type 1 DVI adaptors are not required to implemnt
		* any registers, and that presents a problem for detection.
		* If the i2c transfer is nacked, we may or may not be dealing
		* with a type 1 DVI adaptor. Some other mechanism of detecting
		* the presence of the adaptor is required. One way would be
		* to check the state of the CONFIG1 pin, Another method would
		* simply require the driver to know whether the port is a DP++
		* port or a native HDMI port. Both of these methods are entirely
		* hardware/driver specific so we can't deal with them here.
		*/
		ret = drm_dp_dual_mode_read(adapter, DP_DUAL_MODE_HDMI_ID,
		hdmi_id, sizeof(hdmi_id));
		if (ret)
		return DRM_DP_DUAL_MODE_UNKNOWN;

		/*
		* Sigh. Some (maybe all?) type 1 adaptors are broken and ack
		* the offset but ignore it, and instead they just always return
		* data from the start of the HDMI ID buffer. So for a broken
		* type 1 HDMI adaptor a single byte read will always give us
		* 0x44, and for a type 1 DVI adaptor it should give 0x00
		* (assuming it implements any registers). Fortunately neither
		* of those values will match the type 2 signature of the
		* DP_DUAL_MODE_ADAPTOR_ID register so we can proceed with
		* the type 2 adaptor detection safely even in the presence
		* of broken type 1 adaptors.
		*/
		ret = drm_dp_dual_mode_read(adapter, DP_DUAL_MODE_ADAPTOR_ID,
		&adaptor_id, sizeof(adaptor_id));
		if (ret == 0) {
		if (is_type2_adaptor(adaptor_id)) {
		if (is_hdmi_adaptor(hdmi_id))
		return DRM_DP_DUAL_MODE_TYPE2_HDMI;
		else
		return DRM_DP_DUAL_MODE_TYPE2_DVI;
		}
		}

		if (is_hdmi_adaptor(hdmi_id))
		return DRM_DP_DUAL_MODE_TYPE1_HDMI;
		else
		return DRM_DP_DUAL_MODE_TYPE1_DVI;
		}
		EXPORT_SYMBOL(drm_dp_dual_mode_detect);

		/**
		* drm_dp_dual_mode_max_tmds_clock - Max TMDS clock for DP dual mode adaptor
		* @type: DP dual mode adaptor type
		* @adapter: I2C adapter for the DDC bus
		*
		* Determine the max TMDS clock the adaptor supports based on the
		* type of the dual mode adaptor and the DP_DUAL_MODE_MAX_TMDS_CLOCK
		* register (on type2 adaptors). As some type 1 adaptors have
		* problems with registers (see comments in drm_dp_dual_mode_detect())
		* we don't read the register on those, instead we simply assume
		* a 165 MHz limit based on the specification.
		*
		* Returns:
		* Maximum supported TMDS clock rate for the DP dual mode adaptor in kHz.
		*/
		int drm_dp_dual_mode_max_tmds_clock(enum drm_dp_dual_mode_type type,
		struct i2c_adapter *adapter)
		{
		uint8_t max_tmds_clock;
		ssize_t ret;

		/* native HDMI so no limit */
		if (type == DRM_DP_DUAL_MODE_NONE)
		return 0;

		/*
		* Type 1 adaptors are limited to 165MHz
		* Type 2 adaptors can tells us their limit
		*/
		if (type < DRM_DP_DUAL_MODE_TYPE2_DVI)
		return 165000;

		ret = drm_dp_dual_mode_read(adapter, DP_DUAL_MODE_MAX_TMDS_CLOCK,
		&max_tmds_clock, sizeof(max_tmds_clock));
		if (ret \|\| max_tmds_clock == 0x00 \|\| max_tmds_clock == 0xff) {
		DRM_DEBUG_KMS("Failed to query max TMDS clock\n");
		return 165000;
		}

		return max_tmds_clock * 5000 / 2;
		}
		EXPORT_SYMBOL(drm_dp_dual_mode_max_tmds_clock);

		/**
		* drm_dp_dual_mode_get_tmds_output - Get the state of the TMDS output buffers in the DP dual mode adaptor
		* @type: DP dual mode adaptor type
		* @adapter: I2C adapter for the DDC bus
		* @enabled: current state of the TMDS output buffers
		*
		* Get the state of the TMDS output buffers in the adaptor. For
		* type2 adaptors this is queried from the DP_DUAL_MODE_TMDS_OEN
		* register. As some type 1 adaptors have problems with registers
		* (see comments in drm_dp_dual_mode_detect()) we don't read the
		* register on those, instead we simply assume that the buffers
		* are always enabled.
		*
		* Returns:
		* 0 on success, negative error code on failure
		*/
		int drm_dp_dual_mode_get_tmds_output(enum drm_dp_dual_mode_type type,
		struct i2c_adapter *adapter,
		bool *enabled)
		{
		uint8_t tmds_oen;
		ssize_t ret;

		if (type < DRM_DP_DUAL_MODE_TYPE2_DVI) {
		*enabled = true;
		return 0;
		}

		ret = drm_dp_dual_mode_read(adapter, DP_DUAL_MODE_TMDS_OEN,
		&tmds_oen, sizeof(tmds_oen));
		if (ret) {
		DRM_DEBUG_KMS("Failed to query state of TMDS output buffers\n");
		return ret;
		}

		*enabled = !(tmds_oen & DP_DUAL_MODE_TMDS_DISABLE);

		return 0;
		}
		EXPORT_SYMBOL(drm_dp_dual_mode_get_tmds_output);

		/**
		* drm_dp_dual_mode_set_tmds_output - Enable/disable TMDS output buffers in the DP dual mode adaptor
		* @type: DP dual mode adaptor type
		* @adapter: I2C adapter for the DDC bus
		* @enable: enable (as opposed to disable) the TMDS output buffers
		*
		* Set the state of the TMDS output buffers in the adaptor. For
		* type2 this is set via the DP_DUAL_MODE_TMDS_OEN register. As
		* some type 1 adaptors have problems with registers (see comments
		* in drm_dp_dual_mode_detect()) we avoid touching the register,
		* making this function a no-op on type 1 adaptors.
		*
		* Returns:
		* 0 on success, negative error code on failure
		*/
		int drm_dp_dual_mode_set_tmds_output(enum drm_dp_dual_mode_type type,
		struct i2c_adapter *adapter, bool enable)
		{
		uint8_t tmds_oen = enable ? 0 : DP_DUAL_MODE_TMDS_DISABLE;
		ssize_t ret;

		if (type < DRM_DP_DUAL_MODE_TYPE2_DVI)
		return 0;

		ret = drm_dp_dual_mode_write(adapter, DP_DUAL_MODE_TMDS_OEN,
		&tmds_oen, sizeof(tmds_oen));
		if (ret) {
		DRM_DEBUG_KMS("Failed to %s TMDS output buffers\n",
		enable ? "enable" : "disable");
		return ret;
		}

		return 0;
		}
		EXPORT_SYMBOL(drm_dp_dual_mode_set_tmds_output);

		/**
		* drm_dp_get_dual_mode_type_name - Get the name of the DP dual mode adaptor type as a string
		* @type: DP dual mode adaptor type
		*
		* Returns:
		* String representation of the DP dual mode adaptor type
		*/
		const char *drm_dp_get_dual_mode_type_name(enum drm_dp_dual_mode_type type)
		{
		switch (type) {
		case DRM_DP_DUAL_MODE_NONE:
		return "none";
		case DRM_DP_DUAL_MODE_TYPE1_DVI:
		return "type 1 DVI";
		case DRM_DP_DUAL_MODE_TYPE1_HDMI:
		return "type 1 HDMI";
		case DRM_DP_DUAL_MODE_TYPE2_DVI:
		return "type 2 DVI";
		case DRM_DP_DUAL_MODE_TYPE2_HDMI:
		return "type 2 HDMI";
		default:
		WARN_ON(type != DRM_DP_DUAL_MODE_UNKNOWN);
		return "unknown";
		}
		}
		EXPORT_SYMBOL(drm_dp_get_dual_mode_type_name);

drivers/gpu/drm/i915/i915_dma.c

+6 −0

Original line number	Diff line number	Diff line
		@@ -1183,6 +1183,12 @@ static int i915_driver_init_hw(struct drm_i915_private *dev_priv)
		if (ret)
		return ret;

		ret = i915_ggtt_enable_hw(dev);
		if (ret) {
		DRM_ERROR("failed to enable GGTT\n");
		goto out_ggtt;
		}

		/* WARNING: Apparently we must kick fbdev drivers before vgacon,
		* otherwise the vga fbdev driver falls over. */
		ret = i915_kick_out_firmware_fb(dev_priv);

drivers/gpu/drm/i915/i915_drv.c

+5 −0

Original line number	Diff line number	Diff line
		@@ -734,9 +734,14 @@ int i915_suspend_switcheroo(struct drm_device *dev, pm_message_t state)
		static int i915_drm_resume(struct drm_device *dev)
		{
		struct drm_i915_private *dev_priv = dev->dev_private;
		int ret;

		disable_rpm_wakeref_asserts(dev_priv);

		ret = i915_ggtt_enable_hw(dev);
		if (ret)
		DRM_ERROR("failed to re-enable GGTT\n");

		intel_csr_ucode_resume(dev_priv);

		mutex_lock(&dev->struct_mutex);

Admin message