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