1/*
   2 * Copyright © 2014 Red Hat
   3 *
   4 * Permission to use, copy, modify, distribute, and sell this software and its
   5 * documentation for any purpose is hereby granted without fee, provided that
   6 * the above copyright notice appear in all copies and that both that copyright
   7 * notice and this permission notice appear in supporting documentation, and
   8 * that the name of the copyright holders not be used in advertising or
   9 * publicity pertaining to distribution of the software without specific,
  10 * written prior permission.  The copyright holders make no representations
  11 * about the suitability of this software for any purpose.  It is provided "as
  12 * is" without express or implied warranty.
  13 *
  14 * THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
  15 * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
  16 * EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY SPECIAL, INDIRECT OR
  17 * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
  18 * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
  19 * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE
  20 * OF THIS SOFTWARE.
  21 */
  22
  23#include <linux/bitfield.h>
  24#include <linux/delay.h>
  25#include <linux/errno.h>
  26#include <linux/i2c.h>
  27#include <linux/init.h>
  28#include <linux/kernel.h>
  29#include <linux/random.h>
  30#include <linux/sched.h>
  31#include <linux/seq_file.h>
  32#include <linux/iopoll.h>
  33
  34#if IS_ENABLED(CONFIG_DRM_DEBUG_DP_MST_TOPOLOGY_REFS)
  35#include <linux/stacktrace.h>
  36#include <linux/sort.h>
  37#include <linux/timekeeping.h>
  38#include <linux/math64.h>
  39#endif
  40
  41#include <drm/display/drm_dp_mst_helper.h>
  42#include <drm/drm_atomic.h>
  43#include <drm/drm_atomic_helper.h>
  44#include <drm/drm_drv.h>
  45#include <drm/drm_edid.h>
  46#include <drm/drm_print.h>
  47#include <drm/drm_probe_helper.h>
  48
  49#include "drm_dp_helper_internal.h"
  50#include "drm_dp_mst_topology_internal.h"
  51
  52/**
  53 * DOC: dp mst helper
  54 *
  55 * These functions contain parts of the DisplayPort 1.2a MultiStream Transport
  56 * protocol. The helpers contain a topology manager and bandwidth manager.
  57 * The helpers encapsulate the sending and received of sideband msgs.
  58 */
  59struct drm_dp_pending_up_req {
  60	struct drm_dp_sideband_msg_hdr hdr;
  61	struct drm_dp_sideband_msg_req_body msg;
  62	struct list_head next;
  63};
  64
  65static bool dump_dp_payload_table(struct drm_dp_mst_topology_mgr *mgr,
  66				  char *buf);
  67
  68static void drm_dp_mst_topology_put_port(struct drm_dp_mst_port *port);
  69
  70static int drm_dp_dpcd_write_payload(struct drm_dp_mst_topology_mgr *mgr,
  71				     int id, u8 start_slot, u8 num_slots);
  72
  73static int drm_dp_send_dpcd_read(struct drm_dp_mst_topology_mgr *mgr,
  74				 struct drm_dp_mst_port *port,
  75				 int offset, int size, u8 *bytes);
  76static int drm_dp_send_dpcd_write(struct drm_dp_mst_topology_mgr *mgr,
  77				  struct drm_dp_mst_port *port,
  78				  int offset, int size, u8 *bytes);
  79
  80static int drm_dp_send_link_address(struct drm_dp_mst_topology_mgr *mgr,
  81				    struct drm_dp_mst_branch *mstb);
  82
  83static void
  84drm_dp_send_clear_payload_id_table(struct drm_dp_mst_topology_mgr *mgr,
  85				   struct drm_dp_mst_branch *mstb);
  86
  87static int drm_dp_send_enum_path_resources(struct drm_dp_mst_topology_mgr *mgr,
  88					   struct drm_dp_mst_branch *mstb,
  89					   struct drm_dp_mst_port *port);
  90static bool drm_dp_validate_guid(struct drm_dp_mst_topology_mgr *mgr,
  91				 u8 *guid);
  92
  93static int drm_dp_mst_register_i2c_bus(struct drm_dp_mst_port *port);
  94static void drm_dp_mst_unregister_i2c_bus(struct drm_dp_mst_port *port);
  95static void drm_dp_mst_kick_tx(struct drm_dp_mst_topology_mgr *mgr);
  96
  97static bool drm_dp_mst_port_downstream_of_branch(struct drm_dp_mst_port *port,
  98						 struct drm_dp_mst_branch *branch);
  99
 100#define DBG_PREFIX "[dp_mst]"
 101
 102#define DP_STR(x) [DP_ ## x] = #x
 103
 104static const char *drm_dp_mst_req_type_str(u8 req_type)
 105{
 106	static const char * const req_type_str[] = {
 107		DP_STR(GET_MSG_TRANSACTION_VERSION),
 108		DP_STR(LINK_ADDRESS),
 109		DP_STR(CONNECTION_STATUS_NOTIFY),
 110		DP_STR(ENUM_PATH_RESOURCES),
 111		DP_STR(ALLOCATE_PAYLOAD),
 112		DP_STR(QUERY_PAYLOAD),
 113		DP_STR(RESOURCE_STATUS_NOTIFY),
 114		DP_STR(CLEAR_PAYLOAD_ID_TABLE),
 115		DP_STR(REMOTE_DPCD_READ),
 116		DP_STR(REMOTE_DPCD_WRITE),
 117		DP_STR(REMOTE_I2C_READ),
 118		DP_STR(REMOTE_I2C_WRITE),
 119		DP_STR(POWER_UP_PHY),
 120		DP_STR(POWER_DOWN_PHY),
 121		DP_STR(SINK_EVENT_NOTIFY),
 122		DP_STR(QUERY_STREAM_ENC_STATUS),
 123	};
 124
 125	if (req_type >= ARRAY_SIZE(req_type_str) ||
 126	    !req_type_str[req_type])
 127		return "unknown";
 128
 129	return req_type_str[req_type];
 130}
 131
 132#undef DP_STR
 133#define DP_STR(x) [DP_NAK_ ## x] = #x
 134
 135static const char *drm_dp_mst_nak_reason_str(u8 nak_reason)
 136{
 137	static const char * const nak_reason_str[] = {
 138		DP_STR(WRITE_FAILURE),
 139		DP_STR(INVALID_READ),
 140		DP_STR(CRC_FAILURE),
 141		DP_STR(BAD_PARAM),
 142		DP_STR(DEFER),
 143		DP_STR(LINK_FAILURE),
 144		DP_STR(NO_RESOURCES),
 145		DP_STR(DPCD_FAIL),
 146		DP_STR(I2C_NAK),
 147		DP_STR(ALLOCATE_FAIL),
 148	};
 149
 150	if (nak_reason >= ARRAY_SIZE(nak_reason_str) ||
 151	    !nak_reason_str[nak_reason])
 152		return "unknown";
 153
 154	return nak_reason_str[nak_reason];
 155}
 156
 157#undef DP_STR
 158#define DP_STR(x) [DRM_DP_SIDEBAND_TX_ ## x] = #x
 159
 160static const char *drm_dp_mst_sideband_tx_state_str(int state)
 161{
 162	static const char * const sideband_reason_str[] = {
 163		DP_STR(QUEUED),
 164		DP_STR(START_SEND),
 165		DP_STR(SENT),
 166		DP_STR(RX),
 167		DP_STR(TIMEOUT),
 168	};
 169
 170	if (state >= ARRAY_SIZE(sideband_reason_str) ||
 171	    !sideband_reason_str[state])
 172		return "unknown";
 173
 174	return sideband_reason_str[state];
 175}
 176
 177static int
 178drm_dp_mst_rad_to_str(const u8 rad[8], u8 lct, char *out, size_t len)
 179{
 180	int i;
 181	u8 unpacked_rad[16];
 182
 183	for (i = 0; i < lct; i++) {
 184		if (i % 2)
 185			unpacked_rad[i] = rad[i / 2] >> 4;
 186		else
 187			unpacked_rad[i] = rad[i / 2] & BIT_MASK(4);
 188	}
 189
 190	/* TODO: Eventually add something to printk so we can format the rad
 191	 * like this: 1.2.3
 192	 */
 193	return snprintf(out, len, "%*phC", lct, unpacked_rad);
 194}
 195
 196/* sideband msg handling */
 197static u8 drm_dp_msg_header_crc4(const uint8_t *data, size_t num_nibbles)
 198{
 199	u8 bitmask = 0x80;
 200	u8 bitshift = 7;
 201	u8 array_index = 0;
 202	int number_of_bits = num_nibbles * 4;
 203	u8 remainder = 0;
 204
 205	while (number_of_bits != 0) {
 206		number_of_bits--;
 207		remainder <<= 1;
 208		remainder |= (data[array_index] & bitmask) >> bitshift;
 209		bitmask >>= 1;
 210		bitshift--;
 211		if (bitmask == 0) {
 212			bitmask = 0x80;
 213			bitshift = 7;
 214			array_index++;
 215		}
 216		if ((remainder & 0x10) == 0x10)
 217			remainder ^= 0x13;
 218	}
 219
 220	number_of_bits = 4;
 221	while (number_of_bits != 0) {
 222		number_of_bits--;
 223		remainder <<= 1;
 224		if ((remainder & 0x10) != 0)
 225			remainder ^= 0x13;
 226	}
 227
 228	return remainder;
 229}
 230
 231static u8 drm_dp_msg_data_crc4(const uint8_t *data, u8 number_of_bytes)
 232{
 233	u8 bitmask = 0x80;
 234	u8 bitshift = 7;
 235	u8 array_index = 0;
 236	int number_of_bits = number_of_bytes * 8;
 237	u16 remainder = 0;
 238
 239	while (number_of_bits != 0) {
 240		number_of_bits--;
 241		remainder <<= 1;
 242		remainder |= (data[array_index] & bitmask) >> bitshift;
 243		bitmask >>= 1;
 244		bitshift--;
 245		if (bitmask == 0) {
 246			bitmask = 0x80;
 247			bitshift = 7;
 248			array_index++;
 249		}
 250		if ((remainder & 0x100) == 0x100)
 251			remainder ^= 0xd5;
 252	}
 253
 254	number_of_bits = 8;
 255	while (number_of_bits != 0) {
 256		number_of_bits--;
 257		remainder <<= 1;
 258		if ((remainder & 0x100) != 0)
 259			remainder ^= 0xd5;
 260	}
 261
 262	return remainder & 0xff;
 263}
 264static inline u8 drm_dp_calc_sb_hdr_size(struct drm_dp_sideband_msg_hdr *hdr)
 265{
 266	u8 size = 3;
 267
 268	size += (hdr->lct / 2);
 269	return size;
 270}
 271
 272static void drm_dp_encode_sideband_msg_hdr(struct drm_dp_sideband_msg_hdr *hdr,
 273					   u8 *buf, int *len)
 274{
 275	int idx = 0;
 276	int i;
 277	u8 crc4;
 278
 279	buf[idx++] = ((hdr->lct & 0xf) << 4) | (hdr->lcr & 0xf);
 280	for (i = 0; i < (hdr->lct / 2); i++)
 281		buf[idx++] = hdr->rad[i];
 282	buf[idx++] = (hdr->broadcast << 7) | (hdr->path_msg << 6) |
 283		(hdr->msg_len & 0x3f);
 284	buf[idx++] = (hdr->somt << 7) | (hdr->eomt << 6) | (hdr->seqno << 4);
 285
 286	crc4 = drm_dp_msg_header_crc4(buf, (idx * 2) - 1);
 287	buf[idx - 1] |= (crc4 & 0xf);
 288
 289	*len = idx;
 290}
 291
 292static bool drm_dp_decode_sideband_msg_hdr(const struct drm_dp_mst_topology_mgr *mgr,
 293					   struct drm_dp_sideband_msg_hdr *hdr,
 294					   u8 *buf, int buflen, u8 *hdrlen)
 295{
 296	u8 crc4;
 297	u8 len;
 298	int i;
 299	u8 idx;
 300
 301	if (buf[0] == 0)
 302		return false;
 303	len = 3;
 304	len += ((buf[0] & 0xf0) >> 4) / 2;
 305	if (len > buflen)
 306		return false;
 307	crc4 = drm_dp_msg_header_crc4(buf, (len * 2) - 1);
 308
 309	if ((crc4 & 0xf) != (buf[len - 1] & 0xf)) {
 310		drm_dbg_kms(mgr->dev, "crc4 mismatch 0x%x 0x%x\n", crc4, buf[len - 1]);
 311		return false;
 312	}
 313
 314	hdr->lct = (buf[0] & 0xf0) >> 4;
 315	hdr->lcr = (buf[0] & 0xf);
 316	idx = 1;
 317	for (i = 0; i < (hdr->lct / 2); i++)
 318		hdr->rad[i] = buf[idx++];
 319	hdr->broadcast = (buf[idx] >> 7) & 0x1;
 320	hdr->path_msg = (buf[idx] >> 6) & 0x1;
 321	hdr->msg_len = buf[idx] & 0x3f;
 322	idx++;
 323	hdr->somt = (buf[idx] >> 7) & 0x1;
 324	hdr->eomt = (buf[idx] >> 6) & 0x1;
 325	hdr->seqno = (buf[idx] >> 4) & 0x1;
 326	idx++;
 327	*hdrlen = idx;
 328	return true;
 329}
 330
 331void
 332drm_dp_encode_sideband_req(const struct drm_dp_sideband_msg_req_body *req,
 333			   struct drm_dp_sideband_msg_tx *raw)
 334{
 335	int idx = 0;
 336	int i;
 337	u8 *buf = raw->msg;
 338
 339	buf[idx++] = req->req_type & 0x7f;
 340
 341	switch (req->req_type) {
 342	case DP_ENUM_PATH_RESOURCES:
 343	case DP_POWER_DOWN_PHY:
 344	case DP_POWER_UP_PHY:
 345		buf[idx] = (req->u.port_num.port_number & 0xf) << 4;
 346		idx++;
 347		break;
 348	case DP_ALLOCATE_PAYLOAD:
 349		buf[idx] = (req->u.allocate_payload.port_number & 0xf) << 4 |
 350			(req->u.allocate_payload.number_sdp_streams & 0xf);
 351		idx++;
 352		buf[idx] = (req->u.allocate_payload.vcpi & 0x7f);
 353		idx++;
 354		buf[idx] = (req->u.allocate_payload.pbn >> 8);
 355		idx++;
 356		buf[idx] = (req->u.allocate_payload.pbn & 0xff);
 357		idx++;
 358		for (i = 0; i < req->u.allocate_payload.number_sdp_streams / 2; i++) {
 359			buf[idx] = ((req->u.allocate_payload.sdp_stream_sink[i * 2] & 0xf) << 4) |
 360				(req->u.allocate_payload.sdp_stream_sink[i * 2 + 1] & 0xf);
 361			idx++;
 362		}
 363		if (req->u.allocate_payload.number_sdp_streams & 1) {
 364			i = req->u.allocate_payload.number_sdp_streams - 1;
 365			buf[idx] = (req->u.allocate_payload.sdp_stream_sink[i] & 0xf) << 4;
 366			idx++;
 367		}
 368		break;
 369	case DP_QUERY_PAYLOAD:
 370		buf[idx] = (req->u.query_payload.port_number & 0xf) << 4;
 371		idx++;
 372		buf[idx] = (req->u.query_payload.vcpi & 0x7f);
 373		idx++;
 374		break;
 375	case DP_REMOTE_DPCD_READ:
 376		buf[idx] = (req->u.dpcd_read.port_number & 0xf) << 4;
 377		buf[idx] |= ((req->u.dpcd_read.dpcd_address & 0xf0000) >> 16) & 0xf;
 378		idx++;
 379		buf[idx] = (req->u.dpcd_read.dpcd_address & 0xff00) >> 8;
 380		idx++;
 381		buf[idx] = (req->u.dpcd_read.dpcd_address & 0xff);
 382		idx++;
 383		buf[idx] = (req->u.dpcd_read.num_bytes);
 384		idx++;
 385		break;
 386
 387	case DP_REMOTE_DPCD_WRITE:
 388		buf[idx] = (req->u.dpcd_write.port_number & 0xf) << 4;
 389		buf[idx] |= ((req->u.dpcd_write.dpcd_address & 0xf0000) >> 16) & 0xf;
 390		idx++;
 391		buf[idx] = (req->u.dpcd_write.dpcd_address & 0xff00) >> 8;
 392		idx++;
 393		buf[idx] = (req->u.dpcd_write.dpcd_address & 0xff);
 394		idx++;
 395		buf[idx] = (req->u.dpcd_write.num_bytes);
 396		idx++;
 397		memcpy(&buf[idx], req->u.dpcd_write.bytes, req->u.dpcd_write.num_bytes);
 398		idx += req->u.dpcd_write.num_bytes;
 399		break;
 400	case DP_REMOTE_I2C_READ:
 401		buf[idx] = (req->u.i2c_read.port_number & 0xf) << 4;
 402		buf[idx] |= (req->u.i2c_read.num_transactions & 0x3);
 403		idx++;
 404		for (i = 0; i < (req->u.i2c_read.num_transactions & 0x3); i++) {
 405			buf[idx] = req->u.i2c_read.transactions[i].i2c_dev_id & 0x7f;
 406			idx++;
 407			buf[idx] = req->u.i2c_read.transactions[i].num_bytes;
 408			idx++;
 409			memcpy(&buf[idx], req->u.i2c_read.transactions[i].bytes, req->u.i2c_read.transactions[i].num_bytes);
 410			idx += req->u.i2c_read.transactions[i].num_bytes;
 411
 412			buf[idx] = (req->u.i2c_read.transactions[i].no_stop_bit & 0x1) << 4;
 413			buf[idx] |= (req->u.i2c_read.transactions[i].i2c_transaction_delay & 0xf);
 414			idx++;
 415		}
 416		buf[idx] = (req->u.i2c_read.read_i2c_device_id) & 0x7f;
 417		idx++;
 418		buf[idx] = (req->u.i2c_read.num_bytes_read);
 419		idx++;
 420		break;
 421
 422	case DP_REMOTE_I2C_WRITE:
 423		buf[idx] = (req->u.i2c_write.port_number & 0xf) << 4;
 424		idx++;
 425		buf[idx] = (req->u.i2c_write.write_i2c_device_id) & 0x7f;
 426		idx++;
 427		buf[idx] = (req->u.i2c_write.num_bytes);
 428		idx++;
 429		memcpy(&buf[idx], req->u.i2c_write.bytes, req->u.i2c_write.num_bytes);
 430		idx += req->u.i2c_write.num_bytes;
 431		break;
 432	case DP_QUERY_STREAM_ENC_STATUS: {
 433		const struct drm_dp_query_stream_enc_status *msg;
 434
 435		msg = &req->u.enc_status;
 436		buf[idx] = msg->stream_id;
 437		idx++;
 438		memcpy(&buf[idx], msg->client_id, sizeof(msg->client_id));
 439		idx += sizeof(msg->client_id);
 440		buf[idx] = 0;
 441		buf[idx] |= FIELD_PREP(GENMASK(1, 0), msg->stream_event);
 442		buf[idx] |= msg->valid_stream_event ? BIT(2) : 0;
 443		buf[idx] |= FIELD_PREP(GENMASK(4, 3), msg->stream_behavior);
 444		buf[idx] |= msg->valid_stream_behavior ? BIT(5) : 0;
 445		idx++;
 446		}
 447		break;
 448	}
 449	raw->cur_len = idx;
 450}
 451EXPORT_SYMBOL_FOR_TESTS_ONLY(drm_dp_encode_sideband_req);
 452
 453/* Decode a sideband request we've encoded, mainly used for debugging */
 454int
 455drm_dp_decode_sideband_req(const struct drm_dp_sideband_msg_tx *raw,
 456			   struct drm_dp_sideband_msg_req_body *req)
 457{
 458	const u8 *buf = raw->msg;
 459	int i, idx = 0;
 460
 461	req->req_type = buf[idx++] & 0x7f;
 462	switch (req->req_type) {
 463	case DP_ENUM_PATH_RESOURCES:
 464	case DP_POWER_DOWN_PHY:
 465	case DP_POWER_UP_PHY:
 466		req->u.port_num.port_number = (buf[idx] >> 4) & 0xf;
 467		break;
 468	case DP_ALLOCATE_PAYLOAD:
 469		{
 470			struct drm_dp_allocate_payload *a =
 471				&req->u.allocate_payload;
 472
 473			a->number_sdp_streams = buf[idx] & 0xf;
 474			a->port_number = (buf[idx] >> 4) & 0xf;
 475
 476			WARN_ON(buf[++idx] & 0x80);
 477			a->vcpi = buf[idx] & 0x7f;
 478
 479			a->pbn = buf[++idx] << 8;
 480			a->pbn |= buf[++idx];
 481
 482			idx++;
 483			for (i = 0; i < a->number_sdp_streams; i++) {
 484				a->sdp_stream_sink[i] =
 485					(buf[idx + (i / 2)] >> ((i % 2) ? 0 : 4)) & 0xf;
 486			}
 487		}
 488		break;
 489	case DP_QUERY_PAYLOAD:
 490		req->u.query_payload.port_number = (buf[idx] >> 4) & 0xf;
 491		WARN_ON(buf[++idx] & 0x80);
 492		req->u.query_payload.vcpi = buf[idx] & 0x7f;
 493		break;
 494	case DP_REMOTE_DPCD_READ:
 495		{
 496			struct drm_dp_remote_dpcd_read *r = &req->u.dpcd_read;
 497
 498			r->port_number = (buf[idx] >> 4) & 0xf;
 499
 500			r->dpcd_address = (buf[idx] << 16) & 0xf0000;
 501			r->dpcd_address |= (buf[++idx] << 8) & 0xff00;
 502			r->dpcd_address |= buf[++idx] & 0xff;
 503
 504			r->num_bytes = buf[++idx];
 505		}
 506		break;
 507	case DP_REMOTE_DPCD_WRITE:
 508		{
 509			struct drm_dp_remote_dpcd_write *w =
 510				&req->u.dpcd_write;
 511
 512			w->port_number = (buf[idx] >> 4) & 0xf;
 513
 514			w->dpcd_address = (buf[idx] << 16) & 0xf0000;
 515			w->dpcd_address |= (buf[++idx] << 8) & 0xff00;
 516			w->dpcd_address |= buf[++idx] & 0xff;
 517
 518			w->num_bytes = buf[++idx];
 519
 520			w->bytes = kmemdup(&buf[++idx], w->num_bytes,
 521					   GFP_KERNEL);
 522			if (!w->bytes)
 523				return -ENOMEM;
 524		}
 525		break;
 526	case DP_REMOTE_I2C_READ:
 527		{
 528			struct drm_dp_remote_i2c_read *r = &req->u.i2c_read;
 529			struct drm_dp_remote_i2c_read_tx *tx;
 530			bool failed = false;
 531
 532			r->num_transactions = buf[idx] & 0x3;
 533			r->port_number = (buf[idx] >> 4) & 0xf;
 534			for (i = 0; i < r->num_transactions; i++) {
 535				tx = &r->transactions[i];
 536
 537				tx->i2c_dev_id = buf[++idx] & 0x7f;
 538				tx->num_bytes = buf[++idx];
 539				tx->bytes = kmemdup(&buf[++idx],
 540						    tx->num_bytes,
 541						    GFP_KERNEL);
 542				if (!tx->bytes) {
 543					failed = true;
 544					break;
 545				}
 546				idx += tx->num_bytes;
 547				tx->no_stop_bit = (buf[idx] >> 5) & 0x1;
 548				tx->i2c_transaction_delay = buf[idx] & 0xf;
 549			}
 550
 551			if (failed) {
 552				for (i = 0; i < r->num_transactions; i++) {
 553					tx = &r->transactions[i];
 554					kfree(tx->bytes);
 555				}
 556				return -ENOMEM;
 557			}
 558
 559			r->read_i2c_device_id = buf[++idx] & 0x7f;
 560			r->num_bytes_read = buf[++idx];
 561		}
 562		break;
 563	case DP_REMOTE_I2C_WRITE:
 564		{
 565			struct drm_dp_remote_i2c_write *w = &req->u.i2c_write;
 566
 567			w->port_number = (buf[idx] >> 4) & 0xf;
 568			w->write_i2c_device_id = buf[++idx] & 0x7f;
 569			w->num_bytes = buf[++idx];
 570			w->bytes = kmemdup(&buf[++idx], w->num_bytes,
 571					   GFP_KERNEL);
 572			if (!w->bytes)
 573				return -ENOMEM;
 574		}
 575		break;
 576	case DP_QUERY_STREAM_ENC_STATUS:
 577		req->u.enc_status.stream_id = buf[idx++];
 578		for (i = 0; i < sizeof(req->u.enc_status.client_id); i++)
 579			req->u.enc_status.client_id[i] = buf[idx++];
 580
 581		req->u.enc_status.stream_event = FIELD_GET(GENMASK(1, 0),
 582							   buf[idx]);
 583		req->u.enc_status.valid_stream_event = FIELD_GET(BIT(2),
 584								 buf[idx]);
 585		req->u.enc_status.stream_behavior = FIELD_GET(GENMASK(4, 3),
 586							      buf[idx]);
 587		req->u.enc_status.valid_stream_behavior = FIELD_GET(BIT(5),
 588								    buf[idx]);
 589		break;
 590	}
 591
 592	return 0;
 593}
 594EXPORT_SYMBOL_FOR_TESTS_ONLY(drm_dp_decode_sideband_req);
 595
 596void
 597drm_dp_dump_sideband_msg_req_body(const struct drm_dp_sideband_msg_req_body *req,
 598				  int indent, struct drm_printer *printer)
 599{
 600	int i;
 601
 602#define P(f, ...) drm_printf_indent(printer, indent, f, ##__VA_ARGS__)
 603	if (req->req_type == DP_LINK_ADDRESS) {
 604		/* No contents to print */
 605		P("type=%s\n", drm_dp_mst_req_type_str(req->req_type));
 606		return;
 607	}
 608
 609	P("type=%s contents:\n", drm_dp_mst_req_type_str(req->req_type));
 610	indent++;
 611
 612	switch (req->req_type) {
 613	case DP_ENUM_PATH_RESOURCES:
 614	case DP_POWER_DOWN_PHY:
 615	case DP_POWER_UP_PHY:
 616		P("port=%d\n", req->u.port_num.port_number);
 617		break;
 618	case DP_ALLOCATE_PAYLOAD:
 619		P("port=%d vcpi=%d pbn=%d sdp_streams=%d %*ph\n",
 620		  req->u.allocate_payload.port_number,
 621		  req->u.allocate_payload.vcpi, req->u.allocate_payload.pbn,
 622		  req->u.allocate_payload.number_sdp_streams,
 623		  req->u.allocate_payload.number_sdp_streams,
 624		  req->u.allocate_payload.sdp_stream_sink);
 625		break;
 626	case DP_QUERY_PAYLOAD:
 627		P("port=%d vcpi=%d\n",
 628		  req->u.query_payload.port_number,
 629		  req->u.query_payload.vcpi);
 630		break;
 631	case DP_REMOTE_DPCD_READ:
 632		P("port=%d dpcd_addr=%05x len=%d\n",
 633		  req->u.dpcd_read.port_number, req->u.dpcd_read.dpcd_address,
 634		  req->u.dpcd_read.num_bytes);
 635		break;
 636	case DP_REMOTE_DPCD_WRITE:
 637		P("port=%d addr=%05x len=%d: %*ph\n",
 638		  req->u.dpcd_write.port_number,
 639		  req->u.dpcd_write.dpcd_address,
 640		  req->u.dpcd_write.num_bytes, req->u.dpcd_write.num_bytes,
 641		  req->u.dpcd_write.bytes);
 642		break;
 643	case DP_REMOTE_I2C_READ:
 644		P("port=%d num_tx=%d id=%d size=%d:\n",
 645		  req->u.i2c_read.port_number,
 646		  req->u.i2c_read.num_transactions,
 647		  req->u.i2c_read.read_i2c_device_id,
 648		  req->u.i2c_read.num_bytes_read);
 649
 650		indent++;
 651		for (i = 0; i < req->u.i2c_read.num_transactions; i++) {
 652			const struct drm_dp_remote_i2c_read_tx *rtx =
 653				&req->u.i2c_read.transactions[i];
 654
 655			P("%d: id=%03d size=%03d no_stop_bit=%d tx_delay=%03d: %*ph\n",
 656			  i, rtx->i2c_dev_id, rtx->num_bytes,
 657			  rtx->no_stop_bit, rtx->i2c_transaction_delay,
 658			  rtx->num_bytes, rtx->bytes);
 659		}
 660		break;
 661	case DP_REMOTE_I2C_WRITE:
 662		P("port=%d id=%d size=%d: %*ph\n",
 663		  req->u.i2c_write.port_number,
 664		  req->u.i2c_write.write_i2c_device_id,
 665		  req->u.i2c_write.num_bytes, req->u.i2c_write.num_bytes,
 666		  req->u.i2c_write.bytes);
 667		break;
 668	case DP_QUERY_STREAM_ENC_STATUS:
 669		P("stream_id=%u client_id=%*ph stream_event=%x "
 670		  "valid_event=%d stream_behavior=%x valid_behavior=%d",
 671		  req->u.enc_status.stream_id,
 672		  (int)ARRAY_SIZE(req->u.enc_status.client_id),
 673		  req->u.enc_status.client_id, req->u.enc_status.stream_event,
 674		  req->u.enc_status.valid_stream_event,
 675		  req->u.enc_status.stream_behavior,
 676		  req->u.enc_status.valid_stream_behavior);
 677		break;
 678	default:
 679		P("???\n");
 680		break;
 681	}
 682#undef P
 683}
 684EXPORT_SYMBOL_FOR_TESTS_ONLY(drm_dp_dump_sideband_msg_req_body);
 685
 686static inline void
 687drm_dp_mst_dump_sideband_msg_tx(struct drm_printer *p,
 688				const struct drm_dp_sideband_msg_tx *txmsg)
 689{
 690	struct drm_dp_sideband_msg_req_body req;
 691	char buf[64];
 692	int ret;
 693	int i;
 694
 695	drm_dp_mst_rad_to_str(txmsg->dst->rad, txmsg->dst->lct, buf,
 696			      sizeof(buf));
 697	drm_printf(p, "txmsg cur_offset=%x cur_len=%x seqno=%x state=%s path_msg=%d dst=%s\n",
 698		   txmsg->cur_offset, txmsg->cur_len, txmsg->seqno,
 699		   drm_dp_mst_sideband_tx_state_str(txmsg->state),
 700		   txmsg->path_msg, buf);
 701
 702	ret = drm_dp_decode_sideband_req(txmsg, &req);
 703	if (ret) {
 704		drm_printf(p, "<failed to decode sideband req: %d>\n", ret);
 705		return;
 706	}
 707	drm_dp_dump_sideband_msg_req_body(&req, 1, p);
 708
 709	switch (req.req_type) {
 710	case DP_REMOTE_DPCD_WRITE:
 711		kfree(req.u.dpcd_write.bytes);
 712		break;
 713	case DP_REMOTE_I2C_READ:
 714		for (i = 0; i < req.u.i2c_read.num_transactions; i++)
 715			kfree(req.u.i2c_read.transactions[i].bytes);
 716		break;
 717	case DP_REMOTE_I2C_WRITE:
 718		kfree(req.u.i2c_write.bytes);
 719		break;
 720	}
 721}
 722
 723static void drm_dp_crc_sideband_chunk_req(u8 *msg, u8 len)
 724{
 725	u8 crc4;
 726
 727	crc4 = drm_dp_msg_data_crc4(msg, len);
 728	msg[len] = crc4;
 729}
 730
 731static void drm_dp_encode_sideband_reply(struct drm_dp_sideband_msg_reply_body *rep,
 732					 struct drm_dp_sideband_msg_tx *raw)
 733{
 734	int idx = 0;
 735	u8 *buf = raw->msg;
 736
 737	buf[idx++] = (rep->reply_type & 0x1) << 7 | (rep->req_type & 0x7f);
 738
 739	raw->cur_len = idx;
 740}
 741
 742static int drm_dp_sideband_msg_set_header(struct drm_dp_sideband_msg_rx *msg,
 743					  struct drm_dp_sideband_msg_hdr *hdr,
 744					  u8 hdrlen)
 745{
 746	/*
 747	 * ignore out-of-order messages or messages that are part of a
 748	 * failed transaction
 749	 */
 750	if (!hdr->somt && !msg->have_somt)
 751		return false;
 752
 753	/* get length contained in this portion */
 754	msg->curchunk_idx = 0;
 755	msg->curchunk_len = hdr->msg_len;
 756	msg->curchunk_hdrlen = hdrlen;
 757
 758	/* we have already gotten an somt - don't bother parsing */
 759	if (hdr->somt && msg->have_somt)
 760		return false;
 761
 762	if (hdr->somt) {
 763		memcpy(&msg->initial_hdr, hdr,
 764		       sizeof(struct drm_dp_sideband_msg_hdr));
 765		msg->have_somt = true;
 766	}
 767	if (hdr->eomt)
 768		msg->have_eomt = true;
 769
 770	return true;
 771}
 772
 773/* this adds a chunk of msg to the builder to get the final msg */
 774static bool drm_dp_sideband_append_payload(struct drm_dp_sideband_msg_rx *msg,
 775					   u8 *replybuf, u8 replybuflen)
 776{
 777	u8 crc4;
 778
 779	memcpy(&msg->chunk[msg->curchunk_idx], replybuf, replybuflen);
 780	msg->curchunk_idx += replybuflen;
 781
 782	if (msg->curchunk_idx >= msg->curchunk_len) {
 783		/* do CRC */
 784		crc4 = drm_dp_msg_data_crc4(msg->chunk, msg->curchunk_len - 1);
 785		if (crc4 != msg->chunk[msg->curchunk_len - 1])
 786			print_hex_dump(KERN_DEBUG, "wrong crc",
 787				       DUMP_PREFIX_NONE, 16, 1,
 788				       msg->chunk,  msg->curchunk_len, false);
 789		/* copy chunk into bigger msg */
 790		memcpy(&msg->msg[msg->curlen], msg->chunk, msg->curchunk_len - 1);
 791		msg->curlen += msg->curchunk_len - 1;
 792	}
 793	return true;
 794}
 795
 796static bool drm_dp_sideband_parse_link_address(const struct drm_dp_mst_topology_mgr *mgr,
 797					       struct drm_dp_sideband_msg_rx *raw,
 798					       struct drm_dp_sideband_msg_reply_body *repmsg)
 799{
 800	int idx = 1;
 801	int i;
 802
 803	memcpy(repmsg->u.link_addr.guid, &raw->msg[idx], 16);
 804	idx += 16;
 805	repmsg->u.link_addr.nports = raw->msg[idx] & 0xf;
 806	idx++;
 807	if (idx > raw->curlen)
 808		goto fail_len;
 809	for (i = 0; i < repmsg->u.link_addr.nports; i++) {
 810		if (raw->msg[idx] & 0x80)
 811			repmsg->u.link_addr.ports[i].input_port = 1;
 812
 813		repmsg->u.link_addr.ports[i].peer_device_type = (raw->msg[idx] >> 4) & 0x7;
 814		repmsg->u.link_addr.ports[i].port_number = (raw->msg[idx] & 0xf);
 815
 816		idx++;
 817		if (idx > raw->curlen)
 818			goto fail_len;
 819		repmsg->u.link_addr.ports[i].mcs = (raw->msg[idx] >> 7) & 0x1;
 820		repmsg->u.link_addr.ports[i].ddps = (raw->msg[idx] >> 6) & 0x1;
 821		if (repmsg->u.link_addr.ports[i].input_port == 0)
 822			repmsg->u.link_addr.ports[i].legacy_device_plug_status = (raw->msg[idx] >> 5) & 0x1;
 823		idx++;
 824		if (idx > raw->curlen)
 825			goto fail_len;
 826		if (repmsg->u.link_addr.ports[i].input_port == 0) {
 827			repmsg->u.link_addr.ports[i].dpcd_revision = (raw->msg[idx]);
 828			idx++;
 829			if (idx > raw->curlen)
 830				goto fail_len;
 831			memcpy(repmsg->u.link_addr.ports[i].peer_guid, &raw->msg[idx], 16);
 832			idx += 16;
 833			if (idx > raw->curlen)
 834				goto fail_len;
 835			repmsg->u.link_addr.ports[i].num_sdp_streams = (raw->msg[idx] >> 4) & 0xf;
 836			repmsg->u.link_addr.ports[i].num_sdp_stream_sinks = (raw->msg[idx] & 0xf);
 837			idx++;
 838
 839		}
 840		if (idx > raw->curlen)
 841			goto fail_len;
 842	}
 843
 844	return true;
 845fail_len:
 846	DRM_DEBUG_KMS("link address reply parse length fail %d %d\n", idx, raw->curlen);
 847	return false;
 848}
 849
 850static bool drm_dp_sideband_parse_remote_dpcd_read(struct drm_dp_sideband_msg_rx *raw,
 851						   struct drm_dp_sideband_msg_reply_body *repmsg)
 852{
 853	int idx = 1;
 854
 855	repmsg->u.remote_dpcd_read_ack.port_number = raw->msg[idx] & 0xf;
 856	idx++;
 857	if (idx > raw->curlen)
 858		goto fail_len;
 859	repmsg->u.remote_dpcd_read_ack.num_bytes = raw->msg[idx];
 860	idx++;
 861	if (idx > raw->curlen)
 862		goto fail_len;
 863
 864	memcpy(repmsg->u.remote_dpcd_read_ack.bytes, &raw->msg[idx], repmsg->u.remote_dpcd_read_ack.num_bytes);
 865	return true;
 866fail_len:
 867	DRM_DEBUG_KMS("link address reply parse length fail %d %d\n", idx, raw->curlen);
 868	return false;
 869}
 870
 871static bool drm_dp_sideband_parse_remote_dpcd_write(struct drm_dp_sideband_msg_rx *raw,
 872						      struct drm_dp_sideband_msg_reply_body *repmsg)
 873{
 874	int idx = 1;
 875
 876	repmsg->u.remote_dpcd_write_ack.port_number = raw->msg[idx] & 0xf;
 877	idx++;
 878	if (idx > raw->curlen)
 879		goto fail_len;
 880	return true;
 881fail_len:
 882	DRM_DEBUG_KMS("parse length fail %d %d\n", idx, raw->curlen);
 883	return false;
 884}
 885
 886static bool drm_dp_sideband_parse_remote_i2c_read_ack(struct drm_dp_sideband_msg_rx *raw,
 887						      struct drm_dp_sideband_msg_reply_body *repmsg)
 888{
 889	int idx = 1;
 890
 891	repmsg->u.remote_i2c_read_ack.port_number = (raw->msg[idx] & 0xf);
 892	idx++;
 893	if (idx > raw->curlen)
 894		goto fail_len;
 895	repmsg->u.remote_i2c_read_ack.num_bytes = raw->msg[idx];
 896	idx++;
 897	/* TODO check */
 898	memcpy(repmsg->u.remote_i2c_read_ack.bytes, &raw->msg[idx], repmsg->u.remote_i2c_read_ack.num_bytes);
 899	return true;
 900fail_len:
 901	DRM_DEBUG_KMS("remote i2c reply parse length fail %d %d\n", idx, raw->curlen);
 902	return false;
 903}
 904
 905static bool drm_dp_sideband_parse_enum_path_resources_ack(struct drm_dp_sideband_msg_rx *raw,
 906							  struct drm_dp_sideband_msg_reply_body *repmsg)
 907{
 908	int idx = 1;
 909
 910	repmsg->u.path_resources.port_number = (raw->msg[idx] >> 4) & 0xf;
 911	repmsg->u.path_resources.fec_capable = raw->msg[idx] & 0x1;
 912	idx++;
 913	if (idx > raw->curlen)
 914		goto fail_len;
 915	repmsg->u.path_resources.full_payload_bw_number = (raw->msg[idx] << 8) | (raw->msg[idx+1]);
 916	idx += 2;
 917	if (idx > raw->curlen)
 918		goto fail_len;
 919	repmsg->u.path_resources.avail_payload_bw_number = (raw->msg[idx] << 8) | (raw->msg[idx+1]);
 920	idx += 2;
 921	if (idx > raw->curlen)
 922		goto fail_len;
 923	return true;
 924fail_len:
 925	DRM_DEBUG_KMS("enum resource parse length fail %d %d\n", idx, raw->curlen);
 926	return false;
 927}
 928
 929static bool drm_dp_sideband_parse_allocate_payload_ack(struct drm_dp_sideband_msg_rx *raw,
 930							  struct drm_dp_sideband_msg_reply_body *repmsg)
 931{
 932	int idx = 1;
 933
 934	repmsg->u.allocate_payload.port_number = (raw->msg[idx] >> 4) & 0xf;
 935	idx++;
 936	if (idx > raw->curlen)
 937		goto fail_len;
 938	repmsg->u.allocate_payload.vcpi = raw->msg[idx];
 939	idx++;
 940	if (idx > raw->curlen)
 941		goto fail_len;
 942	repmsg->u.allocate_payload.allocated_pbn = (raw->msg[idx] << 8) | (raw->msg[idx+1]);
 943	idx += 2;
 944	if (idx > raw->curlen)
 945		goto fail_len;
 946	return true;
 947fail_len:
 948	DRM_DEBUG_KMS("allocate payload parse length fail %d %d\n", idx, raw->curlen);
 949	return false;
 950}
 951
 952static bool drm_dp_sideband_parse_query_payload_ack(struct drm_dp_sideband_msg_rx *raw,
 953						    struct drm_dp_sideband_msg_reply_body *repmsg)
 954{
 955	int idx = 1;
 956
 957	repmsg->u.query_payload.port_number = (raw->msg[idx] >> 4) & 0xf;
 958	idx++;
 959	if (idx > raw->curlen)
 960		goto fail_len;
 961	repmsg->u.query_payload.allocated_pbn = (raw->msg[idx] << 8) | (raw->msg[idx + 1]);
 962	idx += 2;
 963	if (idx > raw->curlen)
 964		goto fail_len;
 965	return true;
 966fail_len:
 967	DRM_DEBUG_KMS("query payload parse length fail %d %d\n", idx, raw->curlen);
 968	return false;
 969}
 970
 971static bool drm_dp_sideband_parse_power_updown_phy_ack(struct drm_dp_sideband_msg_rx *raw,
 972						       struct drm_dp_sideband_msg_reply_body *repmsg)
 973{
 974	int idx = 1;
 975
 976	repmsg->u.port_number.port_number = (raw->msg[idx] >> 4) & 0xf;
 977	idx++;
 978	if (idx > raw->curlen) {
 979		DRM_DEBUG_KMS("power up/down phy parse length fail %d %d\n",
 980			      idx, raw->curlen);
 981		return false;
 982	}
 983	return true;
 984}
 985
 986static bool
 987drm_dp_sideband_parse_query_stream_enc_status(
 988				struct drm_dp_sideband_msg_rx *raw,
 989				struct drm_dp_sideband_msg_reply_body *repmsg)
 990{
 991	struct drm_dp_query_stream_enc_status_ack_reply *reply;
 992
 993	reply = &repmsg->u.enc_status;
 994
 995	reply->stream_id = raw->msg[3];
 996
 997	reply->reply_signed = raw->msg[2] & BIT(0);
 998
 999	/*
1000	 * NOTE: It's my impression from reading the spec that the below parsing
1001	 * is correct. However I noticed while testing with an HDCP 1.4 display
1002	 * through an HDCP 2.2 hub that only bit 3 was set. In that case, I
1003	 * would expect both bits to be set. So keep the parsing following the
1004	 * spec, but beware reality might not match the spec (at least for some
1005	 * configurations).
1006	 */
1007	reply->hdcp_1x_device_present = raw->msg[2] & BIT(4);
1008	reply->hdcp_2x_device_present = raw->msg[2] & BIT(3);
1009
1010	reply->query_capable_device_present = raw->msg[2] & BIT(5);
1011	reply->legacy_device_present = raw->msg[2] & BIT(6);
1012	reply->unauthorizable_device_present = raw->msg[2] & BIT(7);
1013
1014	reply->auth_completed = !!(raw->msg[1] & BIT(3));
1015	reply->encryption_enabled = !!(raw->msg[1] & BIT(4));
1016	reply->repeater_present = !!(raw->msg[1] & BIT(5));
1017	reply->state = (raw->msg[1] & GENMASK(7, 6)) >> 6;
1018
1019	return true;
1020}
1021
1022static bool drm_dp_sideband_parse_reply(const struct drm_dp_mst_topology_mgr *mgr,
1023					struct drm_dp_sideband_msg_rx *raw,
1024					struct drm_dp_sideband_msg_reply_body *msg)
1025{
1026	memset(msg, 0, sizeof(*msg));
1027	msg->reply_type = (raw->msg[0] & 0x80) >> 7;
1028	msg->req_type = (raw->msg[0] & 0x7f);
1029
1030	if (msg->reply_type == DP_SIDEBAND_REPLY_NAK) {
1031		memcpy(msg->u.nak.guid, &raw->msg[1], 16);
1032		msg->u.nak.reason = raw->msg[17];
1033		msg->u.nak.nak_data = raw->msg[18];
1034		return false;
1035	}
1036
1037	switch (msg->req_type) {
1038	case DP_LINK_ADDRESS:
1039		return drm_dp_sideband_parse_link_address(mgr, raw, msg);
1040	case DP_QUERY_PAYLOAD:
1041		return drm_dp_sideband_parse_query_payload_ack(raw, msg);
1042	case DP_REMOTE_DPCD_READ:
1043		return drm_dp_sideband_parse_remote_dpcd_read(raw, msg);
1044	case DP_REMOTE_DPCD_WRITE:
1045		return drm_dp_sideband_parse_remote_dpcd_write(raw, msg);
1046	case DP_REMOTE_I2C_READ:
1047		return drm_dp_sideband_parse_remote_i2c_read_ack(raw, msg);
1048	case DP_REMOTE_I2C_WRITE:
1049		return true; /* since there's nothing to parse */
1050	case DP_ENUM_PATH_RESOURCES:
1051		return drm_dp_sideband_parse_enum_path_resources_ack(raw, msg);
1052	case DP_ALLOCATE_PAYLOAD:
1053		return drm_dp_sideband_parse_allocate_payload_ack(raw, msg);
1054	case DP_POWER_DOWN_PHY:
1055	case DP_POWER_UP_PHY:
1056		return drm_dp_sideband_parse_power_updown_phy_ack(raw, msg);
1057	case DP_CLEAR_PAYLOAD_ID_TABLE:
1058		return true; /* since there's nothing to parse */
1059	case DP_QUERY_STREAM_ENC_STATUS:
1060		return drm_dp_sideband_parse_query_stream_enc_status(raw, msg);
1061	default:
1062		drm_err(mgr->dev, "Got unknown reply 0x%02x (%s)\n",
1063			msg->req_type, drm_dp_mst_req_type_str(msg->req_type));
1064		return false;
1065	}
1066}
1067
1068static bool
1069drm_dp_sideband_parse_connection_status_notify(const struct drm_dp_mst_topology_mgr *mgr,
1070					       struct drm_dp_sideband_msg_rx *raw,
1071					       struct drm_dp_sideband_msg_req_body *msg)
1072{
1073	int idx = 1;
1074
1075	msg->u.conn_stat.port_number = (raw->msg[idx] & 0xf0) >> 4;
1076	idx++;
1077	if (idx > raw->curlen)
1078		goto fail_len;
1079
1080	memcpy(msg->u.conn_stat.guid, &raw->msg[idx], 16);
1081	idx += 16;
1082	if (idx > raw->curlen)
1083		goto fail_len;
1084
1085	msg->u.conn_stat.legacy_device_plug_status = (raw->msg[idx] >> 6) & 0x1;
1086	msg->u.conn_stat.displayport_device_plug_status = (raw->msg[idx] >> 5) & 0x1;
1087	msg->u.conn_stat.message_capability_status = (raw->msg[idx] >> 4) & 0x1;
1088	msg->u.conn_stat.input_port = (raw->msg[idx] >> 3) & 0x1;
1089	msg->u.conn_stat.peer_device_type = (raw->msg[idx] & 0x7);
1090	idx++;
1091	return true;
1092fail_len:
1093	drm_dbg_kms(mgr->dev, "connection status reply parse length fail %d %d\n",
1094		    idx, raw->curlen);
1095	return false;
1096}
1097
1098static bool drm_dp_sideband_parse_resource_status_notify(const struct drm_dp_mst_topology_mgr *mgr,
1099							 struct drm_dp_sideband_msg_rx *raw,
1100							 struct drm_dp_sideband_msg_req_body *msg)
1101{
1102	int idx = 1;
1103
1104	msg->u.resource_stat.port_number = (raw->msg[idx] & 0xf0) >> 4;
1105	idx++;
1106	if (idx > raw->curlen)
1107		goto fail_len;
1108
1109	memcpy(msg->u.resource_stat.guid, &raw->msg[idx], 16);
1110	idx += 16;
1111	if (idx > raw->curlen)
1112		goto fail_len;
1113
1114	msg->u.resource_stat.available_pbn = (raw->msg[idx] << 8) | (raw->msg[idx + 1]);
1115	idx++;
1116	return true;
1117fail_len:
1118	drm_dbg_kms(mgr->dev, "resource status reply parse length fail %d %d\n", idx, raw->curlen);
1119	return false;
1120}
1121
1122static bool drm_dp_sideband_parse_req(const struct drm_dp_mst_topology_mgr *mgr,
1123				      struct drm_dp_sideband_msg_rx *raw,
1124				      struct drm_dp_sideband_msg_req_body *msg)
1125{
1126	memset(msg, 0, sizeof(*msg));
1127	msg->req_type = (raw->msg[0] & 0x7f);
1128
1129	switch (msg->req_type) {
1130	case DP_CONNECTION_STATUS_NOTIFY:
1131		return drm_dp_sideband_parse_connection_status_notify(mgr, raw, msg);
1132	case DP_RESOURCE_STATUS_NOTIFY:
1133		return drm_dp_sideband_parse_resource_status_notify(mgr, raw, msg);
1134	default:
1135		drm_err(mgr->dev, "Got unknown request 0x%02x (%s)\n",
1136			msg->req_type, drm_dp_mst_req_type_str(msg->req_type));
1137		return false;
1138	}
1139}
1140
1141static void build_dpcd_write(struct drm_dp_sideband_msg_tx *msg,
1142			     u8 port_num, u32 offset, u8 num_bytes, u8 *bytes)
1143{
1144	struct drm_dp_sideband_msg_req_body req;
1145
1146	req.req_type = DP_REMOTE_DPCD_WRITE;
1147	req.u.dpcd_write.port_number = port_num;
1148	req.u.dpcd_write.dpcd_address = offset;
1149	req.u.dpcd_write.num_bytes = num_bytes;
1150	req.u.dpcd_write.bytes = bytes;
1151	drm_dp_encode_sideband_req(&req, msg);
1152}
1153
1154static void build_link_address(struct drm_dp_sideband_msg_tx *msg)
1155{
1156	struct drm_dp_sideband_msg_req_body req;
1157
1158	req.req_type = DP_LINK_ADDRESS;
1159	drm_dp_encode_sideband_req(&req, msg);
1160}
1161
1162static void build_clear_payload_id_table(struct drm_dp_sideband_msg_tx *msg)
1163{
1164	struct drm_dp_sideband_msg_req_body req;
1165
1166	req.req_type = DP_CLEAR_PAYLOAD_ID_TABLE;
1167	drm_dp_encode_sideband_req(&req, msg);
1168	msg->path_msg = true;
1169}
1170
1171static int build_enum_path_resources(struct drm_dp_sideband_msg_tx *msg,
1172				     int port_num)
1173{
1174	struct drm_dp_sideband_msg_req_body req;
1175
1176	req.req_type = DP_ENUM_PATH_RESOURCES;
1177	req.u.port_num.port_number = port_num;
1178	drm_dp_encode_sideband_req(&req, msg);
1179	msg->path_msg = true;
1180	return 0;
1181}
1182
1183static void build_allocate_payload(struct drm_dp_sideband_msg_tx *msg,
1184				   int port_num,
1185				   u8 vcpi, uint16_t pbn,
1186				   u8 number_sdp_streams,
1187				   u8 *sdp_stream_sink)
1188{
1189	struct drm_dp_sideband_msg_req_body req;
1190
1191	memset(&req, 0, sizeof(req));
1192	req.req_type = DP_ALLOCATE_PAYLOAD;
1193	req.u.allocate_payload.port_number = port_num;
1194	req.u.allocate_payload.vcpi = vcpi;
1195	req.u.allocate_payload.pbn = pbn;
1196	req.u.allocate_payload.number_sdp_streams = number_sdp_streams;
1197	memcpy(req.u.allocate_payload.sdp_stream_sink, sdp_stream_sink,
1198		   number_sdp_streams);
1199	drm_dp_encode_sideband_req(&req, msg);
1200	msg->path_msg = true;
1201}
1202
1203static void build_power_updown_phy(struct drm_dp_sideband_msg_tx *msg,
1204				   int port_num, bool power_up)
1205{
1206	struct drm_dp_sideband_msg_req_body req;
1207
1208	if (power_up)
1209		req.req_type = DP_POWER_UP_PHY;
1210	else
1211		req.req_type = DP_POWER_DOWN_PHY;
1212
1213	req.u.port_num.port_number = port_num;
1214	drm_dp_encode_sideband_req(&req, msg);
1215	msg->path_msg = true;
1216}
1217
1218static int
1219build_query_stream_enc_status(struct drm_dp_sideband_msg_tx *msg, u8 stream_id,
1220			      u8 *q_id)
1221{
1222	struct drm_dp_sideband_msg_req_body req;
1223
1224	req.req_type = DP_QUERY_STREAM_ENC_STATUS;
1225	req.u.enc_status.stream_id = stream_id;
1226	memcpy(req.u.enc_status.client_id, q_id,
1227	       sizeof(req.u.enc_status.client_id));
1228	req.u.enc_status.stream_event = 0;
1229	req.u.enc_status.valid_stream_event = false;
1230	req.u.enc_status.stream_behavior = 0;
1231	req.u.enc_status.valid_stream_behavior = false;
1232
1233	drm_dp_encode_sideband_req(&req, msg);
1234	return 0;
1235}
1236
1237static bool check_txmsg_state(struct drm_dp_mst_topology_mgr *mgr,
1238			      struct drm_dp_sideband_msg_tx *txmsg)
1239{
1240	unsigned int state;
1241
1242	/*
1243	 * All updates to txmsg->state are protected by mgr->qlock, and the two
1244	 * cases we check here are terminal states. For those the barriers
1245	 * provided by the wake_up/wait_event pair are enough.
1246	 */
1247	state = READ_ONCE(txmsg->state);
1248	return (state == DRM_DP_SIDEBAND_TX_RX ||
1249		state == DRM_DP_SIDEBAND_TX_TIMEOUT);
1250}
1251
1252static int drm_dp_mst_wait_tx_reply(struct drm_dp_mst_branch *mstb,
1253				    struct drm_dp_sideband_msg_tx *txmsg)
1254{
1255	struct drm_dp_mst_topology_mgr *mgr = mstb->mgr;
1256	unsigned long wait_timeout = msecs_to_jiffies(4000);
1257	unsigned long wait_expires = jiffies + wait_timeout;
1258	int ret;
1259
1260	for (;;) {
1261		/*
1262		 * If the driver provides a way for this, change to
1263		 * poll-waiting for the MST reply interrupt if we didn't receive
1264		 * it for 50 msec. This would cater for cases where the HPD
1265		 * pulse signal got lost somewhere, even though the sink raised
1266		 * the corresponding MST interrupt correctly. One example is the
1267		 * Club 3D CAC-1557 TypeC -> DP adapter which for some reason
1268		 * filters out short pulses with a duration less than ~540 usec.
1269		 *
1270		 * The poll period is 50 msec to avoid missing an interrupt
1271		 * after the sink has cleared it (after a 110msec timeout
1272		 * since it raised the interrupt).
1273		 */
1274		ret = wait_event_timeout(mgr->tx_waitq,
1275					 check_txmsg_state(mgr, txmsg),
1276					 mgr->cbs->poll_hpd_irq ?
1277						msecs_to_jiffies(50) :
1278						wait_timeout);
1279
1280		if (ret || !mgr->cbs->poll_hpd_irq ||
1281		    time_after(jiffies, wait_expires))
1282			break;
1283
1284		mgr->cbs->poll_hpd_irq(mgr);
1285	}
1286
1287	mutex_lock(&mgr->qlock);
1288	if (ret > 0) {
1289		if (txmsg->state == DRM_DP_SIDEBAND_TX_TIMEOUT) {
1290			ret = -EIO;
1291			goto out;
1292		}
1293	} else {
1294		drm_dbg_kms(mgr->dev, "timedout msg send %p %d %d\n",
1295			    txmsg, txmsg->state, txmsg->seqno);
1296
1297		/* dump some state */
1298		ret = -EIO;
1299
1300		/* remove from q */
1301		if (txmsg->state == DRM_DP_SIDEBAND_TX_QUEUED ||
1302		    txmsg->state == DRM_DP_SIDEBAND_TX_START_SEND ||
1303		    txmsg->state == DRM_DP_SIDEBAND_TX_SENT)
1304			list_del(&txmsg->next);
1305	}
1306out:
1307	if (unlikely(ret == -EIO) && drm_debug_enabled(DRM_UT_DP)) {
1308		struct drm_printer p = drm_debug_printer(DBG_PREFIX);
1309
1310		drm_dp_mst_dump_sideband_msg_tx(&p, txmsg);
1311	}
1312	mutex_unlock(&mgr->qlock);
1313
1314	drm_dp_mst_kick_tx(mgr);
1315	return ret;
1316}
1317
1318static struct drm_dp_mst_branch *drm_dp_add_mst_branch_device(u8 lct, u8 *rad)
1319{
1320	struct drm_dp_mst_branch *mstb;
1321
1322	mstb = kzalloc(sizeof(*mstb), GFP_KERNEL);
1323	if (!mstb)
1324		return NULL;
1325
1326	mstb->lct = lct;
1327	if (lct > 1)
1328		memcpy(mstb->rad, rad, lct / 2);
1329	INIT_LIST_HEAD(&mstb->ports);
1330	kref_init(&mstb->topology_kref);
1331	kref_init(&mstb->malloc_kref);
1332	return mstb;
1333}
1334
1335static void drm_dp_free_mst_branch_device(struct kref *kref)
1336{
1337	struct drm_dp_mst_branch *mstb =
1338		container_of(kref, struct drm_dp_mst_branch, malloc_kref);
1339
1340	if (mstb->port_parent)
1341		drm_dp_mst_put_port_malloc(mstb->port_parent);
1342
1343	kfree(mstb);
1344}
1345
1346/**
1347 * DOC: Branch device and port refcounting
1348 *
1349 * Topology refcount overview
1350 * ~~~~~~~~~~~~~~~~~~~~~~~~~~
1351 *
1352 * The refcounting schemes for &struct drm_dp_mst_branch and &struct
1353 * drm_dp_mst_port are somewhat unusual. Both ports and branch devices have
1354 * two different kinds of refcounts: topology refcounts, and malloc refcounts.
1355 *
1356 * Topology refcounts are not exposed to drivers, and are handled internally
1357 * by the DP MST helpers. The helpers use them in order to prevent the
1358 * in-memory topology state from being changed in the middle of critical
1359 * operations like changing the internal state of payload allocations. This
1360 * means each branch and port will be considered to be connected to the rest
1361 * of the topology until its topology refcount reaches zero. Additionally,
1362 * for ports this means that their associated &struct drm_connector will stay
1363 * registered with userspace until the port's refcount reaches 0.
1364 *
1365 * Malloc refcount overview
1366 * ~~~~~~~~~~~~~~~~~~~~~~~~
1367 *
1368 * Malloc references are used to keep a &struct drm_dp_mst_port or &struct
1369 * drm_dp_mst_branch allocated even after all of its topology references have
1370 * been dropped, so that the driver or MST helpers can safely access each
1371 * branch's last known state before it was disconnected from the topology.
1372 * When the malloc refcount of a port or branch reaches 0, the memory
1373 * allocation containing the &struct drm_dp_mst_branch or &struct
1374 * drm_dp_mst_port respectively will be freed.
1375 *
1376 * For &struct drm_dp_mst_branch, malloc refcounts are not currently exposed
1377 * to drivers. As of writing this documentation, there are no drivers that
1378 * have a usecase for accessing &struct drm_dp_mst_branch outside of the MST
1379 * helpers. Exposing this API to drivers in a race-free manner would take more
1380 * tweaking of the refcounting scheme, however patches are welcome provided
1381 * there is a legitimate driver usecase for this.
1382 *
1383 * Refcount relationships in a topology
1384 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
1385 *
1386 * Let's take a look at why the relationship between topology and malloc
1387 * refcounts is designed the way it is.
1388 *
1389 * .. kernel-figure:: dp-mst/topology-figure-1.dot
1390 *
1391 *    An example of topology and malloc refs in a DP MST topology with two
1392 *    active payloads. Topology refcount increments are indicated by solid
1393 *    lines, and malloc refcount increments are indicated by dashed lines.
1394 *    Each starts from the branch which incremented the refcount, and ends at
1395 *    the branch to which the refcount belongs to, i.e. the arrow points the
1396 *    same way as the C pointers used to reference a structure.
1397 *
1398 * As you can see in the above figure, every branch increments the topology
1399 * refcount of its children, and increments the malloc refcount of its
1400 * parent. Additionally, every payload increments the malloc refcount of its
1401 * assigned port by 1.
1402 *
1403 * So, what would happen if MSTB #3 from the above figure was unplugged from
1404 * the system, but the driver hadn't yet removed payload #2 from port #3? The
1405 * topology would start to look like the figure below.
1406 *
1407 * .. kernel-figure:: dp-mst/topology-figure-2.dot
1408 *
1409 *    Ports and branch devices which have been released from memory are
1410 *    colored grey, and references which have been removed are colored red.
1411 *
1412 * Whenever a port or branch device's topology refcount reaches zero, it will
1413 * decrement the topology refcounts of all its children, the malloc refcount
1414 * of its parent, and finally its own malloc refcount. For MSTB #4 and port
1415 * #4, this means they both have been disconnected from the topology and freed
1416 * from memory. But, because payload #2 is still holding a reference to port
1417 * #3, port #3 is removed from the topology but its &struct drm_dp_mst_port
1418 * is still accessible from memory. This also means port #3 has not yet
1419 * decremented the malloc refcount of MSTB #3, so its &struct
1420 * drm_dp_mst_branch will also stay allocated in memory until port #3's
1421 * malloc refcount reaches 0.
1422 *
1423 * This relationship is necessary because in order to release payload #2, we
1424 * need to be able to figure out the last relative of port #3 that's still
1425 * connected to the topology. In this case, we would travel up the topology as
1426 * shown below.
1427 *
1428 * .. kernel-figure:: dp-mst/topology-figure-3.dot
1429 *
1430 * And finally, remove payload #2 by communicating with port #2 through
1431 * sideband transactions.
1432 */
1433
1434/**
1435 * drm_dp_mst_get_mstb_malloc() - Increment the malloc refcount of a branch
1436 * device
1437 * @mstb: The &struct drm_dp_mst_branch to increment the malloc refcount of
1438 *
1439 * Increments &drm_dp_mst_branch.malloc_kref. When
1440 * &drm_dp_mst_branch.malloc_kref reaches 0, the memory allocation for @mstb
1441 * will be released and @mstb may no longer be used.
1442 *
1443 * See also: drm_dp_mst_put_mstb_malloc()
1444 */
1445static void
1446drm_dp_mst_get_mstb_malloc(struct drm_dp_mst_branch *mstb)
1447{
1448	kref_get(&mstb->malloc_kref);
1449	drm_dbg(mstb->mgr->dev, "mstb %p (%d)\n", mstb, kref_read(&mstb->malloc_kref));
1450}
1451
1452/**
1453 * drm_dp_mst_put_mstb_malloc() - Decrement the malloc refcount of a branch
1454 * device
1455 * @mstb: The &struct drm_dp_mst_branch to decrement the malloc refcount of
1456 *
1457 * Decrements &drm_dp_mst_branch.malloc_kref. When
1458 * &drm_dp_mst_branch.malloc_kref reaches 0, the memory allocation for @mstb
1459 * will be released and @mstb may no longer be used.
1460 *
1461 * See also: drm_dp_mst_get_mstb_malloc()
1462 */
1463static void
1464drm_dp_mst_put_mstb_malloc(struct drm_dp_mst_branch *mstb)
1465{
1466	drm_dbg(mstb->mgr->dev, "mstb %p (%d)\n", mstb, kref_read(&mstb->malloc_kref) - 1);
1467	kref_put(&mstb->malloc_kref, drm_dp_free_mst_branch_device);
1468}
1469
1470static void drm_dp_free_mst_port(struct kref *kref)
1471{
1472	struct drm_dp_mst_port *port =
1473		container_of(kref, struct drm_dp_mst_port, malloc_kref);
1474
1475	drm_dp_mst_put_mstb_malloc(port->parent);
1476	kfree(port);
1477}
1478
1479/**
1480 * drm_dp_mst_get_port_malloc() - Increment the malloc refcount of an MST port
1481 * @port: The &struct drm_dp_mst_port to increment the malloc refcount of
1482 *
1483 * Increments &drm_dp_mst_port.malloc_kref. When &drm_dp_mst_port.malloc_kref
1484 * reaches 0, the memory allocation for @port will be released and @port may
1485 * no longer be used.
1486 *
1487 * Because @port could potentially be freed at any time by the DP MST helpers
1488 * if &drm_dp_mst_port.malloc_kref reaches 0, including during a call to this
1489 * function, drivers that which to make use of &struct drm_dp_mst_port should
1490 * ensure that they grab at least one main malloc reference to their MST ports
1491 * in &drm_dp_mst_topology_cbs.add_connector. This callback is called before
1492 * there is any chance for &drm_dp_mst_port.malloc_kref to reach 0.
1493 *
1494 * See also: drm_dp_mst_put_port_malloc()
1495 */
1496void
1497drm_dp_mst_get_port_malloc(struct drm_dp_mst_port *port)
1498{
1499	kref_get(&port->malloc_kref);
1500	drm_dbg(port->mgr->dev, "port %p (%d)\n", port, kref_read(&port->malloc_kref));
1501}
1502EXPORT_SYMBOL(drm_dp_mst_get_port_malloc);
1503
1504/**
1505 * drm_dp_mst_put_port_malloc() - Decrement the malloc refcount of an MST port
1506 * @port: The &struct drm_dp_mst_port to decrement the malloc refcount of
1507 *
1508 * Decrements &drm_dp_mst_port.malloc_kref. When &drm_dp_mst_port.malloc_kref
1509 * reaches 0, the memory allocation for @port will be released and @port may
1510 * no longer be used.
1511 *
1512 * See also: drm_dp_mst_get_port_malloc()
1513 */
1514void
1515drm_dp_mst_put_port_malloc(struct drm_dp_mst_port *port)
1516{
1517	drm_dbg(port->mgr->dev, "port %p (%d)\n", port, kref_read(&port->malloc_kref) - 1);
1518	kref_put(&port->malloc_kref, drm_dp_free_mst_port);
1519}
1520EXPORT_SYMBOL(drm_dp_mst_put_port_malloc);
1521
1522#if IS_ENABLED(CONFIG_DRM_DEBUG_DP_MST_TOPOLOGY_REFS)
1523
1524#define STACK_DEPTH 8
1525
1526static noinline void
1527__topology_ref_save(struct drm_dp_mst_topology_mgr *mgr,
1528		    struct drm_dp_mst_topology_ref_history *history,
1529		    enum drm_dp_mst_topology_ref_type type)
1530{
1531	struct drm_dp_mst_topology_ref_entry *entry = NULL;
1532	depot_stack_handle_t backtrace;
1533	ulong stack_entries[STACK_DEPTH];
1534	uint n;
1535	int i;
1536
1537	n = stack_trace_save(stack_entries, ARRAY_SIZE(stack_entries), 1);
1538	backtrace = stack_depot_save(stack_entries, n, GFP_KERNEL);
1539	if (!backtrace)
1540		return;
1541
1542	/* Try to find an existing entry for this backtrace */
1543	for (i = 0; i < history->len; i++) {
1544		if (history->entries[i].backtrace == backtrace) {
1545			entry = &history->entries[i];
1546			break;
1547		}
1548	}
1549
1550	/* Otherwise add one */
1551	if (!entry) {
1552		struct drm_dp_mst_topology_ref_entry *new;
1553		int new_len = history->len + 1;
1554
1555		new = krealloc(history->entries, sizeof(*new) * new_len,
1556			       GFP_KERNEL);
1557		if (!new)
1558			return;
1559
1560		entry = &new[history->len];
1561		history->len = new_len;
1562		history->entries = new;
1563
1564		entry->backtrace = backtrace;
1565		entry->type = type;
1566		entry->count = 0;
1567	}
1568	entry->count++;
1569	entry->ts_nsec = ktime_get_ns();
1570}
1571
1572static int
1573topology_ref_history_cmp(const void *a, const void *b)
1574{
1575	const struct drm_dp_mst_topology_ref_entry *entry_a = a, *entry_b = b;
1576
1577	if (entry_a->ts_nsec > entry_b->ts_nsec)
1578		return 1;
1579	else if (entry_a->ts_nsec < entry_b->ts_nsec)
1580		return -1;
1581	else
1582		return 0;
1583}
1584
1585static inline const char *
1586topology_ref_type_to_str(enum drm_dp_mst_topology_ref_type type)
1587{
1588	if (type == DRM_DP_MST_TOPOLOGY_REF_GET)
1589		return "get";
1590	else
1591		return "put";
1592}
1593
1594static void
1595__dump_topology_ref_history(struct drm_dp_mst_topology_ref_history *history,
1596			    void *ptr, const char *type_str)
1597{
1598	struct drm_printer p = drm_debug_printer(DBG_PREFIX);
1599	char *buf = kzalloc(PAGE_SIZE, GFP_KERNEL);
1600	int i;
1601
1602	if (!buf)
1603		return;
1604
1605	if (!history->len)
1606		goto out;
1607
1608	/* First, sort the list so that it goes from oldest to newest
1609	 * reference entry
1610	 */
1611	sort(history->entries, history->len, sizeof(*history->entries),
1612	     topology_ref_history_cmp, NULL);
1613
1614	drm_printf(&p, "%s (%p) topology count reached 0, dumping history:\n",
1615		   type_str, ptr);
1616
1617	for (i = 0; i < history->len; i++) {
1618		const struct drm_dp_mst_topology_ref_entry *entry =
1619			&history->entries[i];
1620		u64 ts_nsec = entry->ts_nsec;
1621		u32 rem_nsec = do_div(ts_nsec, 1000000000);
1622
1623		stack_depot_snprint(entry->backtrace, buf, PAGE_SIZE, 4);
1624
1625		drm_printf(&p, "  %d %ss (last at %5llu.%06u):\n%s",
1626			   entry->count,
1627			   topology_ref_type_to_str(entry->type),
1628			   ts_nsec, rem_nsec / 1000, buf);
1629	}
1630
1631	/* Now free the history, since this is the only time we expose it */
1632	kfree(history->entries);
1633out:
1634	kfree(buf);
1635}
1636
1637static __always_inline void
1638drm_dp_mst_dump_mstb_topology_history(struct drm_dp_mst_branch *mstb)
1639{
1640	__dump_topology_ref_history(&mstb->topology_ref_history, mstb,
1641				    "MSTB");
1642}
1643
1644static __always_inline void
1645drm_dp_mst_dump_port_topology_history(struct drm_dp_mst_port *port)
1646{
1647	__dump_topology_ref_history(&port->topology_ref_history, port,
1648				    "Port");
1649}
1650
1651static __always_inline void
1652save_mstb_topology_ref(struct drm_dp_mst_branch *mstb,
1653		       enum drm_dp_mst_topology_ref_type type)
1654{
1655	__topology_ref_save(mstb->mgr, &mstb->topology_ref_history, type);
1656}
1657
1658static __always_inline void
1659save_port_topology_ref(struct drm_dp_mst_port *port,
1660		       enum drm_dp_mst_topology_ref_type type)
1661{
1662	__topology_ref_save(port->mgr, &port->topology_ref_history, type);
1663}
1664
1665static inline void
1666topology_ref_history_lock(struct drm_dp_mst_topology_mgr *mgr)
1667{
1668	mutex_lock(&mgr->topology_ref_history_lock);
1669}
1670
1671static inline void
1672topology_ref_history_unlock(struct drm_dp_mst_topology_mgr *mgr)
1673{
1674	mutex_unlock(&mgr->topology_ref_history_lock);
1675}
1676#else
1677static inline void
1678topology_ref_history_lock(struct drm_dp_mst_topology_mgr *mgr) {}
1679static inline void
1680topology_ref_history_unlock(struct drm_dp_mst_topology_mgr *mgr) {}
1681static inline void
1682drm_dp_mst_dump_mstb_topology_history(struct drm_dp_mst_branch *mstb) {}
1683static inline void
1684drm_dp_mst_dump_port_topology_history(struct drm_dp_mst_port *port) {}
1685#define save_mstb_topology_ref(mstb, type)
1686#define save_port_topology_ref(port, type)
1687#endif
1688
1689struct drm_dp_mst_atomic_payload *
1690drm_atomic_get_mst_payload_state(struct drm_dp_mst_topology_state *state,
1691				 struct drm_dp_mst_port *port)
1692{
1693	struct drm_dp_mst_atomic_payload *payload;
1694
1695	list_for_each_entry(payload, &state->payloads, next)
1696		if (payload->port == port)
1697			return payload;
1698
1699	return NULL;
1700}
1701EXPORT_SYMBOL(drm_atomic_get_mst_payload_state);
1702
1703static void drm_dp_destroy_mst_branch_device(struct kref *kref)
1704{
1705	struct drm_dp_mst_branch *mstb =
1706		container_of(kref, struct drm_dp_mst_branch, topology_kref);
1707	struct drm_dp_mst_topology_mgr *mgr = mstb->mgr;
1708
1709	drm_dp_mst_dump_mstb_topology_history(mstb);
1710
1711	INIT_LIST_HEAD(&mstb->destroy_next);
1712
1713	/*
1714	 * This can get called under mgr->mutex, so we need to perform the
1715	 * actual destruction of the mstb in another worker
1716	 */
1717	mutex_lock(&mgr->delayed_destroy_lock);
1718	list_add(&mstb->destroy_next, &mgr->destroy_branch_device_list);
1719	mutex_unlock(&mgr->delayed_destroy_lock);
1720	queue_work(mgr->delayed_destroy_wq, &mgr->delayed_destroy_work);
1721}
1722
1723/**
1724 * drm_dp_mst_topology_try_get_mstb() - Increment the topology refcount of a
1725 * branch device unless it's zero
1726 * @mstb: &struct drm_dp_mst_branch to increment the topology refcount of
1727 *
1728 * Attempts to grab a topology reference to @mstb, if it hasn't yet been
1729 * removed from the topology (e.g. &drm_dp_mst_branch.topology_kref has
1730 * reached 0). Holding a topology reference implies that a malloc reference
1731 * will be held to @mstb as long as the user holds the topology reference.
1732 *
1733 * Care should be taken to ensure that the user has at least one malloc
1734 * reference to @mstb. If you already have a topology reference to @mstb, you
1735 * should use drm_dp_mst_topology_get_mstb() instead.
1736 *
1737 * See also:
1738 * drm_dp_mst_topology_get_mstb()
1739 * drm_dp_mst_topology_put_mstb()
1740 *
1741 * Returns:
1742 * * 1: A topology reference was grabbed successfully
1743 * * 0: @port is no longer in the topology, no reference was grabbed
1744 */
1745static int __must_check
1746drm_dp_mst_topology_try_get_mstb(struct drm_dp_mst_branch *mstb)
1747{
1748	int ret;
1749
1750	topology_ref_history_lock(mstb->mgr);
1751	ret = kref_get_unless_zero(&mstb->topology_kref);
1752	if (ret) {
1753		drm_dbg(mstb->mgr->dev, "mstb %p (%d)\n", mstb, kref_read(&mstb->topology_kref));
1754		save_mstb_topology_ref(mstb, DRM_DP_MST_TOPOLOGY_REF_GET);
1755	}
1756
1757	topology_ref_history_unlock(mstb->mgr);
1758
1759	return ret;
1760}
1761
1762/**
1763 * drm_dp_mst_topology_get_mstb() - Increment the topology refcount of a
1764 * branch device
1765 * @mstb: The &struct drm_dp_mst_branch to increment the topology refcount of
1766 *
1767 * Increments &drm_dp_mst_branch.topology_refcount without checking whether or
1768 * not it's already reached 0. This is only valid to use in scenarios where
1769 * you are already guaranteed to have at least one active topology reference
1770 * to @mstb. Otherwise, drm_dp_mst_topology_try_get_mstb() must be used.
1771 *
1772 * See also:
1773 * drm_dp_mst_topology_try_get_mstb()
1774 * drm_dp_mst_topology_put_mstb()
1775 */
1776static void drm_dp_mst_topology_get_mstb(struct drm_dp_mst_branch *mstb)
1777{
1778	topology_ref_history_lock(mstb->mgr);
1779
1780	save_mstb_topology_ref(mstb, DRM_DP_MST_TOPOLOGY_REF_GET);
1781	WARN_ON(kref_read(&mstb->topology_kref) == 0);
1782	kref_get(&mstb->topology_kref);
1783	drm_dbg(mstb->mgr->dev, "mstb %p (%d)\n", mstb, kref_read(&mstb->topology_kref));
1784
1785	topology_ref_history_unlock(mstb->mgr);
1786}
1787
1788/**
1789 * drm_dp_mst_topology_put_mstb() - release a topology reference to a branch
1790 * device
1791 * @mstb: The &struct drm_dp_mst_branch to release the topology reference from
1792 *
1793 * Releases a topology reference from @mstb by decrementing
1794 * &drm_dp_mst_branch.topology_kref.
1795 *
1796 * See also:
1797 * drm_dp_mst_topology_try_get_mstb()
1798 * drm_dp_mst_topology_get_mstb()
1799 */
1800static void
1801drm_dp_mst_topology_put_mstb(struct drm_dp_mst_branch *mstb)
1802{
1803	topology_ref_history_lock(mstb->mgr);
1804
1805	drm_dbg(mstb->mgr->dev, "mstb %p (%d)\n", mstb, kref_read(&mstb->topology_kref) - 1);
1806	save_mstb_topology_ref(mstb, DRM_DP_MST_TOPOLOGY_REF_PUT);
1807
1808	topology_ref_history_unlock(mstb->mgr);
1809	kref_put(&mstb->topology_kref, drm_dp_destroy_mst_branch_device);
1810}
1811
1812static void drm_dp_destroy_port(struct kref *kref)
1813{
1814	struct drm_dp_mst_port *port =
1815		container_of(kref, struct drm_dp_mst_port, topology_kref);
1816	struct drm_dp_mst_topology_mgr *mgr = port->mgr;
1817
1818	drm_dp_mst_dump_port_topology_history(port);
1819
1820	/* There's nothing that needs locking to destroy an input port yet */
1821	if (port->input) {
1822		drm_dp_mst_put_port_malloc(port);
1823		return;
1824	}
1825
1826	kfree(port->cached_edid);
1827
1828	/*
1829	 * we can't destroy the connector here, as we might be holding the
1830	 * mode_config.mutex from an EDID retrieval
1831	 */
1832	mutex_lock(&mgr->delayed_destroy_lock);
1833	list_add(&port->next, &mgr->destroy_port_list);
1834	mutex_unlock(&mgr->delayed_destroy_lock);
1835	queue_work(mgr->delayed_destroy_wq, &mgr->delayed_destroy_work);
1836}
1837
1838/**
1839 * drm_dp_mst_topology_try_get_port() - Increment the topology refcount of a
1840 * port unless it's zero
1841 * @port: &struct drm_dp_mst_port to increment the topology refcount of
1842 *
1843 * Attempts to grab a topology reference to @port, if it hasn't yet been
1844 * removed from the topology (e.g. &drm_dp_mst_port.topology_kref has reached
1845 * 0). Holding a topology reference implies that a malloc reference will be
1846 * held to @port as long as the user holds the topology reference.
1847 *
1848 * Care should be taken to ensure that the user has at least one malloc
1849 * reference to @port. If you already have a topology reference to @port, you
1850 * should use drm_dp_mst_topology_get_port() instead.
1851 *
1852 * See also:
1853 * drm_dp_mst_topology_get_port()
1854 * drm_dp_mst_topology_put_port()
1855 *
1856 * Returns:
1857 * * 1: A topology reference was grabbed successfully
1858 * * 0: @port is no longer in the topology, no reference was grabbed
1859 */
1860static int __must_check
1861drm_dp_mst_topology_try_get_port(struct drm_dp_mst_port *port)
1862{
1863	int ret;
1864
1865	topology_ref_history_lock(port->mgr);
1866	ret = kref_get_unless_zero(&port->topology_kref);
1867	if (ret) {
1868		drm_dbg(port->mgr->dev, "port %p (%d)\n", port, kref_read(&port->topology_kref));
1869		save_port_topology_ref(port, DRM_DP_MST_TOPOLOGY_REF_GET);
1870	}
1871
1872	topology_ref_history_unlock(port->mgr);
1873	return ret;
1874}
1875
1876/**
1877 * drm_dp_mst_topology_get_port() - Increment the topology refcount of a port
1878 * @port: The &struct drm_dp_mst_port to increment the topology refcount of
1879 *
1880 * Increments &drm_dp_mst_port.topology_refcount without checking whether or
1881 * not it's already reached 0. This is only valid to use in scenarios where
1882 * you are already guaranteed to have at least one active topology reference
1883 * to @port. Otherwise, drm_dp_mst_topology_try_get_port() must be used.
1884 *
1885 * See also:
1886 * drm_dp_mst_topology_try_get_port()
1887 * drm_dp_mst_topology_put_port()
1888 */
1889static void drm_dp_mst_topology_get_port(struct drm_dp_mst_port *port)
1890{
1891	topology_ref_history_lock(port->mgr);
1892
1893	WARN_ON(kref_read(&port->topology_kref) == 0);
1894	kref_get(&port->topology_kref);
1895	drm_dbg(port->mgr->dev, "port %p (%d)\n", port, kref_read(&port->topology_kref));
1896	save_port_topology_ref(port, DRM_DP_MST_TOPOLOGY_REF_GET);
1897
1898	topology_ref_history_unlock(port->mgr);
1899}
1900
1901/**
1902 * drm_dp_mst_topology_put_port() - release a topology reference to a port
1903 * @port: The &struct drm_dp_mst_port to release the topology reference from
1904 *
1905 * Releases a topology reference from @port by decrementing
1906 * &drm_dp_mst_port.topology_kref.
1907 *
1908 * See also:
1909 * drm_dp_mst_topology_try_get_port()
1910 * drm_dp_mst_topology_get_port()
1911 */
1912static void drm_dp_mst_topology_put_port(struct drm_dp_mst_port *port)
1913{
1914	topology_ref_history_lock(port->mgr);
1915
1916	drm_dbg(port->mgr->dev, "port %p (%d)\n", port, kref_read(&port->topology_kref) - 1);
1917	save_port_topology_ref(port, DRM_DP_MST_TOPOLOGY_REF_PUT);
1918
1919	topology_ref_history_unlock(port->mgr);
1920	kref_put(&port->topology_kref, drm_dp_destroy_port);
1921}
1922
1923static struct drm_dp_mst_branch *
1924drm_dp_mst_topology_get_mstb_validated_locked(struct drm_dp_mst_branch *mstb,
1925					      struct drm_dp_mst_branch *to_find)
1926{
1927	struct drm_dp_mst_port *port;
1928	struct drm_dp_mst_branch *rmstb;
1929
1930	if (to_find == mstb)
1931		return mstb;
1932
1933	list_for_each_entry(port, &mstb->ports, next) {
1934		if (port->mstb) {
1935			rmstb = drm_dp_mst_topology_get_mstb_validated_locked(
1936			    port->mstb, to_find);
1937			if (rmstb)
1938				return rmstb;
1939		}
1940	}
1941	return NULL;
1942}
1943
1944static struct drm_dp_mst_branch *
1945drm_dp_mst_topology_get_mstb_validated(struct drm_dp_mst_topology_mgr *mgr,
1946				       struct drm_dp_mst_branch *mstb)
1947{
1948	struct drm_dp_mst_branch *rmstb = NULL;
1949
1950	mutex_lock(&mgr->lock);
1951	if (mgr->mst_primary) {
1952		rmstb = drm_dp_mst_topology_get_mstb_validated_locked(
1953		    mgr->mst_primary, mstb);
1954
1955		if (rmstb && !drm_dp_mst_topology_try_get_mstb(rmstb))
1956			rmstb = NULL;
1957	}
1958	mutex_unlock(&mgr->lock);
1959	return rmstb;
1960}
1961
1962static struct drm_dp_mst_port *
1963drm_dp_mst_topology_get_port_validated_locked(struct drm_dp_mst_branch *mstb,
1964					      struct drm_dp_mst_port *to_find)
1965{
1966	struct drm_dp_mst_port *port, *mport;
1967
1968	list_for_each_entry(port, &mstb->ports, next) {
1969		if (port == to_find)
1970			return port;
1971
1972		if (port->mstb) {
1973			mport = drm_dp_mst_topology_get_port_validated_locked(
1974			    port->mstb, to_find);
1975			if (mport)
1976				return mport;
1977		}
1978	}
1979	return NULL;
1980}
1981
1982static struct drm_dp_mst_port *
1983drm_dp_mst_topology_get_port_validated(struct drm_dp_mst_topology_mgr *mgr,
1984				       struct drm_dp_mst_port *port)
1985{
1986	struct drm_dp_mst_port *rport = NULL;
1987
1988	mutex_lock(&mgr->lock);
1989	if (mgr->mst_primary) {
1990		rport = drm_dp_mst_topology_get_port_validated_locked(
1991		    mgr->mst_primary, port);
1992
1993		if (rport && !drm_dp_mst_topology_try_get_port(rport))
1994			rport = NULL;
1995	}
1996	mutex_unlock(&mgr->lock);
1997	return rport;
1998}
1999
2000static struct drm_dp_mst_port *drm_dp_get_port(struct drm_dp_mst_branch *mstb, u8 port_num)
2001{
2002	struct drm_dp_mst_port *port;
2003	int ret;
2004
2005	list_for_each_entry(port, &mstb->ports, next) {
2006		if (port->port_num == port_num) {
2007			ret = drm_dp_mst_topology_try_get_port(port);
2008			return ret ? port : NULL;
2009		}
2010	}
2011
2012	return NULL;
2013}
2014
2015/*
2016 * calculate a new RAD for this MST branch device
2017 * if parent has an LCT of 2 then it has 1 nibble of RAD,
2018 * if parent has an LCT of 3 then it has 2 nibbles of RAD,
2019 */
2020static u8 drm_dp_calculate_rad(struct drm_dp_mst_port *port,
2021				 u8 *rad)
2022{
2023	int parent_lct = port->parent->lct;
2024	int shift = 4;
2025	int idx = (parent_lct - 1) / 2;
2026
2027	if (parent_lct > 1) {
2028		memcpy(rad, port->parent->rad, idx + 1);
2029		shift = (parent_lct % 2) ? 4 : 0;
2030	} else
2031		rad[0] = 0;
2032
2033	rad[idx] |= port->port_num << shift;
2034	return parent_lct + 1;
2035}
2036
2037static bool drm_dp_mst_is_end_device(u8 pdt, bool mcs)
2038{
2039	switch (pdt) {
2040	case DP_PEER_DEVICE_DP_LEGACY_CONV:
2041	case DP_PEER_DEVICE_SST_SINK:
2042		return true;
2043	case DP_PEER_DEVICE_MST_BRANCHING:
2044		/* For sst branch device */
2045		if (!mcs)
2046			return true;
2047
2048		return false;
2049	}
2050	return true;
2051}
2052
2053static int
2054drm_dp_port_set_pdt(struct drm_dp_mst_port *port, u8 new_pdt,
2055		    bool new_mcs)
2056{
2057	struct drm_dp_mst_topology_mgr *mgr = port->mgr;
2058	struct drm_dp_mst_branch *mstb;
2059	u8 rad[8], lct;
2060	int ret = 0;
2061
2062	if (port->pdt == new_pdt && port->mcs == new_mcs)
2063		return 0;
2064
2065	/* Teardown the old pdt, if there is one */
2066	if (port->pdt != DP_PEER_DEVICE_NONE) {
2067		if (drm_dp_mst_is_end_device(port->pdt, port->mcs)) {
2068			/*
2069			 * If the new PDT would also have an i2c bus,
2070			 * don't bother with reregistering it
2071			 */
2072			if (new_pdt != DP_PEER_DEVICE_NONE &&
2073			    drm_dp_mst_is_end_device(new_pdt, new_mcs)) {
2074				port->pdt = new_pdt;
2075				port->mcs = new_mcs;
2076				return 0;
2077			}
2078
2079			/* remove i2c over sideband */
2080			drm_dp_mst_unregister_i2c_bus(port);
2081		} else {
2082			mutex_lock(&mgr->lock);
2083			drm_dp_mst_topology_put_mstb(port->mstb);
2084			port->mstb = NULL;
2085			mutex_unlock(&mgr->lock);
2086		}
2087	}
2088
2089	port->pdt = new_pdt;
2090	port->mcs = new_mcs;
2091
2092	if (port->pdt != DP_PEER_DEVICE_NONE) {
2093		if (drm_dp_mst_is_end_device(port->pdt, port->mcs)) {
2094			/* add i2c over sideband */
2095			ret = drm_dp_mst_register_i2c_bus(port);
2096		} else {
2097			lct = drm_dp_calculate_rad(port, rad);
2098			mstb = drm_dp_add_mst_branch_device(lct, rad);
2099			if (!mstb) {
2100				ret = -ENOMEM;
2101				drm_err(mgr->dev, "Failed to create MSTB for port %p", port);
2102				goto out;
2103			}
2104
2105			mutex_lock(&mgr->lock);
2106			port->mstb = mstb;
2107			mstb->mgr = port->mgr;
2108			mstb->port_parent = port;
2109
2110			/*
2111			 * Make sure this port's memory allocation stays
2112			 * around until its child MSTB releases it
2113			 */
2114			drm_dp_mst_get_port_malloc(port);
2115			mutex_unlock(&mgr->lock);
2116
2117			/* And make sure we send a link address for this */
2118			ret = 1;
2119		}
2120	}
2121
2122out:
2123	if (ret < 0)
2124		port->pdt = DP_PEER_DEVICE_NONE;
2125	return ret;
2126}
2127
2128/**
2129 * drm_dp_mst_dpcd_read() - read a series of bytes from the DPCD via sideband
2130 * @aux: Fake sideband AUX CH
2131 * @offset: address of the (first) register to read
2132 * @buffer: buffer to store the register values
2133 * @size: number of bytes in @buffer
2134 *
2135 * Performs the same functionality for remote devices via
2136 * sideband messaging as drm_dp_dpcd_read() does for local
2137 * devices via actual AUX CH.
2138 *
2139 * Return: Number of bytes read, or negative error code on failure.
2140 */
2141ssize_t drm_dp_mst_dpcd_read(struct drm_dp_aux *aux,
2142			     unsigned int offset, void *buffer, size_t size)
2143{
2144	struct drm_dp_mst_port *port = container_of(aux, struct drm_dp_mst_port,
2145						    aux);
2146
2147	return drm_dp_send_dpcd_read(port->mgr, port,
2148				     offset, size, buffer);
2149}
2150
2151/**
2152 * drm_dp_mst_dpcd_write() - write a series of bytes to the DPCD via sideband
2153 * @aux: Fake sideband AUX CH
2154 * @offset: address of the (first) register to write
2155 * @buffer: buffer containing the values to write
2156 * @size: number of bytes in @buffer
2157 *
2158 * Performs the same functionality for remote devices via
2159 * sideband messaging as drm_dp_dpcd_write() does for local
2160 * devices via actual AUX CH.
2161 *
2162 * Return: number of bytes written on success, negative error code on failure.
2163 */
2164ssize_t drm_dp_mst_dpcd_write(struct drm_dp_aux *aux,
2165			      unsigned int offset, void *buffer, size_t size)
2166{
2167	struct drm_dp_mst_port *port = container_of(aux, struct drm_dp_mst_port,
2168						    aux);
2169
2170	return drm_dp_send_dpcd_write(port->mgr, port,
2171				      offset, size, buffer);
2172}
2173
2174static int drm_dp_check_mstb_guid(struct drm_dp_mst_branch *mstb, u8 *guid)
2175{
2176	int ret = 0;
2177
2178	memcpy(mstb->guid, guid, 16);
2179
2180	if (!drm_dp_validate_guid(mstb->mgr, mstb->guid)) {
2181		if (mstb->port_parent) {
2182			ret = drm_dp_send_dpcd_write(mstb->mgr,
2183						     mstb->port_parent,
2184						     DP_GUID, 16, mstb->guid);
2185		} else {
2186			ret = drm_dp_dpcd_write(mstb->mgr->aux,
2187						DP_GUID, mstb->guid, 16);
2188		}
2189	}
2190
2191	if (ret < 16 && ret > 0)
2192		return -EPROTO;
2193
2194	return ret == 16 ? 0 : ret;
2195}
2196
2197static void build_mst_prop_path(const struct drm_dp_mst_branch *mstb,
2198				int pnum,
2199				char *proppath,
2200				size_t proppath_size)
2201{
2202	int i;
2203	char temp[8];
2204
2205	snprintf(proppath, proppath_size, "mst:%d", mstb->mgr->conn_base_id);
2206	for (i = 0; i < (mstb->lct - 1); i++) {
2207		int shift = (i % 2) ? 0 : 4;
2208		int port_num = (mstb->rad[i / 2] >> shift) & 0xf;
2209
2210		snprintf(temp, sizeof(temp), "-%d", port_num);
2211		strlcat(proppath, temp, proppath_size);
2212	}
2213	snprintf(temp, sizeof(temp), "-%d", pnum);
2214	strlcat(proppath, temp, proppath_size);
2215}
2216
2217/**
2218 * drm_dp_mst_connector_late_register() - Late MST connector registration
2219 * @connector: The MST connector
2220 * @port: The MST port for this connector
2221 *
2222 * Helper to register the remote aux device for this MST port. Drivers should
2223 * call this from their mst connector's late_register hook to enable MST aux
2224 * devices.
2225 *
2226 * Return: 0 on success, negative error code on failure.
2227 */
2228int drm_dp_mst_connector_late_register(struct drm_connector *connector,
2229				       struct drm_dp_mst_port *port)
2230{
2231	drm_dbg_kms(port->mgr->dev, "registering %s remote bus for %s\n",
2232		    port->aux.name, connector->kdev->kobj.name);
2233
2234	port->aux.dev = connector->kdev;
2235	return drm_dp_aux_register_devnode(&port->aux);
2236}
2237EXPORT_SYMBOL(drm_dp_mst_connector_late_register);
2238
2239/**
2240 * drm_dp_mst_connector_early_unregister() - Early MST connector unregistration
2241 * @connector: The MST connector
2242 * @port: The MST port for this connector
2243 *
2244 * Helper to unregister the remote aux device for this MST port, registered by
2245 * drm_dp_mst_connector_late_register(). Drivers should call this from their mst
2246 * connector's early_unregister hook.
2247 */
2248void drm_dp_mst_connector_early_unregister(struct drm_connector *connector,
2249					   struct drm_dp_mst_port *port)
2250{
2251	drm_dbg_kms(port->mgr->dev, "unregistering %s remote bus for %s\n",
2252		    port->aux.name, connector->kdev->kobj.name);
2253	drm_dp_aux_unregister_devnode(&port->aux);
2254}
2255EXPORT_SYMBOL(drm_dp_mst_connector_early_unregister);
2256
2257static void
2258drm_dp_mst_port_add_connector(struct drm_dp_mst_branch *mstb,
2259			      struct drm_dp_mst_port *port)
2260{
2261	struct drm_dp_mst_topology_mgr *mgr = port->mgr;
2262	char proppath[255];
2263	int ret;
2264
2265	build_mst_prop_path(mstb, port->port_num, proppath, sizeof(proppath));
2266	port->connector = mgr->cbs->add_connector(mgr, port, proppath);
2267	if (!port->connector) {
2268		ret = -ENOMEM;
2269		goto error;
2270	}
2271
2272	if (port->pdt != DP_PEER_DEVICE_NONE &&
2273	    drm_dp_mst_is_end_device(port->pdt, port->mcs) &&
2274	    port->port_num >= DP_MST_LOGICAL_PORT_0)
2275		port->cached_edid = drm_get_edid(port->connector,
2276						 &port->aux.ddc);
2277
2278	drm_connector_register(port->connector);
2279	return;
2280
2281error:
2282	drm_err(mgr->dev, "Failed to create connector for port %p: %d\n", port, ret);
2283}
2284
2285/*
2286 * Drop a topology reference, and unlink the port from the in-memory topology
2287 * layout
2288 */
2289static void
2290drm_dp_mst_topology_unlink_port(struct drm_dp_mst_topology_mgr *mgr,
2291				struct drm_dp_mst_port *port)
2292{
2293	mutex_lock(&mgr->lock);
2294	port->parent->num_ports--;
2295	list_del(&port->next);
2296	mutex_unlock(&mgr->lock);
2297	drm_dp_mst_topology_put_port(port);
2298}
2299
2300static struct drm_dp_mst_port *
2301drm_dp_mst_add_port(struct drm_device *dev,
2302		    struct drm_dp_mst_topology_mgr *mgr,
2303		    struct drm_dp_mst_branch *mstb, u8 port_number)
2304{
2305	struct drm_dp_mst_port *port = kzalloc(sizeof(*port), GFP_KERNEL);
2306
2307	if (!port)
2308		return NULL;
2309
2310	kref_init(&port->topology_kref);
2311	kref_init(&port->malloc_kref);
2312	port->parent = mstb;
2313	port->port_num = port_number;
2314	port->mgr = mgr;
2315	port->aux.name = "DPMST";
2316	port->aux.dev = dev->dev;
2317	port->aux.is_remote = true;
2318
2319	/* initialize the MST downstream port's AUX crc work queue */
2320	port->aux.drm_dev = dev;
2321	drm_dp_remote_aux_init(&port->aux);
2322
2323	/*
2324	 * Make sure the memory allocation for our parent branch stays
2325	 * around until our own memory allocation is released
2326	 */
2327	drm_dp_mst_get_mstb_malloc(mstb);
2328
2329	return port;
2330}
2331
2332static int
2333drm_dp_mst_handle_link_address_port(struct drm_dp_mst_branch *mstb,
2334				    struct drm_device *dev,
2335				    struct drm_dp_link_addr_reply_port *port_msg)
2336{
2337	struct drm_dp_mst_topology_mgr *mgr = mstb->mgr;
2338	struct drm_dp_mst_port *port;
2339	int old_ddps = 0, ret;
2340	u8 new_pdt = DP_PEER_DEVICE_NONE;
2341	bool new_mcs = 0;
2342	bool created = false, send_link_addr = false, changed = false;
2343
2344	port = drm_dp_get_port(mstb, port_msg->port_number);
2345	if (!port) {
2346		port = drm_dp_mst_add_port(dev, mgr, mstb,
2347					   port_msg->port_number);
2348		if (!port)
2349			return -ENOMEM;
2350		created = true;
2351		changed = true;
2352	} else if (!port->input && port_msg->input_port && port->connector) {
2353		/* Since port->connector can't be changed here, we create a
2354		 * new port if input_port changes from 0 to 1
2355		 */
2356		drm_dp_mst_topology_unlink_port(mgr, port);
2357		drm_dp_mst_topology_put_port(port);
2358		port = drm_dp_mst_add_port(dev, mgr, mstb,
2359					   port_msg->port_number);
2360		if (!port)
2361			return -ENOMEM;
2362		changed = true;
2363		created = true;
2364	} else if (port->input && !port_msg->input_port) {
2365		changed = true;
2366	} else if (port->connector) {
2367		/* We're updating a port that's exposed to userspace, so do it
2368		 * under lock
2369		 */
2370		drm_modeset_lock(&mgr->base.lock, NULL);
2371
2372		old_ddps = port->ddps;
2373		changed = port->ddps != port_msg->ddps ||
2374			(port->ddps &&
2375			 (port->ldps != port_msg->legacy_device_plug_status ||
2376			  port->dpcd_rev != port_msg->dpcd_revision ||
2377			  port->mcs != port_msg->mcs ||
2378			  port->pdt != port_msg->peer_device_type ||
2379			  port->num_sdp_stream_sinks !=
2380			  port_msg->num_sdp_stream_sinks));
2381	}
2382
2383	port->input = port_msg->input_port;
2384	if (!port->input)
2385		new_pdt = port_msg->peer_device_type;
2386	new_mcs = port_msg->mcs;
2387	port->ddps = port_msg->ddps;
2388	port->ldps = port_msg->legacy_device_plug_status;
2389	port->dpcd_rev = port_msg->dpcd_revision;
2390	port->num_sdp_streams = port_msg->num_sdp_streams;
2391	port->num_sdp_stream_sinks = port_msg->num_sdp_stream_sinks;
2392
2393	/* manage mstb port lists with mgr lock - take a reference
2394	   for this list */
2395	if (created) {
2396		mutex_lock(&mgr->lock);
2397		drm_dp_mst_topology_get_port(port);
2398		list_add(&port->next, &mstb->ports);
2399		mstb->num_ports++;
2400		mutex_unlock(&mgr->lock);
2401	}
2402
2403	/*
2404	 * Reprobe PBN caps on both hotplug, and when re-probing the link
2405	 * for our parent mstb
2406	 */
2407	if (old_ddps != port->ddps || !created) {
2408		if (port->ddps && !port->input) {
2409			ret = drm_dp_send_enum_path_resources(mgr, mstb,
2410							      port);
2411			if (ret == 1)
2412				changed = true;
2413		} else {
2414			port->full_pbn = 0;
2415		}
2416	}
2417
2418	ret = drm_dp_port_set_pdt(port, new_pdt, new_mcs);
2419	if (ret == 1) {
2420		send_link_addr = true;
2421	} else if (ret < 0) {
2422		drm_err(dev, "Failed to change PDT on port %p: %d\n", port, ret);
2423		goto fail;
2424	}
2425
2426	/*
2427	 * If this port wasn't just created, then we're reprobing because
2428	 * we're coming out of suspend. In this case, always resend the link
2429	 * address if there's an MSTB on this port
2430	 */
2431	if (!created && port->pdt == DP_PEER_DEVICE_MST_BRANCHING &&
2432	    port->mcs)
2433		send_link_addr = true;
2434
2435	if (port->connector)
2436		drm_modeset_unlock(&mgr->base.lock);
2437	else if (!port->input)
2438		drm_dp_mst_port_add_connector(mstb, port);
2439
2440	if (send_link_addr && port->mstb) {
2441		ret = drm_dp_send_link_address(mgr, port->mstb);
2442		if (ret == 1) /* MSTB below us changed */
2443			changed = true;
2444		else if (ret < 0)
2445			goto fail_put;
2446	}
2447
2448	/* put reference to this port */
2449	drm_dp_mst_topology_put_port(port);
2450	return changed;
2451
2452fail:
2453	drm_dp_mst_topology_unlink_port(mgr, port);
2454	if (port->connector)
2455		drm_modeset_unlock(&mgr->base.lock);
2456fail_put:
2457	drm_dp_mst_topology_put_port(port);
2458	return ret;
2459}
2460
2461static int
2462drm_dp_mst_handle_conn_stat(struct drm_dp_mst_branch *mstb,
2463			    struct drm_dp_connection_status_notify *conn_stat)
2464{
2465	struct drm_dp_mst_topology_mgr *mgr = mstb->mgr;
2466	struct drm_dp_mst_port *port;
2467	int old_ddps, ret;
2468	u8 new_pdt;
2469	bool new_mcs;
2470	bool dowork = false, create_connector = false;
2471
2472	port = drm_dp_get_port(mstb, conn_stat->port_number);
2473	if (!port)
2474		return 0;
2475
2476	if (port->connector) {
2477		if (!port->input && conn_stat->input_port) {
2478			/*
2479			 * We can't remove a connector from an already exposed
2480			 * port, so just throw the port out and make sure we
2481			 * reprobe the link address of it's parent MSTB
2482			 */
2483			drm_dp_mst_topology_unlink_port(mgr, port);
2484			mstb->link_address_sent = false;
2485			dowork = true;
2486			goto out;
2487		}
2488
2489		/* Locking is only needed if the port's exposed to userspace */
2490		drm_modeset_lock(&mgr->base.lock, NULL);
2491	} else if (port->input && !conn_stat->input_port) {
2492		create_connector = true;
2493		/* Reprobe link address so we get num_sdp_streams */
2494		mstb->link_address_sent = false;
2495		dowork = true;
2496	}
2497
2498	old_ddps = port->ddps;
2499	port->input = conn_stat->input_port;
2500	port->ldps = conn_stat->legacy_device_plug_status;
2501	port->ddps = conn_stat->displayport_device_plug_status;
2502
2503	if (old_ddps != port->ddps) {
2504		if (port->ddps && !port->input)
2505			drm_dp_send_enum_path_resources(mgr, mstb, port);
2506		else
2507			port->full_pbn = 0;
2508	}
2509
2510	new_pdt = port->input ? DP_PEER_DEVICE_NONE : conn_stat->peer_device_type;
2511	new_mcs = conn_stat->message_capability_status;
2512	ret = drm_dp_port_set_pdt(port, new_pdt, new_mcs);
2513	if (ret == 1) {
2514		dowork = true;
2515	} else if (ret < 0) {
2516		drm_err(mgr->dev, "Failed to change PDT for port %p: %d\n", port, ret);
2517		dowork = false;
2518	}
2519
2520	if (port->connector)
2521		drm_modeset_unlock(&mgr->base.lock);
2522	else if (create_connector)
2523		drm_dp_mst_port_add_connector(mstb, port);
2524
2525out:
2526	drm_dp_mst_topology_put_port(port);
2527	return dowork;
2528}
2529
2530static struct drm_dp_mst_branch *drm_dp_get_mst_branch_device(struct drm_dp_mst_topology_mgr *mgr,
2531							       u8 lct, u8 *rad)
2532{
2533	struct drm_dp_mst_branch *mstb;
2534	struct drm_dp_mst_port *port;
2535	int i, ret;
2536	/* find the port by iterating down */
2537
2538	mutex_lock(&mgr->lock);
2539	mstb = mgr->mst_primary;
2540
2541	if (!mstb)
2542		goto out;
2543
2544	for (i = 0; i < lct - 1; i++) {
2545		int shift = (i % 2) ? 0 : 4;
2546		int port_num = (rad[i / 2] >> shift) & 0xf;
2547
2548		list_for_each_entry(port, &mstb->ports, next) {
2549			if (port->port_num == port_num) {
2550				mstb = port->mstb;
2551				if (!mstb) {
2552					drm_err(mgr->dev,
2553						"failed to lookup MSTB with lct %d, rad %02x\n",
2554						lct, rad[0]);
2555					goto out;
2556				}
2557
2558				break;
2559			}
2560		}
2561	}
2562	ret = drm_dp_mst_topology_try_get_mstb(mstb);
2563	if (!ret)
2564		mstb = NULL;
2565out:
2566	mutex_unlock(&mgr->lock);
2567	return mstb;
2568}
2569
2570static struct drm_dp_mst_branch *get_mst_branch_device_by_guid_helper(
2571	struct drm_dp_mst_branch *mstb,
2572	const uint8_t *guid)
2573{
2574	struct drm_dp_mst_branch *found_mstb;
2575	struct drm_dp_mst_port *port;
2576
2577	if (memcmp(mstb->guid, guid, 16) == 0)
2578		return mstb;
2579
2580
2581	list_for_each_entry(port, &mstb->ports, next) {
2582		if (!port->mstb)
2583			continue;
2584
2585		found_mstb = get_mst_branch_device_by_guid_helper(port->mstb, guid);
2586
2587		if (found_mstb)
2588			return found_mstb;
2589	}
2590
2591	return NULL;
2592}
2593
2594static struct drm_dp_mst_branch *
2595drm_dp_get_mst_branch_device_by_guid(struct drm_dp_mst_topology_mgr *mgr,
2596				     const uint8_t *guid)
2597{
2598	struct drm_dp_mst_branch *mstb;
2599	int ret;
2600
2601	/* find the port by iterating down */
2602	mutex_lock(&mgr->lock);
2603
2604	mstb = get_mst_branch_device_by_guid_helper(mgr->mst_primary, guid);
2605	if (mstb) {
2606		ret = drm_dp_mst_topology_try_get_mstb(mstb);
2607		if (!ret)
2608			mstb = NULL;
2609	}
2610
2611	mutex_unlock(&mgr->lock);
2612	return mstb;
2613}
2614
2615static int drm_dp_check_and_send_link_address(struct drm_dp_mst_topology_mgr *mgr,
2616					       struct drm_dp_mst_branch *mstb)
2617{
2618	struct drm_dp_mst_port *port;
2619	int ret;
2620	bool changed = false;
2621
2622	if (!mstb->link_address_sent) {
2623		ret = drm_dp_send_link_address(mgr, mstb);
2624		if (ret == 1)
2625			changed = true;
2626		else if (ret < 0)
2627			return ret;
2628	}
2629
2630	list_for_each_entry(port, &mstb->ports, next) {
2631		if (port->input || !port->ddps || !port->mstb)
2632			continue;
2633
2634		ret = drm_dp_check_and_send_link_address(mgr, port->mstb);
2635		if (ret == 1)
2636			changed = true;
2637		else if (ret < 0)
2638			return ret;
2639	}
2640
2641	return changed;
2642}
2643
2644static void drm_dp_mst_link_probe_work(struct work_struct *work)
2645{
2646	struct drm_dp_mst_topology_mgr *mgr =
2647		container_of(work, struct drm_dp_mst_topology_mgr, work);
2648	struct drm_device *dev = mgr->dev;
2649	struct drm_dp_mst_branch *mstb;
2650	int ret;
2651	bool clear_payload_id_table;
2652
2653	mutex_lock(&mgr->probe_lock);
2654
2655	mutex_lock(&mgr->lock);
2656	clear_payload_id_table = !mgr->payload_id_table_cleared;
2657	mgr->payload_id_table_cleared = true;
2658
2659	mstb = mgr->mst_primary;
2660	if (mstb) {
2661		ret = drm_dp_mst_topology_try_get_mstb(mstb);
2662		if (!ret)
2663			mstb = NULL;
2664	}
2665	mutex_unlock(&mgr->lock);
2666	if (!mstb) {
2667		mutex_unlock(&mgr->probe_lock);
2668		return;
2669	}
2670
2671	/*
2672	 * Certain branch devices seem to incorrectly report an available_pbn
2673	 * of 0 on downstream sinks, even after clearing the
2674	 * DP_PAYLOAD_ALLOCATE_* registers in
2675	 * drm_dp_mst_topology_mgr_set_mst(). Namely, the CableMatters USB-C
2676	 * 2x DP hub. Sending a CLEAR_PAYLOAD_ID_TABLE message seems to make
2677	 * things work again.
2678	 */
2679	if (clear_payload_id_table) {
2680		drm_dbg_kms(dev, "Clearing payload ID table\n");
2681		drm_dp_send_clear_payload_id_table(mgr, mstb);
2682	}
2683
2684	ret = drm_dp_check_and_send_link_address(mgr, mstb);
2685	drm_dp_mst_topology_put_mstb(mstb);
2686
2687	mutex_unlock(&mgr->probe_lock);
2688	if (ret > 0)
2689		drm_kms_helper_hotplug_event(dev);
2690}
2691
2692static bool drm_dp_validate_guid(struct drm_dp_mst_topology_mgr *mgr,
2693				 u8 *guid)
2694{
2695	u64 salt;
2696
2697	if (memchr_inv(guid, 0, 16))
2698		return true;
2699
2700	salt = get_jiffies_64();
2701
2702	memcpy(&guid[0], &salt, sizeof(u64));
2703	memcpy(&guid[8], &salt, sizeof(u64));
2704
2705	return false;
2706}
2707
2708static void build_dpcd_read(struct drm_dp_sideband_msg_tx *msg,
2709			    u8 port_num, u32 offset, u8 num_bytes)
2710{
2711	struct drm_dp_sideband_msg_req_body req;
2712
2713	req.req_type = DP_REMOTE_DPCD_READ;
2714	req.u.dpcd_read.port_number = port_num;
2715	req.u.dpcd_read.dpcd_address = offset;
2716	req.u.dpcd_read.num_bytes = num_bytes;
2717	drm_dp_encode_sideband_req(&req, msg);
2718}
2719
2720static int drm_dp_send_sideband_msg(struct drm_dp_mst_topology_mgr *mgr,
2721				    bool up, u8 *msg, int len)
2722{
2723	int ret;
2724	int regbase = up ? DP_SIDEBAND_MSG_UP_REP_BASE : DP_SIDEBAND_MSG_DOWN_REQ_BASE;
2725	int tosend, total, offset;
2726	int retries = 0;
2727
2728retry:
2729	total = len;
2730	offset = 0;
2731	do {
2732		tosend = min3(mgr->max_dpcd_transaction_bytes, 16, total);
2733
2734		ret = drm_dp_dpcd_write(mgr->aux, regbase + offset,
2735					&msg[offset],
2736					tosend);
2737		if (ret != tosend) {
2738			if (ret == -EIO && retries < 5) {
2739				retries++;
2740				goto retry;
2741			}
2742			drm_dbg_kms(mgr->dev, "failed to dpcd write %d %d\n", tosend, ret);
2743
2744			return -EIO;
2745		}
2746		offset += tosend;
2747		total -= tosend;
2748	} while (total > 0);
2749	return 0;
2750}
2751
2752static int set_hdr_from_dst_qlock(struct drm_dp_sideband_msg_hdr *hdr,
2753				  struct drm_dp_sideband_msg_tx *txmsg)
2754{
2755	struct drm_dp_mst_branch *mstb = txmsg->dst;
2756	u8 req_type;
2757
2758	req_type = txmsg->msg[0] & 0x7f;
2759	if (req_type == DP_CONNECTION_STATUS_NOTIFY ||
2760		req_type == DP_RESOURCE_STATUS_NOTIFY ||
2761		req_type == DP_CLEAR_PAYLOAD_ID_TABLE)
2762		hdr->broadcast = 1;
2763	else
2764		hdr->broadcast = 0;
2765	hdr->path_msg = txmsg->path_msg;
2766	if (hdr->broadcast) {
2767		hdr->lct = 1;
2768		hdr->lcr = 6;
2769	} else {
2770		hdr->lct = mstb->lct;
2771		hdr->lcr = mstb->lct - 1;
2772	}
2773
2774	memcpy(hdr->rad, mstb->rad, hdr->lct / 2);
2775
2776	return 0;
2777}
2778/*
2779 * process a single block of the next message in the sideband queue
2780 */
2781static int process_single_tx_qlock(struct drm_dp_mst_topology_mgr *mgr,
2782				   struct drm_dp_sideband_msg_tx *txmsg,
2783				   bool up)
2784{
2785	u8 chunk[48];
2786	struct drm_dp_sideband_msg_hdr hdr;
2787	int len, space, idx, tosend;
2788	int ret;
2789
2790	if (txmsg->state == DRM_DP_SIDEBAND_TX_SENT)
2791		return 0;
2792
2793	memset(&hdr, 0, sizeof(struct drm_dp_sideband_msg_hdr));
2794
2795	if (txmsg->state == DRM_DP_SIDEBAND_TX_QUEUED)
2796		txmsg->state = DRM_DP_SIDEBAND_TX_START_SEND;
2797
2798	/* make hdr from dst mst */
2799	ret = set_hdr_from_dst_qlock(&hdr, txmsg);
2800	if (ret < 0)
2801		return ret;
2802
2803	/* amount left to send in this message */
2804	len = txmsg->cur_len - txmsg->cur_offset;
2805
2806	/* 48 - sideband msg size - 1 byte for data CRC, x header bytes */
2807	space = 48 - 1 - drm_dp_calc_sb_hdr_size(&hdr);
2808
2809	tosend = min(len, space);
2810	if (len == txmsg->cur_len)
2811		hdr.somt = 1;
2812	if (space >= len)
2813		hdr.eomt = 1;
2814
2815
2816	hdr.msg_len = tosend + 1;
2817	drm_dp_encode_sideband_msg_hdr(&hdr, chunk, &idx);
2818	memcpy(&chunk[idx], &txmsg->msg[txmsg->cur_offset], tosend);
2819	/* add crc at end */
2820	drm_dp_crc_sideband_chunk_req(&chunk[idx], tosend);
2821	idx += tosend + 1;
2822
2823	ret = drm_dp_send_sideband_msg(mgr, up, chunk, idx);
2824	if (ret) {
2825		if (drm_debug_enabled(DRM_UT_DP)) {
2826			struct drm_printer p = drm_debug_printer(DBG_PREFIX);
2827
2828			drm_printf(&p, "sideband msg failed to send\n");
2829			drm_dp_mst_dump_sideband_msg_tx(&p, txmsg);
2830		}
2831		return ret;
2832	}
2833
2834	txmsg->cur_offset += tosend;
2835	if (txmsg->cur_offset == txmsg->cur_len) {
2836		txmsg->state = DRM_DP_SIDEBAND_TX_SENT;
2837		return 1;
2838	}
2839	return 0;
2840}
2841
2842static void process_single_down_tx_qlock(struct drm_dp_mst_topology_mgr *mgr)
2843{
2844	struct drm_dp_sideband_msg_tx *txmsg;
2845	int ret;
2846
2847	WARN_ON(!mutex_is_locked(&mgr->qlock));
2848
2849	/* construct a chunk from the first msg in the tx_msg queue */
2850	if (list_empty(&mgr->tx_msg_downq))
2851		return;
2852
2853	txmsg = list_first_entry(&mgr->tx_msg_downq,
2854				 struct drm_dp_sideband_msg_tx, next);
2855	ret = process_single_tx_qlock(mgr, txmsg, false);
2856	if (ret < 0) {
2857		drm_dbg_kms(mgr->dev, "failed to send msg in q %d\n", ret);
2858		list_del(&txmsg->next);
2859		txmsg->state = DRM_DP_SIDEBAND_TX_TIMEOUT;
2860		wake_up_all(&mgr->tx_waitq);
2861	}
2862}
2863
2864static void drm_dp_queue_down_tx(struct drm_dp_mst_topology_mgr *mgr,
2865				 struct drm_dp_sideband_msg_tx *txmsg)
2866{
2867	mutex_lock(&mgr->qlock);
2868	list_add_tail(&txmsg->next, &mgr->tx_msg_downq);
2869
2870	if (drm_debug_enabled(DRM_UT_DP)) {
2871		struct drm_printer p = drm_debug_printer(DBG_PREFIX);
2872
2873		drm_dp_mst_dump_sideband_msg_tx(&p, txmsg);
2874	}
2875
2876	if (list_is_singular(&mgr->tx_msg_downq))
2877		process_single_down_tx_qlock(mgr);
2878	mutex_unlock(&mgr->qlock);
2879}
2880
2881static void
2882drm_dp_dump_link_address(const struct drm_dp_mst_topology_mgr *mgr,
2883			 struct drm_dp_link_address_ack_reply *reply)
2884{
2885	struct drm_dp_link_addr_reply_port *port_reply;
2886	int i;
2887
2888	for (i = 0; i < reply->nports; i++) {
2889		port_reply = &reply->ports[i];
2890		drm_dbg_kms(mgr->dev,
2891			    "port %d: input %d, pdt: %d, pn: %d, dpcd_rev: %02x, mcs: %d, ddps: %d, ldps %d, sdp %d/%d\n",
2892			    i,
2893			    port_reply->input_port,
2894			    port_reply->peer_device_type,
2895			    port_reply->port_number,
2896			    port_reply->dpcd_revision,
2897			    port_reply->mcs,
2898			    port_reply->ddps,
2899			    port_reply->legacy_device_plug_status,
2900			    port_reply->num_sdp_streams,
2901			    port_reply->num_sdp_stream_sinks);
2902	}
2903}
2904
2905static int drm_dp_send_link_address(struct drm_dp_mst_topology_mgr *mgr,
2906				     struct drm_dp_mst_branch *mstb)
2907{
2908	struct drm_dp_sideband_msg_tx *txmsg;
2909	struct drm_dp_link_address_ack_reply *reply;
2910	struct drm_dp_mst_port *port, *tmp;
2911	int i, ret, port_mask = 0;
2912	bool changed = false;
2913
2914	txmsg = kzalloc(sizeof(*txmsg), GFP_KERNEL);
2915	if (!txmsg)
2916		return -ENOMEM;
2917
2918	txmsg->dst = mstb;
2919	build_link_address(txmsg);
2920
2921	mstb->link_address_sent = true;
2922	drm_dp_queue_down_tx(mgr, txmsg);
2923
2924	/* FIXME: Actually do some real error handling here */
2925	ret = drm_dp_mst_wait_tx_reply(mstb, txmsg);
2926	if (ret <= 0) {
2927		drm_err(mgr->dev, "Sending link address failed with %d\n", ret);
2928		goto out;
2929	}
2930	if (txmsg->reply.reply_type == DP_SIDEBAND_REPLY_NAK) {
2931		drm_err(mgr->dev, "link address NAK received\n");
2932		ret = -EIO;
2933		goto out;
2934	}
2935
2936	reply = &txmsg->reply.u.link_addr;
2937	drm_dbg_kms(mgr->dev, "link address reply: %d\n", reply->nports);
2938	drm_dp_dump_link_address(mgr, reply);
2939
2940	ret = drm_dp_check_mstb_guid(mstb, reply->guid);
2941	if (ret) {
2942		char buf[64];
2943
2944		drm_dp_mst_rad_to_str(mstb->rad, mstb->lct, buf, sizeof(buf));
2945		drm_err(mgr->dev, "GUID check on %s failed: %d\n", buf, ret);
2946		goto out;
2947	}
2948
2949	for (i = 0; i < reply->nports; i++) {
2950		port_mask |= BIT(reply->ports[i].port_number);
2951		ret = drm_dp_mst_handle_link_address_port(mstb, mgr->dev,
2952							  &reply->ports[i]);
2953		if (ret == 1)
2954			changed = true;
2955		else if (ret < 0)
2956			goto out;
2957	}
2958
2959	/* Prune any ports that are currently a part of mstb in our in-memory
2960	 * topology, but were not seen in this link address. Usually this
2961	 * means that they were removed while the topology was out of sync,
2962	 * e.g. during suspend/resume
2963	 */
2964	mutex_lock(&mgr->lock);
2965	list_for_each_entry_safe(port, tmp, &mstb->ports, next) {
2966		if (port_mask & BIT(port->port_num))
2967			continue;
2968
2969		drm_dbg_kms(mgr->dev, "port %d was not in link address, removing\n",
2970			    port->port_num);
2971		list_del(&port->next);
2972		drm_dp_mst_topology_put_port(port);
2973		changed = true;
2974	}
2975	mutex_unlock(&mgr->lock);
2976
2977out:
2978	if (ret <= 0)
2979		mstb->link_address_sent = false;
2980	kfree(txmsg);
2981	return ret < 0 ? ret : changed;
2982}
2983
2984static void
2985drm_dp_send_clear_payload_id_table(struct drm_dp_mst_topology_mgr *mgr,
2986				   struct drm_dp_mst_branch *mstb)
2987{
2988	struct drm_dp_sideband_msg_tx *txmsg;
2989	int ret;
2990
2991	txmsg = kzalloc(sizeof(*txmsg), GFP_KERNEL);
2992	if (!txmsg)
2993		return;
2994
2995	txmsg->dst = mstb;
2996	build_clear_payload_id_table(txmsg);
2997
2998	drm_dp_queue_down_tx(mgr, txmsg);
2999
3000	ret = drm_dp_mst_wait_tx_reply(mstb, txmsg);
3001	if (ret > 0 && txmsg->reply.reply_type == DP_SIDEBAND_REPLY_NAK)
3002		drm_dbg_kms(mgr->dev, "clear payload table id nak received\n");
3003
3004	kfree(txmsg);
3005}
3006
3007static int
3008drm_dp_send_enum_path_resources(struct drm_dp_mst_topology_mgr *mgr,
3009				struct drm_dp_mst_branch *mstb,
3010				struct drm_dp_mst_port *port)
3011{
3012	struct drm_dp_enum_path_resources_ack_reply *path_res;
3013	struct drm_dp_sideband_msg_tx *txmsg;
3014	int ret;
3015
3016	txmsg = kzalloc(sizeof(*txmsg), GFP_KERNEL);
3017	if (!txmsg)
3018		return -ENOMEM;
3019
3020	txmsg->dst = mstb;
3021	build_enum_path_resources(txmsg, port->port_num);
3022
3023	drm_dp_queue_down_tx(mgr, txmsg);
3024
3025	ret = drm_dp_mst_wait_tx_reply(mstb, txmsg);
3026	if (ret > 0) {
3027		ret = 0;
3028		path_res = &txmsg->reply.u.path_resources;
3029
3030		if (txmsg->reply.reply_type == DP_SIDEBAND_REPLY_NAK) {
3031			drm_dbg_kms(mgr->dev, "enum path resources nak received\n");
3032		} else {
3033			if (port->port_num != path_res->port_number)
3034				DRM_ERROR("got incorrect port in response\n");
3035
3036			drm_dbg_kms(mgr->dev, "enum path resources %d: %d %d\n",
3037				    path_res->port_number,
3038				    path_res->full_payload_bw_number,
3039				    path_res->avail_payload_bw_number);
3040
3041			/*
3042			 * If something changed, make sure we send a
3043			 * hotplug
3044			 */
3045			if (port->full_pbn != path_res->full_payload_bw_number ||
3046			    port->fec_capable != path_res->fec_capable)
3047				ret = 1;
3048
3049			port->full_pbn = path_res->full_payload_bw_number;
3050			port->fec_capable = path_res->fec_capable;
3051		}
3052	}
3053
3054	kfree(txmsg);
3055	return ret;
3056}
3057
3058static struct drm_dp_mst_port *drm_dp_get_last_connected_port_to_mstb(struct drm_dp_mst_branch *mstb)
3059{
3060	if (!mstb->port_parent)
3061		return NULL;
3062
3063	if (mstb->port_parent->mstb != mstb)
3064		return mstb->port_parent;
3065
3066	return drm_dp_get_last_connected_port_to_mstb(mstb->port_parent->parent);
3067}
3068
3069/*
3070 * Searches upwards in the topology starting from mstb to try to find the
3071 * closest available parent of mstb that's still connected to the rest of the
3072 * topology. This can be used in order to perform operations like releasing
3073 * payloads, where the branch device which owned the payload may no longer be
3074 * around and thus would require that the payload on the last living relative
3075 * be freed instead.
3076 */
3077static struct drm_dp_mst_branch *
3078drm_dp_get_last_connected_port_and_mstb(struct drm_dp_mst_topology_mgr *mgr,
3079					struct drm_dp_mst_branch *mstb,
3080					int *port_num)
3081{
3082	struct drm_dp_mst_branch *rmstb = NULL;
3083	struct drm_dp_mst_port *found_port;
3084
3085	mutex_lock(&mgr->lock);
3086	if (!mgr->mst_primary)
3087		goto out;
3088
3089	do {
3090		found_port = drm_dp_get_last_connected_port_to_mstb(mstb);
3091		if (!found_port)
3092			break;
3093
3094		if (drm_dp_mst_topology_try_get_mstb(found_port->parent)) {
3095			rmstb = found_port->parent;
3096			*port_num = found_port->port_num;
3097		} else {
3098			/* Search again, starting from this parent */
3099			mstb = found_port->parent;
3100		}
3101	} while (!rmstb);
3102out:
3103	mutex_unlock(&mgr->lock);
3104	return rmstb;
3105}
3106
3107static int drm_dp_payload_send_msg(struct drm_dp_mst_topology_mgr *mgr,
3108				   struct drm_dp_mst_port *port,
3109				   int id,
3110				   int pbn)
3111{
3112	struct drm_dp_sideband_msg_tx *txmsg;
3113	struct drm_dp_mst_branch *mstb;
3114	int ret, port_num;
3115	u8 sinks[DRM_DP_MAX_SDP_STREAMS];
3116	int i;
3117
3118	port_num = port->port_num;
3119	mstb = drm_dp_mst_topology_get_mstb_validated(mgr, port->parent);
3120	if (!mstb) {
3121		mstb = drm_dp_get_last_connected_port_and_mstb(mgr,
3122							       port->parent,
3123							       &port_num);
3124
3125		if (!mstb)
3126			return -EINVAL;
3127	}
3128
3129	txmsg = kzalloc(sizeof(*txmsg), GFP_KERNEL);
3130	if (!txmsg) {
3131		ret = -ENOMEM;
3132		goto fail_put;
3133	}
3134
3135	for (i = 0; i < port->num_sdp_streams; i++)
3136		sinks[i] = i;
3137
3138	txmsg->dst = mstb;
3139	build_allocate_payload(txmsg, port_num,
3140			       id,
3141			       pbn, port->num_sdp_streams, sinks);
3142
3143	drm_dp_queue_down_tx(mgr, txmsg);
3144
3145	/*
3146	 * FIXME: there is a small chance that between getting the last
3147	 * connected mstb and sending the payload message, the last connected
3148	 * mstb could also be removed from the topology. In the future, this
3149	 * needs to be fixed by restarting the
3150	 * drm_dp_get_last_connected_port_and_mstb() search in the event of a
3151	 * timeout if the topology is still connected to the system.
3152	 */
3153	ret = drm_dp_mst_wait_tx_reply(mstb, txmsg);
3154	if (ret > 0) {
3155		if (txmsg->reply.reply_type == DP_SIDEBAND_REPLY_NAK)
3156			ret = -EINVAL;
3157		else
3158			ret = 0;
3159	}
3160	kfree(txmsg);
3161fail_put:
3162	drm_dp_mst_topology_put_mstb(mstb);
3163	return ret;
3164}
3165
3166int drm_dp_send_power_updown_phy(struct drm_dp_mst_topology_mgr *mgr,
3167				 struct drm_dp_mst_port *port, bool power_up)
3168{
3169	struct drm_dp_sideband_msg_tx *txmsg;
3170	int ret;
3171
3172	port = drm_dp_mst_topology_get_port_validated(mgr, port);
3173	if (!port)
3174		return -EINVAL;
3175
3176	txmsg = kzalloc(sizeof(*txmsg), GFP_KERNEL);
3177	if (!txmsg) {
3178		drm_dp_mst_topology_put_port(port);
3179		return -ENOMEM;
3180	}
3181
3182	txmsg->dst = port->parent;
3183	build_power_updown_phy(txmsg, port->port_num, power_up);
3184	drm_dp_queue_down_tx(mgr, txmsg);
3185
3186	ret = drm_dp_mst_wait_tx_reply(port->parent, txmsg);
3187	if (ret > 0) {
3188		if (txmsg->reply.reply_type == DP_SIDEBAND_REPLY_NAK)
3189			ret = -EINVAL;
3190		else
3191			ret = 0;
3192	}
3193	kfree(txmsg);
3194	drm_dp_mst_topology_put_port(port);
3195
3196	return ret;
3197}
3198EXPORT_SYMBOL(drm_dp_send_power_updown_phy);
3199
3200int drm_dp_send_query_stream_enc_status(struct drm_dp_mst_topology_mgr *mgr,
3201		struct drm_dp_mst_port *port,
3202		struct drm_dp_query_stream_enc_status_ack_reply *status)
3203{
3204	struct drm_dp_mst_topology_state *state;
3205	struct drm_dp_mst_atomic_payload *payload;
3206	struct drm_dp_sideband_msg_tx *txmsg;
3207	u8 nonce[7];
3208	int ret;
3209
3210	txmsg = kzalloc(sizeof(*txmsg), GFP_KERNEL);
3211	if (!txmsg)
3212		return -ENOMEM;
3213
3214	port = drm_dp_mst_topology_get_port_validated(mgr, port);
3215	if (!port) {
3216		ret = -EINVAL;
3217		goto out_get_port;
3218	}
3219
3220	get_random_bytes(nonce, sizeof(nonce));
3221
3222	drm_modeset_lock(&mgr->base.lock, NULL);
3223	state = to_drm_dp_mst_topology_state(mgr->base.state);
3224	payload = drm_atomic_get_mst_payload_state(state, port);
3225
3226	/*
3227	 * "Source device targets the QUERY_STREAM_ENCRYPTION_STATUS message
3228	 *  transaction at the MST Branch device directly connected to the
3229	 *  Source"
3230	 */
3231	txmsg->dst = mgr->mst_primary;
3232
3233	build_query_stream_enc_status(txmsg, payload->vcpi, nonce);
3234
3235	drm_dp_queue_down_tx(mgr, txmsg);
3236
3237	ret = drm_dp_mst_wait_tx_reply(mgr->mst_primary, txmsg);
3238	if (ret < 0) {
3239		goto out;
3240	} else if (txmsg->reply.reply_type == DP_SIDEBAND_REPLY_NAK) {
3241		drm_dbg_kms(mgr->dev, "query encryption status nak received\n");
3242		ret = -ENXIO;
3243		goto out;
3244	}
3245
3246	ret = 0;
3247	memcpy(status, &txmsg->reply.u.enc_status, sizeof(*status));
3248
3249out:
3250	drm_modeset_unlock(&mgr->base.lock);
3251	drm_dp_mst_topology_put_port(port);
3252out_get_port:
3253	kfree(txmsg);
3254	return ret;
3255}
3256EXPORT_SYMBOL(drm_dp_send_query_stream_enc_status);
3257
3258static int drm_dp_create_payload_step1(struct drm_dp_mst_topology_mgr *mgr,
3259				       struct drm_dp_mst_atomic_payload *payload)
3260{
3261	return drm_dp_dpcd_write_payload(mgr, payload->vcpi, payload->vc_start_slot,
3262					 payload->time_slots);
3263}
3264
3265static int drm_dp_create_payload_step2(struct drm_dp_mst_topology_mgr *mgr,
3266				       struct drm_dp_mst_atomic_payload *payload)
3267{
3268	int ret;
3269	struct drm_dp_mst_port *port = drm_dp_mst_topology_get_port_validated(mgr, payload->port);
3270
3271	if (!port)
3272		return -EIO;
3273
3274	ret = drm_dp_payload_send_msg(mgr, port, payload->vcpi, payload->pbn);
3275	drm_dp_mst_topology_put_port(port);
3276	return ret;
3277}
3278
3279static int drm_dp_destroy_payload_step1(struct drm_dp_mst_topology_mgr *mgr,
3280					struct drm_dp_mst_topology_state *mst_state,
3281					struct drm_dp_mst_atomic_payload *payload)
3282{
3283	drm_dbg_kms(mgr->dev, "\n");
3284
3285	/* it's okay for these to fail */
3286	drm_dp_payload_send_msg(mgr, payload->port, payload->vcpi, 0);
3287	drm_dp_dpcd_write_payload(mgr, payload->vcpi, payload->vc_start_slot, 0);
3288
3289	return 0;
3290}
3291
3292/**
3293 * drm_dp_add_payload_part1() - Execute payload update part 1
3294 * @mgr: Manager to use.
3295 * @mst_state: The MST atomic state
3296 * @payload: The payload to write
3297 *
3298 * Determines the starting time slot for the given payload, and programs the VCPI for this payload
3299 * into hardware. After calling this, the driver should generate ACT and payload packets.
3300 *
3301 * Returns: 0 on success, error code on failure. In the event that this fails,
3302 * @payload.vc_start_slot will also be set to -1.
3303 */
3304int drm_dp_add_payload_part1(struct drm_dp_mst_topology_mgr *mgr,
3305			     struct drm_dp_mst_topology_state *mst_state,
3306			     struct drm_dp_mst_atomic_payload *payload)
3307{
3308	struct drm_dp_mst_port *port;
3309	int ret;
3310
3311	port = drm_dp_mst_topology_get_port_validated(mgr, payload->port);
3312	if (!port)
3313		return 0;
3314
3315	if (mgr->payload_count == 0)
3316		mgr->next_start_slot = mst_state->start_slot;
3317
3318	payload->vc_start_slot = mgr->next_start_slot;
3319
3320	ret = drm_dp_create_payload_step1(mgr, payload);
3321	drm_dp_mst_topology_put_port(port);
3322	if (ret < 0) {
3323		drm_warn(mgr->dev, "Failed to create MST payload for port %p: %d\n",
3324			 payload->port, ret);
3325		payload->vc_start_slot = -1;
3326		return ret;
3327	}
3328
3329	mgr->payload_count++;
3330	mgr->next_start_slot += payload->time_slots;
3331
3332	return 0;
3333}
3334EXPORT_SYMBOL(drm_dp_add_payload_part1);
3335
3336/**
3337 * drm_dp_remove_payload() - Remove an MST payload
3338 * @mgr: Manager to use.
3339 * @mst_state: The MST atomic state
3340 * @payload: The payload to write
3341 *
3342 * Removes a payload from an MST topology if it was successfully assigned a start slot. Also updates
3343 * the starting time slots of all other payloads which would have been shifted towards the start of
3344 * the VC table as a result. After calling this, the driver should generate ACT and payload packets.
3345 */
3346void drm_dp_remove_payload(struct drm_dp_mst_topology_mgr *mgr,
3347			   struct drm_dp_mst_topology_state *mst_state,
3348			   struct drm_dp_mst_atomic_payload *payload)
3349{
3350	struct drm_dp_mst_atomic_payload *pos;
3351	bool send_remove = false;
3352
3353	/* We failed to make the payload, so nothing to do */
3354	if (payload->vc_start_slot == -1)
3355		return;
3356
3357	mutex_lock(&mgr->lock);
3358	send_remove = drm_dp_mst_port_downstream_of_branch(payload->port, mgr->mst_primary);
3359	mutex_unlock(&mgr->lock);
3360
3361	if (send_remove)
3362		drm_dp_destroy_payload_step1(mgr, mst_state, payload);
3363	else
3364		drm_dbg_kms(mgr->dev, "Payload for VCPI %d not in topology, not sending remove\n",
3365			    payload->vcpi);
3366
3367	list_for_each_entry(pos, &mst_state->payloads, next) {
3368		if (pos != payload && pos->vc_start_slot > payload->vc_start_slot)
3369			pos->vc_start_slot -= payload->time_slots;
3370	}
3371	payload->vc_start_slot = -1;
3372
3373	mgr->payload_count--;
3374	mgr->next_start_slot -= payload->time_slots;
3375
3376	if (payload->delete)
3377		drm_dp_mst_put_port_malloc(payload->port);
3378}
3379EXPORT_SYMBOL(drm_dp_remove_payload);
3380
3381/**
3382 * drm_dp_add_payload_part2() - Execute payload update part 2
3383 * @mgr: Manager to use.
3384 * @state: The global atomic state
3385 * @payload: The payload to update
3386 *
3387 * If @payload was successfully assigned a starting time slot by drm_dp_add_payload_part1(), this
3388 * function will send the sideband messages to finish allocating this payload.
3389 *
3390 * Returns: 0 on success, negative error code on failure.
3391 */
3392int drm_dp_add_payload_part2(struct drm_dp_mst_topology_mgr *mgr,
3393			     struct drm_atomic_state *state,
3394			     struct drm_dp_mst_atomic_payload *payload)
3395{
3396	int ret = 0;
3397
3398	/* Skip failed payloads */
3399	if (payload->vc_start_slot == -1) {
3400		drm_dbg_kms(state->dev, "Part 1 of payload creation for %s failed, skipping part 2\n",
3401			    payload->port->connector->name);
3402		return -EIO;
3403	}
3404
3405	ret = drm_dp_create_payload_step2(mgr, payload);
3406	if (ret < 0) {
3407		if (!payload->delete)
3408			drm_err(mgr->dev, "Step 2 of creating MST payload for %p failed: %d\n",
3409				payload->port, ret);
3410		else
3411			drm_dbg_kms(mgr->dev, "Step 2 of removing MST payload for %p failed: %d\n",
3412				    payload->port, ret);
3413	}
3414
3415	return ret;
3416}
3417EXPORT_SYMBOL(drm_dp_add_payload_part2);
3418
3419static int drm_dp_send_dpcd_read(struct drm_dp_mst_topology_mgr *mgr,
3420				 struct drm_dp_mst_port *port,
3421				 int offset, int size, u8 *bytes)
3422{
3423	int ret = 0;
3424	struct drm_dp_sideband_msg_tx *txmsg;
3425	struct drm_dp_mst_branch *mstb;
3426
3427	mstb = drm_dp_mst_topology_get_mstb_validated(mgr, port->parent);
3428	if (!mstb)
3429		return -EINVAL;
3430
3431	txmsg = kzalloc(sizeof(*txmsg), GFP_KERNEL);
3432	if (!txmsg) {
3433		ret = -ENOMEM;
3434		goto fail_put;
3435	}
3436
3437	build_dpcd_read(txmsg, port->port_num, offset, size);
3438	txmsg->dst = port->parent;
3439
3440	drm_dp_queue_down_tx(mgr, txmsg);
3441
3442	ret = drm_dp_mst_wait_tx_reply(mstb, txmsg);
3443	if (ret < 0)
3444		goto fail_free;
3445
3446	if (txmsg->reply.reply_type == 1) {
3447		drm_dbg_kms(mgr->dev, "mstb %p port %d: DPCD read on addr 0x%x for %d bytes NAKed\n",
3448			    mstb, port->port_num, offset, size);
3449		ret = -EIO;
3450		goto fail_free;
3451	}
3452
3453	if (txmsg->reply.u.remote_dpcd_read_ack.num_bytes != size) {
3454		ret = -EPROTO;
3455		goto fail_free;
3456	}
3457
3458	ret = min_t(size_t, txmsg->reply.u.remote_dpcd_read_ack.num_bytes,
3459		    size);
3460	memcpy(bytes, txmsg->reply.u.remote_dpcd_read_ack.bytes, ret);
3461
3462fail_free:
3463	kfree(txmsg);
3464fail_put:
3465	drm_dp_mst_topology_put_mstb(mstb);
3466
3467	return ret;
3468}
3469
3470static int drm_dp_send_dpcd_write(struct drm_dp_mst_topology_mgr *mgr,
3471				  struct drm_dp_mst_port *port,
3472				  int offset, int size, u8 *bytes)
3473{
3474	int ret;
3475	struct drm_dp_sideband_msg_tx *txmsg;
3476	struct drm_dp_mst_branch *mstb;
3477
3478	mstb = drm_dp_mst_topology_get_mstb_validated(mgr, port->parent);
3479	if (!mstb)
3480		return -EINVAL;
3481
3482	txmsg = kzalloc(sizeof(*txmsg), GFP_KERNEL);
3483	if (!txmsg) {
3484		ret = -ENOMEM;
3485		goto fail_put;
3486	}
3487
3488	build_dpcd_write(txmsg, port->port_num, offset, size, bytes);
3489	txmsg->dst = mstb;
3490
3491	drm_dp_queue_down_tx(mgr, txmsg);
3492
3493	ret = drm_dp_mst_wait_tx_reply(mstb, txmsg);
3494	if (ret > 0) {
3495		if (txmsg->reply.reply_type == DP_SIDEBAND_REPLY_NAK)
3496			ret = -EIO;
3497		else
3498			ret = size;
3499	}
3500
3501	kfree(txmsg);
3502fail_put:
3503	drm_dp_mst_topology_put_mstb(mstb);
3504	return ret;
3505}
3506
3507static int drm_dp_encode_up_ack_reply(struct drm_dp_sideband_msg_tx *msg, u8 req_type)
3508{
3509	struct drm_dp_sideband_msg_reply_body reply;
3510
3511	reply.reply_type = DP_SIDEBAND_REPLY_ACK;
3512	reply.req_type = req_type;
3513	drm_dp_encode_sideband_reply(&reply, msg);
3514	return 0;
3515}
3516
3517static int drm_dp_send_up_ack_reply(struct drm_dp_mst_topology_mgr *mgr,
3518				    struct drm_dp_mst_branch *mstb,
3519				    int req_type, bool broadcast)
3520{
3521	struct drm_dp_sideband_msg_tx *txmsg;
3522
3523	txmsg = kzalloc(sizeof(*txmsg), GFP_KERNEL);
3524	if (!txmsg)
3525		return -ENOMEM;
3526
3527	txmsg->dst = mstb;
3528	drm_dp_encode_up_ack_reply(txmsg, req_type);
3529
3530	mutex_lock(&mgr->qlock);
3531	/* construct a chunk from the first msg in the tx_msg queue */
3532	process_single_tx_qlock(mgr, txmsg, true);
3533	mutex_unlock(&mgr->qlock);
3534
3535	kfree(txmsg);
3536	return 0;
3537}
3538
3539/**
3540 * drm_dp_get_vc_payload_bw - get the VC payload BW for an MST link
3541 * @mgr: The &drm_dp_mst_topology_mgr to use
3542 * @link_rate: link rate in 10kbits/s units
3543 * @link_lane_count: lane count
3544 *
3545 * Calculate the total bandwidth of a MultiStream Transport link. The returned
3546 * value is in units of PBNs/(timeslots/1 MTP). This value can be used to
3547 * convert the number of PBNs required for a given stream to the number of
3548 * timeslots this stream requires in each MTP.
3549 */
3550int drm_dp_get_vc_payload_bw(const struct drm_dp_mst_topology_mgr *mgr,
3551			     int link_rate, int link_lane_count)
3552{
3553	if (link_rate == 0 || link_lane_count == 0)
3554		drm_dbg_kms(mgr->dev, "invalid link rate/lane count: (%d / %d)\n",
3555			    link_rate, link_lane_count);
3556
3557	/* See DP v2.0 2.6.4.2, VCPayload_Bandwidth_for_OneTimeSlotPer_MTP_Allocation */
3558	return link_rate * link_lane_count / 54000;
3559}
3560EXPORT_SYMBOL(drm_dp_get_vc_payload_bw);
3561
3562/**
3563 * drm_dp_read_mst_cap() - check whether or not a sink supports MST
3564 * @aux: The DP AUX channel to use
3565 * @dpcd: A cached copy of the DPCD capabilities for this sink
3566 *
3567 * Returns: %True if the sink supports MST, %false otherwise
3568 */
3569bool drm_dp_read_mst_cap(struct drm_dp_aux *aux,
3570			 const u8 dpcd[DP_RECEIVER_CAP_SIZE])
3571{
3572	u8 mstm_cap;
3573
3574	if (dpcd[DP_DPCD_REV] < DP_DPCD_REV_12)
3575		return false;
3576
3577	if (drm_dp_dpcd_readb(aux, DP_MSTM_CAP, &mstm_cap) != 1)
3578		return false;
3579
3580	return mstm_cap & DP_MST_CAP;
3581}
3582EXPORT_SYMBOL(drm_dp_read_mst_cap);
3583
3584/**
3585 * drm_dp_mst_topology_mgr_set_mst() - Set the MST state for a topology manager
3586 * @mgr: manager to set state for
3587 * @mst_state: true to enable MST on this connector - false to disable.
3588 *
3589 * This is called by the driver when it detects an MST capable device plugged
3590 * into a DP MST capable port, or when a DP MST capable device is unplugged.
3591 */
3592int drm_dp_mst_topology_mgr_set_mst(struct drm_dp_mst_topology_mgr *mgr, bool mst_state)
3593{
3594	int ret = 0;
3595	struct drm_dp_mst_branch *mstb = NULL;
3596
3597	mutex_lock(&mgr->lock);
3598	if (mst_state == mgr->mst_state)
3599		goto out_unlock;
3600
3601	mgr->mst_state = mst_state;
3602	/* set the device into MST mode */
3603	if (mst_state) {
3604		WARN_ON(mgr->mst_primary);
3605
3606		/* get dpcd info */
3607		ret = drm_dp_read_dpcd_caps(mgr->aux, mgr->dpcd);
3608		if (ret < 0) {
3609			drm_dbg_kms(mgr->dev, "%s: failed to read DPCD, ret %d\n",
3610				    mgr->aux->name, ret);
3611			goto out_unlock;
3612		}
3613
3614		/* add initial branch device at LCT 1 */
3615		mstb = drm_dp_add_mst_branch_device(1, NULL);
3616		if (mstb == NULL) {
3617			ret = -ENOMEM;
3618			goto out_unlock;
3619		}
3620		mstb->mgr = mgr;
3621
3622		/* give this the main reference */
3623		mgr->mst_primary = mstb;
3624		drm_dp_mst_topology_get_mstb(mgr->mst_primary);
3625
3626		ret = drm_dp_dpcd_writeb(mgr->aux, DP_MSTM_CTRL,
3627					 DP_MST_EN |
3628					 DP_UP_REQ_EN |
3629					 DP_UPSTREAM_IS_SRC);
3630		if (ret < 0)
3631			goto out_unlock;
3632
3633		/* Write reset payload */
3634		drm_dp_dpcd_write_payload(mgr, 0, 0, 0x3f);
3635
3636		queue_work(system_long_wq, &mgr->work);
3637
3638		ret = 0;
3639	} else {
3640		/* disable MST on the device */
3641		mstb = mgr->mst_primary;
3642		mgr->mst_primary = NULL;
3643		/* this can fail if the device is gone */
3644		drm_dp_dpcd_writeb(mgr->aux, DP_MSTM_CTRL, 0);
3645		ret = 0;
3646		mgr->payload_id_table_cleared = false;
3647	}
3648
3649out_unlock:
3650	mutex_unlock(&mgr->lock);
3651	if (mstb)
3652		drm_dp_mst_topology_put_mstb(mstb);
3653	return ret;
3654
3655}
3656EXPORT_SYMBOL(drm_dp_mst_topology_mgr_set_mst);
3657
3658static void
3659drm_dp_mst_topology_mgr_invalidate_mstb(struct drm_dp_mst_branch *mstb)
3660{
3661	struct drm_dp_mst_port *port;
3662
3663	/* The link address will need to be re-sent on resume */
3664	mstb->link_address_sent = false;
3665
3666	list_for_each_entry(port, &mstb->ports, next)
3667		if (port->mstb)
3668			drm_dp_mst_topology_mgr_invalidate_mstb(port->mstb);
3669}
3670
3671/**
3672 * drm_dp_mst_topology_mgr_suspend() - suspend the MST manager
3673 * @mgr: manager to suspend
3674 *
3675 * This function tells the MST device that we can't handle UP messages
3676 * anymore. This should stop it from sending any since we are suspended.
3677 */
3678void drm_dp_mst_topology_mgr_suspend(struct drm_dp_mst_topology_mgr *mgr)
3679{
3680	mutex_lock(&mgr->lock);
3681	drm_dp_dpcd_writeb(mgr->aux, DP_MSTM_CTRL,
3682			   DP_MST_EN | DP_UPSTREAM_IS_SRC);
3683	mutex_unlock(&mgr->lock);
3684	flush_work(&mgr->up_req_work);
3685	flush_work(&mgr->work);
3686	flush_work(&mgr->delayed_destroy_work);
3687
3688	mutex_lock(&mgr->lock);
3689	if (mgr->mst_state && mgr->mst_primary)
3690		drm_dp_mst_topology_mgr_invalidate_mstb(mgr->mst_primary);
3691	mutex_unlock(&mgr->lock);
3692}
3693EXPORT_SYMBOL(drm_dp_mst_topology_mgr_suspend);
3694
3695/**
3696 * drm_dp_mst_topology_mgr_resume() - resume the MST manager
3697 * @mgr: manager to resume
3698 * @sync: whether or not to perform topology reprobing synchronously
3699 *
3700 * This will fetch DPCD and see if the device is still there,
3701 * if it is, it will rewrite the MSTM control bits, and return.
3702 *
3703 * If the device fails this returns -1, and the driver should do
3704 * a full MST reprobe, in case we were undocked.
3705 *
3706 * During system resume (where it is assumed that the driver will be calling
3707 * drm_atomic_helper_resume()) this function should be called beforehand with
3708 * @sync set to true. In contexts like runtime resume where the driver is not
3709 * expected to be calling drm_atomic_helper_resume(), this function should be
3710 * called with @sync set to false in order to avoid deadlocking.
3711 *
3712 * Returns: -1 if the MST topology was removed while we were suspended, 0
3713 * otherwise.
3714 */
3715int drm_dp_mst_topology_mgr_resume(struct drm_dp_mst_topology_mgr *mgr,
3716				   bool sync)
3717{
3718	int ret;
3719	u8 guid[16];
3720
3721	mutex_lock(&mgr->lock);
3722	if (!mgr->mst_primary)
3723		goto out_fail;
3724
3725	if (drm_dp_read_dpcd_caps(mgr->aux, mgr->dpcd) < 0) {
3726		drm_dbg_kms(mgr->dev, "dpcd read failed - undocked during suspend?\n");
3727		goto out_fail;
3728	}
3729
3730	ret = drm_dp_dpcd_writeb(mgr->aux, DP_MSTM_CTRL,
3731				 DP_MST_EN |
3732				 DP_UP_REQ_EN |
3733				 DP_UPSTREAM_IS_SRC);
3734	if (ret < 0) {
3735		drm_dbg_kms(mgr->dev, "mst write failed - undocked during suspend?\n");
3736		goto out_fail;
3737	}
3738
3739	/* Some hubs forget their guids after they resume */
3740	ret = drm_dp_dpcd_read(mgr->aux, DP_GUID, guid, 16);
3741	if (ret != 16) {
3742		drm_dbg_kms(mgr->dev, "dpcd read failed - undocked during suspend?\n");
3743		goto out_fail;
3744	}
3745
3746	ret = drm_dp_check_mstb_guid(mgr->mst_primary, guid);
3747	if (ret) {
3748		drm_dbg_kms(mgr->dev, "check mstb failed - undocked during suspend?\n");
3749		goto out_fail;
3750	}
3751
3752	/*
3753	 * For the final step of resuming the topology, we need to bring the
3754	 * state of our in-memory topology back into sync with reality. So,
3755	 * restart the probing process as if we're probing a new hub
3756	 */
3757	queue_work(system_long_wq, &mgr->work);
3758	mutex_unlock(&mgr->lock);
3759
3760	if (sync) {
3761		drm_dbg_kms(mgr->dev,
3762			    "Waiting for link probe work to finish re-syncing topology...\n");
3763		flush_work(&mgr->work);
3764	}
3765
3766	return 0;
3767
3768out_fail:
3769	mutex_unlock(&mgr->lock);
3770	return -1;
3771}
3772EXPORT_SYMBOL(drm_dp_mst_topology_mgr_resume);
3773
3774static bool
3775drm_dp_get_one_sb_msg(struct drm_dp_mst_topology_mgr *mgr, bool up,
3776		      struct drm_dp_mst_branch **mstb)
3777{
3778	int len;
3779	u8 replyblock[32];
3780	int replylen, curreply;
3781	int ret;
3782	u8 hdrlen;
3783	struct drm_dp_sideband_msg_hdr hdr;
3784	struct drm_dp_sideband_msg_rx *msg =
3785		up ? &mgr->up_req_recv : &mgr->down_rep_recv;
3786	int basereg = up ? DP_SIDEBAND_MSG_UP_REQ_BASE :
3787			   DP_SIDEBAND_MSG_DOWN_REP_BASE;
3788
3789	if (!up)
3790		*mstb = NULL;
3791
3792	len = min(mgr->max_dpcd_transaction_bytes, 16);
3793	ret = drm_dp_dpcd_read(mgr->aux, basereg, replyblock, len);
3794	if (ret != len) {
3795		drm_dbg_kms(mgr->dev, "failed to read DPCD down rep %d %d\n", len, ret);
3796		return false;
3797	}
3798
3799	ret = drm_dp_decode_sideband_msg_hdr(mgr, &hdr, replyblock, len, &hdrlen);
3800	if (ret == false) {
3801		print_hex_dump(KERN_DEBUG, "failed hdr", DUMP_PREFIX_NONE, 16,
3802			       1, replyblock, len, false);
3803		drm_dbg_kms(mgr->dev, "ERROR: failed header\n");
3804		return false;
3805	}
3806
3807	if (!up) {
3808		/* Caller is responsible for giving back this reference */
3809		*mstb = drm_dp_get_mst_branch_device(mgr, hdr.lct, hdr.rad);
3810		if (!*mstb) {
3811			drm_dbg_kms(mgr->dev, "Got MST reply from unknown device %d\n", hdr.lct);
3812			return false;
3813		}
3814	}
3815
3816	if (!drm_dp_sideband_msg_set_header(msg, &hdr, hdrlen)) {
3817		drm_dbg_kms(mgr->dev, "sideband msg set header failed %d\n", replyblock[0]);
3818		return false;
3819	}
3820
3821	replylen = min(msg->curchunk_len, (u8)(len - hdrlen));
3822	ret = drm_dp_sideband_append_payload(msg, replyblock + hdrlen, replylen);
3823	if (!ret) {
3824		drm_dbg_kms(mgr->dev, "sideband msg build failed %d\n", replyblock[0]);
3825		return false;
3826	}
3827
3828	replylen = msg->curchunk_len + msg->curchunk_hdrlen - len;
3829	curreply = len;
3830	while (replylen > 0) {
3831		len = min3(replylen, mgr->max_dpcd_transaction_bytes, 16);
3832		ret = drm_dp_dpcd_read(mgr->aux, basereg + curreply,
3833				    replyblock, len);
3834		if (ret != len) {
3835			drm_dbg_kms(mgr->dev, "failed to read a chunk (len %d, ret %d)\n",
3836				    len, ret);
3837			return false;
3838		}
3839
3840		ret = drm_dp_sideband_append_payload(msg, replyblock, len);
3841		if (!ret) {
3842			drm_dbg_kms(mgr->dev, "failed to build sideband msg\n");
3843			return false;
3844		}
3845
3846		curreply += len;
3847		replylen -= len;
3848	}
3849	return true;
3850}
3851
3852static int drm_dp_mst_handle_down_rep(struct drm_dp_mst_topology_mgr *mgr)
3853{
3854	struct drm_dp_sideband_msg_tx *txmsg;
3855	struct drm_dp_mst_branch *mstb = NULL;
3856	struct drm_dp_sideband_msg_rx *msg = &mgr->down_rep_recv;
3857
3858	if (!drm_dp_get_one_sb_msg(mgr, false, &mstb))
3859		goto out;
3860
3861	/* Multi-packet message transmission, don't clear the reply */
3862	if (!msg->have_eomt)
3863		goto out;
3864
3865	/* find the message */
3866	mutex_lock(&mgr->qlock);
3867	txmsg = list_first_entry_or_null(&mgr->tx_msg_downq,
3868					 struct drm_dp_sideband_msg_tx, next);
3869	mutex_unlock(&mgr->qlock);
3870
3871	/* Were we actually expecting a response, and from this mstb? */
3872	if (!txmsg || txmsg->dst != mstb) {
3873		struct drm_dp_sideband_msg_hdr *hdr;
3874
3875		hdr = &msg->initial_hdr;
3876		drm_dbg_kms(mgr->dev, "Got MST reply with no msg %p %d %d %02x %02x\n",
3877			    mstb, hdr->seqno, hdr->lct, hdr->rad[0], msg->msg[0]);
3878		goto out_clear_reply;
3879	}
3880
3881	drm_dp_sideband_parse_reply(mgr, msg, &txmsg->reply);
3882
3883	if (txmsg->reply.reply_type == DP_SIDEBAND_REPLY_NAK) {
3884		drm_dbg_kms(mgr->dev,
3885			    "Got NAK reply: req 0x%02x (%s), reason 0x%02x (%s), nak data 0x%02x\n",
3886			    txmsg->reply.req_type,
3887			    drm_dp_mst_req_type_str(txmsg->reply.req_type),
3888			    txmsg->reply.u.nak.reason,
3889			    drm_dp_mst_nak_reason_str(txmsg->reply.u.nak.reason),
3890			    txmsg->reply.u.nak.nak_data);
3891	}
3892
3893	memset(msg, 0, sizeof(struct drm_dp_sideband_msg_rx));
3894	drm_dp_mst_topology_put_mstb(mstb);
3895
3896	mutex_lock(&mgr->qlock);
3897	txmsg->state = DRM_DP_SIDEBAND_TX_RX;
3898	list_del(&txmsg->next);
3899	mutex_unlock(&mgr->qlock);
3900
3901	wake_up_all(&mgr->tx_waitq);
3902
3903	return 0;
3904
3905out_clear_reply:
3906	memset(msg, 0, sizeof(struct drm_dp_sideband_msg_rx));
3907out:
3908	if (mstb)
3909		drm_dp_mst_topology_put_mstb(mstb);
3910
3911	return 0;
3912}
3913
3914static inline bool
3915drm_dp_mst_process_up_req(struct drm_dp_mst_topology_mgr *mgr,
3916			  struct drm_dp_pending_up_req *up_req)
3917{
3918	struct drm_dp_mst_branch *mstb = NULL;
3919	struct drm_dp_sideband_msg_req_body *msg = &up_req->msg;
3920	struct drm_dp_sideband_msg_hdr *hdr = &up_req->hdr;
3921	bool hotplug = false, dowork = false;
3922
3923	if (hdr->broadcast) {
3924		const u8 *guid = NULL;
3925
3926		if (msg->req_type == DP_CONNECTION_STATUS_NOTIFY)
3927			guid = msg->u.conn_stat.guid;
3928		else if (msg->req_type == DP_RESOURCE_STATUS_NOTIFY)
3929			guid = msg->u.resource_stat.guid;
3930
3931		if (guid)
3932			mstb = drm_dp_get_mst_branch_device_by_guid(mgr, guid);
3933	} else {
3934		mstb = drm_dp_get_mst_branch_device(mgr, hdr->lct, hdr->rad);
3935	}
3936
3937	if (!mstb) {
3938		drm_dbg_kms(mgr->dev, "Got MST reply from unknown device %d\n", hdr->lct);
3939		return false;
3940	}
3941
3942	/* TODO: Add missing handler for DP_RESOURCE_STATUS_NOTIFY events */
3943	if (msg->req_type == DP_CONNECTION_STATUS_NOTIFY) {
3944		dowork = drm_dp_mst_handle_conn_stat(mstb, &msg->u.conn_stat);
3945		hotplug = true;
3946	}
3947
3948	drm_dp_mst_topology_put_mstb(mstb);
3949
3950	if (dowork)
3951		queue_work(system_long_wq, &mgr->work);
3952	return hotplug;
3953}
3954
3955static void drm_dp_mst_up_req_work(struct work_struct *work)
3956{
3957	struct drm_dp_mst_topology_mgr *mgr =
3958		container_of(work, struct drm_dp_mst_topology_mgr,
3959			     up_req_work);
3960	struct drm_dp_pending_up_req *up_req;
3961	bool send_hotplug = false;
3962
3963	mutex_lock(&mgr->probe_lock);
3964	while (true) {
3965		mutex_lock(&mgr->up_req_lock);
3966		up_req = list_first_entry_or_null(&mgr->up_req_list,
3967						  struct drm_dp_pending_up_req,
3968						  next);
3969		if (up_req)
3970			list_del(&up_req->next);
3971		mutex_unlock(&mgr->up_req_lock);
3972
3973		if (!up_req)
3974			break;
3975
3976		send_hotplug |= drm_dp_mst_process_up_req(mgr, up_req);
3977		kfree(up_req);
3978	}
3979	mutex_unlock(&mgr->probe_lock);
3980
3981	if (send_hotplug)
3982		drm_kms_helper_hotplug_event(mgr->dev);
3983}
3984
3985static int drm_dp_mst_handle_up_req(struct drm_dp_mst_topology_mgr *mgr)
3986{
3987	struct drm_dp_pending_up_req *up_req;
3988
3989	if (!drm_dp_get_one_sb_msg(mgr, true, NULL))
3990		goto out;
3991
3992	if (!mgr->up_req_recv.have_eomt)
3993		return 0;
3994
3995	up_req = kzalloc(sizeof(*up_req), GFP_KERNEL);
3996	if (!up_req)
3997		return -ENOMEM;
3998
3999	INIT_LIST_HEAD(&up_req->next);
4000
4001	drm_dp_sideband_parse_req(mgr, &mgr->up_req_recv, &up_req->msg);
4002
4003	if (up_req->msg.req_type != DP_CONNECTION_STATUS_NOTIFY &&
4004	    up_req->msg.req_type != DP_RESOURCE_STATUS_NOTIFY) {
4005		drm_dbg_kms(mgr->dev, "Received unknown up req type, ignoring: %x\n",
4006			    up_req->msg.req_type);
4007		kfree(up_req);
4008		goto out;
4009	}
4010
4011	drm_dp_send_up_ack_reply(mgr, mgr->mst_primary, up_req->msg.req_type,
4012				 false);
4013
4014	if (up_req->msg.req_type == DP_CONNECTION_STATUS_NOTIFY) {
4015		const struct drm_dp_connection_status_notify *conn_stat =
4016			&up_req->msg.u.conn_stat;
4017
4018		drm_dbg_kms(mgr->dev, "Got CSN: pn: %d ldps:%d ddps: %d mcs: %d ip: %d pdt: %d\n",
4019			    conn_stat->port_number,
4020			    conn_stat->legacy_device_plug_status,
4021			    conn_stat->displayport_device_plug_status,
4022			    conn_stat->message_capability_status,
4023			    conn_stat->input_port,
4024			    conn_stat->peer_device_type);
4025	} else if (up_req->msg.req_type == DP_RESOURCE_STATUS_NOTIFY) {
4026		const struct drm_dp_resource_status_notify *res_stat =
4027			&up_req->msg.u.resource_stat;
4028
4029		drm_dbg_kms(mgr->dev, "Got RSN: pn: %d avail_pbn %d\n",
4030			    res_stat->port_number,
4031			    res_stat->available_pbn);
4032	}
4033
4034	up_req->hdr = mgr->up_req_recv.initial_hdr;
4035	mutex_lock(&mgr->up_req_lock);
4036	list_add_tail(&up_req->next, &mgr->up_req_list);
4037	mutex_unlock(&mgr->up_req_lock);
4038	queue_work(system_long_wq, &mgr->up_req_work);
4039
4040out:
4041	memset(&mgr->up_req_recv, 0, sizeof(struct drm_dp_sideband_msg_rx));
4042	return 0;
4043}
4044
4045/**
4046 * drm_dp_mst_hpd_irq() - MST hotplug IRQ notify
4047 * @mgr: manager to notify irq for.
4048 * @esi: 4 bytes from SINK_COUNT_ESI
4049 * @handled: whether the hpd interrupt was consumed or not
4050 *
4051 * This should be called from the driver when it detects a short IRQ,
4052 * along with the value of the DEVICE_SERVICE_IRQ_VECTOR_ESI0. The
4053 * topology manager will process the sideband messages received as a result
4054 * of this.
4055 */
4056int drm_dp_mst_hpd_irq(struct drm_dp_mst_topology_mgr *mgr, u8 *esi, bool *handled)
4057{
4058	int ret = 0;
4059	int sc;
4060	*handled = false;
4061	sc = DP_GET_SINK_COUNT(esi[0]);
4062
4063	if (sc != mgr->sink_count) {
4064		mgr->sink_count = sc;
4065		*handled = true;
4066	}
4067
4068	if (esi[1] & DP_DOWN_REP_MSG_RDY) {
4069		ret = drm_dp_mst_handle_down_rep(mgr);
4070		*handled = true;
4071	}
4072
4073	if (esi[1] & DP_UP_REQ_MSG_RDY) {
4074		ret |= drm_dp_mst_handle_up_req(mgr);
4075		*handled = true;
4076	}
4077
4078	drm_dp_mst_kick_tx(mgr);
4079	return ret;
4080}
4081EXPORT_SYMBOL(drm_dp_mst_hpd_irq);
4082
4083/**
4084 * drm_dp_mst_detect_port() - get connection status for an MST port
4085 * @connector: DRM connector for this port
4086 * @ctx: The acquisition context to use for grabbing locks
4087 * @mgr: manager for this port
4088 * @port: pointer to a port
4089 *
4090 * This returns the current connection state for a port.
4091 */
4092int
4093drm_dp_mst_detect_port(struct drm_connector *connector,
4094		       struct drm_modeset_acquire_ctx *ctx,
4095		       struct drm_dp_mst_topology_mgr *mgr,
4096		       struct drm_dp_mst_port *port)
4097{
4098	int ret;
4099
4100	/* we need to search for the port in the mgr in case it's gone */
4101	port = drm_dp_mst_topology_get_port_validated(mgr, port);
4102	if (!port)
4103		return connector_status_disconnected;
4104
4105	ret = drm_modeset_lock(&mgr->base.lock, ctx);
4106	if (ret)
4107		goto out;
4108
4109	ret = connector_status_disconnected;
4110
4111	if (!port->ddps)
4112		goto out;
4113
4114	switch (port->pdt) {
4115	case DP_PEER_DEVICE_NONE:
4116		break;
4117	case DP_PEER_DEVICE_MST_BRANCHING:
4118		if (!port->mcs)
4119			ret = connector_status_connected;
4120		break;
4121
4122	case DP_PEER_DEVICE_SST_SINK:
4123		ret = connector_status_connected;
4124		/* for logical ports - cache the EDID */
4125		if (port->port_num >= DP_MST_LOGICAL_PORT_0 && !port->cached_edid)
4126			port->cached_edid = drm_get_edid(connector, &port->aux.ddc);
4127		break;
4128	case DP_PEER_DEVICE_DP_LEGACY_CONV:
4129		if (port->ldps)
4130			ret = connector_status_connected;
4131		break;
4132	}
4133out:
4134	drm_dp_mst_topology_put_port(port);
4135	return ret;
4136}
4137EXPORT_SYMBOL(drm_dp_mst_detect_port);
4138
4139/**
4140 * drm_dp_mst_get_edid() - get EDID for an MST port
4141 * @connector: toplevel connector to get EDID for
4142 * @mgr: manager for this port
4143 * @port: unverified pointer to a port.
4144 *
4145 * This returns an EDID for the port connected to a connector,
4146 * It validates the pointer still exists so the caller doesn't require a
4147 * reference.
4148 */
4149struct edid *drm_dp_mst_get_edid(struct drm_connector *connector, struct drm_dp_mst_topology_mgr *mgr, struct drm_dp_mst_port *port)
4150{
4151	struct edid *edid = NULL;
4152
4153	/* we need to search for the port in the mgr in case it's gone */
4154	port = drm_dp_mst_topology_get_port_validated(mgr, port);
4155	if (!port)
4156		return NULL;
4157
4158	if (port->cached_edid)
4159		edid = drm_edid_duplicate(port->cached_edid);
4160	else {
4161		edid = drm_get_edid(connector, &port->aux.ddc);
4162	}
4163	port->has_audio = drm_detect_monitor_audio(edid);
4164	drm_dp_mst_topology_put_port(port);
4165	return edid;
4166}
4167EXPORT_SYMBOL(drm_dp_mst_get_edid);
4168
4169/**
4170 * drm_dp_atomic_find_time_slots() - Find and add time slots to the state
4171 * @state: global atomic state
4172 * @mgr: MST topology manager for the port
4173 * @port: port to find time slots for
4174 * @pbn: bandwidth required for the mode in PBN
4175 *
4176 * Allocates time slots to @port, replacing any previous time slot allocations it may
4177 * have had. Any atomic drivers which support MST must call this function in
4178 * their &drm_encoder_helper_funcs.atomic_check() callback unconditionally to
4179 * change the current time slot allocation for the new state, and ensure the MST
4180 * atomic state is added whenever the state of payloads in the topology changes.
4181 *
4182 * Allocations set by this function are not checked against the bandwidth
4183 * restraints of @mgr until the driver calls drm_dp_mst_atomic_check().
4184 *
4185 * Additionally, it is OK to call this function multiple times on the same
4186 * @port as needed. It is not OK however, to call this function and
4187 * drm_dp_atomic_release_time_slots() in the same atomic check phase.
4188 *
4189 * See also:
4190 * drm_dp_atomic_release_time_slots()
4191 * drm_dp_mst_atomic_check()
4192 *
4193 * Returns:
4194 * Total slots in the atomic state assigned for this port, or a negative error
4195 * code if the port no longer exists
4196 */
4197int drm_dp_atomic_find_time_slots(struct drm_atomic_state *state,
4198				  struct drm_dp_mst_topology_mgr *mgr,
4199				  struct drm_dp_mst_port *port, int pbn)
4200{
4201	struct drm_dp_mst_topology_state *topology_state;
4202	struct drm_dp_mst_atomic_payload *payload = NULL;
4203	struct drm_connector_state *conn_state;
4204	int prev_slots = 0, prev_bw = 0, req_slots;
4205
4206	topology_state = drm_atomic_get_mst_topology_state(state, mgr);
4207	if (IS_ERR(topology_state))
4208		return PTR_ERR(topology_state);
4209
4210	conn_state = drm_atomic_get_new_connector_state(state, port->connector);
4211	topology_state->pending_crtc_mask |= drm_crtc_mask(conn_state->crtc);
4212
4213	/* Find the current allocation for this port, if any */
4214	payload = drm_atomic_get_mst_payload_state(topology_state, port);
4215	if (payload) {
4216		prev_slots = payload->time_slots;
4217		prev_bw = payload->pbn;
4218
4219		/*
4220		 * This should never happen, unless the driver tries
4221		 * releasing and allocating the same timeslot allocation,
4222		 * which is an error
4223		 */
4224		if (drm_WARN_ON(mgr->dev, payload->delete)) {
4225			drm_err(mgr->dev,
4226				"cannot allocate and release time slots on [MST PORT:%p] in the same state\n",
4227				port);
4228			return -EINVAL;
4229		}
4230	}
4231
4232	req_slots = DIV_ROUND_UP(pbn, topology_state->pbn_div);
4233
4234	drm_dbg_atomic(mgr->dev, "[CONNECTOR:%d:%s] [MST PORT:%p] TU %d -> %d\n",
4235		       port->connector->base.id, port->connector->name,
4236		       port, prev_slots, req_slots);
4237	drm_dbg_atomic(mgr->dev, "[CONNECTOR:%d:%s] [MST PORT:%p] PBN %d -> %d\n",
4238		       port->connector->base.id, port->connector->name,
4239		       port, prev_bw, pbn);
4240
4241	/* Add the new allocation to the state, note the VCPI isn't assigned until the end */
4242	if (!payload) {
4243		payload = kzalloc(sizeof(*payload), GFP_KERNEL);
4244		if (!payload)
4245			return -ENOMEM;
4246
4247		drm_dp_mst_get_port_malloc(port);
4248		payload->port = port;
4249		payload->vc_start_slot = -1;
4250		list_add(&payload->next, &topology_state->payloads);
4251	}
4252	payload->time_slots = req_slots;
4253	payload->pbn = pbn;
4254
4255	return req_slots;
4256}
4257EXPORT_SYMBOL(drm_dp_atomic_find_time_slots);
4258
4259/**
4260 * drm_dp_atomic_release_time_slots() - Release allocated time slots
4261 * @state: global atomic state
4262 * @mgr: MST topology manager for the port
4263 * @port: The port to release the time slots from
4264 *
4265 * Releases any time slots that have been allocated to a port in the atomic
4266 * state. Any atomic drivers which support MST must call this function
4267 * unconditionally in their &drm_connector_helper_funcs.atomic_check() callback.
4268 * This helper will check whether time slots would be released by the new state and
4269 * respond accordingly, along with ensuring the MST state is always added to the
4270 * atomic state whenever a new state would modify the state of payloads on the
4271 * topology.
4272 *
4273 * It is OK to call this even if @port has been removed from the system.
4274 * Additionally, it is OK to call this function multiple times on the same
4275 * @port as needed. It is not OK however, to call this function and
4276 * drm_dp_atomic_find_time_slots() on the same @port in a single atomic check
4277 * phase.
4278 *
4279 * See also:
4280 * drm_dp_atomic_find_time_slots()
4281 * drm_dp_mst_atomic_check()
4282 *
4283 * Returns:
4284 * 0 on success, negative error code otherwise
4285 */
4286int drm_dp_atomic_release_time_slots(struct drm_atomic_state *state,
4287				     struct drm_dp_mst_topology_mgr *mgr,
4288				     struct drm_dp_mst_port *port)
4289{
4290	struct drm_dp_mst_topology_state *topology_state;
4291	struct drm_dp_mst_atomic_payload *payload;
4292	struct drm_connector_state *old_conn_state, *new_conn_state;
4293	bool update_payload = true;
4294
4295	old_conn_state = drm_atomic_get_old_connector_state(state, port->connector);
4296	if (!old_conn_state->crtc)
4297		return 0;
4298
4299	/* If the CRTC isn't disabled by this state, don't release it's payload */
4300	new_conn_state = drm_atomic_get_new_connector_state(state, port->connector);
4301	if (new_conn_state->crtc) {
4302		struct drm_crtc_state *crtc_state =
4303			drm_atomic_get_new_crtc_state(state, new_conn_state->crtc);
4304
4305		/* No modeset means no payload changes, so it's safe to not pull in the MST state */
4306		if (!crtc_state || !drm_atomic_crtc_needs_modeset(crtc_state))
4307			return 0;
4308
4309		if (!crtc_state->mode_changed && !crtc_state->connectors_changed)
4310			update_payload = false;
4311	}
4312
4313	topology_state = drm_atomic_get_mst_topology_state(state, mgr);
4314	if (IS_ERR(topology_state))
4315		return PTR_ERR(topology_state);
4316
4317	topology_state->pending_crtc_mask |= drm_crtc_mask(old_conn_state->crtc);
4318	if (!update_payload)
4319		return 0;
4320
4321	payload = drm_atomic_get_mst_payload_state(topology_state, port);
4322	if (WARN_ON(!payload)) {
4323		drm_err(mgr->dev, "No payload for [MST PORT:%p] found in mst state %p\n",
4324			port, &topology_state->base);
4325		return -EINVAL;
4326	}
4327
4328	if (new_conn_state->crtc)
4329		return 0;
4330
4331	drm_dbg_atomic(mgr->dev, "[MST PORT:%p] TU %d -> 0\n", port, payload->time_slots);
4332	if (!payload->delete) {
4333		payload->pbn = 0;
4334		payload->delete = true;
4335		topology_state->payload_mask &= ~BIT(payload->vcpi - 1);
4336	}
4337
4338	return 0;
4339}
4340EXPORT_SYMBOL(drm_dp_atomic_release_time_slots);
4341
4342/**
4343 * drm_dp_mst_atomic_setup_commit() - setup_commit hook for MST helpers
4344 * @state: global atomic state
4345 *
4346 * This function saves all of the &drm_crtc_commit structs in an atomic state that touch any CRTCs
4347 * currently assigned to an MST topology. Drivers must call this hook from their
4348 * &drm_mode_config_helper_funcs.atomic_commit_setup hook.
4349 *
4350 * Returns:
4351 * 0 if all CRTC commits were retrieved successfully, negative error code otherwise
4352 */
4353int drm_dp_mst_atomic_setup_commit(struct drm_atomic_state *state)
4354{
4355	struct drm_dp_mst_topology_mgr *mgr;
4356	struct drm_dp_mst_topology_state *mst_state;
4357	struct drm_crtc *crtc;
4358	struct drm_crtc_state *crtc_state;
4359	int i, j, commit_idx, num_commit_deps;
4360
4361	for_each_new_mst_mgr_in_state(state, mgr, mst_state, i) {
4362		if (!mst_state->pending_crtc_mask)
4363			continue;
4364
4365		num_commit_deps = hweight32(mst_state->pending_crtc_mask);
4366		mst_state->commit_deps = kmalloc_array(num_commit_deps,
4367						       sizeof(*mst_state->commit_deps), GFP_KERNEL);
4368		if (!mst_state->commit_deps)
4369			return -ENOMEM;
4370		mst_state->num_commit_deps = num_commit_deps;
4371
4372		commit_idx = 0;
4373		for_each_new_crtc_in_state(state, crtc, crtc_state, j) {
4374			if (mst_state->pending_crtc_mask & drm_crtc_mask(crtc)) {
4375				mst_state->commit_deps[commit_idx++] =
4376					drm_crtc_commit_get(crtc_state->commit);
4377			}
4378		}
4379	}
4380
4381	return 0;
4382}
4383EXPORT_SYMBOL(drm_dp_mst_atomic_setup_commit);
4384
4385/**
4386 * drm_dp_mst_atomic_wait_for_dependencies() - Wait for all pending commits on MST topologies,
4387 * prepare new MST state for commit
4388 * @state: global atomic state
4389 *
4390 * Goes through any MST topologies in this atomic state, and waits for any pending commits which
4391 * touched CRTCs that were/are on an MST topology to be programmed to hardware and flipped to before
4392 * returning. This is to prevent multiple non-blocking commits affecting an MST topology from racing
4393 * with eachother by forcing them to be executed sequentially in situations where the only resources
4394 * the modeset objects in these commits share are an MST topology.
4395 *
4396 * This function also prepares the new MST state for commit by performing some state preparation
4397 * which can't be done until this point, such as reading back the final VC start slots (which are
4398 * determined at commit-time) from the previous state.
4399 *
4400 * All MST drivers must call this function after calling drm_atomic_helper_wait_for_dependencies(),
4401 * or whatever their equivalent of that is.
4402 */
4403void drm_dp_mst_atomic_wait_for_dependencies(struct drm_atomic_state *state)
4404{
4405	struct drm_dp_mst_topology_state *old_mst_state, *new_mst_state;
4406	struct drm_dp_mst_topology_mgr *mgr;
4407	struct drm_dp_mst_atomic_payload *old_payload, *new_payload;
4408	int i, j, ret;
4409
4410	for_each_oldnew_mst_mgr_in_state(state, mgr, old_mst_state, new_mst_state, i) {
4411		for (j = 0; j < old_mst_state->num_commit_deps; j++) {
4412			ret = drm_crtc_commit_wait(old_mst_state->commit_deps[j]);
4413			if (ret < 0)
4414				drm_err(state->dev, "Failed to wait for %s: %d\n",
4415					old_mst_state->commit_deps[j]->crtc->name, ret);
4416		}
4417
4418		/* Now that previous state is committed, it's safe to copy over the start slot
4419		 * assignments
4420		 */
4421		list_for_each_entry(old_payload, &old_mst_state->payloads, next) {
4422			if (old_payload->delete)
4423				continue;
4424
4425			new_payload = drm_atomic_get_mst_payload_state(new_mst_state,
4426								       old_payload->port);
4427			new_payload->vc_start_slot = old_payload->vc_start_slot;
4428		}
4429	}
4430}
4431EXPORT_SYMBOL(drm_dp_mst_atomic_wait_for_dependencies);
4432
4433/**
4434 * drm_dp_mst_root_conn_atomic_check() - Serialize CRTC commits on MST-capable connectors operating
4435 * in SST mode
4436 * @new_conn_state: The new connector state of the &drm_connector
4437 * @mgr: The MST topology manager for the &drm_connector
4438 *
4439 * Since MST uses fake &drm_encoder structs, the generic atomic modesetting code isn't able to
4440 * serialize non-blocking commits happening on the real DP connector of an MST topology switching
4441 * into/away from MST mode - as the CRTC on the real DP connector and the CRTCs on the connector's
4442 * MST topology will never share the same &drm_encoder.
4443 *
4444 * This function takes care of this serialization issue, by checking a root MST connector's atomic
4445 * state to determine if it is about to have a modeset - and then pulling in the MST topology state
4446 * if so, along with adding any relevant CRTCs to &drm_dp_mst_topology_state.pending_crtc_mask.
4447 *
4448 * Drivers implementing MST must call this function from the
4449 * &drm_connector_helper_funcs.atomic_check hook of any physical DP &drm_connector capable of
4450 * driving MST sinks.
4451 *
4452 * Returns:
4453 * 0 on success, negative error code otherwise
4454 */
4455int drm_dp_mst_root_conn_atomic_check(struct drm_connector_state *new_conn_state,
4456				      struct drm_dp_mst_topology_mgr *mgr)
4457{
4458	struct drm_atomic_state *state = new_conn_state->state;
4459	struct drm_connector_state *old_conn_state =
4460		drm_atomic_get_old_connector_state(state, new_conn_state->connector);
4461	struct drm_crtc_state *crtc_state;
4462	struct drm_dp_mst_topology_state *mst_state = NULL;
4463
4464	if (new_conn_state->crtc) {
4465		crtc_state = drm_atomic_get_new_crtc_state(state, new_conn_state->crtc);
4466		if (crtc_state && drm_atomic_crtc_needs_modeset(crtc_state)) {
4467			mst_state = drm_atomic_get_mst_topology_state(state, mgr);
4468			if (IS_ERR(mst_state))
4469				return PTR_ERR(mst_state);
4470
4471			mst_state->pending_crtc_mask |= drm_crtc_mask(new_conn_state->crtc);
4472		}
4473	}
4474
4475	if (old_conn_state->crtc) {
4476		crtc_state = drm_atomic_get_new_crtc_state(state, old_conn_state->crtc);
4477		if (crtc_state && drm_atomic_crtc_needs_modeset(crtc_state)) {
4478			if (!mst_state) {
4479				mst_state = drm_atomic_get_mst_topology_state(state, mgr);
4480				if (IS_ERR(mst_state))
4481					return PTR_ERR(mst_state);
4482			}
4483
4484			mst_state->pending_crtc_mask |= drm_crtc_mask(old_conn_state->crtc);
4485		}
4486	}
4487
4488	return 0;
4489}
4490EXPORT_SYMBOL(drm_dp_mst_root_conn_atomic_check);
4491
4492/**
4493 * drm_dp_mst_update_slots() - updates the slot info depending on the DP ecoding format
4494 * @mst_state: mst_state to update
4495 * @link_encoding_cap: the ecoding format on the link
4496 */
4497void drm_dp_mst_update_slots(struct drm_dp_mst_topology_state *mst_state, uint8_t link_encoding_cap)
4498{
4499	if (link_encoding_cap == DP_CAP_ANSI_128B132B) {
4500		mst_state->total_avail_slots = 64;
4501		mst_state->start_slot = 0;
4502	} else {
4503		mst_state->total_avail_slots = 63;
4504		mst_state->start_slot = 1;
4505	}
4506
4507	DRM_DEBUG_KMS("%s encoding format on mst_state 0x%p\n",
4508		      (link_encoding_cap == DP_CAP_ANSI_128B132B) ? "128b/132b":"8b/10b",
4509		      mst_state);
4510}
4511EXPORT_SYMBOL(drm_dp_mst_update_slots);
4512
4513static int drm_dp_dpcd_write_payload(struct drm_dp_mst_topology_mgr *mgr,
4514				     int id, u8 start_slot, u8 num_slots)
4515{
4516	u8 payload_alloc[3], status;
4517	int ret;
4518	int retries = 0;
4519
4520	drm_dp_dpcd_writeb(mgr->aux, DP_PAYLOAD_TABLE_UPDATE_STATUS,
4521			   DP_PAYLOAD_TABLE_UPDATED);
4522
4523	payload_alloc[0] = id;
4524	payload_alloc[1] = start_slot;
4525	payload_alloc[2] = num_slots;
4526
4527	ret = drm_dp_dpcd_write(mgr->aux, DP_PAYLOAD_ALLOCATE_SET, payload_alloc, 3);
4528	if (ret != 3) {
4529		drm_dbg_kms(mgr->dev, "failed to write payload allocation %d\n", ret);
4530		goto fail;
4531	}
4532
4533retry:
4534	ret = drm_dp_dpcd_readb(mgr->aux, DP_PAYLOAD_TABLE_UPDATE_STATUS, &status);
4535	if (ret < 0) {
4536		drm_dbg_kms(mgr->dev, "failed to read payload table status %d\n", ret);
4537		goto fail;
4538	}
4539
4540	if (!(status & DP_PAYLOAD_TABLE_UPDATED)) {
4541		retries++;
4542		if (retries < 20) {
4543			usleep_range(10000, 20000);
4544			goto retry;
4545		}
4546		drm_dbg_kms(mgr->dev, "status not set after read payload table status %d\n",
4547			    status);
4548		ret = -EINVAL;
4549		goto fail;
4550	}
4551	ret = 0;
4552fail:
4553	return ret;
4554}
4555
4556static int do_get_act_status(struct drm_dp_aux *aux)
4557{
4558	int ret;
4559	u8 status;
4560
4561	ret = drm_dp_dpcd_readb(aux, DP_PAYLOAD_TABLE_UPDATE_STATUS, &status);
4562	if (ret < 0)
4563		return ret;
4564
4565	return status;
4566}
4567
4568/**
4569 * drm_dp_check_act_status() - Polls for ACT handled status.
4570 * @mgr: manager to use
4571 *
4572 * Tries waiting for the MST hub to finish updating it's payload table by
4573 * polling for the ACT handled bit for up to 3 seconds (yes-some hubs really
4574 * take that long).
4575 *
4576 * Returns:
4577 * 0 if the ACT was handled in time, negative error code on failure.
4578 */
4579int drm_dp_check_act_status(struct drm_dp_mst_topology_mgr *mgr)
4580{
4581	/*
4582	 * There doesn't seem to be any recommended retry count or timeout in
4583	 * the MST specification. Since some hubs have been observed to take
4584	 * over 1 second to update their payload allocations under certain
4585	 * conditions, we use a rather large timeout value.
4586	 */
4587	const int timeout_ms = 3000;
4588	int ret, status;
4589
4590	ret = readx_poll_timeout(do_get_act_status, mgr->aux, status,
4591				 status & DP_PAYLOAD_ACT_HANDLED || status < 0,
4592				 200, timeout_ms * USEC_PER_MSEC);
4593	if (ret < 0 && status >= 0) {
4594		drm_err(mgr->dev, "Failed to get ACT after %dms, last status: %02x\n",
4595			timeout_ms, status);
4596		return -EINVAL;
4597	} else if (status < 0) {
4598		/*
4599		 * Failure here isn't unexpected - the hub may have
4600		 * just been unplugged
4601		 */
4602		drm_dbg_kms(mgr->dev, "Failed to read payload table status: %d\n", status);
4603		return status;
4604	}
4605
4606	return 0;
4607}
4608EXPORT_SYMBOL(drm_dp_check_act_status);
4609
4610/**
4611 * drm_dp_calc_pbn_mode() - Calculate the PBN for a mode.
4612 * @clock: dot clock for the mode
4613 * @bpp: bpp for the mode.
4614 * @dsc: DSC mode. If true, bpp has units of 1/16 of a bit per pixel
4615 *
4616 * This uses the formula in the spec to calculate the PBN value for a mode.
4617 */
4618int drm_dp_calc_pbn_mode(int clock, int bpp, bool dsc)
4619{
4620	/*
4621	 * margin 5300ppm + 300ppm ~ 0.6% as per spec, factor is 1.006
4622	 * The unit of 54/64Mbytes/sec is an arbitrary unit chosen based on
4623	 * common multiplier to render an integer PBN for all link rate/lane
4624	 * counts combinations
4625	 * calculate
4626	 * peak_kbps *= (1006/1000)
4627	 * peak_kbps *= (64/54)
4628	 * peak_kbps *= 8    convert to bytes
4629	 *
4630	 * If the bpp is in units of 1/16, further divide by 16. Put this
4631	 * factor in the numerator rather than the denominator to avoid
4632	 * integer overflow
4633	 */
4634
4635	if (dsc)
4636		return DIV_ROUND_UP_ULL(mul_u32_u32(clock * (bpp / 16), 64 * 1006),
4637					8 * 54 * 1000 * 1000);
4638
4639	return DIV_ROUND_UP_ULL(mul_u32_u32(clock * bpp, 64 * 1006),
4640				8 * 54 * 1000 * 1000);
4641}
4642EXPORT_SYMBOL(drm_dp_calc_pbn_mode);
4643
4644/* we want to kick the TX after we've ack the up/down IRQs. */
4645static void drm_dp_mst_kick_tx(struct drm_dp_mst_topology_mgr *mgr)
4646{
4647	queue_work(system_long_wq, &mgr->tx_work);
4648}
4649
4650/*
4651 * Helper function for parsing DP device types into convenient strings
4652 * for use with dp_mst_topology
4653 */
4654static const char *pdt_to_string(u8 pdt)
4655{
4656	switch (pdt) {
4657	case DP_PEER_DEVICE_NONE:
4658		return "NONE";
4659	case DP_PEER_DEVICE_SOURCE_OR_SST:
4660		return "SOURCE OR SST";
4661	case DP_PEER_DEVICE_MST_BRANCHING:
4662		return "MST BRANCHING";
4663	case DP_PEER_DEVICE_SST_SINK:
4664		return "SST SINK";
4665	case DP_PEER_DEVICE_DP_LEGACY_CONV:
4666		return "DP LEGACY CONV";
4667	default:
4668		return "ERR";
4669	}
4670}
4671
4672static void drm_dp_mst_dump_mstb(struct seq_file *m,
4673				 struct drm_dp_mst_branch *mstb)
4674{
4675	struct drm_dp_mst_port *port;
4676	int tabs = mstb->lct;
4677	char prefix[10];
4678	int i;
4679
4680	for (i = 0; i < tabs; i++)
4681		prefix[i] = '\t';
4682	prefix[i] = '\0';
4683
4684	seq_printf(m, "%smstb - [%p]: num_ports: %d\n", prefix, mstb, mstb->num_ports);
4685	list_for_each_entry(port, &mstb->ports, next) {
4686		seq_printf(m, "%sport %d - [%p] (%s - %s): ddps: %d, ldps: %d, sdp: %d/%d, fec: %s, conn: %p\n",
4687			   prefix,
4688			   port->port_num,
4689			   port,
4690			   port->input ? "input" : "output",
4691			   pdt_to_string(port->pdt),
4692			   port->ddps,
4693			   port->ldps,
4694			   port->num_sdp_streams,
4695			   port->num_sdp_stream_sinks,
4696			   port->fec_capable ? "true" : "false",
4697			   port->connector);
4698		if (port->mstb)
4699			drm_dp_mst_dump_mstb(m, port->mstb);
4700	}
4701}
4702
4703#define DP_PAYLOAD_TABLE_SIZE		64
4704
4705static bool dump_dp_payload_table(struct drm_dp_mst_topology_mgr *mgr,
4706				  char *buf)
4707{
4708	int i;
4709
4710	for (i = 0; i < DP_PAYLOAD_TABLE_SIZE; i += 16) {
4711		if (drm_dp_dpcd_read(mgr->aux,
4712				     DP_PAYLOAD_TABLE_UPDATE_STATUS + i,
4713				     &buf[i], 16) != 16)
4714			return false;
4715	}
4716	return true;
4717}
4718
4719static void fetch_monitor_name(struct drm_dp_mst_topology_mgr *mgr,
4720			       struct drm_dp_mst_port *port, char *name,
4721			       int namelen)
4722{
4723	struct edid *mst_edid;
4724
4725	mst_edid = drm_dp_mst_get_edid(port->connector, mgr, port);
4726	drm_edid_get_monitor_name(mst_edid, name, namelen);
4727	kfree(mst_edid);
4728}
4729
4730/**
4731 * drm_dp_mst_dump_topology(): dump topology to seq file.
4732 * @m: seq_file to dump output to
4733 * @mgr: manager to dump current topology for.
4734 *
4735 * helper to dump MST topology to a seq file for debugfs.
4736 */
4737void drm_dp_mst_dump_topology(struct seq_file *m,
4738			      struct drm_dp_mst_topology_mgr *mgr)
4739{
4740	struct drm_dp_mst_topology_state *state;
4741	struct drm_dp_mst_atomic_payload *payload;
4742	int i, ret;
4743
4744	mutex_lock(&mgr->lock);
4745	if (mgr->mst_primary)
4746		drm_dp_mst_dump_mstb(m, mgr->mst_primary);
4747
4748	/* dump VCPIs */
4749	mutex_unlock(&mgr->lock);
4750
4751	ret = drm_modeset_lock_single_interruptible(&mgr->base.lock);
4752	if (ret < 0)
4753		return;
4754
4755	state = to_drm_dp_mst_topology_state(mgr->base.state);
4756	seq_printf(m, "\n*** Atomic state info ***\n");
4757	seq_printf(m, "payload_mask: %x, max_payloads: %d, start_slot: %u, pbn_div: %d\n",
4758		   state->payload_mask, mgr->max_payloads, state->start_slot, state->pbn_div);
4759
4760	seq_printf(m, "\n| idx | port | vcpi | slots | pbn | dsc |     sink name     |\n");
4761	for (i = 0; i < mgr->max_payloads; i++) {
4762		list_for_each_entry(payload, &state->payloads, next) {
4763			char name[14];
4764
4765			if (payload->vcpi != i || payload->delete)
4766				continue;
4767
4768			fetch_monitor_name(mgr, payload->port, name, sizeof(name));
4769			seq_printf(m, " %5d %6d %6d %02d - %02d %5d %5s %19s\n",
4770				   i,
4771				   payload->port->port_num,
4772				   payload->vcpi,
4773				   payload->vc_start_slot,
4774				   payload->vc_start_slot + payload->time_slots - 1,
4775				   payload->pbn,
4776				   payload->dsc_enabled ? "Y" : "N",
4777				   (*name != 0) ? name : "Unknown");
4778		}
4779	}
4780
4781	seq_printf(m, "\n*** DPCD Info ***\n");
4782	mutex_lock(&mgr->lock);
4783	if (mgr->mst_primary) {
4784		u8 buf[DP_PAYLOAD_TABLE_SIZE];
4785		int ret;
4786
4787		if (drm_dp_read_dpcd_caps(mgr->aux, buf) < 0) {
4788			seq_printf(m, "dpcd read failed\n");
4789			goto out;
4790		}
4791		seq_printf(m, "dpcd: %*ph\n", DP_RECEIVER_CAP_SIZE, buf);
4792
4793		ret = drm_dp_dpcd_read(mgr->aux, DP_FAUX_CAP, buf, 2);
4794		if (ret != 2) {
4795			seq_printf(m, "faux/mst read failed\n");
4796			goto out;
4797		}
4798		seq_printf(m, "faux/mst: %*ph\n", 2, buf);
4799
4800		ret = drm_dp_dpcd_read(mgr->aux, DP_MSTM_CTRL, buf, 1);
4801		if (ret != 1) {
4802			seq_printf(m, "mst ctrl read failed\n");
4803			goto out;
4804		}
4805		seq_printf(m, "mst ctrl: %*ph\n", 1, buf);
4806
4807		/* dump the standard OUI branch header */
4808		ret = drm_dp_dpcd_read(mgr->aux, DP_BRANCH_OUI, buf, DP_BRANCH_OUI_HEADER_SIZE);
4809		if (ret != DP_BRANCH_OUI_HEADER_SIZE) {
4810			seq_printf(m, "branch oui read failed\n");
4811			goto out;
4812		}
4813		seq_printf(m, "branch oui: %*phN devid: ", 3, buf);
4814
4815		for (i = 0x3; i < 0x8 && buf[i]; i++)
4816			seq_printf(m, "%c", buf[i]);
4817		seq_printf(m, " revision: hw: %x.%x sw: %x.%x\n",
4818			   buf[0x9] >> 4, buf[0x9] & 0xf, buf[0xa], buf[0xb]);
4819		if (dump_dp_payload_table(mgr, buf))
4820			seq_printf(m, "payload table: %*ph\n", DP_PAYLOAD_TABLE_SIZE, buf);
4821	}
4822
4823out:
4824	mutex_unlock(&mgr->lock);
4825	drm_modeset_unlock(&mgr->base.lock);
4826}
4827EXPORT_SYMBOL(drm_dp_mst_dump_topology);
4828
4829static void drm_dp_tx_work(struct work_struct *work)
4830{
4831	struct drm_dp_mst_topology_mgr *mgr = container_of(work, struct drm_dp_mst_topology_mgr, tx_work);
4832
4833	mutex_lock(&mgr->qlock);
4834	if (!list_empty(&mgr->tx_msg_downq))
4835		process_single_down_tx_qlock(mgr);
4836	mutex_unlock(&mgr->qlock);
4837}
4838
4839static inline void
4840drm_dp_delayed_destroy_port(struct drm_dp_mst_port *port)
4841{
4842	drm_dp_port_set_pdt(port, DP_PEER_DEVICE_NONE, port->mcs);
4843
4844	if (port->connector) {
4845		drm_connector_unregister(port->connector);
4846		drm_connector_put(port->connector);
4847	}
4848
4849	drm_dp_mst_put_port_malloc(port);
4850}
4851
4852static inline void
4853drm_dp_delayed_destroy_mstb(struct drm_dp_mst_branch *mstb)
4854{
4855	struct drm_dp_mst_topology_mgr *mgr = mstb->mgr;
4856	struct drm_dp_mst_port *port, *port_tmp;
4857	struct drm_dp_sideband_msg_tx *txmsg, *txmsg_tmp;
4858	bool wake_tx = false;
4859
4860	mutex_lock(&mgr->lock);
4861	list_for_each_entry_safe(port, port_tmp, &mstb->ports, next) {
4862		list_del(&port->next);
4863		drm_dp_mst_topology_put_port(port);
4864	}
4865	mutex_unlock(&mgr->lock);
4866
4867	/* drop any tx slot msg */
4868	mutex_lock(&mstb->mgr->qlock);
4869	list_for_each_entry_safe(txmsg, txmsg_tmp, &mgr->tx_msg_downq, next) {
4870		if (txmsg->dst != mstb)
4871			continue;
4872
4873		txmsg->state = DRM_DP_SIDEBAND_TX_TIMEOUT;
4874		list_del(&txmsg->next);
4875		wake_tx = true;
4876	}
4877	mutex_unlock(&mstb->mgr->qlock);
4878
4879	if (wake_tx)
4880		wake_up_all(&mstb->mgr->tx_waitq);
4881
4882	drm_dp_mst_put_mstb_malloc(mstb);
4883}
4884
4885static void drm_dp_delayed_destroy_work(struct work_struct *work)
4886{
4887	struct drm_dp_mst_topology_mgr *mgr =
4888		container_of(work, struct drm_dp_mst_topology_mgr,
4889			     delayed_destroy_work);
4890	bool send_hotplug = false, go_again;
4891
4892	/*
4893	 * Not a regular list traverse as we have to drop the destroy
4894	 * connector lock before destroying the mstb/port, to avoid AB->BA
4895	 * ordering between this lock and the config mutex.
4896	 */
4897	do {
4898		go_again = false;
4899
4900		for (;;) {
4901			struct drm_dp_mst_branch *mstb;
4902
4903			mutex_lock(&mgr->delayed_destroy_lock);
4904			mstb = list_first_entry_or_null(&mgr->destroy_branch_device_list,
4905							struct drm_dp_mst_branch,
4906							destroy_next);
4907			if (mstb)
4908				list_del(&mstb->destroy_next);
4909			mutex_unlock(&mgr->delayed_destroy_lock);
4910
4911			if (!mstb)
4912				break;
4913
4914			drm_dp_delayed_destroy_mstb(mstb);
4915			go_again = true;
4916		}
4917
4918		for (;;) {
4919			struct drm_dp_mst_port *port;
4920
4921			mutex_lock(&mgr->delayed_destroy_lock);
4922			port = list_first_entry_or_null(&mgr->destroy_port_list,
4923							struct drm_dp_mst_port,
4924							next);
4925			if (port)
4926				list_del(&port->next);
4927			mutex_unlock(&mgr->delayed_destroy_lock);
4928
4929			if (!port)
4930				break;
4931
4932			drm_dp_delayed_destroy_port(port);
4933			send_hotplug = true;
4934			go_again = true;
4935		}
4936	} while (go_again);
4937
4938	if (send_hotplug)
4939		drm_kms_helper_hotplug_event(mgr->dev);
4940}
4941
4942static struct drm_private_state *
4943drm_dp_mst_duplicate_state(struct drm_private_obj *obj)
4944{
4945	struct drm_dp_mst_topology_state *state, *old_state =
4946		to_dp_mst_topology_state(obj->state);
4947	struct drm_dp_mst_atomic_payload *pos, *payload;
4948
4949	state = kmemdup(old_state, sizeof(*state), GFP_KERNEL);
4950	if (!state)
4951		return NULL;
4952
4953	__drm_atomic_helper_private_obj_duplicate_state(obj, &state->base);
4954
4955	INIT_LIST_HEAD(&state->payloads);
4956	state->commit_deps = NULL;
4957	state->num_commit_deps = 0;
4958	state->pending_crtc_mask = 0;
4959
4960	list_for_each_entry(pos, &old_state->payloads, next) {
4961		/* Prune leftover freed timeslot allocations */
4962		if (pos->delete)
4963			continue;
4964
4965		payload = kmemdup(pos, sizeof(*payload), GFP_KERNEL);
4966		if (!payload)
4967			goto fail;
4968
4969		drm_dp_mst_get_port_malloc(payload->port);
4970		list_add(&payload->next, &state->payloads);
4971	}
4972
4973	return &state->base;
4974
4975fail:
4976	list_for_each_entry_safe(pos, payload, &state->payloads, next) {
4977		drm_dp_mst_put_port_malloc(pos->port);
4978		kfree(pos);
4979	}
4980	kfree(state);
4981
4982	return NULL;
4983}
4984
4985static void drm_dp_mst_destroy_state(struct drm_private_obj *obj,
4986				     struct drm_private_state *state)
4987{
4988	struct drm_dp_mst_topology_state *mst_state =
4989		to_dp_mst_topology_state(state);
4990	struct drm_dp_mst_atomic_payload *pos, *tmp;
4991	int i;
4992
4993	list_for_each_entry_safe(pos, tmp, &mst_state->payloads, next) {
4994		/* We only keep references to ports with active payloads */
4995		if (!pos->delete)
4996			drm_dp_mst_put_port_malloc(pos->port);
4997		kfree(pos);
4998	}
4999
5000	for (i = 0; i < mst_state->num_commit_deps; i++)
5001		drm_crtc_commit_put(mst_state->commit_deps[i]);
5002
5003	kfree(mst_state->commit_deps);
5004	kfree(mst_state);
5005}
5006
5007static bool drm_dp_mst_port_downstream_of_branch(struct drm_dp_mst_port *port,
5008						 struct drm_dp_mst_branch *branch)
5009{
5010	while (port->parent) {
5011		if (port->parent == branch)
5012			return true;
5013
5014		if (port->parent->port_parent)
5015			port = port->parent->port_parent;
5016		else
5017			break;
5018	}
5019	return false;
5020}
5021
5022static int
5023drm_dp_mst_atomic_check_port_bw_limit(struct drm_dp_mst_port *port,
5024				      struct drm_dp_mst_topology_state *state);
5025
5026static int
5027drm_dp_mst_atomic_check_mstb_bw_limit(struct drm_dp_mst_branch *mstb,
5028				      struct drm_dp_mst_topology_state *state)
5029{
5030	struct drm_dp_mst_atomic_payload *payload;
5031	struct drm_dp_mst_port *port;
5032	int pbn_used = 0, ret;
5033	bool found = false;
5034
5035	/* Check that we have at least one port in our state that's downstream
5036	 * of this branch, otherwise we can skip this branch
5037	 */
5038	list_for_each_entry(payload, &state->payloads, next) {
5039		if (!payload->pbn ||
5040		    !drm_dp_mst_port_downstream_of_branch(payload->port, mstb))
5041			continue;
5042
5043		found = true;
5044		break;
5045	}
5046	if (!found)
5047		return 0;
5048
5049	if (mstb->port_parent)
5050		drm_dbg_atomic(mstb->mgr->dev,
5051			       "[MSTB:%p] [MST PORT:%p] Checking bandwidth limits on [MSTB:%p]\n",
5052			       mstb->port_parent->parent, mstb->port_parent, mstb);
5053	else
5054		drm_dbg_atomic(mstb->mgr->dev, "[MSTB:%p] Checking bandwidth limits\n", mstb);
5055
5056	list_for_each_entry(port, &mstb->ports, next) {
5057		ret = drm_dp_mst_atomic_check_port_bw_limit(port, state);
5058		if (ret < 0)
5059			return ret;
5060
5061		pbn_used += ret;
5062	}
5063
5064	return pbn_used;
5065}
5066
5067static int
5068drm_dp_mst_atomic_check_port_bw_limit(struct drm_dp_mst_port *port,
5069				      struct drm_dp_mst_topology_state *state)
5070{
5071	struct drm_dp_mst_atomic_payload *payload;
5072	int pbn_used = 0;
5073
5074	if (port->pdt == DP_PEER_DEVICE_NONE)
5075		return 0;
5076
5077	if (drm_dp_mst_is_end_device(port->pdt, port->mcs)) {
5078		payload = drm_atomic_get_mst_payload_state(state, port);
5079		if (!payload)
5080			return 0;
5081
5082		/*
5083		 * This could happen if the sink deasserted its HPD line, but
5084		 * the branch device still reports it as attached (PDT != NONE).
5085		 */
5086		if (!port->full_pbn) {
5087			drm_dbg_atomic(port->mgr->dev,
5088				       "[MSTB:%p] [MST PORT:%p] no BW available for the port\n",
5089				       port->parent, port);
5090			return -EINVAL;
5091		}
5092
5093		pbn_used = payload->pbn;
5094	} else {
5095		pbn_used = drm_dp_mst_atomic_check_mstb_bw_limit(port->mstb,
5096								 state);
5097		if (pbn_used <= 0)
5098			return pbn_used;
5099	}
5100
5101	if (pbn_used > port->full_pbn) {
5102		drm_dbg_atomic(port->mgr->dev,
5103			       "[MSTB:%p] [MST PORT:%p] required PBN of %d exceeds port limit of %d\n",
5104			       port->parent, port, pbn_used, port->full_pbn);
5105		return -ENOSPC;
5106	}
5107
5108	drm_dbg_atomic(port->mgr->dev, "[MSTB:%p] [MST PORT:%p] uses %d out of %d PBN\n",
5109		       port->parent, port, pbn_used, port->full_pbn);
5110
5111	return pbn_used;
5112}
5113
5114static inline int
5115drm_dp_mst_atomic_check_payload_alloc_limits(struct drm_dp_mst_topology_mgr *mgr,
5116					     struct drm_dp_mst_topology_state *mst_state)
5117{
5118	struct drm_dp_mst_atomic_payload *payload;
5119	int avail_slots = mst_state->total_avail_slots, payload_count = 0;
5120
5121	list_for_each_entry(payload, &mst_state->payloads, next) {
5122		/* Releasing payloads is always OK-even if the port is gone */
5123		if (payload->delete) {
5124			drm_dbg_atomic(mgr->dev, "[MST PORT:%p] releases all time slots\n",
5125				       payload->port);
5126			continue;
5127		}
5128
5129		drm_dbg_atomic(mgr->dev, "[MST PORT:%p] requires %d time slots\n",
5130			       payload->port, payload->time_slots);
5131
5132		avail_slots -= payload->time_slots;
5133		if (avail_slots < 0) {
5134			drm_dbg_atomic(mgr->dev,
5135				       "[MST PORT:%p] not enough time slots in mst state %p (avail=%d)\n",
5136				       payload->port, mst_state, avail_slots + payload->time_slots);
5137			return -ENOSPC;
5138		}
5139
5140		if (++payload_count > mgr->max_payloads) {
5141			drm_dbg_atomic(mgr->dev,
5142				       "[MST MGR:%p] state %p has too many payloads (max=%d)\n",
5143				       mgr, mst_state, mgr->max_payloads);
5144			return -EINVAL;
5145		}
5146
5147		/* Assign a VCPI */
5148		if (!payload->vcpi) {
5149			payload->vcpi = ffz(mst_state->payload_mask) + 1;
5150			drm_dbg_atomic(mgr->dev, "[MST PORT:%p] assigned VCPI #%d\n",
5151				       payload->port, payload->vcpi);
5152			mst_state->payload_mask |= BIT(payload->vcpi - 1);
5153		}
5154	}
5155
5156	if (!payload_count)
5157		mst_state->pbn_div = 0;
5158
5159	drm_dbg_atomic(mgr->dev, "[MST MGR:%p] mst state %p TU pbn_div=%d avail=%d used=%d\n",
5160		       mgr, mst_state, mst_state->pbn_div, avail_slots,
5161		       mst_state->total_avail_slots - avail_slots);
5162
5163	return 0;
5164}
5165
5166/**
5167 * drm_dp_mst_add_affected_dsc_crtcs
5168 * @state: Pointer to the new struct drm_dp_mst_topology_state
5169 * @mgr: MST topology manager
5170 *
5171 * Whenever there is a change in mst topology
5172 * DSC configuration would have to be recalculated
5173 * therefore we need to trigger modeset on all affected
5174 * CRTCs in that topology
5175 *
5176 * See also:
5177 * drm_dp_mst_atomic_enable_dsc()
5178 */
5179int drm_dp_mst_add_affected_dsc_crtcs(struct drm_atomic_state *state, struct drm_dp_mst_topology_mgr *mgr)
5180{
5181	struct drm_dp_mst_topology_state *mst_state;
5182	struct drm_dp_mst_atomic_payload *pos;
5183	struct drm_connector *connector;
5184	struct drm_connector_state *conn_state;
5185	struct drm_crtc *crtc;
5186	struct drm_crtc_state *crtc_state;
5187
5188	mst_state = drm_atomic_get_mst_topology_state(state, mgr);
5189
5190	if (IS_ERR(mst_state))
5191		return PTR_ERR(mst_state);
5192
5193	list_for_each_entry(pos, &mst_state->payloads, next) {
5194
5195		connector = pos->port->connector;
5196
5197		if (!connector)
5198			return -EINVAL;
5199
5200		conn_state = drm_atomic_get_connector_state(state, connector);
5201
5202		if (IS_ERR(conn_state))
5203			return PTR_ERR(conn_state);
5204
5205		crtc = conn_state->crtc;
5206
5207		if (!crtc)
5208			continue;
5209
5210		if (!drm_dp_mst_dsc_aux_for_port(pos->port))
5211			continue;
5212
5213		crtc_state = drm_atomic_get_crtc_state(mst_state->base.state, crtc);
5214
5215		if (IS_ERR(crtc_state))
5216			return PTR_ERR(crtc_state);
5217
5218		drm_dbg_atomic(mgr->dev, "[MST MGR:%p] Setting mode_changed flag on CRTC %p\n",
5219			       mgr, crtc);
5220
5221		crtc_state->mode_changed = true;
5222	}
5223	return 0;
5224}
5225EXPORT_SYMBOL(drm_dp_mst_add_affected_dsc_crtcs);
5226
5227/**
5228 * drm_dp_mst_atomic_enable_dsc - Set DSC Enable Flag to On/Off
5229 * @state: Pointer to the new drm_atomic_state
5230 * @port: Pointer to the affected MST Port
5231 * @pbn: Newly recalculated bw required for link with DSC enabled
5232 * @enable: Boolean flag to enable or disable DSC on the port
5233 *
5234 * This function enables DSC on the given Port
5235 * by recalculating its vcpi from pbn provided
5236 * and sets dsc_enable flag to keep track of which
5237 * ports have DSC enabled
5238 *
5239 */
5240int drm_dp_mst_atomic_enable_dsc(struct drm_atomic_state *state,
5241				 struct drm_dp_mst_port *port,
5242				 int pbn, bool enable)
5243{
5244	struct drm_dp_mst_topology_state *mst_state;
5245	struct drm_dp_mst_atomic_payload *payload;
5246	int time_slots = 0;
5247
5248	mst_state = drm_atomic_get_mst_topology_state(state, port->mgr);
5249	if (IS_ERR(mst_state))
5250		return PTR_ERR(mst_state);
5251
5252	payload = drm_atomic_get_mst_payload_state(mst_state, port);
5253	if (!payload) {
5254		drm_dbg_atomic(state->dev,
5255			       "[MST PORT:%p] Couldn't find payload in mst state %p\n",
5256			       port, mst_state);
5257		return -EINVAL;
5258	}
5259
5260	if (payload->dsc_enabled == enable) {
5261		drm_dbg_atomic(state->dev,
5262			       "[MST PORT:%p] DSC flag is already set to %d, returning %d time slots\n",
5263			       port, enable, payload->time_slots);
5264		time_slots = payload->time_slots;
5265	}
5266
5267	if (enable) {
5268		time_slots = drm_dp_atomic_find_time_slots(state, port->mgr, port, pbn);
5269		drm_dbg_atomic(state->dev,
5270			       "[MST PORT:%p] Enabling DSC flag, reallocating %d time slots on the port\n",
5271			       port, time_slots);
5272		if (time_slots < 0)
5273			return -EINVAL;
5274	}
5275
5276	payload->dsc_enabled = enable;
5277
5278	return time_slots;
5279}
5280EXPORT_SYMBOL(drm_dp_mst_atomic_enable_dsc);
5281
5282/**
5283 * drm_dp_mst_atomic_check - Check that the new state of an MST topology in an
5284 * atomic update is valid
5285 * @state: Pointer to the new &struct drm_dp_mst_topology_state
5286 *
5287 * Checks the given topology state for an atomic update to ensure that it's
5288 * valid. This includes checking whether there's enough bandwidth to support
5289 * the new timeslot allocations in the atomic update.
5290 *
5291 * Any atomic drivers supporting DP MST must make sure to call this after
5292 * checking the rest of their state in their
5293 * &drm_mode_config_funcs.atomic_check() callback.
5294 *
5295 * See also:
5296 * drm_dp_atomic_find_time_slots()
5297 * drm_dp_atomic_release_time_slots()
5298 *
5299 * Returns:
5300 *
5301 * 0 if the new state is valid, negative error code otherwise.
5302 */
5303int drm_dp_mst_atomic_check(struct drm_atomic_state *state)
5304{
5305	struct drm_dp_mst_topology_mgr *mgr;
5306	struct drm_dp_mst_topology_state *mst_state;
5307	int i, ret = 0;
5308
5309	for_each_new_mst_mgr_in_state(state, mgr, mst_state, i) {
5310		if (!mgr->mst_state)
5311			continue;
5312
5313		ret = drm_dp_mst_atomic_check_payload_alloc_limits(mgr, mst_state);
5314		if (ret)
5315			break;
5316
5317		mutex_lock(&mgr->lock);
5318		ret = drm_dp_mst_atomic_check_mstb_bw_limit(mgr->mst_primary,
5319							    mst_state);
5320		mutex_unlock(&mgr->lock);
5321		if (ret < 0)
5322			break;
5323		else
5324			ret = 0;
5325	}
5326
5327	return ret;
5328}
5329EXPORT_SYMBOL(drm_dp_mst_atomic_check);
5330
5331const struct drm_private_state_funcs drm_dp_mst_topology_state_funcs = {
5332	.atomic_duplicate_state = drm_dp_mst_duplicate_state,
5333	.atomic_destroy_state = drm_dp_mst_destroy_state,
5334};
5335EXPORT_SYMBOL(drm_dp_mst_topology_state_funcs);
5336
5337/**
5338 * drm_atomic_get_mst_topology_state: get MST topology state
5339 * @state: global atomic state
5340 * @mgr: MST topology manager, also the private object in this case
5341 *
5342 * This function wraps drm_atomic_get_priv_obj_state() passing in the MST atomic
5343 * state vtable so that the private object state returned is that of a MST
5344 * topology object.
5345 *
5346 * RETURNS:
5347 *
5348 * The MST topology state or error pointer.
5349 */
5350struct drm_dp_mst_topology_state *drm_atomic_get_mst_topology_state(struct drm_atomic_state *state,
5351								    struct drm_dp_mst_topology_mgr *mgr)
5352{
5353	return to_dp_mst_topology_state(drm_atomic_get_private_obj_state(state, &mgr->base));
5354}
5355EXPORT_SYMBOL(drm_atomic_get_mst_topology_state);
5356
5357/**
5358 * drm_atomic_get_new_mst_topology_state: get new MST topology state in atomic state, if any
5359 * @state: global atomic state
5360 * @mgr: MST topology manager, also the private object in this case
5361 *
5362 * This function wraps drm_atomic_get_priv_obj_state() passing in the MST atomic
5363 * state vtable so that the private object state returned is that of a MST
5364 * topology object.
5365 *
5366 * Returns:
5367 *
5368 * The MST topology state, or NULL if there's no topology state for this MST mgr
5369 * in the global atomic state
5370 */
5371struct drm_dp_mst_topology_state *
5372drm_atomic_get_new_mst_topology_state(struct drm_atomic_state *state,
5373				      struct drm_dp_mst_topology_mgr *mgr)
5374{
5375	struct drm_private_state *priv_state =
5376		drm_atomic_get_new_private_obj_state(state, &mgr->base);
5377
5378	return priv_state ? to_dp_mst_topology_state(priv_state) : NULL;
5379}
5380EXPORT_SYMBOL(drm_atomic_get_new_mst_topology_state);
5381
5382/**
5383 * drm_dp_mst_topology_mgr_init - initialise a topology manager
5384 * @mgr: manager struct to initialise
5385 * @dev: device providing this structure - for i2c addition.
5386 * @aux: DP helper aux channel to talk to this device
5387 * @max_dpcd_transaction_bytes: hw specific DPCD transaction limit
5388 * @max_payloads: maximum number of payloads this GPU can source
5389 * @conn_base_id: the connector object ID the MST device is connected to.
5390 *
5391 * Return 0 for success, or negative error code on failure
5392 */
5393int drm_dp_mst_topology_mgr_init(struct drm_dp_mst_topology_mgr *mgr,
5394				 struct drm_device *dev, struct drm_dp_aux *aux,
5395				 int max_dpcd_transaction_bytes, int max_payloads,
5396				 int conn_base_id)
5397{
5398	struct drm_dp_mst_topology_state *mst_state;
5399
5400	mutex_init(&mgr->lock);
5401	mutex_init(&mgr->qlock);
5402	mutex_init(&mgr->delayed_destroy_lock);
5403	mutex_init(&mgr->up_req_lock);
5404	mutex_init(&mgr->probe_lock);
5405#if IS_ENABLED(CONFIG_DRM_DEBUG_DP_MST_TOPOLOGY_REFS)
5406	mutex_init(&mgr->topology_ref_history_lock);
5407	stack_depot_init();
5408#endif
5409	INIT_LIST_HEAD(&mgr->tx_msg_downq);
5410	INIT_LIST_HEAD(&mgr->destroy_port_list);
5411	INIT_LIST_HEAD(&mgr->destroy_branch_device_list);
5412	INIT_LIST_HEAD(&mgr->up_req_list);
5413
5414	/*
5415	 * delayed_destroy_work will be queued on a dedicated WQ, so that any
5416	 * requeuing will be also flushed when deiniting the topology manager.
5417	 */
5418	mgr->delayed_destroy_wq = alloc_ordered_workqueue("drm_dp_mst_wq", 0);
5419	if (mgr->delayed_destroy_wq == NULL)
5420		return -ENOMEM;
5421
5422	INIT_WORK(&mgr->work, drm_dp_mst_link_probe_work);
5423	INIT_WORK(&mgr->tx_work, drm_dp_tx_work);
5424	INIT_WORK(&mgr->delayed_destroy_work, drm_dp_delayed_destroy_work);
5425	INIT_WORK(&mgr->up_req_work, drm_dp_mst_up_req_work);
5426	init_waitqueue_head(&mgr->tx_waitq);
5427	mgr->dev = dev;
5428	mgr->aux = aux;
5429	mgr->max_dpcd_transaction_bytes = max_dpcd_transaction_bytes;
5430	mgr->max_payloads = max_payloads;
5431	mgr->conn_base_id = conn_base_id;
5432
5433	mst_state = kzalloc(sizeof(*mst_state), GFP_KERNEL);
5434	if (mst_state == NULL)
5435		return -ENOMEM;
5436
5437	mst_state->total_avail_slots = 63;
5438	mst_state->start_slot = 1;
5439
5440	mst_state->mgr = mgr;
5441	INIT_LIST_HEAD(&mst_state->payloads);
5442
5443	drm_atomic_private_obj_init(dev, &mgr->base,
5444				    &mst_state->base,
5445				    &drm_dp_mst_topology_state_funcs);
5446
5447	return 0;
5448}
5449EXPORT_SYMBOL(drm_dp_mst_topology_mgr_init);
5450
5451/**
5452 * drm_dp_mst_topology_mgr_destroy() - destroy topology manager.
5453 * @mgr: manager to destroy
5454 */
5455void drm_dp_mst_topology_mgr_destroy(struct drm_dp_mst_topology_mgr *mgr)
5456{
5457	drm_dp_mst_topology_mgr_set_mst(mgr, false);
5458	flush_work(&mgr->work);
5459	/* The following will also drain any requeued work on the WQ. */
5460	if (mgr->delayed_destroy_wq) {
5461		destroy_workqueue(mgr->delayed_destroy_wq);
5462		mgr->delayed_destroy_wq = NULL;
5463	}
5464	mgr->dev = NULL;
5465	mgr->aux = NULL;
5466	drm_atomic_private_obj_fini(&mgr->base);
5467	mgr->funcs = NULL;
5468
5469	mutex_destroy(&mgr->delayed_destroy_lock);
5470	mutex_destroy(&mgr->qlock);
5471	mutex_destroy(&mgr->lock);
5472	mutex_destroy(&mgr->up_req_lock);
5473	mutex_destroy(&mgr->probe_lock);
5474#if IS_ENABLED(CONFIG_DRM_DEBUG_DP_MST_TOPOLOGY_REFS)
5475	mutex_destroy(&mgr->topology_ref_history_lock);
5476#endif
5477}
5478EXPORT_SYMBOL(drm_dp_mst_topology_mgr_destroy);
5479
5480static bool remote_i2c_read_ok(const struct i2c_msg msgs[], int num)
5481{
5482	int i;
5483
5484	if (num - 1 > DP_REMOTE_I2C_READ_MAX_TRANSACTIONS)
5485		return false;
5486
5487	for (i = 0; i < num - 1; i++) {
5488		if (msgs[i].flags & I2C_M_RD ||
5489		    msgs[i].len > 0xff)
5490			return false;
5491	}
5492
5493	return msgs[num - 1].flags & I2C_M_RD &&
5494		msgs[num - 1].len <= 0xff;
5495}
5496
5497static bool remote_i2c_write_ok(const struct i2c_msg msgs[], int num)
5498{
5499	int i;
5500
5501	for (i = 0; i < num - 1; i++) {
5502		if (msgs[i].flags & I2C_M_RD || !(msgs[i].flags & I2C_M_STOP) ||
5503		    msgs[i].len > 0xff)
5504			return false;
5505	}
5506
5507	return !(msgs[num - 1].flags & I2C_M_RD) && msgs[num - 1].len <= 0xff;
5508}
5509
5510static int drm_dp_mst_i2c_read(struct drm_dp_mst_branch *mstb,
5511			       struct drm_dp_mst_port *port,
5512			       struct i2c_msg *msgs, int num)
5513{
5514	struct drm_dp_mst_topology_mgr *mgr = port->mgr;
5515	unsigned int i;
5516	struct drm_dp_sideband_msg_req_body msg;
5517	struct drm_dp_sideband_msg_tx *txmsg = NULL;
5518	int ret;
5519
5520	memset(&msg, 0, sizeof(msg));
5521	msg.req_type = DP_REMOTE_I2C_READ;
5522	msg.u.i2c_read.num_transactions = num - 1;
5523	msg.u.i2c_read.port_number = port->port_num;
5524	for (i = 0; i < num - 1; i++) {
5525		msg.u.i2c_read.transactions[i].i2c_dev_id = msgs[i].addr;
5526		msg.u.i2c_read.transactions[i].num_bytes = msgs[i].len;
5527		msg.u.i2c_read.transactions[i].bytes = msgs[i].buf;
5528		msg.u.i2c_read.transactions[i].no_stop_bit = !(msgs[i].flags & I2C_M_STOP);
5529	}
5530	msg.u.i2c_read.read_i2c_device_id = msgs[num - 1].addr;
5531	msg.u.i2c_read.num_bytes_read = msgs[num - 1].len;
5532
5533	txmsg = kzalloc(sizeof(*txmsg), GFP_KERNEL);
5534	if (!txmsg) {
5535		ret = -ENOMEM;
5536		goto out;
5537	}
5538
5539	txmsg->dst = mstb;
5540	drm_dp_encode_sideband_req(&msg, txmsg);
5541
5542	drm_dp_queue_down_tx(mgr, txmsg);
5543
5544	ret = drm_dp_mst_wait_tx_reply(mstb, txmsg);
5545	if (ret > 0) {
5546
5547		if (txmsg->reply.reply_type == DP_SIDEBAND_REPLY_NAK) {
5548			ret = -EREMOTEIO;
5549			goto out;
5550		}
5551		if (txmsg->reply.u.remote_i2c_read_ack.num_bytes != msgs[num - 1].len) {
5552			ret = -EIO;
5553			goto out;
5554		}
5555		memcpy(msgs[num - 1].buf, txmsg->reply.u.remote_i2c_read_ack.bytes, msgs[num - 1].len);
5556		ret = num;
5557	}
5558out:
5559	kfree(txmsg);
5560	return ret;
5561}
5562
5563static int drm_dp_mst_i2c_write(struct drm_dp_mst_branch *mstb,
5564				struct drm_dp_mst_port *port,
5565				struct i2c_msg *msgs, int num)
5566{
5567	struct drm_dp_mst_topology_mgr *mgr = port->mgr;
5568	unsigned int i;
5569	struct drm_dp_sideband_msg_req_body msg;
5570	struct drm_dp_sideband_msg_tx *txmsg = NULL;
5571	int ret;
5572
5573	txmsg = kzalloc(sizeof(*txmsg), GFP_KERNEL);
5574	if (!txmsg) {
5575		ret = -ENOMEM;
5576		goto out;
5577	}
5578	for (i = 0; i < num; i++) {
5579		memset(&msg, 0, sizeof(msg));
5580		msg.req_type = DP_REMOTE_I2C_WRITE;
5581		msg.u.i2c_write.port_number = port->port_num;
5582		msg.u.i2c_write.write_i2c_device_id = msgs[i].addr;
5583		msg.u.i2c_write.num_bytes = msgs[i].len;
5584		msg.u.i2c_write.bytes = msgs[i].buf;
5585
5586		memset(txmsg, 0, sizeof(*txmsg));
5587		txmsg->dst = mstb;
5588
5589		drm_dp_encode_sideband_req(&msg, txmsg);
5590		drm_dp_queue_down_tx(mgr, txmsg);
5591
5592		ret = drm_dp_mst_wait_tx_reply(mstb, txmsg);
5593		if (ret > 0) {
5594			if (txmsg->reply.reply_type == DP_SIDEBAND_REPLY_NAK) {
5595				ret = -EREMOTEIO;
5596				goto out;
5597			}
5598		} else {
5599			goto out;
5600		}
5601	}
5602	ret = num;
5603out:
5604	kfree(txmsg);
5605	return ret;
5606}
5607
5608/* I2C device */
5609static int drm_dp_mst_i2c_xfer(struct i2c_adapter *adapter,
5610			       struct i2c_msg *msgs, int num)
5611{
5612	struct drm_dp_aux *aux = adapter->algo_data;
5613	struct drm_dp_mst_port *port =
5614		container_of(aux, struct drm_dp_mst_port, aux);
5615	struct drm_dp_mst_branch *mstb;
5616	struct drm_dp_mst_topology_mgr *mgr = port->mgr;
5617	int ret;
5618
5619	mstb = drm_dp_mst_topology_get_mstb_validated(mgr, port->parent);
5620	if (!mstb)
5621		return -EREMOTEIO;
5622
5623	if (remote_i2c_read_ok(msgs, num)) {
5624		ret = drm_dp_mst_i2c_read(mstb, port, msgs, num);
5625	} else if (remote_i2c_write_ok(msgs, num)) {
5626		ret = drm_dp_mst_i2c_write(mstb, port, msgs, num);
5627	} else {
5628		drm_dbg_kms(mgr->dev, "Unsupported I2C transaction for MST device\n");
5629		ret = -EIO;
5630	}
5631
5632	drm_dp_mst_topology_put_mstb(mstb);
5633	return ret;
5634}
5635
5636static u32 drm_dp_mst_i2c_functionality(struct i2c_adapter *adapter)
5637{
5638	return I2C_FUNC_I2C | I2C_FUNC_SMBUS_EMUL |
5639	       I2C_FUNC_SMBUS_READ_BLOCK_DATA |
5640	       I2C_FUNC_SMBUS_BLOCK_PROC_CALL |
5641	       I2C_FUNC_10BIT_ADDR;
5642}
5643
5644static const struct i2c_algorithm drm_dp_mst_i2c_algo = {
5645	.functionality = drm_dp_mst_i2c_functionality,
5646	.master_xfer = drm_dp_mst_i2c_xfer,
5647};
5648
5649/**
5650 * drm_dp_mst_register_i2c_bus() - register an I2C adapter for I2C-over-AUX
5651 * @port: The port to add the I2C bus on
5652 *
5653 * Returns 0 on success or a negative error code on failure.
5654 */
5655static int drm_dp_mst_register_i2c_bus(struct drm_dp_mst_port *port)
5656{
5657	struct drm_dp_aux *aux = &port->aux;
5658	struct device *parent_dev = port->mgr->dev->dev;
5659
5660	aux->ddc.algo = &drm_dp_mst_i2c_algo;
5661	aux->ddc.algo_data = aux;
5662	aux->ddc.retries = 3;
5663
5664	aux->ddc.class = I2C_CLASS_DDC;
5665	aux->ddc.owner = THIS_MODULE;
5666	/* FIXME: set the kdev of the port's connector as parent */
5667	aux->ddc.dev.parent = parent_dev;
5668	aux->ddc.dev.of_node = parent_dev->of_node;
5669
5670	strlcpy(aux->ddc.name, aux->name ? aux->name : dev_name(parent_dev),
5671		sizeof(aux->ddc.name));
5672
5673	return i2c_add_adapter(&aux->ddc);
5674}
5675
5676/**
5677 * drm_dp_mst_unregister_i2c_bus() - unregister an I2C-over-AUX adapter
5678 * @port: The port to remove the I2C bus from
5679 */
5680static void drm_dp_mst_unregister_i2c_bus(struct drm_dp_mst_port *port)
5681{
5682	i2c_del_adapter(&port->aux.ddc);
5683}
5684
5685/**
5686 * drm_dp_mst_is_virtual_dpcd() - Is the given port a virtual DP Peer Device
5687 * @port: The port to check
5688 *
5689 * A single physical MST hub object can be represented in the topology
5690 * by multiple branches, with virtual ports between those branches.
5691 *
5692 * As of DP1.4, An MST hub with internal (virtual) ports must expose
5693 * certain DPCD registers over those ports. See sections 2.6.1.1.1
5694 * and 2.6.1.1.2 of Display Port specification v1.4 for details.
5695 *
5696 * May acquire mgr->lock
5697 *
5698 * Returns:
5699 * true if the port is a virtual DP peer device, false otherwise
5700 */
5701static bool drm_dp_mst_is_virtual_dpcd(struct drm_dp_mst_port *port)
5702{
5703	struct drm_dp_mst_port *downstream_port;
5704
5705	if (!port || port->dpcd_rev < DP_DPCD_REV_14)
5706		return false;
5707
5708	/* Virtual DP Sink (Internal Display Panel) */
5709	if (port->port_num >= 8)
5710		return true;
5711
5712	/* DP-to-HDMI Protocol Converter */
5713	if (port->pdt == DP_PEER_DEVICE_DP_LEGACY_CONV &&
5714	    !port->mcs &&
5715	    port->ldps)
5716		return true;
5717
5718	/* DP-to-DP */
5719	mutex_lock(&port->mgr->lock);
5720	if (port->pdt == DP_PEER_DEVICE_MST_BRANCHING &&
5721	    port->mstb &&
5722	    port->mstb->num_ports == 2) {
5723		list_for_each_entry(downstream_port, &port->mstb->ports, next) {
5724			if (downstream_port->pdt == DP_PEER_DEVICE_SST_SINK &&
5725			    !downstream_port->input) {
5726				mutex_unlock(&port->mgr->lock);
5727				return true;
5728			}
5729		}
5730	}
5731	mutex_unlock(&port->mgr->lock);
5732
5733	return false;
5734}
5735
5736/**
5737 * drm_dp_mst_dsc_aux_for_port() - Find the correct aux for DSC
5738 * @port: The port to check. A leaf of the MST tree with an attached display.
5739 *
5740 * Depending on the situation, DSC may be enabled via the endpoint aux,
5741 * the immediately upstream aux, or the connector's physical aux.
5742 *
5743 * This is both the correct aux to read DSC_CAPABILITY and the
5744 * correct aux to write DSC_ENABLED.
5745 *
5746 * This operation can be expensive (up to four aux reads), so
5747 * the caller should cache the return.
5748 *
5749 * Returns:
5750 * NULL if DSC cannot be enabled on this port, otherwise the aux device
5751 */
5752struct drm_dp_aux *drm_dp_mst_dsc_aux_for_port(struct drm_dp_mst_port *port)
5753{
5754	struct drm_dp_mst_port *immediate_upstream_port;
5755	struct drm_dp_mst_port *fec_port;
5756	struct drm_dp_desc desc = {};
5757	u8 endpoint_fec;
5758	u8 endpoint_dsc;
5759
5760	if (!port)
5761		return NULL;
5762
5763	if (port->parent->port_parent)
5764		immediate_upstream_port = port->parent->port_parent;
5765	else
5766		immediate_upstream_port = NULL;
5767
5768	fec_port = immediate_upstream_port;
5769	while (fec_port) {
5770		/*
5771		 * Each physical link (i.e. not a virtual port) between the
5772		 * output and the primary device must support FEC
5773		 */
5774		if (!drm_dp_mst_is_virtual_dpcd(fec_port) &&
5775		    !fec_port->fec_capable)
5776			return NULL;
5777
5778		fec_port = fec_port->parent->port_parent;
5779	}
5780
5781	/* DP-to-DP peer device */
5782	if (drm_dp_mst_is_virtual_dpcd(immediate_upstream_port)) {
5783		u8 upstream_dsc;
5784
5785		if (drm_dp_dpcd_read(&port->aux,
5786				     DP_DSC_SUPPORT, &endpoint_dsc, 1) != 1)
5787			return NULL;
5788		if (drm_dp_dpcd_read(&port->aux,
5789				     DP_FEC_CAPABILITY, &endpoint_fec, 1) != 1)
5790			return NULL;
5791		if (drm_dp_dpcd_read(&immediate_upstream_port->aux,
5792				     DP_DSC_SUPPORT, &upstream_dsc, 1) != 1)
5793			return NULL;
5794
5795		/* Enpoint decompression with DP-to-DP peer device */
5796		if ((endpoint_dsc & DP_DSC_DECOMPRESSION_IS_SUPPORTED) &&
5797		    (endpoint_fec & DP_FEC_CAPABLE) &&
5798		    (upstream_dsc & DP_DSC_PASSTHROUGH_IS_SUPPORTED)) {
5799			port->passthrough_aux = &immediate_upstream_port->aux;
5800			return &port->aux;
5801		}
5802
5803		/* Virtual DPCD decompression with DP-to-DP peer device */
5804		return &immediate_upstream_port->aux;
5805	}
5806
5807	/* Virtual DPCD decompression with DP-to-HDMI or Virtual DP Sink */
5808	if (drm_dp_mst_is_virtual_dpcd(port))
5809		return &port->aux;
5810
5811	/*
5812	 * Synaptics quirk
5813	 * Applies to ports for which:
5814	 * - Physical aux has Synaptics OUI
5815	 * - DPv1.4 or higher
5816	 * - Port is on primary branch device
5817	 * - Not a VGA adapter (DP_DWN_STRM_PORT_TYPE_ANALOG)
5818	 */
5819	if (drm_dp_read_desc(port->mgr->aux, &desc, true))
5820		return NULL;
5821
5822	if (drm_dp_has_quirk(&desc, DP_DPCD_QUIRK_DSC_WITHOUT_VIRTUAL_DPCD) &&
5823	    port->mgr->dpcd[DP_DPCD_REV] >= DP_DPCD_REV_14 &&
5824	    port->parent == port->mgr->mst_primary) {
5825		u8 dpcd_ext[DP_RECEIVER_CAP_SIZE];
5826
5827		if (drm_dp_read_dpcd_caps(port->mgr->aux, dpcd_ext) < 0)
5828			return NULL;
5829
5830		if ((dpcd_ext[DP_DOWNSTREAMPORT_PRESENT] & DP_DWN_STRM_PORT_PRESENT) &&
5831		    ((dpcd_ext[DP_DOWNSTREAMPORT_PRESENT] & DP_DWN_STRM_PORT_TYPE_MASK)
5832		     != DP_DWN_STRM_PORT_TYPE_ANALOG))
5833			return port->mgr->aux;
5834	}
5835
5836	/*
5837	 * The check below verifies if the MST sink
5838	 * connected to the GPU is capable of DSC -
5839	 * therefore the endpoint needs to be
5840	 * both DSC and FEC capable.
5841	 */
5842	if (drm_dp_dpcd_read(&port->aux,
5843	   DP_DSC_SUPPORT, &endpoint_dsc, 1) != 1)
5844		return NULL;
5845	if (drm_dp_dpcd_read(&port->aux,
5846	   DP_FEC_CAPABILITY, &endpoint_fec, 1) != 1)
5847		return NULL;
5848	if ((endpoint_dsc & DP_DSC_DECOMPRESSION_IS_SUPPORTED) &&
5849	   (endpoint_fec & DP_FEC_CAPABLE))
5850		return &port->aux;
5851
5852	return NULL;
5853}
5854EXPORT_SYMBOL(drm_dp_mst_dsc_aux_for_port);