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