1 // SPDX-License-Identifier: GPL-2.0 2 /* 3 * Thunderbolt XDomain discovery protocol support 4 * 5 * Copyright (C) 2017, Intel Corporation 6 * Authors: Michael Jamet <michael.jamet@intel.com> 7 * Mika Westerberg <mika.westerberg@linux.intel.com> 8 */ 9 10 #include <linux/device.h> 11 #include <linux/kmod.h> 12 #include <linux/module.h> 13 #include <linux/pm_runtime.h> 14 #include <linux/utsname.h> 15 #include <linux/uuid.h> 16 #include <linux/workqueue.h> 17 18 #include "tb.h" 19 20 #define XDOMAIN_DEFAULT_TIMEOUT 5000 /* ms */ 21 #define XDOMAIN_UUID_RETRIES 10 22 #define XDOMAIN_PROPERTIES_RETRIES 60 23 #define XDOMAIN_PROPERTIES_CHANGED_RETRIES 10 24 25 struct xdomain_request_work { 26 struct work_struct work; 27 struct tb_xdp_header *pkg; 28 struct tb *tb; 29 }; 30 31 /* Serializes access to the properties and protocol handlers below */ 32 static DEFINE_MUTEX(xdomain_lock); 33 34 /* Properties exposed to the remote domains */ 35 static struct tb_property_dir *xdomain_property_dir; 36 static u32 *xdomain_property_block; 37 static u32 xdomain_property_block_len; 38 static u32 xdomain_property_block_gen; 39 40 /* Additional protocol handlers */ 41 static LIST_HEAD(protocol_handlers); 42 43 /* UUID for XDomain discovery protocol: b638d70e-42ff-40bb-97c2-90e2c0b2ff07 */ 44 static const uuid_t tb_xdp_uuid = 45 UUID_INIT(0xb638d70e, 0x42ff, 0x40bb, 46 0x97, 0xc2, 0x90, 0xe2, 0xc0, 0xb2, 0xff, 0x07); 47 48 static bool tb_xdomain_match(const struct tb_cfg_request *req, 49 const struct ctl_pkg *pkg) 50 { 51 switch (pkg->frame.eof) { 52 case TB_CFG_PKG_ERROR: 53 return true; 54 55 case TB_CFG_PKG_XDOMAIN_RESP: { 56 const struct tb_xdp_header *res_hdr = pkg->buffer; 57 const struct tb_xdp_header *req_hdr = req->request; 58 59 if (pkg->frame.size < req->response_size / 4) 60 return false; 61 62 /* Make sure route matches */ 63 if ((res_hdr->xd_hdr.route_hi & ~BIT(31)) != 64 req_hdr->xd_hdr.route_hi) 65 return false; 66 if ((res_hdr->xd_hdr.route_lo) != req_hdr->xd_hdr.route_lo) 67 return false; 68 69 /* Check that the XDomain protocol matches */ 70 if (!uuid_equal(&res_hdr->uuid, &req_hdr->uuid)) 71 return false; 72 73 return true; 74 } 75 76 default: 77 return false; 78 } 79 } 80 81 static bool tb_xdomain_copy(struct tb_cfg_request *req, 82 const struct ctl_pkg *pkg) 83 { 84 memcpy(req->response, pkg->buffer, req->response_size); 85 req->result.err = 0; 86 return true; 87 } 88 89 static void response_ready(void *data) 90 { 91 tb_cfg_request_put(data); 92 } 93 94 static int __tb_xdomain_response(struct tb_ctl *ctl, const void *response, 95 size_t size, enum tb_cfg_pkg_type type) 96 { 97 struct tb_cfg_request *req; 98 99 req = tb_cfg_request_alloc(); 100 if (!req) 101 return -ENOMEM; 102 103 req->match = tb_xdomain_match; 104 req->copy = tb_xdomain_copy; 105 req->request = response; 106 req->request_size = size; 107 req->request_type = type; 108 109 return tb_cfg_request(ctl, req, response_ready, req); 110 } 111 112 /** 113 * tb_xdomain_response() - Send a XDomain response message 114 * @xd: XDomain to send the message 115 * @response: Response to send 116 * @size: Size of the response 117 * @type: PDF type of the response 118 * 119 * This can be used to send a XDomain response message to the other 120 * domain. No response for the message is expected. 121 * 122 * Return: %0 in case of success and negative errno in case of failure 123 */ 124 int tb_xdomain_response(struct tb_xdomain *xd, const void *response, 125 size_t size, enum tb_cfg_pkg_type type) 126 { 127 return __tb_xdomain_response(xd->tb->ctl, response, size, type); 128 } 129 EXPORT_SYMBOL_GPL(tb_xdomain_response); 130 131 static int __tb_xdomain_request(struct tb_ctl *ctl, const void *request, 132 size_t request_size, enum tb_cfg_pkg_type request_type, void *response, 133 size_t response_size, enum tb_cfg_pkg_type response_type, 134 unsigned int timeout_msec) 135 { 136 struct tb_cfg_request *req; 137 struct tb_cfg_result res; 138 139 req = tb_cfg_request_alloc(); 140 if (!req) 141 return -ENOMEM; 142 143 req->match = tb_xdomain_match; 144 req->copy = tb_xdomain_copy; 145 req->request = request; 146 req->request_size = request_size; 147 req->request_type = request_type; 148 req->response = response; 149 req->response_size = response_size; 150 req->response_type = response_type; 151 152 res = tb_cfg_request_sync(ctl, req, timeout_msec); 153 154 tb_cfg_request_put(req); 155 156 return res.err == 1 ? -EIO : res.err; 157 } 158 159 /** 160 * tb_xdomain_request() - Send a XDomain request 161 * @xd: XDomain to send the request 162 * @request: Request to send 163 * @request_size: Size of the request in bytes 164 * @request_type: PDF type of the request 165 * @response: Response is copied here 166 * @response_size: Expected size of the response in bytes 167 * @response_type: Expected PDF type of the response 168 * @timeout_msec: Timeout in milliseconds to wait for the response 169 * 170 * This function can be used to send XDomain control channel messages to 171 * the other domain. The function waits until the response is received 172 * or when timeout triggers. Whichever comes first. 173 * 174 * Return: %0 in case of success and negative errno in case of failure 175 */ 176 int tb_xdomain_request(struct tb_xdomain *xd, const void *request, 177 size_t request_size, enum tb_cfg_pkg_type request_type, 178 void *response, size_t response_size, 179 enum tb_cfg_pkg_type response_type, unsigned int timeout_msec) 180 { 181 return __tb_xdomain_request(xd->tb->ctl, request, request_size, 182 request_type, response, response_size, 183 response_type, timeout_msec); 184 } 185 EXPORT_SYMBOL_GPL(tb_xdomain_request); 186 187 static inline void tb_xdp_fill_header(struct tb_xdp_header *hdr, u64 route, 188 u8 sequence, enum tb_xdp_type type, size_t size) 189 { 190 u32 length_sn; 191 192 length_sn = (size - sizeof(hdr->xd_hdr)) / 4; 193 length_sn |= (sequence << TB_XDOMAIN_SN_SHIFT) & TB_XDOMAIN_SN_MASK; 194 195 hdr->xd_hdr.route_hi = upper_32_bits(route); 196 hdr->xd_hdr.route_lo = lower_32_bits(route); 197 hdr->xd_hdr.length_sn = length_sn; 198 hdr->type = type; 199 memcpy(&hdr->uuid, &tb_xdp_uuid, sizeof(tb_xdp_uuid)); 200 } 201 202 static int tb_xdp_handle_error(const struct tb_xdp_header *hdr) 203 { 204 const struct tb_xdp_error_response *error; 205 206 if (hdr->type != ERROR_RESPONSE) 207 return 0; 208 209 error = (const struct tb_xdp_error_response *)hdr; 210 211 switch (error->error) { 212 case ERROR_UNKNOWN_PACKET: 213 case ERROR_UNKNOWN_DOMAIN: 214 return -EIO; 215 case ERROR_NOT_SUPPORTED: 216 return -ENOTSUPP; 217 case ERROR_NOT_READY: 218 return -EAGAIN; 219 default: 220 break; 221 } 222 223 return 0; 224 } 225 226 static int tb_xdp_uuid_request(struct tb_ctl *ctl, u64 route, int retry, 227 uuid_t *uuid) 228 { 229 struct tb_xdp_uuid_response res; 230 struct tb_xdp_uuid req; 231 int ret; 232 233 memset(&req, 0, sizeof(req)); 234 tb_xdp_fill_header(&req.hdr, route, retry % 4, UUID_REQUEST, 235 sizeof(req)); 236 237 memset(&res, 0, sizeof(res)); 238 ret = __tb_xdomain_request(ctl, &req, sizeof(req), 239 TB_CFG_PKG_XDOMAIN_REQ, &res, sizeof(res), 240 TB_CFG_PKG_XDOMAIN_RESP, 241 XDOMAIN_DEFAULT_TIMEOUT); 242 if (ret) 243 return ret; 244 245 ret = tb_xdp_handle_error(&res.hdr); 246 if (ret) 247 return ret; 248 249 uuid_copy(uuid, &res.src_uuid); 250 return 0; 251 } 252 253 static int tb_xdp_uuid_response(struct tb_ctl *ctl, u64 route, u8 sequence, 254 const uuid_t *uuid) 255 { 256 struct tb_xdp_uuid_response res; 257 258 memset(&res, 0, sizeof(res)); 259 tb_xdp_fill_header(&res.hdr, route, sequence, UUID_RESPONSE, 260 sizeof(res)); 261 262 uuid_copy(&res.src_uuid, uuid); 263 res.src_route_hi = upper_32_bits(route); 264 res.src_route_lo = lower_32_bits(route); 265 266 return __tb_xdomain_response(ctl, &res, sizeof(res), 267 TB_CFG_PKG_XDOMAIN_RESP); 268 } 269 270 static int tb_xdp_error_response(struct tb_ctl *ctl, u64 route, u8 sequence, 271 enum tb_xdp_error error) 272 { 273 struct tb_xdp_error_response res; 274 275 memset(&res, 0, sizeof(res)); 276 tb_xdp_fill_header(&res.hdr, route, sequence, ERROR_RESPONSE, 277 sizeof(res)); 278 res.error = error; 279 280 return __tb_xdomain_response(ctl, &res, sizeof(res), 281 TB_CFG_PKG_XDOMAIN_RESP); 282 } 283 284 static int tb_xdp_properties_request(struct tb_ctl *ctl, u64 route, 285 const uuid_t *src_uuid, const uuid_t *dst_uuid, int retry, 286 u32 **block, u32 *generation) 287 { 288 struct tb_xdp_properties_response *res; 289 struct tb_xdp_properties req; 290 u16 data_len, len; 291 size_t total_size; 292 u32 *data = NULL; 293 int ret; 294 295 total_size = sizeof(*res) + TB_XDP_PROPERTIES_MAX_DATA_LENGTH * 4; 296 res = kzalloc(total_size, GFP_KERNEL); 297 if (!res) 298 return -ENOMEM; 299 300 memset(&req, 0, sizeof(req)); 301 tb_xdp_fill_header(&req.hdr, route, retry % 4, PROPERTIES_REQUEST, 302 sizeof(req)); 303 memcpy(&req.src_uuid, src_uuid, sizeof(*src_uuid)); 304 memcpy(&req.dst_uuid, dst_uuid, sizeof(*dst_uuid)); 305 306 len = 0; 307 data_len = 0; 308 309 do { 310 ret = __tb_xdomain_request(ctl, &req, sizeof(req), 311 TB_CFG_PKG_XDOMAIN_REQ, res, 312 total_size, TB_CFG_PKG_XDOMAIN_RESP, 313 XDOMAIN_DEFAULT_TIMEOUT); 314 if (ret) 315 goto err; 316 317 ret = tb_xdp_handle_error(&res->hdr); 318 if (ret) 319 goto err; 320 321 /* 322 * Package length includes the whole payload without the 323 * XDomain header. Validate first that the package is at 324 * least size of the response structure. 325 */ 326 len = res->hdr.xd_hdr.length_sn & TB_XDOMAIN_LENGTH_MASK; 327 if (len < sizeof(*res) / 4) { 328 ret = -EINVAL; 329 goto err; 330 } 331 332 len += sizeof(res->hdr.xd_hdr) / 4; 333 len -= sizeof(*res) / 4; 334 335 if (res->offset != req.offset) { 336 ret = -EINVAL; 337 goto err; 338 } 339 340 /* 341 * First time allocate block that has enough space for 342 * the whole properties block. 343 */ 344 if (!data) { 345 data_len = res->data_length; 346 if (data_len > TB_XDP_PROPERTIES_MAX_LENGTH) { 347 ret = -E2BIG; 348 goto err; 349 } 350 351 data = kcalloc(data_len, sizeof(u32), GFP_KERNEL); 352 if (!data) { 353 ret = -ENOMEM; 354 goto err; 355 } 356 } 357 358 memcpy(data + req.offset, res->data, len * 4); 359 req.offset += len; 360 } while (!data_len || req.offset < data_len); 361 362 *block = data; 363 *generation = res->generation; 364 365 kfree(res); 366 367 return data_len; 368 369 err: 370 kfree(data); 371 kfree(res); 372 373 return ret; 374 } 375 376 static int tb_xdp_properties_response(struct tb *tb, struct tb_ctl *ctl, 377 u64 route, u8 sequence, const uuid_t *src_uuid, 378 const struct tb_xdp_properties *req) 379 { 380 struct tb_xdp_properties_response *res; 381 size_t total_size; 382 u16 len; 383 int ret; 384 385 /* 386 * Currently we expect all requests to be directed to us. The 387 * protocol supports forwarding, though which we might add 388 * support later on. 389 */ 390 if (!uuid_equal(src_uuid, &req->dst_uuid)) { 391 tb_xdp_error_response(ctl, route, sequence, 392 ERROR_UNKNOWN_DOMAIN); 393 return 0; 394 } 395 396 mutex_lock(&xdomain_lock); 397 398 if (req->offset >= xdomain_property_block_len) { 399 mutex_unlock(&xdomain_lock); 400 return -EINVAL; 401 } 402 403 len = xdomain_property_block_len - req->offset; 404 len = min_t(u16, len, TB_XDP_PROPERTIES_MAX_DATA_LENGTH); 405 total_size = sizeof(*res) + len * 4; 406 407 res = kzalloc(total_size, GFP_KERNEL); 408 if (!res) { 409 mutex_unlock(&xdomain_lock); 410 return -ENOMEM; 411 } 412 413 tb_xdp_fill_header(&res->hdr, route, sequence, PROPERTIES_RESPONSE, 414 total_size); 415 res->generation = xdomain_property_block_gen; 416 res->data_length = xdomain_property_block_len; 417 res->offset = req->offset; 418 uuid_copy(&res->src_uuid, src_uuid); 419 uuid_copy(&res->dst_uuid, &req->src_uuid); 420 memcpy(res->data, &xdomain_property_block[req->offset], len * 4); 421 422 mutex_unlock(&xdomain_lock); 423 424 ret = __tb_xdomain_response(ctl, res, total_size, 425 TB_CFG_PKG_XDOMAIN_RESP); 426 427 kfree(res); 428 return ret; 429 } 430 431 static int tb_xdp_properties_changed_request(struct tb_ctl *ctl, u64 route, 432 int retry, const uuid_t *uuid) 433 { 434 struct tb_xdp_properties_changed_response res; 435 struct tb_xdp_properties_changed req; 436 int ret; 437 438 memset(&req, 0, sizeof(req)); 439 tb_xdp_fill_header(&req.hdr, route, retry % 4, 440 PROPERTIES_CHANGED_REQUEST, sizeof(req)); 441 uuid_copy(&req.src_uuid, uuid); 442 443 memset(&res, 0, sizeof(res)); 444 ret = __tb_xdomain_request(ctl, &req, sizeof(req), 445 TB_CFG_PKG_XDOMAIN_REQ, &res, sizeof(res), 446 TB_CFG_PKG_XDOMAIN_RESP, 447 XDOMAIN_DEFAULT_TIMEOUT); 448 if (ret) 449 return ret; 450 451 return tb_xdp_handle_error(&res.hdr); 452 } 453 454 static int 455 tb_xdp_properties_changed_response(struct tb_ctl *ctl, u64 route, u8 sequence) 456 { 457 struct tb_xdp_properties_changed_response res; 458 459 memset(&res, 0, sizeof(res)); 460 tb_xdp_fill_header(&res.hdr, route, sequence, 461 PROPERTIES_CHANGED_RESPONSE, sizeof(res)); 462 return __tb_xdomain_response(ctl, &res, sizeof(res), 463 TB_CFG_PKG_XDOMAIN_RESP); 464 } 465 466 /** 467 * tb_register_protocol_handler() - Register protocol handler 468 * @handler: Handler to register 469 * 470 * This allows XDomain service drivers to hook into incoming XDomain 471 * messages. After this function is called the service driver needs to 472 * be able to handle calls to callback whenever a package with the 473 * registered protocol is received. 474 */ 475 int tb_register_protocol_handler(struct tb_protocol_handler *handler) 476 { 477 if (!handler->uuid || !handler->callback) 478 return -EINVAL; 479 if (uuid_equal(handler->uuid, &tb_xdp_uuid)) 480 return -EINVAL; 481 482 mutex_lock(&xdomain_lock); 483 list_add_tail(&handler->list, &protocol_handlers); 484 mutex_unlock(&xdomain_lock); 485 486 return 0; 487 } 488 EXPORT_SYMBOL_GPL(tb_register_protocol_handler); 489 490 /** 491 * tb_unregister_protocol_handler() - Unregister protocol handler 492 * @handler: Handler to unregister 493 * 494 * Removes the previously registered protocol handler. 495 */ 496 void tb_unregister_protocol_handler(struct tb_protocol_handler *handler) 497 { 498 mutex_lock(&xdomain_lock); 499 list_del_init(&handler->list); 500 mutex_unlock(&xdomain_lock); 501 } 502 EXPORT_SYMBOL_GPL(tb_unregister_protocol_handler); 503 504 static int rebuild_property_block(void) 505 { 506 u32 *block, len; 507 int ret; 508 509 ret = tb_property_format_dir(xdomain_property_dir, NULL, 0); 510 if (ret < 0) 511 return ret; 512 513 len = ret; 514 515 block = kcalloc(len, sizeof(u32), GFP_KERNEL); 516 if (!block) 517 return -ENOMEM; 518 519 ret = tb_property_format_dir(xdomain_property_dir, block, len); 520 if (ret) { 521 kfree(block); 522 return ret; 523 } 524 525 kfree(xdomain_property_block); 526 xdomain_property_block = block; 527 xdomain_property_block_len = len; 528 xdomain_property_block_gen++; 529 530 return 0; 531 } 532 533 static void finalize_property_block(void) 534 { 535 const struct tb_property *nodename; 536 537 /* 538 * On first XDomain connection we set up the the system 539 * nodename. This delayed here because userspace may not have it 540 * set when the driver is first probed. 541 */ 542 mutex_lock(&xdomain_lock); 543 nodename = tb_property_find(xdomain_property_dir, "deviceid", 544 TB_PROPERTY_TYPE_TEXT); 545 if (!nodename) { 546 tb_property_add_text(xdomain_property_dir, "deviceid", 547 utsname()->nodename); 548 rebuild_property_block(); 549 } 550 mutex_unlock(&xdomain_lock); 551 } 552 553 static void tb_xdp_handle_request(struct work_struct *work) 554 { 555 struct xdomain_request_work *xw = container_of(work, typeof(*xw), work); 556 const struct tb_xdp_header *pkg = xw->pkg; 557 const struct tb_xdomain_header *xhdr = &pkg->xd_hdr; 558 struct tb *tb = xw->tb; 559 struct tb_ctl *ctl = tb->ctl; 560 const uuid_t *uuid; 561 int ret = 0; 562 u32 sequence; 563 u64 route; 564 565 route = ((u64)xhdr->route_hi << 32 | xhdr->route_lo) & ~BIT_ULL(63); 566 sequence = xhdr->length_sn & TB_XDOMAIN_SN_MASK; 567 sequence >>= TB_XDOMAIN_SN_SHIFT; 568 569 mutex_lock(&tb->lock); 570 if (tb->root_switch) 571 uuid = tb->root_switch->uuid; 572 else 573 uuid = NULL; 574 mutex_unlock(&tb->lock); 575 576 if (!uuid) { 577 tb_xdp_error_response(ctl, route, sequence, ERROR_NOT_READY); 578 goto out; 579 } 580 581 finalize_property_block(); 582 583 switch (pkg->type) { 584 case PROPERTIES_REQUEST: 585 ret = tb_xdp_properties_response(tb, ctl, route, sequence, uuid, 586 (const struct tb_xdp_properties *)pkg); 587 break; 588 589 case PROPERTIES_CHANGED_REQUEST: { 590 const struct tb_xdp_properties_changed *xchg = 591 (const struct tb_xdp_properties_changed *)pkg; 592 struct tb_xdomain *xd; 593 594 ret = tb_xdp_properties_changed_response(ctl, route, sequence); 595 596 /* 597 * Since the properties have been changed, let's update 598 * the xdomain related to this connection as well in 599 * case there is a change in services it offers. 600 */ 601 xd = tb_xdomain_find_by_uuid_locked(tb, &xchg->src_uuid); 602 if (xd) { 603 queue_delayed_work(tb->wq, &xd->get_properties_work, 604 msecs_to_jiffies(50)); 605 tb_xdomain_put(xd); 606 } 607 608 break; 609 } 610 611 case UUID_REQUEST_OLD: 612 case UUID_REQUEST: 613 ret = tb_xdp_uuid_response(ctl, route, sequence, uuid); 614 break; 615 616 default: 617 tb_xdp_error_response(ctl, route, sequence, 618 ERROR_NOT_SUPPORTED); 619 break; 620 } 621 622 if (ret) { 623 tb_warn(tb, "failed to send XDomain response for %#x\n", 624 pkg->type); 625 } 626 627 out: 628 kfree(xw->pkg); 629 kfree(xw); 630 631 tb_domain_put(tb); 632 } 633 634 static bool 635 tb_xdp_schedule_request(struct tb *tb, const struct tb_xdp_header *hdr, 636 size_t size) 637 { 638 struct xdomain_request_work *xw; 639 640 xw = kmalloc(sizeof(*xw), GFP_KERNEL); 641 if (!xw) 642 return false; 643 644 INIT_WORK(&xw->work, tb_xdp_handle_request); 645 xw->pkg = kmemdup(hdr, size, GFP_KERNEL); 646 if (!xw->pkg) { 647 kfree(xw); 648 return false; 649 } 650 xw->tb = tb_domain_get(tb); 651 652 schedule_work(&xw->work); 653 return true; 654 } 655 656 /** 657 * tb_register_service_driver() - Register XDomain service driver 658 * @drv: Driver to register 659 * 660 * Registers new service driver from @drv to the bus. 661 */ 662 int tb_register_service_driver(struct tb_service_driver *drv) 663 { 664 drv->driver.bus = &tb_bus_type; 665 return driver_register(&drv->driver); 666 } 667 EXPORT_SYMBOL_GPL(tb_register_service_driver); 668 669 /** 670 * tb_unregister_service_driver() - Unregister XDomain service driver 671 * @xdrv: Driver to unregister 672 * 673 * Unregisters XDomain service driver from the bus. 674 */ 675 void tb_unregister_service_driver(struct tb_service_driver *drv) 676 { 677 driver_unregister(&drv->driver); 678 } 679 EXPORT_SYMBOL_GPL(tb_unregister_service_driver); 680 681 static ssize_t key_show(struct device *dev, struct device_attribute *attr, 682 char *buf) 683 { 684 struct tb_service *svc = container_of(dev, struct tb_service, dev); 685 686 /* 687 * It should be null terminated but anything else is pretty much 688 * allowed. 689 */ 690 return sprintf(buf, "%*pE\n", (int)strlen(svc->key), svc->key); 691 } 692 static DEVICE_ATTR_RO(key); 693 694 static int get_modalias(struct tb_service *svc, char *buf, size_t size) 695 { 696 return snprintf(buf, size, "tbsvc:k%sp%08Xv%08Xr%08X", svc->key, 697 svc->prtcid, svc->prtcvers, svc->prtcrevs); 698 } 699 700 static ssize_t modalias_show(struct device *dev, struct device_attribute *attr, 701 char *buf) 702 { 703 struct tb_service *svc = container_of(dev, struct tb_service, dev); 704 705 /* Full buffer size except new line and null termination */ 706 get_modalias(svc, buf, PAGE_SIZE - 2); 707 return sprintf(buf, "%s\n", buf); 708 } 709 static DEVICE_ATTR_RO(modalias); 710 711 static ssize_t prtcid_show(struct device *dev, struct device_attribute *attr, 712 char *buf) 713 { 714 struct tb_service *svc = container_of(dev, struct tb_service, dev); 715 716 return sprintf(buf, "%u\n", svc->prtcid); 717 } 718 static DEVICE_ATTR_RO(prtcid); 719 720 static ssize_t prtcvers_show(struct device *dev, struct device_attribute *attr, 721 char *buf) 722 { 723 struct tb_service *svc = container_of(dev, struct tb_service, dev); 724 725 return sprintf(buf, "%u\n", svc->prtcvers); 726 } 727 static DEVICE_ATTR_RO(prtcvers); 728 729 static ssize_t prtcrevs_show(struct device *dev, struct device_attribute *attr, 730 char *buf) 731 { 732 struct tb_service *svc = container_of(dev, struct tb_service, dev); 733 734 return sprintf(buf, "%u\n", svc->prtcrevs); 735 } 736 static DEVICE_ATTR_RO(prtcrevs); 737 738 static ssize_t prtcstns_show(struct device *dev, struct device_attribute *attr, 739 char *buf) 740 { 741 struct tb_service *svc = container_of(dev, struct tb_service, dev); 742 743 return sprintf(buf, "0x%08x\n", svc->prtcstns); 744 } 745 static DEVICE_ATTR_RO(prtcstns); 746 747 static struct attribute *tb_service_attrs[] = { 748 &dev_attr_key.attr, 749 &dev_attr_modalias.attr, 750 &dev_attr_prtcid.attr, 751 &dev_attr_prtcvers.attr, 752 &dev_attr_prtcrevs.attr, 753 &dev_attr_prtcstns.attr, 754 NULL, 755 }; 756 757 static struct attribute_group tb_service_attr_group = { 758 .attrs = tb_service_attrs, 759 }; 760 761 static const struct attribute_group *tb_service_attr_groups[] = { 762 &tb_service_attr_group, 763 NULL, 764 }; 765 766 static int tb_service_uevent(struct device *dev, struct kobj_uevent_env *env) 767 { 768 struct tb_service *svc = container_of(dev, struct tb_service, dev); 769 char modalias[64]; 770 771 get_modalias(svc, modalias, sizeof(modalias)); 772 return add_uevent_var(env, "MODALIAS=%s", modalias); 773 } 774 775 static void tb_service_release(struct device *dev) 776 { 777 struct tb_service *svc = container_of(dev, struct tb_service, dev); 778 struct tb_xdomain *xd = tb_service_parent(svc); 779 780 ida_simple_remove(&xd->service_ids, svc->id); 781 kfree(svc->key); 782 kfree(svc); 783 } 784 785 struct device_type tb_service_type = { 786 .name = "thunderbolt_service", 787 .groups = tb_service_attr_groups, 788 .uevent = tb_service_uevent, 789 .release = tb_service_release, 790 }; 791 EXPORT_SYMBOL_GPL(tb_service_type); 792 793 static int remove_missing_service(struct device *dev, void *data) 794 { 795 struct tb_xdomain *xd = data; 796 struct tb_service *svc; 797 798 svc = tb_to_service(dev); 799 if (!svc) 800 return 0; 801 802 if (!tb_property_find(xd->properties, svc->key, 803 TB_PROPERTY_TYPE_DIRECTORY)) 804 device_unregister(dev); 805 806 return 0; 807 } 808 809 static int find_service(struct device *dev, void *data) 810 { 811 const struct tb_property *p = data; 812 struct tb_service *svc; 813 814 svc = tb_to_service(dev); 815 if (!svc) 816 return 0; 817 818 return !strcmp(svc->key, p->key); 819 } 820 821 static int populate_service(struct tb_service *svc, 822 struct tb_property *property) 823 { 824 struct tb_property_dir *dir = property->value.dir; 825 struct tb_property *p; 826 827 /* Fill in standard properties */ 828 p = tb_property_find(dir, "prtcid", TB_PROPERTY_TYPE_VALUE); 829 if (p) 830 svc->prtcid = p->value.immediate; 831 p = tb_property_find(dir, "prtcvers", TB_PROPERTY_TYPE_VALUE); 832 if (p) 833 svc->prtcvers = p->value.immediate; 834 p = tb_property_find(dir, "prtcrevs", TB_PROPERTY_TYPE_VALUE); 835 if (p) 836 svc->prtcrevs = p->value.immediate; 837 p = tb_property_find(dir, "prtcstns", TB_PROPERTY_TYPE_VALUE); 838 if (p) 839 svc->prtcstns = p->value.immediate; 840 841 svc->key = kstrdup(property->key, GFP_KERNEL); 842 if (!svc->key) 843 return -ENOMEM; 844 845 return 0; 846 } 847 848 static void enumerate_services(struct tb_xdomain *xd) 849 { 850 struct tb_service *svc; 851 struct tb_property *p; 852 struct device *dev; 853 int id; 854 855 /* 856 * First remove all services that are not available anymore in 857 * the updated property block. 858 */ 859 device_for_each_child_reverse(&xd->dev, xd, remove_missing_service); 860 861 /* Then re-enumerate properties creating new services as we go */ 862 tb_property_for_each(xd->properties, p) { 863 if (p->type != TB_PROPERTY_TYPE_DIRECTORY) 864 continue; 865 866 /* If the service exists already we are fine */ 867 dev = device_find_child(&xd->dev, p, find_service); 868 if (dev) { 869 put_device(dev); 870 continue; 871 } 872 873 svc = kzalloc(sizeof(*svc), GFP_KERNEL); 874 if (!svc) 875 break; 876 877 if (populate_service(svc, p)) { 878 kfree(svc); 879 break; 880 } 881 882 id = ida_simple_get(&xd->service_ids, 0, 0, GFP_KERNEL); 883 if (id < 0) { 884 kfree(svc->key); 885 kfree(svc); 886 break; 887 } 888 svc->id = id; 889 svc->dev.bus = &tb_bus_type; 890 svc->dev.type = &tb_service_type; 891 svc->dev.parent = &xd->dev; 892 dev_set_name(&svc->dev, "%s.%d", dev_name(&xd->dev), svc->id); 893 894 if (device_register(&svc->dev)) { 895 put_device(&svc->dev); 896 break; 897 } 898 } 899 } 900 901 static int populate_properties(struct tb_xdomain *xd, 902 struct tb_property_dir *dir) 903 { 904 const struct tb_property *p; 905 906 /* Required properties */ 907 p = tb_property_find(dir, "deviceid", TB_PROPERTY_TYPE_VALUE); 908 if (!p) 909 return -EINVAL; 910 xd->device = p->value.immediate; 911 912 p = tb_property_find(dir, "vendorid", TB_PROPERTY_TYPE_VALUE); 913 if (!p) 914 return -EINVAL; 915 xd->vendor = p->value.immediate; 916 917 kfree(xd->device_name); 918 xd->device_name = NULL; 919 kfree(xd->vendor_name); 920 xd->vendor_name = NULL; 921 922 /* Optional properties */ 923 p = tb_property_find(dir, "deviceid", TB_PROPERTY_TYPE_TEXT); 924 if (p) 925 xd->device_name = kstrdup(p->value.text, GFP_KERNEL); 926 p = tb_property_find(dir, "vendorid", TB_PROPERTY_TYPE_TEXT); 927 if (p) 928 xd->vendor_name = kstrdup(p->value.text, GFP_KERNEL); 929 930 return 0; 931 } 932 933 /* Called with @xd->lock held */ 934 static void tb_xdomain_restore_paths(struct tb_xdomain *xd) 935 { 936 if (!xd->resume) 937 return; 938 939 xd->resume = false; 940 if (xd->transmit_path) { 941 dev_dbg(&xd->dev, "re-establishing DMA path\n"); 942 tb_domain_approve_xdomain_paths(xd->tb, xd); 943 } 944 } 945 946 static void tb_xdomain_get_uuid(struct work_struct *work) 947 { 948 struct tb_xdomain *xd = container_of(work, typeof(*xd), 949 get_uuid_work.work); 950 struct tb *tb = xd->tb; 951 uuid_t uuid; 952 int ret; 953 954 ret = tb_xdp_uuid_request(tb->ctl, xd->route, xd->uuid_retries, &uuid); 955 if (ret < 0) { 956 if (xd->uuid_retries-- > 0) { 957 queue_delayed_work(xd->tb->wq, &xd->get_uuid_work, 958 msecs_to_jiffies(100)); 959 } else { 960 dev_dbg(&xd->dev, "failed to read remote UUID\n"); 961 } 962 return; 963 } 964 965 if (uuid_equal(&uuid, xd->local_uuid)) { 966 dev_dbg(&xd->dev, "intra-domain loop detected\n"); 967 return; 968 } 969 970 /* 971 * If the UUID is different, there is another domain connected 972 * so mark this one unplugged and wait for the connection 973 * manager to replace it. 974 */ 975 if (xd->remote_uuid && !uuid_equal(&uuid, xd->remote_uuid)) { 976 dev_dbg(&xd->dev, "remote UUID is different, unplugging\n"); 977 xd->is_unplugged = true; 978 return; 979 } 980 981 /* First time fill in the missing UUID */ 982 if (!xd->remote_uuid) { 983 xd->remote_uuid = kmemdup(&uuid, sizeof(uuid_t), GFP_KERNEL); 984 if (!xd->remote_uuid) 985 return; 986 } 987 988 /* Now we can start the normal properties exchange */ 989 queue_delayed_work(xd->tb->wq, &xd->properties_changed_work, 990 msecs_to_jiffies(100)); 991 queue_delayed_work(xd->tb->wq, &xd->get_properties_work, 992 msecs_to_jiffies(1000)); 993 } 994 995 static void tb_xdomain_get_properties(struct work_struct *work) 996 { 997 struct tb_xdomain *xd = container_of(work, typeof(*xd), 998 get_properties_work.work); 999 struct tb_property_dir *dir; 1000 struct tb *tb = xd->tb; 1001 bool update = false; 1002 u32 *block = NULL; 1003 u32 gen = 0; 1004 int ret; 1005 1006 ret = tb_xdp_properties_request(tb->ctl, xd->route, xd->local_uuid, 1007 xd->remote_uuid, xd->properties_retries, 1008 &block, &gen); 1009 if (ret < 0) { 1010 if (xd->properties_retries-- > 0) { 1011 queue_delayed_work(xd->tb->wq, &xd->get_properties_work, 1012 msecs_to_jiffies(1000)); 1013 } else { 1014 /* Give up now */ 1015 dev_err(&xd->dev, 1016 "failed read XDomain properties from %pUb\n", 1017 xd->remote_uuid); 1018 } 1019 return; 1020 } 1021 1022 xd->properties_retries = XDOMAIN_PROPERTIES_RETRIES; 1023 1024 mutex_lock(&xd->lock); 1025 1026 /* Only accept newer generation properties */ 1027 if (xd->properties && gen <= xd->property_block_gen) { 1028 /* 1029 * On resume it is likely that the properties block is 1030 * not changed (unless the other end added or removed 1031 * services). However, we need to make sure the existing 1032 * DMA paths are restored properly. 1033 */ 1034 tb_xdomain_restore_paths(xd); 1035 goto err_free_block; 1036 } 1037 1038 dir = tb_property_parse_dir(block, ret); 1039 if (!dir) { 1040 dev_err(&xd->dev, "failed to parse XDomain properties\n"); 1041 goto err_free_block; 1042 } 1043 1044 ret = populate_properties(xd, dir); 1045 if (ret) { 1046 dev_err(&xd->dev, "missing XDomain properties in response\n"); 1047 goto err_free_dir; 1048 } 1049 1050 /* Release the existing one */ 1051 if (xd->properties) { 1052 tb_property_free_dir(xd->properties); 1053 update = true; 1054 } 1055 1056 xd->properties = dir; 1057 xd->property_block_gen = gen; 1058 1059 tb_xdomain_restore_paths(xd); 1060 1061 mutex_unlock(&xd->lock); 1062 1063 kfree(block); 1064 1065 /* 1066 * Now the device should be ready enough so we can add it to the 1067 * bus and let userspace know about it. If the device is already 1068 * registered, we notify the userspace that it has changed. 1069 */ 1070 if (!update) { 1071 if (device_add(&xd->dev)) { 1072 dev_err(&xd->dev, "failed to add XDomain device\n"); 1073 return; 1074 } 1075 } else { 1076 kobject_uevent(&xd->dev.kobj, KOBJ_CHANGE); 1077 } 1078 1079 enumerate_services(xd); 1080 return; 1081 1082 err_free_dir: 1083 tb_property_free_dir(dir); 1084 err_free_block: 1085 kfree(block); 1086 mutex_unlock(&xd->lock); 1087 } 1088 1089 static void tb_xdomain_properties_changed(struct work_struct *work) 1090 { 1091 struct tb_xdomain *xd = container_of(work, typeof(*xd), 1092 properties_changed_work.work); 1093 int ret; 1094 1095 ret = tb_xdp_properties_changed_request(xd->tb->ctl, xd->route, 1096 xd->properties_changed_retries, xd->local_uuid); 1097 if (ret) { 1098 if (xd->properties_changed_retries-- > 0) 1099 queue_delayed_work(xd->tb->wq, 1100 &xd->properties_changed_work, 1101 msecs_to_jiffies(1000)); 1102 return; 1103 } 1104 1105 xd->properties_changed_retries = XDOMAIN_PROPERTIES_CHANGED_RETRIES; 1106 } 1107 1108 static ssize_t device_show(struct device *dev, struct device_attribute *attr, 1109 char *buf) 1110 { 1111 struct tb_xdomain *xd = container_of(dev, struct tb_xdomain, dev); 1112 1113 return sprintf(buf, "%#x\n", xd->device); 1114 } 1115 static DEVICE_ATTR_RO(device); 1116 1117 static ssize_t 1118 device_name_show(struct device *dev, struct device_attribute *attr, char *buf) 1119 { 1120 struct tb_xdomain *xd = container_of(dev, struct tb_xdomain, dev); 1121 int ret; 1122 1123 if (mutex_lock_interruptible(&xd->lock)) 1124 return -ERESTARTSYS; 1125 ret = sprintf(buf, "%s\n", xd->device_name ? xd->device_name : ""); 1126 mutex_unlock(&xd->lock); 1127 1128 return ret; 1129 } 1130 static DEVICE_ATTR_RO(device_name); 1131 1132 static ssize_t vendor_show(struct device *dev, struct device_attribute *attr, 1133 char *buf) 1134 { 1135 struct tb_xdomain *xd = container_of(dev, struct tb_xdomain, dev); 1136 1137 return sprintf(buf, "%#x\n", xd->vendor); 1138 } 1139 static DEVICE_ATTR_RO(vendor); 1140 1141 static ssize_t 1142 vendor_name_show(struct device *dev, struct device_attribute *attr, char *buf) 1143 { 1144 struct tb_xdomain *xd = container_of(dev, struct tb_xdomain, dev); 1145 int ret; 1146 1147 if (mutex_lock_interruptible(&xd->lock)) 1148 return -ERESTARTSYS; 1149 ret = sprintf(buf, "%s\n", xd->vendor_name ? xd->vendor_name : ""); 1150 mutex_unlock(&xd->lock); 1151 1152 return ret; 1153 } 1154 static DEVICE_ATTR_RO(vendor_name); 1155 1156 static ssize_t unique_id_show(struct device *dev, struct device_attribute *attr, 1157 char *buf) 1158 { 1159 struct tb_xdomain *xd = container_of(dev, struct tb_xdomain, dev); 1160 1161 return sprintf(buf, "%pUb\n", xd->remote_uuid); 1162 } 1163 static DEVICE_ATTR_RO(unique_id); 1164 1165 static struct attribute *xdomain_attrs[] = { 1166 &dev_attr_device.attr, 1167 &dev_attr_device_name.attr, 1168 &dev_attr_unique_id.attr, 1169 &dev_attr_vendor.attr, 1170 &dev_attr_vendor_name.attr, 1171 NULL, 1172 }; 1173 1174 static struct attribute_group xdomain_attr_group = { 1175 .attrs = xdomain_attrs, 1176 }; 1177 1178 static const struct attribute_group *xdomain_attr_groups[] = { 1179 &xdomain_attr_group, 1180 NULL, 1181 }; 1182 1183 static void tb_xdomain_release(struct device *dev) 1184 { 1185 struct tb_xdomain *xd = container_of(dev, struct tb_xdomain, dev); 1186 1187 put_device(xd->dev.parent); 1188 1189 tb_property_free_dir(xd->properties); 1190 ida_destroy(&xd->service_ids); 1191 1192 kfree(xd->local_uuid); 1193 kfree(xd->remote_uuid); 1194 kfree(xd->device_name); 1195 kfree(xd->vendor_name); 1196 kfree(xd); 1197 } 1198 1199 static void start_handshake(struct tb_xdomain *xd) 1200 { 1201 xd->uuid_retries = XDOMAIN_UUID_RETRIES; 1202 xd->properties_retries = XDOMAIN_PROPERTIES_RETRIES; 1203 xd->properties_changed_retries = XDOMAIN_PROPERTIES_CHANGED_RETRIES; 1204 1205 if (xd->needs_uuid) { 1206 queue_delayed_work(xd->tb->wq, &xd->get_uuid_work, 1207 msecs_to_jiffies(100)); 1208 } else { 1209 /* Start exchanging properties with the other host */ 1210 queue_delayed_work(xd->tb->wq, &xd->properties_changed_work, 1211 msecs_to_jiffies(100)); 1212 queue_delayed_work(xd->tb->wq, &xd->get_properties_work, 1213 msecs_to_jiffies(1000)); 1214 } 1215 } 1216 1217 static void stop_handshake(struct tb_xdomain *xd) 1218 { 1219 xd->uuid_retries = 0; 1220 xd->properties_retries = 0; 1221 xd->properties_changed_retries = 0; 1222 1223 cancel_delayed_work_sync(&xd->get_uuid_work); 1224 cancel_delayed_work_sync(&xd->get_properties_work); 1225 cancel_delayed_work_sync(&xd->properties_changed_work); 1226 } 1227 1228 static int __maybe_unused tb_xdomain_suspend(struct device *dev) 1229 { 1230 stop_handshake(tb_to_xdomain(dev)); 1231 return 0; 1232 } 1233 1234 static int __maybe_unused tb_xdomain_resume(struct device *dev) 1235 { 1236 struct tb_xdomain *xd = tb_to_xdomain(dev); 1237 1238 /* 1239 * Ask tb_xdomain_get_properties() restore any existing DMA 1240 * paths after properties are re-read. 1241 */ 1242 xd->resume = true; 1243 start_handshake(xd); 1244 1245 return 0; 1246 } 1247 1248 static const struct dev_pm_ops tb_xdomain_pm_ops = { 1249 SET_SYSTEM_SLEEP_PM_OPS(tb_xdomain_suspend, tb_xdomain_resume) 1250 }; 1251 1252 struct device_type tb_xdomain_type = { 1253 .name = "thunderbolt_xdomain", 1254 .release = tb_xdomain_release, 1255 .pm = &tb_xdomain_pm_ops, 1256 }; 1257 EXPORT_SYMBOL_GPL(tb_xdomain_type); 1258 1259 /** 1260 * tb_xdomain_alloc() - Allocate new XDomain object 1261 * @tb: Domain where the XDomain belongs 1262 * @parent: Parent device (the switch through the connection to the 1263 * other domain is reached). 1264 * @route: Route string used to reach the other domain 1265 * @local_uuid: Our local domain UUID 1266 * @remote_uuid: UUID of the other domain (optional) 1267 * 1268 * Allocates new XDomain structure and returns pointer to that. The 1269 * object must be released by calling tb_xdomain_put(). 1270 */ 1271 struct tb_xdomain *tb_xdomain_alloc(struct tb *tb, struct device *parent, 1272 u64 route, const uuid_t *local_uuid, 1273 const uuid_t *remote_uuid) 1274 { 1275 struct tb_switch *parent_sw = tb_to_switch(parent); 1276 struct tb_xdomain *xd; 1277 struct tb_port *down; 1278 1279 /* Make sure the downstream domain is accessible */ 1280 down = tb_port_at(route, parent_sw); 1281 tb_port_unlock(down); 1282 1283 xd = kzalloc(sizeof(*xd), GFP_KERNEL); 1284 if (!xd) 1285 return NULL; 1286 1287 xd->tb = tb; 1288 xd->route = route; 1289 ida_init(&xd->service_ids); 1290 mutex_init(&xd->lock); 1291 INIT_DELAYED_WORK(&xd->get_uuid_work, tb_xdomain_get_uuid); 1292 INIT_DELAYED_WORK(&xd->get_properties_work, tb_xdomain_get_properties); 1293 INIT_DELAYED_WORK(&xd->properties_changed_work, 1294 tb_xdomain_properties_changed); 1295 1296 xd->local_uuid = kmemdup(local_uuid, sizeof(uuid_t), GFP_KERNEL); 1297 if (!xd->local_uuid) 1298 goto err_free; 1299 1300 if (remote_uuid) { 1301 xd->remote_uuid = kmemdup(remote_uuid, sizeof(uuid_t), 1302 GFP_KERNEL); 1303 if (!xd->remote_uuid) 1304 goto err_free_local_uuid; 1305 } else { 1306 xd->needs_uuid = true; 1307 } 1308 1309 device_initialize(&xd->dev); 1310 xd->dev.parent = get_device(parent); 1311 xd->dev.bus = &tb_bus_type; 1312 xd->dev.type = &tb_xdomain_type; 1313 xd->dev.groups = xdomain_attr_groups; 1314 dev_set_name(&xd->dev, "%u-%llx", tb->index, route); 1315 1316 /* 1317 * This keeps the DMA powered on as long as we have active 1318 * connection to another host. 1319 */ 1320 pm_runtime_set_active(&xd->dev); 1321 pm_runtime_get_noresume(&xd->dev); 1322 pm_runtime_enable(&xd->dev); 1323 1324 return xd; 1325 1326 err_free_local_uuid: 1327 kfree(xd->local_uuid); 1328 err_free: 1329 kfree(xd); 1330 1331 return NULL; 1332 } 1333 1334 /** 1335 * tb_xdomain_add() - Add XDomain to the bus 1336 * @xd: XDomain to add 1337 * 1338 * This function starts XDomain discovery protocol handshake and 1339 * eventually adds the XDomain to the bus. After calling this function 1340 * the caller needs to call tb_xdomain_remove() in order to remove and 1341 * release the object regardless whether the handshake succeeded or not. 1342 */ 1343 void tb_xdomain_add(struct tb_xdomain *xd) 1344 { 1345 /* Start exchanging properties with the other host */ 1346 start_handshake(xd); 1347 } 1348 1349 static int unregister_service(struct device *dev, void *data) 1350 { 1351 device_unregister(dev); 1352 return 0; 1353 } 1354 1355 /** 1356 * tb_xdomain_remove() - Remove XDomain from the bus 1357 * @xd: XDomain to remove 1358 * 1359 * This will stop all ongoing configuration work and remove the XDomain 1360 * along with any services from the bus. When the last reference to @xd 1361 * is released the object will be released as well. 1362 */ 1363 void tb_xdomain_remove(struct tb_xdomain *xd) 1364 { 1365 stop_handshake(xd); 1366 1367 device_for_each_child_reverse(&xd->dev, xd, unregister_service); 1368 1369 /* 1370 * Undo runtime PM here explicitly because it is possible that 1371 * the XDomain was never added to the bus and thus device_del() 1372 * is not called for it (device_del() would handle this otherwise). 1373 */ 1374 pm_runtime_disable(&xd->dev); 1375 pm_runtime_put_noidle(&xd->dev); 1376 pm_runtime_set_suspended(&xd->dev); 1377 1378 if (!device_is_registered(&xd->dev)) 1379 put_device(&xd->dev); 1380 else 1381 device_unregister(&xd->dev); 1382 } 1383 1384 /** 1385 * tb_xdomain_enable_paths() - Enable DMA paths for XDomain connection 1386 * @xd: XDomain connection 1387 * @transmit_path: HopID of the transmit path the other end is using to 1388 * send packets 1389 * @transmit_ring: DMA ring used to receive packets from the other end 1390 * @receive_path: HopID of the receive path the other end is using to 1391 * receive packets 1392 * @receive_ring: DMA ring used to send packets to the other end 1393 * 1394 * The function enables DMA paths accordingly so that after successful 1395 * return the caller can send and receive packets using high-speed DMA 1396 * path. 1397 * 1398 * Return: %0 in case of success and negative errno in case of error 1399 */ 1400 int tb_xdomain_enable_paths(struct tb_xdomain *xd, u16 transmit_path, 1401 u16 transmit_ring, u16 receive_path, 1402 u16 receive_ring) 1403 { 1404 int ret; 1405 1406 mutex_lock(&xd->lock); 1407 1408 if (xd->transmit_path) { 1409 ret = xd->transmit_path == transmit_path ? 0 : -EBUSY; 1410 goto exit_unlock; 1411 } 1412 1413 xd->transmit_path = transmit_path; 1414 xd->transmit_ring = transmit_ring; 1415 xd->receive_path = receive_path; 1416 xd->receive_ring = receive_ring; 1417 1418 ret = tb_domain_approve_xdomain_paths(xd->tb, xd); 1419 1420 exit_unlock: 1421 mutex_unlock(&xd->lock); 1422 1423 return ret; 1424 } 1425 EXPORT_SYMBOL_GPL(tb_xdomain_enable_paths); 1426 1427 /** 1428 * tb_xdomain_disable_paths() - Disable DMA paths for XDomain connection 1429 * @xd: XDomain connection 1430 * 1431 * This does the opposite of tb_xdomain_enable_paths(). After call to 1432 * this the caller is not expected to use the rings anymore. 1433 * 1434 * Return: %0 in case of success and negative errno in case of error 1435 */ 1436 int tb_xdomain_disable_paths(struct tb_xdomain *xd) 1437 { 1438 int ret = 0; 1439 1440 mutex_lock(&xd->lock); 1441 if (xd->transmit_path) { 1442 xd->transmit_path = 0; 1443 xd->transmit_ring = 0; 1444 xd->receive_path = 0; 1445 xd->receive_ring = 0; 1446 1447 ret = tb_domain_disconnect_xdomain_paths(xd->tb, xd); 1448 } 1449 mutex_unlock(&xd->lock); 1450 1451 return ret; 1452 } 1453 EXPORT_SYMBOL_GPL(tb_xdomain_disable_paths); 1454 1455 struct tb_xdomain_lookup { 1456 const uuid_t *uuid; 1457 u8 link; 1458 u8 depth; 1459 u64 route; 1460 }; 1461 1462 static struct tb_xdomain *switch_find_xdomain(struct tb_switch *sw, 1463 const struct tb_xdomain_lookup *lookup) 1464 { 1465 struct tb_port *port; 1466 1467 tb_switch_for_each_port(sw, port) { 1468 struct tb_xdomain *xd; 1469 1470 if (port->xdomain) { 1471 xd = port->xdomain; 1472 1473 if (lookup->uuid) { 1474 if (xd->remote_uuid && 1475 uuid_equal(xd->remote_uuid, lookup->uuid)) 1476 return xd; 1477 } else if (lookup->link && 1478 lookup->link == xd->link && 1479 lookup->depth == xd->depth) { 1480 return xd; 1481 } else if (lookup->route && 1482 lookup->route == xd->route) { 1483 return xd; 1484 } 1485 } else if (tb_port_has_remote(port)) { 1486 xd = switch_find_xdomain(port->remote->sw, lookup); 1487 if (xd) 1488 return xd; 1489 } 1490 } 1491 1492 return NULL; 1493 } 1494 1495 /** 1496 * tb_xdomain_find_by_uuid() - Find an XDomain by UUID 1497 * @tb: Domain where the XDomain belongs to 1498 * @uuid: UUID to look for 1499 * 1500 * Finds XDomain by walking through the Thunderbolt topology below @tb. 1501 * The returned XDomain will have its reference count increased so the 1502 * caller needs to call tb_xdomain_put() when it is done with the 1503 * object. 1504 * 1505 * This will find all XDomains including the ones that are not yet added 1506 * to the bus (handshake is still in progress). 1507 * 1508 * The caller needs to hold @tb->lock. 1509 */ 1510 struct tb_xdomain *tb_xdomain_find_by_uuid(struct tb *tb, const uuid_t *uuid) 1511 { 1512 struct tb_xdomain_lookup lookup; 1513 struct tb_xdomain *xd; 1514 1515 memset(&lookup, 0, sizeof(lookup)); 1516 lookup.uuid = uuid; 1517 1518 xd = switch_find_xdomain(tb->root_switch, &lookup); 1519 return tb_xdomain_get(xd); 1520 } 1521 EXPORT_SYMBOL_GPL(tb_xdomain_find_by_uuid); 1522 1523 /** 1524 * tb_xdomain_find_by_link_depth() - Find an XDomain by link and depth 1525 * @tb: Domain where the XDomain belongs to 1526 * @link: Root switch link number 1527 * @depth: Depth in the link 1528 * 1529 * Finds XDomain by walking through the Thunderbolt topology below @tb. 1530 * The returned XDomain will have its reference count increased so the 1531 * caller needs to call tb_xdomain_put() when it is done with the 1532 * object. 1533 * 1534 * This will find all XDomains including the ones that are not yet added 1535 * to the bus (handshake is still in progress). 1536 * 1537 * The caller needs to hold @tb->lock. 1538 */ 1539 struct tb_xdomain *tb_xdomain_find_by_link_depth(struct tb *tb, u8 link, 1540 u8 depth) 1541 { 1542 struct tb_xdomain_lookup lookup; 1543 struct tb_xdomain *xd; 1544 1545 memset(&lookup, 0, sizeof(lookup)); 1546 lookup.link = link; 1547 lookup.depth = depth; 1548 1549 xd = switch_find_xdomain(tb->root_switch, &lookup); 1550 return tb_xdomain_get(xd); 1551 } 1552 1553 /** 1554 * tb_xdomain_find_by_route() - Find an XDomain by route string 1555 * @tb: Domain where the XDomain belongs to 1556 * @route: XDomain route string 1557 * 1558 * Finds XDomain by walking through the Thunderbolt topology below @tb. 1559 * The returned XDomain will have its reference count increased so the 1560 * caller needs to call tb_xdomain_put() when it is done with the 1561 * object. 1562 * 1563 * This will find all XDomains including the ones that are not yet added 1564 * to the bus (handshake is still in progress). 1565 * 1566 * The caller needs to hold @tb->lock. 1567 */ 1568 struct tb_xdomain *tb_xdomain_find_by_route(struct tb *tb, u64 route) 1569 { 1570 struct tb_xdomain_lookup lookup; 1571 struct tb_xdomain *xd; 1572 1573 memset(&lookup, 0, sizeof(lookup)); 1574 lookup.route = route; 1575 1576 xd = switch_find_xdomain(tb->root_switch, &lookup); 1577 return tb_xdomain_get(xd); 1578 } 1579 EXPORT_SYMBOL_GPL(tb_xdomain_find_by_route); 1580 1581 bool tb_xdomain_handle_request(struct tb *tb, enum tb_cfg_pkg_type type, 1582 const void *buf, size_t size) 1583 { 1584 const struct tb_protocol_handler *handler, *tmp; 1585 const struct tb_xdp_header *hdr = buf; 1586 unsigned int length; 1587 int ret = 0; 1588 1589 /* We expect the packet is at least size of the header */ 1590 length = hdr->xd_hdr.length_sn & TB_XDOMAIN_LENGTH_MASK; 1591 if (length != size / 4 - sizeof(hdr->xd_hdr) / 4) 1592 return true; 1593 if (length < sizeof(*hdr) / 4 - sizeof(hdr->xd_hdr) / 4) 1594 return true; 1595 1596 /* 1597 * Handle XDomain discovery protocol packets directly here. For 1598 * other protocols (based on their UUID) we call registered 1599 * handlers in turn. 1600 */ 1601 if (uuid_equal(&hdr->uuid, &tb_xdp_uuid)) { 1602 if (type == TB_CFG_PKG_XDOMAIN_REQ) 1603 return tb_xdp_schedule_request(tb, hdr, size); 1604 return false; 1605 } 1606 1607 mutex_lock(&xdomain_lock); 1608 list_for_each_entry_safe(handler, tmp, &protocol_handlers, list) { 1609 if (!uuid_equal(&hdr->uuid, handler->uuid)) 1610 continue; 1611 1612 mutex_unlock(&xdomain_lock); 1613 ret = handler->callback(buf, size, handler->data); 1614 mutex_lock(&xdomain_lock); 1615 1616 if (ret) 1617 break; 1618 } 1619 mutex_unlock(&xdomain_lock); 1620 1621 return ret > 0; 1622 } 1623 1624 static int update_xdomain(struct device *dev, void *data) 1625 { 1626 struct tb_xdomain *xd; 1627 1628 xd = tb_to_xdomain(dev); 1629 if (xd) { 1630 queue_delayed_work(xd->tb->wq, &xd->properties_changed_work, 1631 msecs_to_jiffies(50)); 1632 } 1633 1634 return 0; 1635 } 1636 1637 static void update_all_xdomains(void) 1638 { 1639 bus_for_each_dev(&tb_bus_type, NULL, NULL, update_xdomain); 1640 } 1641 1642 static bool remove_directory(const char *key, const struct tb_property_dir *dir) 1643 { 1644 struct tb_property *p; 1645 1646 p = tb_property_find(xdomain_property_dir, key, 1647 TB_PROPERTY_TYPE_DIRECTORY); 1648 if (p && p->value.dir == dir) { 1649 tb_property_remove(p); 1650 return true; 1651 } 1652 return false; 1653 } 1654 1655 /** 1656 * tb_register_property_dir() - Register property directory to the host 1657 * @key: Key (name) of the directory to add 1658 * @dir: Directory to add 1659 * 1660 * Service drivers can use this function to add new property directory 1661 * to the host available properties. The other connected hosts are 1662 * notified so they can re-read properties of this host if they are 1663 * interested. 1664 * 1665 * Return: %0 on success and negative errno on failure 1666 */ 1667 int tb_register_property_dir(const char *key, struct tb_property_dir *dir) 1668 { 1669 int ret; 1670 1671 if (WARN_ON(!xdomain_property_dir)) 1672 return -EAGAIN; 1673 1674 if (!key || strlen(key) > 8) 1675 return -EINVAL; 1676 1677 mutex_lock(&xdomain_lock); 1678 if (tb_property_find(xdomain_property_dir, key, 1679 TB_PROPERTY_TYPE_DIRECTORY)) { 1680 ret = -EEXIST; 1681 goto err_unlock; 1682 } 1683 1684 ret = tb_property_add_dir(xdomain_property_dir, key, dir); 1685 if (ret) 1686 goto err_unlock; 1687 1688 ret = rebuild_property_block(); 1689 if (ret) { 1690 remove_directory(key, dir); 1691 goto err_unlock; 1692 } 1693 1694 mutex_unlock(&xdomain_lock); 1695 update_all_xdomains(); 1696 return 0; 1697 1698 err_unlock: 1699 mutex_unlock(&xdomain_lock); 1700 return ret; 1701 } 1702 EXPORT_SYMBOL_GPL(tb_register_property_dir); 1703 1704 /** 1705 * tb_unregister_property_dir() - Removes property directory from host 1706 * @key: Key (name) of the directory 1707 * @dir: Directory to remove 1708 * 1709 * This will remove the existing directory from this host and notify the 1710 * connected hosts about the change. 1711 */ 1712 void tb_unregister_property_dir(const char *key, struct tb_property_dir *dir) 1713 { 1714 int ret = 0; 1715 1716 mutex_lock(&xdomain_lock); 1717 if (remove_directory(key, dir)) 1718 ret = rebuild_property_block(); 1719 mutex_unlock(&xdomain_lock); 1720 1721 if (!ret) 1722 update_all_xdomains(); 1723 } 1724 EXPORT_SYMBOL_GPL(tb_unregister_property_dir); 1725 1726 int tb_xdomain_init(void) 1727 { 1728 xdomain_property_dir = tb_property_create_dir(NULL); 1729 if (!xdomain_property_dir) 1730 return -ENOMEM; 1731 1732 /* 1733 * Initialize standard set of properties without any service 1734 * directories. Those will be added by service drivers 1735 * themselves when they are loaded. 1736 * 1737 * We also add node name later when first connection is made. 1738 */ 1739 tb_property_add_immediate(xdomain_property_dir, "vendorid", 1740 PCI_VENDOR_ID_INTEL); 1741 tb_property_add_text(xdomain_property_dir, "vendorid", "Intel Corp."); 1742 tb_property_add_immediate(xdomain_property_dir, "deviceid", 0x1); 1743 tb_property_add_immediate(xdomain_property_dir, "devicerv", 0x80000100); 1744 1745 return 0; 1746 } 1747 1748 void tb_xdomain_exit(void) 1749 { 1750 kfree(xdomain_property_block); 1751 tb_property_free_dir(xdomain_property_dir); 1752 } 1753