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