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