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 bool primary_mstb_probing_is_done(struct drm_dp_mst_topology_mgr *mgr) 4029 { 4030 bool probing_done = false; 4031 4032 mutex_lock(&mgr->lock); 4033 4034 if (mgr->mst_primary && drm_dp_mst_topology_try_get_mstb(mgr->mst_primary)) { 4035 probing_done = mgr->mst_primary->link_address_sent; 4036 drm_dp_mst_topology_put_mstb(mgr->mst_primary); 4037 } 4038 4039 mutex_unlock(&mgr->lock); 4040 4041 return probing_done; 4042 } 4043 4044 static inline bool 4045 drm_dp_mst_process_up_req(struct drm_dp_mst_topology_mgr *mgr, 4046 struct drm_dp_pending_up_req *up_req) 4047 { 4048 struct drm_dp_mst_branch *mstb = NULL; 4049 struct drm_dp_sideband_msg_req_body *msg = &up_req->msg; 4050 struct drm_dp_sideband_msg_hdr *hdr = &up_req->hdr; 4051 bool hotplug = false, dowork = false; 4052 4053 if (hdr->broadcast) { 4054 const guid_t *guid = NULL; 4055 4056 if (msg->req_type == DP_CONNECTION_STATUS_NOTIFY) 4057 guid = &msg->u.conn_stat.guid; 4058 else if (msg->req_type == DP_RESOURCE_STATUS_NOTIFY) 4059 guid = &msg->u.resource_stat.guid; 4060 4061 if (guid) 4062 mstb = drm_dp_get_mst_branch_device_by_guid(mgr, guid); 4063 } else { 4064 mstb = drm_dp_get_mst_branch_device(mgr, hdr->lct, hdr->rad); 4065 } 4066 4067 if (!mstb) { 4068 drm_dbg_kms(mgr->dev, "Got MST reply from unknown device %d\n", hdr->lct); 4069 return false; 4070 } 4071 4072 /* TODO: Add missing handler for DP_RESOURCE_STATUS_NOTIFY events */ 4073 if (msg->req_type == DP_CONNECTION_STATUS_NOTIFY) { 4074 if (!primary_mstb_probing_is_done(mgr)) { 4075 drm_dbg_kms(mgr->dev, "Got CSN before finish topology probing. Skip it.\n"); 4076 } else { 4077 dowork = drm_dp_mst_handle_conn_stat(mstb, &msg->u.conn_stat); 4078 hotplug = true; 4079 } 4080 } 4081 4082 drm_dp_mst_topology_put_mstb(mstb); 4083 4084 if (dowork) 4085 queue_work(system_long_wq, &mgr->work); 4086 return hotplug; 4087 } 4088 4089 static void drm_dp_mst_up_req_work(struct work_struct *work) 4090 { 4091 struct drm_dp_mst_topology_mgr *mgr = 4092 container_of(work, struct drm_dp_mst_topology_mgr, 4093 up_req_work); 4094 struct drm_dp_pending_up_req *up_req; 4095 bool send_hotplug = false; 4096 4097 mutex_lock(&mgr->probe_lock); 4098 while (true) { 4099 mutex_lock(&mgr->up_req_lock); 4100 up_req = list_first_entry_or_null(&mgr->up_req_list, 4101 struct drm_dp_pending_up_req, 4102 next); 4103 if (up_req) 4104 list_del(&up_req->next); 4105 mutex_unlock(&mgr->up_req_lock); 4106 4107 if (!up_req) 4108 break; 4109 4110 send_hotplug |= drm_dp_mst_process_up_req(mgr, up_req); 4111 kfree(up_req); 4112 } 4113 mutex_unlock(&mgr->probe_lock); 4114 4115 if (send_hotplug) 4116 drm_kms_helper_hotplug_event(mgr->dev); 4117 } 4118 4119 static int drm_dp_mst_handle_up_req(struct drm_dp_mst_topology_mgr *mgr) 4120 { 4121 struct drm_dp_pending_up_req *up_req; 4122 struct drm_dp_mst_branch *mst_primary; 4123 int ret = 0; 4124 4125 if (!drm_dp_get_one_sb_msg(mgr, true, NULL)) 4126 goto out_clear_reply; 4127 4128 if (!mgr->up_req_recv.have_eomt) 4129 return 0; 4130 4131 up_req = kzalloc(sizeof(*up_req), GFP_KERNEL); 4132 if (!up_req) { 4133 ret = -ENOMEM; 4134 goto out_clear_reply; 4135 } 4136 4137 INIT_LIST_HEAD(&up_req->next); 4138 4139 drm_dp_sideband_parse_req(mgr, &mgr->up_req_recv, &up_req->msg); 4140 4141 if (up_req->msg.req_type != DP_CONNECTION_STATUS_NOTIFY && 4142 up_req->msg.req_type != DP_RESOURCE_STATUS_NOTIFY) { 4143 drm_dbg_kms(mgr->dev, "Received unknown up req type, ignoring: %x\n", 4144 up_req->msg.req_type); 4145 kfree(up_req); 4146 goto out_clear_reply; 4147 } 4148 4149 mutex_lock(&mgr->lock); 4150 mst_primary = mgr->mst_primary; 4151 if (!mst_primary || !drm_dp_mst_topology_try_get_mstb(mst_primary)) { 4152 mutex_unlock(&mgr->lock); 4153 kfree(up_req); 4154 goto out_clear_reply; 4155 } 4156 mutex_unlock(&mgr->lock); 4157 4158 drm_dp_send_up_ack_reply(mgr, mst_primary, up_req->msg.req_type, 4159 false); 4160 4161 drm_dp_mst_topology_put_mstb(mst_primary); 4162 4163 if (up_req->msg.req_type == DP_CONNECTION_STATUS_NOTIFY) { 4164 const struct drm_dp_connection_status_notify *conn_stat = 4165 &up_req->msg.u.conn_stat; 4166 4167 drm_dbg_kms(mgr->dev, "Got CSN: pn: %d ldps:%d ddps: %d mcs: %d ip: %d pdt: %d\n", 4168 conn_stat->port_number, 4169 conn_stat->legacy_device_plug_status, 4170 conn_stat->displayport_device_plug_status, 4171 conn_stat->message_capability_status, 4172 conn_stat->input_port, 4173 conn_stat->peer_device_type); 4174 } else if (up_req->msg.req_type == DP_RESOURCE_STATUS_NOTIFY) { 4175 const struct drm_dp_resource_status_notify *res_stat = 4176 &up_req->msg.u.resource_stat; 4177 4178 drm_dbg_kms(mgr->dev, "Got RSN: pn: %d avail_pbn %d\n", 4179 res_stat->port_number, 4180 res_stat->available_pbn); 4181 } 4182 4183 up_req->hdr = mgr->up_req_recv.initial_hdr; 4184 mutex_lock(&mgr->up_req_lock); 4185 list_add_tail(&up_req->next, &mgr->up_req_list); 4186 mutex_unlock(&mgr->up_req_lock); 4187 queue_work(system_long_wq, &mgr->up_req_work); 4188 out_clear_reply: 4189 reset_msg_rx_state(&mgr->up_req_recv); 4190 return ret; 4191 } 4192 4193 static void update_msg_rx_state(struct drm_dp_mst_topology_mgr *mgr) 4194 { 4195 mutex_lock(&mgr->lock); 4196 if (mgr->reset_rx_state) { 4197 mgr->reset_rx_state = false; 4198 reset_msg_rx_state(&mgr->down_rep_recv); 4199 reset_msg_rx_state(&mgr->up_req_recv); 4200 } 4201 mutex_unlock(&mgr->lock); 4202 } 4203 4204 /** 4205 * drm_dp_mst_hpd_irq_handle_event() - MST hotplug IRQ handle MST event 4206 * @mgr: manager to notify irq for. 4207 * @esi: 4 bytes from SINK_COUNT_ESI 4208 * @ack: 4 bytes used to ack events starting from SINK_COUNT_ESI 4209 * @handled: whether the hpd interrupt was consumed or not 4210 * 4211 * This should be called from the driver when it detects a HPD IRQ, 4212 * along with the value of the DEVICE_SERVICE_IRQ_VECTOR_ESI0. The 4213 * topology manager will process the sideband messages received 4214 * as indicated in the DEVICE_SERVICE_IRQ_VECTOR_ESI0 and set the 4215 * corresponding flags that Driver has to ack the DP receiver later. 4216 * 4217 * Note that driver shall also call 4218 * drm_dp_mst_hpd_irq_send_new_request() if the 'handled' is set 4219 * after calling this function, to try to kick off a new request in 4220 * the queue if the previous message transaction is completed. 4221 * 4222 * See also: 4223 * drm_dp_mst_hpd_irq_send_new_request() 4224 */ 4225 int drm_dp_mst_hpd_irq_handle_event(struct drm_dp_mst_topology_mgr *mgr, const u8 *esi, 4226 u8 *ack, bool *handled) 4227 { 4228 int ret = 0; 4229 int sc; 4230 *handled = false; 4231 sc = DP_GET_SINK_COUNT(esi[0]); 4232 4233 if (sc != mgr->sink_count) { 4234 mgr->sink_count = sc; 4235 *handled = true; 4236 } 4237 4238 update_msg_rx_state(mgr); 4239 4240 if (esi[1] & DP_DOWN_REP_MSG_RDY) { 4241 ret = drm_dp_mst_handle_down_rep(mgr); 4242 *handled = true; 4243 ack[1] |= DP_DOWN_REP_MSG_RDY; 4244 } 4245 4246 if (esi[1] & DP_UP_REQ_MSG_RDY) { 4247 ret |= drm_dp_mst_handle_up_req(mgr); 4248 *handled = true; 4249 ack[1] |= DP_UP_REQ_MSG_RDY; 4250 } 4251 4252 return ret; 4253 } 4254 EXPORT_SYMBOL(drm_dp_mst_hpd_irq_handle_event); 4255 4256 /** 4257 * drm_dp_mst_hpd_irq_send_new_request() - MST hotplug IRQ kick off new request 4258 * @mgr: manager to notify irq for. 4259 * 4260 * This should be called from the driver when mst irq event is handled 4261 * and acked. Note that new down request should only be sent when 4262 * previous message transaction is completed. Source is not supposed to generate 4263 * interleaved message transactions. 4264 */ 4265 void drm_dp_mst_hpd_irq_send_new_request(struct drm_dp_mst_topology_mgr *mgr) 4266 { 4267 struct drm_dp_sideband_msg_tx *txmsg; 4268 bool kick = true; 4269 4270 mutex_lock(&mgr->qlock); 4271 txmsg = list_first_entry_or_null(&mgr->tx_msg_downq, 4272 struct drm_dp_sideband_msg_tx, next); 4273 /* If last transaction is not completed yet*/ 4274 if (!txmsg || 4275 txmsg->state == DRM_DP_SIDEBAND_TX_START_SEND || 4276 txmsg->state == DRM_DP_SIDEBAND_TX_SENT) 4277 kick = false; 4278 mutex_unlock(&mgr->qlock); 4279 4280 if (kick) 4281 drm_dp_mst_kick_tx(mgr); 4282 } 4283 EXPORT_SYMBOL(drm_dp_mst_hpd_irq_send_new_request); 4284 /** 4285 * drm_dp_mst_detect_port() - get connection status for an MST port 4286 * @connector: DRM connector for this port 4287 * @ctx: The acquisition context to use for grabbing locks 4288 * @mgr: manager for this port 4289 * @port: pointer to a port 4290 * 4291 * This returns the current connection state for a port. 4292 */ 4293 int 4294 drm_dp_mst_detect_port(struct drm_connector *connector, 4295 struct drm_modeset_acquire_ctx *ctx, 4296 struct drm_dp_mst_topology_mgr *mgr, 4297 struct drm_dp_mst_port *port) 4298 { 4299 int ret; 4300 4301 /* we need to search for the port in the mgr in case it's gone */ 4302 port = drm_dp_mst_topology_get_port_validated(mgr, port); 4303 if (!port) 4304 return connector_status_disconnected; 4305 4306 ret = drm_modeset_lock(&mgr->base.lock, ctx); 4307 if (ret) 4308 goto out; 4309 4310 ret = connector_status_disconnected; 4311 4312 if (!port->ddps) 4313 goto out; 4314 4315 switch (port->pdt) { 4316 case DP_PEER_DEVICE_NONE: 4317 break; 4318 case DP_PEER_DEVICE_MST_BRANCHING: 4319 if (!port->mcs) 4320 ret = connector_status_connected; 4321 break; 4322 4323 case DP_PEER_DEVICE_SST_SINK: 4324 ret = connector_status_connected; 4325 /* for logical ports - cache the EDID */ 4326 if (drm_dp_mst_port_is_logical(port) && !port->cached_edid) 4327 port->cached_edid = drm_edid_read_ddc(connector, &port->aux.ddc); 4328 break; 4329 case DP_PEER_DEVICE_DP_LEGACY_CONV: 4330 if (port->ldps) 4331 ret = connector_status_connected; 4332 break; 4333 } 4334 out: 4335 drm_dp_mst_topology_put_port(port); 4336 return ret; 4337 } 4338 EXPORT_SYMBOL(drm_dp_mst_detect_port); 4339 4340 /** 4341 * drm_dp_mst_edid_read() - get EDID for an MST port 4342 * @connector: toplevel connector to get EDID for 4343 * @mgr: manager for this port 4344 * @port: unverified pointer to a port. 4345 * 4346 * This returns an EDID for the port connected to a connector, 4347 * It validates the pointer still exists so the caller doesn't require a 4348 * reference. 4349 */ 4350 const struct drm_edid *drm_dp_mst_edid_read(struct drm_connector *connector, 4351 struct drm_dp_mst_topology_mgr *mgr, 4352 struct drm_dp_mst_port *port) 4353 { 4354 const struct drm_edid *drm_edid; 4355 4356 /* we need to search for the port in the mgr in case it's gone */ 4357 port = drm_dp_mst_topology_get_port_validated(mgr, port); 4358 if (!port) 4359 return NULL; 4360 4361 if (port->cached_edid) 4362 drm_edid = drm_edid_dup(port->cached_edid); 4363 else 4364 drm_edid = drm_edid_read_ddc(connector, &port->aux.ddc); 4365 4366 drm_dp_mst_topology_put_port(port); 4367 4368 return drm_edid; 4369 } 4370 EXPORT_SYMBOL(drm_dp_mst_edid_read); 4371 4372 /** 4373 * drm_dp_mst_get_edid() - get EDID for an MST port 4374 * @connector: toplevel connector to get EDID for 4375 * @mgr: manager for this port 4376 * @port: unverified pointer to a port. 4377 * 4378 * This function is deprecated; please use drm_dp_mst_edid_read() instead. 4379 * 4380 * This returns an EDID for the port connected to a connector, 4381 * It validates the pointer still exists so the caller doesn't require a 4382 * reference. 4383 */ 4384 struct edid *drm_dp_mst_get_edid(struct drm_connector *connector, 4385 struct drm_dp_mst_topology_mgr *mgr, 4386 struct drm_dp_mst_port *port) 4387 { 4388 const struct drm_edid *drm_edid; 4389 struct edid *edid; 4390 4391 drm_edid = drm_dp_mst_edid_read(connector, mgr, port); 4392 4393 edid = drm_edid_duplicate(drm_edid_raw(drm_edid)); 4394 4395 drm_edid_free(drm_edid); 4396 4397 return edid; 4398 } 4399 EXPORT_SYMBOL(drm_dp_mst_get_edid); 4400 4401 /** 4402 * drm_dp_atomic_find_time_slots() - Find and add time slots to the state 4403 * @state: global atomic state 4404 * @mgr: MST topology manager for the port 4405 * @port: port to find time slots for 4406 * @pbn: bandwidth required for the mode in PBN 4407 * 4408 * Allocates time slots to @port, replacing any previous time slot allocations it may 4409 * have had. Any atomic drivers which support MST must call this function in 4410 * their &drm_encoder_helper_funcs.atomic_check() callback unconditionally to 4411 * change the current time slot allocation for the new state, and ensure the MST 4412 * atomic state is added whenever the state of payloads in the topology changes. 4413 * 4414 * Allocations set by this function are not checked against the bandwidth 4415 * restraints of @mgr until the driver calls drm_dp_mst_atomic_check(). 4416 * 4417 * Additionally, it is OK to call this function multiple times on the same 4418 * @port as needed. It is not OK however, to call this function and 4419 * drm_dp_atomic_release_time_slots() in the same atomic check phase. 4420 * 4421 * See also: 4422 * drm_dp_atomic_release_time_slots() 4423 * drm_dp_mst_atomic_check() 4424 * 4425 * Returns: 4426 * Total slots in the atomic state assigned for this port, or a negative error 4427 * code if the port no longer exists 4428 */ 4429 int drm_dp_atomic_find_time_slots(struct drm_atomic_state *state, 4430 struct drm_dp_mst_topology_mgr *mgr, 4431 struct drm_dp_mst_port *port, int pbn) 4432 { 4433 struct drm_dp_mst_topology_state *topology_state; 4434 struct drm_dp_mst_atomic_payload *payload = NULL; 4435 struct drm_connector_state *conn_state; 4436 int prev_slots = 0, prev_bw = 0, req_slots; 4437 4438 topology_state = drm_atomic_get_mst_topology_state(state, mgr); 4439 if (IS_ERR(topology_state)) 4440 return PTR_ERR(topology_state); 4441 4442 conn_state = drm_atomic_get_new_connector_state(state, port->connector); 4443 topology_state->pending_crtc_mask |= drm_crtc_mask(conn_state->crtc); 4444 4445 /* Find the current allocation for this port, if any */ 4446 payload = drm_atomic_get_mst_payload_state(topology_state, port); 4447 if (payload) { 4448 prev_slots = payload->time_slots; 4449 prev_bw = payload->pbn; 4450 4451 /* 4452 * This should never happen, unless the driver tries 4453 * releasing and allocating the same timeslot allocation, 4454 * which is an error 4455 */ 4456 if (drm_WARN_ON(mgr->dev, payload->delete)) { 4457 drm_err(mgr->dev, 4458 "cannot allocate and release time slots on [MST PORT:%p] in the same state\n", 4459 port); 4460 return -EINVAL; 4461 } 4462 } 4463 4464 req_slots = DIV_ROUND_UP(dfixed_const(pbn), topology_state->pbn_div.full); 4465 4466 drm_dbg_atomic(mgr->dev, "[CONNECTOR:%d:%s] [MST PORT:%p] TU %d -> %d\n", 4467 port->connector->base.id, port->connector->name, 4468 port, prev_slots, req_slots); 4469 drm_dbg_atomic(mgr->dev, "[CONNECTOR:%d:%s] [MST PORT:%p] PBN %d -> %d\n", 4470 port->connector->base.id, port->connector->name, 4471 port, prev_bw, pbn); 4472 4473 /* Add the new allocation to the state, note the VCPI isn't assigned until the end */ 4474 if (!payload) { 4475 payload = kzalloc(sizeof(*payload), GFP_KERNEL); 4476 if (!payload) 4477 return -ENOMEM; 4478 4479 drm_dp_mst_get_port_malloc(port); 4480 payload->port = port; 4481 payload->vc_start_slot = -1; 4482 payload->payload_allocation_status = DRM_DP_MST_PAYLOAD_ALLOCATION_NONE; 4483 list_add(&payload->next, &topology_state->payloads); 4484 } 4485 payload->time_slots = req_slots; 4486 payload->pbn = pbn; 4487 4488 return req_slots; 4489 } 4490 EXPORT_SYMBOL(drm_dp_atomic_find_time_slots); 4491 4492 /** 4493 * drm_dp_atomic_release_time_slots() - Release allocated time slots 4494 * @state: global atomic state 4495 * @mgr: MST topology manager for the port 4496 * @port: The port to release the time slots from 4497 * 4498 * Releases any time slots that have been allocated to a port in the atomic 4499 * state. Any atomic drivers which support MST must call this function 4500 * unconditionally in their &drm_connector_helper_funcs.atomic_check() callback. 4501 * This helper will check whether time slots would be released by the new state and 4502 * respond accordingly, along with ensuring the MST state is always added to the 4503 * atomic state whenever a new state would modify the state of payloads on the 4504 * topology. 4505 * 4506 * It is OK to call this even if @port has been removed from the system. 4507 * Additionally, it is OK to call this function multiple times on the same 4508 * @port as needed. It is not OK however, to call this function and 4509 * drm_dp_atomic_find_time_slots() on the same @port in a single atomic check 4510 * phase. 4511 * 4512 * See also: 4513 * drm_dp_atomic_find_time_slots() 4514 * drm_dp_mst_atomic_check() 4515 * 4516 * Returns: 4517 * 0 on success, negative error code otherwise 4518 */ 4519 int drm_dp_atomic_release_time_slots(struct drm_atomic_state *state, 4520 struct drm_dp_mst_topology_mgr *mgr, 4521 struct drm_dp_mst_port *port) 4522 { 4523 struct drm_dp_mst_topology_state *topology_state; 4524 struct drm_dp_mst_atomic_payload *payload; 4525 struct drm_connector_state *old_conn_state, *new_conn_state; 4526 bool update_payload = true; 4527 4528 old_conn_state = drm_atomic_get_old_connector_state(state, port->connector); 4529 if (!old_conn_state->crtc) 4530 return 0; 4531 4532 /* If the CRTC isn't disabled by this state, don't release it's payload */ 4533 new_conn_state = drm_atomic_get_new_connector_state(state, port->connector); 4534 if (new_conn_state->crtc) { 4535 struct drm_crtc_state *crtc_state = 4536 drm_atomic_get_new_crtc_state(state, new_conn_state->crtc); 4537 4538 /* No modeset means no payload changes, so it's safe to not pull in the MST state */ 4539 if (!crtc_state || !drm_atomic_crtc_needs_modeset(crtc_state)) 4540 return 0; 4541 4542 if (!crtc_state->mode_changed && !crtc_state->connectors_changed) 4543 update_payload = false; 4544 } 4545 4546 topology_state = drm_atomic_get_mst_topology_state(state, mgr); 4547 if (IS_ERR(topology_state)) 4548 return PTR_ERR(topology_state); 4549 4550 topology_state->pending_crtc_mask |= drm_crtc_mask(old_conn_state->crtc); 4551 if (!update_payload) 4552 return 0; 4553 4554 payload = drm_atomic_get_mst_payload_state(topology_state, port); 4555 if (WARN_ON(!payload)) { 4556 drm_err(mgr->dev, "No payload for [MST PORT:%p] found in mst state %p\n", 4557 port, &topology_state->base); 4558 return -EINVAL; 4559 } 4560 4561 if (new_conn_state->crtc) 4562 return 0; 4563 4564 drm_dbg_atomic(mgr->dev, "[MST PORT:%p] TU %d -> 0\n", port, payload->time_slots); 4565 if (!payload->delete) { 4566 payload->pbn = 0; 4567 payload->delete = true; 4568 topology_state->payload_mask &= ~BIT(payload->vcpi - 1); 4569 } 4570 4571 return 0; 4572 } 4573 EXPORT_SYMBOL(drm_dp_atomic_release_time_slots); 4574 4575 /** 4576 * drm_dp_mst_atomic_setup_commit() - setup_commit hook for MST helpers 4577 * @state: global atomic state 4578 * 4579 * This function saves all of the &drm_crtc_commit structs in an atomic state that touch any CRTCs 4580 * currently assigned to an MST topology. Drivers must call this hook from their 4581 * &drm_mode_config_helper_funcs.atomic_commit_setup hook. 4582 * 4583 * Returns: 4584 * 0 if all CRTC commits were retrieved successfully, negative error code otherwise 4585 */ 4586 int drm_dp_mst_atomic_setup_commit(struct drm_atomic_state *state) 4587 { 4588 struct drm_dp_mst_topology_mgr *mgr; 4589 struct drm_dp_mst_topology_state *mst_state; 4590 struct drm_crtc *crtc; 4591 struct drm_crtc_state *crtc_state; 4592 int i, j, commit_idx, num_commit_deps; 4593 4594 for_each_new_mst_mgr_in_state(state, mgr, mst_state, i) { 4595 if (!mst_state->pending_crtc_mask) 4596 continue; 4597 4598 num_commit_deps = hweight32(mst_state->pending_crtc_mask); 4599 mst_state->commit_deps = kmalloc_array(num_commit_deps, 4600 sizeof(*mst_state->commit_deps), GFP_KERNEL); 4601 if (!mst_state->commit_deps) 4602 return -ENOMEM; 4603 mst_state->num_commit_deps = num_commit_deps; 4604 4605 commit_idx = 0; 4606 for_each_new_crtc_in_state(state, crtc, crtc_state, j) { 4607 if (mst_state->pending_crtc_mask & drm_crtc_mask(crtc)) { 4608 mst_state->commit_deps[commit_idx++] = 4609 drm_crtc_commit_get(crtc_state->commit); 4610 } 4611 } 4612 } 4613 4614 return 0; 4615 } 4616 EXPORT_SYMBOL(drm_dp_mst_atomic_setup_commit); 4617 4618 /** 4619 * drm_dp_mst_atomic_wait_for_dependencies() - Wait for all pending commits on MST topologies, 4620 * prepare new MST state for commit 4621 * @state: global atomic state 4622 * 4623 * Goes through any MST topologies in this atomic state, and waits for any pending commits which 4624 * touched CRTCs that were/are on an MST topology to be programmed to hardware and flipped to before 4625 * returning. This is to prevent multiple non-blocking commits affecting an MST topology from racing 4626 * with eachother by forcing them to be executed sequentially in situations where the only resources 4627 * the modeset objects in these commits share are an MST topology. 4628 * 4629 * This function also prepares the new MST state for commit by performing some state preparation 4630 * which can't be done until this point, such as reading back the final VC start slots (which are 4631 * determined at commit-time) from the previous state. 4632 * 4633 * All MST drivers must call this function after calling drm_atomic_helper_wait_for_dependencies(), 4634 * or whatever their equivalent of that is. 4635 */ 4636 void drm_dp_mst_atomic_wait_for_dependencies(struct drm_atomic_state *state) 4637 { 4638 struct drm_dp_mst_topology_state *old_mst_state, *new_mst_state; 4639 struct drm_dp_mst_topology_mgr *mgr; 4640 struct drm_dp_mst_atomic_payload *old_payload, *new_payload; 4641 int i, j, ret; 4642 4643 for_each_oldnew_mst_mgr_in_state(state, mgr, old_mst_state, new_mst_state, i) { 4644 for (j = 0; j < old_mst_state->num_commit_deps; j++) { 4645 ret = drm_crtc_commit_wait(old_mst_state->commit_deps[j]); 4646 if (ret < 0) 4647 drm_err(state->dev, "Failed to wait for %s: %d\n", 4648 old_mst_state->commit_deps[j]->crtc->name, ret); 4649 } 4650 4651 /* Now that previous state is committed, it's safe to copy over the start slot 4652 * and allocation status assignments 4653 */ 4654 list_for_each_entry(old_payload, &old_mst_state->payloads, next) { 4655 if (old_payload->delete) 4656 continue; 4657 4658 new_payload = drm_atomic_get_mst_payload_state(new_mst_state, 4659 old_payload->port); 4660 new_payload->vc_start_slot = old_payload->vc_start_slot; 4661 new_payload->payload_allocation_status = 4662 old_payload->payload_allocation_status; 4663 } 4664 } 4665 } 4666 EXPORT_SYMBOL(drm_dp_mst_atomic_wait_for_dependencies); 4667 4668 /** 4669 * drm_dp_mst_root_conn_atomic_check() - Serialize CRTC commits on MST-capable connectors operating 4670 * in SST mode 4671 * @new_conn_state: The new connector state of the &drm_connector 4672 * @mgr: The MST topology manager for the &drm_connector 4673 * 4674 * Since MST uses fake &drm_encoder structs, the generic atomic modesetting code isn't able to 4675 * serialize non-blocking commits happening on the real DP connector of an MST topology switching 4676 * into/away from MST mode - as the CRTC on the real DP connector and the CRTCs on the connector's 4677 * MST topology will never share the same &drm_encoder. 4678 * 4679 * This function takes care of this serialization issue, by checking a root MST connector's atomic 4680 * state to determine if it is about to have a modeset - and then pulling in the MST topology state 4681 * if so, along with adding any relevant CRTCs to &drm_dp_mst_topology_state.pending_crtc_mask. 4682 * 4683 * Drivers implementing MST must call this function from the 4684 * &drm_connector_helper_funcs.atomic_check hook of any physical DP &drm_connector capable of 4685 * driving MST sinks. 4686 * 4687 * Returns: 4688 * 0 on success, negative error code otherwise 4689 */ 4690 int drm_dp_mst_root_conn_atomic_check(struct drm_connector_state *new_conn_state, 4691 struct drm_dp_mst_topology_mgr *mgr) 4692 { 4693 struct drm_atomic_state *state = new_conn_state->state; 4694 struct drm_connector_state *old_conn_state = 4695 drm_atomic_get_old_connector_state(state, new_conn_state->connector); 4696 struct drm_crtc_state *crtc_state; 4697 struct drm_dp_mst_topology_state *mst_state = NULL; 4698 4699 if (new_conn_state->crtc) { 4700 crtc_state = drm_atomic_get_new_crtc_state(state, new_conn_state->crtc); 4701 if (crtc_state && drm_atomic_crtc_needs_modeset(crtc_state)) { 4702 mst_state = drm_atomic_get_mst_topology_state(state, mgr); 4703 if (IS_ERR(mst_state)) 4704 return PTR_ERR(mst_state); 4705 4706 mst_state->pending_crtc_mask |= drm_crtc_mask(new_conn_state->crtc); 4707 } 4708 } 4709 4710 if (old_conn_state->crtc) { 4711 crtc_state = drm_atomic_get_new_crtc_state(state, old_conn_state->crtc); 4712 if (crtc_state && drm_atomic_crtc_needs_modeset(crtc_state)) { 4713 if (!mst_state) { 4714 mst_state = drm_atomic_get_mst_topology_state(state, mgr); 4715 if (IS_ERR(mst_state)) 4716 return PTR_ERR(mst_state); 4717 } 4718 4719 mst_state->pending_crtc_mask |= drm_crtc_mask(old_conn_state->crtc); 4720 } 4721 } 4722 4723 return 0; 4724 } 4725 EXPORT_SYMBOL(drm_dp_mst_root_conn_atomic_check); 4726 4727 /** 4728 * drm_dp_mst_update_slots() - updates the slot info depending on the DP ecoding format 4729 * @mst_state: mst_state to update 4730 * @link_encoding_cap: the ecoding format on the link 4731 */ 4732 void drm_dp_mst_update_slots(struct drm_dp_mst_topology_state *mst_state, uint8_t link_encoding_cap) 4733 { 4734 if (link_encoding_cap == DP_CAP_ANSI_128B132B) { 4735 mst_state->total_avail_slots = 64; 4736 mst_state->start_slot = 0; 4737 } else { 4738 mst_state->total_avail_slots = 63; 4739 mst_state->start_slot = 1; 4740 } 4741 4742 DRM_DEBUG_KMS("%s encoding format on mst_state 0x%p\n", 4743 (link_encoding_cap == DP_CAP_ANSI_128B132B) ? "128b/132b":"8b/10b", 4744 mst_state); 4745 } 4746 EXPORT_SYMBOL(drm_dp_mst_update_slots); 4747 4748 /** 4749 * drm_dp_check_act_status() - Polls for ACT handled status. 4750 * @mgr: manager to use 4751 * 4752 * Tries waiting for the MST hub to finish updating it's payload table by 4753 * polling for the ACT handled bit for up to 3 seconds (yes-some hubs really 4754 * take that long). 4755 * 4756 * Returns: 4757 * 0 if the ACT was handled in time, negative error code on failure. 4758 */ 4759 int drm_dp_check_act_status(struct drm_dp_mst_topology_mgr *mgr) 4760 { 4761 /* 4762 * There doesn't seem to be any recommended retry count or timeout in 4763 * the MST specification. Since some hubs have been observed to take 4764 * over 1 second to update their payload allocations under certain 4765 * conditions, we use a rather large timeout value of 3 seconds. 4766 */ 4767 return drm_dp_dpcd_poll_act_handled(mgr->aux, 3000); 4768 } 4769 EXPORT_SYMBOL(drm_dp_check_act_status); 4770 4771 /** 4772 * drm_dp_calc_pbn_mode() - Calculate the PBN for a mode. 4773 * @clock: dot clock 4774 * @bpp: bpp as .4 binary fixed point 4775 * 4776 * This uses the formula in the spec to calculate the PBN value for a mode. 4777 */ 4778 int drm_dp_calc_pbn_mode(int clock, int bpp) 4779 { 4780 /* 4781 * The unit of 54/64Mbytes/sec is an arbitrary unit chosen based on 4782 * common multiplier to render an integer PBN for all link rate/lane 4783 * counts combinations 4784 * calculate 4785 * peak_kbps = clock * bpp / 16 4786 * peak_kbps *= SSC overhead / 1000000 4787 * peak_kbps /= 8 convert to Kbytes 4788 * peak_kBps *= (64/54) / 1000 convert to PBN 4789 */ 4790 /* 4791 * TODO: Use the actual link and mode parameters to calculate 4792 * the overhead. For now it's assumed that these are 4793 * 4 link lanes, 4096 hactive pixels, which don't add any 4794 * significant data padding overhead and that there is no DSC 4795 * or FEC overhead. 4796 */ 4797 int overhead = drm_dp_bw_overhead(4, 4096, 0, bpp, 4798 DRM_DP_BW_OVERHEAD_MST | 4799 DRM_DP_BW_OVERHEAD_SSC_REF_CLK); 4800 4801 return DIV64_U64_ROUND_UP(mul_u32_u32(clock * bpp, 64 * overhead >> 4), 4802 1000000ULL * 8 * 54 * 1000); 4803 } 4804 EXPORT_SYMBOL(drm_dp_calc_pbn_mode); 4805 4806 /* we want to kick the TX after we've ack the up/down IRQs. */ 4807 static void drm_dp_mst_kick_tx(struct drm_dp_mst_topology_mgr *mgr) 4808 { 4809 queue_work(system_long_wq, &mgr->tx_work); 4810 } 4811 4812 /* 4813 * Helper function for parsing DP device types into convenient strings 4814 * for use with dp_mst_topology 4815 */ 4816 static const char *pdt_to_string(u8 pdt) 4817 { 4818 switch (pdt) { 4819 case DP_PEER_DEVICE_NONE: 4820 return "NONE"; 4821 case DP_PEER_DEVICE_SOURCE_OR_SST: 4822 return "SOURCE OR SST"; 4823 case DP_PEER_DEVICE_MST_BRANCHING: 4824 return "MST BRANCHING"; 4825 case DP_PEER_DEVICE_SST_SINK: 4826 return "SST SINK"; 4827 case DP_PEER_DEVICE_DP_LEGACY_CONV: 4828 return "DP LEGACY CONV"; 4829 default: 4830 return "ERR"; 4831 } 4832 } 4833 4834 static void drm_dp_mst_dump_mstb(struct seq_file *m, 4835 struct drm_dp_mst_branch *mstb) 4836 { 4837 struct drm_dp_mst_port *port; 4838 int tabs = mstb->lct; 4839 char prefix[10]; 4840 int i; 4841 4842 for (i = 0; i < tabs; i++) 4843 prefix[i] = '\t'; 4844 prefix[i] = '\0'; 4845 4846 seq_printf(m, "%smstb - [%p]: num_ports: %d\n", prefix, mstb, mstb->num_ports); 4847 list_for_each_entry(port, &mstb->ports, next) { 4848 seq_printf(m, "%sport %d - [%p] (%s - %s): ddps: %d, ldps: %d, sdp: %d/%d, fec: %s, conn: %p\n", 4849 prefix, 4850 port->port_num, 4851 port, 4852 port->input ? "input" : "output", 4853 pdt_to_string(port->pdt), 4854 port->ddps, 4855 port->ldps, 4856 port->num_sdp_streams, 4857 port->num_sdp_stream_sinks, 4858 port->fec_capable ? "true" : "false", 4859 port->connector); 4860 if (port->mstb) 4861 drm_dp_mst_dump_mstb(m, port->mstb); 4862 } 4863 } 4864 4865 #define DP_PAYLOAD_TABLE_SIZE 64 4866 4867 static bool dump_dp_payload_table(struct drm_dp_mst_topology_mgr *mgr, 4868 char *buf) 4869 { 4870 int i; 4871 4872 for (i = 0; i < DP_PAYLOAD_TABLE_SIZE; i += 16) { 4873 if (drm_dp_dpcd_read(mgr->aux, 4874 DP_PAYLOAD_TABLE_UPDATE_STATUS + i, 4875 &buf[i], 16) != 16) 4876 return false; 4877 } 4878 return true; 4879 } 4880 4881 static void fetch_monitor_name(struct drm_dp_mst_topology_mgr *mgr, 4882 struct drm_dp_mst_port *port, char *name, 4883 int namelen) 4884 { 4885 struct edid *mst_edid; 4886 4887 mst_edid = drm_dp_mst_get_edid(port->connector, mgr, port); 4888 drm_edid_get_monitor_name(mst_edid, name, namelen); 4889 kfree(mst_edid); 4890 } 4891 4892 /** 4893 * drm_dp_mst_dump_topology(): dump topology to seq file. 4894 * @m: seq_file to dump output to 4895 * @mgr: manager to dump current topology for. 4896 * 4897 * helper to dump MST topology to a seq file for debugfs. 4898 */ 4899 void drm_dp_mst_dump_topology(struct seq_file *m, 4900 struct drm_dp_mst_topology_mgr *mgr) 4901 { 4902 struct drm_dp_mst_topology_state *state; 4903 struct drm_dp_mst_atomic_payload *payload; 4904 int i, ret; 4905 4906 static const char *const status[] = { 4907 "None", 4908 "Local", 4909 "DFP", 4910 "Remote", 4911 }; 4912 4913 mutex_lock(&mgr->lock); 4914 if (mgr->mst_primary) 4915 drm_dp_mst_dump_mstb(m, mgr->mst_primary); 4916 4917 /* dump VCPIs */ 4918 mutex_unlock(&mgr->lock); 4919 4920 ret = drm_modeset_lock_single_interruptible(&mgr->base.lock); 4921 if (ret < 0) 4922 return; 4923 4924 state = to_drm_dp_mst_topology_state(mgr->base.state); 4925 seq_printf(m, "\n*** Atomic state info ***\n"); 4926 seq_printf(m, "payload_mask: %x, max_payloads: %d, start_slot: %u, pbn_div: %d\n", 4927 state->payload_mask, mgr->max_payloads, state->start_slot, 4928 dfixed_trunc(state->pbn_div)); 4929 4930 seq_printf(m, "\n| idx | port | vcpi | slots | pbn | dsc | status | sink name |\n"); 4931 for (i = 0; i < mgr->max_payloads; i++) { 4932 list_for_each_entry(payload, &state->payloads, next) { 4933 char name[14]; 4934 4935 if (payload->vcpi != i || payload->delete) 4936 continue; 4937 4938 fetch_monitor_name(mgr, payload->port, name, sizeof(name)); 4939 seq_printf(m, " %5d %6d %6d %02d - %02d %5d %5s %8s %19s\n", 4940 i, 4941 payload->port->port_num, 4942 payload->vcpi, 4943 payload->vc_start_slot, 4944 payload->vc_start_slot + payload->time_slots - 1, 4945 payload->pbn, 4946 payload->dsc_enabled ? "Y" : "N", 4947 status[payload->payload_allocation_status], 4948 (*name != 0) ? name : "Unknown"); 4949 } 4950 } 4951 4952 seq_printf(m, "\n*** DPCD Info ***\n"); 4953 mutex_lock(&mgr->lock); 4954 if (mgr->mst_primary) { 4955 u8 buf[DP_PAYLOAD_TABLE_SIZE]; 4956 int ret; 4957 4958 if (drm_dp_read_dpcd_caps(mgr->aux, buf) < 0) { 4959 seq_printf(m, "dpcd read failed\n"); 4960 goto out; 4961 } 4962 seq_printf(m, "dpcd: %*ph\n", DP_RECEIVER_CAP_SIZE, buf); 4963 4964 ret = drm_dp_dpcd_read(mgr->aux, DP_FAUX_CAP, buf, 2); 4965 if (ret != 2) { 4966 seq_printf(m, "faux/mst read failed\n"); 4967 goto out; 4968 } 4969 seq_printf(m, "faux/mst: %*ph\n", 2, buf); 4970 4971 ret = drm_dp_dpcd_read(mgr->aux, DP_MSTM_CTRL, buf, 1); 4972 if (ret != 1) { 4973 seq_printf(m, "mst ctrl read failed\n"); 4974 goto out; 4975 } 4976 seq_printf(m, "mst ctrl: %*ph\n", 1, buf); 4977 4978 /* dump the standard OUI branch header */ 4979 ret = drm_dp_dpcd_read(mgr->aux, DP_BRANCH_OUI, buf, DP_BRANCH_OUI_HEADER_SIZE); 4980 if (ret != DP_BRANCH_OUI_HEADER_SIZE) { 4981 seq_printf(m, "branch oui read failed\n"); 4982 goto out; 4983 } 4984 seq_printf(m, "branch oui: %*phN devid: ", 3, buf); 4985 4986 for (i = 0x3; i < 0x8 && buf[i]; i++) 4987 seq_putc(m, buf[i]); 4988 seq_printf(m, " revision: hw: %x.%x sw: %x.%x\n", 4989 buf[0x9] >> 4, buf[0x9] & 0xf, buf[0xa], buf[0xb]); 4990 if (dump_dp_payload_table(mgr, buf)) 4991 seq_printf(m, "payload table: %*ph\n", DP_PAYLOAD_TABLE_SIZE, buf); 4992 } 4993 4994 out: 4995 mutex_unlock(&mgr->lock); 4996 drm_modeset_unlock(&mgr->base.lock); 4997 } 4998 EXPORT_SYMBOL(drm_dp_mst_dump_topology); 4999 5000 static void drm_dp_tx_work(struct work_struct *work) 5001 { 5002 struct drm_dp_mst_topology_mgr *mgr = container_of(work, struct drm_dp_mst_topology_mgr, tx_work); 5003 5004 mutex_lock(&mgr->qlock); 5005 if (!list_empty(&mgr->tx_msg_downq)) 5006 process_single_down_tx_qlock(mgr); 5007 mutex_unlock(&mgr->qlock); 5008 } 5009 5010 static inline void 5011 drm_dp_delayed_destroy_port(struct drm_dp_mst_port *port) 5012 { 5013 drm_dp_port_set_pdt(port, DP_PEER_DEVICE_NONE, port->mcs); 5014 5015 if (port->connector) { 5016 drm_connector_unregister(port->connector); 5017 drm_connector_put(port->connector); 5018 } 5019 5020 drm_dp_mst_put_port_malloc(port); 5021 } 5022 5023 static inline void 5024 drm_dp_delayed_destroy_mstb(struct drm_dp_mst_branch *mstb) 5025 { 5026 struct drm_dp_mst_topology_mgr *mgr = mstb->mgr; 5027 struct drm_dp_mst_port *port, *port_tmp; 5028 struct drm_dp_sideband_msg_tx *txmsg, *txmsg_tmp; 5029 bool wake_tx = false; 5030 5031 mutex_lock(&mgr->lock); 5032 list_for_each_entry_safe(port, port_tmp, &mstb->ports, next) { 5033 list_del(&port->next); 5034 drm_dp_mst_topology_put_port(port); 5035 } 5036 mutex_unlock(&mgr->lock); 5037 5038 /* drop any tx slot msg */ 5039 mutex_lock(&mstb->mgr->qlock); 5040 list_for_each_entry_safe(txmsg, txmsg_tmp, &mgr->tx_msg_downq, next) { 5041 if (txmsg->dst != mstb) 5042 continue; 5043 5044 txmsg->state = DRM_DP_SIDEBAND_TX_TIMEOUT; 5045 list_del(&txmsg->next); 5046 wake_tx = true; 5047 } 5048 mutex_unlock(&mstb->mgr->qlock); 5049 5050 if (wake_tx) 5051 wake_up_all(&mstb->mgr->tx_waitq); 5052 5053 drm_dp_mst_put_mstb_malloc(mstb); 5054 } 5055 5056 static void drm_dp_delayed_destroy_work(struct work_struct *work) 5057 { 5058 struct drm_dp_mst_topology_mgr *mgr = 5059 container_of(work, struct drm_dp_mst_topology_mgr, 5060 delayed_destroy_work); 5061 bool send_hotplug = false, go_again; 5062 5063 /* 5064 * Not a regular list traverse as we have to drop the destroy 5065 * connector lock before destroying the mstb/port, to avoid AB->BA 5066 * ordering between this lock and the config mutex. 5067 */ 5068 do { 5069 go_again = false; 5070 5071 for (;;) { 5072 struct drm_dp_mst_branch *mstb; 5073 5074 mutex_lock(&mgr->delayed_destroy_lock); 5075 mstb = list_first_entry_or_null(&mgr->destroy_branch_device_list, 5076 struct drm_dp_mst_branch, 5077 destroy_next); 5078 if (mstb) 5079 list_del(&mstb->destroy_next); 5080 mutex_unlock(&mgr->delayed_destroy_lock); 5081 5082 if (!mstb) 5083 break; 5084 5085 drm_dp_delayed_destroy_mstb(mstb); 5086 go_again = true; 5087 } 5088 5089 for (;;) { 5090 struct drm_dp_mst_port *port; 5091 5092 mutex_lock(&mgr->delayed_destroy_lock); 5093 port = list_first_entry_or_null(&mgr->destroy_port_list, 5094 struct drm_dp_mst_port, 5095 next); 5096 if (port) 5097 list_del(&port->next); 5098 mutex_unlock(&mgr->delayed_destroy_lock); 5099 5100 if (!port) 5101 break; 5102 5103 drm_dp_delayed_destroy_port(port); 5104 send_hotplug = true; 5105 go_again = true; 5106 } 5107 } while (go_again); 5108 5109 if (send_hotplug) 5110 drm_kms_helper_hotplug_event(mgr->dev); 5111 } 5112 5113 static struct drm_private_state * 5114 drm_dp_mst_duplicate_state(struct drm_private_obj *obj) 5115 { 5116 struct drm_dp_mst_topology_state *state, *old_state = 5117 to_dp_mst_topology_state(obj->state); 5118 struct drm_dp_mst_atomic_payload *pos, *payload; 5119 5120 state = kmemdup(old_state, sizeof(*state), GFP_KERNEL); 5121 if (!state) 5122 return NULL; 5123 5124 __drm_atomic_helper_private_obj_duplicate_state(obj, &state->base); 5125 5126 INIT_LIST_HEAD(&state->payloads); 5127 state->commit_deps = NULL; 5128 state->num_commit_deps = 0; 5129 state->pending_crtc_mask = 0; 5130 5131 list_for_each_entry(pos, &old_state->payloads, next) { 5132 /* Prune leftover freed timeslot allocations */ 5133 if (pos->delete) 5134 continue; 5135 5136 payload = kmemdup(pos, sizeof(*payload), GFP_KERNEL); 5137 if (!payload) 5138 goto fail; 5139 5140 drm_dp_mst_get_port_malloc(payload->port); 5141 list_add(&payload->next, &state->payloads); 5142 } 5143 5144 return &state->base; 5145 5146 fail: 5147 list_for_each_entry_safe(pos, payload, &state->payloads, next) { 5148 drm_dp_mst_put_port_malloc(pos->port); 5149 kfree(pos); 5150 } 5151 kfree(state); 5152 5153 return NULL; 5154 } 5155 5156 static void drm_dp_mst_destroy_state(struct drm_private_obj *obj, 5157 struct drm_private_state *state) 5158 { 5159 struct drm_dp_mst_topology_state *mst_state = 5160 to_dp_mst_topology_state(state); 5161 struct drm_dp_mst_atomic_payload *pos, *tmp; 5162 int i; 5163 5164 list_for_each_entry_safe(pos, tmp, &mst_state->payloads, next) { 5165 /* We only keep references to ports with active payloads */ 5166 if (!pos->delete) 5167 drm_dp_mst_put_port_malloc(pos->port); 5168 kfree(pos); 5169 } 5170 5171 for (i = 0; i < mst_state->num_commit_deps; i++) 5172 drm_crtc_commit_put(mst_state->commit_deps[i]); 5173 5174 kfree(mst_state->commit_deps); 5175 kfree(mst_state); 5176 } 5177 5178 static bool drm_dp_mst_port_downstream_of_branch(struct drm_dp_mst_port *port, 5179 struct drm_dp_mst_branch *branch) 5180 { 5181 while (port->parent) { 5182 if (port->parent == branch) 5183 return true; 5184 5185 if (port->parent->port_parent) 5186 port = port->parent->port_parent; 5187 else 5188 break; 5189 } 5190 return false; 5191 } 5192 5193 static bool 5194 drm_dp_mst_port_downstream_of_parent_locked(struct drm_dp_mst_topology_mgr *mgr, 5195 struct drm_dp_mst_port *port, 5196 struct drm_dp_mst_port *parent) 5197 { 5198 if (!mgr->mst_primary) 5199 return false; 5200 5201 port = drm_dp_mst_topology_get_port_validated_locked(mgr->mst_primary, 5202 port); 5203 if (!port) 5204 return false; 5205 5206 if (!parent) 5207 return true; 5208 5209 parent = drm_dp_mst_topology_get_port_validated_locked(mgr->mst_primary, 5210 parent); 5211 if (!parent) 5212 return false; 5213 5214 if (!parent->mstb) 5215 return false; 5216 5217 return drm_dp_mst_port_downstream_of_branch(port, parent->mstb); 5218 } 5219 5220 /** 5221 * drm_dp_mst_port_downstream_of_parent - check if a port is downstream of a parent port 5222 * @mgr: MST topology manager 5223 * @port: the port being looked up 5224 * @parent: the parent port 5225 * 5226 * The function returns %true if @port is downstream of @parent. If @parent is 5227 * %NULL - denoting the root port - the function returns %true if @port is in 5228 * @mgr's topology. 5229 */ 5230 bool 5231 drm_dp_mst_port_downstream_of_parent(struct drm_dp_mst_topology_mgr *mgr, 5232 struct drm_dp_mst_port *port, 5233 struct drm_dp_mst_port *parent) 5234 { 5235 bool ret; 5236 5237 mutex_lock(&mgr->lock); 5238 ret = drm_dp_mst_port_downstream_of_parent_locked(mgr, port, parent); 5239 mutex_unlock(&mgr->lock); 5240 5241 return ret; 5242 } 5243 EXPORT_SYMBOL(drm_dp_mst_port_downstream_of_parent); 5244 5245 static int 5246 drm_dp_mst_atomic_check_port_bw_limit(struct drm_dp_mst_port *port, 5247 struct drm_dp_mst_topology_state *state, 5248 struct drm_dp_mst_port **failing_port); 5249 5250 static int 5251 drm_dp_mst_atomic_check_mstb_bw_limit(struct drm_dp_mst_branch *mstb, 5252 struct drm_dp_mst_topology_state *state, 5253 struct drm_dp_mst_port **failing_port) 5254 { 5255 struct drm_dp_mst_atomic_payload *payload; 5256 struct drm_dp_mst_port *port; 5257 int pbn_used = 0, ret; 5258 bool found = false; 5259 5260 /* Check that we have at least one port in our state that's downstream 5261 * of this branch, otherwise we can skip this branch 5262 */ 5263 list_for_each_entry(payload, &state->payloads, next) { 5264 if (!payload->pbn || 5265 !drm_dp_mst_port_downstream_of_branch(payload->port, mstb)) 5266 continue; 5267 5268 found = true; 5269 break; 5270 } 5271 if (!found) 5272 return 0; 5273 5274 if (mstb->port_parent) 5275 drm_dbg_atomic(mstb->mgr->dev, 5276 "[MSTB:%p] [MST PORT:%p] Checking bandwidth limits on [MSTB:%p]\n", 5277 mstb->port_parent->parent, mstb->port_parent, mstb); 5278 else 5279 drm_dbg_atomic(mstb->mgr->dev, "[MSTB:%p] Checking bandwidth limits\n", mstb); 5280 5281 list_for_each_entry(port, &mstb->ports, next) { 5282 ret = drm_dp_mst_atomic_check_port_bw_limit(port, state, failing_port); 5283 if (ret < 0) 5284 return ret; 5285 5286 pbn_used += ret; 5287 } 5288 5289 return pbn_used; 5290 } 5291 5292 static int 5293 drm_dp_mst_atomic_check_port_bw_limit(struct drm_dp_mst_port *port, 5294 struct drm_dp_mst_topology_state *state, 5295 struct drm_dp_mst_port **failing_port) 5296 { 5297 struct drm_dp_mst_atomic_payload *payload; 5298 int pbn_used = 0; 5299 5300 if (port->pdt == DP_PEER_DEVICE_NONE) 5301 return 0; 5302 5303 if (drm_dp_mst_is_end_device(port->pdt, port->mcs)) { 5304 payload = drm_atomic_get_mst_payload_state(state, port); 5305 if (!payload) 5306 return 0; 5307 5308 /* 5309 * This could happen if the sink deasserted its HPD line, but 5310 * the branch device still reports it as attached (PDT != NONE). 5311 */ 5312 if (!port->full_pbn) { 5313 drm_dbg_atomic(port->mgr->dev, 5314 "[MSTB:%p] [MST PORT:%p] no BW available for the port\n", 5315 port->parent, port); 5316 *failing_port = port; 5317 return -EINVAL; 5318 } 5319 5320 pbn_used = payload->pbn; 5321 } else { 5322 pbn_used = drm_dp_mst_atomic_check_mstb_bw_limit(port->mstb, 5323 state, 5324 failing_port); 5325 if (pbn_used <= 0) 5326 return pbn_used; 5327 } 5328 5329 if (pbn_used > port->full_pbn) { 5330 drm_dbg_atomic(port->mgr->dev, 5331 "[MSTB:%p] [MST PORT:%p] required PBN of %d exceeds port limit of %d\n", 5332 port->parent, port, pbn_used, port->full_pbn); 5333 *failing_port = port; 5334 return -ENOSPC; 5335 } 5336 5337 drm_dbg_atomic(port->mgr->dev, "[MSTB:%p] [MST PORT:%p] uses %d out of %d PBN\n", 5338 port->parent, port, pbn_used, port->full_pbn); 5339 5340 return pbn_used; 5341 } 5342 5343 static inline int 5344 drm_dp_mst_atomic_check_payload_alloc_limits(struct drm_dp_mst_topology_mgr *mgr, 5345 struct drm_dp_mst_topology_state *mst_state) 5346 { 5347 struct drm_dp_mst_atomic_payload *payload; 5348 int avail_slots = mst_state->total_avail_slots, payload_count = 0; 5349 5350 list_for_each_entry(payload, &mst_state->payloads, next) { 5351 /* Releasing payloads is always OK-even if the port is gone */ 5352 if (payload->delete) { 5353 drm_dbg_atomic(mgr->dev, "[MST PORT:%p] releases all time slots\n", 5354 payload->port); 5355 continue; 5356 } 5357 5358 drm_dbg_atomic(mgr->dev, "[MST PORT:%p] requires %d time slots\n", 5359 payload->port, payload->time_slots); 5360 5361 avail_slots -= payload->time_slots; 5362 if (avail_slots < 0) { 5363 drm_dbg_atomic(mgr->dev, 5364 "[MST PORT:%p] not enough time slots in mst state %p (avail=%d)\n", 5365 payload->port, mst_state, avail_slots + payload->time_slots); 5366 return -ENOSPC; 5367 } 5368 5369 if (++payload_count > mgr->max_payloads) { 5370 drm_dbg_atomic(mgr->dev, 5371 "[MST MGR:%p] state %p has too many payloads (max=%d)\n", 5372 mgr, mst_state, mgr->max_payloads); 5373 return -EINVAL; 5374 } 5375 5376 /* Assign a VCPI */ 5377 if (!payload->vcpi) { 5378 payload->vcpi = ffz(mst_state->payload_mask) + 1; 5379 drm_dbg_atomic(mgr->dev, "[MST PORT:%p] assigned VCPI #%d\n", 5380 payload->port, payload->vcpi); 5381 mst_state->payload_mask |= BIT(payload->vcpi - 1); 5382 } 5383 } 5384 5385 if (!payload_count) 5386 mst_state->pbn_div.full = dfixed_const(0); 5387 5388 drm_dbg_atomic(mgr->dev, "[MST MGR:%p] mst state %p TU pbn_div=%d avail=%d used=%d\n", 5389 mgr, mst_state, dfixed_trunc(mst_state->pbn_div), avail_slots, 5390 mst_state->total_avail_slots - avail_slots); 5391 5392 return 0; 5393 } 5394 5395 /** 5396 * drm_dp_mst_add_affected_dsc_crtcs 5397 * @state: Pointer to the new struct drm_dp_mst_topology_state 5398 * @mgr: MST topology manager 5399 * 5400 * Whenever there is a change in mst topology 5401 * DSC configuration would have to be recalculated 5402 * therefore we need to trigger modeset on all affected 5403 * CRTCs in that topology 5404 * 5405 * See also: 5406 * drm_dp_mst_atomic_enable_dsc() 5407 */ 5408 int drm_dp_mst_add_affected_dsc_crtcs(struct drm_atomic_state *state, struct drm_dp_mst_topology_mgr *mgr) 5409 { 5410 struct drm_dp_mst_topology_state *mst_state; 5411 struct drm_dp_mst_atomic_payload *pos; 5412 struct drm_connector *connector; 5413 struct drm_connector_state *conn_state; 5414 struct drm_crtc *crtc; 5415 struct drm_crtc_state *crtc_state; 5416 5417 mst_state = drm_atomic_get_mst_topology_state(state, mgr); 5418 5419 if (IS_ERR(mst_state)) 5420 return PTR_ERR(mst_state); 5421 5422 list_for_each_entry(pos, &mst_state->payloads, next) { 5423 5424 connector = pos->port->connector; 5425 5426 if (!connector) 5427 return -EINVAL; 5428 5429 conn_state = drm_atomic_get_connector_state(state, connector); 5430 5431 if (IS_ERR(conn_state)) 5432 return PTR_ERR(conn_state); 5433 5434 crtc = conn_state->crtc; 5435 5436 if (!crtc) 5437 continue; 5438 5439 if (!drm_dp_mst_dsc_aux_for_port(pos->port)) 5440 continue; 5441 5442 crtc_state = drm_atomic_get_crtc_state(mst_state->base.state, crtc); 5443 5444 if (IS_ERR(crtc_state)) 5445 return PTR_ERR(crtc_state); 5446 5447 drm_dbg_atomic(mgr->dev, "[MST MGR:%p] Setting mode_changed flag on CRTC %p\n", 5448 mgr, crtc); 5449 5450 crtc_state->mode_changed = true; 5451 } 5452 return 0; 5453 } 5454 EXPORT_SYMBOL(drm_dp_mst_add_affected_dsc_crtcs); 5455 5456 /** 5457 * drm_dp_mst_atomic_enable_dsc - Set DSC Enable Flag to On/Off 5458 * @state: Pointer to the new drm_atomic_state 5459 * @port: Pointer to the affected MST Port 5460 * @pbn: Newly recalculated bw required for link with DSC enabled 5461 * @enable: Boolean flag to enable or disable DSC on the port 5462 * 5463 * This function enables DSC on the given Port 5464 * by recalculating its vcpi from pbn provided 5465 * and sets dsc_enable flag to keep track of which 5466 * ports have DSC enabled 5467 * 5468 */ 5469 int drm_dp_mst_atomic_enable_dsc(struct drm_atomic_state *state, 5470 struct drm_dp_mst_port *port, 5471 int pbn, bool enable) 5472 { 5473 struct drm_dp_mst_topology_state *mst_state; 5474 struct drm_dp_mst_atomic_payload *payload; 5475 int time_slots = 0; 5476 5477 mst_state = drm_atomic_get_mst_topology_state(state, port->mgr); 5478 if (IS_ERR(mst_state)) 5479 return PTR_ERR(mst_state); 5480 5481 payload = drm_atomic_get_mst_payload_state(mst_state, port); 5482 if (!payload) { 5483 drm_dbg_atomic(state->dev, 5484 "[MST PORT:%p] Couldn't find payload in mst state %p\n", 5485 port, mst_state); 5486 return -EINVAL; 5487 } 5488 5489 if (payload->dsc_enabled == enable) { 5490 drm_dbg_atomic(state->dev, 5491 "[MST PORT:%p] DSC flag is already set to %d, returning %d time slots\n", 5492 port, enable, payload->time_slots); 5493 time_slots = payload->time_slots; 5494 } 5495 5496 if (enable) { 5497 time_slots = drm_dp_atomic_find_time_slots(state, port->mgr, port, pbn); 5498 drm_dbg_atomic(state->dev, 5499 "[MST PORT:%p] Enabling DSC flag, reallocating %d time slots on the port\n", 5500 port, time_slots); 5501 if (time_slots < 0) 5502 return -EINVAL; 5503 } 5504 5505 payload->dsc_enabled = enable; 5506 5507 return time_slots; 5508 } 5509 EXPORT_SYMBOL(drm_dp_mst_atomic_enable_dsc); 5510 5511 /** 5512 * drm_dp_mst_atomic_check_mgr - Check the atomic state of an MST topology manager 5513 * @state: The global atomic state 5514 * @mgr: Manager to check 5515 * @mst_state: The MST atomic state for @mgr 5516 * @failing_port: Returns the port with a BW limitation 5517 * 5518 * Checks the given MST manager's topology state for an atomic update to ensure 5519 * that it's valid. This includes checking whether there's enough bandwidth to 5520 * support the new timeslot allocations in the atomic update. 5521 * 5522 * Any atomic drivers supporting DP MST must make sure to call this or 5523 * the drm_dp_mst_atomic_check() function after checking the rest of their state 5524 * in their &drm_mode_config_funcs.atomic_check() callback. 5525 * 5526 * See also: 5527 * drm_dp_mst_atomic_check() 5528 * drm_dp_atomic_find_time_slots() 5529 * drm_dp_atomic_release_time_slots() 5530 * 5531 * Returns: 5532 * - 0 if the new state is valid 5533 * - %-ENOSPC, if the new state is invalid, because of BW limitation 5534 * @failing_port is set to: 5535 * 5536 * - The non-root port where a BW limit check failed 5537 * with all the ports downstream of @failing_port passing 5538 * the BW limit check. 5539 * The returned port pointer is valid until at least 5540 * one payload downstream of it exists. 5541 * - %NULL if the BW limit check failed at the root port 5542 * with all the ports downstream of the root port passing 5543 * the BW limit check. 5544 * 5545 * - %-EINVAL, if the new state is invalid, because the root port has 5546 * too many payloads. 5547 */ 5548 int drm_dp_mst_atomic_check_mgr(struct drm_atomic_state *state, 5549 struct drm_dp_mst_topology_mgr *mgr, 5550 struct drm_dp_mst_topology_state *mst_state, 5551 struct drm_dp_mst_port **failing_port) 5552 { 5553 int ret; 5554 5555 *failing_port = NULL; 5556 5557 if (!mgr->mst_state) 5558 return 0; 5559 5560 mutex_lock(&mgr->lock); 5561 ret = drm_dp_mst_atomic_check_mstb_bw_limit(mgr->mst_primary, 5562 mst_state, 5563 failing_port); 5564 mutex_unlock(&mgr->lock); 5565 5566 if (ret < 0) 5567 return ret; 5568 5569 return drm_dp_mst_atomic_check_payload_alloc_limits(mgr, mst_state); 5570 } 5571 EXPORT_SYMBOL(drm_dp_mst_atomic_check_mgr); 5572 5573 /** 5574 * drm_dp_mst_atomic_check - Check that the new state of an MST topology in an 5575 * atomic update is valid 5576 * @state: Pointer to the new &struct drm_dp_mst_topology_state 5577 * 5578 * Checks the given topology state for an atomic update to ensure that it's 5579 * valid, calling drm_dp_mst_atomic_check_mgr() for all MST manager in the 5580 * atomic state. This includes checking whether there's enough bandwidth to 5581 * support the new timeslot allocations in the atomic update. 5582 * 5583 * Any atomic drivers supporting DP MST must make sure to call this after 5584 * checking the rest of their state in their 5585 * &drm_mode_config_funcs.atomic_check() callback. 5586 * 5587 * See also: 5588 * drm_dp_mst_atomic_check_mgr() 5589 * drm_dp_atomic_find_time_slots() 5590 * drm_dp_atomic_release_time_slots() 5591 * 5592 * Returns: 5593 * 0 if the new state is valid, negative error code otherwise. 5594 */ 5595 int drm_dp_mst_atomic_check(struct drm_atomic_state *state) 5596 { 5597 struct drm_dp_mst_topology_mgr *mgr; 5598 struct drm_dp_mst_topology_state *mst_state; 5599 int i, ret = 0; 5600 5601 for_each_new_mst_mgr_in_state(state, mgr, mst_state, i) { 5602 struct drm_dp_mst_port *tmp_port; 5603 5604 ret = drm_dp_mst_atomic_check_mgr(state, mgr, mst_state, &tmp_port); 5605 if (ret) 5606 break; 5607 } 5608 5609 return ret; 5610 } 5611 EXPORT_SYMBOL(drm_dp_mst_atomic_check); 5612 5613 const struct drm_private_state_funcs drm_dp_mst_topology_state_funcs = { 5614 .atomic_duplicate_state = drm_dp_mst_duplicate_state, 5615 .atomic_destroy_state = drm_dp_mst_destroy_state, 5616 }; 5617 EXPORT_SYMBOL(drm_dp_mst_topology_state_funcs); 5618 5619 /** 5620 * drm_atomic_get_mst_topology_state: get MST topology state 5621 * @state: global atomic state 5622 * @mgr: MST topology manager, also the private object in this case 5623 * 5624 * This function wraps drm_atomic_get_priv_obj_state() passing in the MST atomic 5625 * state vtable so that the private object state returned is that of a MST 5626 * topology object. 5627 * 5628 * RETURNS: 5629 * The MST topology state or error pointer. 5630 */ 5631 struct drm_dp_mst_topology_state *drm_atomic_get_mst_topology_state(struct drm_atomic_state *state, 5632 struct drm_dp_mst_topology_mgr *mgr) 5633 { 5634 return to_dp_mst_topology_state(drm_atomic_get_private_obj_state(state, &mgr->base)); 5635 } 5636 EXPORT_SYMBOL(drm_atomic_get_mst_topology_state); 5637 5638 /** 5639 * drm_atomic_get_old_mst_topology_state: get old MST topology state in atomic state, if any 5640 * @state: global atomic state 5641 * @mgr: MST topology manager, also the private object in this case 5642 * 5643 * This function wraps drm_atomic_get_old_private_obj_state() passing in the MST atomic 5644 * state vtable so that the private object state returned is that of a MST 5645 * topology object. 5646 * 5647 * Returns: 5648 * The old MST topology state, or NULL if there's no topology state for this MST mgr 5649 * in the global atomic state 5650 */ 5651 struct drm_dp_mst_topology_state * 5652 drm_atomic_get_old_mst_topology_state(struct drm_atomic_state *state, 5653 struct drm_dp_mst_topology_mgr *mgr) 5654 { 5655 struct drm_private_state *old_priv_state = 5656 drm_atomic_get_old_private_obj_state(state, &mgr->base); 5657 5658 return old_priv_state ? to_dp_mst_topology_state(old_priv_state) : NULL; 5659 } 5660 EXPORT_SYMBOL(drm_atomic_get_old_mst_topology_state); 5661 5662 /** 5663 * drm_atomic_get_new_mst_topology_state: get new MST topology state in atomic state, if any 5664 * @state: global atomic state 5665 * @mgr: MST topology manager, also the private object in this case 5666 * 5667 * This function wraps drm_atomic_get_new_private_obj_state() passing in the MST atomic 5668 * state vtable so that the private object state returned is that of a MST 5669 * topology object. 5670 * 5671 * Returns: 5672 * The new MST topology state, or NULL if there's no topology state for this MST mgr 5673 * in the global atomic state 5674 */ 5675 struct drm_dp_mst_topology_state * 5676 drm_atomic_get_new_mst_topology_state(struct drm_atomic_state *state, 5677 struct drm_dp_mst_topology_mgr *mgr) 5678 { 5679 struct drm_private_state *new_priv_state = 5680 drm_atomic_get_new_private_obj_state(state, &mgr->base); 5681 5682 return new_priv_state ? to_dp_mst_topology_state(new_priv_state) : NULL; 5683 } 5684 EXPORT_SYMBOL(drm_atomic_get_new_mst_topology_state); 5685 5686 /** 5687 * drm_dp_mst_topology_mgr_init - initialise a topology manager 5688 * @mgr: manager struct to initialise 5689 * @dev: device providing this structure - for i2c addition. 5690 * @aux: DP helper aux channel to talk to this device 5691 * @max_dpcd_transaction_bytes: hw specific DPCD transaction limit 5692 * @max_payloads: maximum number of payloads this GPU can source 5693 * @conn_base_id: the connector object ID the MST device is connected to. 5694 * 5695 * Return 0 for success, or negative error code on failure 5696 */ 5697 int drm_dp_mst_topology_mgr_init(struct drm_dp_mst_topology_mgr *mgr, 5698 struct drm_device *dev, struct drm_dp_aux *aux, 5699 int max_dpcd_transaction_bytes, int max_payloads, 5700 int conn_base_id) 5701 { 5702 struct drm_dp_mst_topology_state *mst_state; 5703 5704 mutex_init(&mgr->lock); 5705 mutex_init(&mgr->qlock); 5706 mutex_init(&mgr->delayed_destroy_lock); 5707 mutex_init(&mgr->up_req_lock); 5708 mutex_init(&mgr->probe_lock); 5709 #if IS_ENABLED(CONFIG_DRM_DEBUG_DP_MST_TOPOLOGY_REFS) 5710 mutex_init(&mgr->topology_ref_history_lock); 5711 stack_depot_init(); 5712 #endif 5713 INIT_LIST_HEAD(&mgr->tx_msg_downq); 5714 INIT_LIST_HEAD(&mgr->destroy_port_list); 5715 INIT_LIST_HEAD(&mgr->destroy_branch_device_list); 5716 INIT_LIST_HEAD(&mgr->up_req_list); 5717 5718 /* 5719 * delayed_destroy_work will be queued on a dedicated WQ, so that any 5720 * requeuing will be also flushed when deiniting the topology manager. 5721 */ 5722 mgr->delayed_destroy_wq = alloc_ordered_workqueue("drm_dp_mst_wq", 0); 5723 if (mgr->delayed_destroy_wq == NULL) 5724 return -ENOMEM; 5725 5726 INIT_WORK(&mgr->work, drm_dp_mst_link_probe_work); 5727 INIT_WORK(&mgr->tx_work, drm_dp_tx_work); 5728 INIT_WORK(&mgr->delayed_destroy_work, drm_dp_delayed_destroy_work); 5729 INIT_WORK(&mgr->up_req_work, drm_dp_mst_up_req_work); 5730 init_waitqueue_head(&mgr->tx_waitq); 5731 mgr->dev = dev; 5732 mgr->aux = aux; 5733 mgr->max_dpcd_transaction_bytes = max_dpcd_transaction_bytes; 5734 mgr->max_payloads = max_payloads; 5735 mgr->conn_base_id = conn_base_id; 5736 5737 mst_state = kzalloc(sizeof(*mst_state), GFP_KERNEL); 5738 if (mst_state == NULL) 5739 return -ENOMEM; 5740 5741 mst_state->total_avail_slots = 63; 5742 mst_state->start_slot = 1; 5743 5744 mst_state->mgr = mgr; 5745 INIT_LIST_HEAD(&mst_state->payloads); 5746 5747 drm_atomic_private_obj_init(dev, &mgr->base, 5748 &mst_state->base, 5749 &drm_dp_mst_topology_state_funcs); 5750 5751 return 0; 5752 } 5753 EXPORT_SYMBOL(drm_dp_mst_topology_mgr_init); 5754 5755 /** 5756 * drm_dp_mst_topology_mgr_destroy() - destroy topology manager. 5757 * @mgr: manager to destroy 5758 */ 5759 void drm_dp_mst_topology_mgr_destroy(struct drm_dp_mst_topology_mgr *mgr) 5760 { 5761 drm_dp_mst_topology_mgr_set_mst(mgr, false); 5762 flush_work(&mgr->work); 5763 /* The following will also drain any requeued work on the WQ. */ 5764 if (mgr->delayed_destroy_wq) { 5765 destroy_workqueue(mgr->delayed_destroy_wq); 5766 mgr->delayed_destroy_wq = NULL; 5767 } 5768 mgr->dev = NULL; 5769 mgr->aux = NULL; 5770 drm_atomic_private_obj_fini(&mgr->base); 5771 mgr->funcs = NULL; 5772 5773 mutex_destroy(&mgr->delayed_destroy_lock); 5774 mutex_destroy(&mgr->qlock); 5775 mutex_destroy(&mgr->lock); 5776 mutex_destroy(&mgr->up_req_lock); 5777 mutex_destroy(&mgr->probe_lock); 5778 #if IS_ENABLED(CONFIG_DRM_DEBUG_DP_MST_TOPOLOGY_REFS) 5779 mutex_destroy(&mgr->topology_ref_history_lock); 5780 #endif 5781 } 5782 EXPORT_SYMBOL(drm_dp_mst_topology_mgr_destroy); 5783 5784 static bool remote_i2c_read_ok(const struct i2c_msg msgs[], int num) 5785 { 5786 int i; 5787 5788 if (num - 1 > DP_REMOTE_I2C_READ_MAX_TRANSACTIONS) 5789 return false; 5790 5791 for (i = 0; i < num - 1; i++) { 5792 if (msgs[i].flags & I2C_M_RD || 5793 msgs[i].len > 0xff) 5794 return false; 5795 } 5796 5797 return msgs[num - 1].flags & I2C_M_RD && 5798 msgs[num - 1].len <= 0xff; 5799 } 5800 5801 static bool remote_i2c_write_ok(const struct i2c_msg msgs[], int num) 5802 { 5803 int i; 5804 5805 for (i = 0; i < num - 1; i++) { 5806 if (msgs[i].flags & I2C_M_RD || !(msgs[i].flags & I2C_M_STOP) || 5807 msgs[i].len > 0xff) 5808 return false; 5809 } 5810 5811 return !(msgs[num - 1].flags & I2C_M_RD) && msgs[num - 1].len <= 0xff; 5812 } 5813 5814 static int drm_dp_mst_i2c_read(struct drm_dp_mst_branch *mstb, 5815 struct drm_dp_mst_port *port, 5816 struct i2c_msg *msgs, int num) 5817 { 5818 struct drm_dp_mst_topology_mgr *mgr = port->mgr; 5819 unsigned int i; 5820 struct drm_dp_sideband_msg_req_body msg; 5821 struct drm_dp_sideband_msg_tx *txmsg = NULL; 5822 int ret; 5823 5824 memset(&msg, 0, sizeof(msg)); 5825 msg.req_type = DP_REMOTE_I2C_READ; 5826 msg.u.i2c_read.num_transactions = num - 1; 5827 msg.u.i2c_read.port_number = port->port_num; 5828 for (i = 0; i < num - 1; i++) { 5829 msg.u.i2c_read.transactions[i].i2c_dev_id = msgs[i].addr; 5830 msg.u.i2c_read.transactions[i].num_bytes = msgs[i].len; 5831 msg.u.i2c_read.transactions[i].bytes = msgs[i].buf; 5832 msg.u.i2c_read.transactions[i].no_stop_bit = !(msgs[i].flags & I2C_M_STOP); 5833 } 5834 msg.u.i2c_read.read_i2c_device_id = msgs[num - 1].addr; 5835 msg.u.i2c_read.num_bytes_read = msgs[num - 1].len; 5836 5837 txmsg = kzalloc(sizeof(*txmsg), GFP_KERNEL); 5838 if (!txmsg) { 5839 ret = -ENOMEM; 5840 goto out; 5841 } 5842 5843 txmsg->dst = mstb; 5844 drm_dp_encode_sideband_req(&msg, txmsg); 5845 5846 drm_dp_queue_down_tx(mgr, txmsg); 5847 5848 ret = drm_dp_mst_wait_tx_reply(mstb, txmsg); 5849 if (ret > 0) { 5850 5851 if (txmsg->reply.reply_type == DP_SIDEBAND_REPLY_NAK) { 5852 ret = -EREMOTEIO; 5853 goto out; 5854 } 5855 if (txmsg->reply.u.remote_i2c_read_ack.num_bytes != msgs[num - 1].len) { 5856 ret = -EIO; 5857 goto out; 5858 } 5859 memcpy(msgs[num - 1].buf, txmsg->reply.u.remote_i2c_read_ack.bytes, msgs[num - 1].len); 5860 ret = num; 5861 } 5862 out: 5863 kfree(txmsg); 5864 return ret; 5865 } 5866 5867 static int drm_dp_mst_i2c_write(struct drm_dp_mst_branch *mstb, 5868 struct drm_dp_mst_port *port, 5869 struct i2c_msg *msgs, int num) 5870 { 5871 struct drm_dp_mst_topology_mgr *mgr = port->mgr; 5872 unsigned int i; 5873 struct drm_dp_sideband_msg_req_body msg; 5874 struct drm_dp_sideband_msg_tx *txmsg = NULL; 5875 int ret; 5876 5877 txmsg = kzalloc(sizeof(*txmsg), GFP_KERNEL); 5878 if (!txmsg) { 5879 ret = -ENOMEM; 5880 goto out; 5881 } 5882 for (i = 0; i < num; i++) { 5883 memset(&msg, 0, sizeof(msg)); 5884 msg.req_type = DP_REMOTE_I2C_WRITE; 5885 msg.u.i2c_write.port_number = port->port_num; 5886 msg.u.i2c_write.write_i2c_device_id = msgs[i].addr; 5887 msg.u.i2c_write.num_bytes = msgs[i].len; 5888 msg.u.i2c_write.bytes = msgs[i].buf; 5889 5890 memset(txmsg, 0, sizeof(*txmsg)); 5891 txmsg->dst = mstb; 5892 5893 drm_dp_encode_sideband_req(&msg, txmsg); 5894 drm_dp_queue_down_tx(mgr, txmsg); 5895 5896 ret = drm_dp_mst_wait_tx_reply(mstb, txmsg); 5897 if (ret > 0) { 5898 if (txmsg->reply.reply_type == DP_SIDEBAND_REPLY_NAK) { 5899 ret = -EREMOTEIO; 5900 goto out; 5901 } 5902 } else { 5903 goto out; 5904 } 5905 } 5906 ret = num; 5907 out: 5908 kfree(txmsg); 5909 return ret; 5910 } 5911 5912 /* I2C device */ 5913 static int drm_dp_mst_i2c_xfer(struct i2c_adapter *adapter, 5914 struct i2c_msg *msgs, int num) 5915 { 5916 struct drm_dp_aux *aux = adapter->algo_data; 5917 struct drm_dp_mst_port *port = 5918 container_of(aux, struct drm_dp_mst_port, aux); 5919 struct drm_dp_mst_branch *mstb; 5920 struct drm_dp_mst_topology_mgr *mgr = port->mgr; 5921 int ret; 5922 5923 mstb = drm_dp_mst_topology_get_mstb_validated(mgr, port->parent); 5924 if (!mstb) 5925 return -EREMOTEIO; 5926 5927 if (remote_i2c_read_ok(msgs, num)) { 5928 ret = drm_dp_mst_i2c_read(mstb, port, msgs, num); 5929 } else if (remote_i2c_write_ok(msgs, num)) { 5930 ret = drm_dp_mst_i2c_write(mstb, port, msgs, num); 5931 } else { 5932 drm_dbg_kms(mgr->dev, "Unsupported I2C transaction for MST device\n"); 5933 ret = -EIO; 5934 } 5935 5936 drm_dp_mst_topology_put_mstb(mstb); 5937 return ret; 5938 } 5939 5940 static u32 drm_dp_mst_i2c_functionality(struct i2c_adapter *adapter) 5941 { 5942 return I2C_FUNC_I2C | I2C_FUNC_SMBUS_EMUL | 5943 I2C_FUNC_SMBUS_READ_BLOCK_DATA | 5944 I2C_FUNC_SMBUS_BLOCK_PROC_CALL | 5945 I2C_FUNC_10BIT_ADDR; 5946 } 5947 5948 static const struct i2c_algorithm drm_dp_mst_i2c_algo = { 5949 .functionality = drm_dp_mst_i2c_functionality, 5950 .master_xfer = drm_dp_mst_i2c_xfer, 5951 }; 5952 5953 /** 5954 * drm_dp_mst_register_i2c_bus() - register an I2C adapter for I2C-over-AUX 5955 * @port: The port to add the I2C bus on 5956 * 5957 * Returns 0 on success or a negative error code on failure. 5958 */ 5959 static int drm_dp_mst_register_i2c_bus(struct drm_dp_mst_port *port) 5960 { 5961 struct drm_dp_aux *aux = &port->aux; 5962 struct device *parent_dev = port->mgr->dev->dev; 5963 5964 aux->ddc.algo = &drm_dp_mst_i2c_algo; 5965 aux->ddc.algo_data = aux; 5966 aux->ddc.retries = 3; 5967 5968 aux->ddc.owner = THIS_MODULE; 5969 /* FIXME: set the kdev of the port's connector as parent */ 5970 aux->ddc.dev.parent = parent_dev; 5971 aux->ddc.dev.of_node = parent_dev->of_node; 5972 5973 strscpy(aux->ddc.name, aux->name ? aux->name : dev_name(parent_dev), 5974 sizeof(aux->ddc.name)); 5975 5976 return i2c_add_adapter(&aux->ddc); 5977 } 5978 5979 /** 5980 * drm_dp_mst_unregister_i2c_bus() - unregister an I2C-over-AUX adapter 5981 * @port: The port to remove the I2C bus from 5982 */ 5983 static void drm_dp_mst_unregister_i2c_bus(struct drm_dp_mst_port *port) 5984 { 5985 i2c_del_adapter(&port->aux.ddc); 5986 } 5987 5988 /** 5989 * drm_dp_mst_is_virtual_dpcd() - Is the given port a virtual DP Peer Device 5990 * @port: The port to check 5991 * 5992 * A single physical MST hub object can be represented in the topology 5993 * by multiple branches, with virtual ports between those branches. 5994 * 5995 * As of DP1.4, An MST hub with internal (virtual) ports must expose 5996 * certain DPCD registers over those ports. See sections 2.6.1.1.1 5997 * and 2.6.1.1.2 of Display Port specification v1.4 for details. 5998 * 5999 * May acquire mgr->lock 6000 * 6001 * Returns: 6002 * true if the port is a virtual DP peer device, false otherwise 6003 */ 6004 static bool drm_dp_mst_is_virtual_dpcd(struct drm_dp_mst_port *port) 6005 { 6006 struct drm_dp_mst_port *downstream_port; 6007 6008 if (!port || port->dpcd_rev < DP_DPCD_REV_14) 6009 return false; 6010 6011 /* Virtual DP Sink (Internal Display Panel) */ 6012 if (drm_dp_mst_port_is_logical(port)) 6013 return true; 6014 6015 /* DP-to-HDMI Protocol Converter */ 6016 if (port->pdt == DP_PEER_DEVICE_DP_LEGACY_CONV && 6017 !port->mcs && 6018 port->ldps) 6019 return true; 6020 6021 /* DP-to-DP */ 6022 mutex_lock(&port->mgr->lock); 6023 if (port->pdt == DP_PEER_DEVICE_MST_BRANCHING && 6024 port->mstb && 6025 port->mstb->num_ports == 2) { 6026 list_for_each_entry(downstream_port, &port->mstb->ports, next) { 6027 if (downstream_port->pdt == DP_PEER_DEVICE_SST_SINK && 6028 !downstream_port->input) { 6029 mutex_unlock(&port->mgr->lock); 6030 return true; 6031 } 6032 } 6033 } 6034 mutex_unlock(&port->mgr->lock); 6035 6036 return false; 6037 } 6038 6039 /** 6040 * drm_dp_mst_aux_for_parent() - Get the AUX device for an MST port's parent 6041 * @port: MST port whose parent's AUX device is returned 6042 * 6043 * Return the AUX device for @port's parent or NULL if port's parent is the 6044 * root port. 6045 */ 6046 struct drm_dp_aux *drm_dp_mst_aux_for_parent(struct drm_dp_mst_port *port) 6047 { 6048 if (!port->parent || !port->parent->port_parent) 6049 return NULL; 6050 6051 return &port->parent->port_parent->aux; 6052 } 6053 EXPORT_SYMBOL(drm_dp_mst_aux_for_parent); 6054 6055 /** 6056 * drm_dp_mst_dsc_aux_for_port() - Find the correct aux for DSC 6057 * @port: The port to check. A leaf of the MST tree with an attached display. 6058 * 6059 * Depending on the situation, DSC may be enabled via the endpoint aux, 6060 * the immediately upstream aux, or the connector's physical aux. 6061 * 6062 * This is both the correct aux to read DSC_CAPABILITY and the 6063 * correct aux to write DSC_ENABLED. 6064 * 6065 * This operation can be expensive (up to four aux reads), so 6066 * the caller should cache the return. 6067 * 6068 * Returns: 6069 * NULL if DSC cannot be enabled on this port, otherwise the aux device 6070 */ 6071 struct drm_dp_aux *drm_dp_mst_dsc_aux_for_port(struct drm_dp_mst_port *port) 6072 { 6073 struct drm_dp_mst_port *immediate_upstream_port; 6074 struct drm_dp_aux *immediate_upstream_aux; 6075 struct drm_dp_mst_port *fec_port; 6076 struct drm_dp_desc desc = {}; 6077 u8 upstream_dsc; 6078 u8 endpoint_fec; 6079 u8 endpoint_dsc; 6080 6081 if (!port) 6082 return NULL; 6083 6084 if (port->parent->port_parent) 6085 immediate_upstream_port = port->parent->port_parent; 6086 else 6087 immediate_upstream_port = NULL; 6088 6089 fec_port = immediate_upstream_port; 6090 while (fec_port) { 6091 /* 6092 * Each physical link (i.e. not a virtual port) between the 6093 * output and the primary device must support FEC 6094 */ 6095 if (!drm_dp_mst_is_virtual_dpcd(fec_port) && 6096 !fec_port->fec_capable) 6097 return NULL; 6098 6099 fec_port = fec_port->parent->port_parent; 6100 } 6101 6102 /* DP-to-DP peer device */ 6103 if (drm_dp_mst_is_virtual_dpcd(immediate_upstream_port)) { 6104 if (drm_dp_dpcd_read(&port->aux, 6105 DP_DSC_SUPPORT, &endpoint_dsc, 1) != 1) 6106 return NULL; 6107 if (drm_dp_dpcd_read(&port->aux, 6108 DP_FEC_CAPABILITY, &endpoint_fec, 1) != 1) 6109 return NULL; 6110 if (drm_dp_dpcd_read(&immediate_upstream_port->aux, 6111 DP_DSC_SUPPORT, &upstream_dsc, 1) != 1) 6112 return NULL; 6113 6114 /* Enpoint decompression with DP-to-DP peer device */ 6115 if ((endpoint_dsc & DP_DSC_DECOMPRESSION_IS_SUPPORTED) && 6116 (endpoint_fec & DP_FEC_CAPABLE) && 6117 (upstream_dsc & DP_DSC_PASSTHROUGH_IS_SUPPORTED)) { 6118 port->passthrough_aux = &immediate_upstream_port->aux; 6119 return &port->aux; 6120 } 6121 6122 /* Virtual DPCD decompression with DP-to-DP peer device */ 6123 return &immediate_upstream_port->aux; 6124 } 6125 6126 /* Virtual DPCD decompression with DP-to-HDMI or Virtual DP Sink */ 6127 if (drm_dp_mst_is_virtual_dpcd(port)) 6128 return &port->aux; 6129 6130 /* 6131 * Synaptics quirk 6132 * Applies to ports for which: 6133 * - Physical aux has Synaptics OUI 6134 * - DPv1.4 or higher 6135 * - Port is on primary branch device 6136 * - Not a VGA adapter (DP_DWN_STRM_PORT_TYPE_ANALOG) 6137 */ 6138 if (immediate_upstream_port) 6139 immediate_upstream_aux = &immediate_upstream_port->aux; 6140 else 6141 immediate_upstream_aux = port->mgr->aux; 6142 6143 if (drm_dp_read_desc(immediate_upstream_aux, &desc, true)) 6144 return NULL; 6145 6146 if (drm_dp_has_quirk(&desc, DP_DPCD_QUIRK_DSC_WITHOUT_VIRTUAL_DPCD)) { 6147 u8 dpcd_ext[DP_RECEIVER_CAP_SIZE]; 6148 6149 if (drm_dp_dpcd_read(immediate_upstream_aux, 6150 DP_DSC_SUPPORT, &upstream_dsc, 1) != 1) 6151 return NULL; 6152 6153 if (!(upstream_dsc & DP_DSC_DECOMPRESSION_IS_SUPPORTED)) 6154 return NULL; 6155 6156 if (drm_dp_read_dpcd_caps(immediate_upstream_aux, dpcd_ext) < 0) 6157 return NULL; 6158 6159 if (dpcd_ext[DP_DPCD_REV] >= DP_DPCD_REV_14 && 6160 ((dpcd_ext[DP_DOWNSTREAMPORT_PRESENT] & DP_DWN_STRM_PORT_PRESENT) && 6161 ((dpcd_ext[DP_DOWNSTREAMPORT_PRESENT] & DP_DWN_STRM_PORT_TYPE_MASK) 6162 != DP_DWN_STRM_PORT_TYPE_ANALOG))) 6163 return immediate_upstream_aux; 6164 } 6165 6166 /* 6167 * The check below verifies if the MST sink 6168 * connected to the GPU is capable of DSC - 6169 * therefore the endpoint needs to be 6170 * both DSC and FEC capable. 6171 */ 6172 if (drm_dp_dpcd_read(&port->aux, 6173 DP_DSC_SUPPORT, &endpoint_dsc, 1) != 1) 6174 return NULL; 6175 if (drm_dp_dpcd_read(&port->aux, 6176 DP_FEC_CAPABILITY, &endpoint_fec, 1) != 1) 6177 return NULL; 6178 if ((endpoint_dsc & DP_DSC_DECOMPRESSION_IS_SUPPORTED) && 6179 (endpoint_fec & DP_FEC_CAPABLE)) 6180 return &port->aux; 6181 6182 return NULL; 6183 } 6184 EXPORT_SYMBOL(drm_dp_mst_dsc_aux_for_port); 6185