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