Skip to contentSkip to conversation

drm/dp: Introduce AUX channel infrastructure

PATCH Superseded Thierry Reding 1 participant 5 messages Dec 12, 2013

Subsystems (2)

v1 of 4 Superseded Latest is v4 →

lore
Share & tools
lore
#0 lore raw

cover drm/dp: Introduce AUX channel infrastructure

Hi,

This small series introduces some infrastructure to support AUX channels in a generic way. Drivers make use of it by embedding and filling in a struct drm_dp_aux. Various helpers can then be used to for example read from or write to the DPCD.

Patch 1 adds the basic infrastructure as well as a couple of helpers to access the DPCD.

The helper introduced in patch 2 can be used to obtain the link status as expected by various existing DP helpers.

More convenience helpers are added in patch 3, which can come in handy during DP initialization.

An AUX channel can also be used to implement I2C-over-AUX and patch 4 wraps a drm_dp_aux object such that it can be used with the existing i2c_dp_aux helpers. Eventually it should be possible to implement the same functionality more directly instead of going through the additional layer of indirection.

Thierry

Thierry Reding (4):
drm/dp: Add AUX channel infrastructure drm/dp: Add drm_dp_dpcd_read_link_status() drm/dp: Add DisplayPort link helpers drm/dp: Allow registering AUX channels as I2C busses

 drivers/gpu/drm/drm_dp_helper.c | 203 ++++++++++++++++++++++++++++++++++++++++
 include/drm/drm_dp_helper.h     | 122 ++++++++++++++++++++++++
 2 files changed, 325 insertions(+)
Signature · 1 line
1.8.4.2
#1 lore raw

PATCH 1/4 drm/dp: Add AUX channel infrastructure

This is a superset of the current i2c_dp_aux bus functionality and can be used to transfer native AUX in addition to I2C-over-AUX messages.

Helpers are provided to read and write the DPCD, either blockwise or byte-wise. Many of the existing helpers for DisplayPort take a copy of a portion of the DPCD and operate on that, without a way to write data back to the DPCD (e.g. for configuration of the link).

Subsequent patches will build upon this infrastructure to provide common functionality in a generic way.

---
 drivers/gpu/drm/drm_dp_helper.c | 50 ++++++++++++++++++++++++
 include/drm/drm_dp_helper.h     | 85 +++++++++++++++++++++++++++++++++++++++++
 2 files changed, 135 insertions(+)
drivers/gpu/drm/drm_dp_helper.c +50 -0
index 9e978aae8972..6c9276098069 100644
@@ -346,3 +346,53 @@ int drm_dp_bw_code_to_link_rate(u8 link_bw)
 	}
 }
 EXPORT_SYMBOL(drm_dp_bw_code_to_link_rate);
+
+/**
+ * drm_dp_dpcd_read() - read a series of bytes from the DPCD
+ * @aux: DisplayPort AUX channel
+ * @offset: address of the (first) register to read
+ * @buffer: buffer to store the register values
+ * @size: number of bytes in @buffer
+ *
+ * Returns the number of bytes transferred on success, or a negative error
+ * code on failure.
+ */
+ssize_t drm_dp_dpcd_read(struct drm_dp_aux *aux, unsigned int offset,
+			 void *buffer, size_t size)
+{
+	struct drm_dp_aux_msg msg;
+
+	memset(&msg, 0, sizeof(msg));
+	msg.address = offset;
+	msg.flags = DRM_DP_AUX_NATIVE_READ;
+	msg.buffer = buffer;
+	msg.size = size;
+
+	return aux->transfer(aux, &msg);
+}
+EXPORT_SYMBOL(drm_dp_dpcd_read);
+
+/**
+ * drm_dp_dpcd_write() - write a series of bytes to the DPCD
+ * @aux: DisplayPort AUX channel
+ * @offset: address of the (first) register to write
+ * @buffer: buffer containing the values to write
+ * @size: number of bytes in @buffer
+ *
+ * Returns the number of bytes transferred on success, or a negative error
+ * code on failure.
+ */
+ssize_t drm_dp_dpcd_write(struct drm_dp_aux *aux, unsigned int offset,
+			  void *buffer, size_t size)
+{
+	struct drm_dp_aux_msg msg;
+
+	memset(&msg, 0, sizeof(msg));
+	msg.address = offset;
+	msg.flags = DRM_DP_AUX_NATIVE_WRITE;
+	msg.buffer = buffer;
+	msg.size = size;
+
+	return aux->transfer(aux, &msg);
+}
+EXPORT_SYMBOL(drm_dp_dpcd_write);
include/drm/drm_dp_helper.h +85 -0

89 lines not on this page · raw message

Signature · 1 line
1.8.4.2
#2 lore raw

PATCH 2/4 drm/dp: Add drm_dp_dpcd_read_link_status()

In reply to Thierry Reding

The function reads the link status (6 bytes starting at offset 0x202) from the DPCD so that it can be conveniently passed to other DPCD helpers.

---
 drivers/gpu/drm/drm_dp_helper.c | 16 ++++++++++++++++
 include/drm/drm_dp_helper.h     |  3 +++
 2 files changed, 19 insertions(+)
drivers/gpu/drm/drm_dp_helper.c +16 -0
index 6c9276098069..d7a4df2e6b56 100644
@@ -396,3 +396,19 @@ ssize_t drm_dp_dpcd_write(struct drm_dp_aux *aux, unsigned int offset,
 	return aux->transfer(aux, &msg);
 }
 EXPORT_SYMBOL(drm_dp_dpcd_write);
+
+/**
+ * drm_dp_dpcd_read_link_status() - read DPCD link status (bytes 0x202-0x207)
+ * @aux: DisplayPort AUX channel
+ * @status: buffer to store the link status in (must be at least 6 bytes)
+ *
+ * Returns the number of bytes transferred on success or a negative error
+ * code on failure.
+ */
+int drm_dp_dpcd_read_link_status(struct drm_dp_aux *aux,
+				 u8 status[DP_LINK_STATUS_SIZE])
+{
+	return drm_dp_dpcd_read(aux, DP_LANE0_1_STATUS, status,
+				DP_LINK_STATUS_SIZE);
+}
+EXPORT_SYMBOL(drm_dp_dpcd_read_link_status);
include/drm/drm_dp_helper.h +3 -0
index e528b2b64cef..a7c336444cea 100644
@@ -482,4 +482,7 @@ static inline ssize_t drm_dp_dpcd_writeb(struct drm_dp_aux *aux, u8 value,
 	return drm_dp_dpcd_write(aux, offset, &value, 1);
 }
 
+int drm_dp_dpcd_read_link_status(struct drm_dp_aux *aux,
+				 u8 status[DP_LINK_STATUS_SIZE]);
+
 #endif /* _DRM_DP_HELPER_H_ */
Signature · 1 line
1.8.4.2
#3 lore raw

PATCH 3/4 drm/dp: Add DisplayPort link helpers

In reply to Thierry Reding

Add a helper to probe a DP link (reading out the maximum rate, link count and capabilities) as well as configuring it accordingly.

---
 drivers/gpu/drm/drm_dp_helper.c | 59 +++++++++++++++++++++++++++++++++++++++++
 include/drm/drm_dp_helper.h     | 30 +++++++++++++++++++++
 2 files changed, 89 insertions(+)
drivers/gpu/drm/drm_dp_helper.c +59 -0
index d7a4df2e6b56..873aedccc84e 100644
@@ -412,3 +412,62 @@ int drm_dp_dpcd_read_link_status(struct drm_dp_aux *aux,
 				DP_LINK_STATUS_SIZE);
 }
 EXPORT_SYMBOL(drm_dp_dpcd_read_link_status);
+
+int drm_dp_link_probe(struct drm_dp_aux *aux, struct drm_dp_link *link)
+{
+	u8 value;
+	int err;
+
+	memset(link, 0, sizeof(*link));
+
+	err = drm_dp_dpcd_readb(aux, DP_MAX_LINK_RATE, &value);
+	if (err < 0)
+		return err;
+
+	link->rate = drm_dp_bw_code_to_link_rate(value);
+
+	err = drm_dp_dpcd_readb(aux, DP_MAX_LANE_COUNT, &value);
+	if (err < 0)
+		return err;
+
+	link->num_lanes = value & DP_MAX_LANE_COUNT_MASK;
+
+	if (value & DP_ENHANCED_FRAME_CAP)
+		link->capabilities |= DP_LINK_CAP_ENHANCED_FRAMING;
+
+	return 0;
+}
+
+int drm_dp_link_power_up(struct drm_dp_aux *aux, struct drm_dp_link *link)
+{
+	u8 value;
+	int err;
+
+	err = drm_dp_dpcd_readb(aux, DP_SET_POWER, &value);
+	if (err < 0)
+		return err;
+
+	value &= ~DP_SET_POWER_MASK;
+	value |= DP_SET_POWER_D0;
+
+	err = drm_dp_dpcd_writeb(aux, value, DP_SET_POWER);
+	if (err < 0)
+		return err;
+
+	value = drm_dp_link_rate_to_bw_code(link->rate);
+
+	err = drm_dp_dpcd_writeb(aux, value, DP_LINK_BW_SET);
+	if (err < 0)
+		return err;
+
+	value = link->num_lanes;
+
+	if (link->capabilities & DP_LINK_CAP_ENHANCED_FRAMING)
+		value |= DP_LANE_COUNT_ENHANCED_FRAME_EN;
+
+	err = drm_dp_dpcd_writeb(aux, value, DP_LANE_COUNT_SET);
+	if (err < 0)
+		return err;
+
+	return 0;
+}
include/drm/drm_dp_helper.h +30 -0
index a7c336444cea..cf03a6ff8634 100644
@@ -290,6 +290,7 @@
 #define DP_SET_POWER                        0x600
 # define DP_SET_POWER_D0                    0x1
 # define DP_SET_POWER_D3                    0x2
+# define DP_SET_POWER_MASK                  0x3
 
 #define DP_PSR_ERROR_STATUS                 0x2006  /* XXX 1.2? */
 # define DP_PSR_LINK_CRC_ERROR              (1 << 0)
@@ -485,4 +486,33 @@ static inline ssize_t drm_dp_dpcd_writeb(struct drm_dp_aux *aux, u8 value,
 int drm_dp_dpcd_read_link_status(struct drm_dp_aux *aux,
 				 u8 status[DP_LINK_STATUS_SIZE]);
 
+/*
+ * DisplayPort link
+ */
+#define DP_LINK_CAP_ENHANCED_FRAMING (1 << 0)
+
+struct drm_dp_link {
+	unsigned int rate;
+	unsigned int num_lanes;
+	unsigned long capabilities;
+};
+
+/**
+ * drm_dp_link_probe() - probe link properties and capabilities
+ * @aux: DisplayPort AUX channel
+ * @link: DisplayPort link
+ *
+ * Returns 0 on success or a negative error code on failure.
+ */
+int drm_dp_link_probe(struct drm_dp_aux *aux, struct drm_dp_link *link);
+
+/**
+ * drm_dp_link_power_up() - power up a link
+ * @aux: DisplayPort AUX channel
+ * @link: DisplayPort link
+ *
+ * Returns 0 on success or a negative error code on failure.
+ */
+int drm_dp_link_power_up(struct drm_dp_aux *aux, struct drm_dp_link *link);
+
 #endif /* _DRM_DP_HELPER_H_ */
Signature · 1 line
1.8.4.2
#4 lore raw

PATCH 4/4 drm/dp: Allow registering AUX channels as I2C busses

In reply to Thierry Reding

This reuses the existing I2C-over-AUX implementation by translating the messages to ones compatible with the struct drm_dp_aux implementation.

---
 drivers/gpu/drm/drm_dp_helper.c | 78 +++++++++++++++++++++++++++++++++++++++++
 include/drm/drm_dp_helper.h     |  4 +++
 2 files changed, 82 insertions(+)
drivers/gpu/drm/drm_dp_helper.c +78 -0
index 873aedccc84e..2864a47e6abe 100644
@@ -471,3 +471,81 @@ int drm_dp_link_power_up(struct drm_dp_aux *aux, struct drm_dp_link *link)
 
 	return 0;
 }
+
+struct drm_dp_i2c_adapter {
+	struct i2c_algo_dp_aux_data algo;
+	struct i2c_adapter adapter;
+	struct drm_dp_aux *aux;
+};
+
+static int drm_dp_i2c_aux_ch(struct i2c_adapter *adapter, int mode,
+			     uint8_t write_byte, uint8_t *read_byte)
+{
+	struct drm_dp_i2c_adapter *dp = container_of(adapter, struct drm_dp_i2c_adapter, adapter);
+	struct i2c_algo_dp_aux_data *algo = adapter->algo_data;
+	struct drm_dp_aux_msg msg;
+	u8 data = 0;
+	int err;
+
+	if (mode & MODE_I2C_START)
+		return 0;
+
+	memset(&msg, 0, sizeof(msg));
+	msg.address = algo->address;
+	msg.flags = DRM_DP_AUX_I2C;
+
+	if ((mode & MODE_I2C_STOP) == 0)
+		msg.flags |= DRM_DP_AUX_I2C_MOT;
+
+	if (mode & MODE_I2C_WRITE) {
+		msg.flags |= DRM_DP_AUX_WRITE;
+		msg.buffer = &write_byte;
+		msg.size = 1;
+	} else {
+		msg.buffer = &data;
+		msg.size = 1;
+	}
+
+	err = dp->aux->transfer(dp->aux, &msg);
+	if (err < 0)
+		return err;
+
+	/*
+	 * Allow the transfer() functions to be ignorant about whether or not
+	 * the read buffer passed in is valid or not.
+	 */
+	if (((mode & MODE_I2C_WRITE) == 0) && read_byte)
+		*read_byte = data;
+
+	return err;
+}
+
+struct i2c_adapter *drm_dp_add_i2c_bus(struct drm_dp_aux *aux)
+{
+	struct drm_dp_i2c_adapter *adapter;
+	int err;
+
+	adapter = kzalloc(sizeof(*adapter), GFP_KERNEL);
+	if (!adapter)
+		return ERR_PTR(-ENOMEM);
+
+	adapter->algo.running = false;
+	adapter->algo.address = 0;
+	adapter->algo.aux_ch = drm_dp_i2c_aux_ch;
+	adapter->aux = aux;
+
+	adapter->adapter.class = I2C_CLASS_DDC;
+	adapter->adapter.owner = THIS_MODULE;
+	strncpy(adapter->adapter.name, "DPAUX", sizeof(adapter->adapter.name));
+	adapter->adapter.algo_data = &adapter->algo;
+	adapter->adapter.dev.parent = aux->dev;
+	adapter->adapter.dev.of_node = aux->dev->of_node;
+
+	err = i2c_dp_aux_add_bus(&adapter->adapter);
+	if (err < 0) {
+		kfree(adapter);
+		return ERR_PTR(err);
+	}
+
+	return &adapter->adapter;
+}
include/drm/drm_dp_helper.h +4 -0
index cf03a6ff8634..8b0f6c44251e 100644
@@ -444,6 +444,8 @@ struct drm_dp_aux_msg {
  * @transfer: transfers a message representing a single AUX transaction
  */
 struct drm_dp_aux {
+	struct device *dev;
+
 	ssize_t (*transfer)(struct drm_dp_aux *aux,
 			    struct drm_dp_aux_msg *msg);
 };
@@ -515,4 +517,6 @@ int drm_dp_link_probe(struct drm_dp_aux *aux, struct drm_dp_link *link);
  */
 int drm_dp_link_power_up(struct drm_dp_aux *aux, struct drm_dp_link *link);
 
+struct i2c_adapter *drm_dp_add_i2c_bus(struct drm_dp_aux *aux);
+
 #endif /* _DRM_DP_HELPER_H_ */
Signature · 1 line
1.8.4.2