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