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