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