[v2,6/9] media: intel: Add Displayport RX IP driver

  Add driver for the Intel DisplayPort RX FPGA IP

Signed-off-by: Paweł Anikiel <panikiel@google.com>
---
 drivers/media/platform/intel/Kconfig      |   12 +
 drivers/media/platform/intel/Makefile     |    1 +
 drivers/media/platform/intel/intel-dprx.c | 2176 +++++++++++++++++++++
 3 files changed, 2189 insertions(+)
 create mode 100644 drivers/media/platform/intel/intel-dprx.c
  

On 21/02/2024 17:02, Paweł Anikiel wrote:
> Add driver for the Intel DisplayPort RX FPGA IP
> 
> Signed-off-by: Paweł Anikiel <panikiel@google.com>
> ---
>  drivers/media/platform/intel/Kconfig      |   12 +
>  drivers/media/platform/intel/Makefile     |    1 +
>  drivers/media/platform/intel/intel-dprx.c | 2176 +++++++++++++++++++++
>  3 files changed, 2189 insertions(+)
>  create mode 100644 drivers/media/platform/intel/intel-dprx.c
> 
> diff --git a/drivers/media/platform/intel/Kconfig b/drivers/media/platform/intel/Kconfig
> index 724e80a9086d..eafcd47cce68 100644
> --- a/drivers/media/platform/intel/Kconfig
> +++ b/drivers/media/platform/intel/Kconfig
> @@ -12,3 +12,15 @@ config VIDEO_PXA27x
>  	select V4L2_FWNODE
>  	help
>  	  This is a v4l2 driver for the PXA27x Quick Capture Interface
> +
> +config VIDEO_INTEL_DPRX
> +	tristate "Intel DisplayPort RX IP driver"
> +	depends on V4L_PLATFORM_DRIVERS
> +	depends on VIDEO_DEV
> +	select V4L2_FWNODE
> +	select CRC_DP
> +	help
> +	  v4l2 subdev driver for Intel Displayport receiver FPGA IP.
> +	  It is a part of the DisplayPort Intel FPGA IP Core.
> +	  It implements a DisplayPort 1.4 receiver capable of HBR3
> +	  video capture and Multi-Stream Transport.
> diff --git a/drivers/media/platform/intel/Makefile b/drivers/media/platform/intel/Makefile
> index 7e8889cbd2df..f571399f5aa8 100644
> --- a/drivers/media/platform/intel/Makefile
> +++ b/drivers/media/platform/intel/Makefile
> @@ -1,2 +1,3 @@
>  # SPDX-License-Identifier: GPL-2.0-only
>  obj-$(CONFIG_VIDEO_PXA27x) += pxa_camera.o
> +obj-$(CONFIG_VIDEO_INTEL_DPRX) += intel-dprx.o
> diff --git a/drivers/media/platform/intel/intel-dprx.c b/drivers/media/platform/intel/intel-dprx.c
> new file mode 100644
> index 000000000000..d0c60e29e51d
> --- /dev/null
> +++ b/drivers/media/platform/intel/intel-dprx.c
> @@ -0,0 +1,2176 @@
> +// SPDX-License-Identifier: GPL-2.0
> +/*
> + * Copyright 2023-2024 Google LLC.
> + * Author: Paweł Anikiel <panikiel@google.com>
> + */
> +
> +#include <linux/crc-dp.h>
> +#include <linux/delay.h>
> +#include <linux/interrupt.h>
> +#include <linux/kernel.h>
> +#include <linux/module.h>
> +#include <linux/of.h>
> +#include <linux/platform_device.h>
> +#include <media/v4l2-dv-timings.h>
> +#include <media/v4l2-subdev.h>
> +#include <drm/display/drm_dp.h>
> +#include <drm/display/drm_dp_mst.h>
> +
> +#define DPRX_MAX_EDID_BLOCKS	4
> +
> +/* DPRX registers */
> +
> +#define DPRX_RX_CONTROL				0x000
> +#define DPRX_RX_CONTROL_LINK_RATE_SHIFT		16
> +#define DPRX_RX_CONTROL_LINK_RATE_MASK		0xff
> +#define DPRX_RX_CONTROL_RECONFIG_LINKRATE	13
> +#define DPRX_RX_CONTROL_TP_SHIFT		8
> +#define DPRX_RX_CONTROL_TP_MASK			0x7
> +#define DPRX_RX_CONTROL_SCRAMBLER_DISABLE	7
> +#define DPRX_RX_CONTROL_CHANNEL_CODING_SHIFT	5
> +#define DPRX_RX_CONTROL_CHANNEL_CODING_8B10B	0x1
> +#define DPRX_RX_CONTROL_LANE_COUNT_SHIFT	0
> +#define DPRX_RX_CONTROL_LANE_COUNT_MASK		0x1f
> +
> +#define DPRX_RX_STATUS				0x001
> +#define DPRX_RX_STATUS_INTERLANE_ALIGN		8
> +#define DPRX_RX_STATUS_SYM_LOCK_SHIFT		4
> +#define DPRX_RX_STATUS_SYM_LOCK(i)		(4 + i)
> +#define DPRX_RX_STATUS_CR_LOCK_SHIFT		0
> +#define DPRX_RX_STATUS_CR_LOCK(i)		(0 + i)
> +
> +#define DPRX_MSA_HTOTAL(i)			(0x022 + 0x20 * (i))
> +#define DPRX_MSA_VTOTAL(i)			(0x023 + 0x20 * (i))
> +#define DPRX_MSA_HSP(i)				(0x024 + 0x20 * (i))
> +#define DPRX_MSA_HSW(i)				(0x025 + 0x20 * (i))
> +#define DPRX_MSA_HSTART(i)			(0x026 + 0x20 * (i))
> +#define DPRX_MSA_VSTART(i)			(0x027 + 0x20 * (i))
> +#define DPRX_MSA_VSP(i)				(0x028 + 0x20 * (i))
> +#define DPRX_MSA_VSW(i)				(0x029 + 0x20 * (i))
> +#define DPRX_MSA_HWIDTH(i)			(0x02a + 0x20 * (i))
> +#define DPRX_MSA_VHEIGHT(i)			(0x02b + 0x20 * (i))
> +#define DPRX_VBID(i)				(0x02f + 0x20 * (i))
> +#define DPRX_VBID_MSA_LOCK			7
> +
> +#define DPRX_MST_CONTROL1			0x0a0
> +#define DPRX_MST_CONTROL1_VCPTAB_UPD_FORCE	31
> +#define DPRX_MST_CONTROL1_VCPTAB_UPD_REQ	30
> +#define DPRX_MST_CONTROL1_VCP_ID_SHIFT(i)	(4 + 4 * (i))
> +#define DPRX_MST_CONTROL1_VCP_IDS_SHIFT		4
> +#define DPRX_MST_CONTROL1_VCP_IDS_MASK		0xffff
> +#define DPRX_MST_CONTROL1_MST_EN		0
> +
> +#define DPRX_MST_STATUS1			0x0a1
> +#define DPRX_MST_STATUS1_VCPTAB_ACT_ACK		30
> +
> +#define DPRX_MST_VCPTAB(i)			(0x0a2 + i)
> +
> +#define DPRX_AUX_CONTROL			0x100
> +#define DPRX_AUX_CONTROL_IRQ_EN			8
> +#define DPRX_AUX_CONTROL_TX_STROBE		7
> +#define DPRX_AUX_CONTROL_LENGTH_SHIFT		0
> +#define DPRX_AUX_CONTROL_LENGTH_MASK		0x1f
> +
> +#define DPRX_AUX_STATUS				0x101
> +#define DPRX_AUX_STATUS_MSG_READY		31
> +#define DPRX_AUX_STATUS_READY_TO_TX		30
> +
> +#define DPRX_AUX_COMMAND			0x102
> +
> +#define DPRX_AUX_HPD				0x119
> +#define DPRX_AUX_HPD_IRQ			12
> +#define DPRX_AUX_HPD_EN				11
> +
> +/* DDC defines */
> +
> +#define DDC_EDID_ADDR		0x50
> +#define DDC_SEGMENT_ADDR	0x30
> +
> +struct dprx_training_control {
> +	u8 volt_swing;
> +	u8 pre_emph;
> +	bool max_swing;
> +	bool max_pre_emph;
> +};
> +
> +struct dprx_sink {
> +	u8 edid[128 * DPRX_MAX_EDID_BLOCKS];
> +	int blocks;
> +	int offset;
> +	int segment;
> +};
> +
> +struct msg_transaction_rxbuf {
> +	u8 buf[256];
> +	int len;
> +};
> +
> +struct msg_transaction_txbuf {
> +	u8 buf[256];
> +	int len;
> +	int written;
> +};
> +
> +struct msg_transaction_meta {
> +	u8 lct;
> +	u8 rad[8];
> +	bool seqno;
> +};
> +
> +struct dprx {
> +	struct device *dev;
> +	void __iomem *iobase;
> +
> +	struct v4l2_subdev subdev;
> +	struct media_pad pads[4];
> +
> +	struct dprx_sink sinks[4];
> +
> +	int max_link_rate;
> +	int max_lane_count;
> +	bool multi_stream_support;
> +	int max_stream_count;
> +
> +	u8 caps[16];
> +	u8 guid[16];
> +
> +	struct dprx_training_control training_control[4];
> +
> +	u8 payload_allocate_set;
> +	u8 payload_allocate_start_time_slot;
> +	u8 payload_allocate_time_slot_count;
> +	u8 payload_table[64];
> +	u8 payload_table_updated;
> +
> +	u8  payload_id[4];
> +	u32 payload_pbn[4];
> +	u32 payload_pbn_total;
> +
> +	u8 irq_vector;
> +
> +	u8 down_req_buf[48];
> +	u8 down_rep_buf[48];
> +
> +	struct msg_transaction_rxbuf mt_rxbuf[2];
> +	struct msg_transaction_txbuf mt_txbuf[2];
> +	struct msg_transaction_meta mt_meta[2];
> +	bool mt_seqno;
> +	bool mt_pending;
> +	bool down_rep_pending;
> +
> +	spinlock_t lock;
> +};
> +
> +struct aux_buf {
> +	u8 data[20];
> +	int len;
> +};
> +
> +struct aux_msg {
> +	u8 cmd;
> +	u32 addr;
> +	u8 len;
> +	u8 data[16];
> +};
> +
> +struct sideband_msg {
> +	u8 lct;
> +	u8 lcr;
> +	u8 rad[8];
> +	bool broadcast;
> +	bool path_msg;
> +	bool somt;
> +	bool eomt;
> +	bool seqno;
> +
> +	u8 body[48];
> +	u8 body_len;
> +};
> +
> +static void dprx_write(struct dprx *dprx, int addr, u32 val)
> +{
> +	writel(val, dprx->iobase + (addr * 4));
> +}
> +
> +static u32 dprx_read(struct dprx *dprx, int addr)
> +{
> +	return readl(dprx->iobase + (addr * 4));
> +}
> +
> +static void dprx_set_irq(struct dprx *dprx, int val)
> +{
> +	u32 reg;
> +
> +	reg = dprx_read(dprx, DPRX_AUX_CONTROL);
> +	reg |= ~(1 << DPRX_AUX_CONTROL_IRQ_EN);
> +	reg |= val << DPRX_AUX_CONTROL_IRQ_EN;
> +	dprx_write(dprx, DPRX_AUX_CONTROL, reg);
> +}
> +
> +static void dprx_set_hpd(struct dprx *dprx, int val)
> +{
> +	u32 reg;
> +
> +	reg = dprx_read(dprx, DPRX_AUX_HPD);
> +	reg &= ~(1 << DPRX_AUX_HPD_EN);
> +	reg |= val << DPRX_AUX_HPD_EN;
> +	dprx_write(dprx, DPRX_AUX_HPD, reg);
> +}
> +
> +static void dprx_pulse_hpd(struct dprx *dprx)
> +{
> +	u32 reg;
> +
> +	reg = dprx_read(dprx, DPRX_AUX_HPD);
> +	reg |= 1 << DPRX_AUX_HPD_IRQ;
> +	dprx_write(dprx, DPRX_AUX_HPD, reg);
> +}
> +
> +static void dprx_clear_vc_payload_table(struct dprx *dprx)
> +{
> +	u32 reg;
> +	int i;
> +
> +	memset(dprx->payload_table, 0, sizeof(dprx->payload_table));
> +
> +	for (i = 0; i < 8; i++)
> +		dprx_write(dprx, DPRX_MST_VCPTAB(i), 0);
> +
> +	reg = dprx_read(dprx, DPRX_MST_CONTROL1);
> +	reg &= ~(DPRX_MST_CONTROL1_VCP_IDS_MASK << DPRX_MST_CONTROL1_VCP_IDS_SHIFT);
> +	reg |= 1 << DPRX_MST_CONTROL1_VCPTAB_UPD_FORCE;
> +	dprx_write(dprx, DPRX_MST_CONTROL1, reg);
> +}
> +
> +static void dprx_set_vc_payload_table(struct dprx *dprx)
> +{
> +	int i, j;
> +	u32 reg;
> +	u8 val;
> +
> +	/*
> +	 * The IP core only accepts VC payload IDs of 1-4. Thus, we need to
> +	 * remap the 1-63 range allowed by DisplayPort into 1-4. However, some
> +	 * hosts first set the VC payload table and then allocate the VC
> +	 * payload IDs, which means we can't remap the range immediately.
> +	 *
> +	 * It is probably possible to force a VC payload table update (without
> +	 * waiting for a ACT trigger) when the IDs change, but for now we just
> +	 * ignore IDs higher than 4.
> +	 */
> +	for (i = 0; i < 8; i++) {
> +		reg = 0;
> +		for (j = 0; j < 8; j++) {
> +			val = dprx->payload_table[i*8+j];
> +			if (val <= 4)
> +				reg |= val << (j * 4);
> +		}
> +		dprx_write(dprx, DPRX_MST_VCPTAB(i), reg);
> +	}
> +
> +	reg = dprx_read(dprx, DPRX_MST_CONTROL1);
> +	reg |= 1 << DPRX_MST_CONTROL1_VCPTAB_UPD_REQ;
> +	dprx_write(dprx, DPRX_MST_CONTROL1, reg);
> +}
> +
> +static void dprx_set_vc_ids(struct dprx *dprx)
> +{
> +	u32 reg;
> +	int i;
> +
> +	reg = dprx_read(dprx, DPRX_MST_CONTROL1);
> +	reg &= ~(DPRX_MST_CONTROL1_VCP_IDS_MASK << DPRX_MST_CONTROL1_VCP_IDS_SHIFT);
> +	for (i = 0; i < dprx->max_stream_count; i++) {
> +		if (dprx->payload_id[i] <= 4)
> +			reg |= dprx->payload_id[i] << DPRX_MST_CONTROL1_VCP_ID_SHIFT(i);
> +	}
> +	dprx_write(dprx, DPRX_MST_CONTROL1, reg);
> +}
> +
> +static void dprx_allocate_vc_payload(struct dprx *dprx, u8 start, u8 count, u8 id)
> +{
> +	if (count > sizeof(dprx->payload_table) - start)
> +		count = sizeof(dprx->payload_table) - start;
> +	memset(dprx->payload_table + start, id, count);
> +}
> +
> +static void dprx_deallocate_vc_payload(struct dprx *dprx, int start, u8 id)
> +{
> +	u8 to = start;
> +	u8 i;
> +
> +	for (i = start; i < sizeof(dprx->payload_table); i++) {
> +		if (dprx->payload_table[i] == id)
> +			dprx->payload_table[i] = 0;
> +		else
> +			dprx->payload_table[to++] = dprx->payload_table[i];
> +	}
> +}
> +
> +static u32 dprx_full_pbn(struct dprx *dprx)
> +{
> +	u32 reg;
> +	u32 lane_count;
> +	u32 link_rate;
> +
> +	if ((dprx_read(dprx, DPRX_RX_STATUS) >> DPRX_RX_STATUS_INTERLANE_ALIGN) & 1) {
> +		/* link training done - get current bandwidth */
> +		reg = dprx_read(dprx, DPRX_RX_CONTROL);
> +		lane_count = (reg >> DPRX_RX_CONTROL_LANE_COUNT_SHIFT) &
> +			     DPRX_RX_CONTROL_LANE_COUNT_MASK;
> +		link_rate  = (reg >> DPRX_RX_CONTROL_LINK_RATE_SHIFT) &
> +			     DPRX_RX_CONTROL_LINK_RATE_MASK;
> +	} else {
> +		/* link training not done - get max bandwidth */
> +		lane_count = dprx->max_lane_count;
> +		link_rate  = dprx->max_link_rate;
> +	}
> +
> +	return lane_count * link_rate * 32;
> +}
> +
> +static int dprx_port_number_to_sink_idx(struct dprx *dprx, u8 port_number)
> +{
> +	/* check if port number is valid */
> +	if (port_number < DP_MST_LOGICAL_PORT_0 ||
> +	    port_number >= DP_MST_LOGICAL_PORT_0 + dprx->max_stream_count)
> +		return -1;
> +
> +	return port_number - DP_MST_LOGICAL_PORT_0;
> +}
> +
> +static bool dprx_adjust_needed(struct dprx *dprx)
> +{
> +	u32 control;
> +	u32 status;
> +	u32 lane_count;
> +	u32 lane_count_mask;
> +	u32 pattern;
> +
> +	control = dprx_read(dprx, DPRX_RX_CONTROL);
> +	status = dprx_read(dprx, DPRX_RX_STATUS);
> +
> +	pattern = (control >> DPRX_RX_CONTROL_TP_SHIFT) & DPRX_RX_CONTROL_TP_MASK;
> +	lane_count = (control >> DPRX_RX_CONTROL_LANE_COUNT_SHIFT) &
> +		     DPRX_RX_CONTROL_LANE_COUNT_MASK;
> +	lane_count_mask = (1 << lane_count) - 1;
> +
> +	if (pattern == 0) {
> +		/* link training not in progress */
> +		return false;
> +	} else if (pattern == 1) {
> +		/* link training CR phase - check CR lock */
> +		return (~status) & (lane_count_mask << DPRX_RX_STATUS_CR_LOCK_SHIFT);
> +	}
> +	/* link training EQ phase - check synbol lock and interlane align */
> +	return (~status) & (lane_count_mask << DPRX_RX_STATUS_SYM_LOCK_SHIFT |
> +			    1 << DPRX_RX_STATUS_INTERLANE_ALIGN);
> +}
> +
> +/*
> + * Return next allowed voltage swing, and pre-emphasis pair.
> + * DisplayPort 1.2 spec, section 3.1.5.2
> + */
> +static void dprx_training_control_next(struct dprx_training_control *ctl,
> +				       u8 *next_volt_swing, u8 *next_pre_emph)
> +{
> +	u8 volt_swing = ctl->volt_swing;
> +	u8 pre_emph = ctl->pre_emph;
> +
> +	pre_emph++;
> +	if (pre_emph > 2) {
> +		volt_swing++;
> +		pre_emph = 0;
> +	}
> +
> +	if (volt_swing > 2 || (volt_swing == 2 && pre_emph == 2)) {
> +		volt_swing = 0;
> +		pre_emph = 0;
> +	}
> +
> +	*next_volt_swing = volt_swing;
> +	*next_pre_emph = pre_emph;
> +}
> +
> +static int dprx_i2c_read(struct dprx_sink *sink, u8 addr, u8 *buf, int len)
> +{
> +	int offset;
> +
> +	if (len == 0)
> +		return 0;
> +
> +	switch (addr) {
> +	case DDC_EDID_ADDR:
> +		offset = sink->offset + sink->segment * 256;
> +		if (len + offset > sink->blocks * 128)
> +			return -1;
> +		memcpy(buf, sink->edid + offset, len);
> +		sink->offset += len;
> +		break;
> +	case DDC_SEGMENT_ADDR:
> +		if (len > 1)
> +			return -1;
> +		buf[0] = sink->segment;
> +		break;
> +	default:
> +		return -1;
> +	}
> +
> +	return 0;
> +}
> +
> +static int dprx_i2c_write(struct dprx_sink *sink, u8 addr, u8 *buf, int len)
> +{
> +	if (len == 0)
> +		return 0;
> +	if (len > 1)
> +		return -1;
> +
> +	switch (addr) {
> +	case DDC_EDID_ADDR:
> +		sink->offset = buf[0];
> +		break;
> +	case DDC_SEGMENT_ADDR:
> +		sink->segment = buf[0];
> +		break;
> +	default:
> +		return -1;
> +	}
> +
> +	return 0;
> +}
> +
> +static void dprx_i2c_stop(struct dprx_sink *sink)
> +{
> +	sink->segment = 0;
> +}
> +
> +static void dprx_write_nak(struct dprx *dprx,
> +			   struct drm_dp_sideband_msg_reply_body *rep,
> +			   u8 req_type, u8 reason)
> +{
> +	rep->reply_type = DP_SIDEBAND_REPLY_NAK;
> +	rep->req_type = req_type;
> +
> +	memcpy(rep->u.nak.guid, dprx->guid, sizeof(dprx->guid));
> +	rep->u.nak.reason = reason;
> +	rep->u.nak.nak_data = 0;
> +}
> +
> +static void dprx_execute_link_address(struct dprx *dprx,
> +				      struct drm_dp_sideband_msg_req_body *req,
> +				      struct drm_dp_sideband_msg_reply_body *rep)
> +{
> +	struct drm_dp_link_address_ack_reply *link_address = &rep->u.link_addr;
> +	struct drm_dp_link_addr_reply_port *port = link_address->ports;
> +	int i;
> +
> +	rep->reply_type = DP_SIDEBAND_REPLY_ACK;
> +	rep->req_type = DP_LINK_ADDRESS;
> +
> +	memcpy(link_address->guid, dprx->guid, sizeof(dprx->guid));
> +	link_address->nports = dprx->max_stream_count + 1;
> +
> +	/* Port 0: input (physical) */
> +	port->input_port = true;
> +	port->peer_device_type = DP_PEER_DEVICE_SOURCE_OR_SST;
> +	port->port_number = 0;
> +	port->mcs = false;
> +	port->ddps = true;
> +	port++;
> +
> +	for (i = 0; i < dprx->max_stream_count; i++) {
> +		/* Port 8 + n: internal sink number n (logical) */
> +		port->input_port = false;
> +		port->port_number = DP_MST_LOGICAL_PORT_0 + i;
> +		port->mcs = false;
> +		if (dprx->sinks[i].blocks > 0) {
> +			port->peer_device_type = DP_PEER_DEVICE_SST_SINK;
> +			port->ddps = true;
> +		} else {
> +			port->peer_device_type = DP_PEER_DEVICE_NONE;
> +			port->ddps = false;
> +		}
> +		port->legacy_device_plug_status = false;
> +		port->dpcd_revision = 0;
> +		memset(port->peer_guid, 0, 16);
> +		port->num_sdp_streams = 0;
> +		port->num_sdp_stream_sinks = 0;
> +		port++;
> +	}
> +}
> +
> +static void dprx_execute_connection_status_notify(struct dprx *dprx,
> +						  struct drm_dp_sideband_msg_req_body *req,
> +						  struct drm_dp_sideband_msg_reply_body *rep)
> +{
> +	rep->reply_type = DP_SIDEBAND_REPLY_ACK;
> +	rep->req_type = DP_CONNECTION_STATUS_NOTIFY;
> +}
> +
> +static void dprx_execute_enum_path_resources(struct dprx *dprx,
> +					     struct drm_dp_sideband_msg_req_body *req,
> +					     struct drm_dp_sideband_msg_reply_body *rep)
> +{
> +	u32 full_pbn = dprx_full_pbn(dprx);
> +
> +	rep->reply_type = DP_SIDEBAND_REPLY_ACK;
> +	rep->req_type = DP_ENUM_PATH_RESOURCES;
> +
> +	rep->u.path_resources.port_number = req->u.port_num.port_number;
> +	rep->u.path_resources.fec_capable = false;
> +	rep->u.path_resources.full_payload_bw_number = full_pbn;
> +	if (dprx->payload_pbn_total > full_pbn)
> +		rep->u.path_resources.avail_payload_bw_number = 0;
> +	else
> +		rep->u.path_resources.avail_payload_bw_number = full_pbn - dprx->payload_pbn_total;
> +}
> +
> +static void dprx_execute_allocate_payload(struct dprx *dprx,
> +					  struct drm_dp_sideband_msg_req_body *req,
> +					  struct drm_dp_sideband_msg_reply_body *rep)
> +{
> +	struct drm_dp_allocate_payload *a_req = &req->u.allocate_payload;
> +	struct drm_dp_allocate_payload_ack_reply *a_rep = &rep->u.allocate_payload;
> +	int sink_idx;
> +
> +	sink_idx = dprx_port_number_to_sink_idx(dprx, a_req->port_number);
> +	if (sink_idx == -1) {
> +		dprx_write_nak(dprx, rep, req->req_type, DP_NAK_BAD_PARAM);
> +		return;
> +	}
> +
> +	if (a_req->vcpi == 0) {
> +		dprx_write_nak(dprx, rep, req->req_type, DP_NAK_BAD_PARAM);
> +		return;
> +	}
> +
> +	if (a_req->pbn > 0) {
> +		if (dprx->payload_pbn[sink_idx] == 0) {
> +			/* New payload ID */
> +			dprx->payload_id[sink_idx] = a_req->vcpi;
> +		} else if (dprx->payload_id[sink_idx] != a_req->vcpi) {
> +			/* At most one payload ID is allowed per sink */
> +			dprx_write_nak(dprx, rep, req->req_type, DP_NAK_ALLOCATE_FAIL);
> +			return;
> +		}
> +	}
> +	WARN_ON_ONCE(dprx->payload_pbn_total < dprx->payload_pbn[sink_idx]);
> +	dprx->payload_pbn_total -= dprx->payload_pbn[sink_idx];
> +	dprx->payload_pbn_total += a_req->pbn;
> +	dprx->payload_pbn[sink_idx] = a_req->pbn;
> +
> +	dprx_set_vc_ids(dprx);
> +
> +	rep->reply_type = DP_SIDEBAND_REPLY_ACK;
> +	rep->req_type = DP_ALLOCATE_PAYLOAD;
> +
> +	a_rep->port_number = a_req->port_number;
> +	a_rep->vcpi = a_req->vcpi;
> +	a_rep->allocated_pbn = a_req->pbn;
> +}
> +
> +static void dprx_execute_clear_payload_id_table(struct dprx *dprx,
> +						struct drm_dp_sideband_msg_req_body *req,
> +						struct drm_dp_sideband_msg_reply_body *rep)
> +{
> +	rep->reply_type = DP_SIDEBAND_REPLY_ACK;
> +	rep->req_type = DP_CLEAR_PAYLOAD_ID_TABLE;
> +
> +	dprx_clear_vc_payload_table(dprx);
> +}
> +
> +static void dprx_execute_remote_dpcd_read(struct dprx *dprx,
> +					  struct drm_dp_sideband_msg_req_body *req,
> +					  struct drm_dp_sideband_msg_reply_body *rep)
> +{
> +	struct drm_dp_remote_dpcd_read *read_req = &req->u.dpcd_read;
> +	struct drm_dp_remote_dpcd_read_ack_reply *read_rep = &rep->u.remote_dpcd_read_ack;
> +
> +	rep->reply_type = DP_SIDEBAND_REPLY_ACK;
> +	rep->req_type = DP_REMOTE_DPCD_READ;
> +
> +	read_rep->port_number = read_req->port_number;
> +	read_rep->num_bytes = read_req->num_bytes;
> +	memset(read_rep->bytes, 0, read_req->num_bytes);
> +}
> +
> +static void dprx_execute_remote_i2c_read(struct dprx *dprx,
> +					 struct drm_dp_sideband_msg_req_body *req,
> +					 struct drm_dp_sideband_msg_reply_body *rep)
> +{
> +	struct drm_dp_remote_i2c_read *read_req = &req->u.i2c_read;
> +	struct drm_dp_remote_i2c_read_ack_reply *read_rep = &rep->u.remote_i2c_read_ack;
> +	struct drm_dp_remote_i2c_read_tx *tx;
> +	struct dprx_sink *sink;
> +	int sink_idx;
> +	int res;
> +	int i;
> +
> +	sink_idx = dprx_port_number_to_sink_idx(dprx, read_req->port_number);
> +	if (sink_idx == -1) {
> +		dprx_write_nak(dprx, rep, req->req_type, DP_NAK_BAD_PARAM);
> +		return;
> +	}
> +	sink = &dprx->sinks[sink_idx];
> +
> +	for (i = 0; i < read_req->num_transactions; i++) {
> +		tx = &read_req->transactions[i];
> +		res = dprx_i2c_write(sink, tx->i2c_dev_id, tx->bytes, tx->num_bytes);
> +		if (res)
> +			goto i2c_err;
> +		if (!tx->no_stop_bit)
> +			dprx_i2c_stop(sink);
> +	}
> +
> +	res = dprx_i2c_read(sink, read_req->read_i2c_device_id,
> +				  read_rep->bytes, read_req->num_bytes_read);
> +	if (res)
> +		goto i2c_err;
> +	dprx_i2c_stop(sink);
> +
> +	rep->reply_type = DP_SIDEBAND_REPLY_ACK;
> +	rep->req_type = DP_REMOTE_I2C_READ;
> +
> +	read_rep->port_number = read_req->port_number;
> +	read_rep->num_bytes = read_req->num_bytes_read;
> +	return;
> +
> +i2c_err:
> +	dprx_i2c_stop(sink);
> +	dprx_write_nak(dprx, rep, req->req_type, DP_NAK_I2C_NAK);
> +}
> +
> +static void dprx_execute_remote_i2c_write(struct dprx *dprx,
> +					  struct drm_dp_sideband_msg_req_body *req,
> +					  struct drm_dp_sideband_msg_reply_body *rep)
> +{
> +	struct drm_dp_remote_i2c_write *write_req = &req->u.i2c_write;
> +	struct drm_dp_remote_i2c_write_ack_reply *write_rep = &rep->u.remote_i2c_write_ack;
> +	struct dprx_sink *sink;
> +	int sink_idx;
> +	int res;
> +
> +	sink_idx = dprx_port_number_to_sink_idx(dprx, write_req->port_number);
> +	if (sink_idx == -1) {
> +		dprx_write_nak(dprx, rep, req->req_type, DP_NAK_BAD_PARAM);
> +		return;
> +	}
> +	sink = &dprx->sinks[sink_idx];
> +
> +	res = dprx_i2c_write(sink, write_req->write_i2c_device_id,
> +				   write_req->bytes, write_req->num_bytes);
> +	dprx_i2c_stop(sink);
> +	if (res) {
> +		dprx_write_nak(dprx, rep, req->req_type, DP_NAK_I2C_NAK);
> +		return;
> +	}
> +
> +	rep->reply_type = DP_SIDEBAND_REPLY_ACK;
> +	rep->req_type = DP_REMOTE_I2C_WRITE;
> +	write_rep->port_number = write_req->port_number;
> +}
> +
> +static void dprx_execute_power_up_phy(struct dprx *dprx,
> +				      struct drm_dp_sideband_msg_req_body *req,
> +				      struct drm_dp_sideband_msg_reply_body *rep)
> +{
> +	rep->reply_type = DP_SIDEBAND_REPLY_ACK;
> +	rep->req_type = DP_POWER_UP_PHY;
> +	rep->u.port_number.port_number = req->u.port_num.port_number;
> +}
> +
> +static void dprx_execute_power_down_phy(struct dprx *dprx,
> +					struct drm_dp_sideband_msg_req_body *req,
> +					struct drm_dp_sideband_msg_reply_body *rep)
> +{
> +	rep->reply_type = DP_SIDEBAND_REPLY_ACK;
> +	rep->req_type = DP_POWER_DOWN_PHY;
> +	rep->u.port_number.port_number = req->u.port_num.port_number;
> +}
> +
> +static void dprx_encode_sideband_msg(struct sideband_msg *msg, u8 *buf)
> +{
> +	int idx = 0;
> +	int i;
> +	u8 crc4;
> +
> +	buf[idx++] = ((msg->lct & 0xf) << 4) | (msg->lcr & 0xf);
> +	for (i = 0; i < (msg->lct / 2); i++)
> +		buf[idx++] = msg->rad[i];
> +	buf[idx++] = (msg->broadcast << 7) | (msg->path_msg << 6) |
> +		((msg->body_len + 1) & 0x3f);
> +	buf[idx++] = (msg->somt << 7) | (msg->eomt << 6) | (msg->seqno << 4);
> +
> +	crc4 = crc_dp_msg_header(buf, (idx * 2) - 1);
> +	buf[idx - 1] |= (crc4 & 0xf);
> +
> +	memcpy(&buf[idx], msg->body, msg->body_len);
> +	idx += msg->body_len;
> +	buf[idx] = crc_dp_msg_data(msg->body, msg->body_len);
> +}
> +
> +static bool dprx_decode_sideband_msg(struct sideband_msg *msg, u8 *buf, int buflen)
> +{
> +	u8 hdr_crc;
> +	u8 hdr_len;
> +	u8 body_crc;
> +	int i;
> +	u8 idx;
> +
> +	if (buf[0] == 0)
> +		return false;
> +	hdr_len = 3;
> +	hdr_len += ((buf[0] & 0xf0) >> 4) / 2;
> +	if (hdr_len > buflen)
> +		return false;
> +	hdr_crc = crc_dp_msg_header(buf, (hdr_len * 2) - 1);
> +	if ((hdr_crc & 0xf) != (buf[hdr_len - 1] & 0xf))
> +		return false;
> +
> +	msg->lct = (buf[0] & 0xf0) >> 4;
> +	msg->lcr = (buf[0] & 0xf);
> +	idx = 1;
> +	for (i = 0; i < (msg->lct / 2); i++)
> +		msg->rad[i] = buf[idx++];
> +	msg->broadcast = (buf[idx] >> 7) & 0x1;
> +	msg->path_msg = (buf[idx] >> 6) & 0x1;
> +	msg->body_len = (buf[idx] & 0x3f) - 1;
> +	idx++;
> +	msg->somt = (buf[idx] >> 7) & 0x1;
> +	msg->eomt = (buf[idx] >> 6) & 0x1;
> +	msg->seqno = (buf[idx] >> 4) & 0x1;
> +	idx++;
> +
> +	if (hdr_len + msg->body_len + 1 != buflen)
> +		return false;
> +
> +	body_crc = crc_dp_msg_data(&buf[idx], msg->body_len);
> +	if (body_crc != buf[idx + msg->body_len])
> +		return false;
> +
> +	memcpy(msg->body, &buf[idx], msg->body_len);
> +	idx += msg->body_len;
> +
> +	return true;
> +}
> +
> +static bool dprx_decode_port_number_req(struct drm_dp_port_number_req *port_num, u8 *buf, int len)
> +{
> +	if (len != 1)
> +		return false;
> +
> +	port_num->port_number = buf[0] >> 4;
> +
> +	return true;
> +}
> +
> +static bool
> +dprx_decode_connection_status_notify_req(struct drm_dp_connection_status_notify *conn_stat,
> +					 u8 *buf, int len)
> +{
> +	int idx = 0;
> +
> +	if (len != 18)
> +		return false;
> +
> +	conn_stat->port_number = buf[idx++];
> +	memcpy(conn_stat->guid, &buf[idx], 16);
> +	idx += 16;
> +	conn_stat->legacy_device_plug_status = (buf[idx] >> 6) & 1;
> +	conn_stat->displayport_device_plug_status = (buf[idx] >> 5) & 1;
> +	conn_stat->message_capability_status = (buf[idx] >> 4) & 1;
> +	conn_stat->input_port = (buf[idx] >> 3) & 1;
> +	conn_stat->peer_device_type = buf[idx] & 0x7;
> +
> +	return true;
> +}
> +
> +static bool dprx_decode_allocate_payload_req(struct drm_dp_allocate_payload *alloc_payload,
> +					     u8 *buf, int len)
> +{
> +	int idx = 0;
> +	int i;
> +
> +	if (len < 4)
> +		return false;
> +
> +	alloc_payload->port_number = buf[idx] >> 4;
> +	alloc_payload->number_sdp_streams = buf[idx++] & 0xf;
> +	alloc_payload->vcpi = buf[idx++] & 0x7f;
> +	alloc_payload->pbn = buf[idx] << 8 | buf[idx + 1];
> +	idx += 2;
> +
> +	if (len != idx + (alloc_payload->number_sdp_streams + 1) / 2)
> +		return false;
> +
> +	for (i = 0; i < alloc_payload->number_sdp_streams; i++) {
> +		if ((i & 1) == 0) {
> +			alloc_payload->sdp_stream_sink[i] = buf[idx] >> 4;
> +		} else {
> +			alloc_payload->sdp_stream_sink[i] = buf[idx] & 0xf;
> +			idx++;
> +		}
> +	}
> +
> +	return true;
> +}
> +
> +static bool dprx_decode_remote_dpcd_read_req(struct drm_dp_remote_dpcd_read *dpcd_read,
> +					     u8 *buf, int len)
> +{
> +	if (len != 4)
> +		return false;
> +
> +	dpcd_read->port_number = buf[0] >> 4;
> +	dpcd_read->dpcd_address = (buf[0] & 0xf) << 16 | buf[1] << 8 | buf[2];
> +	dpcd_read->num_bytes = buf[3];
> +
> +	return true;
> +}
> +
> +static bool dprx_decode_remote_i2c_read_req(struct drm_dp_remote_i2c_read *i2c_read,
> +					    u8 *buf, int len)
> +{
> +	struct drm_dp_remote_i2c_read_tx *tx;
> +	int idx = 0;
> +	int i;
> +
> +	if (len < 1)
> +		return false;
> +
> +	i2c_read->port_number = buf[idx] >> 4;
> +	i2c_read->num_transactions = buf[idx] & 0x3;
> +	idx++;
> +
> +	for (i = 0; i < i2c_read->num_transactions; i++) {
> +		tx = &i2c_read->transactions[i];
> +		if (len < idx + 2)
> +			return false;
> +		tx->i2c_dev_id = buf[idx++] & 0x7f;
> +		tx->num_bytes = buf[idx++];
> +		if (len < idx + tx->num_bytes + 1)
> +			return -1;
> +		tx->bytes = &buf[idx];
> +		idx += tx->num_bytes;
> +		tx->no_stop_bit = (buf[idx] >> 4) & 1;
> +		tx->i2c_transaction_delay = buf[idx] & 0xf;
> +		idx++;
> +	}
> +
> +	if (len != idx + 2)
> +		return false;
> +
> +	i2c_read->read_i2c_device_id = buf[idx++] & 0x7f;
> +	i2c_read->num_bytes_read = buf[idx++];
> +
> +	return true;
> +}
> +
> +static bool dprx_decode_remote_i2c_write_req(struct drm_dp_remote_i2c_write *i2c_write,
> +					     u8 *buf, int len)
> +{
> +	int idx = 0;
> +
> +	if (len < 3)
> +		return false;
> +
> +	i2c_write->port_number = buf[idx++] >> 4;
> +	i2c_write->write_i2c_device_id = buf[idx++] & 0x7f;
> +	i2c_write->num_bytes = buf[idx++];
> +
> +	if (len != idx + i2c_write->num_bytes)
> +		return false;
> +
> +	i2c_write->bytes = &buf[idx];
> +
> +	return true;
> +}
> +
> +static bool dprx_decode_sideband_req(struct drm_dp_sideband_msg_req_body *req, u8 *buf, int len)
> +{
> +	if (len == 0)
> +		return false;
> +
> +	req->req_type = buf[0] & 0x7f;
> +	buf++;
> +	len--;
> +
> +	switch (req->req_type) {
> +	case DP_LINK_ADDRESS:
> +	case DP_CLEAR_PAYLOAD_ID_TABLE:
> +		return len == 0; /* no request data */
> +	case DP_ENUM_PATH_RESOURCES:
> +	case DP_POWER_UP_PHY:
> +	case DP_POWER_DOWN_PHY:
> +		return dprx_decode_port_number_req(&req->u.port_num, buf, len);
> +	case DP_CONNECTION_STATUS_NOTIFY:
> +		return dprx_decode_connection_status_notify_req(&req->u.conn_stat, buf, len);
> +	case DP_ALLOCATE_PAYLOAD:
> +		return dprx_decode_allocate_payload_req(&req->u.allocate_payload, buf, len);
> +	case DP_REMOTE_DPCD_READ:
> +		return dprx_decode_remote_dpcd_read_req(&req->u.dpcd_read, buf, len);
> +	case DP_REMOTE_I2C_READ:
> +		return dprx_decode_remote_i2c_read_req(&req->u.i2c_read, buf, len);
> +	case DP_REMOTE_I2C_WRITE:
> +		return dprx_decode_remote_i2c_write_req(&req->u.i2c_write, buf, len);
> +	default:
> +		return false;
> +	}
> +}
> +
> +static void dprx_encode_sideband_rep(struct drm_dp_sideband_msg_reply_body *rep, u8 *buf, int *len)
> +{
> +	int idx = 0;
> +	int i;
> +
> +	buf[idx++] = (rep->reply_type & 0x1) << 7 | (rep->req_type & 0x7f);
> +
> +	if (rep->reply_type) {
> +		memcpy(&buf[idx], rep->u.nak.guid, 16);
> +		idx += 16;
> +		buf[idx++] = rep->u.nak.reason;
> +		buf[idx++] = rep->u.nak.nak_data;
> +		*len = idx;
> +		return;
> +	}
> +
> +	switch (rep->req_type) {
> +	case DP_LINK_ADDRESS: {
> +		struct drm_dp_link_address_ack_reply *link_addr = &rep->u.link_addr;
> +		struct drm_dp_link_addr_reply_port *port;
> +
> +		memcpy(&buf[idx], link_addr->guid, 16);
> +		idx += 16;
> +		buf[idx++] = link_addr->nports;
> +		for (i = 0; i < link_addr->nports; i++) {
> +			port = &link_addr->ports[i];
> +			buf[idx++] = port->input_port << 7 | port->peer_device_type << 4 |
> +				     port->port_number;
> +			if (port->input_port == 0) {
> +				buf[idx++] = port->mcs << 7 | port->ddps << 6 |
> +					     port->legacy_device_plug_status << 5;
> +				buf[idx++] = port->dpcd_revision;
> +				memcpy(&buf[idx], port->peer_guid, 16);
> +				idx += 16;
> +				buf[idx++] = port->num_sdp_streams << 4 |
> +					     port->num_sdp_stream_sinks;
> +			} else {
> +				buf[idx++] = port->mcs << 7 | port->ddps << 6;
> +			}
> +		}
> +		break;
> +	}
> +	case DP_ENUM_PATH_RESOURCES: {
> +		struct drm_dp_enum_path_resources_ack_reply *path_res = &rep->u.path_resources;
> +
> +		buf[idx++] = path_res->port_number << 4 | path_res->fec_capable;
> +		buf[idx++] = path_res->full_payload_bw_number >> 8;
> +		buf[idx++] = path_res->full_payload_bw_number & 0xff;
> +		buf[idx++] = path_res->avail_payload_bw_number >> 8;
> +		buf[idx++] = path_res->avail_payload_bw_number & 0xff;
> +		break;
> +	}
> +	case DP_ALLOCATE_PAYLOAD: {
> +		struct drm_dp_allocate_payload_ack_reply *alloc_payload = &rep->u.allocate_payload;
> +
> +		buf[idx++] = alloc_payload->port_number << 4;
> +		buf[idx++] = alloc_payload->vcpi & 0x3f;
> +		buf[idx++] = alloc_payload->allocated_pbn >> 8;
> +		buf[idx++] = alloc_payload->allocated_pbn & 0xff;
> +		break;
> +	}
> +	case DP_REMOTE_DPCD_READ: {
> +		struct drm_dp_remote_dpcd_read_ack_reply *dpcd_read = &rep->u.remote_dpcd_read_ack;
> +
> +		buf[idx++] = dpcd_read->port_number & 0xf;
> +		buf[idx++] = dpcd_read->num_bytes;
> +		memcpy(&buf[idx], dpcd_read->bytes, dpcd_read->num_bytes);
> +		idx += dpcd_read->num_bytes;
> +		break;
> +	}
> +	case DP_REMOTE_I2C_READ: {
> +		struct drm_dp_remote_i2c_read_ack_reply *i2c_read = &rep->u.remote_i2c_read_ack;
> +
> +		buf[idx++] = i2c_read->port_number & 0xf;
> +		buf[idx++] = i2c_read->num_bytes;
> +		memcpy(&buf[idx], i2c_read->bytes, i2c_read->num_bytes);
> +		idx += i2c_read->num_bytes;
> +		break;
> +	}
> +	case DP_REMOTE_I2C_WRITE:
> +		buf[idx++] = rep->u.remote_i2c_write_ack.port_number & 0xf;
> +		break;
> +	case DP_POWER_UP_PHY:
> +	case DP_POWER_DOWN_PHY:
> +		buf[idx++] = rep->u.port_number.port_number << 4;
> +		break;
> +	}
> +	*len = idx;
> +}
> +
> +static void dprx_execute_msg_transaction(struct dprx *dprx,
> +					 struct drm_dp_sideband_msg_req_body *req,
> +					 struct drm_dp_sideband_msg_reply_body *rep)
> +{
> +	switch (req->req_type) {
> +	case DP_LINK_ADDRESS:
> +		dprx_execute_link_address(dprx, req, rep);
> +		break;
> +	case DP_CONNECTION_STATUS_NOTIFY:
> +		dprx_execute_connection_status_notify(dprx, req, rep);
> +		break;
> +	case DP_ENUM_PATH_RESOURCES:
> +		dprx_execute_enum_path_resources(dprx, req, rep);
> +		break;
> +	case DP_ALLOCATE_PAYLOAD:
> +		dprx_execute_allocate_payload(dprx, req, rep);
> +		break;
> +	case DP_CLEAR_PAYLOAD_ID_TABLE:
> +		dprx_execute_clear_payload_id_table(dprx, req, rep);
> +		break;
> +	case DP_REMOTE_DPCD_READ:
> +		dprx_execute_remote_dpcd_read(dprx, req, rep);
> +		break;
> +	case DP_REMOTE_I2C_READ:
> +		dprx_execute_remote_i2c_read(dprx, req, rep);
> +		break;
> +	case DP_REMOTE_I2C_WRITE:
> +		dprx_execute_remote_i2c_write(dprx, req, rep);
> +		break;
> +	case DP_POWER_UP_PHY:
> +		dprx_execute_power_up_phy(dprx, req, rep);
> +		break;
> +	case DP_POWER_DOWN_PHY:
> +		dprx_execute_power_down_phy(dprx, req, rep);
> +		break;
> +	default:
> +		dprx_write_nak(dprx, rep, req->req_type, DP_NAK_BAD_PARAM);
> +		break;
> +	}
> +}
> +
> +static void dprx_handle_msg_transaction(struct dprx *dprx,
> +					struct msg_transaction_rxbuf *rxbuf,
> +					struct msg_transaction_txbuf *txbuf)
> +{
> +	bool decoded;
> +	struct drm_dp_sideband_msg_req_body req;
> +	struct drm_dp_sideband_msg_reply_body rep;
> +
> +	decoded = dprx_decode_sideband_req(&req, rxbuf->buf, rxbuf->len);
> +	if (decoded)
> +		dprx_execute_msg_transaction(dprx, &req, &rep);
> +	else
> +		dprx_write_nak(dprx, &rep, req.req_type, DP_NAK_BAD_PARAM);
> +	dprx_encode_sideband_rep(&rep, txbuf->buf, &txbuf->len);
> +	txbuf->written = 0;
> +}
> +
> +static void dprx_msg_transaction_append(struct msg_transaction_rxbuf *rxbuf,
> +					struct msg_transaction_meta *meta,
> +					struct sideband_msg *msg)
> +{
> +	int append_len;
> +
> +	append_len = min(msg->body_len, sizeof(rxbuf->buf) - rxbuf->len);
> +	memcpy(rxbuf->buf + rxbuf->len, msg->body, append_len);
> +	rxbuf->len += append_len;
> +
> +	if (msg->somt) {
> +		meta->lct = msg->lct;
> +		memcpy(meta->rad, msg->rad, msg->lct / 2);
> +		meta->seqno = msg->seqno;
> +	}
> +}
> +
> +static void dprx_msg_transaction_extract(struct msg_transaction_txbuf *txbuf,
> +					 struct msg_transaction_meta *meta,
> +					 struct sideband_msg *msg)
> +{
> +	int hdr_len = 3 + meta->lct / 2;
> +	int body_len;
> +	bool somt;
> +	bool eomt;
> +
> +	body_len = txbuf->len - txbuf->written;
> +	/* trim body_len so that the sideband msg fits into 48 bytes */
> +	body_len = min(body_len, 48 - 1 - hdr_len);
> +
> +	somt = (txbuf->written == 0);
> +	eomt = (txbuf->written + body_len == txbuf->len);
> +
> +	msg->lct = meta->lct;
> +	msg->lcr = meta->lct - 1;
> +	memcpy(msg->rad, meta->rad, meta->lct / 2);
> +	msg->broadcast = false;
> +	msg->path_msg = false;
> +	msg->somt = somt;
> +	msg->eomt = eomt;
> +	msg->seqno = meta->seqno;
> +
> +	memcpy(msg->body, txbuf->buf + txbuf->written, body_len);
> +	msg->body_len = body_len;
> +
> +	txbuf->written += body_len;
> +}
> +
> +static void dprx_msg_transaction_clear_rxbuf(struct msg_transaction_rxbuf *rxbuf)
> +{
> +	rxbuf->len = 0;
> +}
> +
> +static void dprx_msg_transaction_clear_txbuf(struct msg_transaction_txbuf *txbuf)
> +{
> +	txbuf->len = 0;
> +	txbuf->written = 0;
> +}
> +
> +static bool dprx_msg_transaction_txbuf_empty(struct msg_transaction_txbuf *txbuf)
> +{
> +	return txbuf->written == txbuf->len;
> +}
> +
> +static void dprx_write_pending_sideband_msg(struct dprx *dprx)
> +{
> +	struct msg_transaction_txbuf *txbuf;
> +	struct msg_transaction_meta *meta;
> +	struct sideband_msg msg;
> +
> +	if (WARN_ON_ONCE(!dprx->mt_pending))
> +		return;
> +
> +	txbuf = &dprx->mt_txbuf[dprx->mt_seqno];
> +	meta = &dprx->mt_meta[dprx->mt_seqno];
> +
> +	dprx_msg_transaction_extract(txbuf, meta, &msg);
> +	if (dprx_msg_transaction_txbuf_empty(txbuf)) {
> +		dprx->mt_seqno = !dprx->mt_seqno;
> +		txbuf = &dprx->mt_txbuf[dprx->mt_seqno];
> +		if (dprx_msg_transaction_txbuf_empty(txbuf))
> +			dprx->mt_pending = false;
> +	}
> +
> +	dprx_encode_sideband_msg(&msg, dprx->down_rep_buf);
> +}
> +
> +static void dprx_signal_irq(struct dprx *dprx, int irq)
> +{
> +	dprx->irq_vector |= irq;
> +	dprx_pulse_hpd(dprx);
> +}
> +
> +static void dprx_handle_sideband_msg(struct dprx *dprx, struct sideband_msg *msg)
> +{
> +	struct msg_transaction_rxbuf *rxbuf = &dprx->mt_rxbuf[msg->seqno];
> +	struct msg_transaction_txbuf *txbuf = &dprx->mt_txbuf[msg->seqno];
> +	struct msg_transaction_meta *meta = &dprx->mt_meta[msg->seqno];
> +
> +	if (msg->somt)
> +		dprx_msg_transaction_clear_rxbuf(rxbuf);
> +	dprx_msg_transaction_append(rxbuf, meta, msg);
> +
> +	if (msg->eomt) {
> +		/* drop the message if txbuf isn't empty */
> +		if (!dprx_msg_transaction_txbuf_empty(txbuf))
> +			return;
> +		dprx_handle_msg_transaction(dprx, rxbuf, txbuf);
> +
> +		if (!dprx->mt_pending) {
> +			dprx->mt_pending = true;
> +			dprx->mt_seqno = msg->seqno;
> +			if (!dprx->down_rep_pending) {
> +				dprx_write_pending_sideband_msg(dprx);
> +				dprx_signal_irq(dprx, DP_DOWN_REP_MSG_RDY);
> +				dprx->down_rep_pending = true;
> +			}
> +		}
> +	}
> +}
> +
> +static void dprx_init_caps(struct dprx *dprx)
> +{
> +	memset(dprx->caps, 0, sizeof(dprx->caps));
> +	dprx->caps[DP_DPCD_REV]			= DP_DPCD_REV_14;
> +	dprx->caps[DP_MAX_LINK_RATE]		= dprx->max_link_rate;
> +	dprx->caps[DP_MAX_LANE_COUNT]		= DP_ENHANCED_FRAME_CAP | DP_TPS3_SUPPORTED |
> +						  dprx->max_lane_count;
> +	dprx->caps[DP_MAX_DOWNSPREAD]		= DP_TPS4_SUPPORTED | DP_MAX_DOWNSPREAD_0_5;
> +	dprx->caps[DP_MAIN_LINK_CHANNEL_CODING]	= DP_CAP_ANSI_8B10B;
> +	dprx->caps[DP_RECEIVE_PORT_0_CAP_0]	= DP_LOCAL_EDID_PRESENT;
> +}
> +
> +static u8 dprx_read_caps(struct dprx *dprx, u32 offset)
> +{
> +	return dprx->caps[offset];
> +}
> +
> +static u8 dprx_read_mstm_cap(struct dprx *dprx)
> +{
> +	return dprx->multi_stream_support;
> +}
> +
> +static u8 dprx_read_guid(struct dprx *dprx, u32 offset)
> +{
> +	return dprx->guid[offset];
> +}
> +
> +static void dprx_write_guid(struct dprx *dprx, u32 offset, u8 val)
> +{
> +	dprx->guid[offset] = val;
> +}
> +
> +static u8 dprx_read_link_bw(struct dprx *dprx)
> +{
> +	u32 reg = dprx_read(dprx, DPRX_RX_CONTROL);
> +
> +	return (reg >> DPRX_RX_CONTROL_LINK_RATE_SHIFT) & DPRX_RX_CONTROL_LINK_RATE_MASK;
> +}
> +
> +static void dprx_write_link_bw(struct dprx *dprx, u8 val)
> +{
> +	u32 reg;
> +
> +	if (val != DP_LINK_BW_1_62 && val != DP_LINK_BW_2_7 &&
> +	    val != DP_LINK_BW_5_4  && val != DP_LINK_BW_8_1)
> +		return;
> +
> +	if (val > dprx->max_link_rate)
> +		return;
> +
> +	reg = dprx_read(dprx, DPRX_RX_CONTROL);
> +	reg &= ~(DPRX_RX_CONTROL_LINK_RATE_MASK << DPRX_RX_CONTROL_LINK_RATE_SHIFT);
> +	reg |= val << DPRX_RX_CONTROL_LINK_RATE_SHIFT;
> +	reg |= 1 << DPRX_RX_CONTROL_RECONFIG_LINKRATE;
> +	dprx_write(dprx, DPRX_RX_CONTROL, reg);
> +}
> +
> +static u8 dprx_read_lane_count(struct dprx *dprx)
> +{
> +	u32 reg = dprx_read(dprx, DPRX_RX_CONTROL);
> +
> +	return (reg >> DPRX_RX_CONTROL_LANE_COUNT_SHIFT) & DPRX_RX_CONTROL_LANE_COUNT_MASK;
> +}
> +
> +static void dprx_write_lane_count(struct dprx *dprx, u8 val)
> +{
> +	u32 reg;
> +	u8 lane_count;
> +
> +	lane_count = val & DP_LANE_COUNT_MASK;
> +
> +	if (lane_count != 1 && lane_count != 2 && lane_count != 4)
> +		return;
> +
> +	if (lane_count > dprx->max_lane_count)
> +		return;
> +
> +	reg = dprx_read(dprx, DPRX_RX_CONTROL);
> +	reg &= ~(DPRX_RX_CONTROL_LANE_COUNT_MASK << DPRX_RX_CONTROL_LANE_COUNT_SHIFT);
> +	reg |= lane_count << DPRX_RX_CONTROL_LANE_COUNT_SHIFT;
> +	dprx_write(dprx, DPRX_RX_CONTROL, reg);
> +}
> +
> +static u8 dprx_read_training_pattern(struct dprx *dprx)
> +{
> +	u32 reg;
> +	u32 pattern;
> +	u32 scrambler_disable;
> +	u8 result = 0;
> +
> +	reg = dprx_read(dprx, DPRX_RX_CONTROL);
> +	pattern = (reg >> DPRX_RX_CONTROL_TP_SHIFT) & DPRX_RX_CONTROL_TP_MASK;
> +	scrambler_disable = (reg >> DPRX_RX_CONTROL_SCRAMBLER_DISABLE) & 1;
> +
> +	if (scrambler_disable)
> +		result |= DP_LINK_SCRAMBLING_DISABLE;
> +	result |= pattern;
> +
> +	return result;
> +}
> +
> +static void dprx_write_training_pattern(struct dprx *dprx, u8 val)
> +{
> +	u8 pattern;
> +	u8 scrambler_disable;
> +	u32 reg;
> +
> +	pattern = val & DP_TRAINING_PATTERN_MASK_1_4;
> +	scrambler_disable = !!(val & DP_LINK_SCRAMBLING_DISABLE);
> +
> +	reg = dprx_read(dprx, DPRX_RX_CONTROL);
> +	reg &= ~(DPRX_RX_CONTROL_TP_MASK << DPRX_RX_CONTROL_TP_SHIFT);
> +	reg |= pattern << DPRX_RX_CONTROL_TP_SHIFT;
> +	reg &= ~(1 << DPRX_RX_CONTROL_SCRAMBLER_DISABLE);
> +	reg |= scrambler_disable << DPRX_RX_CONTROL_SCRAMBLER_DISABLE;
> +	dprx_write(dprx, DPRX_RX_CONTROL, reg);
> +}
> +
> +static u8 dprx_read_training_lane(struct dprx *dprx, u32 offset)
> +{
> +	struct dprx_training_control *ctl = &dprx->training_control[offset];
> +	u8 result = 0;
> +
> +	result |= ctl->volt_swing << DP_TRAIN_VOLTAGE_SWING_SHIFT;
> +	if (ctl->max_swing)
> +		result |= DP_TRAIN_MAX_SWING_REACHED;
> +	result |= ctl->pre_emph << DP_TRAIN_PRE_EMPHASIS_SHIFT;
> +	if (ctl->max_pre_emph)
> +		result |= DP_TRAIN_MAX_PRE_EMPHASIS_REACHED;
> +
> +	return result;
> +}
> +
> +static void dprx_write_training_lane(struct dprx *dprx, u32 offset, u8 val)
> +{
> +	struct dprx_training_control *ctl = &dprx->training_control[offset];
> +
> +	ctl->volt_swing   = (val & DP_TRAIN_VOLTAGE_SWING_MASK) >> DP_TRAIN_VOLTAGE_SWING_SHIFT;
> +	ctl->max_swing    = (val & DP_TRAIN_MAX_SWING_REACHED);
> +	ctl->pre_emph     = (val & DP_TRAIN_PRE_EMPHASIS_MASK) >> DP_TRAIN_PRE_EMPHASIS_SHIFT;
> +	ctl->max_pre_emph = (val & DP_TRAIN_MAX_PRE_EMPHASIS_REACHED);
> +}
> +
> +static u8 dprx_read_mstm_ctrl(struct dprx *dprx)
> +{
> +	return (dprx_read(dprx, DPRX_MST_CONTROL1) >> DPRX_MST_CONTROL1_MST_EN) & 1;
> +}
> +
> +static void dprx_write_mstm_ctrl(struct dprx *dprx, u8 val)
> +{
> +	u8 mst_en = !!(val & DP_MST_EN);
> +	u32 reg;
> +
> +	reg = dprx_read(dprx, DPRX_MST_CONTROL1);
> +	reg &= ~(1 << DPRX_MST_CONTROL1_MST_EN);
> +	reg |= mst_en << DPRX_MST_CONTROL1_MST_EN;
> +	dprx_write(dprx, DPRX_MST_CONTROL1, reg);
> +}
> +
> +static void dprx_handle_payload_allocate(struct dprx *dprx)
> +{
> +	u8 id = dprx->payload_allocate_set;
> +	u8 start = dprx->payload_allocate_start_time_slot;
> +	u8 count = dprx->payload_allocate_time_slot_count;
> +
> +	if (id == 0 && start == 0 && count == 0x3f) {
> +		dprx_clear_vc_payload_table(dprx);
> +	} else {
> +		if (count == 0)
> +			dprx_deallocate_vc_payload(dprx, start, id);
> +		else
> +			dprx_allocate_vc_payload(dprx, start, count, id);
> +		dprx_set_vc_payload_table(dprx);
> +	}
> +	dprx->payload_table_updated = 1;
> +}
> +
> +static u8 dprx_read_payload_allocate_set(struct dprx *dprx)
> +{
> +	return dprx->payload_allocate_set;
> +}
> +
> +static void dprx_write_payload_allocate_set(struct dprx *dprx, u8 val)
> +{
> +	dprx->payload_allocate_set = val & DP_PAYLOAD_ALLOCATE_SET_MASK;
> +}
> +
> +static u8 dprx_read_payload_allocate_start_time_slot(struct dprx *dprx)
> +{
> +	return dprx->payload_allocate_start_time_slot;
> +}
> +
> +static void dprx_write_payload_allocate_start_time_slot(struct dprx *dprx, u8 val)
> +{
> +	dprx->payload_allocate_start_time_slot = val & DP_PAYLOAD_ALLOCATE_START_TIME_SLOT_MASK;
> +}
> +
> +static u8 dprx_read_payload_allocate_time_slot_count(struct dprx *dprx)
> +{
> +	return dprx->payload_allocate_time_slot_count;
> +}
> +
> +static void dprx_write_payload_allocate_time_slot_count(struct dprx *dprx, u8 val)
> +{
> +	dprx->payload_allocate_time_slot_count = val & DP_PAYLOAD_ALLOCATE_TIME_SLOT_COUNT_MASK;
> +	dprx_handle_payload_allocate(dprx);
> +}
> +
> +static u8 dprx_read_sink_count(struct dprx *dprx)
> +{
> +	return dprx->max_stream_count;
> +}
> +
> +static u8 dprx_read_device_service_irq_vector(struct dprx *dprx)
> +{
> +	return dprx->irq_vector;
> +}
> +
> +static void dprx_write_device_service_irq_vector(struct dprx *dprx, u8 val)
> +{
> +	dprx->irq_vector &= ~val;
> +
> +	if (val & DP_DOWN_REP_MSG_RDY) {
> +		if (dprx->mt_pending) {
> +			dprx_write_pending_sideband_msg(dprx);
> +			dprx_signal_irq(dprx, DP_DOWN_REP_MSG_RDY);
> +		} else {
> +			dprx->down_rep_pending = false;
> +		}
> +	}
> +}
> +
> +static u8 dprx_read_lane0_1_status(struct dprx *dprx)
> +{
> +	u32 reg;
> +	u8 res = 0;
> +
> +	reg = dprx_read(dprx, DPRX_RX_STATUS);
> +	if ((reg >> DPRX_RX_STATUS_CR_LOCK(0)) & 1)
> +		res |= DP_LANE_CR_DONE;
> +	if ((reg >> DPRX_RX_STATUS_CR_LOCK(1)) & 1)
> +		res |= DP_LANE_CR_DONE << 4;
> +	if ((reg >> DPRX_RX_STATUS_SYM_LOCK(0)) & 1)
> +		res |= DP_LANE_CHANNEL_EQ_DONE | DP_LANE_SYMBOL_LOCKED;
> +	if ((reg >> DPRX_RX_STATUS_SYM_LOCK(1)) & 1)
> +		res |= (DP_LANE_CHANNEL_EQ_DONE | DP_LANE_SYMBOL_LOCKED) << 4;
> +
> +	return res;
> +}
> +
> +static u8 dprx_read_lane2_3_status(struct dprx *dprx)
> +{
> +	u32 reg;
> +	u8 res = 0;
> +
> +	reg = dprx_read(dprx, DPRX_RX_STATUS);
> +	if ((reg >> DPRX_RX_STATUS_CR_LOCK(2)) & 1)
> +		res |= DP_LANE_CR_DONE;
> +	if ((reg >> DPRX_RX_STATUS_CR_LOCK(3)) & 1)
> +		res |= DP_LANE_CR_DONE << 4;
> +	if ((reg >> DPRX_RX_STATUS_SYM_LOCK(2)) & 1)
> +		res |= DP_LANE_CHANNEL_EQ_DONE | DP_LANE_SYMBOL_LOCKED;
> +	if ((reg >> DPRX_RX_STATUS_SYM_LOCK(3)) & 1)
> +		res |= (DP_LANE_CHANNEL_EQ_DONE | DP_LANE_SYMBOL_LOCKED) << 4;
> +
> +	return res;
> +}
> +
> +static u8 dprx_read_lane_align_status(struct dprx *dprx)
> +{
> +	return (dprx_read(dprx, DPRX_RX_STATUS) >> DPRX_RX_STATUS_INTERLANE_ALIGN) & 1;
> +}
> +
> +static u8 dprx_read_sink_status(struct dprx *dprx)
> +{
> +	return (dprx_read(dprx, DPRX_VBID(0)) >> DPRX_VBID_MSA_LOCK) & 1;
> +}
> +
> +static u8 dprx_read_adjust_request(struct dprx *dprx,
> +				   struct dprx_training_control *ctl0,
> +				   struct dprx_training_control *ctl1)
> +{
> +	u8 next_volt_swing0;
> +	u8 next_pre_emph0;
> +	u8 next_volt_swing1;
> +	u8 next_pre_emph1;
> +
> +	if (dprx_adjust_needed(dprx)) {
> +		dprx_training_control_next(ctl0, &next_volt_swing0, &next_pre_emph0);
> +		dprx_training_control_next(ctl1, &next_volt_swing1, &next_pre_emph1);
> +	} else {
> +		next_volt_swing0 = ctl0->volt_swing;
> +		next_pre_emph0 = ctl0->pre_emph;
> +		next_volt_swing1 = ctl1->volt_swing;
> +		next_pre_emph1 = ctl1->pre_emph;
> +	}
> +
> +	return next_volt_swing0 << DP_ADJUST_VOLTAGE_SWING_LANE0_SHIFT |
> +	       next_pre_emph0   << DP_ADJUST_PRE_EMPHASIS_LANE0_SHIFT  |
> +	       next_volt_swing1 << DP_ADJUST_VOLTAGE_SWING_LANE1_SHIFT |
> +	       next_pre_emph1   << DP_ADJUST_PRE_EMPHASIS_LANE1_SHIFT;
> +}
> +
> +static u8 dprx_read_adjust_request_lane0_1(struct dprx *dprx)
> +{
> +	return dprx_read_adjust_request(dprx,
> +					&dprx->training_control[0],
> +					&dprx->training_control[1]);
> +}
> +
> +static u8 dprx_read_adjust_request_lane2_3(struct dprx *dprx)
> +{
> +	return dprx_read_adjust_request(dprx,
> +					&dprx->training_control[2],
> +					&dprx->training_control[3]);
> +}
> +
> +static u8 dprx_read_payload_table_update_status(struct dprx *dprx)
> +{
> +	u32 reg;
> +	u32 act_handled;
> +	u8 result = 0;
> +
> +	reg = dprx_read(dprx, DPRX_MST_STATUS1);
> +	act_handled = (reg >> DPRX_MST_STATUS1_VCPTAB_ACT_ACK) & 1;
> +
> +	if (dprx->payload_table_updated)
> +		result |= DP_PAYLOAD_TABLE_UPDATED;
> +	if (act_handled)
> +		result |= DP_PAYLOAD_ACT_HANDLED;
> +
> +	return result;
> +}
> +
> +static void dprx_write_payload_table_update_status(struct dprx *dprx, u8 val)
> +{
> +	u32 reg;
> +
> +	if (val & DP_PAYLOAD_TABLE_UPDATED) {
> +		dprx->payload_table_updated = 0;
> +		reg = dprx_read(dprx, DPRX_MST_CONTROL1);
> +		reg &= ~(1 << DPRX_MST_CONTROL1_VCPTAB_UPD_REQ);
> +		dprx_write(dprx, DPRX_MST_CONTROL1, reg);
> +	}
> +}
> +
> +static u8 dprx_read_vc_payload_id_slot(struct dprx *dprx, u32 offset)
> +{
> +	return dprx->payload_table[offset + 1];
> +}
> +
> +static u8 dprx_read_down_req(struct dprx *dprx, u32 offset)
> +{
> +	return dprx->down_req_buf[offset];
> +}
> +
> +static void dprx_write_down_req(struct dprx *dprx, u32 offset, u8 val)
> +{
> +	struct sideband_msg msg;
> +
> +	dprx->down_req_buf[offset] = val;
> +	if (dprx_decode_sideband_msg(&msg, dprx->down_req_buf, offset + 1))
> +		dprx_handle_sideband_msg(dprx, &msg);
> +}
> +
> +static u8 dprx_read_down_rep(struct dprx *dprx, u32 offset)
> +{
> +	return dprx->down_rep_buf[offset];
> +}
> +
> +struct dprx_dpcd_handler {
> +	u32 addr;
> +	u32 range_len;
> +	union {
> +		u8 (*point)(struct dprx *dprx);
> +		u8 (*range)(struct dprx *dprx, u32 offset);
> +	} read;
> +	union {
> +		void (*point)(struct dprx *dprx, u8 val);
> +		void (*range)(struct dprx *dprx, u32 offset, u8 val);
> +	} write;
> +};
> +
> +static void dprx_write_noop(struct dprx *dprx, u8 val)
> +{
> +}
> +
> +static void dprx_write_noop_range(struct dprx *dprx, u32 offset, u8 val)
> +{
> +}
> +
> +static struct dprx_dpcd_handler dprx_dpcd_handlers[] = {
> +	{ 0x00000, 16,	{ .range = dprx_read_caps },
> +			{ .range = dprx_write_noop_range } },
> +	{ 0x00021, 0,	{ .point = dprx_read_mstm_cap },
> +			{ .point = dprx_write_noop } },
> +	{ 0x00030, 16,	{ .range = dprx_read_guid },
> +			{ .range = dprx_write_guid } },
> +	{ 0x00100, 0,	{ .point = dprx_read_link_bw },
> +			{ .point = dprx_write_link_bw } },
> +	{ 0x00101, 0,	{ .point = dprx_read_lane_count },
> +			{ .point = dprx_write_lane_count } },
> +	{ 0x00102, 0,	{ .point = dprx_read_training_pattern },
> +			{ .point = dprx_write_training_pattern } },
> +	{ 0x00103, 4,	{ .range = dprx_read_training_lane },
> +			{ .range = dprx_write_training_lane } },
> +	{ 0x00111, 0,	{ .point = dprx_read_mstm_ctrl },
> +			{ .point = dprx_write_mstm_ctrl } },
> +	{ 0x001c0, 0,	{ .point = dprx_read_payload_allocate_set },
> +			{ .point = dprx_write_payload_allocate_set } },
> +	{ 0x001c1, 0,	{ .point = dprx_read_payload_allocate_start_time_slot },
> +			{ .point = dprx_write_payload_allocate_start_time_slot } },
> +	{ 0x001c2, 0,	{ .point = dprx_read_payload_allocate_time_slot_count },
> +			{ .point = dprx_write_payload_allocate_time_slot_count } },
> +	{ 0x00200, 0,	{ .point = dprx_read_sink_count },
> +			{ .point = dprx_write_noop } },
> +	{ 0x00201, 0,	{ .point = dprx_read_device_service_irq_vector },
> +			{ .point = dprx_write_device_service_irq_vector } },
> +	{ 0x00202, 0,	{ .point = dprx_read_lane0_1_status },
> +			{ .point = dprx_write_noop } },
> +	{ 0x00203, 0,	{ .point = dprx_read_lane2_3_status },
> +			{ .point = dprx_write_noop } },
> +	{ 0x00204, 0,	{ .point = dprx_read_lane_align_status },
> +			{ .point = dprx_write_noop } },
> +	{ 0x00205, 0,	{ .point = dprx_read_sink_status },
> +			{ .point = dprx_write_noop } },
> +	{ 0x00206, 0,	{ .point = dprx_read_adjust_request_lane0_1 },
> +			{ .point = dprx_write_noop } },
> +	{ 0x00207, 0,	{ .point = dprx_read_adjust_request_lane2_3 },
> +			{ .point = dprx_write_noop } },
> +	{ 0x002c0, 0,	{ .point = dprx_read_payload_table_update_status },
> +			{ .point = dprx_write_payload_table_update_status } },
> +	{ 0x002c1, 63,	{ .range = dprx_read_vc_payload_id_slot },
> +			{ .range = dprx_write_noop_range } },
> +	{ 0x01000, 48,	{ .range = dprx_read_down_req },
> +			{ .range = dprx_write_down_req } },
> +	{ 0x01400, 48,	{ .range = dprx_read_down_rep },
> +			{ .range = dprx_write_noop_range } },
> +	/* Event Status Indicator is a copy of 200h - 205h */
> +	{ 0x02002, 0,	{ .point = dprx_read_sink_count },
> +			{ .point = dprx_write_noop } },
> +	{ 0x02003, 0,	{ .point = dprx_read_device_service_irq_vector },
> +			{ .point = dprx_write_device_service_irq_vector } },
> +	{ 0x0200c, 0,	{ .point = dprx_read_lane0_1_status },
> +			{ .point = dprx_write_noop } },
> +	{ 0x0200d, 0,	{ .point = dprx_read_lane2_3_status },
> +			{ .point = dprx_write_noop } },
> +	{ 0x0200e, 0,	{ .point = dprx_read_lane_align_status },
> +			{ .point = dprx_write_noop } },
> +	{ 0x0200f, 0,	{ .point = dprx_read_sink_status },
> +			{ .point = dprx_write_noop } },
> +	/* Extended Receiver Capability is a copy of 0h - 0fh */
> +	{ 0x02200, 16,	{ .range = dprx_read_caps },
> +			{ .range = dprx_write_noop_range } },
> +};
> +
> +static bool dprx_dpcd_handler_match(struct dprx_dpcd_handler *handler, u32 addr)
> +{
> +	if (handler->range_len == 0)
> +		return addr == handler->addr;
> +	else
> +		return addr >= handler->addr && addr < handler->addr + handler->range_len;
> +}
> +
> +static void dprx_dpcd_handler_run(struct dprx_dpcd_handler *handler,
> +				  struct dprx *dprx, u32 addr, u8 *val, bool read)
> +{
> +	if (read) {
> +		if (handler->range_len == 0)
> +			*val = handler->read.point(dprx);
> +		else
> +			*val = handler->read.range(dprx, addr - handler->addr);
> +	} else {
> +		if (handler->range_len == 0)
> +			handler->write.point(dprx, *val);
> +		else
> +			handler->write.range(dprx, addr - handler->addr, *val);
> +	}
> +}
> +
> +static void dprx_dpcd_access(struct dprx *dprx, u32 addr, u8 *val, bool read)
> +{
> +	struct dprx_dpcd_handler *handler;
> +	int i;
> +
> +	for (i = 0; i < ARRAY_SIZE(dprx_dpcd_handlers); i++) {
> +		handler = &dprx_dpcd_handlers[i];
> +		if (dprx_dpcd_handler_match(handler, addr)) {
> +			dprx_dpcd_handler_run(handler, dprx, addr, val, read);
> +			return;
> +		}
> +	}
> +
> +	/* for unsupported registers, writes are ignored and reads return 0. */
> +	if (read)
> +		*val = 0;
> +}
> +
> +static void dprx_handle_native_aux(struct dprx *dprx, struct aux_msg *req, struct aux_msg *rep)
> +{
> +	bool read = req->cmd & 1;
> +	u8 *data;
> +	int i;
> +
> +	rep->cmd = DP_AUX_NATIVE_REPLY_ACK;
> +	if (read) {
> +		rep->len = req->len;
> +		data = rep->data;
> +	} else {
> +		rep->len = 0;
> +		data = req->data;
> +	}
> +
> +	for (i = 0; i < req->len; i++)
> +		dprx_dpcd_access(dprx, req->addr + i, data + i, read);
> +}
> +
> +static void dprx_handle_i2c_read(struct dprx *dprx, struct aux_msg *req, struct aux_msg *rep)
> +{
> +	int res;
> +
> +	res = dprx_i2c_read(&dprx->sinks[0], req->addr, rep->data, req->len);
> +	if (!res) {
> +		rep->cmd = DP_AUX_I2C_REPLY_ACK;
> +		rep->len = req->len;
> +	} else {
> +		rep->cmd = DP_AUX_I2C_REPLY_NACK;
> +		rep->len = 0;
> +	}
> +}
> +
> +static void dprx_handle_i2c_write(struct dprx *dprx, struct aux_msg *req, struct aux_msg *rep)
> +{
> +	int res;
> +
> +	res = dprx_i2c_write(&dprx->sinks[0], req->addr, req->data, req->len);
> +	if (!res)
> +		rep->cmd = DP_AUX_I2C_REPLY_ACK;
> +	else
> +		rep->cmd = DP_AUX_I2C_REPLY_NACK;
> +	rep->len = 0;
> +}
> +
> +static void dprx_decode_aux_request(struct aux_msg *req, struct aux_buf *buf)
> +{
> +	req->cmd = buf->data[0] >> 4;
> +	req->addr = (buf->data[0] & 0xf) << 16 | buf->data[1] << 8 | buf->data[2];
> +	if (buf->len < 4) {
> +		req->len = 0;
> +	} else {
> +		req->len = buf->data[3] + 1;
> +		memcpy(req->data, &buf->data[4], req->len);
> +	}
> +}
> +
> +static void dprx_encode_aux_reply(struct aux_msg *rep, struct aux_buf *buf)
> +{
> +	buf->data[0] = rep->cmd << 4;
> +	memcpy(&buf->data[1], rep->data, rep->len);
> +	buf->len = rep->len + 1;
> +}
> +
> +static void dprx_handle_aux(struct dprx *dprx, struct aux_buf *req_buf, struct aux_buf *rep_buf)
> +{
> +	struct aux_msg req;
> +	struct aux_msg rep;
> +
> +	dprx_decode_aux_request(&req, req_buf);
> +
> +	if (req.cmd & 8) {
> +		dprx_handle_native_aux(dprx, &req, &rep);
> +	} else {
> +		if (req.cmd & 1)
> +			dprx_handle_i2c_read(dprx, &req, &rep);
> +		else
> +			dprx_handle_i2c_write(dprx, &req, &rep);
> +		if (!(req.cmd & DP_AUX_I2C_MOT))
> +			dprx_i2c_stop(&dprx->sinks[0]);
> +	}
> +
> +	dprx_encode_aux_reply(&rep, rep_buf);
> +}
> +
> +static int dprx_read_aux(struct dprx *dprx, struct aux_buf *buf)
> +{
> +	u32 control = dprx_read(dprx, DPRX_AUX_CONTROL);
> +	int i;
> +
> +	/* check MSG_READY */
> +	if (!((dprx_read(dprx, DPRX_AUX_STATUS) >> DPRX_AUX_STATUS_MSG_READY) & 1))
> +		return -1;
> +
> +	/* read LENGTH */
> +	buf->len = (control >> DPRX_AUX_CONTROL_LENGTH_SHIFT) & DPRX_AUX_CONTROL_LENGTH_MASK;
> +	if (buf->len > 20)
> +		buf->len = 20;
> +
> +	/* read request */
> +	for (i = 0; i < buf->len; i++)
> +		buf->data[i] = dprx_read(dprx, DPRX_AUX_COMMAND + i);
> +
> +	return 0;
> +}
> +
> +static void dprx_write_aux(struct dprx *dprx, struct aux_buf *buf)
> +{
> +	u32 reg;
> +	int i;
> +
> +	if (!((dprx_read(dprx, DPRX_AUX_STATUS) >> DPRX_AUX_STATUS_READY_TO_TX) & 1))
> +		return;
> +
> +	if (buf->len > 17)
> +		buf->len = 17;
> +	for (i = 0; i < buf->len; i++)
> +		dprx_write(dprx, DPRX_AUX_COMMAND + i, buf->data[i]);
> +
> +	reg = dprx_read(dprx, DPRX_AUX_CONTROL);
> +	reg &= ~(DPRX_AUX_CONTROL_LENGTH_MASK << DPRX_AUX_CONTROL_LENGTH_SHIFT);
> +	reg |= buf->len << DPRX_AUX_CONTROL_LENGTH_SHIFT;
> +	reg |= 1 << DPRX_AUX_CONTROL_TX_STROBE;
> +	dprx_write(dprx, DPRX_AUX_CONTROL, reg);
> +}
> +
> +static irqreturn_t dprx_isr(int irq, void *data)
> +{
> +	struct dprx *dprx = data;
> +	struct aux_buf request;
> +	struct aux_buf reply;
> +
> +	if (!dprx_read_aux(dprx, &request)) {
> +		spin_lock(&dprx->lock);
> +		dprx_handle_aux(dprx, &request, &reply);
> +		spin_unlock(&dprx->lock);
> +		dprx_write_aux(dprx, &reply);
> +	}
> +
> +	return IRQ_HANDLED;
> +}
> +
> +static void dprx_reset_hw(struct dprx *dprx)
> +{
> +	int i;
> +
> +	/* set link rate to 1.62 Gbps and lane count to 1 */
> +	dprx_write(dprx, DPRX_RX_CONTROL,
> +		   DP_LINK_BW_1_62 << DPRX_RX_CONTROL_LINK_RATE_SHIFT |
> +		   1 << DPRX_RX_CONTROL_RECONFIG_LINKRATE |
> +		   DPRX_RX_CONTROL_CHANNEL_CODING_8B10B << DPRX_RX_CONTROL_CHANNEL_CODING_SHIFT |
> +		   1 << DPRX_RX_CONTROL_LANE_COUNT_SHIFT);
> +	/* clear VC payload ID table */
> +	for (i = 0; i < 8; i++)
> +		dprx_write(dprx, DPRX_MST_VCPTAB(i), 0);
> +	dprx_write(dprx, DPRX_MST_CONTROL1, 1 << DPRX_MST_CONTROL1_VCPTAB_UPD_FORCE);
> +}
> +
> +static void dprx_reset(struct dprx *dprx)
> +{
> +	int i;
> +
> +	memset(dprx->guid, 0, sizeof(dprx->guid));
> +	memset(dprx->training_control, 0, sizeof(dprx->training_control));
> +
> +	dprx->payload_allocate_set = 0;
> +	dprx->payload_allocate_start_time_slot = 0;
> +	dprx->payload_allocate_time_slot_count = 0;
> +	memset(dprx->payload_table, 0, sizeof(dprx->payload_table));
> +	dprx->payload_table_updated = 0;
> +
> +	memset(dprx->payload_id, 0, sizeof(dprx->payload_id));
> +	memset(dprx->payload_pbn, 0, sizeof(dprx->payload_pbn));
> +	dprx->payload_pbn_total = 0;
> +
> +	dprx->irq_vector = 0;
> +
> +	memset(dprx->down_req_buf, 0, sizeof(dprx->down_req_buf));
> +	memset(dprx->down_rep_buf, 0, sizeof(dprx->down_rep_buf));
> +
> +	for (i = 0; i < 2; i++) {
> +		dprx_msg_transaction_clear_rxbuf(&dprx->mt_rxbuf[i]);
> +		dprx_msg_transaction_clear_txbuf(&dprx->mt_txbuf[i]);
> +	}
> +	dprx->mt_seqno = 0;
> +	dprx->mt_pending = false;
> +	dprx->down_rep_pending = false;
> +
> +	dprx_reset_hw(dprx);
> +}
> +
> +#define to_dprx(sd) container_of(sd, struct dprx, subdev)
> +
> +static int dprx_get_edid(struct v4l2_subdev *sd, struct v4l2_edid *edid)
> +{
> +	struct dprx *dprx = to_dprx(sd);
> +	struct dprx_sink *sink;
> +	u32 end_block = edid->start_block + edid->blocks;
> +	unsigned long flags;
> +	int res = 0;
> +
> +	memset(edid->reserved, 0, sizeof(edid->reserved));
> +
> +	if (edid->pad >= dprx->max_stream_count)
> +		return -EINVAL;
> +
> +	spin_lock_irqsave(&dprx->lock, flags);
> +
> +	sink = &dprx->sinks[edid->pad];
> +	if (edid->start_block == 0 && edid->blocks == 0) {
> +		edid->blocks = sink->blocks;
> +		goto out;
> +	}
> +	if (sink->blocks == 0) {
> +		res = -ENODATA;
> +		goto out;
> +	}
> +	if (edid->start_block >= sink->blocks) {
> +		res = -EINVAL;
> +		goto out;
> +	}
> +	if (end_block > sink->blocks) {
> +		end_block = sink->blocks;
> +		edid->blocks = end_block - edid->start_block;
> +	}
> +
> +	memcpy(edid->edid, sink->edid + edid->start_block * 128, edid->blocks * 128);
> +
> +out:
> +	spin_unlock_irqrestore(&dprx->lock, flags);
> +
> +	return res;
> +}
> +
> +static int dprx_set_edid(struct v4l2_subdev *sd, struct v4l2_edid *edid)
> +{
> +	struct dprx *dprx = to_dprx(sd);
> +	struct dprx_sink *sink;
> +	bool prev_hpd;
> +	bool cur_hpd;
> +	unsigned long flags;
> +
> +	memset(edid->reserved, 0, sizeof(edid->reserved));
> +
> +	if (edid->pad >= dprx->max_stream_count)
> +		return -EINVAL;
> +	if (edid->start_block != 0)
> +		return -EINVAL;
> +	if (edid->blocks > DPRX_MAX_EDID_BLOCKS) {
> +		edid->blocks = DPRX_MAX_EDID_BLOCKS;
> +		return -E2BIG;
> +	}
> +
> +	spin_lock_irqsave(&dprx->lock, flags);
> +	sink = &dprx->sinks[edid->pad];
> +	/*
> +	 * This is an MST DisplayPort device, which means that one HPD
> +	 * line controls all the video streams. The way this is handled
> +	 * in s_edid is that the HPD line is controlled by the presence
> +	 * of only the first stream's EDID. This allows, for example, to
> +	 * first set the second streams's EDID and then the first one in
> +	 * order to reduce the amount of AUX communication.
> +	 */
> +	prev_hpd = dprx->sinks[0].blocks > 0;
> +	sink->blocks = edid->blocks;

The HPD needs to be pulled low before you start updating the EDID.

> +	memcpy(sink->edid, edid->edid, edid->blocks * 128);
> +	cur_hpd = dprx->sinks[0].blocks > 0;
> +	if (!prev_hpd && cur_hpd)
> +		dprx_reset(dprx);
> +	spin_unlock_irqrestore(&dprx->lock, flags);
> +
> +	if (!prev_hpd && cur_hpd) {
> +		dprx_set_hpd(dprx, 1);
> +	} else if (prev_hpd && !cur_hpd) {
> +		dprx_set_hpd(dprx, 0);
> +	} else if (prev_hpd && cur_hpd) {
> +		/* HPD replug - pulse for >2ms */
> +		dprx_set_hpd(dprx, 0);
> +		usleep_range(2000, 4000);

The threshold for a short HPD pulse is <= 2ms. An EDID change requires a long
HPD pulse, so I would start with a lower limit in usleep_range of 4000.

Unfortunately I was not able to find a recommended length for a long HPD
pulse other than that 2 ms threshold. HDMI uses 100 ms, but that's probably
overkill for DisplayPort.

> +		dprx_set_hpd(dprx, 1);
> +	}
> +
> +	return 0;
> +}
> +
> +static int dprx_query_dv_timings(struct v4l2_subdev *sd, unsigned int pad,
> +				 struct v4l2_dv_timings *timings)
> +{
> +	struct dprx *dprx = to_dprx(sd);
> +	u32 htotal, vtotal;
> +	u32 hsp, hsw;
> +	u32 hstart, vstart;
> +	u32 vsp, vsw;
> +	u32 hwidth, vheight;
> +
> +	if (pad >= dprx->max_stream_count)
> +		return -EINVAL;
> +
> +	if (!((dprx_read(dprx, DPRX_VBID(pad)) >> DPRX_VBID_MSA_LOCK) & 1))
> +		return -ENOLINK;
> +
> +	htotal  = dprx_read(dprx, DPRX_MSA_HTOTAL(pad));
> +	vtotal  = dprx_read(dprx, DPRX_MSA_VTOTAL(pad));
> +	hsp     = dprx_read(dprx, DPRX_MSA_HSP(pad));
> +	hsw     = dprx_read(dprx, DPRX_MSA_HSW(pad));
> +	hstart  = dprx_read(dprx, DPRX_MSA_HSTART(pad));
> +	vstart  = dprx_read(dprx, DPRX_MSA_VSTART(pad));
> +	vsp     = dprx_read(dprx, DPRX_MSA_VSP(pad));
> +	vsw     = dprx_read(dprx, DPRX_MSA_VSW(pad));
> +	hwidth  = dprx_read(dprx, DPRX_MSA_HWIDTH(pad));
> +	vheight = dprx_read(dprx, DPRX_MSA_VHEIGHT(pad));
> +
> +	memset(timings, 0, sizeof(*timings));
> +	timings->type = V4L2_DV_BT_656_1120;
> +	timings->bt.width = hwidth;
> +	timings->bt.height = vheight;
> +	timings->bt.polarities = (!vsp) | (!hsp) << 1;
> +	timings->bt.hfrontporch = htotal - hstart - hwidth;
> +	timings->bt.hsync = hsw;
> +	timings->bt.hbackporch = hstart - hsw;
> +	timings->bt.vfrontporch = vtotal - vstart - vheight;
> +	timings->bt.vsync = vsw;
> +	timings->bt.vbackporch = vstart - vsw;
> +
> +	return 0;
> +}
> +
> +/* DisplayPort 1.4 capabilities */
> +
> +static const struct v4l2_dv_timings_cap dprx_timings_cap = {
> +	.type = V4L2_DV_BT_656_1120,
> +	.bt = {
> +		.min_width = 0,
> +		.max_width = 7680,
> +		.min_height = 0,
> +		.max_height = 4320,
> +		.min_pixelclock = 0,

Same comment as for the main driver: minimum values of 0 really make no sense.

> +		.max_pixelclock = 1350000000, /* 8.1Gbps * 4lanes / 24bpp */
> +		.standards = V4L2_DV_BT_STD_CEA861 | V4L2_DV_BT_STD_DMT |
> +			V4L2_DV_BT_STD_CVT | V4L2_DV_BT_STD_GTF,
> +		.capabilities = V4L2_DV_BT_CAP_PROGRESSIVE |
> +			V4L2_DV_BT_CAP_REDUCED_BLANKING |
> +			V4L2_DV_BT_CAP_CUSTOM,
> +	},
> +};
> +
> +static int dprx_enum_dv_timings(struct v4l2_subdev *sd, struct v4l2_enum_dv_timings *timings)
> +{
> +	return v4l2_enum_dv_timings_cap(timings, &dprx_timings_cap,
> +					NULL, NULL);
> +}
> +
> +static int dprx_dv_timings_cap(struct v4l2_subdev *sd, struct v4l2_dv_timings_cap *cap)
> +{
> +	*cap = dprx_timings_cap;
> +
> +	return 0;
> +}
> +
> +static const struct v4l2_subdev_pad_ops dprx_pad_ops = {
> +	.get_edid = dprx_get_edid,
> +	.set_edid = dprx_set_edid,
> +	.dv_timings_cap = dprx_dv_timings_cap,
> +	.enum_dv_timings = dprx_enum_dv_timings,
> +	.query_dv_timings = dprx_query_dv_timings,
> +};
> +
> +static const struct v4l2_subdev_ops dprx_subdev_ops = {
> +	.pad = &dprx_pad_ops,
> +};
> +
> +static const struct media_entity_operations dprx_entity_ops = {
> +	.link_validate = v4l2_subdev_link_validate,
> +	.get_fwnode_pad = v4l2_subdev_get_fwnode_pad_1_to_1,
> +};
> +
> +static int dprx_init_pads(struct dprx *dprx)
> +{
> +	int i;
> +
> +	for (i = 0; i < dprx->max_stream_count; i++)
> +		dprx->pads[i].flags = MEDIA_PAD_FL_SOURCE;
> +
> +	return media_entity_pads_init(&dprx->subdev.entity, dprx->max_stream_count, dprx->pads);
> +}
> +
> +static int dprx_probe(struct platform_device *pdev)
> +{
> +	struct dprx *dprx;
> +	int irq;
> +	int res;
> +
> +	dprx = devm_kzalloc(&pdev->dev, sizeof(*dprx), GFP_KERNEL);
> +	if (!dprx)
> +		return -ENOMEM;
> +	dprx->dev = &pdev->dev;
> +	platform_set_drvdata(pdev, dprx);
> +
> +	dprx->iobase = devm_platform_ioremap_resource(pdev, 0);
> +	if (IS_ERR(dprx->iobase))
> +		return PTR_ERR(dprx->iobase);
> +
> +	irq = platform_get_irq(pdev, 0);
> +	if (irq < 0)
> +		return irq;
> +
> +	res = devm_request_irq(dprx->dev, irq, dprx_isr, 0, "intel-dprx", dprx);
> +	if (res)
> +		return res;
> +
> +	res = device_property_read_u32(&pdev->dev, "intel,max-link-rate", &dprx->max_link_rate);
> +	if (res)
> +		return res;
> +
> +	res = device_property_read_u32(&pdev->dev, "intel,max-lane-count", &dprx->max_lane_count);
> +	if (res)
> +		return res;
> +
> +	dprx->multi_stream_support = device_property_read_bool(&pdev->dev,
> +							       "intel,multi-stream-support");
> +
> +	if (dprx->multi_stream_support) {
> +		res = device_property_read_u32(&pdev->dev, "intel,max-stream-count",
> +					       &dprx->max_stream_count);
> +		if (res)
> +			return res;
> +	} else {
> +		dprx->max_stream_count = 1;
> +	}
> +
> +	dprx_init_caps(dprx);
> +
> +	dprx->subdev.owner = THIS_MODULE;
> +	dprx->subdev.dev = &pdev->dev;
> +	v4l2_subdev_init(&dprx->subdev, &dprx_subdev_ops);
> +	v4l2_set_subdevdata(&dprx->subdev, &pdev->dev);
> +	snprintf(dprx->subdev.name, sizeof(dprx->subdev.name), "%s %s",
> +		 KBUILD_MODNAME, dev_name(&pdev->dev));
> +	dprx->subdev.flags = V4L2_SUBDEV_FL_HAS_DEVNODE;
> +
> +	dprx->subdev.entity.function = MEDIA_ENT_F_PROC_VIDEO_PIXEL_FORMATTER;

I would expect this to be a MEDIA_ENT_F_DV_DECODER.

> +	dprx->subdev.entity.ops = &dprx_entity_ops;
> +
> +	res = dprx_init_pads(dprx);
> +	if (res)
> +		return res;
> +
> +	res = v4l2_async_register_subdev(&dprx->subdev);
> +	if (res)
> +		return res;
> +
> +	dprx_set_hpd(dprx, 0);
> +	dprx_reset_hw(dprx);
> +
> +	dprx_set_irq(dprx, 1);
> +
> +	return 0;
> +}
> +
> +static void dprx_remove(struct platform_device *pdev)
> +{
> +	struct dprx *dprx = platform_get_drvdata(pdev);
> +
> +	/* disable interrupts */
> +	dprx_set_irq(dprx, 0);
> +
> +	v4l2_async_unregister_subdev(&dprx->subdev);
> +}
> +
> +static const struct of_device_id dprx_match_table[] = {
> +	{ .compatible = "intel,dprx-20.0.1" },
> +	{ },
> +};
> +
> +static struct platform_driver dprx_platform_driver = {
> +	.probe = dprx_probe,
> +	.remove_new = dprx_remove,
> +	.driver = {
> +		.name = "intel-dprx",
> +		.of_match_table = dprx_match_table,
> +	},
> +};
> +
> +module_platform_driver(dprx_platform_driver);
> +
> +MODULE_AUTHOR("Paweł Anikiel <panikiel@google.com>");
> +MODULE_DESCRIPTION("Intel DisplayPort RX IP core driver");
> +MODULE_LICENSE("GPL");

Regards,

	Hans