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