2 * Copyright © 2014 Red Hat
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.
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
23 #include <linux/bitfield.h>
24 #include <linux/delay.h>
25 #include <linux/errno.h>
26 #include <linux/i2c.h>
27 #include <linux/init.h>
28 #include <linux/kernel.h>
29 #include <linux/random.h>
30 #include <linux/sched.h>
31 #include <linux/seq_file.h>
32 #include <linux/iopoll.h>
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>
41 #include <drm/dp/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_print.h>
46 #include <drm/drm_probe_helper.h>
48 #include "drm_dp_helper_internal.h"
49 #include "drm_dp_mst_topology_internal.h"
54 * These functions contain parts of the DisplayPort 1.2a MultiStream Transport
55 * protocol. The helpers contain a topology manager and bandwidth manager.
56 * The helpers encapsulate the sending and received of sideband msgs.
58 struct drm_dp_pending_up_req
{
59 struct drm_dp_sideband_msg_hdr hdr
;
60 struct drm_dp_sideband_msg_req_body msg
;
61 struct list_head next
;
64 static bool dump_dp_payload_table(struct drm_dp_mst_topology_mgr
*mgr
,
67 static void drm_dp_mst_topology_put_port(struct drm_dp_mst_port
*port
);
69 static int drm_dp_dpcd_write_payload(struct drm_dp_mst_topology_mgr
*mgr
,
71 struct drm_dp_payload
*payload
);
73 static int drm_dp_send_dpcd_read(struct drm_dp_mst_topology_mgr
*mgr
,
74 struct drm_dp_mst_port
*port
,
75 int offset
, int size
, u8
*bytes
);
76 static int drm_dp_send_dpcd_write(struct drm_dp_mst_topology_mgr
*mgr
,
77 struct drm_dp_mst_port
*port
,
78 int offset
, int size
, u8
*bytes
);
80 static int drm_dp_send_link_address(struct drm_dp_mst_topology_mgr
*mgr
,
81 struct drm_dp_mst_branch
*mstb
);
84 drm_dp_send_clear_payload_id_table(struct drm_dp_mst_topology_mgr
*mgr
,
85 struct drm_dp_mst_branch
*mstb
);
87 static int drm_dp_send_enum_path_resources(struct drm_dp_mst_topology_mgr
*mgr
,
88 struct drm_dp_mst_branch
*mstb
,
89 struct drm_dp_mst_port
*port
);
90 static bool drm_dp_validate_guid(struct drm_dp_mst_topology_mgr
*mgr
,
93 static int drm_dp_mst_register_i2c_bus(struct drm_dp_mst_port
*port
);
94 static void drm_dp_mst_unregister_i2c_bus(struct drm_dp_mst_port
*port
);
95 static void drm_dp_mst_kick_tx(struct drm_dp_mst_topology_mgr
*mgr
);
97 static bool drm_dp_mst_port_downstream_of_branch(struct drm_dp_mst_port
*port
,
98 struct drm_dp_mst_branch
*branch
);
100 #define DBG_PREFIX "[dp_mst]"
102 #define DP_STR(x) [DP_ ## x] = #x
104 static const char *drm_dp_mst_req_type_str(u8 req_type
)
106 static const char * const req_type_str
[] = {
107 DP_STR(GET_MSG_TRANSACTION_VERSION
),
108 DP_STR(LINK_ADDRESS
),
109 DP_STR(CONNECTION_STATUS_NOTIFY
),
110 DP_STR(ENUM_PATH_RESOURCES
),
111 DP_STR(ALLOCATE_PAYLOAD
),
112 DP_STR(QUERY_PAYLOAD
),
113 DP_STR(RESOURCE_STATUS_NOTIFY
),
114 DP_STR(CLEAR_PAYLOAD_ID_TABLE
),
115 DP_STR(REMOTE_DPCD_READ
),
116 DP_STR(REMOTE_DPCD_WRITE
),
117 DP_STR(REMOTE_I2C_READ
),
118 DP_STR(REMOTE_I2C_WRITE
),
119 DP_STR(POWER_UP_PHY
),
120 DP_STR(POWER_DOWN_PHY
),
121 DP_STR(SINK_EVENT_NOTIFY
),
122 DP_STR(QUERY_STREAM_ENC_STATUS
),
125 if (req_type
>= ARRAY_SIZE(req_type_str
) ||
126 !req_type_str
[req_type
])
129 return req_type_str
[req_type
];
133 #define DP_STR(x) [DP_NAK_ ## x] = #x
135 static const char *drm_dp_mst_nak_reason_str(u8 nak_reason
)
137 static const char * const nak_reason_str
[] = {
138 DP_STR(WRITE_FAILURE
),
139 DP_STR(INVALID_READ
),
143 DP_STR(LINK_FAILURE
),
144 DP_STR(NO_RESOURCES
),
147 DP_STR(ALLOCATE_FAIL
),
150 if (nak_reason
>= ARRAY_SIZE(nak_reason_str
) ||
151 !nak_reason_str
[nak_reason
])
154 return nak_reason_str
[nak_reason
];
158 #define DP_STR(x) [DRM_DP_SIDEBAND_TX_ ## x] = #x
160 static const char *drm_dp_mst_sideband_tx_state_str(int state
)
162 static const char * const sideband_reason_str
[] = {
170 if (state
>= ARRAY_SIZE(sideband_reason_str
) ||
171 !sideband_reason_str
[state
])
174 return sideband_reason_str
[state
];
178 drm_dp_mst_rad_to_str(const u8 rad
[8], u8 lct
, char *out
, size_t len
)
183 for (i
= 0; i
< lct
; i
++) {
185 unpacked_rad
[i
] = rad
[i
/ 2] >> 4;
187 unpacked_rad
[i
] = rad
[i
/ 2] & BIT_MASK(4);
190 /* TODO: Eventually add something to printk so we can format the rad
193 return snprintf(out
, len
, "%*phC", lct
, unpacked_rad
);
196 /* sideband msg handling */
197 static u8
drm_dp_msg_header_crc4(const uint8_t *data
, size_t num_nibbles
)
202 int number_of_bits
= num_nibbles
* 4;
205 while (number_of_bits
!= 0) {
208 remainder
|= (data
[array_index
] & bitmask
) >> bitshift
;
216 if ((remainder
& 0x10) == 0x10)
221 while (number_of_bits
!= 0) {
224 if ((remainder
& 0x10) != 0)
231 static u8
drm_dp_msg_data_crc4(const uint8_t *data
, u8 number_of_bytes
)
236 int number_of_bits
= number_of_bytes
* 8;
239 while (number_of_bits
!= 0) {
242 remainder
|= (data
[array_index
] & bitmask
) >> bitshift
;
250 if ((remainder
& 0x100) == 0x100)
255 while (number_of_bits
!= 0) {
258 if ((remainder
& 0x100) != 0)
262 return remainder
& 0xff;
264 static inline u8
drm_dp_calc_sb_hdr_size(struct drm_dp_sideband_msg_hdr
*hdr
)
268 size
+= (hdr
->lct
/ 2);
272 static void drm_dp_encode_sideband_msg_hdr(struct drm_dp_sideband_msg_hdr
*hdr
,
279 buf
[idx
++] = ((hdr
->lct
& 0xf) << 4) | (hdr
->lcr
& 0xf);
280 for (i
= 0; i
< (hdr
->lct
/ 2); i
++)
281 buf
[idx
++] = hdr
->rad
[i
];
282 buf
[idx
++] = (hdr
->broadcast
<< 7) | (hdr
->path_msg
<< 6) |
283 (hdr
->msg_len
& 0x3f);
284 buf
[idx
++] = (hdr
->somt
<< 7) | (hdr
->eomt
<< 6) | (hdr
->seqno
<< 4);
286 crc4
= drm_dp_msg_header_crc4(buf
, (idx
* 2) - 1);
287 buf
[idx
- 1] |= (crc4
& 0xf);
292 static bool drm_dp_decode_sideband_msg_hdr(const struct drm_dp_mst_topology_mgr
*mgr
,
293 struct drm_dp_sideband_msg_hdr
*hdr
,
294 u8
*buf
, int buflen
, u8
*hdrlen
)
304 len
+= ((buf
[0] & 0xf0) >> 4) / 2;
307 crc4
= drm_dp_msg_header_crc4(buf
, (len
* 2) - 1);
309 if ((crc4
& 0xf) != (buf
[len
- 1] & 0xf)) {
310 drm_dbg_kms(mgr
->dev
, "crc4 mismatch 0x%x 0x%x\n", crc4
, buf
[len
- 1]);
314 hdr
->lct
= (buf
[0] & 0xf0) >> 4;
315 hdr
->lcr
= (buf
[0] & 0xf);
317 for (i
= 0; i
< (hdr
->lct
/ 2); i
++)
318 hdr
->rad
[i
] = buf
[idx
++];
319 hdr
->broadcast
= (buf
[idx
] >> 7) & 0x1;
320 hdr
->path_msg
= (buf
[idx
] >> 6) & 0x1;
321 hdr
->msg_len
= buf
[idx
] & 0x3f;
323 hdr
->somt
= (buf
[idx
] >> 7) & 0x1;
324 hdr
->eomt
= (buf
[idx
] >> 6) & 0x1;
325 hdr
->seqno
= (buf
[idx
] >> 4) & 0x1;
332 drm_dp_encode_sideband_req(const struct drm_dp_sideband_msg_req_body
*req
,
333 struct drm_dp_sideband_msg_tx
*raw
)
339 buf
[idx
++] = req
->req_type
& 0x7f;
341 switch (req
->req_type
) {
342 case DP_ENUM_PATH_RESOURCES
:
343 case DP_POWER_DOWN_PHY
:
344 case DP_POWER_UP_PHY
:
345 buf
[idx
] = (req
->u
.port_num
.port_number
& 0xf) << 4;
348 case DP_ALLOCATE_PAYLOAD
:
349 buf
[idx
] = (req
->u
.allocate_payload
.port_number
& 0xf) << 4 |
350 (req
->u
.allocate_payload
.number_sdp_streams
& 0xf);
352 buf
[idx
] = (req
->u
.allocate_payload
.vcpi
& 0x7f);
354 buf
[idx
] = (req
->u
.allocate_payload
.pbn
>> 8);
356 buf
[idx
] = (req
->u
.allocate_payload
.pbn
& 0xff);
358 for (i
= 0; i
< req
->u
.allocate_payload
.number_sdp_streams
/ 2; i
++) {
359 buf
[idx
] = ((req
->u
.allocate_payload
.sdp_stream_sink
[i
* 2] & 0xf) << 4) |
360 (req
->u
.allocate_payload
.sdp_stream_sink
[i
* 2 + 1] & 0xf);
363 if (req
->u
.allocate_payload
.number_sdp_streams
& 1) {
364 i
= req
->u
.allocate_payload
.number_sdp_streams
- 1;
365 buf
[idx
] = (req
->u
.allocate_payload
.sdp_stream_sink
[i
] & 0xf) << 4;
369 case DP_QUERY_PAYLOAD
:
370 buf
[idx
] = (req
->u
.query_payload
.port_number
& 0xf) << 4;
372 buf
[idx
] = (req
->u
.query_payload
.vcpi
& 0x7f);
375 case DP_REMOTE_DPCD_READ
:
376 buf
[idx
] = (req
->u
.dpcd_read
.port_number
& 0xf) << 4;
377 buf
[idx
] |= ((req
->u
.dpcd_read
.dpcd_address
& 0xf0000) >> 16) & 0xf;
379 buf
[idx
] = (req
->u
.dpcd_read
.dpcd_address
& 0xff00) >> 8;
381 buf
[idx
] = (req
->u
.dpcd_read
.dpcd_address
& 0xff);
383 buf
[idx
] = (req
->u
.dpcd_read
.num_bytes
);
387 case DP_REMOTE_DPCD_WRITE
:
388 buf
[idx
] = (req
->u
.dpcd_write
.port_number
& 0xf) << 4;
389 buf
[idx
] |= ((req
->u
.dpcd_write
.dpcd_address
& 0xf0000) >> 16) & 0xf;
391 buf
[idx
] = (req
->u
.dpcd_write
.dpcd_address
& 0xff00) >> 8;
393 buf
[idx
] = (req
->u
.dpcd_write
.dpcd_address
& 0xff);
395 buf
[idx
] = (req
->u
.dpcd_write
.num_bytes
);
397 memcpy(&buf
[idx
], req
->u
.dpcd_write
.bytes
, req
->u
.dpcd_write
.num_bytes
);
398 idx
+= req
->u
.dpcd_write
.num_bytes
;
400 case DP_REMOTE_I2C_READ
:
401 buf
[idx
] = (req
->u
.i2c_read
.port_number
& 0xf) << 4;
402 buf
[idx
] |= (req
->u
.i2c_read
.num_transactions
& 0x3);
404 for (i
= 0; i
< (req
->u
.i2c_read
.num_transactions
& 0x3); i
++) {
405 buf
[idx
] = req
->u
.i2c_read
.transactions
[i
].i2c_dev_id
& 0x7f;
407 buf
[idx
] = req
->u
.i2c_read
.transactions
[i
].num_bytes
;
409 memcpy(&buf
[idx
], req
->u
.i2c_read
.transactions
[i
].bytes
, req
->u
.i2c_read
.transactions
[i
].num_bytes
);
410 idx
+= req
->u
.i2c_read
.transactions
[i
].num_bytes
;
412 buf
[idx
] = (req
->u
.i2c_read
.transactions
[i
].no_stop_bit
& 0x1) << 4;
413 buf
[idx
] |= (req
->u
.i2c_read
.transactions
[i
].i2c_transaction_delay
& 0xf);
416 buf
[idx
] = (req
->u
.i2c_read
.read_i2c_device_id
) & 0x7f;
418 buf
[idx
] = (req
->u
.i2c_read
.num_bytes_read
);
422 case DP_REMOTE_I2C_WRITE
:
423 buf
[idx
] = (req
->u
.i2c_write
.port_number
& 0xf) << 4;
425 buf
[idx
] = (req
->u
.i2c_write
.write_i2c_device_id
) & 0x7f;
427 buf
[idx
] = (req
->u
.i2c_write
.num_bytes
);
429 memcpy(&buf
[idx
], req
->u
.i2c_write
.bytes
, req
->u
.i2c_write
.num_bytes
);
430 idx
+= req
->u
.i2c_write
.num_bytes
;
432 case DP_QUERY_STREAM_ENC_STATUS
: {
433 const struct drm_dp_query_stream_enc_status
*msg
;
435 msg
= &req
->u
.enc_status
;
436 buf
[idx
] = msg
->stream_id
;
438 memcpy(&buf
[idx
], msg
->client_id
, sizeof(msg
->client_id
));
439 idx
+= sizeof(msg
->client_id
);
441 buf
[idx
] |= FIELD_PREP(GENMASK(1, 0), msg
->stream_event
);
442 buf
[idx
] |= msg
->valid_stream_event
? BIT(2) : 0;
443 buf
[idx
] |= FIELD_PREP(GENMASK(4, 3), msg
->stream_behavior
);
444 buf
[idx
] |= msg
->valid_stream_behavior
? BIT(5) : 0;
451 EXPORT_SYMBOL_FOR_TESTS_ONLY(drm_dp_encode_sideband_req
);
453 /* Decode a sideband request we've encoded, mainly used for debugging */
455 drm_dp_decode_sideband_req(const struct drm_dp_sideband_msg_tx
*raw
,
456 struct drm_dp_sideband_msg_req_body
*req
)
458 const u8
*buf
= raw
->msg
;
461 req
->req_type
= buf
[idx
++] & 0x7f;
462 switch (req
->req_type
) {
463 case DP_ENUM_PATH_RESOURCES
:
464 case DP_POWER_DOWN_PHY
:
465 case DP_POWER_UP_PHY
:
466 req
->u
.port_num
.port_number
= (buf
[idx
] >> 4) & 0xf;
468 case DP_ALLOCATE_PAYLOAD
:
470 struct drm_dp_allocate_payload
*a
=
471 &req
->u
.allocate_payload
;
473 a
->number_sdp_streams
= buf
[idx
] & 0xf;
474 a
->port_number
= (buf
[idx
] >> 4) & 0xf;
476 WARN_ON(buf
[++idx
] & 0x80);
477 a
->vcpi
= buf
[idx
] & 0x7f;
479 a
->pbn
= buf
[++idx
] << 8;
480 a
->pbn
|= buf
[++idx
];
483 for (i
= 0; i
< a
->number_sdp_streams
; i
++) {
484 a
->sdp_stream_sink
[i
] =
485 (buf
[idx
+ (i
/ 2)] >> ((i
% 2) ? 0 : 4)) & 0xf;
489 case DP_QUERY_PAYLOAD
:
490 req
->u
.query_payload
.port_number
= (buf
[idx
] >> 4) & 0xf;
491 WARN_ON(buf
[++idx
] & 0x80);
492 req
->u
.query_payload
.vcpi
= buf
[idx
] & 0x7f;
494 case DP_REMOTE_DPCD_READ
:
496 struct drm_dp_remote_dpcd_read
*r
= &req
->u
.dpcd_read
;
498 r
->port_number
= (buf
[idx
] >> 4) & 0xf;
500 r
->dpcd_address
= (buf
[idx
] << 16) & 0xf0000;
501 r
->dpcd_address
|= (buf
[++idx
] << 8) & 0xff00;
502 r
->dpcd_address
|= buf
[++idx
] & 0xff;
504 r
->num_bytes
= buf
[++idx
];
507 case DP_REMOTE_DPCD_WRITE
:
509 struct drm_dp_remote_dpcd_write
*w
=
512 w
->port_number
= (buf
[idx
] >> 4) & 0xf;
514 w
->dpcd_address
= (buf
[idx
] << 16) & 0xf0000;
515 w
->dpcd_address
|= (buf
[++idx
] << 8) & 0xff00;
516 w
->dpcd_address
|= buf
[++idx
] & 0xff;
518 w
->num_bytes
= buf
[++idx
];
520 w
->bytes
= kmemdup(&buf
[++idx
], w
->num_bytes
,
526 case DP_REMOTE_I2C_READ
:
528 struct drm_dp_remote_i2c_read
*r
= &req
->u
.i2c_read
;
529 struct drm_dp_remote_i2c_read_tx
*tx
;
532 r
->num_transactions
= buf
[idx
] & 0x3;
533 r
->port_number
= (buf
[idx
] >> 4) & 0xf;
534 for (i
= 0; i
< r
->num_transactions
; i
++) {
535 tx
= &r
->transactions
[i
];
537 tx
->i2c_dev_id
= buf
[++idx
] & 0x7f;
538 tx
->num_bytes
= buf
[++idx
];
539 tx
->bytes
= kmemdup(&buf
[++idx
],
546 idx
+= tx
->num_bytes
;
547 tx
->no_stop_bit
= (buf
[idx
] >> 5) & 0x1;
548 tx
->i2c_transaction_delay
= buf
[idx
] & 0xf;
552 for (i
= 0; i
< r
->num_transactions
; i
++) {
553 tx
= &r
->transactions
[i
];
559 r
->read_i2c_device_id
= buf
[++idx
] & 0x7f;
560 r
->num_bytes_read
= buf
[++idx
];
563 case DP_REMOTE_I2C_WRITE
:
565 struct drm_dp_remote_i2c_write
*w
= &req
->u
.i2c_write
;
567 w
->port_number
= (buf
[idx
] >> 4) & 0xf;
568 w
->write_i2c_device_id
= buf
[++idx
] & 0x7f;
569 w
->num_bytes
= buf
[++idx
];
570 w
->bytes
= kmemdup(&buf
[++idx
], w
->num_bytes
,
576 case DP_QUERY_STREAM_ENC_STATUS
:
577 req
->u
.enc_status
.stream_id
= buf
[idx
++];
578 for (i
= 0; i
< sizeof(req
->u
.enc_status
.client_id
); i
++)
579 req
->u
.enc_status
.client_id
[i
] = buf
[idx
++];
581 req
->u
.enc_status
.stream_event
= FIELD_GET(GENMASK(1, 0),
583 req
->u
.enc_status
.valid_stream_event
= FIELD_GET(BIT(2),
585 req
->u
.enc_status
.stream_behavior
= FIELD_GET(GENMASK(4, 3),
587 req
->u
.enc_status
.valid_stream_behavior
= FIELD_GET(BIT(5),
594 EXPORT_SYMBOL_FOR_TESTS_ONLY(drm_dp_decode_sideband_req
);
597 drm_dp_dump_sideband_msg_req_body(const struct drm_dp_sideband_msg_req_body
*req
,
598 int indent
, struct drm_printer
*printer
)
602 #define P(f, ...) drm_printf_indent(printer, indent, f, ##__VA_ARGS__)
603 if (req
->req_type
== DP_LINK_ADDRESS
) {
604 /* No contents to print */
605 P("type=%s\n", drm_dp_mst_req_type_str(req
->req_type
));
609 P("type=%s contents:\n", drm_dp_mst_req_type_str(req
->req_type
));
612 switch (req
->req_type
) {
613 case DP_ENUM_PATH_RESOURCES
:
614 case DP_POWER_DOWN_PHY
:
615 case DP_POWER_UP_PHY
:
616 P("port=%d\n", req
->u
.port_num
.port_number
);
618 case DP_ALLOCATE_PAYLOAD
:
619 P("port=%d vcpi=%d pbn=%d sdp_streams=%d %*ph\n",
620 req
->u
.allocate_payload
.port_number
,
621 req
->u
.allocate_payload
.vcpi
, req
->u
.allocate_payload
.pbn
,
622 req
->u
.allocate_payload
.number_sdp_streams
,
623 req
->u
.allocate_payload
.number_sdp_streams
,
624 req
->u
.allocate_payload
.sdp_stream_sink
);
626 case DP_QUERY_PAYLOAD
:
627 P("port=%d vcpi=%d\n",
628 req
->u
.query_payload
.port_number
,
629 req
->u
.query_payload
.vcpi
);
631 case DP_REMOTE_DPCD_READ
:
632 P("port=%d dpcd_addr=%05x len=%d\n",
633 req
->u
.dpcd_read
.port_number
, req
->u
.dpcd_read
.dpcd_address
,
634 req
->u
.dpcd_read
.num_bytes
);
636 case DP_REMOTE_DPCD_WRITE
:
637 P("port=%d addr=%05x len=%d: %*ph\n",
638 req
->u
.dpcd_write
.port_number
,
639 req
->u
.dpcd_write
.dpcd_address
,
640 req
->u
.dpcd_write
.num_bytes
, req
->u
.dpcd_write
.num_bytes
,
641 req
->u
.dpcd_write
.bytes
);
643 case DP_REMOTE_I2C_READ
:
644 P("port=%d num_tx=%d id=%d size=%d:\n",
645 req
->u
.i2c_read
.port_number
,
646 req
->u
.i2c_read
.num_transactions
,
647 req
->u
.i2c_read
.read_i2c_device_id
,
648 req
->u
.i2c_read
.num_bytes_read
);
651 for (i
= 0; i
< req
->u
.i2c_read
.num_transactions
; i
++) {
652 const struct drm_dp_remote_i2c_read_tx
*rtx
=
653 &req
->u
.i2c_read
.transactions
[i
];
655 P("%d: id=%03d size=%03d no_stop_bit=%d tx_delay=%03d: %*ph\n",
656 i
, rtx
->i2c_dev_id
, rtx
->num_bytes
,
657 rtx
->no_stop_bit
, rtx
->i2c_transaction_delay
,
658 rtx
->num_bytes
, rtx
->bytes
);
661 case DP_REMOTE_I2C_WRITE
:
662 P("port=%d id=%d size=%d: %*ph\n",
663 req
->u
.i2c_write
.port_number
,
664 req
->u
.i2c_write
.write_i2c_device_id
,
665 req
->u
.i2c_write
.num_bytes
, req
->u
.i2c_write
.num_bytes
,
666 req
->u
.i2c_write
.bytes
);
668 case DP_QUERY_STREAM_ENC_STATUS
:
669 P("stream_id=%u client_id=%*ph stream_event=%x "
670 "valid_event=%d stream_behavior=%x valid_behavior=%d",
671 req
->u
.enc_status
.stream_id
,
672 (int)ARRAY_SIZE(req
->u
.enc_status
.client_id
),
673 req
->u
.enc_status
.client_id
, req
->u
.enc_status
.stream_event
,
674 req
->u
.enc_status
.valid_stream_event
,
675 req
->u
.enc_status
.stream_behavior
,
676 req
->u
.enc_status
.valid_stream_behavior
);
684 EXPORT_SYMBOL_FOR_TESTS_ONLY(drm_dp_dump_sideband_msg_req_body
);
687 drm_dp_mst_dump_sideband_msg_tx(struct drm_printer
*p
,
688 const struct drm_dp_sideband_msg_tx
*txmsg
)
690 struct drm_dp_sideband_msg_req_body req
;
695 drm_dp_mst_rad_to_str(txmsg
->dst
->rad
, txmsg
->dst
->lct
, buf
,
697 drm_printf(p
, "txmsg cur_offset=%x cur_len=%x seqno=%x state=%s path_msg=%d dst=%s\n",
698 txmsg
->cur_offset
, txmsg
->cur_len
, txmsg
->seqno
,
699 drm_dp_mst_sideband_tx_state_str(txmsg
->state
),
700 txmsg
->path_msg
, buf
);
702 ret
= drm_dp_decode_sideband_req(txmsg
, &req
);
704 drm_printf(p
, "<failed to decode sideband req: %d>\n", ret
);
707 drm_dp_dump_sideband_msg_req_body(&req
, 1, p
);
709 switch (req
.req_type
) {
710 case DP_REMOTE_DPCD_WRITE
:
711 kfree(req
.u
.dpcd_write
.bytes
);
713 case DP_REMOTE_I2C_READ
:
714 for (i
= 0; i
< req
.u
.i2c_read
.num_transactions
; i
++)
715 kfree(req
.u
.i2c_read
.transactions
[i
].bytes
);
717 case DP_REMOTE_I2C_WRITE
:
718 kfree(req
.u
.i2c_write
.bytes
);
723 static void drm_dp_crc_sideband_chunk_req(u8
*msg
, u8 len
)
727 crc4
= drm_dp_msg_data_crc4(msg
, len
);
731 static void drm_dp_encode_sideband_reply(struct drm_dp_sideband_msg_reply_body
*rep
,
732 struct drm_dp_sideband_msg_tx
*raw
)
737 buf
[idx
++] = (rep
->reply_type
& 0x1) << 7 | (rep
->req_type
& 0x7f);
742 static int drm_dp_sideband_msg_set_header(struct drm_dp_sideband_msg_rx
*msg
,
743 struct drm_dp_sideband_msg_hdr
*hdr
,
747 * ignore out-of-order messages or messages that are part of a
750 if (!hdr
->somt
&& !msg
->have_somt
)
753 /* get length contained in this portion */
754 msg
->curchunk_idx
= 0;
755 msg
->curchunk_len
= hdr
->msg_len
;
756 msg
->curchunk_hdrlen
= hdrlen
;
758 /* we have already gotten an somt - don't bother parsing */
759 if (hdr
->somt
&& msg
->have_somt
)
763 memcpy(&msg
->initial_hdr
, hdr
,
764 sizeof(struct drm_dp_sideband_msg_hdr
));
765 msg
->have_somt
= true;
768 msg
->have_eomt
= true;
773 /* this adds a chunk of msg to the builder to get the final msg */
774 static bool drm_dp_sideband_append_payload(struct drm_dp_sideband_msg_rx
*msg
,
775 u8
*replybuf
, u8 replybuflen
)
779 memcpy(&msg
->chunk
[msg
->curchunk_idx
], replybuf
, replybuflen
);
780 msg
->curchunk_idx
+= replybuflen
;
782 if (msg
->curchunk_idx
>= msg
->curchunk_len
) {
784 crc4
= drm_dp_msg_data_crc4(msg
->chunk
, msg
->curchunk_len
- 1);
785 if (crc4
!= msg
->chunk
[msg
->curchunk_len
- 1])
786 print_hex_dump(KERN_DEBUG
, "wrong crc",
787 DUMP_PREFIX_NONE
, 16, 1,
788 msg
->chunk
, msg
->curchunk_len
, false);
789 /* copy chunk into bigger msg */
790 memcpy(&msg
->msg
[msg
->curlen
], msg
->chunk
, msg
->curchunk_len
- 1);
791 msg
->curlen
+= msg
->curchunk_len
- 1;
796 static bool drm_dp_sideband_parse_link_address(const struct drm_dp_mst_topology_mgr
*mgr
,
797 struct drm_dp_sideband_msg_rx
*raw
,
798 struct drm_dp_sideband_msg_reply_body
*repmsg
)
803 memcpy(repmsg
->u
.link_addr
.guid
, &raw
->msg
[idx
], 16);
805 repmsg
->u
.link_addr
.nports
= raw
->msg
[idx
] & 0xf;
807 if (idx
> raw
->curlen
)
809 for (i
= 0; i
< repmsg
->u
.link_addr
.nports
; i
++) {
810 if (raw
->msg
[idx
] & 0x80)
811 repmsg
->u
.link_addr
.ports
[i
].input_port
= 1;
813 repmsg
->u
.link_addr
.ports
[i
].peer_device_type
= (raw
->msg
[idx
] >> 4) & 0x7;
814 repmsg
->u
.link_addr
.ports
[i
].port_number
= (raw
->msg
[idx
] & 0xf);
817 if (idx
> raw
->curlen
)
819 repmsg
->u
.link_addr
.ports
[i
].mcs
= (raw
->msg
[idx
] >> 7) & 0x1;
820 repmsg
->u
.link_addr
.ports
[i
].ddps
= (raw
->msg
[idx
] >> 6) & 0x1;
821 if (repmsg
->u
.link_addr
.ports
[i
].input_port
== 0)
822 repmsg
->u
.link_addr
.ports
[i
].legacy_device_plug_status
= (raw
->msg
[idx
] >> 5) & 0x1;
824 if (idx
> raw
->curlen
)
826 if (repmsg
->u
.link_addr
.ports
[i
].input_port
== 0) {
827 repmsg
->u
.link_addr
.ports
[i
].dpcd_revision
= (raw
->msg
[idx
]);
829 if (idx
> raw
->curlen
)
831 memcpy(repmsg
->u
.link_addr
.ports
[i
].peer_guid
, &raw
->msg
[idx
], 16);
833 if (idx
> raw
->curlen
)
835 repmsg
->u
.link_addr
.ports
[i
].num_sdp_streams
= (raw
->msg
[idx
] >> 4) & 0xf;
836 repmsg
->u
.link_addr
.ports
[i
].num_sdp_stream_sinks
= (raw
->msg
[idx
] & 0xf);
840 if (idx
> raw
->curlen
)
846 DRM_DEBUG_KMS("link address reply parse length fail %d %d\n", idx
, raw
->curlen
);
850 static bool drm_dp_sideband_parse_remote_dpcd_read(struct drm_dp_sideband_msg_rx
*raw
,
851 struct drm_dp_sideband_msg_reply_body
*repmsg
)
855 repmsg
->u
.remote_dpcd_read_ack
.port_number
= raw
->msg
[idx
] & 0xf;
857 if (idx
> raw
->curlen
)
859 repmsg
->u
.remote_dpcd_read_ack
.num_bytes
= raw
->msg
[idx
];
861 if (idx
> raw
->curlen
)
864 memcpy(repmsg
->u
.remote_dpcd_read_ack
.bytes
, &raw
->msg
[idx
], repmsg
->u
.remote_dpcd_read_ack
.num_bytes
);
867 DRM_DEBUG_KMS("link address reply parse length fail %d %d\n", idx
, raw
->curlen
);
871 static bool drm_dp_sideband_parse_remote_dpcd_write(struct drm_dp_sideband_msg_rx
*raw
,
872 struct drm_dp_sideband_msg_reply_body
*repmsg
)
876 repmsg
->u
.remote_dpcd_write_ack
.port_number
= raw
->msg
[idx
] & 0xf;
878 if (idx
> raw
->curlen
)
882 DRM_DEBUG_KMS("parse length fail %d %d\n", idx
, raw
->curlen
);
886 static bool drm_dp_sideband_parse_remote_i2c_read_ack(struct drm_dp_sideband_msg_rx
*raw
,
887 struct drm_dp_sideband_msg_reply_body
*repmsg
)
891 repmsg
->u
.remote_i2c_read_ack
.port_number
= (raw
->msg
[idx
] & 0xf);
893 if (idx
> raw
->curlen
)
895 repmsg
->u
.remote_i2c_read_ack
.num_bytes
= raw
->msg
[idx
];
898 memcpy(repmsg
->u
.remote_i2c_read_ack
.bytes
, &raw
->msg
[idx
], repmsg
->u
.remote_i2c_read_ack
.num_bytes
);
901 DRM_DEBUG_KMS("remote i2c reply parse length fail %d %d\n", idx
, raw
->curlen
);
905 static bool drm_dp_sideband_parse_enum_path_resources_ack(struct drm_dp_sideband_msg_rx
*raw
,
906 struct drm_dp_sideband_msg_reply_body
*repmsg
)
910 repmsg
->u
.path_resources
.port_number
= (raw
->msg
[idx
] >> 4) & 0xf;
911 repmsg
->u
.path_resources
.fec_capable
= raw
->msg
[idx
] & 0x1;
913 if (idx
> raw
->curlen
)
915 repmsg
->u
.path_resources
.full_payload_bw_number
= (raw
->msg
[idx
] << 8) | (raw
->msg
[idx
+1]);
917 if (idx
> raw
->curlen
)
919 repmsg
->u
.path_resources
.avail_payload_bw_number
= (raw
->msg
[idx
] << 8) | (raw
->msg
[idx
+1]);
921 if (idx
> raw
->curlen
)
925 DRM_DEBUG_KMS("enum resource parse length fail %d %d\n", idx
, raw
->curlen
);
929 static bool drm_dp_sideband_parse_allocate_payload_ack(struct drm_dp_sideband_msg_rx
*raw
,
930 struct drm_dp_sideband_msg_reply_body
*repmsg
)
934 repmsg
->u
.allocate_payload
.port_number
= (raw
->msg
[idx
] >> 4) & 0xf;
936 if (idx
> raw
->curlen
)
938 repmsg
->u
.allocate_payload
.vcpi
= raw
->msg
[idx
];
940 if (idx
> raw
->curlen
)
942 repmsg
->u
.allocate_payload
.allocated_pbn
= (raw
->msg
[idx
] << 8) | (raw
->msg
[idx
+1]);
944 if (idx
> raw
->curlen
)
948 DRM_DEBUG_KMS("allocate payload parse length fail %d %d\n", idx
, raw
->curlen
);
952 static bool drm_dp_sideband_parse_query_payload_ack(struct drm_dp_sideband_msg_rx
*raw
,
953 struct drm_dp_sideband_msg_reply_body
*repmsg
)
957 repmsg
->u
.query_payload
.port_number
= (raw
->msg
[idx
] >> 4) & 0xf;
959 if (idx
> raw
->curlen
)
961 repmsg
->u
.query_payload
.allocated_pbn
= (raw
->msg
[idx
] << 8) | (raw
->msg
[idx
+ 1]);
963 if (idx
> raw
->curlen
)
967 DRM_DEBUG_KMS("query payload parse length fail %d %d\n", idx
, raw
->curlen
);
971 static bool drm_dp_sideband_parse_power_updown_phy_ack(struct drm_dp_sideband_msg_rx
*raw
,
972 struct drm_dp_sideband_msg_reply_body
*repmsg
)
976 repmsg
->u
.port_number
.port_number
= (raw
->msg
[idx
] >> 4) & 0xf;
978 if (idx
> raw
->curlen
) {
979 DRM_DEBUG_KMS("power up/down phy parse length fail %d %d\n",
987 drm_dp_sideband_parse_query_stream_enc_status(
988 struct drm_dp_sideband_msg_rx
*raw
,
989 struct drm_dp_sideband_msg_reply_body
*repmsg
)
991 struct drm_dp_query_stream_enc_status_ack_reply
*reply
;
993 reply
= &repmsg
->u
.enc_status
;
995 reply
->stream_id
= raw
->msg
[3];
997 reply
->reply_signed
= raw
->msg
[2] & BIT(0);
1000 * NOTE: It's my impression from reading the spec that the below parsing
1001 * is correct. However I noticed while testing with an HDCP 1.4 display
1002 * through an HDCP 2.2 hub that only bit 3 was set. In that case, I
1003 * would expect both bits to be set. So keep the parsing following the
1004 * spec, but beware reality might not match the spec (at least for some
1007 reply
->hdcp_1x_device_present
= raw
->msg
[2] & BIT(4);
1008 reply
->hdcp_2x_device_present
= raw
->msg
[2] & BIT(3);
1010 reply
->query_capable_device_present
= raw
->msg
[2] & BIT(5);
1011 reply
->legacy_device_present
= raw
->msg
[2] & BIT(6);
1012 reply
->unauthorizable_device_present
= raw
->msg
[2] & BIT(7);
1014 reply
->auth_completed
= !!(raw
->msg
[1] & BIT(3));
1015 reply
->encryption_enabled
= !!(raw
->msg
[1] & BIT(4));
1016 reply
->repeater_present
= !!(raw
->msg
[1] & BIT(5));
1017 reply
->state
= (raw
->msg
[1] & GENMASK(7, 6)) >> 6;
1022 static bool drm_dp_sideband_parse_reply(const struct drm_dp_mst_topology_mgr
*mgr
,
1023 struct drm_dp_sideband_msg_rx
*raw
,
1024 struct drm_dp_sideband_msg_reply_body
*msg
)
1026 memset(msg
, 0, sizeof(*msg
));
1027 msg
->reply_type
= (raw
->msg
[0] & 0x80) >> 7;
1028 msg
->req_type
= (raw
->msg
[0] & 0x7f);
1030 if (msg
->reply_type
== DP_SIDEBAND_REPLY_NAK
) {
1031 memcpy(msg
->u
.nak
.guid
, &raw
->msg
[1], 16);
1032 msg
->u
.nak
.reason
= raw
->msg
[17];
1033 msg
->u
.nak
.nak_data
= raw
->msg
[18];
1037 switch (msg
->req_type
) {
1038 case DP_LINK_ADDRESS
:
1039 return drm_dp_sideband_parse_link_address(mgr
, raw
, msg
);
1040 case DP_QUERY_PAYLOAD
:
1041 return drm_dp_sideband_parse_query_payload_ack(raw
, msg
);
1042 case DP_REMOTE_DPCD_READ
:
1043 return drm_dp_sideband_parse_remote_dpcd_read(raw
, msg
);
1044 case DP_REMOTE_DPCD_WRITE
:
1045 return drm_dp_sideband_parse_remote_dpcd_write(raw
, msg
);
1046 case DP_REMOTE_I2C_READ
:
1047 return drm_dp_sideband_parse_remote_i2c_read_ack(raw
, msg
);
1048 case DP_REMOTE_I2C_WRITE
:
1049 return true; /* since there's nothing to parse */
1050 case DP_ENUM_PATH_RESOURCES
:
1051 return drm_dp_sideband_parse_enum_path_resources_ack(raw
, msg
);
1052 case DP_ALLOCATE_PAYLOAD
:
1053 return drm_dp_sideband_parse_allocate_payload_ack(raw
, msg
);
1054 case DP_POWER_DOWN_PHY
:
1055 case DP_POWER_UP_PHY
:
1056 return drm_dp_sideband_parse_power_updown_phy_ack(raw
, msg
);
1057 case DP_CLEAR_PAYLOAD_ID_TABLE
:
1058 return true; /* since there's nothing to parse */
1059 case DP_QUERY_STREAM_ENC_STATUS
:
1060 return drm_dp_sideband_parse_query_stream_enc_status(raw
, msg
);
1062 drm_err(mgr
->dev
, "Got unknown reply 0x%02x (%s)\n",
1063 msg
->req_type
, drm_dp_mst_req_type_str(msg
->req_type
));
1069 drm_dp_sideband_parse_connection_status_notify(const struct drm_dp_mst_topology_mgr
*mgr
,
1070 struct drm_dp_sideband_msg_rx
*raw
,
1071 struct drm_dp_sideband_msg_req_body
*msg
)
1075 msg
->u
.conn_stat
.port_number
= (raw
->msg
[idx
] & 0xf0) >> 4;
1077 if (idx
> raw
->curlen
)
1080 memcpy(msg
->u
.conn_stat
.guid
, &raw
->msg
[idx
], 16);
1082 if (idx
> raw
->curlen
)
1085 msg
->u
.conn_stat
.legacy_device_plug_status
= (raw
->msg
[idx
] >> 6) & 0x1;
1086 msg
->u
.conn_stat
.displayport_device_plug_status
= (raw
->msg
[idx
] >> 5) & 0x1;
1087 msg
->u
.conn_stat
.message_capability_status
= (raw
->msg
[idx
] >> 4) & 0x1;
1088 msg
->u
.conn_stat
.input_port
= (raw
->msg
[idx
] >> 3) & 0x1;
1089 msg
->u
.conn_stat
.peer_device_type
= (raw
->msg
[idx
] & 0x7);
1093 drm_dbg_kms(mgr
->dev
, "connection status reply parse length fail %d %d\n",
1098 static bool drm_dp_sideband_parse_resource_status_notify(const struct drm_dp_mst_topology_mgr
*mgr
,
1099 struct drm_dp_sideband_msg_rx
*raw
,
1100 struct drm_dp_sideband_msg_req_body
*msg
)
1104 msg
->u
.resource_stat
.port_number
= (raw
->msg
[idx
] & 0xf0) >> 4;
1106 if (idx
> raw
->curlen
)
1109 memcpy(msg
->u
.resource_stat
.guid
, &raw
->msg
[idx
], 16);
1111 if (idx
> raw
->curlen
)
1114 msg
->u
.resource_stat
.available_pbn
= (raw
->msg
[idx
] << 8) | (raw
->msg
[idx
+ 1]);
1118 drm_dbg_kms(mgr
->dev
, "resource status reply parse length fail %d %d\n", idx
, raw
->curlen
);
1122 static bool drm_dp_sideband_parse_req(const struct drm_dp_mst_topology_mgr
*mgr
,
1123 struct drm_dp_sideband_msg_rx
*raw
,
1124 struct drm_dp_sideband_msg_req_body
*msg
)
1126 memset(msg
, 0, sizeof(*msg
));
1127 msg
->req_type
= (raw
->msg
[0] & 0x7f);
1129 switch (msg
->req_type
) {
1130 case DP_CONNECTION_STATUS_NOTIFY
:
1131 return drm_dp_sideband_parse_connection_status_notify(mgr
, raw
, msg
);
1132 case DP_RESOURCE_STATUS_NOTIFY
:
1133 return drm_dp_sideband_parse_resource_status_notify(mgr
, raw
, msg
);
1135 drm_err(mgr
->dev
, "Got unknown request 0x%02x (%s)\n",
1136 msg
->req_type
, drm_dp_mst_req_type_str(msg
->req_type
));
1141 static void build_dpcd_write(struct drm_dp_sideband_msg_tx
*msg
,
1142 u8 port_num
, u32 offset
, u8 num_bytes
, u8
*bytes
)
1144 struct drm_dp_sideband_msg_req_body req
;
1146 req
.req_type
= DP_REMOTE_DPCD_WRITE
;
1147 req
.u
.dpcd_write
.port_number
= port_num
;
1148 req
.u
.dpcd_write
.dpcd_address
= offset
;
1149 req
.u
.dpcd_write
.num_bytes
= num_bytes
;
1150 req
.u
.dpcd_write
.bytes
= bytes
;
1151 drm_dp_encode_sideband_req(&req
, msg
);
1154 static void build_link_address(struct drm_dp_sideband_msg_tx
*msg
)
1156 struct drm_dp_sideband_msg_req_body req
;
1158 req
.req_type
= DP_LINK_ADDRESS
;
1159 drm_dp_encode_sideband_req(&req
, msg
);
1162 static void build_clear_payload_id_table(struct drm_dp_sideband_msg_tx
*msg
)
1164 struct drm_dp_sideband_msg_req_body req
;
1166 req
.req_type
= DP_CLEAR_PAYLOAD_ID_TABLE
;
1167 drm_dp_encode_sideband_req(&req
, msg
);
1168 msg
->path_msg
= true;
1171 static int build_enum_path_resources(struct drm_dp_sideband_msg_tx
*msg
,
1174 struct drm_dp_sideband_msg_req_body req
;
1176 req
.req_type
= DP_ENUM_PATH_RESOURCES
;
1177 req
.u
.port_num
.port_number
= port_num
;
1178 drm_dp_encode_sideband_req(&req
, msg
);
1179 msg
->path_msg
= true;
1183 static void build_allocate_payload(struct drm_dp_sideband_msg_tx
*msg
,
1185 u8 vcpi
, uint16_t pbn
,
1186 u8 number_sdp_streams
,
1187 u8
*sdp_stream_sink
)
1189 struct drm_dp_sideband_msg_req_body req
;
1191 memset(&req
, 0, sizeof(req
));
1192 req
.req_type
= DP_ALLOCATE_PAYLOAD
;
1193 req
.u
.allocate_payload
.port_number
= port_num
;
1194 req
.u
.allocate_payload
.vcpi
= vcpi
;
1195 req
.u
.allocate_payload
.pbn
= pbn
;
1196 req
.u
.allocate_payload
.number_sdp_streams
= number_sdp_streams
;
1197 memcpy(req
.u
.allocate_payload
.sdp_stream_sink
, sdp_stream_sink
,
1198 number_sdp_streams
);
1199 drm_dp_encode_sideband_req(&req
, msg
);
1200 msg
->path_msg
= true;
1203 static void build_power_updown_phy(struct drm_dp_sideband_msg_tx
*msg
,
1204 int port_num
, bool power_up
)
1206 struct drm_dp_sideband_msg_req_body req
;
1209 req
.req_type
= DP_POWER_UP_PHY
;
1211 req
.req_type
= DP_POWER_DOWN_PHY
;
1213 req
.u
.port_num
.port_number
= port_num
;
1214 drm_dp_encode_sideband_req(&req
, msg
);
1215 msg
->path_msg
= true;
1219 build_query_stream_enc_status(struct drm_dp_sideband_msg_tx
*msg
, u8 stream_id
,
1222 struct drm_dp_sideband_msg_req_body req
;
1224 req
.req_type
= DP_QUERY_STREAM_ENC_STATUS
;
1225 req
.u
.enc_status
.stream_id
= stream_id
;
1226 memcpy(req
.u
.enc_status
.client_id
, q_id
,
1227 sizeof(req
.u
.enc_status
.client_id
));
1228 req
.u
.enc_status
.stream_event
= 0;
1229 req
.u
.enc_status
.valid_stream_event
= false;
1230 req
.u
.enc_status
.stream_behavior
= 0;
1231 req
.u
.enc_status
.valid_stream_behavior
= false;
1233 drm_dp_encode_sideband_req(&req
, msg
);
1237 static int drm_dp_mst_assign_payload_id(struct drm_dp_mst_topology_mgr
*mgr
,
1238 struct drm_dp_vcpi
*vcpi
)
1242 mutex_lock(&mgr
->payload_lock
);
1243 ret
= find_first_zero_bit(&mgr
->payload_mask
, mgr
->max_payloads
+ 1);
1244 if (ret
> mgr
->max_payloads
) {
1246 drm_dbg_kms(mgr
->dev
, "out of payload ids %d\n", ret
);
1250 vcpi_ret
= find_first_zero_bit(&mgr
->vcpi_mask
, mgr
->max_payloads
+ 1);
1251 if (vcpi_ret
> mgr
->max_payloads
) {
1253 drm_dbg_kms(mgr
->dev
, "out of vcpi ids %d\n", ret
);
1257 set_bit(ret
, &mgr
->payload_mask
);
1258 set_bit(vcpi_ret
, &mgr
->vcpi_mask
);
1259 vcpi
->vcpi
= vcpi_ret
+ 1;
1260 mgr
->proposed_vcpis
[ret
- 1] = vcpi
;
1262 mutex_unlock(&mgr
->payload_lock
);
1266 static void drm_dp_mst_put_payload_id(struct drm_dp_mst_topology_mgr
*mgr
,
1274 mutex_lock(&mgr
->payload_lock
);
1275 drm_dbg_kms(mgr
->dev
, "putting payload %d\n", vcpi
);
1276 clear_bit(vcpi
- 1, &mgr
->vcpi_mask
);
1278 for (i
= 0; i
< mgr
->max_payloads
; i
++) {
1279 if (mgr
->proposed_vcpis
[i
] &&
1280 mgr
->proposed_vcpis
[i
]->vcpi
== vcpi
) {
1281 mgr
->proposed_vcpis
[i
] = NULL
;
1282 clear_bit(i
+ 1, &mgr
->payload_mask
);
1285 mutex_unlock(&mgr
->payload_lock
);
1288 static bool check_txmsg_state(struct drm_dp_mst_topology_mgr
*mgr
,
1289 struct drm_dp_sideband_msg_tx
*txmsg
)
1294 * All updates to txmsg->state are protected by mgr->qlock, and the two
1295 * cases we check here are terminal states. For those the barriers
1296 * provided by the wake_up/wait_event pair are enough.
1298 state
= READ_ONCE(txmsg
->state
);
1299 return (state
== DRM_DP_SIDEBAND_TX_RX
||
1300 state
== DRM_DP_SIDEBAND_TX_TIMEOUT
);
1303 static int drm_dp_mst_wait_tx_reply(struct drm_dp_mst_branch
*mstb
,
1304 struct drm_dp_sideband_msg_tx
*txmsg
)
1306 struct drm_dp_mst_topology_mgr
*mgr
= mstb
->mgr
;
1307 unsigned long wait_timeout
= msecs_to_jiffies(4000);
1308 unsigned long wait_expires
= jiffies
+ wait_timeout
;
1313 * If the driver provides a way for this, change to
1314 * poll-waiting for the MST reply interrupt if we didn't receive
1315 * it for 50 msec. This would cater for cases where the HPD
1316 * pulse signal got lost somewhere, even though the sink raised
1317 * the corresponding MST interrupt correctly. One example is the
1318 * Club 3D CAC-1557 TypeC -> DP adapter which for some reason
1319 * filters out short pulses with a duration less than ~540 usec.
1321 * The poll period is 50 msec to avoid missing an interrupt
1322 * after the sink has cleared it (after a 110msec timeout
1323 * since it raised the interrupt).
1325 ret
= wait_event_timeout(mgr
->tx_waitq
,
1326 check_txmsg_state(mgr
, txmsg
),
1327 mgr
->cbs
->poll_hpd_irq
?
1328 msecs_to_jiffies(50) :
1331 if (ret
|| !mgr
->cbs
->poll_hpd_irq
||
1332 time_after(jiffies
, wait_expires
))
1335 mgr
->cbs
->poll_hpd_irq(mgr
);
1338 mutex_lock(&mgr
->qlock
);
1340 if (txmsg
->state
== DRM_DP_SIDEBAND_TX_TIMEOUT
) {
1345 drm_dbg_kms(mgr
->dev
, "timedout msg send %p %d %d\n",
1346 txmsg
, txmsg
->state
, txmsg
->seqno
);
1348 /* dump some state */
1352 if (txmsg
->state
== DRM_DP_SIDEBAND_TX_QUEUED
||
1353 txmsg
->state
== DRM_DP_SIDEBAND_TX_START_SEND
||
1354 txmsg
->state
== DRM_DP_SIDEBAND_TX_SENT
)
1355 list_del(&txmsg
->next
);
1358 if (unlikely(ret
== -EIO
) && drm_debug_enabled(DRM_UT_DP
)) {
1359 struct drm_printer p
= drm_debug_printer(DBG_PREFIX
);
1361 drm_dp_mst_dump_sideband_msg_tx(&p
, txmsg
);
1363 mutex_unlock(&mgr
->qlock
);
1365 drm_dp_mst_kick_tx(mgr
);
1369 static struct drm_dp_mst_branch
*drm_dp_add_mst_branch_device(u8 lct
, u8
*rad
)
1371 struct drm_dp_mst_branch
*mstb
;
1373 mstb
= kzalloc(sizeof(*mstb
), GFP_KERNEL
);
1379 memcpy(mstb
->rad
, rad
, lct
/ 2);
1380 INIT_LIST_HEAD(&mstb
->ports
);
1381 kref_init(&mstb
->topology_kref
);
1382 kref_init(&mstb
->malloc_kref
);
1386 static void drm_dp_free_mst_branch_device(struct kref
*kref
)
1388 struct drm_dp_mst_branch
*mstb
=
1389 container_of(kref
, struct drm_dp_mst_branch
, malloc_kref
);
1391 if (mstb
->port_parent
)
1392 drm_dp_mst_put_port_malloc(mstb
->port_parent
);
1398 * DOC: Branch device and port refcounting
1400 * Topology refcount overview
1401 * ~~~~~~~~~~~~~~~~~~~~~~~~~~
1403 * The refcounting schemes for &struct drm_dp_mst_branch and &struct
1404 * drm_dp_mst_port are somewhat unusual. Both ports and branch devices have
1405 * two different kinds of refcounts: topology refcounts, and malloc refcounts.
1407 * Topology refcounts are not exposed to drivers, and are handled internally
1408 * by the DP MST helpers. The helpers use them in order to prevent the
1409 * in-memory topology state from being changed in the middle of critical
1410 * operations like changing the internal state of payload allocations. This
1411 * means each branch and port will be considered to be connected to the rest
1412 * of the topology until its topology refcount reaches zero. Additionally,
1413 * for ports this means that their associated &struct drm_connector will stay
1414 * registered with userspace until the port's refcount reaches 0.
1416 * Malloc refcount overview
1417 * ~~~~~~~~~~~~~~~~~~~~~~~~
1419 * Malloc references are used to keep a &struct drm_dp_mst_port or &struct
1420 * drm_dp_mst_branch allocated even after all of its topology references have
1421 * been dropped, so that the driver or MST helpers can safely access each
1422 * branch's last known state before it was disconnected from the topology.
1423 * When the malloc refcount of a port or branch reaches 0, the memory
1424 * allocation containing the &struct drm_dp_mst_branch or &struct
1425 * drm_dp_mst_port respectively will be freed.
1427 * For &struct drm_dp_mst_branch, malloc refcounts are not currently exposed
1428 * to drivers. As of writing this documentation, there are no drivers that
1429 * have a usecase for accessing &struct drm_dp_mst_branch outside of the MST
1430 * helpers. Exposing this API to drivers in a race-free manner would take more
1431 * tweaking of the refcounting scheme, however patches are welcome provided
1432 * there is a legitimate driver usecase for this.
1434 * Refcount relationships in a topology
1435 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
1437 * Let's take a look at why the relationship between topology and malloc
1438 * refcounts is designed the way it is.
1440 * .. kernel-figure:: dp-mst/topology-figure-1.dot
1442 * An example of topology and malloc refs in a DP MST topology with two
1443 * active payloads. Topology refcount increments are indicated by solid
1444 * lines, and malloc refcount increments are indicated by dashed lines.
1445 * Each starts from the branch which incremented the refcount, and ends at
1446 * the branch to which the refcount belongs to, i.e. the arrow points the
1447 * same way as the C pointers used to reference a structure.
1449 * As you can see in the above figure, every branch increments the topology
1450 * refcount of its children, and increments the malloc refcount of its
1451 * parent. Additionally, every payload increments the malloc refcount of its
1452 * assigned port by 1.
1454 * So, what would happen if MSTB #3 from the above figure was unplugged from
1455 * the system, but the driver hadn't yet removed payload #2 from port #3? The
1456 * topology would start to look like the figure below.
1458 * .. kernel-figure:: dp-mst/topology-figure-2.dot
1460 * Ports and branch devices which have been released from memory are
1461 * colored grey, and references which have been removed are colored red.
1463 * Whenever a port or branch device's topology refcount reaches zero, it will
1464 * decrement the topology refcounts of all its children, the malloc refcount
1465 * of its parent, and finally its own malloc refcount. For MSTB #4 and port
1466 * #4, this means they both have been disconnected from the topology and freed
1467 * from memory. But, because payload #2 is still holding a reference to port
1468 * #3, port #3 is removed from the topology but its &struct drm_dp_mst_port
1469 * is still accessible from memory. This also means port #3 has not yet
1470 * decremented the malloc refcount of MSTB #3, so its &struct
1471 * drm_dp_mst_branch will also stay allocated in memory until port #3's
1472 * malloc refcount reaches 0.
1474 * This relationship is necessary because in order to release payload #2, we
1475 * need to be able to figure out the last relative of port #3 that's still
1476 * connected to the topology. In this case, we would travel up the topology as
1479 * .. kernel-figure:: dp-mst/topology-figure-3.dot
1481 * And finally, remove payload #2 by communicating with port #2 through
1482 * sideband transactions.
1486 * drm_dp_mst_get_mstb_malloc() - Increment the malloc refcount of a branch
1488 * @mstb: The &struct drm_dp_mst_branch to increment the malloc refcount of
1490 * Increments &drm_dp_mst_branch.malloc_kref. When
1491 * &drm_dp_mst_branch.malloc_kref reaches 0, the memory allocation for @mstb
1492 * will be released and @mstb may no longer be used.
1494 * See also: drm_dp_mst_put_mstb_malloc()
1497 drm_dp_mst_get_mstb_malloc(struct drm_dp_mst_branch
*mstb
)
1499 kref_get(&mstb
->malloc_kref
);
1500 drm_dbg(mstb
->mgr
->dev
, "mstb %p (%d)\n", mstb
, kref_read(&mstb
->malloc_kref
));
1504 * drm_dp_mst_put_mstb_malloc() - Decrement the malloc refcount of a branch
1506 * @mstb: The &struct drm_dp_mst_branch to decrement the malloc refcount of
1508 * Decrements &drm_dp_mst_branch.malloc_kref. When
1509 * &drm_dp_mst_branch.malloc_kref reaches 0, the memory allocation for @mstb
1510 * will be released and @mstb may no longer be used.
1512 * See also: drm_dp_mst_get_mstb_malloc()
1515 drm_dp_mst_put_mstb_malloc(struct drm_dp_mst_branch
*mstb
)
1517 drm_dbg(mstb
->mgr
->dev
, "mstb %p (%d)\n", mstb
, kref_read(&mstb
->malloc_kref
) - 1);
1518 kref_put(&mstb
->malloc_kref
, drm_dp_free_mst_branch_device
);
1521 static void drm_dp_free_mst_port(struct kref
*kref
)
1523 struct drm_dp_mst_port
*port
=
1524 container_of(kref
, struct drm_dp_mst_port
, malloc_kref
);
1526 drm_dp_mst_put_mstb_malloc(port
->parent
);
1531 * drm_dp_mst_get_port_malloc() - Increment the malloc refcount of an MST port
1532 * @port: The &struct drm_dp_mst_port to increment the malloc refcount of
1534 * Increments &drm_dp_mst_port.malloc_kref. When &drm_dp_mst_port.malloc_kref
1535 * reaches 0, the memory allocation for @port will be released and @port may
1536 * no longer be used.
1538 * Because @port could potentially be freed at any time by the DP MST helpers
1539 * if &drm_dp_mst_port.malloc_kref reaches 0, including during a call to this
1540 * function, drivers that which to make use of &struct drm_dp_mst_port should
1541 * ensure that they grab at least one main malloc reference to their MST ports
1542 * in &drm_dp_mst_topology_cbs.add_connector. This callback is called before
1543 * there is any chance for &drm_dp_mst_port.malloc_kref to reach 0.
1545 * See also: drm_dp_mst_put_port_malloc()
1548 drm_dp_mst_get_port_malloc(struct drm_dp_mst_port
*port
)
1550 kref_get(&port
->malloc_kref
);
1551 drm_dbg(port
->mgr
->dev
, "port %p (%d)\n", port
, kref_read(&port
->malloc_kref
));
1553 EXPORT_SYMBOL(drm_dp_mst_get_port_malloc
);
1556 * drm_dp_mst_put_port_malloc() - Decrement the malloc refcount of an MST port
1557 * @port: The &struct drm_dp_mst_port to decrement the malloc refcount of
1559 * Decrements &drm_dp_mst_port.malloc_kref. When &drm_dp_mst_port.malloc_kref
1560 * reaches 0, the memory allocation for @port will be released and @port may
1561 * no longer be used.
1563 * See also: drm_dp_mst_get_port_malloc()
1566 drm_dp_mst_put_port_malloc(struct drm_dp_mst_port
*port
)
1568 drm_dbg(port
->mgr
->dev
, "port %p (%d)\n", port
, kref_read(&port
->malloc_kref
) - 1);
1569 kref_put(&port
->malloc_kref
, drm_dp_free_mst_port
);
1571 EXPORT_SYMBOL(drm_dp_mst_put_port_malloc
);
1573 #if IS_ENABLED(CONFIG_DRM_DEBUG_DP_MST_TOPOLOGY_REFS)
1575 #define STACK_DEPTH 8
1577 static noinline
void
1578 __topology_ref_save(struct drm_dp_mst_topology_mgr
*mgr
,
1579 struct drm_dp_mst_topology_ref_history
*history
,
1580 enum drm_dp_mst_topology_ref_type type
)
1582 struct drm_dp_mst_topology_ref_entry
*entry
= NULL
;
1583 depot_stack_handle_t backtrace
;
1584 ulong stack_entries
[STACK_DEPTH
];
1588 n
= stack_trace_save(stack_entries
, ARRAY_SIZE(stack_entries
), 1);
1589 backtrace
= stack_depot_save(stack_entries
, n
, GFP_KERNEL
);
1593 /* Try to find an existing entry for this backtrace */
1594 for (i
= 0; i
< history
->len
; i
++) {
1595 if (history
->entries
[i
].backtrace
== backtrace
) {
1596 entry
= &history
->entries
[i
];
1601 /* Otherwise add one */
1603 struct drm_dp_mst_topology_ref_entry
*new;
1604 int new_len
= history
->len
+ 1;
1606 new = krealloc(history
->entries
, sizeof(*new) * new_len
,
1611 entry
= &new[history
->len
];
1612 history
->len
= new_len
;
1613 history
->entries
= new;
1615 entry
->backtrace
= backtrace
;
1620 entry
->ts_nsec
= ktime_get_ns();
1624 topology_ref_history_cmp(const void *a
, const void *b
)
1626 const struct drm_dp_mst_topology_ref_entry
*entry_a
= a
, *entry_b
= b
;
1628 if (entry_a
->ts_nsec
> entry_b
->ts_nsec
)
1630 else if (entry_a
->ts_nsec
< entry_b
->ts_nsec
)
1636 static inline const char *
1637 topology_ref_type_to_str(enum drm_dp_mst_topology_ref_type type
)
1639 if (type
== DRM_DP_MST_TOPOLOGY_REF_GET
)
1646 __dump_topology_ref_history(struct drm_dp_mst_topology_ref_history
*history
,
1647 void *ptr
, const char *type_str
)
1649 struct drm_printer p
= drm_debug_printer(DBG_PREFIX
);
1650 char *buf
= kzalloc(PAGE_SIZE
, GFP_KERNEL
);
1659 /* First, sort the list so that it goes from oldest to newest
1662 sort(history
->entries
, history
->len
, sizeof(*history
->entries
),
1663 topology_ref_history_cmp
, NULL
);
1665 drm_printf(&p
, "%s (%p) topology count reached 0, dumping history:\n",
1668 for (i
= 0; i
< history
->len
; i
++) {
1669 const struct drm_dp_mst_topology_ref_entry
*entry
=
1670 &history
->entries
[i
];
1671 u64 ts_nsec
= entry
->ts_nsec
;
1672 u32 rem_nsec
= do_div(ts_nsec
, 1000000000);
1674 stack_depot_snprint(entry
->backtrace
, buf
, PAGE_SIZE
, 4);
1676 drm_printf(&p
, " %d %ss (last at %5llu.%06u):\n%s",
1678 topology_ref_type_to_str(entry
->type
),
1679 ts_nsec
, rem_nsec
/ 1000, buf
);
1682 /* Now free the history, since this is the only time we expose it */
1683 kfree(history
->entries
);
1688 static __always_inline
void
1689 drm_dp_mst_dump_mstb_topology_history(struct drm_dp_mst_branch
*mstb
)
1691 __dump_topology_ref_history(&mstb
->topology_ref_history
, mstb
,
1695 static __always_inline
void
1696 drm_dp_mst_dump_port_topology_history(struct drm_dp_mst_port
*port
)
1698 __dump_topology_ref_history(&port
->topology_ref_history
, port
,
1702 static __always_inline
void
1703 save_mstb_topology_ref(struct drm_dp_mst_branch
*mstb
,
1704 enum drm_dp_mst_topology_ref_type type
)
1706 __topology_ref_save(mstb
->mgr
, &mstb
->topology_ref_history
, type
);
1709 static __always_inline
void
1710 save_port_topology_ref(struct drm_dp_mst_port
*port
,
1711 enum drm_dp_mst_topology_ref_type type
)
1713 __topology_ref_save(port
->mgr
, &port
->topology_ref_history
, type
);
1717 topology_ref_history_lock(struct drm_dp_mst_topology_mgr
*mgr
)
1719 mutex_lock(&mgr
->topology_ref_history_lock
);
1723 topology_ref_history_unlock(struct drm_dp_mst_topology_mgr
*mgr
)
1725 mutex_unlock(&mgr
->topology_ref_history_lock
);
1729 topology_ref_history_lock(struct drm_dp_mst_topology_mgr
*mgr
) {}
1731 topology_ref_history_unlock(struct drm_dp_mst_topology_mgr
*mgr
) {}
1733 drm_dp_mst_dump_mstb_topology_history(struct drm_dp_mst_branch
*mstb
) {}
1735 drm_dp_mst_dump_port_topology_history(struct drm_dp_mst_port
*port
) {}
1736 #define save_mstb_topology_ref(mstb, type)
1737 #define save_port_topology_ref(port, type)
1740 static void drm_dp_destroy_mst_branch_device(struct kref
*kref
)
1742 struct drm_dp_mst_branch
*mstb
=
1743 container_of(kref
, struct drm_dp_mst_branch
, topology_kref
);
1744 struct drm_dp_mst_topology_mgr
*mgr
= mstb
->mgr
;
1746 drm_dp_mst_dump_mstb_topology_history(mstb
);
1748 INIT_LIST_HEAD(&mstb
->destroy_next
);
1751 * This can get called under mgr->mutex, so we need to perform the
1752 * actual destruction of the mstb in another worker
1754 mutex_lock(&mgr
->delayed_destroy_lock
);
1755 list_add(&mstb
->destroy_next
, &mgr
->destroy_branch_device_list
);
1756 mutex_unlock(&mgr
->delayed_destroy_lock
);
1757 queue_work(mgr
->delayed_destroy_wq
, &mgr
->delayed_destroy_work
);
1761 * drm_dp_mst_topology_try_get_mstb() - Increment the topology refcount of a
1762 * branch device unless it's zero
1763 * @mstb: &struct drm_dp_mst_branch to increment the topology refcount of
1765 * Attempts to grab a topology reference to @mstb, if it hasn't yet been
1766 * removed from the topology (e.g. &drm_dp_mst_branch.topology_kref has
1767 * reached 0). Holding a topology reference implies that a malloc reference
1768 * will be held to @mstb as long as the user holds the topology reference.
1770 * Care should be taken to ensure that the user has at least one malloc
1771 * reference to @mstb. If you already have a topology reference to @mstb, you
1772 * should use drm_dp_mst_topology_get_mstb() instead.
1775 * drm_dp_mst_topology_get_mstb()
1776 * drm_dp_mst_topology_put_mstb()
1779 * * 1: A topology reference was grabbed successfully
1780 * * 0: @port is no longer in the topology, no reference was grabbed
1782 static int __must_check
1783 drm_dp_mst_topology_try_get_mstb(struct drm_dp_mst_branch
*mstb
)
1787 topology_ref_history_lock(mstb
->mgr
);
1788 ret
= kref_get_unless_zero(&mstb
->topology_kref
);
1790 drm_dbg(mstb
->mgr
->dev
, "mstb %p (%d)\n", mstb
, kref_read(&mstb
->topology_kref
));
1791 save_mstb_topology_ref(mstb
, DRM_DP_MST_TOPOLOGY_REF_GET
);
1794 topology_ref_history_unlock(mstb
->mgr
);
1800 * drm_dp_mst_topology_get_mstb() - Increment the topology refcount of a
1802 * @mstb: The &struct drm_dp_mst_branch to increment the topology refcount of
1804 * Increments &drm_dp_mst_branch.topology_refcount without checking whether or
1805 * not it's already reached 0. This is only valid to use in scenarios where
1806 * you are already guaranteed to have at least one active topology reference
1807 * to @mstb. Otherwise, drm_dp_mst_topology_try_get_mstb() must be used.
1810 * drm_dp_mst_topology_try_get_mstb()
1811 * drm_dp_mst_topology_put_mstb()
1813 static void drm_dp_mst_topology_get_mstb(struct drm_dp_mst_branch
*mstb
)
1815 topology_ref_history_lock(mstb
->mgr
);
1817 save_mstb_topology_ref(mstb
, DRM_DP_MST_TOPOLOGY_REF_GET
);
1818 WARN_ON(kref_read(&mstb
->topology_kref
) == 0);
1819 kref_get(&mstb
->topology_kref
);
1820 drm_dbg(mstb
->mgr
->dev
, "mstb %p (%d)\n", mstb
, kref_read(&mstb
->topology_kref
));
1822 topology_ref_history_unlock(mstb
->mgr
);
1826 * drm_dp_mst_topology_put_mstb() - release a topology reference to a branch
1828 * @mstb: The &struct drm_dp_mst_branch to release the topology reference from
1830 * Releases a topology reference from @mstb by decrementing
1831 * &drm_dp_mst_branch.topology_kref.
1834 * drm_dp_mst_topology_try_get_mstb()
1835 * drm_dp_mst_topology_get_mstb()
1838 drm_dp_mst_topology_put_mstb(struct drm_dp_mst_branch
*mstb
)
1840 topology_ref_history_lock(mstb
->mgr
);
1842 drm_dbg(mstb
->mgr
->dev
, "mstb %p (%d)\n", mstb
, kref_read(&mstb
->topology_kref
) - 1);
1843 save_mstb_topology_ref(mstb
, DRM_DP_MST_TOPOLOGY_REF_PUT
);
1845 topology_ref_history_unlock(mstb
->mgr
);
1846 kref_put(&mstb
->topology_kref
, drm_dp_destroy_mst_branch_device
);
1849 static void drm_dp_destroy_port(struct kref
*kref
)
1851 struct drm_dp_mst_port
*port
=
1852 container_of(kref
, struct drm_dp_mst_port
, topology_kref
);
1853 struct drm_dp_mst_topology_mgr
*mgr
= port
->mgr
;
1855 drm_dp_mst_dump_port_topology_history(port
);
1857 /* There's nothing that needs locking to destroy an input port yet */
1859 drm_dp_mst_put_port_malloc(port
);
1863 kfree(port
->cached_edid
);
1866 * we can't destroy the connector here, as we might be holding the
1867 * mode_config.mutex from an EDID retrieval
1869 mutex_lock(&mgr
->delayed_destroy_lock
);
1870 list_add(&port
->next
, &mgr
->destroy_port_list
);
1871 mutex_unlock(&mgr
->delayed_destroy_lock
);
1872 queue_work(mgr
->delayed_destroy_wq
, &mgr
->delayed_destroy_work
);
1876 * drm_dp_mst_topology_try_get_port() - Increment the topology refcount of a
1877 * port unless it's zero
1878 * @port: &struct drm_dp_mst_port to increment the topology refcount of
1880 * Attempts to grab a topology reference to @port, if it hasn't yet been
1881 * removed from the topology (e.g. &drm_dp_mst_port.topology_kref has reached
1882 * 0). Holding a topology reference implies that a malloc reference will be
1883 * held to @port as long as the user holds the topology reference.
1885 * Care should be taken to ensure that the user has at least one malloc
1886 * reference to @port. If you already have a topology reference to @port, you
1887 * should use drm_dp_mst_topology_get_port() instead.
1890 * drm_dp_mst_topology_get_port()
1891 * drm_dp_mst_topology_put_port()
1894 * * 1: A topology reference was grabbed successfully
1895 * * 0: @port is no longer in the topology, no reference was grabbed
1897 static int __must_check
1898 drm_dp_mst_topology_try_get_port(struct drm_dp_mst_port
*port
)
1902 topology_ref_history_lock(port
->mgr
);
1903 ret
= kref_get_unless_zero(&port
->topology_kref
);
1905 drm_dbg(port
->mgr
->dev
, "port %p (%d)\n", port
, kref_read(&port
->topology_kref
));
1906 save_port_topology_ref(port
, DRM_DP_MST_TOPOLOGY_REF_GET
);
1909 topology_ref_history_unlock(port
->mgr
);
1914 * drm_dp_mst_topology_get_port() - Increment the topology refcount of a port
1915 * @port: The &struct drm_dp_mst_port to increment the topology refcount of
1917 * Increments &drm_dp_mst_port.topology_refcount without checking whether or
1918 * not it's already reached 0. This is only valid to use in scenarios where
1919 * you are already guaranteed to have at least one active topology reference
1920 * to @port. Otherwise, drm_dp_mst_topology_try_get_port() must be used.
1923 * drm_dp_mst_topology_try_get_port()
1924 * drm_dp_mst_topology_put_port()
1926 static void drm_dp_mst_topology_get_port(struct drm_dp_mst_port
*port
)
1928 topology_ref_history_lock(port
->mgr
);
1930 WARN_ON(kref_read(&port
->topology_kref
) == 0);
1931 kref_get(&port
->topology_kref
);
1932 drm_dbg(port
->mgr
->dev
, "port %p (%d)\n", port
, kref_read(&port
->topology_kref
));
1933 save_port_topology_ref(port
, DRM_DP_MST_TOPOLOGY_REF_GET
);
1935 topology_ref_history_unlock(port
->mgr
);
1939 * drm_dp_mst_topology_put_port() - release a topology reference to a port
1940 * @port: The &struct drm_dp_mst_port to release the topology reference from
1942 * Releases a topology reference from @port by decrementing
1943 * &drm_dp_mst_port.topology_kref.
1946 * drm_dp_mst_topology_try_get_port()
1947 * drm_dp_mst_topology_get_port()
1949 static void drm_dp_mst_topology_put_port(struct drm_dp_mst_port
*port
)
1951 topology_ref_history_lock(port
->mgr
);
1953 drm_dbg(port
->mgr
->dev
, "port %p (%d)\n", port
, kref_read(&port
->topology_kref
) - 1);
1954 save_port_topology_ref(port
, DRM_DP_MST_TOPOLOGY_REF_PUT
);
1956 topology_ref_history_unlock(port
->mgr
);
1957 kref_put(&port
->topology_kref
, drm_dp_destroy_port
);
1960 static struct drm_dp_mst_branch
*
1961 drm_dp_mst_topology_get_mstb_validated_locked(struct drm_dp_mst_branch
*mstb
,
1962 struct drm_dp_mst_branch
*to_find
)
1964 struct drm_dp_mst_port
*port
;
1965 struct drm_dp_mst_branch
*rmstb
;
1967 if (to_find
== mstb
)
1970 list_for_each_entry(port
, &mstb
->ports
, next
) {
1972 rmstb
= drm_dp_mst_topology_get_mstb_validated_locked(
1973 port
->mstb
, to_find
);
1981 static struct drm_dp_mst_branch
*
1982 drm_dp_mst_topology_get_mstb_validated(struct drm_dp_mst_topology_mgr
*mgr
,
1983 struct drm_dp_mst_branch
*mstb
)
1985 struct drm_dp_mst_branch
*rmstb
= NULL
;
1987 mutex_lock(&mgr
->lock
);
1988 if (mgr
->mst_primary
) {
1989 rmstb
= drm_dp_mst_topology_get_mstb_validated_locked(
1990 mgr
->mst_primary
, mstb
);
1992 if (rmstb
&& !drm_dp_mst_topology_try_get_mstb(rmstb
))
1995 mutex_unlock(&mgr
->lock
);
1999 static struct drm_dp_mst_port
*
2000 drm_dp_mst_topology_get_port_validated_locked(struct drm_dp_mst_branch
*mstb
,
2001 struct drm_dp_mst_port
*to_find
)
2003 struct drm_dp_mst_port
*port
, *mport
;
2005 list_for_each_entry(port
, &mstb
->ports
, next
) {
2006 if (port
== to_find
)
2010 mport
= drm_dp_mst_topology_get_port_validated_locked(
2011 port
->mstb
, to_find
);
2019 static struct drm_dp_mst_port
*
2020 drm_dp_mst_topology_get_port_validated(struct drm_dp_mst_topology_mgr
*mgr
,
2021 struct drm_dp_mst_port
*port
)
2023 struct drm_dp_mst_port
*rport
= NULL
;
2025 mutex_lock(&mgr
->lock
);
2026 if (mgr
->mst_primary
) {
2027 rport
= drm_dp_mst_topology_get_port_validated_locked(
2028 mgr
->mst_primary
, port
);
2030 if (rport
&& !drm_dp_mst_topology_try_get_port(rport
))
2033 mutex_unlock(&mgr
->lock
);
2037 static struct drm_dp_mst_port
*drm_dp_get_port(struct drm_dp_mst_branch
*mstb
, u8 port_num
)
2039 struct drm_dp_mst_port
*port
;
2042 list_for_each_entry(port
, &mstb
->ports
, next
) {
2043 if (port
->port_num
== port_num
) {
2044 ret
= drm_dp_mst_topology_try_get_port(port
);
2045 return ret
? port
: NULL
;
2053 * calculate a new RAD for this MST branch device
2054 * if parent has an LCT of 2 then it has 1 nibble of RAD,
2055 * if parent has an LCT of 3 then it has 2 nibbles of RAD,
2057 static u8
drm_dp_calculate_rad(struct drm_dp_mst_port
*port
,
2060 int parent_lct
= port
->parent
->lct
;
2062 int idx
= (parent_lct
- 1) / 2;
2064 if (parent_lct
> 1) {
2065 memcpy(rad
, port
->parent
->rad
, idx
+ 1);
2066 shift
= (parent_lct
% 2) ? 4 : 0;
2070 rad
[idx
] |= port
->port_num
<< shift
;
2071 return parent_lct
+ 1;
2074 static bool drm_dp_mst_is_end_device(u8 pdt
, bool mcs
)
2077 case DP_PEER_DEVICE_DP_LEGACY_CONV
:
2078 case DP_PEER_DEVICE_SST_SINK
:
2080 case DP_PEER_DEVICE_MST_BRANCHING
:
2081 /* For sst branch device */
2091 drm_dp_port_set_pdt(struct drm_dp_mst_port
*port
, u8 new_pdt
,
2094 struct drm_dp_mst_topology_mgr
*mgr
= port
->mgr
;
2095 struct drm_dp_mst_branch
*mstb
;
2099 if (port
->pdt
== new_pdt
&& port
->mcs
== new_mcs
)
2102 /* Teardown the old pdt, if there is one */
2103 if (port
->pdt
!= DP_PEER_DEVICE_NONE
) {
2104 if (drm_dp_mst_is_end_device(port
->pdt
, port
->mcs
)) {
2106 * If the new PDT would also have an i2c bus,
2107 * don't bother with reregistering it
2109 if (new_pdt
!= DP_PEER_DEVICE_NONE
&&
2110 drm_dp_mst_is_end_device(new_pdt
, new_mcs
)) {
2111 port
->pdt
= new_pdt
;
2112 port
->mcs
= new_mcs
;
2116 /* remove i2c over sideband */
2117 drm_dp_mst_unregister_i2c_bus(port
);
2119 mutex_lock(&mgr
->lock
);
2120 drm_dp_mst_topology_put_mstb(port
->mstb
);
2122 mutex_unlock(&mgr
->lock
);
2126 port
->pdt
= new_pdt
;
2127 port
->mcs
= new_mcs
;
2129 if (port
->pdt
!= DP_PEER_DEVICE_NONE
) {
2130 if (drm_dp_mst_is_end_device(port
->pdt
, port
->mcs
)) {
2131 /* add i2c over sideband */
2132 ret
= drm_dp_mst_register_i2c_bus(port
);
2134 lct
= drm_dp_calculate_rad(port
, rad
);
2135 mstb
= drm_dp_add_mst_branch_device(lct
, rad
);
2138 drm_err(mgr
->dev
, "Failed to create MSTB for port %p", port
);
2142 mutex_lock(&mgr
->lock
);
2144 mstb
->mgr
= port
->mgr
;
2145 mstb
->port_parent
= port
;
2148 * Make sure this port's memory allocation stays
2149 * around until its child MSTB releases it
2151 drm_dp_mst_get_port_malloc(port
);
2152 mutex_unlock(&mgr
->lock
);
2154 /* And make sure we send a link address for this */
2161 port
->pdt
= DP_PEER_DEVICE_NONE
;
2166 * drm_dp_mst_dpcd_read() - read a series of bytes from the DPCD via sideband
2167 * @aux: Fake sideband AUX CH
2168 * @offset: address of the (first) register to read
2169 * @buffer: buffer to store the register values
2170 * @size: number of bytes in @buffer
2172 * Performs the same functionality for remote devices via
2173 * sideband messaging as drm_dp_dpcd_read() does for local
2174 * devices via actual AUX CH.
2176 * Return: Number of bytes read, or negative error code on failure.
2178 ssize_t
drm_dp_mst_dpcd_read(struct drm_dp_aux
*aux
,
2179 unsigned int offset
, void *buffer
, size_t size
)
2181 struct drm_dp_mst_port
*port
= container_of(aux
, struct drm_dp_mst_port
,
2184 return drm_dp_send_dpcd_read(port
->mgr
, port
,
2185 offset
, size
, buffer
);
2189 * drm_dp_mst_dpcd_write() - write a series of bytes to the DPCD via sideband
2190 * @aux: Fake sideband AUX CH
2191 * @offset: address of the (first) register to write
2192 * @buffer: buffer containing the values to write
2193 * @size: number of bytes in @buffer
2195 * Performs the same functionality for remote devices via
2196 * sideband messaging as drm_dp_dpcd_write() does for local
2197 * devices via actual AUX CH.
2199 * Return: number of bytes written on success, negative error code on failure.
2201 ssize_t
drm_dp_mst_dpcd_write(struct drm_dp_aux
*aux
,
2202 unsigned int offset
, void *buffer
, size_t size
)
2204 struct drm_dp_mst_port
*port
= container_of(aux
, struct drm_dp_mst_port
,
2207 return drm_dp_send_dpcd_write(port
->mgr
, port
,
2208 offset
, size
, buffer
);
2211 static int drm_dp_check_mstb_guid(struct drm_dp_mst_branch
*mstb
, u8
*guid
)
2215 memcpy(mstb
->guid
, guid
, 16);
2217 if (!drm_dp_validate_guid(mstb
->mgr
, mstb
->guid
)) {
2218 if (mstb
->port_parent
) {
2219 ret
= drm_dp_send_dpcd_write(mstb
->mgr
,
2221 DP_GUID
, 16, mstb
->guid
);
2223 ret
= drm_dp_dpcd_write(mstb
->mgr
->aux
,
2224 DP_GUID
, mstb
->guid
, 16);
2228 if (ret
< 16 && ret
> 0)
2231 return ret
== 16 ? 0 : ret
;
2234 static void build_mst_prop_path(const struct drm_dp_mst_branch
*mstb
,
2237 size_t proppath_size
)
2242 snprintf(proppath
, proppath_size
, "mst:%d", mstb
->mgr
->conn_base_id
);
2243 for (i
= 0; i
< (mstb
->lct
- 1); i
++) {
2244 int shift
= (i
% 2) ? 0 : 4;
2245 int port_num
= (mstb
->rad
[i
/ 2] >> shift
) & 0xf;
2247 snprintf(temp
, sizeof(temp
), "-%d", port_num
);
2248 strlcat(proppath
, temp
, proppath_size
);
2250 snprintf(temp
, sizeof(temp
), "-%d", pnum
);
2251 strlcat(proppath
, temp
, proppath_size
);
2255 * drm_dp_mst_connector_late_register() - Late MST connector registration
2256 * @connector: The MST connector
2257 * @port: The MST port for this connector
2259 * Helper to register the remote aux device for this MST port. Drivers should
2260 * call this from their mst connector's late_register hook to enable MST aux
2263 * Return: 0 on success, negative error code on failure.
2265 int drm_dp_mst_connector_late_register(struct drm_connector
*connector
,
2266 struct drm_dp_mst_port
*port
)
2268 drm_dbg_kms(port
->mgr
->dev
, "registering %s remote bus for %s\n",
2269 port
->aux
.name
, connector
->kdev
->kobj
.name
);
2271 port
->aux
.dev
= connector
->kdev
;
2272 return drm_dp_aux_register_devnode(&port
->aux
);
2274 EXPORT_SYMBOL(drm_dp_mst_connector_late_register
);
2277 * drm_dp_mst_connector_early_unregister() - Early MST connector unregistration
2278 * @connector: The MST connector
2279 * @port: The MST port for this connector
2281 * Helper to unregister the remote aux device for this MST port, registered by
2282 * drm_dp_mst_connector_late_register(). Drivers should call this from their mst
2283 * connector's early_unregister hook.
2285 void drm_dp_mst_connector_early_unregister(struct drm_connector
*connector
,
2286 struct drm_dp_mst_port
*port
)
2288 drm_dbg_kms(port
->mgr
->dev
, "unregistering %s remote bus for %s\n",
2289 port
->aux
.name
, connector
->kdev
->kobj
.name
);
2290 drm_dp_aux_unregister_devnode(&port
->aux
);
2292 EXPORT_SYMBOL(drm_dp_mst_connector_early_unregister
);
2295 drm_dp_mst_port_add_connector(struct drm_dp_mst_branch
*mstb
,
2296 struct drm_dp_mst_port
*port
)
2298 struct drm_dp_mst_topology_mgr
*mgr
= port
->mgr
;
2302 build_mst_prop_path(mstb
, port
->port_num
, proppath
, sizeof(proppath
));
2303 port
->connector
= mgr
->cbs
->add_connector(mgr
, port
, proppath
);
2304 if (!port
->connector
) {
2309 if (port
->pdt
!= DP_PEER_DEVICE_NONE
&&
2310 drm_dp_mst_is_end_device(port
->pdt
, port
->mcs
) &&
2311 port
->port_num
>= DP_MST_LOGICAL_PORT_0
)
2312 port
->cached_edid
= drm_get_edid(port
->connector
,
2315 drm_connector_register(port
->connector
);
2319 drm_err(mgr
->dev
, "Failed to create connector for port %p: %d\n", port
, ret
);
2323 * Drop a topology reference, and unlink the port from the in-memory topology
2327 drm_dp_mst_topology_unlink_port(struct drm_dp_mst_topology_mgr
*mgr
,
2328 struct drm_dp_mst_port
*port
)
2330 mutex_lock(&mgr
->lock
);
2331 port
->parent
->num_ports
--;
2332 list_del(&port
->next
);
2333 mutex_unlock(&mgr
->lock
);
2334 drm_dp_mst_topology_put_port(port
);
2337 static struct drm_dp_mst_port
*
2338 drm_dp_mst_add_port(struct drm_device
*dev
,
2339 struct drm_dp_mst_topology_mgr
*mgr
,
2340 struct drm_dp_mst_branch
*mstb
, u8 port_number
)
2342 struct drm_dp_mst_port
*port
= kzalloc(sizeof(*port
), GFP_KERNEL
);
2347 kref_init(&port
->topology_kref
);
2348 kref_init(&port
->malloc_kref
);
2349 port
->parent
= mstb
;
2350 port
->port_num
= port_number
;
2352 port
->aux
.name
= "DPMST";
2353 port
->aux
.dev
= dev
->dev
;
2354 port
->aux
.is_remote
= true;
2356 /* initialize the MST downstream port's AUX crc work queue */
2357 port
->aux
.drm_dev
= dev
;
2358 drm_dp_remote_aux_init(&port
->aux
);
2361 * Make sure the memory allocation for our parent branch stays
2362 * around until our own memory allocation is released
2364 drm_dp_mst_get_mstb_malloc(mstb
);
2370 drm_dp_mst_handle_link_address_port(struct drm_dp_mst_branch
*mstb
,
2371 struct drm_device
*dev
,
2372 struct drm_dp_link_addr_reply_port
*port_msg
)
2374 struct drm_dp_mst_topology_mgr
*mgr
= mstb
->mgr
;
2375 struct drm_dp_mst_port
*port
;
2376 int old_ddps
= 0, ret
;
2377 u8 new_pdt
= DP_PEER_DEVICE_NONE
;
2379 bool created
= false, send_link_addr
= false, changed
= false;
2381 port
= drm_dp_get_port(mstb
, port_msg
->port_number
);
2383 port
= drm_dp_mst_add_port(dev
, mgr
, mstb
,
2384 port_msg
->port_number
);
2389 } else if (!port
->input
&& port_msg
->input_port
&& port
->connector
) {
2390 /* Since port->connector can't be changed here, we create a
2391 * new port if input_port changes from 0 to 1
2393 drm_dp_mst_topology_unlink_port(mgr
, port
);
2394 drm_dp_mst_topology_put_port(port
);
2395 port
= drm_dp_mst_add_port(dev
, mgr
, mstb
,
2396 port_msg
->port_number
);
2401 } else if (port
->input
&& !port_msg
->input_port
) {
2403 } else if (port
->connector
) {
2404 /* We're updating a port that's exposed to userspace, so do it
2407 drm_modeset_lock(&mgr
->base
.lock
, NULL
);
2409 old_ddps
= port
->ddps
;
2410 changed
= port
->ddps
!= port_msg
->ddps
||
2412 (port
->ldps
!= port_msg
->legacy_device_plug_status
||
2413 port
->dpcd_rev
!= port_msg
->dpcd_revision
||
2414 port
->mcs
!= port_msg
->mcs
||
2415 port
->pdt
!= port_msg
->peer_device_type
||
2416 port
->num_sdp_stream_sinks
!=
2417 port_msg
->num_sdp_stream_sinks
));
2420 port
->input
= port_msg
->input_port
;
2422 new_pdt
= port_msg
->peer_device_type
;
2423 new_mcs
= port_msg
->mcs
;
2424 port
->ddps
= port_msg
->ddps
;
2425 port
->ldps
= port_msg
->legacy_device_plug_status
;
2426 port
->dpcd_rev
= port_msg
->dpcd_revision
;
2427 port
->num_sdp_streams
= port_msg
->num_sdp_streams
;
2428 port
->num_sdp_stream_sinks
= port_msg
->num_sdp_stream_sinks
;
2430 /* manage mstb port lists with mgr lock - take a reference
2433 mutex_lock(&mgr
->lock
);
2434 drm_dp_mst_topology_get_port(port
);
2435 list_add(&port
->next
, &mstb
->ports
);
2437 mutex_unlock(&mgr
->lock
);
2441 * Reprobe PBN caps on both hotplug, and when re-probing the link
2442 * for our parent mstb
2444 if (old_ddps
!= port
->ddps
|| !created
) {
2445 if (port
->ddps
&& !port
->input
) {
2446 ret
= drm_dp_send_enum_path_resources(mgr
, mstb
,
2455 ret
= drm_dp_port_set_pdt(port
, new_pdt
, new_mcs
);
2457 send_link_addr
= true;
2458 } else if (ret
< 0) {
2459 drm_err(dev
, "Failed to change PDT on port %p: %d\n", port
, ret
);
2464 * If this port wasn't just created, then we're reprobing because
2465 * we're coming out of suspend. In this case, always resend the link
2466 * address if there's an MSTB on this port
2468 if (!created
&& port
->pdt
== DP_PEER_DEVICE_MST_BRANCHING
&&
2470 send_link_addr
= true;
2472 if (port
->connector
)
2473 drm_modeset_unlock(&mgr
->base
.lock
);
2474 else if (!port
->input
)
2475 drm_dp_mst_port_add_connector(mstb
, port
);
2477 if (send_link_addr
&& port
->mstb
) {
2478 ret
= drm_dp_send_link_address(mgr
, port
->mstb
);
2479 if (ret
== 1) /* MSTB below us changed */
2485 /* put reference to this port */
2486 drm_dp_mst_topology_put_port(port
);
2490 drm_dp_mst_topology_unlink_port(mgr
, port
);
2491 if (port
->connector
)
2492 drm_modeset_unlock(&mgr
->base
.lock
);
2494 drm_dp_mst_topology_put_port(port
);
2499 drm_dp_mst_handle_conn_stat(struct drm_dp_mst_branch
*mstb
,
2500 struct drm_dp_connection_status_notify
*conn_stat
)
2502 struct drm_dp_mst_topology_mgr
*mgr
= mstb
->mgr
;
2503 struct drm_dp_mst_port
*port
;
2507 bool dowork
= false, create_connector
= false;
2509 port
= drm_dp_get_port(mstb
, conn_stat
->port_number
);
2513 if (port
->connector
) {
2514 if (!port
->input
&& conn_stat
->input_port
) {
2516 * We can't remove a connector from an already exposed
2517 * port, so just throw the port out and make sure we
2518 * reprobe the link address of it's parent MSTB
2520 drm_dp_mst_topology_unlink_port(mgr
, port
);
2521 mstb
->link_address_sent
= false;
2526 /* Locking is only needed if the port's exposed to userspace */
2527 drm_modeset_lock(&mgr
->base
.lock
, NULL
);
2528 } else if (port
->input
&& !conn_stat
->input_port
) {
2529 create_connector
= true;
2530 /* Reprobe link address so we get num_sdp_streams */
2531 mstb
->link_address_sent
= false;
2535 old_ddps
= port
->ddps
;
2536 port
->input
= conn_stat
->input_port
;
2537 port
->ldps
= conn_stat
->legacy_device_plug_status
;
2538 port
->ddps
= conn_stat
->displayport_device_plug_status
;
2540 if (old_ddps
!= port
->ddps
) {
2541 if (port
->ddps
&& !port
->input
)
2542 drm_dp_send_enum_path_resources(mgr
, mstb
, port
);
2547 new_pdt
= port
->input
? DP_PEER_DEVICE_NONE
: conn_stat
->peer_device_type
;
2548 new_mcs
= conn_stat
->message_capability_status
;
2549 ret
= drm_dp_port_set_pdt(port
, new_pdt
, new_mcs
);
2552 } else if (ret
< 0) {
2553 drm_err(mgr
->dev
, "Failed to change PDT for port %p: %d\n", port
, ret
);
2557 if (port
->connector
)
2558 drm_modeset_unlock(&mgr
->base
.lock
);
2559 else if (create_connector
)
2560 drm_dp_mst_port_add_connector(mstb
, port
);
2563 drm_dp_mst_topology_put_port(port
);
2565 queue_work(system_long_wq
, &mstb
->mgr
->work
);
2568 static struct drm_dp_mst_branch
*drm_dp_get_mst_branch_device(struct drm_dp_mst_topology_mgr
*mgr
,
2571 struct drm_dp_mst_branch
*mstb
;
2572 struct drm_dp_mst_port
*port
;
2574 /* find the port by iterating down */
2576 mutex_lock(&mgr
->lock
);
2577 mstb
= mgr
->mst_primary
;
2582 for (i
= 0; i
< lct
- 1; i
++) {
2583 int shift
= (i
% 2) ? 0 : 4;
2584 int port_num
= (rad
[i
/ 2] >> shift
) & 0xf;
2586 list_for_each_entry(port
, &mstb
->ports
, next
) {
2587 if (port
->port_num
== port_num
) {
2591 "failed to lookup MSTB with lct %d, rad %02x\n",
2600 ret
= drm_dp_mst_topology_try_get_mstb(mstb
);
2604 mutex_unlock(&mgr
->lock
);
2608 static struct drm_dp_mst_branch
*get_mst_branch_device_by_guid_helper(
2609 struct drm_dp_mst_branch
*mstb
,
2610 const uint8_t *guid
)
2612 struct drm_dp_mst_branch
*found_mstb
;
2613 struct drm_dp_mst_port
*port
;
2615 if (memcmp(mstb
->guid
, guid
, 16) == 0)
2619 list_for_each_entry(port
, &mstb
->ports
, next
) {
2623 found_mstb
= get_mst_branch_device_by_guid_helper(port
->mstb
, guid
);
2632 static struct drm_dp_mst_branch
*
2633 drm_dp_get_mst_branch_device_by_guid(struct drm_dp_mst_topology_mgr
*mgr
,
2634 const uint8_t *guid
)
2636 struct drm_dp_mst_branch
*mstb
;
2639 /* find the port by iterating down */
2640 mutex_lock(&mgr
->lock
);
2642 mstb
= get_mst_branch_device_by_guid_helper(mgr
->mst_primary
, guid
);
2644 ret
= drm_dp_mst_topology_try_get_mstb(mstb
);
2649 mutex_unlock(&mgr
->lock
);
2653 static int drm_dp_check_and_send_link_address(struct drm_dp_mst_topology_mgr
*mgr
,
2654 struct drm_dp_mst_branch
*mstb
)
2656 struct drm_dp_mst_port
*port
;
2658 bool changed
= false;
2660 if (!mstb
->link_address_sent
) {
2661 ret
= drm_dp_send_link_address(mgr
, mstb
);
2668 list_for_each_entry(port
, &mstb
->ports
, next
) {
2669 struct drm_dp_mst_branch
*mstb_child
= NULL
;
2671 if (port
->input
|| !port
->ddps
)
2675 mstb_child
= drm_dp_mst_topology_get_mstb_validated(
2679 ret
= drm_dp_check_and_send_link_address(mgr
,
2681 drm_dp_mst_topology_put_mstb(mstb_child
);
2692 static void drm_dp_mst_link_probe_work(struct work_struct
*work
)
2694 struct drm_dp_mst_topology_mgr
*mgr
=
2695 container_of(work
, struct drm_dp_mst_topology_mgr
, work
);
2696 struct drm_device
*dev
= mgr
->dev
;
2697 struct drm_dp_mst_branch
*mstb
;
2699 bool clear_payload_id_table
;
2701 mutex_lock(&mgr
->probe_lock
);
2703 mutex_lock(&mgr
->lock
);
2704 clear_payload_id_table
= !mgr
->payload_id_table_cleared
;
2705 mgr
->payload_id_table_cleared
= true;
2707 mstb
= mgr
->mst_primary
;
2709 ret
= drm_dp_mst_topology_try_get_mstb(mstb
);
2713 mutex_unlock(&mgr
->lock
);
2715 mutex_unlock(&mgr
->probe_lock
);
2720 * Certain branch devices seem to incorrectly report an available_pbn
2721 * of 0 on downstream sinks, even after clearing the
2722 * DP_PAYLOAD_ALLOCATE_* registers in
2723 * drm_dp_mst_topology_mgr_set_mst(). Namely, the CableMatters USB-C
2724 * 2x DP hub. Sending a CLEAR_PAYLOAD_ID_TABLE message seems to make
2725 * things work again.
2727 if (clear_payload_id_table
) {
2728 drm_dbg_kms(dev
, "Clearing payload ID table\n");
2729 drm_dp_send_clear_payload_id_table(mgr
, mstb
);
2732 ret
= drm_dp_check_and_send_link_address(mgr
, mstb
);
2733 drm_dp_mst_topology_put_mstb(mstb
);
2735 mutex_unlock(&mgr
->probe_lock
);
2737 drm_kms_helper_hotplug_event(dev
);
2740 static bool drm_dp_validate_guid(struct drm_dp_mst_topology_mgr
*mgr
,
2745 if (memchr_inv(guid
, 0, 16))
2748 salt
= get_jiffies_64();
2750 memcpy(&guid
[0], &salt
, sizeof(u64
));
2751 memcpy(&guid
[8], &salt
, sizeof(u64
));
2756 static void build_dpcd_read(struct drm_dp_sideband_msg_tx
*msg
,
2757 u8 port_num
, u32 offset
, u8 num_bytes
)
2759 struct drm_dp_sideband_msg_req_body req
;
2761 req
.req_type
= DP_REMOTE_DPCD_READ
;
2762 req
.u
.dpcd_read
.port_number
= port_num
;
2763 req
.u
.dpcd_read
.dpcd_address
= offset
;
2764 req
.u
.dpcd_read
.num_bytes
= num_bytes
;
2765 drm_dp_encode_sideband_req(&req
, msg
);
2768 static int drm_dp_send_sideband_msg(struct drm_dp_mst_topology_mgr
*mgr
,
2769 bool up
, u8
*msg
, int len
)
2772 int regbase
= up
? DP_SIDEBAND_MSG_UP_REP_BASE
: DP_SIDEBAND_MSG_DOWN_REQ_BASE
;
2773 int tosend
, total
, offset
;
2780 tosend
= min3(mgr
->max_dpcd_transaction_bytes
, 16, total
);
2782 ret
= drm_dp_dpcd_write(mgr
->aux
, regbase
+ offset
,
2785 if (ret
!= tosend
) {
2786 if (ret
== -EIO
&& retries
< 5) {
2790 drm_dbg_kms(mgr
->dev
, "failed to dpcd write %d %d\n", tosend
, ret
);
2796 } while (total
> 0);
2800 static int set_hdr_from_dst_qlock(struct drm_dp_sideband_msg_hdr
*hdr
,
2801 struct drm_dp_sideband_msg_tx
*txmsg
)
2803 struct drm_dp_mst_branch
*mstb
= txmsg
->dst
;
2806 req_type
= txmsg
->msg
[0] & 0x7f;
2807 if (req_type
== DP_CONNECTION_STATUS_NOTIFY
||
2808 req_type
== DP_RESOURCE_STATUS_NOTIFY
||
2809 req_type
== DP_CLEAR_PAYLOAD_ID_TABLE
)
2813 hdr
->path_msg
= txmsg
->path_msg
;
2814 if (hdr
->broadcast
) {
2818 hdr
->lct
= mstb
->lct
;
2819 hdr
->lcr
= mstb
->lct
- 1;
2822 memcpy(hdr
->rad
, mstb
->rad
, hdr
->lct
/ 2);
2827 * process a single block of the next message in the sideband queue
2829 static int process_single_tx_qlock(struct drm_dp_mst_topology_mgr
*mgr
,
2830 struct drm_dp_sideband_msg_tx
*txmsg
,
2834 struct drm_dp_sideband_msg_hdr hdr
;
2835 int len
, space
, idx
, tosend
;
2838 if (txmsg
->state
== DRM_DP_SIDEBAND_TX_SENT
)
2841 memset(&hdr
, 0, sizeof(struct drm_dp_sideband_msg_hdr
));
2843 if (txmsg
->state
== DRM_DP_SIDEBAND_TX_QUEUED
)
2844 txmsg
->state
= DRM_DP_SIDEBAND_TX_START_SEND
;
2846 /* make hdr from dst mst */
2847 ret
= set_hdr_from_dst_qlock(&hdr
, txmsg
);
2851 /* amount left to send in this message */
2852 len
= txmsg
->cur_len
- txmsg
->cur_offset
;
2854 /* 48 - sideband msg size - 1 byte for data CRC, x header bytes */
2855 space
= 48 - 1 - drm_dp_calc_sb_hdr_size(&hdr
);
2857 tosend
= min(len
, space
);
2858 if (len
== txmsg
->cur_len
)
2864 hdr
.msg_len
= tosend
+ 1;
2865 drm_dp_encode_sideband_msg_hdr(&hdr
, chunk
, &idx
);
2866 memcpy(&chunk
[idx
], &txmsg
->msg
[txmsg
->cur_offset
], tosend
);
2867 /* add crc at end */
2868 drm_dp_crc_sideband_chunk_req(&chunk
[idx
], tosend
);
2871 ret
= drm_dp_send_sideband_msg(mgr
, up
, chunk
, idx
);
2873 if (drm_debug_enabled(DRM_UT_DP
)) {
2874 struct drm_printer p
= drm_debug_printer(DBG_PREFIX
);
2876 drm_printf(&p
, "sideband msg failed to send\n");
2877 drm_dp_mst_dump_sideband_msg_tx(&p
, txmsg
);
2882 txmsg
->cur_offset
+= tosend
;
2883 if (txmsg
->cur_offset
== txmsg
->cur_len
) {
2884 txmsg
->state
= DRM_DP_SIDEBAND_TX_SENT
;
2890 static void process_single_down_tx_qlock(struct drm_dp_mst_topology_mgr
*mgr
)
2892 struct drm_dp_sideband_msg_tx
*txmsg
;
2895 WARN_ON(!mutex_is_locked(&mgr
->qlock
));
2897 /* construct a chunk from the first msg in the tx_msg queue */
2898 if (list_empty(&mgr
->tx_msg_downq
))
2901 txmsg
= list_first_entry(&mgr
->tx_msg_downq
,
2902 struct drm_dp_sideband_msg_tx
, next
);
2903 ret
= process_single_tx_qlock(mgr
, txmsg
, false);
2905 drm_dbg_kms(mgr
->dev
, "failed to send msg in q %d\n", ret
);
2906 list_del(&txmsg
->next
);
2907 txmsg
->state
= DRM_DP_SIDEBAND_TX_TIMEOUT
;
2908 wake_up_all(&mgr
->tx_waitq
);
2912 static void drm_dp_queue_down_tx(struct drm_dp_mst_topology_mgr
*mgr
,
2913 struct drm_dp_sideband_msg_tx
*txmsg
)
2915 mutex_lock(&mgr
->qlock
);
2916 list_add_tail(&txmsg
->next
, &mgr
->tx_msg_downq
);
2918 if (drm_debug_enabled(DRM_UT_DP
)) {
2919 struct drm_printer p
= drm_debug_printer(DBG_PREFIX
);
2921 drm_dp_mst_dump_sideband_msg_tx(&p
, txmsg
);
2924 if (list_is_singular(&mgr
->tx_msg_downq
))
2925 process_single_down_tx_qlock(mgr
);
2926 mutex_unlock(&mgr
->qlock
);
2930 drm_dp_dump_link_address(const struct drm_dp_mst_topology_mgr
*mgr
,
2931 struct drm_dp_link_address_ack_reply
*reply
)
2933 struct drm_dp_link_addr_reply_port
*port_reply
;
2936 for (i
= 0; i
< reply
->nports
; i
++) {
2937 port_reply
= &reply
->ports
[i
];
2938 drm_dbg_kms(mgr
->dev
,
2939 "port %d: input %d, pdt: %d, pn: %d, dpcd_rev: %02x, mcs: %d, ddps: %d, ldps %d, sdp %d/%d\n",
2941 port_reply
->input_port
,
2942 port_reply
->peer_device_type
,
2943 port_reply
->port_number
,
2944 port_reply
->dpcd_revision
,
2947 port_reply
->legacy_device_plug_status
,
2948 port_reply
->num_sdp_streams
,
2949 port_reply
->num_sdp_stream_sinks
);
2953 static int drm_dp_send_link_address(struct drm_dp_mst_topology_mgr
*mgr
,
2954 struct drm_dp_mst_branch
*mstb
)
2956 struct drm_dp_sideband_msg_tx
*txmsg
;
2957 struct drm_dp_link_address_ack_reply
*reply
;
2958 struct drm_dp_mst_port
*port
, *tmp
;
2959 int i
, ret
, port_mask
= 0;
2960 bool changed
= false;
2962 txmsg
= kzalloc(sizeof(*txmsg
), GFP_KERNEL
);
2967 build_link_address(txmsg
);
2969 mstb
->link_address_sent
= true;
2970 drm_dp_queue_down_tx(mgr
, txmsg
);
2972 /* FIXME: Actually do some real error handling here */
2973 ret
= drm_dp_mst_wait_tx_reply(mstb
, txmsg
);
2975 drm_err(mgr
->dev
, "Sending link address failed with %d\n", ret
);
2978 if (txmsg
->reply
.reply_type
== DP_SIDEBAND_REPLY_NAK
) {
2979 drm_err(mgr
->dev
, "link address NAK received\n");
2984 reply
= &txmsg
->reply
.u
.link_addr
;
2985 drm_dbg_kms(mgr
->dev
, "link address reply: %d\n", reply
->nports
);
2986 drm_dp_dump_link_address(mgr
, reply
);
2988 ret
= drm_dp_check_mstb_guid(mstb
, reply
->guid
);
2992 drm_dp_mst_rad_to_str(mstb
->rad
, mstb
->lct
, buf
, sizeof(buf
));
2993 drm_err(mgr
->dev
, "GUID check on %s failed: %d\n", buf
, ret
);
2997 for (i
= 0; i
< reply
->nports
; i
++) {
2998 port_mask
|= BIT(reply
->ports
[i
].port_number
);
2999 ret
= drm_dp_mst_handle_link_address_port(mstb
, mgr
->dev
,
3007 /* Prune any ports that are currently a part of mstb in our in-memory
3008 * topology, but were not seen in this link address. Usually this
3009 * means that they were removed while the topology was out of sync,
3010 * e.g. during suspend/resume
3012 mutex_lock(&mgr
->lock
);
3013 list_for_each_entry_safe(port
, tmp
, &mstb
->ports
, next
) {
3014 if (port_mask
& BIT(port
->port_num
))
3017 drm_dbg_kms(mgr
->dev
, "port %d was not in link address, removing\n",
3019 list_del(&port
->next
);
3020 drm_dp_mst_topology_put_port(port
);
3023 mutex_unlock(&mgr
->lock
);
3027 mstb
->link_address_sent
= false;
3029 return ret
< 0 ? ret
: changed
;
3033 drm_dp_send_clear_payload_id_table(struct drm_dp_mst_topology_mgr
*mgr
,
3034 struct drm_dp_mst_branch
*mstb
)
3036 struct drm_dp_sideband_msg_tx
*txmsg
;
3039 txmsg
= kzalloc(sizeof(*txmsg
), GFP_KERNEL
);
3044 build_clear_payload_id_table(txmsg
);
3046 drm_dp_queue_down_tx(mgr
, txmsg
);
3048 ret
= drm_dp_mst_wait_tx_reply(mstb
, txmsg
);
3049 if (ret
> 0 && txmsg
->reply
.reply_type
== DP_SIDEBAND_REPLY_NAK
)
3050 drm_dbg_kms(mgr
->dev
, "clear payload table id nak received\n");
3056 drm_dp_send_enum_path_resources(struct drm_dp_mst_topology_mgr
*mgr
,
3057 struct drm_dp_mst_branch
*mstb
,
3058 struct drm_dp_mst_port
*port
)
3060 struct drm_dp_enum_path_resources_ack_reply
*path_res
;
3061 struct drm_dp_sideband_msg_tx
*txmsg
;
3064 txmsg
= kzalloc(sizeof(*txmsg
), GFP_KERNEL
);
3069 build_enum_path_resources(txmsg
, port
->port_num
);
3071 drm_dp_queue_down_tx(mgr
, txmsg
);
3073 ret
= drm_dp_mst_wait_tx_reply(mstb
, txmsg
);
3076 path_res
= &txmsg
->reply
.u
.path_resources
;
3078 if (txmsg
->reply
.reply_type
== DP_SIDEBAND_REPLY_NAK
) {
3079 drm_dbg_kms(mgr
->dev
, "enum path resources nak received\n");
3081 if (port
->port_num
!= path_res
->port_number
)
3082 DRM_ERROR("got incorrect port in response\n");
3084 drm_dbg_kms(mgr
->dev
, "enum path resources %d: %d %d\n",
3085 path_res
->port_number
,
3086 path_res
->full_payload_bw_number
,
3087 path_res
->avail_payload_bw_number
);
3090 * If something changed, make sure we send a
3093 if (port
->full_pbn
!= path_res
->full_payload_bw_number
||
3094 port
->fec_capable
!= path_res
->fec_capable
)
3097 port
->full_pbn
= path_res
->full_payload_bw_number
;
3098 port
->fec_capable
= path_res
->fec_capable
;
3106 static struct drm_dp_mst_port
*drm_dp_get_last_connected_port_to_mstb(struct drm_dp_mst_branch
*mstb
)
3108 if (!mstb
->port_parent
)
3111 if (mstb
->port_parent
->mstb
!= mstb
)
3112 return mstb
->port_parent
;
3114 return drm_dp_get_last_connected_port_to_mstb(mstb
->port_parent
->parent
);
3118 * Searches upwards in the topology starting from mstb to try to find the
3119 * closest available parent of mstb that's still connected to the rest of the
3120 * topology. This can be used in order to perform operations like releasing
3121 * payloads, where the branch device which owned the payload may no longer be
3122 * around and thus would require that the payload on the last living relative
3125 static struct drm_dp_mst_branch
*
3126 drm_dp_get_last_connected_port_and_mstb(struct drm_dp_mst_topology_mgr
*mgr
,
3127 struct drm_dp_mst_branch
*mstb
,
3130 struct drm_dp_mst_branch
*rmstb
= NULL
;
3131 struct drm_dp_mst_port
*found_port
;
3133 mutex_lock(&mgr
->lock
);
3134 if (!mgr
->mst_primary
)
3138 found_port
= drm_dp_get_last_connected_port_to_mstb(mstb
);
3142 if (drm_dp_mst_topology_try_get_mstb(found_port
->parent
)) {
3143 rmstb
= found_port
->parent
;
3144 *port_num
= found_port
->port_num
;
3146 /* Search again, starting from this parent */
3147 mstb
= found_port
->parent
;
3151 mutex_unlock(&mgr
->lock
);
3155 static int drm_dp_payload_send_msg(struct drm_dp_mst_topology_mgr
*mgr
,
3156 struct drm_dp_mst_port
*port
,
3160 struct drm_dp_sideband_msg_tx
*txmsg
;
3161 struct drm_dp_mst_branch
*mstb
;
3163 u8 sinks
[DRM_DP_MAX_SDP_STREAMS
];
3166 port_num
= port
->port_num
;
3167 mstb
= drm_dp_mst_topology_get_mstb_validated(mgr
, port
->parent
);
3169 mstb
= drm_dp_get_last_connected_port_and_mstb(mgr
,
3177 txmsg
= kzalloc(sizeof(*txmsg
), GFP_KERNEL
);
3183 for (i
= 0; i
< port
->num_sdp_streams
; i
++)
3187 build_allocate_payload(txmsg
, port_num
,
3189 pbn
, port
->num_sdp_streams
, sinks
);
3191 drm_dp_queue_down_tx(mgr
, txmsg
);
3194 * FIXME: there is a small chance that between getting the last
3195 * connected mstb and sending the payload message, the last connected
3196 * mstb could also be removed from the topology. In the future, this
3197 * needs to be fixed by restarting the
3198 * drm_dp_get_last_connected_port_and_mstb() search in the event of a
3199 * timeout if the topology is still connected to the system.
3201 ret
= drm_dp_mst_wait_tx_reply(mstb
, txmsg
);
3203 if (txmsg
->reply
.reply_type
== DP_SIDEBAND_REPLY_NAK
)
3210 drm_dp_mst_topology_put_mstb(mstb
);
3214 int drm_dp_send_power_updown_phy(struct drm_dp_mst_topology_mgr
*mgr
,
3215 struct drm_dp_mst_port
*port
, bool power_up
)
3217 struct drm_dp_sideband_msg_tx
*txmsg
;
3220 port
= drm_dp_mst_topology_get_port_validated(mgr
, port
);
3224 txmsg
= kzalloc(sizeof(*txmsg
), GFP_KERNEL
);
3226 drm_dp_mst_topology_put_port(port
);
3230 txmsg
->dst
= port
->parent
;
3231 build_power_updown_phy(txmsg
, port
->port_num
, power_up
);
3232 drm_dp_queue_down_tx(mgr
, txmsg
);
3234 ret
= drm_dp_mst_wait_tx_reply(port
->parent
, txmsg
);
3236 if (txmsg
->reply
.reply_type
== DP_SIDEBAND_REPLY_NAK
)
3242 drm_dp_mst_topology_put_port(port
);
3246 EXPORT_SYMBOL(drm_dp_send_power_updown_phy
);
3248 int drm_dp_send_query_stream_enc_status(struct drm_dp_mst_topology_mgr
*mgr
,
3249 struct drm_dp_mst_port
*port
,
3250 struct drm_dp_query_stream_enc_status_ack_reply
*status
)
3252 struct drm_dp_sideband_msg_tx
*txmsg
;
3256 txmsg
= kzalloc(sizeof(*txmsg
), GFP_KERNEL
);
3260 port
= drm_dp_mst_topology_get_port_validated(mgr
, port
);
3266 get_random_bytes(nonce
, sizeof(nonce
));
3269 * "Source device targets the QUERY_STREAM_ENCRYPTION_STATUS message
3270 * transaction at the MST Branch device directly connected to the
3273 txmsg
->dst
= mgr
->mst_primary
;
3275 build_query_stream_enc_status(txmsg
, port
->vcpi
.vcpi
, nonce
);
3277 drm_dp_queue_down_tx(mgr
, txmsg
);
3279 ret
= drm_dp_mst_wait_tx_reply(mgr
->mst_primary
, txmsg
);
3282 } else if (txmsg
->reply
.reply_type
== DP_SIDEBAND_REPLY_NAK
) {
3283 drm_dbg_kms(mgr
->dev
, "query encryption status nak received\n");
3289 memcpy(status
, &txmsg
->reply
.u
.enc_status
, sizeof(*status
));
3292 drm_dp_mst_topology_put_port(port
);
3297 EXPORT_SYMBOL(drm_dp_send_query_stream_enc_status
);
3299 static int drm_dp_create_payload_step1(struct drm_dp_mst_topology_mgr
*mgr
,
3301 struct drm_dp_payload
*payload
)
3305 ret
= drm_dp_dpcd_write_payload(mgr
, id
, payload
);
3307 payload
->payload_state
= 0;
3310 payload
->payload_state
= DP_PAYLOAD_LOCAL
;
3314 static int drm_dp_create_payload_step2(struct drm_dp_mst_topology_mgr
*mgr
,
3315 struct drm_dp_mst_port
*port
,
3317 struct drm_dp_payload
*payload
)
3321 ret
= drm_dp_payload_send_msg(mgr
, port
, id
, port
->vcpi
.pbn
);
3324 payload
->payload_state
= DP_PAYLOAD_REMOTE
;
3328 static int drm_dp_destroy_payload_step1(struct drm_dp_mst_topology_mgr
*mgr
,
3329 struct drm_dp_mst_port
*port
,
3331 struct drm_dp_payload
*payload
)
3333 drm_dbg_kms(mgr
->dev
, "\n");
3334 /* it's okay for these to fail */
3336 drm_dp_payload_send_msg(mgr
, port
, id
, 0);
3339 drm_dp_dpcd_write_payload(mgr
, id
, payload
);
3340 payload
->payload_state
= DP_PAYLOAD_DELETE_LOCAL
;
3344 static int drm_dp_destroy_payload_step2(struct drm_dp_mst_topology_mgr
*mgr
,
3346 struct drm_dp_payload
*payload
)
3348 payload
->payload_state
= 0;
3353 * drm_dp_update_payload_part1() - Execute payload update part 1
3354 * @mgr: manager to use.
3355 * @start_slot: this is the cur slot
3357 * NOTE: start_slot is a temporary workaround for non-atomic drivers,
3358 * this will be removed when non-atomic mst helpers are moved out of the helper
3360 * This iterates over all proposed virtual channels, and tries to
3361 * allocate space in the link for them. For 0->slots transitions,
3362 * this step just writes the VCPI to the MST device. For slots->0
3363 * transitions, this writes the updated VCPIs and removes the
3364 * remote VC payloads.
3366 * after calling this the driver should generate ACT and payload
3369 int drm_dp_update_payload_part1(struct drm_dp_mst_topology_mgr
*mgr
, int start_slot
)
3371 struct drm_dp_payload req_payload
;
3372 struct drm_dp_mst_port
*port
;
3374 int cur_slots
= start_slot
;
3377 mutex_lock(&mgr
->payload_lock
);
3378 for (i
= 0; i
< mgr
->max_payloads
; i
++) {
3379 struct drm_dp_vcpi
*vcpi
= mgr
->proposed_vcpis
[i
];
3380 struct drm_dp_payload
*payload
= &mgr
->payloads
[i
];
3381 bool put_port
= false;
3383 /* solve the current payloads - compare to the hw ones
3384 - update the hw view */
3385 req_payload
.start_slot
= cur_slots
;
3387 port
= container_of(vcpi
, struct drm_dp_mst_port
,
3390 mutex_lock(&mgr
->lock
);
3391 skip
= !drm_dp_mst_port_downstream_of_branch(port
, mgr
->mst_primary
);
3392 mutex_unlock(&mgr
->lock
);
3395 drm_dbg_kms(mgr
->dev
,
3396 "Virtual channel %d is not in current topology\n",
3400 /* Validated ports don't matter if we're releasing
3403 if (vcpi
->num_slots
) {
3404 port
= drm_dp_mst_topology_get_port_validated(
3407 if (vcpi
->num_slots
== payload
->num_slots
) {
3408 cur_slots
+= vcpi
->num_slots
;
3409 payload
->start_slot
= req_payload
.start_slot
;
3412 drm_dbg_kms(mgr
->dev
,
3413 "Fail:set payload to invalid sink");
3414 mutex_unlock(&mgr
->payload_lock
);
3421 req_payload
.num_slots
= vcpi
->num_slots
;
3422 req_payload
.vcpi
= vcpi
->vcpi
;
3425 req_payload
.num_slots
= 0;
3428 payload
->start_slot
= req_payload
.start_slot
;
3429 /* work out what is required to happen with this payload */
3430 if (payload
->num_slots
!= req_payload
.num_slots
) {
3432 /* need to push an update for this payload */
3433 if (req_payload
.num_slots
) {
3434 drm_dp_create_payload_step1(mgr
, vcpi
->vcpi
,
3436 payload
->num_slots
= req_payload
.num_slots
;
3437 payload
->vcpi
= req_payload
.vcpi
;
3439 } else if (payload
->num_slots
) {
3440 payload
->num_slots
= 0;
3441 drm_dp_destroy_payload_step1(mgr
, port
,
3444 req_payload
.payload_state
=
3445 payload
->payload_state
;
3446 payload
->start_slot
= 0;
3448 payload
->payload_state
= req_payload
.payload_state
;
3450 cur_slots
+= req_payload
.num_slots
;
3453 drm_dp_mst_topology_put_port(port
);
3456 for (i
= 0; i
< mgr
->max_payloads
; /* do nothing */) {
3457 if (mgr
->payloads
[i
].payload_state
!= DP_PAYLOAD_DELETE_LOCAL
) {
3462 drm_dbg_kms(mgr
->dev
, "removing payload %d\n", i
);
3463 for (j
= i
; j
< mgr
->max_payloads
- 1; j
++) {
3464 mgr
->payloads
[j
] = mgr
->payloads
[j
+ 1];
3465 mgr
->proposed_vcpis
[j
] = mgr
->proposed_vcpis
[j
+ 1];
3467 if (mgr
->proposed_vcpis
[j
] &&
3468 mgr
->proposed_vcpis
[j
]->num_slots
) {
3469 set_bit(j
+ 1, &mgr
->payload_mask
);
3471 clear_bit(j
+ 1, &mgr
->payload_mask
);
3475 memset(&mgr
->payloads
[mgr
->max_payloads
- 1], 0,
3476 sizeof(struct drm_dp_payload
));
3477 mgr
->proposed_vcpis
[mgr
->max_payloads
- 1] = NULL
;
3478 clear_bit(mgr
->max_payloads
, &mgr
->payload_mask
);
3480 mutex_unlock(&mgr
->payload_lock
);
3484 EXPORT_SYMBOL(drm_dp_update_payload_part1
);
3487 * drm_dp_update_payload_part2() - Execute payload update part 2
3488 * @mgr: manager to use.
3490 * This iterates over all proposed virtual channels, and tries to
3491 * allocate space in the link for them. For 0->slots transitions,
3492 * this step writes the remote VC payload commands. For slots->0
3493 * this just resets some internal state.
3495 int drm_dp_update_payload_part2(struct drm_dp_mst_topology_mgr
*mgr
)
3497 struct drm_dp_mst_port
*port
;
3502 mutex_lock(&mgr
->payload_lock
);
3503 for (i
= 0; i
< mgr
->max_payloads
; i
++) {
3505 if (!mgr
->proposed_vcpis
[i
])
3508 port
= container_of(mgr
->proposed_vcpis
[i
], struct drm_dp_mst_port
, vcpi
);
3510 mutex_lock(&mgr
->lock
);
3511 skip
= !drm_dp_mst_port_downstream_of_branch(port
, mgr
->mst_primary
);
3512 mutex_unlock(&mgr
->lock
);
3517 drm_dbg_kms(mgr
->dev
, "payload %d %d\n", i
, mgr
->payloads
[i
].payload_state
);
3518 if (mgr
->payloads
[i
].payload_state
== DP_PAYLOAD_LOCAL
) {
3519 ret
= drm_dp_create_payload_step2(mgr
, port
, mgr
->proposed_vcpis
[i
]->vcpi
, &mgr
->payloads
[i
]);
3520 } else if (mgr
->payloads
[i
].payload_state
== DP_PAYLOAD_DELETE_LOCAL
) {
3521 ret
= drm_dp_destroy_payload_step2(mgr
, mgr
->proposed_vcpis
[i
]->vcpi
, &mgr
->payloads
[i
]);
3524 mutex_unlock(&mgr
->payload_lock
);
3528 mutex_unlock(&mgr
->payload_lock
);
3531 EXPORT_SYMBOL(drm_dp_update_payload_part2
);
3533 static int drm_dp_send_dpcd_read(struct drm_dp_mst_topology_mgr
*mgr
,
3534 struct drm_dp_mst_port
*port
,
3535 int offset
, int size
, u8
*bytes
)
3538 struct drm_dp_sideband_msg_tx
*txmsg
;
3539 struct drm_dp_mst_branch
*mstb
;
3541 mstb
= drm_dp_mst_topology_get_mstb_validated(mgr
, port
->parent
);
3545 txmsg
= kzalloc(sizeof(*txmsg
), GFP_KERNEL
);
3551 build_dpcd_read(txmsg
, port
->port_num
, offset
, size
);
3552 txmsg
->dst
= port
->parent
;
3554 drm_dp_queue_down_tx(mgr
, txmsg
);
3556 ret
= drm_dp_mst_wait_tx_reply(mstb
, txmsg
);
3560 /* DPCD read should never be NACKed */
3561 if (txmsg
->reply
.reply_type
== 1) {
3562 drm_err(mgr
->dev
, "mstb %p port %d: DPCD read on addr 0x%x for %d bytes NAKed\n",
3563 mstb
, port
->port_num
, offset
, size
);
3568 if (txmsg
->reply
.u
.remote_dpcd_read_ack
.num_bytes
!= size
) {
3573 ret
= min_t(size_t, txmsg
->reply
.u
.remote_dpcd_read_ack
.num_bytes
,
3575 memcpy(bytes
, txmsg
->reply
.u
.remote_dpcd_read_ack
.bytes
, ret
);
3580 drm_dp_mst_topology_put_mstb(mstb
);
3585 static int drm_dp_send_dpcd_write(struct drm_dp_mst_topology_mgr
*mgr
,
3586 struct drm_dp_mst_port
*port
,
3587 int offset
, int size
, u8
*bytes
)
3590 struct drm_dp_sideband_msg_tx
*txmsg
;
3591 struct drm_dp_mst_branch
*mstb
;
3593 mstb
= drm_dp_mst_topology_get_mstb_validated(mgr
, port
->parent
);
3597 txmsg
= kzalloc(sizeof(*txmsg
), GFP_KERNEL
);
3603 build_dpcd_write(txmsg
, port
->port_num
, offset
, size
, bytes
);
3606 drm_dp_queue_down_tx(mgr
, txmsg
);
3608 ret
= drm_dp_mst_wait_tx_reply(mstb
, txmsg
);
3610 if (txmsg
->reply
.reply_type
== DP_SIDEBAND_REPLY_NAK
)
3618 drm_dp_mst_topology_put_mstb(mstb
);
3622 static int drm_dp_encode_up_ack_reply(struct drm_dp_sideband_msg_tx
*msg
, u8 req_type
)
3624 struct drm_dp_sideband_msg_reply_body reply
;
3626 reply
.reply_type
= DP_SIDEBAND_REPLY_ACK
;
3627 reply
.req_type
= req_type
;
3628 drm_dp_encode_sideband_reply(&reply
, msg
);
3632 static int drm_dp_send_up_ack_reply(struct drm_dp_mst_topology_mgr
*mgr
,
3633 struct drm_dp_mst_branch
*mstb
,
3634 int req_type
, bool broadcast
)
3636 struct drm_dp_sideband_msg_tx
*txmsg
;
3638 txmsg
= kzalloc(sizeof(*txmsg
), GFP_KERNEL
);
3643 drm_dp_encode_up_ack_reply(txmsg
, req_type
);
3645 mutex_lock(&mgr
->qlock
);
3646 /* construct a chunk from the first msg in the tx_msg queue */
3647 process_single_tx_qlock(mgr
, txmsg
, true);
3648 mutex_unlock(&mgr
->qlock
);
3655 * drm_dp_get_vc_payload_bw - get the VC payload BW for an MST link
3656 * @mgr: The &drm_dp_mst_topology_mgr to use
3657 * @link_rate: link rate in 10kbits/s units
3658 * @link_lane_count: lane count
3660 * Calculate the total bandwidth of a MultiStream Transport link. The returned
3661 * value is in units of PBNs/(timeslots/1 MTP). This value can be used to
3662 * convert the number of PBNs required for a given stream to the number of
3663 * timeslots this stream requires in each MTP.
3665 int drm_dp_get_vc_payload_bw(const struct drm_dp_mst_topology_mgr
*mgr
,
3666 int link_rate
, int link_lane_count
)
3668 if (link_rate
== 0 || link_lane_count
== 0)
3669 drm_dbg_kms(mgr
->dev
, "invalid link rate/lane count: (%d / %d)\n",
3670 link_rate
, link_lane_count
);
3672 /* See DP v2.0 2.6.4.2, VCPayload_Bandwidth_for_OneTimeSlotPer_MTP_Allocation */
3673 return link_rate
* link_lane_count
/ 54000;
3675 EXPORT_SYMBOL(drm_dp_get_vc_payload_bw
);
3678 * drm_dp_read_mst_cap() - check whether or not a sink supports MST
3679 * @aux: The DP AUX channel to use
3680 * @dpcd: A cached copy of the DPCD capabilities for this sink
3682 * Returns: %True if the sink supports MST, %false otherwise
3684 bool drm_dp_read_mst_cap(struct drm_dp_aux
*aux
,
3685 const u8 dpcd
[DP_RECEIVER_CAP_SIZE
])
3689 if (dpcd
[DP_DPCD_REV
] < DP_DPCD_REV_12
)
3692 if (drm_dp_dpcd_readb(aux
, DP_MSTM_CAP
, &mstm_cap
) != 1)
3695 return mstm_cap
& DP_MST_CAP
;
3697 EXPORT_SYMBOL(drm_dp_read_mst_cap
);
3700 * drm_dp_mst_topology_mgr_set_mst() - Set the MST state for a topology manager
3701 * @mgr: manager to set state for
3702 * @mst_state: true to enable MST on this connector - false to disable.
3704 * This is called by the driver when it detects an MST capable device plugged
3705 * into a DP MST capable port, or when a DP MST capable device is unplugged.
3707 int drm_dp_mst_topology_mgr_set_mst(struct drm_dp_mst_topology_mgr
*mgr
, bool mst_state
)
3710 struct drm_dp_mst_branch
*mstb
= NULL
;
3712 mutex_lock(&mgr
->payload_lock
);
3713 mutex_lock(&mgr
->lock
);
3714 if (mst_state
== mgr
->mst_state
)
3717 mgr
->mst_state
= mst_state
;
3718 /* set the device into MST mode */
3720 struct drm_dp_payload reset_pay
;
3724 WARN_ON(mgr
->mst_primary
);
3727 ret
= drm_dp_read_dpcd_caps(mgr
->aux
, mgr
->dpcd
);
3729 drm_dbg_kms(mgr
->dev
, "%s: failed to read DPCD, ret %d\n",
3730 mgr
->aux
->name
, ret
);
3734 lane_count
= min_t(int, mgr
->dpcd
[2] & DP_MAX_LANE_COUNT_MASK
, mgr
->max_lane_count
);
3735 link_rate
= min_t(int, drm_dp_bw_code_to_link_rate(mgr
->dpcd
[1]), mgr
->max_link_rate
);
3736 mgr
->pbn_div
= drm_dp_get_vc_payload_bw(mgr
,
3739 if (mgr
->pbn_div
== 0) {
3744 /* add initial branch device at LCT 1 */
3745 mstb
= drm_dp_add_mst_branch_device(1, NULL
);
3752 /* give this the main reference */
3753 mgr
->mst_primary
= mstb
;
3754 drm_dp_mst_topology_get_mstb(mgr
->mst_primary
);
3756 ret
= drm_dp_dpcd_writeb(mgr
->aux
, DP_MSTM_CTRL
,
3759 DP_UPSTREAM_IS_SRC
);
3763 reset_pay
.start_slot
= 0;
3764 reset_pay
.num_slots
= 0x3f;
3765 drm_dp_dpcd_write_payload(mgr
, 0, &reset_pay
);
3767 queue_work(system_long_wq
, &mgr
->work
);
3771 /* disable MST on the device */
3772 mstb
= mgr
->mst_primary
;
3773 mgr
->mst_primary
= NULL
;
3774 /* this can fail if the device is gone */
3775 drm_dp_dpcd_writeb(mgr
->aux
, DP_MSTM_CTRL
, 0);
3777 memset(mgr
->payloads
, 0,
3778 mgr
->max_payloads
* sizeof(mgr
->payloads
[0]));
3779 memset(mgr
->proposed_vcpis
, 0,
3780 mgr
->max_payloads
* sizeof(mgr
->proposed_vcpis
[0]));
3781 mgr
->payload_mask
= 0;
3782 set_bit(0, &mgr
->payload_mask
);
3784 mgr
->payload_id_table_cleared
= false;
3788 mutex_unlock(&mgr
->lock
);
3789 mutex_unlock(&mgr
->payload_lock
);
3791 drm_dp_mst_topology_put_mstb(mstb
);
3795 EXPORT_SYMBOL(drm_dp_mst_topology_mgr_set_mst
);
3798 drm_dp_mst_topology_mgr_invalidate_mstb(struct drm_dp_mst_branch
*mstb
)
3800 struct drm_dp_mst_port
*port
;
3802 /* The link address will need to be re-sent on resume */
3803 mstb
->link_address_sent
= false;
3805 list_for_each_entry(port
, &mstb
->ports
, next
)
3807 drm_dp_mst_topology_mgr_invalidate_mstb(port
->mstb
);
3811 * drm_dp_mst_topology_mgr_suspend() - suspend the MST manager
3812 * @mgr: manager to suspend
3814 * This function tells the MST device that we can't handle UP messages
3815 * anymore. This should stop it from sending any since we are suspended.
3817 void drm_dp_mst_topology_mgr_suspend(struct drm_dp_mst_topology_mgr
*mgr
)
3819 mutex_lock(&mgr
->lock
);
3820 drm_dp_dpcd_writeb(mgr
->aux
, DP_MSTM_CTRL
,
3821 DP_MST_EN
| DP_UPSTREAM_IS_SRC
);
3822 mutex_unlock(&mgr
->lock
);
3823 flush_work(&mgr
->up_req_work
);
3824 flush_work(&mgr
->work
);
3825 flush_work(&mgr
->delayed_destroy_work
);
3827 mutex_lock(&mgr
->lock
);
3828 if (mgr
->mst_state
&& mgr
->mst_primary
)
3829 drm_dp_mst_topology_mgr_invalidate_mstb(mgr
->mst_primary
);
3830 mutex_unlock(&mgr
->lock
);
3832 EXPORT_SYMBOL(drm_dp_mst_topology_mgr_suspend
);
3835 * drm_dp_mst_topology_mgr_resume() - resume the MST manager
3836 * @mgr: manager to resume
3837 * @sync: whether or not to perform topology reprobing synchronously
3839 * This will fetch DPCD and see if the device is still there,
3840 * if it is, it will rewrite the MSTM control bits, and return.
3842 * If the device fails this returns -1, and the driver should do
3843 * a full MST reprobe, in case we were undocked.
3845 * During system resume (where it is assumed that the driver will be calling
3846 * drm_atomic_helper_resume()) this function should be called beforehand with
3847 * @sync set to true. In contexts like runtime resume where the driver is not
3848 * expected to be calling drm_atomic_helper_resume(), this function should be
3849 * called with @sync set to false in order to avoid deadlocking.
3851 * Returns: -1 if the MST topology was removed while we were suspended, 0
3854 int drm_dp_mst_topology_mgr_resume(struct drm_dp_mst_topology_mgr
*mgr
,
3860 mutex_lock(&mgr
->lock
);
3861 if (!mgr
->mst_primary
)
3864 ret
= drm_dp_dpcd_read(mgr
->aux
, DP_DPCD_REV
, mgr
->dpcd
,
3865 DP_RECEIVER_CAP_SIZE
);
3866 if (ret
!= DP_RECEIVER_CAP_SIZE
) {
3867 drm_dbg_kms(mgr
->dev
, "dpcd read failed - undocked during suspend?\n");
3871 ret
= drm_dp_dpcd_writeb(mgr
->aux
, DP_MSTM_CTRL
,
3874 DP_UPSTREAM_IS_SRC
);
3876 drm_dbg_kms(mgr
->dev
, "mst write failed - undocked during suspend?\n");
3880 /* Some hubs forget their guids after they resume */
3881 ret
= drm_dp_dpcd_read(mgr
->aux
, DP_GUID
, guid
, 16);
3883 drm_dbg_kms(mgr
->dev
, "dpcd read failed - undocked during suspend?\n");
3887 ret
= drm_dp_check_mstb_guid(mgr
->mst_primary
, guid
);
3889 drm_dbg_kms(mgr
->dev
, "check mstb failed - undocked during suspend?\n");
3894 * For the final step of resuming the topology, we need to bring the
3895 * state of our in-memory topology back into sync with reality. So,
3896 * restart the probing process as if we're probing a new hub
3898 queue_work(system_long_wq
, &mgr
->work
);
3899 mutex_unlock(&mgr
->lock
);
3902 drm_dbg_kms(mgr
->dev
,
3903 "Waiting for link probe work to finish re-syncing topology...\n");
3904 flush_work(&mgr
->work
);
3910 mutex_unlock(&mgr
->lock
);
3913 EXPORT_SYMBOL(drm_dp_mst_topology_mgr_resume
);
3916 drm_dp_get_one_sb_msg(struct drm_dp_mst_topology_mgr
*mgr
, bool up
,
3917 struct drm_dp_mst_branch
**mstb
)
3921 int replylen
, curreply
;
3924 struct drm_dp_sideband_msg_hdr hdr
;
3925 struct drm_dp_sideband_msg_rx
*msg
=
3926 up
? &mgr
->up_req_recv
: &mgr
->down_rep_recv
;
3927 int basereg
= up
? DP_SIDEBAND_MSG_UP_REQ_BASE
:
3928 DP_SIDEBAND_MSG_DOWN_REP_BASE
;
3933 len
= min(mgr
->max_dpcd_transaction_bytes
, 16);
3934 ret
= drm_dp_dpcd_read(mgr
->aux
, basereg
, replyblock
, len
);
3936 drm_dbg_kms(mgr
->dev
, "failed to read DPCD down rep %d %d\n", len
, ret
);
3940 ret
= drm_dp_decode_sideband_msg_hdr(mgr
, &hdr
, replyblock
, len
, &hdrlen
);
3942 print_hex_dump(KERN_DEBUG
, "failed hdr", DUMP_PREFIX_NONE
, 16,
3943 1, replyblock
, len
, false);
3944 drm_dbg_kms(mgr
->dev
, "ERROR: failed header\n");
3949 /* Caller is responsible for giving back this reference */
3950 *mstb
= drm_dp_get_mst_branch_device(mgr
, hdr
.lct
, hdr
.rad
);
3952 drm_dbg_kms(mgr
->dev
, "Got MST reply from unknown device %d\n", hdr
.lct
);
3957 if (!drm_dp_sideband_msg_set_header(msg
, &hdr
, hdrlen
)) {
3958 drm_dbg_kms(mgr
->dev
, "sideband msg set header failed %d\n", replyblock
[0]);
3962 replylen
= min(msg
->curchunk_len
, (u8
)(len
- hdrlen
));
3963 ret
= drm_dp_sideband_append_payload(msg
, replyblock
+ hdrlen
, replylen
);
3965 drm_dbg_kms(mgr
->dev
, "sideband msg build failed %d\n", replyblock
[0]);
3969 replylen
= msg
->curchunk_len
+ msg
->curchunk_hdrlen
- len
;
3971 while (replylen
> 0) {
3972 len
= min3(replylen
, mgr
->max_dpcd_transaction_bytes
, 16);
3973 ret
= drm_dp_dpcd_read(mgr
->aux
, basereg
+ curreply
,
3976 drm_dbg_kms(mgr
->dev
, "failed to read a chunk (len %d, ret %d)\n",
3981 ret
= drm_dp_sideband_append_payload(msg
, replyblock
, len
);
3983 drm_dbg_kms(mgr
->dev
, "failed to build sideband msg\n");
3993 static int drm_dp_mst_handle_down_rep(struct drm_dp_mst_topology_mgr
*mgr
)
3995 struct drm_dp_sideband_msg_tx
*txmsg
;
3996 struct drm_dp_mst_branch
*mstb
= NULL
;
3997 struct drm_dp_sideband_msg_rx
*msg
= &mgr
->down_rep_recv
;
3999 if (!drm_dp_get_one_sb_msg(mgr
, false, &mstb
))
4002 /* Multi-packet message transmission, don't clear the reply */
4003 if (!msg
->have_eomt
)
4006 /* find the message */
4007 mutex_lock(&mgr
->qlock
);
4008 txmsg
= list_first_entry_or_null(&mgr
->tx_msg_downq
,
4009 struct drm_dp_sideband_msg_tx
, next
);
4010 mutex_unlock(&mgr
->qlock
);
4012 /* Were we actually expecting a response, and from this mstb? */
4013 if (!txmsg
|| txmsg
->dst
!= mstb
) {
4014 struct drm_dp_sideband_msg_hdr
*hdr
;
4016 hdr
= &msg
->initial_hdr
;
4017 drm_dbg_kms(mgr
->dev
, "Got MST reply with no msg %p %d %d %02x %02x\n",
4018 mstb
, hdr
->seqno
, hdr
->lct
, hdr
->rad
[0], msg
->msg
[0]);
4019 goto out_clear_reply
;
4022 drm_dp_sideband_parse_reply(mgr
, msg
, &txmsg
->reply
);
4024 if (txmsg
->reply
.reply_type
== DP_SIDEBAND_REPLY_NAK
) {
4025 drm_dbg_kms(mgr
->dev
,
4026 "Got NAK reply: req 0x%02x (%s), reason 0x%02x (%s), nak data 0x%02x\n",
4027 txmsg
->reply
.req_type
,
4028 drm_dp_mst_req_type_str(txmsg
->reply
.req_type
),
4029 txmsg
->reply
.u
.nak
.reason
,
4030 drm_dp_mst_nak_reason_str(txmsg
->reply
.u
.nak
.reason
),
4031 txmsg
->reply
.u
.nak
.nak_data
);
4034 memset(msg
, 0, sizeof(struct drm_dp_sideband_msg_rx
));
4035 drm_dp_mst_topology_put_mstb(mstb
);
4037 mutex_lock(&mgr
->qlock
);
4038 txmsg
->state
= DRM_DP_SIDEBAND_TX_RX
;
4039 list_del(&txmsg
->next
);
4040 mutex_unlock(&mgr
->qlock
);
4042 wake_up_all(&mgr
->tx_waitq
);
4047 memset(msg
, 0, sizeof(struct drm_dp_sideband_msg_rx
));
4050 drm_dp_mst_topology_put_mstb(mstb
);
4056 drm_dp_mst_process_up_req(struct drm_dp_mst_topology_mgr
*mgr
,
4057 struct drm_dp_pending_up_req
*up_req
)
4059 struct drm_dp_mst_branch
*mstb
= NULL
;
4060 struct drm_dp_sideband_msg_req_body
*msg
= &up_req
->msg
;
4061 struct drm_dp_sideband_msg_hdr
*hdr
= &up_req
->hdr
;
4062 bool hotplug
= false;
4064 if (hdr
->broadcast
) {
4065 const u8
*guid
= NULL
;
4067 if (msg
->req_type
== DP_CONNECTION_STATUS_NOTIFY
)
4068 guid
= msg
->u
.conn_stat
.guid
;
4069 else if (msg
->req_type
== DP_RESOURCE_STATUS_NOTIFY
)
4070 guid
= msg
->u
.resource_stat
.guid
;
4073 mstb
= drm_dp_get_mst_branch_device_by_guid(mgr
, guid
);
4075 mstb
= drm_dp_get_mst_branch_device(mgr
, hdr
->lct
, hdr
->rad
);
4079 drm_dbg_kms(mgr
->dev
, "Got MST reply from unknown device %d\n", hdr
->lct
);
4083 /* TODO: Add missing handler for DP_RESOURCE_STATUS_NOTIFY events */
4084 if (msg
->req_type
== DP_CONNECTION_STATUS_NOTIFY
) {
4085 drm_dp_mst_handle_conn_stat(mstb
, &msg
->u
.conn_stat
);
4089 drm_dp_mst_topology_put_mstb(mstb
);
4093 static void drm_dp_mst_up_req_work(struct work_struct
*work
)
4095 struct drm_dp_mst_topology_mgr
*mgr
=
4096 container_of(work
, struct drm_dp_mst_topology_mgr
,
4098 struct drm_dp_pending_up_req
*up_req
;
4099 bool send_hotplug
= false;
4101 mutex_lock(&mgr
->probe_lock
);
4103 mutex_lock(&mgr
->up_req_lock
);
4104 up_req
= list_first_entry_or_null(&mgr
->up_req_list
,
4105 struct drm_dp_pending_up_req
,
4108 list_del(&up_req
->next
);
4109 mutex_unlock(&mgr
->up_req_lock
);
4114 send_hotplug
|= drm_dp_mst_process_up_req(mgr
, up_req
);
4117 mutex_unlock(&mgr
->probe_lock
);
4120 drm_kms_helper_hotplug_event(mgr
->dev
);
4123 static int drm_dp_mst_handle_up_req(struct drm_dp_mst_topology_mgr
*mgr
)
4125 struct drm_dp_pending_up_req
*up_req
;
4127 if (!drm_dp_get_one_sb_msg(mgr
, true, NULL
))
4130 if (!mgr
->up_req_recv
.have_eomt
)
4133 up_req
= kzalloc(sizeof(*up_req
), GFP_KERNEL
);
4137 INIT_LIST_HEAD(&up_req
->next
);
4139 drm_dp_sideband_parse_req(mgr
, &mgr
->up_req_recv
, &up_req
->msg
);
4141 if (up_req
->msg
.req_type
!= DP_CONNECTION_STATUS_NOTIFY
&&
4142 up_req
->msg
.req_type
!= DP_RESOURCE_STATUS_NOTIFY
) {
4143 drm_dbg_kms(mgr
->dev
, "Received unknown up req type, ignoring: %x\n",
4144 up_req
->msg
.req_type
);
4149 drm_dp_send_up_ack_reply(mgr
, mgr
->mst_primary
, up_req
->msg
.req_type
,
4152 if (up_req
->msg
.req_type
== DP_CONNECTION_STATUS_NOTIFY
) {
4153 const struct drm_dp_connection_status_notify
*conn_stat
=
4154 &up_req
->msg
.u
.conn_stat
;
4156 drm_dbg_kms(mgr
->dev
, "Got CSN: pn: %d ldps:%d ddps: %d mcs: %d ip: %d pdt: %d\n",
4157 conn_stat
->port_number
,
4158 conn_stat
->legacy_device_plug_status
,
4159 conn_stat
->displayport_device_plug_status
,
4160 conn_stat
->message_capability_status
,
4161 conn_stat
->input_port
,
4162 conn_stat
->peer_device_type
);
4163 } else if (up_req
->msg
.req_type
== DP_RESOURCE_STATUS_NOTIFY
) {
4164 const struct drm_dp_resource_status_notify
*res_stat
=
4165 &up_req
->msg
.u
.resource_stat
;
4167 drm_dbg_kms(mgr
->dev
, "Got RSN: pn: %d avail_pbn %d\n",
4168 res_stat
->port_number
,
4169 res_stat
->available_pbn
);
4172 up_req
->hdr
= mgr
->up_req_recv
.initial_hdr
;
4173 mutex_lock(&mgr
->up_req_lock
);
4174 list_add_tail(&up_req
->next
, &mgr
->up_req_list
);
4175 mutex_unlock(&mgr
->up_req_lock
);
4176 queue_work(system_long_wq
, &mgr
->up_req_work
);
4179 memset(&mgr
->up_req_recv
, 0, sizeof(struct drm_dp_sideband_msg_rx
));
4184 * drm_dp_mst_hpd_irq() - MST hotplug IRQ notify
4185 * @mgr: manager to notify irq for.
4186 * @esi: 4 bytes from SINK_COUNT_ESI
4187 * @handled: whether the hpd interrupt was consumed or not
4189 * This should be called from the driver when it detects a short IRQ,
4190 * along with the value of the DEVICE_SERVICE_IRQ_VECTOR_ESI0. The
4191 * topology manager will process the sideband messages received as a result
4194 int drm_dp_mst_hpd_irq(struct drm_dp_mst_topology_mgr
*mgr
, u8
*esi
, bool *handled
)
4199 sc
= DP_GET_SINK_COUNT(esi
[0]);
4201 if (sc
!= mgr
->sink_count
) {
4202 mgr
->sink_count
= sc
;
4206 if (esi
[1] & DP_DOWN_REP_MSG_RDY
) {
4207 ret
= drm_dp_mst_handle_down_rep(mgr
);
4211 if (esi
[1] & DP_UP_REQ_MSG_RDY
) {
4212 ret
|= drm_dp_mst_handle_up_req(mgr
);
4216 drm_dp_mst_kick_tx(mgr
);
4219 EXPORT_SYMBOL(drm_dp_mst_hpd_irq
);
4222 * drm_dp_mst_detect_port() - get connection status for an MST port
4223 * @connector: DRM connector for this port
4224 * @ctx: The acquisition context to use for grabbing locks
4225 * @mgr: manager for this port
4226 * @port: pointer to a port
4228 * This returns the current connection state for a port.
4231 drm_dp_mst_detect_port(struct drm_connector
*connector
,
4232 struct drm_modeset_acquire_ctx
*ctx
,
4233 struct drm_dp_mst_topology_mgr
*mgr
,
4234 struct drm_dp_mst_port
*port
)
4238 /* we need to search for the port in the mgr in case it's gone */
4239 port
= drm_dp_mst_topology_get_port_validated(mgr
, port
);
4241 return connector_status_disconnected
;
4243 ret
= drm_modeset_lock(&mgr
->base
.lock
, ctx
);
4247 ret
= connector_status_disconnected
;
4252 switch (port
->pdt
) {
4253 case DP_PEER_DEVICE_NONE
:
4255 case DP_PEER_DEVICE_MST_BRANCHING
:
4257 ret
= connector_status_connected
;
4260 case DP_PEER_DEVICE_SST_SINK
:
4261 ret
= connector_status_connected
;
4262 /* for logical ports - cache the EDID */
4263 if (port
->port_num
>= DP_MST_LOGICAL_PORT_0
&& !port
->cached_edid
)
4264 port
->cached_edid
= drm_get_edid(connector
, &port
->aux
.ddc
);
4266 case DP_PEER_DEVICE_DP_LEGACY_CONV
:
4268 ret
= connector_status_connected
;
4272 drm_dp_mst_topology_put_port(port
);
4275 EXPORT_SYMBOL(drm_dp_mst_detect_port
);
4278 * drm_dp_mst_get_edid() - get EDID for an MST port
4279 * @connector: toplevel connector to get EDID for
4280 * @mgr: manager for this port
4281 * @port: unverified pointer to a port.
4283 * This returns an EDID for the port connected to a connector,
4284 * It validates the pointer still exists so the caller doesn't require a
4287 struct edid
*drm_dp_mst_get_edid(struct drm_connector
*connector
, struct drm_dp_mst_topology_mgr
*mgr
, struct drm_dp_mst_port
*port
)
4289 struct edid
*edid
= NULL
;
4291 /* we need to search for the port in the mgr in case it's gone */
4292 port
= drm_dp_mst_topology_get_port_validated(mgr
, port
);
4296 if (port
->cached_edid
)
4297 edid
= drm_edid_duplicate(port
->cached_edid
);
4299 edid
= drm_get_edid(connector
, &port
->aux
.ddc
);
4301 port
->has_audio
= drm_detect_monitor_audio(edid
);
4302 drm_dp_mst_topology_put_port(port
);
4305 EXPORT_SYMBOL(drm_dp_mst_get_edid
);
4308 * drm_dp_find_vcpi_slots() - Find VCPI slots for this PBN value
4309 * @mgr: manager to use
4310 * @pbn: payload bandwidth to convert into slots.
4312 * Calculate the number of VCPI slots that will be required for the given PBN
4313 * value. This function is deprecated, and should not be used in atomic
4317 * The total slots required for this port, or error.
4319 int drm_dp_find_vcpi_slots(struct drm_dp_mst_topology_mgr
*mgr
,
4324 num_slots
= DIV_ROUND_UP(pbn
, mgr
->pbn_div
);
4326 /* max. time slots - one slot for MTP header */
4331 EXPORT_SYMBOL(drm_dp_find_vcpi_slots
);
4333 static int drm_dp_init_vcpi(struct drm_dp_mst_topology_mgr
*mgr
,
4334 struct drm_dp_vcpi
*vcpi
, int pbn
, int slots
)
4339 vcpi
->aligned_pbn
= slots
* mgr
->pbn_div
;
4340 vcpi
->num_slots
= slots
;
4342 ret
= drm_dp_mst_assign_payload_id(mgr
, vcpi
);
4349 * drm_dp_atomic_find_vcpi_slots() - Find and add VCPI slots to the state
4350 * @state: global atomic state
4351 * @mgr: MST topology manager for the port
4352 * @port: port to find vcpi slots for
4353 * @pbn: bandwidth required for the mode in PBN
4354 * @pbn_div: divider for DSC mode that takes FEC into account
4356 * Allocates VCPI slots to @port, replacing any previous VCPI allocations it
4357 * may have had. Any atomic drivers which support MST must call this function
4358 * in their &drm_encoder_helper_funcs.atomic_check() callback to change the
4359 * current VCPI allocation for the new state, but only when
4360 * &drm_crtc_state.mode_changed or &drm_crtc_state.connectors_changed is set
4361 * to ensure compatibility with userspace applications that still use the
4362 * legacy modesetting UAPI.
4364 * Allocations set by this function are not checked against the bandwidth
4365 * restraints of @mgr until the driver calls drm_dp_mst_atomic_check().
4367 * Additionally, it is OK to call this function multiple times on the same
4368 * @port as needed. It is not OK however, to call this function and
4369 * drm_dp_atomic_release_vcpi_slots() in the same atomic check phase.
4372 * drm_dp_atomic_release_vcpi_slots()
4373 * drm_dp_mst_atomic_check()
4376 * Total slots in the atomic state assigned for this port, or a negative error
4377 * code if the port no longer exists
4379 int drm_dp_atomic_find_vcpi_slots(struct drm_atomic_state
*state
,
4380 struct drm_dp_mst_topology_mgr
*mgr
,
4381 struct drm_dp_mst_port
*port
, int pbn
,
4384 struct drm_dp_mst_topology_state
*topology_state
;
4385 struct drm_dp_vcpi_allocation
*pos
, *vcpi
= NULL
;
4386 int prev_slots
, prev_bw
, req_slots
;
4388 topology_state
= drm_atomic_get_mst_topology_state(state
, mgr
);
4389 if (IS_ERR(topology_state
))
4390 return PTR_ERR(topology_state
);
4392 /* Find the current allocation for this port, if any */
4393 list_for_each_entry(pos
, &topology_state
->vcpis
, next
) {
4394 if (pos
->port
== port
) {
4396 prev_slots
= vcpi
->vcpi
;
4397 prev_bw
= vcpi
->pbn
;
4400 * This should never happen, unless the driver tries
4401 * releasing and allocating the same VCPI allocation,
4404 if (WARN_ON(!prev_slots
)) {
4406 "cannot allocate and release VCPI on [MST PORT:%p] in the same state\n",
4420 pbn_div
= mgr
->pbn_div
;
4422 req_slots
= DIV_ROUND_UP(pbn
, pbn_div
);
4424 drm_dbg_atomic(mgr
->dev
, "[CONNECTOR:%d:%s] [MST PORT:%p] VCPI %d -> %d\n",
4425 port
->connector
->base
.id
, port
->connector
->name
,
4426 port
, prev_slots
, req_slots
);
4427 drm_dbg_atomic(mgr
->dev
, "[CONNECTOR:%d:%s] [MST PORT:%p] PBN %d -> %d\n",
4428 port
->connector
->base
.id
, port
->connector
->name
,
4429 port
, prev_bw
, pbn
);
4431 /* Add the new allocation to the state */
4433 vcpi
= kzalloc(sizeof(*vcpi
), GFP_KERNEL
);
4437 drm_dp_mst_get_port_malloc(port
);
4439 list_add(&vcpi
->next
, &topology_state
->vcpis
);
4441 vcpi
->vcpi
= req_slots
;
4446 EXPORT_SYMBOL(drm_dp_atomic_find_vcpi_slots
);
4449 * drm_dp_atomic_release_vcpi_slots() - Release allocated vcpi slots
4450 * @state: global atomic state
4451 * @mgr: MST topology manager for the port
4452 * @port: The port to release the VCPI slots from
4454 * Releases any VCPI slots that have been allocated to a port in the atomic
4455 * state. Any atomic drivers which support MST must call this function in
4456 * their &drm_connector_helper_funcs.atomic_check() callback when the
4457 * connector will no longer have VCPI allocated (e.g. because its CRTC was
4458 * removed) when it had VCPI allocated in the previous atomic state.
4460 * It is OK to call this even if @port has been removed from the system.
4461 * Additionally, it is OK to call this function multiple times on the same
4462 * @port as needed. It is not OK however, to call this function and
4463 * drm_dp_atomic_find_vcpi_slots() on the same @port in a single atomic check
4467 * drm_dp_atomic_find_vcpi_slots()
4468 * drm_dp_mst_atomic_check()
4471 * 0 if all slots for this port were added back to
4472 * &drm_dp_mst_topology_state.avail_slots or negative error code
4474 int drm_dp_atomic_release_vcpi_slots(struct drm_atomic_state
*state
,
4475 struct drm_dp_mst_topology_mgr
*mgr
,
4476 struct drm_dp_mst_port
*port
)
4478 struct drm_dp_mst_topology_state
*topology_state
;
4479 struct drm_dp_vcpi_allocation
*pos
;
4482 topology_state
= drm_atomic_get_mst_topology_state(state
, mgr
);
4483 if (IS_ERR(topology_state
))
4484 return PTR_ERR(topology_state
);
4486 list_for_each_entry(pos
, &topology_state
->vcpis
, next
) {
4487 if (pos
->port
== port
) {
4492 if (WARN_ON(!found
)) {
4493 drm_err(mgr
->dev
, "no VCPI for [MST PORT:%p] found in mst state %p\n",
4494 port
, &topology_state
->base
);
4498 drm_dbg_atomic(mgr
->dev
, "[MST PORT:%p] VCPI %d -> 0\n", port
, pos
->vcpi
);
4500 drm_dp_mst_put_port_malloc(port
);
4507 EXPORT_SYMBOL(drm_dp_atomic_release_vcpi_slots
);
4510 * drm_dp_mst_update_slots() - updates the slot info depending on the DP ecoding format
4511 * @mst_state: mst_state to update
4512 * @link_encoding_cap: the ecoding format on the link
4514 void drm_dp_mst_update_slots(struct drm_dp_mst_topology_state
*mst_state
, uint8_t link_encoding_cap
)
4516 if (link_encoding_cap
== DP_CAP_ANSI_128B132B
) {
4517 mst_state
->total_avail_slots
= 64;
4518 mst_state
->start_slot
= 0;
4520 mst_state
->total_avail_slots
= 63;
4521 mst_state
->start_slot
= 1;
4524 DRM_DEBUG_KMS("%s encoding format on mst_state 0x%p\n",
4525 (link_encoding_cap
== DP_CAP_ANSI_128B132B
) ? "128b/132b":"8b/10b",
4528 EXPORT_SYMBOL(drm_dp_mst_update_slots
);
4531 * drm_dp_mst_allocate_vcpi() - Allocate a virtual channel
4532 * @mgr: manager for this port
4533 * @port: port to allocate a virtual channel for.
4534 * @pbn: payload bandwidth number to request
4535 * @slots: returned number of slots for this PBN.
4537 bool drm_dp_mst_allocate_vcpi(struct drm_dp_mst_topology_mgr
*mgr
,
4538 struct drm_dp_mst_port
*port
, int pbn
, int slots
)
4545 port
= drm_dp_mst_topology_get_port_validated(mgr
, port
);
4549 if (port
->vcpi
.vcpi
> 0) {
4550 drm_dbg_kms(mgr
->dev
,
4551 "payload: vcpi %d already allocated for pbn %d - requested pbn %d\n",
4552 port
->vcpi
.vcpi
, port
->vcpi
.pbn
, pbn
);
4553 if (pbn
== port
->vcpi
.pbn
) {
4554 drm_dp_mst_topology_put_port(port
);
4559 ret
= drm_dp_init_vcpi(mgr
, &port
->vcpi
, pbn
, slots
);
4561 drm_dbg_kms(mgr
->dev
, "failed to init vcpi slots=%d ret=%d\n",
4562 DIV_ROUND_UP(pbn
, mgr
->pbn_div
), ret
);
4563 drm_dp_mst_topology_put_port(port
);
4566 drm_dbg_kms(mgr
->dev
, "initing vcpi for pbn=%d slots=%d\n", pbn
, port
->vcpi
.num_slots
);
4568 /* Keep port allocated until its payload has been removed */
4569 drm_dp_mst_get_port_malloc(port
);
4570 drm_dp_mst_topology_put_port(port
);
4575 EXPORT_SYMBOL(drm_dp_mst_allocate_vcpi
);
4577 int drm_dp_mst_get_vcpi_slots(struct drm_dp_mst_topology_mgr
*mgr
, struct drm_dp_mst_port
*port
)
4581 port
= drm_dp_mst_topology_get_port_validated(mgr
, port
);
4585 slots
= port
->vcpi
.num_slots
;
4586 drm_dp_mst_topology_put_port(port
);
4589 EXPORT_SYMBOL(drm_dp_mst_get_vcpi_slots
);
4592 * drm_dp_mst_reset_vcpi_slots() - Reset number of slots to 0 for VCPI
4593 * @mgr: manager for this port
4594 * @port: unverified pointer to a port.
4596 * This just resets the number of slots for the ports VCPI for later programming.
4598 void drm_dp_mst_reset_vcpi_slots(struct drm_dp_mst_topology_mgr
*mgr
, struct drm_dp_mst_port
*port
)
4601 * A port with VCPI will remain allocated until its VCPI is
4602 * released, no verified ref needed
4605 port
->vcpi
.num_slots
= 0;
4607 EXPORT_SYMBOL(drm_dp_mst_reset_vcpi_slots
);
4610 * drm_dp_mst_deallocate_vcpi() - deallocate a VCPI
4611 * @mgr: manager for this port
4612 * @port: port to deallocate vcpi for
4614 * This can be called unconditionally, regardless of whether
4615 * drm_dp_mst_allocate_vcpi() succeeded or not.
4617 void drm_dp_mst_deallocate_vcpi(struct drm_dp_mst_topology_mgr
*mgr
,
4618 struct drm_dp_mst_port
*port
)
4622 if (!port
->vcpi
.vcpi
)
4625 mutex_lock(&mgr
->lock
);
4626 skip
= !drm_dp_mst_port_downstream_of_branch(port
, mgr
->mst_primary
);
4627 mutex_unlock(&mgr
->lock
);
4632 drm_dp_mst_put_payload_id(mgr
, port
->vcpi
.vcpi
);
4633 port
->vcpi
.num_slots
= 0;
4635 port
->vcpi
.aligned_pbn
= 0;
4636 port
->vcpi
.vcpi
= 0;
4637 drm_dp_mst_put_port_malloc(port
);
4639 EXPORT_SYMBOL(drm_dp_mst_deallocate_vcpi
);
4641 static int drm_dp_dpcd_write_payload(struct drm_dp_mst_topology_mgr
*mgr
,
4642 int id
, struct drm_dp_payload
*payload
)
4644 u8 payload_alloc
[3], status
;
4648 drm_dp_dpcd_writeb(mgr
->aux
, DP_PAYLOAD_TABLE_UPDATE_STATUS
,
4649 DP_PAYLOAD_TABLE_UPDATED
);
4651 payload_alloc
[0] = id
;
4652 payload_alloc
[1] = payload
->start_slot
;
4653 payload_alloc
[2] = payload
->num_slots
;
4655 ret
= drm_dp_dpcd_write(mgr
->aux
, DP_PAYLOAD_ALLOCATE_SET
, payload_alloc
, 3);
4657 drm_dbg_kms(mgr
->dev
, "failed to write payload allocation %d\n", ret
);
4662 ret
= drm_dp_dpcd_readb(mgr
->aux
, DP_PAYLOAD_TABLE_UPDATE_STATUS
, &status
);
4664 drm_dbg_kms(mgr
->dev
, "failed to read payload table status %d\n", ret
);
4668 if (!(status
& DP_PAYLOAD_TABLE_UPDATED
)) {
4671 usleep_range(10000, 20000);
4674 drm_dbg_kms(mgr
->dev
, "status not set after read payload table status %d\n",
4684 static int do_get_act_status(struct drm_dp_aux
*aux
)
4689 ret
= drm_dp_dpcd_readb(aux
, DP_PAYLOAD_TABLE_UPDATE_STATUS
, &status
);
4697 * drm_dp_check_act_status() - Polls for ACT handled status.
4698 * @mgr: manager to use
4700 * Tries waiting for the MST hub to finish updating it's payload table by
4701 * polling for the ACT handled bit for up to 3 seconds (yes-some hubs really
4705 * 0 if the ACT was handled in time, negative error code on failure.
4707 int drm_dp_check_act_status(struct drm_dp_mst_topology_mgr
*mgr
)
4710 * There doesn't seem to be any recommended retry count or timeout in
4711 * the MST specification. Since some hubs have been observed to take
4712 * over 1 second to update their payload allocations under certain
4713 * conditions, we use a rather large timeout value.
4715 const int timeout_ms
= 3000;
4718 ret
= readx_poll_timeout(do_get_act_status
, mgr
->aux
, status
,
4719 status
& DP_PAYLOAD_ACT_HANDLED
|| status
< 0,
4720 200, timeout_ms
* USEC_PER_MSEC
);
4721 if (ret
< 0 && status
>= 0) {
4722 drm_err(mgr
->dev
, "Failed to get ACT after %dms, last status: %02x\n",
4723 timeout_ms
, status
);
4725 } else if (status
< 0) {
4727 * Failure here isn't unexpected - the hub may have
4728 * just been unplugged
4730 drm_dbg_kms(mgr
->dev
, "Failed to read payload table status: %d\n", status
);
4736 EXPORT_SYMBOL(drm_dp_check_act_status
);
4739 * drm_dp_calc_pbn_mode() - Calculate the PBN for a mode.
4740 * @clock: dot clock for the mode
4741 * @bpp: bpp for the mode.
4742 * @dsc: DSC mode. If true, bpp has units of 1/16 of a bit per pixel
4744 * This uses the formula in the spec to calculate the PBN value for a mode.
4746 int drm_dp_calc_pbn_mode(int clock
, int bpp
, bool dsc
)
4749 * margin 5300ppm + 300ppm ~ 0.6% as per spec, factor is 1.006
4750 * The unit of 54/64Mbytes/sec is an arbitrary unit chosen based on
4751 * common multiplier to render an integer PBN for all link rate/lane
4752 * counts combinations
4754 * peak_kbps *= (1006/1000)
4755 * peak_kbps *= (64/54)
4756 * peak_kbps *= 8 convert to bytes
4758 * If the bpp is in units of 1/16, further divide by 16. Put this
4759 * factor in the numerator rather than the denominator to avoid
4764 return DIV_ROUND_UP_ULL(mul_u32_u32(clock
* (bpp
/ 16), 64 * 1006),
4765 8 * 54 * 1000 * 1000);
4767 return DIV_ROUND_UP_ULL(mul_u32_u32(clock
* bpp
, 64 * 1006),
4768 8 * 54 * 1000 * 1000);
4770 EXPORT_SYMBOL(drm_dp_calc_pbn_mode
);
4772 /* we want to kick the TX after we've ack the up/down IRQs. */
4773 static void drm_dp_mst_kick_tx(struct drm_dp_mst_topology_mgr
*mgr
)
4775 queue_work(system_long_wq
, &mgr
->tx_work
);
4779 * Helper function for parsing DP device types into convenient strings
4780 * for use with dp_mst_topology
4782 static const char *pdt_to_string(u8 pdt
)
4785 case DP_PEER_DEVICE_NONE
:
4787 case DP_PEER_DEVICE_SOURCE_OR_SST
:
4788 return "SOURCE OR SST";
4789 case DP_PEER_DEVICE_MST_BRANCHING
:
4790 return "MST BRANCHING";
4791 case DP_PEER_DEVICE_SST_SINK
:
4793 case DP_PEER_DEVICE_DP_LEGACY_CONV
:
4794 return "DP LEGACY CONV";
4800 static void drm_dp_mst_dump_mstb(struct seq_file
*m
,
4801 struct drm_dp_mst_branch
*mstb
)
4803 struct drm_dp_mst_port
*port
;
4804 int tabs
= mstb
->lct
;
4808 for (i
= 0; i
< tabs
; i
++)
4812 seq_printf(m
, "%smstb - [%p]: num_ports: %d\n", prefix
, mstb
, mstb
->num_ports
);
4813 list_for_each_entry(port
, &mstb
->ports
, next
) {
4814 seq_printf(m
, "%sport %d - [%p] (%s - %s): ddps: %d, ldps: %d, sdp: %d/%d, fec: %s, conn: %p\n",
4818 port
->input
? "input" : "output",
4819 pdt_to_string(port
->pdt
),
4822 port
->num_sdp_streams
,
4823 port
->num_sdp_stream_sinks
,
4824 port
->fec_capable
? "true" : "false",
4827 drm_dp_mst_dump_mstb(m
, port
->mstb
);
4831 #define DP_PAYLOAD_TABLE_SIZE 64
4833 static bool dump_dp_payload_table(struct drm_dp_mst_topology_mgr
*mgr
,
4838 for (i
= 0; i
< DP_PAYLOAD_TABLE_SIZE
; i
+= 16) {
4839 if (drm_dp_dpcd_read(mgr
->aux
,
4840 DP_PAYLOAD_TABLE_UPDATE_STATUS
+ i
,
4847 static void fetch_monitor_name(struct drm_dp_mst_topology_mgr
*mgr
,
4848 struct drm_dp_mst_port
*port
, char *name
,
4851 struct edid
*mst_edid
;
4853 mst_edid
= drm_dp_mst_get_edid(port
->connector
, mgr
, port
);
4854 drm_edid_get_monitor_name(mst_edid
, name
, namelen
);
4858 * drm_dp_mst_dump_topology(): dump topology to seq file.
4859 * @m: seq_file to dump output to
4860 * @mgr: manager to dump current topology for.
4862 * helper to dump MST topology to a seq file for debugfs.
4864 void drm_dp_mst_dump_topology(struct seq_file
*m
,
4865 struct drm_dp_mst_topology_mgr
*mgr
)
4868 struct drm_dp_mst_port
*port
;
4870 mutex_lock(&mgr
->lock
);
4871 if (mgr
->mst_primary
)
4872 drm_dp_mst_dump_mstb(m
, mgr
->mst_primary
);
4875 mutex_unlock(&mgr
->lock
);
4877 mutex_lock(&mgr
->payload_lock
);
4878 seq_printf(m
, "\n*** VCPI Info ***\n");
4879 seq_printf(m
, "payload_mask: %lx, vcpi_mask: %lx, max_payloads: %d\n", mgr
->payload_mask
, mgr
->vcpi_mask
, mgr
->max_payloads
);
4881 seq_printf(m
, "\n| idx | port # | vcp_id | # slots | sink name |\n");
4882 for (i
= 0; i
< mgr
->max_payloads
; i
++) {
4883 if (mgr
->proposed_vcpis
[i
]) {
4886 port
= container_of(mgr
->proposed_vcpis
[i
], struct drm_dp_mst_port
, vcpi
);
4887 fetch_monitor_name(mgr
, port
, name
, sizeof(name
));
4888 seq_printf(m
, "%10d%10d%10d%10d%20s\n",
4892 port
->vcpi
.num_slots
,
4893 (*name
!= 0) ? name
: "Unknown");
4895 seq_printf(m
, "%6d - Unused\n", i
);
4897 seq_printf(m
, "\n*** Payload Info ***\n");
4898 seq_printf(m
, "| idx | state | start slot | # slots |\n");
4899 for (i
= 0; i
< mgr
->max_payloads
; i
++) {
4900 seq_printf(m
, "%10d%10d%15d%10d\n",
4902 mgr
->payloads
[i
].payload_state
,
4903 mgr
->payloads
[i
].start_slot
,
4904 mgr
->payloads
[i
].num_slots
);
4906 mutex_unlock(&mgr
->payload_lock
);
4908 seq_printf(m
, "\n*** DPCD Info ***\n");
4909 mutex_lock(&mgr
->lock
);
4910 if (mgr
->mst_primary
) {
4911 u8 buf
[DP_PAYLOAD_TABLE_SIZE
];
4914 ret
= drm_dp_dpcd_read(mgr
->aux
, DP_DPCD_REV
, buf
, DP_RECEIVER_CAP_SIZE
);
4916 seq_printf(m
, "dpcd read failed\n");
4919 seq_printf(m
, "dpcd: %*ph\n", DP_RECEIVER_CAP_SIZE
, buf
);
4921 ret
= drm_dp_dpcd_read(mgr
->aux
, DP_FAUX_CAP
, buf
, 2);
4923 seq_printf(m
, "faux/mst read failed\n");
4926 seq_printf(m
, "faux/mst: %*ph\n", 2, buf
);
4928 ret
= drm_dp_dpcd_read(mgr
->aux
, DP_MSTM_CTRL
, buf
, 1);
4930 seq_printf(m
, "mst ctrl read failed\n");
4933 seq_printf(m
, "mst ctrl: %*ph\n", 1, buf
);
4935 /* dump the standard OUI branch header */
4936 ret
= drm_dp_dpcd_read(mgr
->aux
, DP_BRANCH_OUI
, buf
, DP_BRANCH_OUI_HEADER_SIZE
);
4938 seq_printf(m
, "branch oui read failed\n");
4941 seq_printf(m
, "branch oui: %*phN devid: ", 3, buf
);
4943 for (i
= 0x3; i
< 0x8 && buf
[i
]; i
++)
4944 seq_printf(m
, "%c", buf
[i
]);
4945 seq_printf(m
, " revision: hw: %x.%x sw: %x.%x\n",
4946 buf
[0x9] >> 4, buf
[0x9] & 0xf, buf
[0xa], buf
[0xb]);
4947 if (dump_dp_payload_table(mgr
, buf
))
4948 seq_printf(m
, "payload table: %*ph\n", DP_PAYLOAD_TABLE_SIZE
, buf
);
4952 mutex_unlock(&mgr
->lock
);
4955 EXPORT_SYMBOL(drm_dp_mst_dump_topology
);
4957 static void drm_dp_tx_work(struct work_struct
*work
)
4959 struct drm_dp_mst_topology_mgr
*mgr
= container_of(work
, struct drm_dp_mst_topology_mgr
, tx_work
);
4961 mutex_lock(&mgr
->qlock
);
4962 if (!list_empty(&mgr
->tx_msg_downq
))
4963 process_single_down_tx_qlock(mgr
);
4964 mutex_unlock(&mgr
->qlock
);
4968 drm_dp_delayed_destroy_port(struct drm_dp_mst_port
*port
)
4970 drm_dp_port_set_pdt(port
, DP_PEER_DEVICE_NONE
, port
->mcs
);
4972 if (port
->connector
) {
4973 drm_connector_unregister(port
->connector
);
4974 drm_connector_put(port
->connector
);
4977 drm_dp_mst_put_port_malloc(port
);
4981 drm_dp_delayed_destroy_mstb(struct drm_dp_mst_branch
*mstb
)
4983 struct drm_dp_mst_topology_mgr
*mgr
= mstb
->mgr
;
4984 struct drm_dp_mst_port
*port
, *port_tmp
;
4985 struct drm_dp_sideband_msg_tx
*txmsg
, *txmsg_tmp
;
4986 bool wake_tx
= false;
4988 mutex_lock(&mgr
->lock
);
4989 list_for_each_entry_safe(port
, port_tmp
, &mstb
->ports
, next
) {
4990 list_del(&port
->next
);
4991 drm_dp_mst_topology_put_port(port
);
4993 mutex_unlock(&mgr
->lock
);
4995 /* drop any tx slot msg */
4996 mutex_lock(&mstb
->mgr
->qlock
);
4997 list_for_each_entry_safe(txmsg
, txmsg_tmp
, &mgr
->tx_msg_downq
, next
) {
4998 if (txmsg
->dst
!= mstb
)
5001 txmsg
->state
= DRM_DP_SIDEBAND_TX_TIMEOUT
;
5002 list_del(&txmsg
->next
);
5005 mutex_unlock(&mstb
->mgr
->qlock
);
5008 wake_up_all(&mstb
->mgr
->tx_waitq
);
5010 drm_dp_mst_put_mstb_malloc(mstb
);
5013 static void drm_dp_delayed_destroy_work(struct work_struct
*work
)
5015 struct drm_dp_mst_topology_mgr
*mgr
=
5016 container_of(work
, struct drm_dp_mst_topology_mgr
,
5017 delayed_destroy_work
);
5018 bool send_hotplug
= false, go_again
;
5021 * Not a regular list traverse as we have to drop the destroy
5022 * connector lock before destroying the mstb/port, to avoid AB->BA
5023 * ordering between this lock and the config mutex.
5029 struct drm_dp_mst_branch
*mstb
;
5031 mutex_lock(&mgr
->delayed_destroy_lock
);
5032 mstb
= list_first_entry_or_null(&mgr
->destroy_branch_device_list
,
5033 struct drm_dp_mst_branch
,
5036 list_del(&mstb
->destroy_next
);
5037 mutex_unlock(&mgr
->delayed_destroy_lock
);
5042 drm_dp_delayed_destroy_mstb(mstb
);
5047 struct drm_dp_mst_port
*port
;
5049 mutex_lock(&mgr
->delayed_destroy_lock
);
5050 port
= list_first_entry_or_null(&mgr
->destroy_port_list
,
5051 struct drm_dp_mst_port
,
5054 list_del(&port
->next
);
5055 mutex_unlock(&mgr
->delayed_destroy_lock
);
5060 drm_dp_delayed_destroy_port(port
);
5061 send_hotplug
= true;
5067 drm_kms_helper_hotplug_event(mgr
->dev
);
5070 static struct drm_private_state
*
5071 drm_dp_mst_duplicate_state(struct drm_private_obj
*obj
)
5073 struct drm_dp_mst_topology_state
*state
, *old_state
=
5074 to_dp_mst_topology_state(obj
->state
);
5075 struct drm_dp_vcpi_allocation
*pos
, *vcpi
;
5077 state
= kmemdup(old_state
, sizeof(*state
), GFP_KERNEL
);
5081 __drm_atomic_helper_private_obj_duplicate_state(obj
, &state
->base
);
5083 INIT_LIST_HEAD(&state
->vcpis
);
5085 list_for_each_entry(pos
, &old_state
->vcpis
, next
) {
5086 /* Prune leftover freed VCPI allocations */
5090 vcpi
= kmemdup(pos
, sizeof(*vcpi
), GFP_KERNEL
);
5094 drm_dp_mst_get_port_malloc(vcpi
->port
);
5095 list_add(&vcpi
->next
, &state
->vcpis
);
5098 return &state
->base
;
5101 list_for_each_entry_safe(pos
, vcpi
, &state
->vcpis
, next
) {
5102 drm_dp_mst_put_port_malloc(pos
->port
);
5110 static void drm_dp_mst_destroy_state(struct drm_private_obj
*obj
,
5111 struct drm_private_state
*state
)
5113 struct drm_dp_mst_topology_state
*mst_state
=
5114 to_dp_mst_topology_state(state
);
5115 struct drm_dp_vcpi_allocation
*pos
, *tmp
;
5117 list_for_each_entry_safe(pos
, tmp
, &mst_state
->vcpis
, next
) {
5118 /* We only keep references to ports with non-zero VCPIs */
5120 drm_dp_mst_put_port_malloc(pos
->port
);
5127 static bool drm_dp_mst_port_downstream_of_branch(struct drm_dp_mst_port
*port
,
5128 struct drm_dp_mst_branch
*branch
)
5130 while (port
->parent
) {
5131 if (port
->parent
== branch
)
5134 if (port
->parent
->port_parent
)
5135 port
= port
->parent
->port_parent
;
5143 drm_dp_mst_atomic_check_port_bw_limit(struct drm_dp_mst_port
*port
,
5144 struct drm_dp_mst_topology_state
*state
);
5147 drm_dp_mst_atomic_check_mstb_bw_limit(struct drm_dp_mst_branch
*mstb
,
5148 struct drm_dp_mst_topology_state
*state
)
5150 struct drm_dp_vcpi_allocation
*vcpi
;
5151 struct drm_dp_mst_port
*port
;
5152 int pbn_used
= 0, ret
;
5155 /* Check that we have at least one port in our state that's downstream
5156 * of this branch, otherwise we can skip this branch
5158 list_for_each_entry(vcpi
, &state
->vcpis
, next
) {
5160 !drm_dp_mst_port_downstream_of_branch(vcpi
->port
, mstb
))
5169 if (mstb
->port_parent
)
5170 drm_dbg_atomic(mstb
->mgr
->dev
,
5171 "[MSTB:%p] [MST PORT:%p] Checking bandwidth limits on [MSTB:%p]\n",
5172 mstb
->port_parent
->parent
, mstb
->port_parent
, mstb
);
5174 drm_dbg_atomic(mstb
->mgr
->dev
, "[MSTB:%p] Checking bandwidth limits\n", mstb
);
5176 list_for_each_entry(port
, &mstb
->ports
, next
) {
5177 ret
= drm_dp_mst_atomic_check_port_bw_limit(port
, state
);
5188 drm_dp_mst_atomic_check_port_bw_limit(struct drm_dp_mst_port
*port
,
5189 struct drm_dp_mst_topology_state
*state
)
5191 struct drm_dp_vcpi_allocation
*vcpi
;
5194 if (port
->pdt
== DP_PEER_DEVICE_NONE
)
5197 if (drm_dp_mst_is_end_device(port
->pdt
, port
->mcs
)) {
5200 list_for_each_entry(vcpi
, &state
->vcpis
, next
) {
5201 if (vcpi
->port
!= port
)
5213 * This could happen if the sink deasserted its HPD line, but
5214 * the branch device still reports it as attached (PDT != NONE).
5216 if (!port
->full_pbn
) {
5217 drm_dbg_atomic(port
->mgr
->dev
,
5218 "[MSTB:%p] [MST PORT:%p] no BW available for the port\n",
5219 port
->parent
, port
);
5223 pbn_used
= vcpi
->pbn
;
5225 pbn_used
= drm_dp_mst_atomic_check_mstb_bw_limit(port
->mstb
,
5231 if (pbn_used
> port
->full_pbn
) {
5232 drm_dbg_atomic(port
->mgr
->dev
,
5233 "[MSTB:%p] [MST PORT:%p] required PBN of %d exceeds port limit of %d\n",
5234 port
->parent
, port
, pbn_used
, port
->full_pbn
);
5238 drm_dbg_atomic(port
->mgr
->dev
, "[MSTB:%p] [MST PORT:%p] uses %d out of %d PBN\n",
5239 port
->parent
, port
, pbn_used
, port
->full_pbn
);
5245 drm_dp_mst_atomic_check_vcpi_alloc_limit(struct drm_dp_mst_topology_mgr
*mgr
,
5246 struct drm_dp_mst_topology_state
*mst_state
)
5248 struct drm_dp_vcpi_allocation
*vcpi
;
5249 int avail_slots
= mst_state
->total_avail_slots
, payload_count
= 0;
5251 list_for_each_entry(vcpi
, &mst_state
->vcpis
, next
) {
5252 /* Releasing VCPI is always OK-even if the port is gone */
5254 drm_dbg_atomic(mgr
->dev
, "[MST PORT:%p] releases all VCPI slots\n",
5259 drm_dbg_atomic(mgr
->dev
, "[MST PORT:%p] requires %d vcpi slots\n",
5260 vcpi
->port
, vcpi
->vcpi
);
5262 avail_slots
-= vcpi
->vcpi
;
5263 if (avail_slots
< 0) {
5264 drm_dbg_atomic(mgr
->dev
,
5265 "[MST PORT:%p] not enough VCPI slots in mst state %p (avail=%d)\n",
5266 vcpi
->port
, mst_state
, avail_slots
+ vcpi
->vcpi
);
5270 if (++payload_count
> mgr
->max_payloads
) {
5271 drm_dbg_atomic(mgr
->dev
,
5272 "[MST MGR:%p] state %p has too many payloads (max=%d)\n",
5273 mgr
, mst_state
, mgr
->max_payloads
);
5277 drm_dbg_atomic(mgr
->dev
, "[MST MGR:%p] mst state %p VCPI avail=%d used=%d\n",
5278 mgr
, mst_state
, avail_slots
, mst_state
->total_avail_slots
- avail_slots
);
5284 * drm_dp_mst_add_affected_dsc_crtcs
5285 * @state: Pointer to the new struct drm_dp_mst_topology_state
5286 * @mgr: MST topology manager
5288 * Whenever there is a change in mst topology
5289 * DSC configuration would have to be recalculated
5290 * therefore we need to trigger modeset on all affected
5291 * CRTCs in that topology
5294 * drm_dp_mst_atomic_enable_dsc()
5296 int drm_dp_mst_add_affected_dsc_crtcs(struct drm_atomic_state
*state
, struct drm_dp_mst_topology_mgr
*mgr
)
5298 struct drm_dp_mst_topology_state
*mst_state
;
5299 struct drm_dp_vcpi_allocation
*pos
;
5300 struct drm_connector
*connector
;
5301 struct drm_connector_state
*conn_state
;
5302 struct drm_crtc
*crtc
;
5303 struct drm_crtc_state
*crtc_state
;
5305 mst_state
= drm_atomic_get_mst_topology_state(state
, mgr
);
5307 if (IS_ERR(mst_state
))
5310 list_for_each_entry(pos
, &mst_state
->vcpis
, next
) {
5312 connector
= pos
->port
->connector
;
5317 conn_state
= drm_atomic_get_connector_state(state
, connector
);
5319 if (IS_ERR(conn_state
))
5320 return PTR_ERR(conn_state
);
5322 crtc
= conn_state
->crtc
;
5327 if (!drm_dp_mst_dsc_aux_for_port(pos
->port
))
5330 crtc_state
= drm_atomic_get_crtc_state(mst_state
->base
.state
, crtc
);
5332 if (IS_ERR(crtc_state
))
5333 return PTR_ERR(crtc_state
);
5335 drm_dbg_atomic(mgr
->dev
, "[MST MGR:%p] Setting mode_changed flag on CRTC %p\n",
5338 crtc_state
->mode_changed
= true;
5342 EXPORT_SYMBOL(drm_dp_mst_add_affected_dsc_crtcs
);
5345 * drm_dp_mst_atomic_enable_dsc - Set DSC Enable Flag to On/Off
5346 * @state: Pointer to the new drm_atomic_state
5347 * @port: Pointer to the affected MST Port
5348 * @pbn: Newly recalculated bw required for link with DSC enabled
5349 * @pbn_div: Divider to calculate correct number of pbn per slot
5350 * @enable: Boolean flag to enable or disable DSC on the port
5352 * This function enables DSC on the given Port
5353 * by recalculating its vcpi from pbn provided
5354 * and sets dsc_enable flag to keep track of which
5355 * ports have DSC enabled
5358 int drm_dp_mst_atomic_enable_dsc(struct drm_atomic_state
*state
,
5359 struct drm_dp_mst_port
*port
,
5360 int pbn
, int pbn_div
,
5363 struct drm_dp_mst_topology_state
*mst_state
;
5364 struct drm_dp_vcpi_allocation
*pos
;
5368 mst_state
= drm_atomic_get_mst_topology_state(state
, port
->mgr
);
5370 if (IS_ERR(mst_state
))
5371 return PTR_ERR(mst_state
);
5373 list_for_each_entry(pos
, &mst_state
->vcpis
, next
) {
5374 if (pos
->port
== port
) {
5381 drm_dbg_atomic(state
->dev
,
5382 "[MST PORT:%p] Couldn't find VCPI allocation in mst state %p\n",
5387 if (pos
->dsc_enabled
== enable
) {
5388 drm_dbg_atomic(state
->dev
,
5389 "[MST PORT:%p] DSC flag is already set to %d, returning %d VCPI slots\n",
5390 port
, enable
, pos
->vcpi
);
5395 vcpi
= drm_dp_atomic_find_vcpi_slots(state
, port
->mgr
, port
, pbn
, pbn_div
);
5396 drm_dbg_atomic(state
->dev
,
5397 "[MST PORT:%p] Enabling DSC flag, reallocating %d VCPI slots on the port\n",
5403 pos
->dsc_enabled
= enable
;
5407 EXPORT_SYMBOL(drm_dp_mst_atomic_enable_dsc
);
5409 * drm_dp_mst_atomic_check - Check that the new state of an MST topology in an
5410 * atomic update is valid
5411 * @state: Pointer to the new &struct drm_dp_mst_topology_state
5413 * Checks the given topology state for an atomic update to ensure that it's
5414 * valid. This includes checking whether there's enough bandwidth to support
5415 * the new VCPI allocations in the atomic update.
5417 * Any atomic drivers supporting DP MST must make sure to call this after
5418 * checking the rest of their state in their
5419 * &drm_mode_config_funcs.atomic_check() callback.
5422 * drm_dp_atomic_find_vcpi_slots()
5423 * drm_dp_atomic_release_vcpi_slots()
5427 * 0 if the new state is valid, negative error code otherwise.
5429 int drm_dp_mst_atomic_check(struct drm_atomic_state
*state
)
5431 struct drm_dp_mst_topology_mgr
*mgr
;
5432 struct drm_dp_mst_topology_state
*mst_state
;
5435 for_each_new_mst_mgr_in_state(state
, mgr
, mst_state
, i
) {
5436 if (!mgr
->mst_state
)
5439 ret
= drm_dp_mst_atomic_check_vcpi_alloc_limit(mgr
, mst_state
);
5443 mutex_lock(&mgr
->lock
);
5444 ret
= drm_dp_mst_atomic_check_mstb_bw_limit(mgr
->mst_primary
,
5446 mutex_unlock(&mgr
->lock
);
5455 EXPORT_SYMBOL(drm_dp_mst_atomic_check
);
5457 const struct drm_private_state_funcs drm_dp_mst_topology_state_funcs
= {
5458 .atomic_duplicate_state
= drm_dp_mst_duplicate_state
,
5459 .atomic_destroy_state
= drm_dp_mst_destroy_state
,
5461 EXPORT_SYMBOL(drm_dp_mst_topology_state_funcs
);
5464 * drm_atomic_get_mst_topology_state: get MST topology state
5466 * @state: global atomic state
5467 * @mgr: MST topology manager, also the private object in this case
5469 * This function wraps drm_atomic_get_priv_obj_state() passing in the MST atomic
5470 * state vtable so that the private object state returned is that of a MST
5471 * topology object. Also, drm_atomic_get_private_obj_state() expects the caller
5472 * to care of the locking, so warn if don't hold the connection_mutex.
5476 * The MST topology state or error pointer.
5478 struct drm_dp_mst_topology_state
*drm_atomic_get_mst_topology_state(struct drm_atomic_state
*state
,
5479 struct drm_dp_mst_topology_mgr
*mgr
)
5481 return to_dp_mst_topology_state(drm_atomic_get_private_obj_state(state
, &mgr
->base
));
5483 EXPORT_SYMBOL(drm_atomic_get_mst_topology_state
);
5486 * drm_dp_mst_topology_mgr_init - initialise a topology manager
5487 * @mgr: manager struct to initialise
5488 * @dev: device providing this structure - for i2c addition.
5489 * @aux: DP helper aux channel to talk to this device
5490 * @max_dpcd_transaction_bytes: hw specific DPCD transaction limit
5491 * @max_payloads: maximum number of payloads this GPU can source
5492 * @max_lane_count: maximum number of lanes this GPU supports
5493 * @max_link_rate: maximum link rate per lane this GPU supports in kHz
5494 * @conn_base_id: the connector object ID the MST device is connected to.
5496 * Return 0 for success, or negative error code on failure
5498 int drm_dp_mst_topology_mgr_init(struct drm_dp_mst_topology_mgr
*mgr
,
5499 struct drm_device
*dev
, struct drm_dp_aux
*aux
,
5500 int max_dpcd_transaction_bytes
, int max_payloads
,
5501 int max_lane_count
, int max_link_rate
,
5504 struct drm_dp_mst_topology_state
*mst_state
;
5506 mutex_init(&mgr
->lock
);
5507 mutex_init(&mgr
->qlock
);
5508 mutex_init(&mgr
->payload_lock
);
5509 mutex_init(&mgr
->delayed_destroy_lock
);
5510 mutex_init(&mgr
->up_req_lock
);
5511 mutex_init(&mgr
->probe_lock
);
5512 #if IS_ENABLED(CONFIG_DRM_DEBUG_DP_MST_TOPOLOGY_REFS)
5513 mutex_init(&mgr
->topology_ref_history_lock
);
5516 INIT_LIST_HEAD(&mgr
->tx_msg_downq
);
5517 INIT_LIST_HEAD(&mgr
->destroy_port_list
);
5518 INIT_LIST_HEAD(&mgr
->destroy_branch_device_list
);
5519 INIT_LIST_HEAD(&mgr
->up_req_list
);
5522 * delayed_destroy_work will be queued on a dedicated WQ, so that any
5523 * requeuing will be also flushed when deiniting the topology manager.
5525 mgr
->delayed_destroy_wq
= alloc_ordered_workqueue("drm_dp_mst_wq", 0);
5526 if (mgr
->delayed_destroy_wq
== NULL
)
5529 INIT_WORK(&mgr
->work
, drm_dp_mst_link_probe_work
);
5530 INIT_WORK(&mgr
->tx_work
, drm_dp_tx_work
);
5531 INIT_WORK(&mgr
->delayed_destroy_work
, drm_dp_delayed_destroy_work
);
5532 INIT_WORK(&mgr
->up_req_work
, drm_dp_mst_up_req_work
);
5533 init_waitqueue_head(&mgr
->tx_waitq
);
5536 mgr
->max_dpcd_transaction_bytes
= max_dpcd_transaction_bytes
;
5537 mgr
->max_payloads
= max_payloads
;
5538 mgr
->max_lane_count
= max_lane_count
;
5539 mgr
->max_link_rate
= max_link_rate
;
5540 mgr
->conn_base_id
= conn_base_id
;
5541 if (max_payloads
+ 1 > sizeof(mgr
->payload_mask
) * 8 ||
5542 max_payloads
+ 1 > sizeof(mgr
->vcpi_mask
) * 8)
5544 mgr
->payloads
= kcalloc(max_payloads
, sizeof(struct drm_dp_payload
), GFP_KERNEL
);
5547 mgr
->proposed_vcpis
= kcalloc(max_payloads
, sizeof(struct drm_dp_vcpi
*), GFP_KERNEL
);
5548 if (!mgr
->proposed_vcpis
)
5550 set_bit(0, &mgr
->payload_mask
);
5552 mst_state
= kzalloc(sizeof(*mst_state
), GFP_KERNEL
);
5553 if (mst_state
== NULL
)
5556 mst_state
->total_avail_slots
= 63;
5557 mst_state
->start_slot
= 1;
5559 mst_state
->mgr
= mgr
;
5560 INIT_LIST_HEAD(&mst_state
->vcpis
);
5562 drm_atomic_private_obj_init(dev
, &mgr
->base
,
5564 &drm_dp_mst_topology_state_funcs
);
5568 EXPORT_SYMBOL(drm_dp_mst_topology_mgr_init
);
5571 * drm_dp_mst_topology_mgr_destroy() - destroy topology manager.
5572 * @mgr: manager to destroy
5574 void drm_dp_mst_topology_mgr_destroy(struct drm_dp_mst_topology_mgr
*mgr
)
5576 drm_dp_mst_topology_mgr_set_mst(mgr
, false);
5577 flush_work(&mgr
->work
);
5578 /* The following will also drain any requeued work on the WQ. */
5579 if (mgr
->delayed_destroy_wq
) {
5580 destroy_workqueue(mgr
->delayed_destroy_wq
);
5581 mgr
->delayed_destroy_wq
= NULL
;
5583 mutex_lock(&mgr
->payload_lock
);
5584 kfree(mgr
->payloads
);
5585 mgr
->payloads
= NULL
;
5586 kfree(mgr
->proposed_vcpis
);
5587 mgr
->proposed_vcpis
= NULL
;
5588 mutex_unlock(&mgr
->payload_lock
);
5591 drm_atomic_private_obj_fini(&mgr
->base
);
5594 mutex_destroy(&mgr
->delayed_destroy_lock
);
5595 mutex_destroy(&mgr
->payload_lock
);
5596 mutex_destroy(&mgr
->qlock
);
5597 mutex_destroy(&mgr
->lock
);
5598 mutex_destroy(&mgr
->up_req_lock
);
5599 mutex_destroy(&mgr
->probe_lock
);
5600 #if IS_ENABLED(CONFIG_DRM_DEBUG_DP_MST_TOPOLOGY_REFS)
5601 mutex_destroy(&mgr
->topology_ref_history_lock
);
5604 EXPORT_SYMBOL(drm_dp_mst_topology_mgr_destroy
);
5606 static bool remote_i2c_read_ok(const struct i2c_msg msgs
[], int num
)
5610 if (num
- 1 > DP_REMOTE_I2C_READ_MAX_TRANSACTIONS
)
5613 for (i
= 0; i
< num
- 1; i
++) {
5614 if (msgs
[i
].flags
& I2C_M_RD
||
5619 return msgs
[num
- 1].flags
& I2C_M_RD
&&
5620 msgs
[num
- 1].len
<= 0xff;
5623 static bool remote_i2c_write_ok(const struct i2c_msg msgs
[], int num
)
5627 for (i
= 0; i
< num
- 1; i
++) {
5628 if (msgs
[i
].flags
& I2C_M_RD
|| !(msgs
[i
].flags
& I2C_M_STOP
) ||
5633 return !(msgs
[num
- 1].flags
& I2C_M_RD
) && msgs
[num
- 1].len
<= 0xff;
5636 static int drm_dp_mst_i2c_read(struct drm_dp_mst_branch
*mstb
,
5637 struct drm_dp_mst_port
*port
,
5638 struct i2c_msg
*msgs
, int num
)
5640 struct drm_dp_mst_topology_mgr
*mgr
= port
->mgr
;
5642 struct drm_dp_sideband_msg_req_body msg
;
5643 struct drm_dp_sideband_msg_tx
*txmsg
= NULL
;
5646 memset(&msg
, 0, sizeof(msg
));
5647 msg
.req_type
= DP_REMOTE_I2C_READ
;
5648 msg
.u
.i2c_read
.num_transactions
= num
- 1;
5649 msg
.u
.i2c_read
.port_number
= port
->port_num
;
5650 for (i
= 0; i
< num
- 1; i
++) {
5651 msg
.u
.i2c_read
.transactions
[i
].i2c_dev_id
= msgs
[i
].addr
;
5652 msg
.u
.i2c_read
.transactions
[i
].num_bytes
= msgs
[i
].len
;
5653 msg
.u
.i2c_read
.transactions
[i
].bytes
= msgs
[i
].buf
;
5654 msg
.u
.i2c_read
.transactions
[i
].no_stop_bit
= !(msgs
[i
].flags
& I2C_M_STOP
);
5656 msg
.u
.i2c_read
.read_i2c_device_id
= msgs
[num
- 1].addr
;
5657 msg
.u
.i2c_read
.num_bytes_read
= msgs
[num
- 1].len
;
5659 txmsg
= kzalloc(sizeof(*txmsg
), GFP_KERNEL
);
5666 drm_dp_encode_sideband_req(&msg
, txmsg
);
5668 drm_dp_queue_down_tx(mgr
, txmsg
);
5670 ret
= drm_dp_mst_wait_tx_reply(mstb
, txmsg
);
5673 if (txmsg
->reply
.reply_type
== DP_SIDEBAND_REPLY_NAK
) {
5677 if (txmsg
->reply
.u
.remote_i2c_read_ack
.num_bytes
!= msgs
[num
- 1].len
) {
5681 memcpy(msgs
[num
- 1].buf
, txmsg
->reply
.u
.remote_i2c_read_ack
.bytes
, msgs
[num
- 1].len
);
5689 static int drm_dp_mst_i2c_write(struct drm_dp_mst_branch
*mstb
,
5690 struct drm_dp_mst_port
*port
,
5691 struct i2c_msg
*msgs
, int num
)
5693 struct drm_dp_mst_topology_mgr
*mgr
= port
->mgr
;
5695 struct drm_dp_sideband_msg_req_body msg
;
5696 struct drm_dp_sideband_msg_tx
*txmsg
= NULL
;
5699 txmsg
= kzalloc(sizeof(*txmsg
), GFP_KERNEL
);
5704 for (i
= 0; i
< num
; i
++) {
5705 memset(&msg
, 0, sizeof(msg
));
5706 msg
.req_type
= DP_REMOTE_I2C_WRITE
;
5707 msg
.u
.i2c_write
.port_number
= port
->port_num
;
5708 msg
.u
.i2c_write
.write_i2c_device_id
= msgs
[i
].addr
;
5709 msg
.u
.i2c_write
.num_bytes
= msgs
[i
].len
;
5710 msg
.u
.i2c_write
.bytes
= msgs
[i
].buf
;
5712 memset(txmsg
, 0, sizeof(*txmsg
));
5715 drm_dp_encode_sideband_req(&msg
, txmsg
);
5716 drm_dp_queue_down_tx(mgr
, txmsg
);
5718 ret
= drm_dp_mst_wait_tx_reply(mstb
, txmsg
);
5720 if (txmsg
->reply
.reply_type
== DP_SIDEBAND_REPLY_NAK
) {
5735 static int drm_dp_mst_i2c_xfer(struct i2c_adapter
*adapter
,
5736 struct i2c_msg
*msgs
, int num
)
5738 struct drm_dp_aux
*aux
= adapter
->algo_data
;
5739 struct drm_dp_mst_port
*port
=
5740 container_of(aux
, struct drm_dp_mst_port
, aux
);
5741 struct drm_dp_mst_branch
*mstb
;
5742 struct drm_dp_mst_topology_mgr
*mgr
= port
->mgr
;
5745 mstb
= drm_dp_mst_topology_get_mstb_validated(mgr
, port
->parent
);
5749 if (remote_i2c_read_ok(msgs
, num
)) {
5750 ret
= drm_dp_mst_i2c_read(mstb
, port
, msgs
, num
);
5751 } else if (remote_i2c_write_ok(msgs
, num
)) {
5752 ret
= drm_dp_mst_i2c_write(mstb
, port
, msgs
, num
);
5754 drm_dbg_kms(mgr
->dev
, "Unsupported I2C transaction for MST device\n");
5758 drm_dp_mst_topology_put_mstb(mstb
);
5762 static u32
drm_dp_mst_i2c_functionality(struct i2c_adapter
*adapter
)
5764 return I2C_FUNC_I2C
| I2C_FUNC_SMBUS_EMUL
|
5765 I2C_FUNC_SMBUS_READ_BLOCK_DATA
|
5766 I2C_FUNC_SMBUS_BLOCK_PROC_CALL
|
5767 I2C_FUNC_10BIT_ADDR
;
5770 static const struct i2c_algorithm drm_dp_mst_i2c_algo
= {
5771 .functionality
= drm_dp_mst_i2c_functionality
,
5772 .master_xfer
= drm_dp_mst_i2c_xfer
,
5776 * drm_dp_mst_register_i2c_bus() - register an I2C adapter for I2C-over-AUX
5777 * @port: The port to add the I2C bus on
5779 * Returns 0 on success or a negative error code on failure.
5781 static int drm_dp_mst_register_i2c_bus(struct drm_dp_mst_port
*port
)
5783 struct drm_dp_aux
*aux
= &port
->aux
;
5784 struct device
*parent_dev
= port
->mgr
->dev
->dev
;
5786 aux
->ddc
.algo
= &drm_dp_mst_i2c_algo
;
5787 aux
->ddc
.algo_data
= aux
;
5788 aux
->ddc
.retries
= 3;
5790 aux
->ddc
.class = I2C_CLASS_DDC
;
5791 aux
->ddc
.owner
= THIS_MODULE
;
5792 /* FIXME: set the kdev of the port's connector as parent */
5793 aux
->ddc
.dev
.parent
= parent_dev
;
5794 aux
->ddc
.dev
.of_node
= parent_dev
->of_node
;
5796 strlcpy(aux
->ddc
.name
, aux
->name
? aux
->name
: dev_name(parent_dev
),
5797 sizeof(aux
->ddc
.name
));
5799 return i2c_add_adapter(&aux
->ddc
);
5803 * drm_dp_mst_unregister_i2c_bus() - unregister an I2C-over-AUX adapter
5804 * @port: The port to remove the I2C bus from
5806 static void drm_dp_mst_unregister_i2c_bus(struct drm_dp_mst_port
*port
)
5808 i2c_del_adapter(&port
->aux
.ddc
);
5812 * drm_dp_mst_is_virtual_dpcd() - Is the given port a virtual DP Peer Device
5813 * @port: The port to check
5815 * A single physical MST hub object can be represented in the topology
5816 * by multiple branches, with virtual ports between those branches.
5818 * As of DP1.4, An MST hub with internal (virtual) ports must expose
5819 * certain DPCD registers over those ports. See sections 2.6.1.1.1
5820 * and 2.6.1.1.2 of Display Port specification v1.4 for details.
5822 * May acquire mgr->lock
5825 * true if the port is a virtual DP peer device, false otherwise
5827 static bool drm_dp_mst_is_virtual_dpcd(struct drm_dp_mst_port
*port
)
5829 struct drm_dp_mst_port
*downstream_port
;
5831 if (!port
|| port
->dpcd_rev
< DP_DPCD_REV_14
)
5834 /* Virtual DP Sink (Internal Display Panel) */
5835 if (port
->port_num
>= 8)
5838 /* DP-to-HDMI Protocol Converter */
5839 if (port
->pdt
== DP_PEER_DEVICE_DP_LEGACY_CONV
&&
5845 mutex_lock(&port
->mgr
->lock
);
5846 if (port
->pdt
== DP_PEER_DEVICE_MST_BRANCHING
&&
5848 port
->mstb
->num_ports
== 2) {
5849 list_for_each_entry(downstream_port
, &port
->mstb
->ports
, next
) {
5850 if (downstream_port
->pdt
== DP_PEER_DEVICE_SST_SINK
&&
5851 !downstream_port
->input
) {
5852 mutex_unlock(&port
->mgr
->lock
);
5857 mutex_unlock(&port
->mgr
->lock
);
5863 * drm_dp_mst_dsc_aux_for_port() - Find the correct aux for DSC
5864 * @port: The port to check. A leaf of the MST tree with an attached display.
5866 * Depending on the situation, DSC may be enabled via the endpoint aux,
5867 * the immediately upstream aux, or the connector's physical aux.
5869 * This is both the correct aux to read DSC_CAPABILITY and the
5870 * correct aux to write DSC_ENABLED.
5872 * This operation can be expensive (up to four aux reads), so
5873 * the caller should cache the return.
5876 * NULL if DSC cannot be enabled on this port, otherwise the aux device
5878 struct drm_dp_aux
*drm_dp_mst_dsc_aux_for_port(struct drm_dp_mst_port
*port
)
5880 struct drm_dp_mst_port
*immediate_upstream_port
;
5881 struct drm_dp_mst_port
*fec_port
;
5882 struct drm_dp_desc desc
= {};
5889 if (port
->parent
->port_parent
)
5890 immediate_upstream_port
= port
->parent
->port_parent
;
5892 immediate_upstream_port
= NULL
;
5894 fec_port
= immediate_upstream_port
;
5897 * Each physical link (i.e. not a virtual port) between the
5898 * output and the primary device must support FEC
5900 if (!drm_dp_mst_is_virtual_dpcd(fec_port
) &&
5901 !fec_port
->fec_capable
)
5904 fec_port
= fec_port
->parent
->port_parent
;
5907 /* DP-to-DP peer device */
5908 if (drm_dp_mst_is_virtual_dpcd(immediate_upstream_port
)) {
5911 if (drm_dp_dpcd_read(&port
->aux
,
5912 DP_DSC_SUPPORT
, &endpoint_dsc
, 1) != 1)
5914 if (drm_dp_dpcd_read(&port
->aux
,
5915 DP_FEC_CAPABILITY
, &endpoint_fec
, 1) != 1)
5917 if (drm_dp_dpcd_read(&immediate_upstream_port
->aux
,
5918 DP_DSC_SUPPORT
, &upstream_dsc
, 1) != 1)
5921 /* Enpoint decompression with DP-to-DP peer device */
5922 if ((endpoint_dsc
& DP_DSC_DECOMPRESSION_IS_SUPPORTED
) &&
5923 (endpoint_fec
& DP_FEC_CAPABLE
) &&
5924 (upstream_dsc
& 0x2) /* DSC passthrough */)
5927 /* Virtual DPCD decompression with DP-to-DP peer device */
5928 return &immediate_upstream_port
->aux
;
5931 /* Virtual DPCD decompression with DP-to-HDMI or Virtual DP Sink */
5932 if (drm_dp_mst_is_virtual_dpcd(port
))
5937 * Applies to ports for which:
5938 * - Physical aux has Synaptics OUI
5939 * - DPv1.4 or higher
5940 * - Port is on primary branch device
5941 * - Not a VGA adapter (DP_DWN_STRM_PORT_TYPE_ANALOG)
5943 if (drm_dp_read_desc(port
->mgr
->aux
, &desc
, true))
5946 if (drm_dp_has_quirk(&desc
, DP_DPCD_QUIRK_DSC_WITHOUT_VIRTUAL_DPCD
) &&
5947 port
->mgr
->dpcd
[DP_DPCD_REV
] >= DP_DPCD_REV_14
&&
5948 port
->parent
== port
->mgr
->mst_primary
) {
5949 u8 dpcd_ext
[DP_RECEIVER_CAP_SIZE
];
5951 if (drm_dp_read_dpcd_caps(port
->mgr
->aux
, dpcd_ext
) < 0)
5954 if ((dpcd_ext
[DP_DOWNSTREAMPORT_PRESENT
] & DP_DWN_STRM_PORT_PRESENT
) &&
5955 ((dpcd_ext
[DP_DOWNSTREAMPORT_PRESENT
] & DP_DWN_STRM_PORT_TYPE_MASK
)
5956 != DP_DWN_STRM_PORT_TYPE_ANALOG
))
5957 return port
->mgr
->aux
;
5961 * The check below verifies if the MST sink
5962 * connected to the GPU is capable of DSC -
5963 * therefore the endpoint needs to be
5964 * both DSC and FEC capable.
5966 if (drm_dp_dpcd_read(&port
->aux
,
5967 DP_DSC_SUPPORT
, &endpoint_dsc
, 1) != 1)
5969 if (drm_dp_dpcd_read(&port
->aux
,
5970 DP_FEC_CAPABILITY
, &endpoint_fec
, 1) != 1)
5972 if ((endpoint_dsc
& DP_DSC_DECOMPRESSION_IS_SUPPORTED
) &&
5973 (endpoint_fec
& DP_FEC_CAPABLE
))
5978 EXPORT_SYMBOL(drm_dp_mst_dsc_aux_for_port
);