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