drivers/thunderbolt/xdomain.c

   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/delay.h>
  12 #include <linux/kmod.h>
  13 #include <linux/module.h>
  14 #include <linux/pm_runtime.h>
  15 #include <linux/prandom.h>
  16 #include <linux/string_helpers.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_SHORT_TIMEOUT                   100     /* ms */
  24 #define XDOMAIN_DEFAULT_TIMEOUT                 1000    /* ms */
  25 #define XDOMAIN_BONDING_TIMEOUT                 10000   /* ms */
  26 #define XDOMAIN_RETRIES                         10
  27 #define XDOMAIN_DEFAULT_MAX_HOPID               15
  28
  29 enum {
  30         XDOMAIN_STATE_INIT,
  31         XDOMAIN_STATE_UUID,
  32         XDOMAIN_STATE_LINK_STATUS,
  33         XDOMAIN_STATE_LINK_STATE_CHANGE,
  34         XDOMAIN_STATE_LINK_STATUS2,
  35         XDOMAIN_STATE_BONDING_UUID_LOW,
  36         XDOMAIN_STATE_BONDING_UUID_HIGH,
  37         XDOMAIN_STATE_PROPERTIES,
  38         XDOMAIN_STATE_ENUMERATED,
  39         XDOMAIN_STATE_ERROR,
  40 };
  41
  42 static const char * const state_names[] = {
  43         [XDOMAIN_STATE_INIT] = "INIT",
  44         [XDOMAIN_STATE_UUID] = "UUID",
  45         [XDOMAIN_STATE_LINK_STATUS] = "LINK_STATUS",
  46         [XDOMAIN_STATE_LINK_STATE_CHANGE] = "LINK_STATE_CHANGE",
  47         [XDOMAIN_STATE_LINK_STATUS2] = "LINK_STATUS2",
  48         [XDOMAIN_STATE_BONDING_UUID_LOW] = "BONDING_UUID_LOW",
  49         [XDOMAIN_STATE_BONDING_UUID_HIGH] = "BONDING_UUID_HIGH",
  50         [XDOMAIN_STATE_PROPERTIES] = "PROPERTIES",
  51         [XDOMAIN_STATE_ENUMERATED] = "ENUMERATED",
  52         [XDOMAIN_STATE_ERROR] = "ERROR",
  53 };
  54
  55 struct xdomain_request_work {
  56         struct work_struct work;
  57         struct tb_xdp_header *pkg;
  58         struct tb *tb;
  59 };
  60
  61 static bool tb_xdomain_enabled = true;
  62 module_param_named(xdomain, tb_xdomain_enabled, bool, 0444);
  63 MODULE_PARM_DESC(xdomain, "allow XDomain protocol (default: true)");
  64
  65 /*
  66  * Serializes access to the properties and protocol handlers below. If
  67  * you need to take both this lock and the struct tb_xdomain lock, take
  68  * this one first.
  69  */
  70 static DEFINE_MUTEX(xdomain_lock);
  71
  72 /* Properties exposed to the remote domains */
  73 static struct tb_property_dir *xdomain_property_dir;
  74 static u32 xdomain_property_block_gen;
  75
  76 /* Additional protocol handlers */
  77 static LIST_HEAD(protocol_handlers);
  78
  79 /* UUID for XDomain discovery protocol: b638d70e-42ff-40bb-97c2-90e2c0b2ff07 */
  80 static const uuid_t tb_xdp_uuid =
  81         UUID_INIT(0xb638d70e, 0x42ff, 0x40bb,
  82                   0x97, 0xc2, 0x90, 0xe2, 0xc0, 0xb2, 0xff, 0x07);
  83
  84 bool tb_is_xdomain_enabled(void)
  85 {
  86         return tb_xdomain_enabled && tb_acpi_is_xdomain_allowed();
  87 }
  88
  89 static bool tb_xdomain_match(const struct tb_cfg_request *req,
  90                              const struct ctl_pkg *pkg)
  91 {
  92         switch (pkg->frame.eof) {
  93         case TB_CFG_PKG_ERROR:
  94                 return true;
  95
  96         case TB_CFG_PKG_XDOMAIN_RESP: {
  97                 const struct tb_xdp_header *res_hdr = pkg->buffer;
  98                 const struct tb_xdp_header *req_hdr = req->request;
  99
 100                 if (pkg->frame.size < req->response_size / 4)
 101                         return false;
 102
 103                 /* Make sure route matches */
 104                 if ((res_hdr->xd_hdr.route_hi & ~BIT(31)) !=
 105                      req_hdr->xd_hdr.route_hi)
 106                         return false;
 107                 if ((res_hdr->xd_hdr.route_lo) != req_hdr->xd_hdr.route_lo)
 108                         return false;
 109
 110                 /* Check that the XDomain protocol matches */
 111                 if (!uuid_equal(&res_hdr->uuid, &req_hdr->uuid))
 112                         return false;
 113
 114                 return true;
 115         }
 116
 117         default:
 118                 return false;
 119         }
 120 }
 121
 122 static bool tb_xdomain_copy(struct tb_cfg_request *req,
 123                             const struct ctl_pkg *pkg)
 124 {
 125         memcpy(req->response, pkg->buffer, req->response_size);
 126         req->result.err = 0;
 127         return true;
 128 }
 129
 130 static void response_ready(void *data)
 131 {
 132         tb_cfg_request_put(data);
 133 }
 134
 135 static int __tb_xdomain_response(struct tb_ctl *ctl, const void *response,
 136                                  size_t size, enum tb_cfg_pkg_type type)
 137 {
 138         struct tb_cfg_request *req;
 139
 140         req = tb_cfg_request_alloc();
 141         if (!req)
 142                 return -ENOMEM;
 143
 144         req->match = tb_xdomain_match;
 145         req->copy = tb_xdomain_copy;
 146         req->request = response;
 147         req->request_size = size;
 148         req->request_type = type;
 149
 150         return tb_cfg_request(ctl, req, response_ready, req);
 151 }
 152
 153 /**
 154  * tb_xdomain_response() - Send a XDomain response message
 155  * @xd: XDomain to send the message
 156  * @response: Response to send
 157  * @size: Size of the response
 158  * @type: PDF type of the response
 159  *
 160  * This can be used to send a XDomain response message to the other
 161  * domain. No response for the message is expected.
 162  *
 163  * Return: %0 in case of success and negative errno in case of failure
 164  */
 165 int tb_xdomain_response(struct tb_xdomain *xd, const void *response,
 166                         size_t size, enum tb_cfg_pkg_type type)
 167 {
 168         return __tb_xdomain_response(xd->tb->ctl, response, size, type);
 169 }
 170 EXPORT_SYMBOL_GPL(tb_xdomain_response);
 171
 172 static int __tb_xdomain_request(struct tb_ctl *ctl, const void *request,
 173         size_t request_size, enum tb_cfg_pkg_type request_type, void *response,
 174         size_t response_size, enum tb_cfg_pkg_type response_type,
 175         unsigned int timeout_msec)
 176 {
 177         struct tb_cfg_request *req;
 178         struct tb_cfg_result res;
 179
 180         req = tb_cfg_request_alloc();
 181         if (!req)
 182                 return -ENOMEM;
 183
 184         req->match = tb_xdomain_match;
 185         req->copy = tb_xdomain_copy;
 186         req->request = request;
 187         req->request_size = request_size;
 188         req->request_type = request_type;
 189         req->response = response;
 190         req->response_size = response_size;
 191         req->response_type = response_type;
 192
 193         res = tb_cfg_request_sync(ctl, req, timeout_msec);
 194
 195         tb_cfg_request_put(req);
 196
 197         return res.err == 1 ? -EIO : res.err;
 198 }
 199
 200 /**
 201  * tb_xdomain_request() - Send a XDomain request
 202  * @xd: XDomain to send the request
 203  * @request: Request to send
 204  * @request_size: Size of the request in bytes
 205  * @request_type: PDF type of the request
 206  * @response: Response is copied here
 207  * @response_size: Expected size of the response in bytes
 208  * @response_type: Expected PDF type of the response
 209  * @timeout_msec: Timeout in milliseconds to wait for the response
 210  *
 211  * This function can be used to send XDomain control channel messages to
 212  * the other domain. The function waits until the response is received
 213  * or when timeout triggers. Whichever comes first.
 214  *
 215  * Return: %0 in case of success and negative errno in case of failure
 216  */
 217 int tb_xdomain_request(struct tb_xdomain *xd, const void *request,
 218         size_t request_size, enum tb_cfg_pkg_type request_type,
 219         void *response, size_t response_size,
 220         enum tb_cfg_pkg_type response_type, unsigned int timeout_msec)
 221 {
 222         return __tb_xdomain_request(xd->tb->ctl, request, request_size,
 223                                     request_type, response, response_size,
 224                                     response_type, timeout_msec);
 225 }
 226 EXPORT_SYMBOL_GPL(tb_xdomain_request);
 227
 228 static inline void tb_xdp_fill_header(struct tb_xdp_header *hdr, u64 route,
 229         u8 sequence, enum tb_xdp_type type, size_t size)
 230 {
 231         u32 length_sn;
 232
 233         length_sn = (size - sizeof(hdr->xd_hdr)) / 4;
 234         length_sn |= (sequence << TB_XDOMAIN_SN_SHIFT) & TB_XDOMAIN_SN_MASK;
 235
 236         hdr->xd_hdr.route_hi = upper_32_bits(route);
 237         hdr->xd_hdr.route_lo = lower_32_bits(route);
 238         hdr->xd_hdr.length_sn = length_sn;
 239         hdr->type = type;
 240         memcpy(&hdr->uuid, &tb_xdp_uuid, sizeof(tb_xdp_uuid));
 241 }
 242
 243 static int tb_xdp_handle_error(const struct tb_xdp_error_response *res)
 244 {
 245         if (res->hdr.type != ERROR_RESPONSE)
 246                 return 0;
 247
 248         switch (res->error) {
 249         case ERROR_UNKNOWN_PACKET:
 250         case ERROR_UNKNOWN_DOMAIN:
 251                 return -EIO;
 252         case ERROR_NOT_SUPPORTED:
 253                 return -ENOTSUPP;
 254         case ERROR_NOT_READY:
 255                 return -EAGAIN;
 256         default:
 257                 break;
 258         }
 259
 260         return 0;
 261 }
 262
 263 static int tb_xdp_uuid_request(struct tb_ctl *ctl, u64 route, int retry,
 264                                uuid_t *uuid, u64 *remote_route)
 265 {
 266         struct tb_xdp_uuid_response res;
 267         struct tb_xdp_uuid req;
 268         int ret;
 269
 270         memset(&req, 0, sizeof(req));
 271         tb_xdp_fill_header(&req.hdr, route, retry % 4, UUID_REQUEST,
 272                            sizeof(req));
 273
 274         memset(&res, 0, sizeof(res));
 275         ret = __tb_xdomain_request(ctl, &req, sizeof(req),
 276                                    TB_CFG_PKG_XDOMAIN_REQ, &res, sizeof(res),
 277                                    TB_CFG_PKG_XDOMAIN_RESP,
 278                                    XDOMAIN_DEFAULT_TIMEOUT);
 279         if (ret)
 280                 return ret;
 281
 282         ret = tb_xdp_handle_error(&res.err);
 283         if (ret)
 284                 return ret;
 285
 286         uuid_copy(uuid, &res.src_uuid);
 287         *remote_route = (u64)res.src_route_hi << 32 | res.src_route_lo;
 288
 289         return 0;
 290 }
 291
 292 static int tb_xdp_uuid_response(struct tb_ctl *ctl, u64 route, u8 sequence,
 293                                 const uuid_t *uuid)
 294 {
 295         struct tb_xdp_uuid_response res;
 296
 297         memset(&res, 0, sizeof(res));
 298         tb_xdp_fill_header(&res.hdr, route, sequence, UUID_RESPONSE,
 299                            sizeof(res));
 300
 301         uuid_copy(&res.src_uuid, uuid);
 302         res.src_route_hi = upper_32_bits(route);
 303         res.src_route_lo = lower_32_bits(route);
 304
 305         return __tb_xdomain_response(ctl, &res, sizeof(res),
 306                                      TB_CFG_PKG_XDOMAIN_RESP);
 307 }
 308
 309 static int tb_xdp_error_response(struct tb_ctl *ctl, u64 route, u8 sequence,
 310                                  enum tb_xdp_error error)
 311 {
 312         struct tb_xdp_error_response res;
 313
 314         memset(&res, 0, sizeof(res));
 315         tb_xdp_fill_header(&res.hdr, route, sequence, ERROR_RESPONSE,
 316                            sizeof(res));
 317         res.error = error;
 318
 319         return __tb_xdomain_response(ctl, &res, sizeof(res),
 320                                      TB_CFG_PKG_XDOMAIN_RESP);
 321 }
 322
 323 static int tb_xdp_properties_request(struct tb_ctl *ctl, u64 route,
 324         const uuid_t *src_uuid, const uuid_t *dst_uuid, int retry,
 325         u32 **block, u32 *generation)
 326 {
 327         struct tb_xdp_properties_response *res;
 328         struct tb_xdp_properties req;
 329         u16 data_len, len;
 330         size_t total_size;
 331         u32 *data = NULL;
 332         int ret;
 333
 334         total_size = sizeof(*res) + TB_XDP_PROPERTIES_MAX_DATA_LENGTH * 4;
 335         res = kzalloc(total_size, GFP_KERNEL);
 336         if (!res)
 337                 return -ENOMEM;
 338
 339         memset(&req, 0, sizeof(req));
 340         tb_xdp_fill_header(&req.hdr, route, retry % 4, PROPERTIES_REQUEST,
 341                            sizeof(req));
 342         memcpy(&req.src_uuid, src_uuid, sizeof(*src_uuid));
 343         memcpy(&req.dst_uuid, dst_uuid, sizeof(*dst_uuid));
 344
 345         data_len = 0;
 346
 347         do {
 348                 ret = __tb_xdomain_request(ctl, &req, sizeof(req),
 349                                            TB_CFG_PKG_XDOMAIN_REQ, res,
 350                                            total_size, TB_CFG_PKG_XDOMAIN_RESP,
 351                                            XDOMAIN_DEFAULT_TIMEOUT);
 352                 if (ret)
 353                         goto err;
 354
 355                 ret = tb_xdp_handle_error(&res->err);
 356                 if (ret)
 357                         goto err;
 358
 359                 /*
 360                  * Package length includes the whole payload without the
 361                  * XDomain header. Validate first that the package is at
 362                  * least size of the response structure.
 363                  */
 364                 len = res->hdr.xd_hdr.length_sn & TB_XDOMAIN_LENGTH_MASK;
 365                 if (len < sizeof(*res) / 4) {
 366                         ret = -EINVAL;
 367                         goto err;
 368                 }
 369
 370                 len += sizeof(res->hdr.xd_hdr) / 4;
 371                 len -= sizeof(*res) / 4;
 372
 373                 if (res->offset != req.offset) {
 374                         ret = -EINVAL;
 375                         goto err;
 376                 }
 377
 378                 /*
 379                  * First time allocate block that has enough space for
 380                  * the whole properties block.
 381                  */
 382                 if (!data) {
 383                         data_len = res->data_length;
 384                         if (data_len > TB_XDP_PROPERTIES_MAX_LENGTH) {
 385                                 ret = -E2BIG;
 386                                 goto err;
 387                         }
 388
 389                         data = kcalloc(data_len, sizeof(u32), GFP_KERNEL);
 390                         if (!data) {
 391                                 ret = -ENOMEM;
 392                                 goto err;
 393                         }
 394                 }
 395
 396                 memcpy(data + req.offset, res->data, len * 4);
 397                 req.offset += len;
 398         } while (!data_len || req.offset < data_len);
 399
 400         *block = data;
 401         *generation = res->generation;
 402
 403         kfree(res);
 404
 405         return data_len;
 406
 407 err:
 408         kfree(data);
 409         kfree(res);
 410
 411         return ret;
 412 }
 413
 414 static int tb_xdp_properties_response(struct tb *tb, struct tb_ctl *ctl,
 415         struct tb_xdomain *xd, u8 sequence, const struct tb_xdp_properties *req)
 416 {
 417         struct tb_xdp_properties_response *res;
 418         size_t total_size;
 419         u16 len;
 420         int ret;
 421
 422         /*
 423          * Currently we expect all requests to be directed to us. The
 424          * protocol supports forwarding, though which we might add
 425          * support later on.
 426          */
 427         if (!uuid_equal(xd->local_uuid, &req->dst_uuid)) {
 428                 tb_xdp_error_response(ctl, xd->route, sequence,
 429                                       ERROR_UNKNOWN_DOMAIN);
 430                 return 0;
 431         }
 432
 433         mutex_lock(&xd->lock);
 434
 435         if (req->offset >= xd->local_property_block_len) {
 436                 mutex_unlock(&xd->lock);
 437                 return -EINVAL;
 438         }
 439
 440         len = xd->local_property_block_len - req->offset;
 441         len = min_t(u16, len, TB_XDP_PROPERTIES_MAX_DATA_LENGTH);
 442         total_size = sizeof(*res) + len * 4;
 443
 444         res = kzalloc(total_size, GFP_KERNEL);
 445         if (!res) {
 446                 mutex_unlock(&xd->lock);
 447                 return -ENOMEM;
 448         }
 449
 450         tb_xdp_fill_header(&res->hdr, xd->route, sequence, PROPERTIES_RESPONSE,
 451                            total_size);
 452         res->generation = xd->local_property_block_gen;
 453         res->data_length = xd->local_property_block_len;
 454         res->offset = req->offset;
 455         uuid_copy(&res->src_uuid, xd->local_uuid);
 456         uuid_copy(&res->dst_uuid, &req->src_uuid);
 457         memcpy(res->data, &xd->local_property_block[req->offset], len * 4);
 458
 459         mutex_unlock(&xd->lock);
 460
 461         ret = __tb_xdomain_response(ctl, res, total_size,
 462                                     TB_CFG_PKG_XDOMAIN_RESP);
 463
 464         kfree(res);
 465         return ret;
 466 }
 467
 468 static int tb_xdp_properties_changed_request(struct tb_ctl *ctl, u64 route,
 469                                              int retry, const uuid_t *uuid)
 470 {
 471         struct tb_xdp_properties_changed_response res;
 472         struct tb_xdp_properties_changed req;
 473         int ret;
 474
 475         memset(&req, 0, sizeof(req));
 476         tb_xdp_fill_header(&req.hdr, route, retry % 4,
 477                            PROPERTIES_CHANGED_REQUEST, sizeof(req));
 478         uuid_copy(&req.src_uuid, uuid);
 479
 480         memset(&res, 0, sizeof(res));
 481         ret = __tb_xdomain_request(ctl, &req, sizeof(req),
 482                                    TB_CFG_PKG_XDOMAIN_REQ, &res, sizeof(res),
 483                                    TB_CFG_PKG_XDOMAIN_RESP,
 484                                    XDOMAIN_DEFAULT_TIMEOUT);
 485         if (ret)
 486                 return ret;
 487
 488         return tb_xdp_handle_error(&res.err);
 489 }
 490
 491 static int
 492 tb_xdp_properties_changed_response(struct tb_ctl *ctl, u64 route, u8 sequence)
 493 {
 494         struct tb_xdp_properties_changed_response res;
 495
 496         memset(&res, 0, sizeof(res));
 497         tb_xdp_fill_header(&res.hdr, route, sequence,
 498                            PROPERTIES_CHANGED_RESPONSE, sizeof(res));
 499         return __tb_xdomain_response(ctl, &res, sizeof(res),
 500                                      TB_CFG_PKG_XDOMAIN_RESP);
 501 }
 502
 503 static int tb_xdp_link_state_status_request(struct tb_ctl *ctl, u64 route,
 504                                             u8 sequence, u8 *slw, u8 *tlw,
 505                                             u8 *sls, u8 *tls)
 506 {
 507         struct tb_xdp_link_state_status_response res;
 508         struct tb_xdp_link_state_status req;
 509         int ret;
 510
 511         memset(&req, 0, sizeof(req));
 512         tb_xdp_fill_header(&req.hdr, route, sequence, LINK_STATE_STATUS_REQUEST,
 513                            sizeof(req));
 514
 515         memset(&res, 0, sizeof(res));
 516         ret = __tb_xdomain_request(ctl, &req, sizeof(req), TB_CFG_PKG_XDOMAIN_REQ,
 517                                    &res, sizeof(res), TB_CFG_PKG_XDOMAIN_RESP,
 518                                    XDOMAIN_DEFAULT_TIMEOUT);
 519         if (ret)
 520                 return ret;
 521
 522         ret = tb_xdp_handle_error(&res.err);
 523         if (ret)
 524                 return ret;
 525
 526         if (res.status != 0)
 527                 return -EREMOTEIO;
 528
 529         *slw = res.slw;
 530         *tlw = res.tlw;
 531         *sls = res.sls;
 532         *tls = res.tls;
 533
 534         return 0;
 535 }
 536
 537 static int tb_xdp_link_state_status_response(struct tb *tb, struct tb_ctl *ctl,
 538                                              struct tb_xdomain *xd, u8 sequence)
 539 {
 540         struct tb_xdp_link_state_status_response res;
 541         struct tb_port *port = tb_xdomain_downstream_port(xd);
 542         u32 val[2];
 543         int ret;
 544
 545         memset(&res, 0, sizeof(res));
 546         tb_xdp_fill_header(&res.hdr, xd->route, sequence,
 547                            LINK_STATE_STATUS_RESPONSE, sizeof(res));
 548
 549         ret = tb_port_read(port, val, TB_CFG_PORT,
 550                            port->cap_phy + LANE_ADP_CS_0, ARRAY_SIZE(val));
 551         if (ret)
 552                 return ret;
 553
 554         res.slw = (val[0] & LANE_ADP_CS_0_SUPPORTED_WIDTH_MASK) >>
 555                         LANE_ADP_CS_0_SUPPORTED_WIDTH_SHIFT;
 556         res.sls = (val[0] & LANE_ADP_CS_0_SUPPORTED_SPEED_MASK) >>
 557                         LANE_ADP_CS_0_SUPPORTED_SPEED_SHIFT;
 558         res.tls = val[1] & LANE_ADP_CS_1_TARGET_SPEED_MASK;
 559         res.tlw = (val[1] & LANE_ADP_CS_1_TARGET_WIDTH_MASK) >>
 560                         LANE_ADP_CS_1_TARGET_WIDTH_SHIFT;
 561
 562         return __tb_xdomain_response(ctl, &res, sizeof(res),
 563                                      TB_CFG_PKG_XDOMAIN_RESP);
 564 }
 565
 566 static int tb_xdp_link_state_change_request(struct tb_ctl *ctl, u64 route,
 567                                             u8 sequence, u8 tlw, u8 tls)
 568 {
 569         struct tb_xdp_link_state_change_response res;
 570         struct tb_xdp_link_state_change req;
 571         int ret;
 572
 573         memset(&req, 0, sizeof(req));
 574         tb_xdp_fill_header(&req.hdr, route, sequence, LINK_STATE_CHANGE_REQUEST,
 575                            sizeof(req));
 576         req.tlw = tlw;
 577         req.tls = tls;
 578
 579         memset(&res, 0, sizeof(res));
 580         ret = __tb_xdomain_request(ctl, &req, sizeof(req), TB_CFG_PKG_XDOMAIN_REQ,
 581                                    &res, sizeof(res), TB_CFG_PKG_XDOMAIN_RESP,
 582                                    XDOMAIN_DEFAULT_TIMEOUT);
 583         if (ret)
 584                 return ret;
 585
 586         ret = tb_xdp_handle_error(&res.err);
 587         if (ret)
 588                 return ret;
 589
 590         return res.status != 0 ? -EREMOTEIO : 0;
 591 }
 592
 593 static int tb_xdp_link_state_change_response(struct tb_ctl *ctl, u64 route,
 594                                              u8 sequence, u32 status)
 595 {
 596         struct tb_xdp_link_state_change_response res;
 597
 598         memset(&res, 0, sizeof(res));
 599         tb_xdp_fill_header(&res.hdr, route, sequence, LINK_STATE_CHANGE_RESPONSE,
 600                            sizeof(res));
 601
 602         res.status = status;
 603
 604         return __tb_xdomain_response(ctl, &res, sizeof(res),
 605                                      TB_CFG_PKG_XDOMAIN_RESP);
 606 }
 607
 608 /**
 609  * tb_register_protocol_handler() - Register protocol handler
 610  * @handler: Handler to register
 611  *
 612  * This allows XDomain service drivers to hook into incoming XDomain
 613  * messages. After this function is called the service driver needs to
 614  * be able to handle calls to callback whenever a package with the
 615  * registered protocol is received.
 616  */
 617 int tb_register_protocol_handler(struct tb_protocol_handler *handler)
 618 {
 619         if (!handler->uuid || !handler->callback)
 620                 return -EINVAL;
 621         if (uuid_equal(handler->uuid, &tb_xdp_uuid))
 622                 return -EINVAL;
 623
 624         mutex_lock(&xdomain_lock);
 625         list_add_tail(&handler->list, &protocol_handlers);
 626         mutex_unlock(&xdomain_lock);
 627
 628         return 0;
 629 }
 630 EXPORT_SYMBOL_GPL(tb_register_protocol_handler);
 631
 632 /**
 633  * tb_unregister_protocol_handler() - Unregister protocol handler
 634  * @handler: Handler to unregister
 635  *
 636  * Removes the previously registered protocol handler.
 637  */
 638 void tb_unregister_protocol_handler(struct tb_protocol_handler *handler)
 639 {
 640         mutex_lock(&xdomain_lock);
 641         list_del_init(&handler->list);
 642         mutex_unlock(&xdomain_lock);
 643 }
 644 EXPORT_SYMBOL_GPL(tb_unregister_protocol_handler);
 645
 646 static void update_property_block(struct tb_xdomain *xd)
 647 {
 648         mutex_lock(&xdomain_lock);
 649         mutex_lock(&xd->lock);
 650         /*
 651          * If the local property block is not up-to-date, rebuild it now
 652          * based on the global property template.
 653          */
 654         if (!xd->local_property_block ||
 655             xd->local_property_block_gen < xdomain_property_block_gen) {
 656                 struct tb_property_dir *dir;
 657                 int ret, block_len;
 658                 u32 *block;
 659
 660                 dir = tb_property_copy_dir(xdomain_property_dir);
 661                 if (!dir) {
 662                         dev_warn(&xd->dev, "failed to copy properties\n");
 663                         goto out_unlock;
 664                 }
 665
 666                 /* Fill in non-static properties now */
 667                 tb_property_add_text(dir, "deviceid", utsname()->nodename);
 668                 tb_property_add_immediate(dir, "maxhopid", xd->local_max_hopid);
 669
 670                 ret = tb_property_format_dir(dir, NULL, 0);
 671                 if (ret < 0) {
 672                         dev_warn(&xd->dev, "local property block creation failed\n");
 673                         tb_property_free_dir(dir);
 674                         goto out_unlock;
 675                 }
 676
 677                 block_len = ret;
 678                 block = kcalloc(block_len, sizeof(*block), GFP_KERNEL);
 679                 if (!block) {
 680                         tb_property_free_dir(dir);
 681                         goto out_unlock;
 682                 }
 683
 684                 ret = tb_property_format_dir(dir, block, block_len);
 685                 if (ret) {
 686                         dev_warn(&xd->dev, "property block generation failed\n");
 687                         tb_property_free_dir(dir);
 688                         kfree(block);
 689                         goto out_unlock;
 690                 }
 691
 692                 tb_property_free_dir(dir);
 693                 /* Release the previous block */
 694                 kfree(xd->local_property_block);
 695                 /* Assign new one */
 696                 xd->local_property_block = block;
 697                 xd->local_property_block_len = block_len;
 698                 xd->local_property_block_gen = xdomain_property_block_gen;
 699         }
 700
 701 out_unlock:
 702         mutex_unlock(&xd->lock);
 703         mutex_unlock(&xdomain_lock);
 704 }
 705
 706 static void start_handshake(struct tb_xdomain *xd)
 707 {
 708         xd->state = XDOMAIN_STATE_INIT;
 709         queue_delayed_work(xd->tb->wq, &xd->state_work,
 710                            msecs_to_jiffies(XDOMAIN_SHORT_TIMEOUT));
 711 }
 712
 713 /* Can be called from state_work */
 714 static void __stop_handshake(struct tb_xdomain *xd)
 715 {
 716         cancel_delayed_work_sync(&xd->properties_changed_work);
 717         xd->properties_changed_retries = 0;
 718         xd->state_retries = 0;
 719 }
 720
 721 static void stop_handshake(struct tb_xdomain *xd)
 722 {
 723         cancel_delayed_work_sync(&xd->state_work);
 724         __stop_handshake(xd);
 725 }
 726
 727 static void tb_xdp_handle_request(struct work_struct *work)
 728 {
 729         struct xdomain_request_work *xw = container_of(work, typeof(*xw), work);
 730         const struct tb_xdp_header *pkg = xw->pkg;
 731         const struct tb_xdomain_header *xhdr = &pkg->xd_hdr;
 732         struct tb *tb = xw->tb;
 733         struct tb_ctl *ctl = tb->ctl;
 734         struct tb_xdomain *xd;
 735         const uuid_t *uuid;
 736         int ret = 0;
 737         u32 sequence;
 738         u64 route;
 739
 740         route = ((u64)xhdr->route_hi << 32 | xhdr->route_lo) & ~BIT_ULL(63);
 741         sequence = xhdr->length_sn & TB_XDOMAIN_SN_MASK;
 742         sequence >>= TB_XDOMAIN_SN_SHIFT;
 743
 744         mutex_lock(&tb->lock);
 745         if (tb->root_switch)
 746                 uuid = tb->root_switch->uuid;
 747         else
 748                 uuid = NULL;
 749         mutex_unlock(&tb->lock);
 750
 751         if (!uuid) {
 752                 tb_xdp_error_response(ctl, route, sequence, ERROR_NOT_READY);
 753                 goto out;
 754         }
 755
 756         xd = tb_xdomain_find_by_route_locked(tb, route);
 757         if (xd)
 758                 update_property_block(xd);
 759
 760         switch (pkg->type) {
 761         case PROPERTIES_REQUEST:
 762                 tb_dbg(tb, "%llx: received XDomain properties request\n", route);
 763                 if (xd) {
 764                         ret = tb_xdp_properties_response(tb, ctl, xd, sequence,
 765                                 (const struct tb_xdp_properties *)pkg);
 766                 }
 767                 break;
 768
 769         case PROPERTIES_CHANGED_REQUEST:
 770                 tb_dbg(tb, "%llx: received XDomain properties changed request\n",
 771                        route);
 772
 773                 ret = tb_xdp_properties_changed_response(ctl, route, sequence);
 774
 775                 /*
 776                  * Since the properties have been changed, let's update
 777                  * the xdomain related to this connection as well in
 778                  * case there is a change in services it offers.
 779                  */
 780                 if (xd && device_is_registered(&xd->dev))
 781                         queue_delayed_work(tb->wq, &xd->state_work,
 782                                            msecs_to_jiffies(XDOMAIN_SHORT_TIMEOUT));
 783                 break;
 784
 785         case UUID_REQUEST_OLD:
 786         case UUID_REQUEST:
 787                 tb_dbg(tb, "%llx: received XDomain UUID request\n", route);
 788                 ret = tb_xdp_uuid_response(ctl, route, sequence, uuid);
 789                 /*
 790                  * If we've stopped the discovery with an error such as
 791                  * timing out, we will restart the handshake now that we
 792                  * received UUID request from the remote host.
 793                  */
 794                 if (!ret && xd && xd->state == XDOMAIN_STATE_ERROR) {
 795                         dev_dbg(&xd->dev, "restarting handshake\n");
 796                         start_handshake(xd);
 797                 }
 798                 break;
 799
 800         case LINK_STATE_STATUS_REQUEST:
 801                 tb_dbg(tb, "%llx: received XDomain link state status request\n",
 802                        route);
 803
 804                 if (xd) {
 805                         ret = tb_xdp_link_state_status_response(tb, ctl, xd,
 806                                                                 sequence);
 807                 } else {
 808                         tb_xdp_error_response(ctl, route, sequence,
 809                                               ERROR_NOT_READY);
 810                 }
 811                 break;
 812
 813         case LINK_STATE_CHANGE_REQUEST:
 814                 tb_dbg(tb, "%llx: received XDomain link state change request\n",
 815                        route);
 816
 817                 if (xd && xd->state == XDOMAIN_STATE_BONDING_UUID_HIGH) {
 818                         const struct tb_xdp_link_state_change *lsc =
 819                                 (const struct tb_xdp_link_state_change *)pkg;
 820
 821                         ret = tb_xdp_link_state_change_response(ctl, route,
 822                                                                 sequence, 0);
 823                         xd->target_link_width = lsc->tlw;
 824                         queue_delayed_work(tb->wq, &xd->state_work,
 825                                            msecs_to_jiffies(XDOMAIN_SHORT_TIMEOUT));
 826                 } else {
 827                         tb_xdp_error_response(ctl, route, sequence,
 828                                               ERROR_NOT_READY);
 829                 }
 830                 break;
 831
 832         default:
 833                 tb_dbg(tb, "%llx: unknown XDomain request %#x\n", route, pkg->type);
 834                 tb_xdp_error_response(ctl, route, sequence,
 835                                       ERROR_NOT_SUPPORTED);
 836                 break;
 837         }
 838
 839         tb_xdomain_put(xd);
 840
 841         if (ret) {
 842                 tb_warn(tb, "failed to send XDomain response for %#x\n",
 843                         pkg->type);
 844         }
 845
 846 out:
 847         kfree(xw->pkg);
 848         kfree(xw);
 849
 850         tb_domain_put(tb);
 851 }
 852
 853 static bool
 854 tb_xdp_schedule_request(struct tb *tb, const struct tb_xdp_header *hdr,
 855                         size_t size)
 856 {
 857         struct xdomain_request_work *xw;
 858
 859         xw = kmalloc(sizeof(*xw), GFP_KERNEL);
 860         if (!xw)
 861                 return false;
 862
 863         INIT_WORK(&xw->work, tb_xdp_handle_request);
 864         xw->pkg = kmemdup(hdr, size, GFP_KERNEL);
 865         if (!xw->pkg) {
 866                 kfree(xw);
 867                 return false;
 868         }
 869         xw->tb = tb_domain_get(tb);
 870
 871         schedule_work(&xw->work);
 872         return true;
 873 }
 874
 875 /**
 876  * tb_register_service_driver() - Register XDomain service driver
 877  * @drv: Driver to register
 878  *
 879  * Registers new service driver from @drv to the bus.
 880  */
 881 int tb_register_service_driver(struct tb_service_driver *drv)
 882 {
 883         drv->driver.bus = &tb_bus_type;
 884         return driver_register(&drv->driver);
 885 }
 886 EXPORT_SYMBOL_GPL(tb_register_service_driver);
 887
 888 /**
 889  * tb_unregister_service_driver() - Unregister XDomain service driver
 890  * @drv: Driver to unregister
 891  *
 892  * Unregisters XDomain service driver from the bus.
 893  */
 894 void tb_unregister_service_driver(struct tb_service_driver *drv)
 895 {
 896         driver_unregister(&drv->driver);
 897 }
 898 EXPORT_SYMBOL_GPL(tb_unregister_service_driver);
 899
 900 static ssize_t key_show(struct device *dev, struct device_attribute *attr,
 901                         char *buf)
 902 {
 903         struct tb_service *svc = container_of(dev, struct tb_service, dev);
 904
 905         /*
 906          * It should be null terminated but anything else is pretty much
 907          * allowed.
 908          */
 909         return sysfs_emit(buf, "%*pE\n", (int)strlen(svc->key), svc->key);
 910 }
 911 static DEVICE_ATTR_RO(key);
 912
 913 static int get_modalias(const struct tb_service *svc, char *buf, size_t size)
 914 {
 915         return snprintf(buf, size, "tbsvc:k%sp%08Xv%08Xr%08X", svc->key,
 916                         svc->prtcid, svc->prtcvers, svc->prtcrevs);
 917 }
 918
 919 static ssize_t modalias_show(struct device *dev, struct device_attribute *attr,
 920                              char *buf)
 921 {
 922         struct tb_service *svc = container_of(dev, struct tb_service, dev);
 923
 924         /* Full buffer size except new line and null termination */
 925         get_modalias(svc, buf, PAGE_SIZE - 2);
 926         return strlen(strcat(buf, "\n"));
 927 }
 928 static DEVICE_ATTR_RO(modalias);
 929
 930 static ssize_t prtcid_show(struct device *dev, struct device_attribute *attr,
 931                            char *buf)
 932 {
 933         struct tb_service *svc = container_of(dev, struct tb_service, dev);
 934
 935         return sysfs_emit(buf, "%u\n", svc->prtcid);
 936 }
 937 static DEVICE_ATTR_RO(prtcid);
 938
 939 static ssize_t prtcvers_show(struct device *dev, struct device_attribute *attr,
 940                              char *buf)
 941 {
 942         struct tb_service *svc = container_of(dev, struct tb_service, dev);
 943
 944         return sysfs_emit(buf, "%u\n", svc->prtcvers);
 945 }
 946 static DEVICE_ATTR_RO(prtcvers);
 947
 948 static ssize_t prtcrevs_show(struct device *dev, struct device_attribute *attr,
 949                              char *buf)
 950 {
 951         struct tb_service *svc = container_of(dev, struct tb_service, dev);
 952
 953         return sysfs_emit(buf, "%u\n", svc->prtcrevs);
 954 }
 955 static DEVICE_ATTR_RO(prtcrevs);
 956
 957 static ssize_t prtcstns_show(struct device *dev, struct device_attribute *attr,
 958                              char *buf)
 959 {
 960         struct tb_service *svc = container_of(dev, struct tb_service, dev);
 961
 962         return sysfs_emit(buf, "0x%08x\n", svc->prtcstns);
 963 }
 964 static DEVICE_ATTR_RO(prtcstns);
 965
 966 static struct attribute *tb_service_attrs[] = {
 967         &dev_attr_key.attr,
 968         &dev_attr_modalias.attr,
 969         &dev_attr_prtcid.attr,
 970         &dev_attr_prtcvers.attr,
 971         &dev_attr_prtcrevs.attr,
 972         &dev_attr_prtcstns.attr,
 973         NULL,
 974 };
 975
 976 static const struct attribute_group tb_service_attr_group = {
 977         .attrs = tb_service_attrs,
 978 };
 979
 980 static const struct attribute_group *tb_service_attr_groups[] = {
 981         &tb_service_attr_group,
 982         NULL,
 983 };
 984
 985 static int tb_service_uevent(const struct device *dev, struct kobj_uevent_env *env)
 986 {
 987         const struct tb_service *svc = container_of_const(dev, struct tb_service, dev);
 988         char modalias[64];
 989
 990         get_modalias(svc, modalias, sizeof(modalias));
 991         return add_uevent_var(env, "MODALIAS=%s", modalias);
 992 }
 993
 994 static void tb_service_release(struct device *dev)
 995 {
 996         struct tb_service *svc = container_of(dev, struct tb_service, dev);
 997         struct tb_xdomain *xd = tb_service_parent(svc);
 998
 999         tb_service_debugfs_remove(svc);
1000         ida_free(&xd->service_ids, svc->id);
1001         kfree(svc->key);
1002         kfree(svc);
1003 }
1004
1005 const struct device_type tb_service_type = {
1006         .name = "thunderbolt_service",
1007         .groups = tb_service_attr_groups,
1008         .uevent = tb_service_uevent,
1009         .release = tb_service_release,
1010 };
1011 EXPORT_SYMBOL_GPL(tb_service_type);
1012
1013 static int remove_missing_service(struct device *dev, void *data)
1014 {
1015         struct tb_xdomain *xd = data;
1016         struct tb_service *svc;
1017
1018         svc = tb_to_service(dev);
1019         if (!svc)
1020                 return 0;
1021
1022         if (!tb_property_find(xd->remote_properties, svc->key,
1023                               TB_PROPERTY_TYPE_DIRECTORY))
1024                 device_unregister(dev);
1025
1026         return 0;
1027 }
1028
1029 static int find_service(struct device *dev, void *data)
1030 {
1031         const struct tb_property *p = data;
1032         struct tb_service *svc;
1033
1034         svc = tb_to_service(dev);
1035         if (!svc)
1036                 return 0;
1037
1038         return !strcmp(svc->key, p->key);
1039 }
1040
1041 static int populate_service(struct tb_service *svc,
1042                             struct tb_property *property)
1043 {
1044         struct tb_property_dir *dir = property->value.dir;
1045         struct tb_property *p;
1046
1047         /* Fill in standard properties */
1048         p = tb_property_find(dir, "prtcid", TB_PROPERTY_TYPE_VALUE);
1049         if (p)
1050                 svc->prtcid = p->value.immediate;
1051         p = tb_property_find(dir, "prtcvers", TB_PROPERTY_TYPE_VALUE);
1052         if (p)
1053                 svc->prtcvers = p->value.immediate;
1054         p = tb_property_find(dir, "prtcrevs", TB_PROPERTY_TYPE_VALUE);
1055         if (p)
1056                 svc->prtcrevs = p->value.immediate;
1057         p = tb_property_find(dir, "prtcstns", TB_PROPERTY_TYPE_VALUE);
1058         if (p)
1059                 svc->prtcstns = p->value.immediate;
1060
1061         svc->key = kstrdup(property->key, GFP_KERNEL);
1062         if (!svc->key)
1063                 return -ENOMEM;
1064
1065         return 0;
1066 }
1067
1068 static void enumerate_services(struct tb_xdomain *xd)
1069 {
1070         struct tb_service *svc;
1071         struct tb_property *p;
1072         struct device *dev;
1073         int id;
1074
1075         /*
1076          * First remove all services that are not available anymore in
1077          * the updated property block.
1078          */
1079         device_for_each_child_reverse(&xd->dev, xd, remove_missing_service);
1080
1081         /* Then re-enumerate properties creating new services as we go */
1082         tb_property_for_each(xd->remote_properties, p) {
1083                 if (p->type != TB_PROPERTY_TYPE_DIRECTORY)
1084                         continue;
1085
1086                 /* If the service exists already we are fine */
1087                 dev = device_find_child(&xd->dev, p, find_service);
1088                 if (dev) {
1089                         put_device(dev);
1090                         continue;
1091                 }
1092
1093                 svc = kzalloc(sizeof(*svc), GFP_KERNEL);
1094                 if (!svc)
1095                         break;
1096
1097                 if (populate_service(svc, p)) {
1098                         kfree(svc);
1099                         break;
1100                 }
1101
1102                 id = ida_alloc(&xd->service_ids, GFP_KERNEL);
1103                 if (id < 0) {
1104                         kfree(svc->key);
1105                         kfree(svc);
1106                         break;
1107                 }
1108                 svc->id = id;
1109                 svc->dev.bus = &tb_bus_type;
1110                 svc->dev.type = &tb_service_type;
1111                 svc->dev.parent = &xd->dev;
1112                 dev_set_name(&svc->dev, "%s.%d", dev_name(&xd->dev), svc->id);
1113
1114                 tb_service_debugfs_init(svc);
1115
1116                 if (device_register(&svc->dev)) {
1117                         put_device(&svc->dev);
1118                         break;
1119                 }
1120         }
1121 }
1122
1123 static int populate_properties(struct tb_xdomain *xd,
1124                                struct tb_property_dir *dir)
1125 {
1126         const struct tb_property *p;
1127
1128         /* Required properties */
1129         p = tb_property_find(dir, "deviceid", TB_PROPERTY_TYPE_VALUE);
1130         if (!p)
1131                 return -EINVAL;
1132         xd->device = p->value.immediate;
1133
1134         p = tb_property_find(dir, "vendorid", TB_PROPERTY_TYPE_VALUE);
1135         if (!p)
1136                 return -EINVAL;
1137         xd->vendor = p->value.immediate;
1138
1139         p = tb_property_find(dir, "maxhopid", TB_PROPERTY_TYPE_VALUE);
1140         /*
1141          * USB4 inter-domain spec suggests using 15 as HopID if the
1142          * other end does not announce it in a property. This is for
1143          * TBT3 compatibility.
1144          */
1145         xd->remote_max_hopid = p ? p->value.immediate : XDOMAIN_DEFAULT_MAX_HOPID;
1146
1147         kfree(xd->device_name);
1148         xd->device_name = NULL;
1149         kfree(xd->vendor_name);
1150         xd->vendor_name = NULL;
1151
1152         /* Optional properties */
1153         p = tb_property_find(dir, "deviceid", TB_PROPERTY_TYPE_TEXT);
1154         if (p)
1155                 xd->device_name = kstrdup(p->value.text, GFP_KERNEL);
1156         p = tb_property_find(dir, "vendorid", TB_PROPERTY_TYPE_TEXT);
1157         if (p)
1158                 xd->vendor_name = kstrdup(p->value.text, GFP_KERNEL);
1159
1160         return 0;
1161 }
1162
1163 static int tb_xdomain_update_link_attributes(struct tb_xdomain *xd)
1164 {
1165         bool change = false;
1166         struct tb_port *port;
1167         int ret;
1168
1169         port = tb_xdomain_downstream_port(xd);
1170
1171         ret = tb_port_get_link_speed(port);
1172         if (ret < 0)
1173                 return ret;
1174
1175         if (xd->link_speed != ret)
1176                 change = true;
1177
1178         xd->link_speed = ret;
1179
1180         ret = tb_port_get_link_width(port);
1181         if (ret < 0)
1182                 return ret;
1183
1184         if (xd->link_width != ret)
1185                 change = true;
1186
1187         xd->link_width = ret;
1188
1189         if (change)
1190                 kobject_uevent(&xd->dev.kobj, KOBJ_CHANGE);
1191
1192         return 0;
1193 }
1194
1195 static int tb_xdomain_get_uuid(struct tb_xdomain *xd)
1196 {
1197         struct tb *tb = xd->tb;
1198         uuid_t uuid;
1199         u64 route;
1200         int ret;
1201
1202         dev_dbg(&xd->dev, "requesting remote UUID\n");
1203
1204         ret = tb_xdp_uuid_request(tb->ctl, xd->route, xd->state_retries, &uuid,
1205                                   &route);
1206         if (ret < 0) {
1207                 if (xd->state_retries-- > 0) {
1208                         dev_dbg(&xd->dev, "failed to request UUID, retrying\n");
1209                         return -EAGAIN;
1210                 }
1211                 dev_dbg(&xd->dev, "failed to read remote UUID\n");
1212                 return ret;
1213         }
1214
1215         dev_dbg(&xd->dev, "got remote UUID %pUb\n", &uuid);
1216
1217         if (uuid_equal(&uuid, xd->local_uuid)) {
1218                 if (route == xd->route)
1219                         dev_dbg(&xd->dev, "loop back detected\n");
1220                 else
1221                         dev_dbg(&xd->dev, "intra-domain loop detected\n");
1222
1223                 /* Don't bond lanes automatically for loops */
1224                 xd->bonding_possible = false;
1225         }
1226
1227         /*
1228          * If the UUID is different, there is another domain connected
1229          * so mark this one unplugged and wait for the connection
1230          * manager to replace it.
1231          */
1232         if (xd->remote_uuid && !uuid_equal(&uuid, xd->remote_uuid)) {
1233                 dev_dbg(&xd->dev, "remote UUID is different, unplugging\n");
1234                 xd->is_unplugged = true;
1235                 return -ENODEV;
1236         }
1237
1238         /* First time fill in the missing UUID */
1239         if (!xd->remote_uuid) {
1240                 xd->remote_uuid = kmemdup(&uuid, sizeof(uuid_t), GFP_KERNEL);
1241                 if (!xd->remote_uuid)
1242                         return -ENOMEM;
1243         }
1244
1245         return 0;
1246 }
1247
1248 static int tb_xdomain_get_link_status(struct tb_xdomain *xd)
1249 {
1250         struct tb *tb = xd->tb;
1251         u8 slw, tlw, sls, tls;
1252         int ret;
1253
1254         dev_dbg(&xd->dev, "sending link state status request to %pUb\n",
1255                 xd->remote_uuid);
1256
1257         ret = tb_xdp_link_state_status_request(tb->ctl, xd->route,
1258                                                xd->state_retries, &slw, &tlw, &sls,
1259                                                &tls);
1260         if (ret) {
1261                 if (ret != -EOPNOTSUPP && xd->state_retries-- > 0) {
1262                         dev_dbg(&xd->dev,
1263                                 "failed to request remote link status, retrying\n");
1264                         return -EAGAIN;
1265                 }
1266                 dev_dbg(&xd->dev, "failed to receive remote link status\n");
1267                 return ret;
1268         }
1269
1270         dev_dbg(&xd->dev, "remote link supports width %#x speed %#x\n", slw, sls);
1271
1272         if (slw < LANE_ADP_CS_0_SUPPORTED_WIDTH_DUAL) {
1273                 dev_dbg(&xd->dev, "remote adapter is single lane only\n");
1274                 return -EOPNOTSUPP;
1275         }
1276
1277         return 0;
1278 }
1279
1280 static int tb_xdomain_link_state_change(struct tb_xdomain *xd,
1281                                         unsigned int width)
1282 {
1283         struct tb_port *port = tb_xdomain_downstream_port(xd);
1284         struct tb *tb = xd->tb;
1285         u8 tlw, tls;
1286         u32 val;
1287         int ret;
1288
1289         if (width == 2)
1290                 tlw = LANE_ADP_CS_1_TARGET_WIDTH_DUAL;
1291         else if (width == 1)
1292                 tlw = LANE_ADP_CS_1_TARGET_WIDTH_SINGLE;
1293         else
1294                 return -EINVAL;
1295
1296         /* Use the current target speed */
1297         ret = tb_port_read(port, &val, TB_CFG_PORT, port->cap_phy + LANE_ADP_CS_1, 1);
1298         if (ret)
1299                 return ret;
1300         tls = val & LANE_ADP_CS_1_TARGET_SPEED_MASK;
1301
1302         dev_dbg(&xd->dev, "sending link state change request with width %#x speed %#x\n",
1303                 tlw, tls);
1304
1305         ret = tb_xdp_link_state_change_request(tb->ctl, xd->route,
1306                                                xd->state_retries, tlw, tls);
1307         if (ret) {
1308                 if (ret != -EOPNOTSUPP && xd->state_retries-- > 0) {
1309                         dev_dbg(&xd->dev,
1310                                 "failed to change remote link state, retrying\n");
1311                         return -EAGAIN;
1312                 }
1313                 dev_err(&xd->dev, "failed request link state change, aborting\n");
1314                 return ret;
1315         }
1316
1317         dev_dbg(&xd->dev, "received link state change response\n");
1318         return 0;
1319 }
1320
1321 static int tb_xdomain_bond_lanes_uuid_high(struct tb_xdomain *xd)
1322 {
1323         unsigned int width, width_mask;
1324         struct tb_port *port;
1325         int ret;
1326
1327         if (xd->target_link_width == LANE_ADP_CS_1_TARGET_WIDTH_SINGLE) {
1328                 width = TB_LINK_WIDTH_SINGLE;
1329                 width_mask = width;
1330         } else if (xd->target_link_width == LANE_ADP_CS_1_TARGET_WIDTH_DUAL) {
1331                 width = TB_LINK_WIDTH_DUAL;
1332                 width_mask = width | TB_LINK_WIDTH_ASYM_TX | TB_LINK_WIDTH_ASYM_RX;
1333         } else {
1334                 if (xd->state_retries-- > 0) {
1335                         dev_dbg(&xd->dev,
1336                                 "link state change request not received yet, retrying\n");
1337                         return -EAGAIN;
1338                 }
1339                 dev_dbg(&xd->dev, "timeout waiting for link change request\n");
1340                 return -ETIMEDOUT;
1341         }
1342
1343         port = tb_xdomain_downstream_port(xd);
1344
1345         /*
1346          * We can't use tb_xdomain_lane_bonding_enable() here because it
1347          * is the other side that initiates lane bonding. So here we
1348          * just set the width to both lane adapters and wait for the
1349          * link to transition bonded.
1350          */
1351         ret = tb_port_set_link_width(port->dual_link_port, width);
1352         if (ret) {
1353                 tb_port_warn(port->dual_link_port,
1354                              "failed to set link width to %d\n", width);
1355                 return ret;
1356         }
1357
1358         ret = tb_port_set_link_width(port, width);
1359         if (ret) {
1360                 tb_port_warn(port, "failed to set link width to %d\n", width);
1361                 return ret;
1362         }
1363
1364         ret = tb_port_wait_for_link_width(port, width_mask,
1365                                           XDOMAIN_BONDING_TIMEOUT);
1366         if (ret) {
1367                 dev_warn(&xd->dev, "error waiting for link width to become %d\n",
1368                          width_mask);
1369                 return ret;
1370         }
1371
1372         port->bonded = width > TB_LINK_WIDTH_SINGLE;
1373         port->dual_link_port->bonded = width > TB_LINK_WIDTH_SINGLE;
1374
1375         tb_port_update_credits(port);
1376         tb_xdomain_update_link_attributes(xd);
1377
1378         dev_dbg(&xd->dev, "lane bonding %s\n", str_enabled_disabled(width == 2));
1379         return 0;
1380 }
1381
1382 static int tb_xdomain_get_properties(struct tb_xdomain *xd)
1383 {
1384         struct tb_property_dir *dir;
1385         struct tb *tb = xd->tb;
1386         bool update = false;
1387         u32 *block = NULL;
1388         u32 gen = 0;
1389         int ret;
1390
1391         dev_dbg(&xd->dev, "requesting remote properties\n");
1392
1393         ret = tb_xdp_properties_request(tb->ctl, xd->route, xd->local_uuid,
1394                                         xd->remote_uuid, xd->state_retries,
1395                                         &block, &gen);
1396         if (ret < 0) {
1397                 if (xd->state_retries-- > 0) {
1398                         dev_dbg(&xd->dev,
1399                                 "failed to request remote properties, retrying\n");
1400                         return -EAGAIN;
1401                 }
1402                 /* Give up now */
1403                 dev_err(&xd->dev, "failed read XDomain properties from %pUb\n",
1404                         xd->remote_uuid);
1405
1406                 return ret;
1407         }
1408
1409         mutex_lock(&xd->lock);
1410
1411         /* Only accept newer generation properties */
1412         if (xd->remote_properties && gen <= xd->remote_property_block_gen) {
1413                 ret = 0;
1414                 goto err_free_block;
1415         }
1416
1417         dir = tb_property_parse_dir(block, ret);
1418         if (!dir) {
1419                 dev_err(&xd->dev, "failed to parse XDomain properties\n");
1420                 ret = -ENOMEM;
1421                 goto err_free_block;
1422         }
1423
1424         ret = populate_properties(xd, dir);
1425         if (ret) {
1426                 dev_err(&xd->dev, "missing XDomain properties in response\n");
1427                 goto err_free_dir;
1428         }
1429
1430         /* Release the existing one */
1431         if (xd->remote_properties) {
1432                 tb_property_free_dir(xd->remote_properties);
1433                 update = true;
1434         }
1435
1436         xd->remote_properties = dir;
1437         xd->remote_property_block_gen = gen;
1438
1439         tb_xdomain_update_link_attributes(xd);
1440
1441         mutex_unlock(&xd->lock);
1442
1443         kfree(block);
1444
1445         /*
1446          * Now the device should be ready enough so we can add it to the
1447          * bus and let userspace know about it. If the device is already
1448          * registered, we notify the userspace that it has changed.
1449          */
1450         if (!update) {
1451                 /*
1452                  * Now disable lane 1 if bonding was not enabled. Do
1453                  * this only if bonding was possible at the beginning
1454                  * (that is we are the connection manager and there are
1455                  * two lanes).
1456                  */
1457                 if (xd->bonding_possible) {
1458                         struct tb_port *port;
1459
1460                         port = tb_xdomain_downstream_port(xd);
1461                         if (!port->bonded)
1462                                 tb_port_disable(port->dual_link_port);
1463                 }
1464
1465                 dev_dbg(&xd->dev, "current link speed %u.0 Gb/s\n",
1466                         xd->link_speed);
1467                 dev_dbg(&xd->dev, "current link width %s\n",
1468                         tb_width_name(xd->link_width));
1469
1470                 if (device_add(&xd->dev)) {
1471                         dev_err(&xd->dev, "failed to add XDomain device\n");
1472                         return -ENODEV;
1473                 }
1474                 dev_info(&xd->dev, "new host found, vendor=%#x device=%#x\n",
1475                          xd->vendor, xd->device);
1476                 if (xd->vendor_name && xd->device_name)
1477                         dev_info(&xd->dev, "%s %s\n", xd->vendor_name,
1478                                  xd->device_name);
1479
1480                 tb_xdomain_debugfs_init(xd);
1481         } else {
1482                 kobject_uevent(&xd->dev.kobj, KOBJ_CHANGE);
1483         }
1484
1485         enumerate_services(xd);
1486         return 0;
1487
1488 err_free_dir:
1489         tb_property_free_dir(dir);
1490 err_free_block:
1491         kfree(block);
1492         mutex_unlock(&xd->lock);
1493
1494         return ret;
1495 }
1496
1497 static void tb_xdomain_queue_uuid(struct tb_xdomain *xd)
1498 {
1499         xd->state = XDOMAIN_STATE_UUID;
1500         xd->state_retries = XDOMAIN_RETRIES;
1501         queue_delayed_work(xd->tb->wq, &xd->state_work,
1502                            msecs_to_jiffies(XDOMAIN_SHORT_TIMEOUT));
1503 }
1504
1505 static void tb_xdomain_queue_link_status(struct tb_xdomain *xd)
1506 {
1507         xd->state = XDOMAIN_STATE_LINK_STATUS;
1508         xd->state_retries = XDOMAIN_RETRIES;
1509         queue_delayed_work(xd->tb->wq, &xd->state_work,
1510                            msecs_to_jiffies(XDOMAIN_DEFAULT_TIMEOUT));
1511 }
1512
1513 static void tb_xdomain_queue_link_status2(struct tb_xdomain *xd)
1514 {
1515         xd->state = XDOMAIN_STATE_LINK_STATUS2;
1516         xd->state_retries = XDOMAIN_RETRIES;
1517         queue_delayed_work(xd->tb->wq, &xd->state_work,
1518                            msecs_to_jiffies(XDOMAIN_DEFAULT_TIMEOUT));
1519 }
1520
1521 static void tb_xdomain_queue_bonding(struct tb_xdomain *xd)
1522 {
1523         if (memcmp(xd->local_uuid, xd->remote_uuid, UUID_SIZE) > 0) {
1524                 dev_dbg(&xd->dev, "we have higher UUID, other side bonds the lanes\n");
1525                 xd->state = XDOMAIN_STATE_BONDING_UUID_HIGH;
1526         } else {
1527                 dev_dbg(&xd->dev, "we have lower UUID, bonding lanes\n");
1528                 xd->state = XDOMAIN_STATE_LINK_STATE_CHANGE;
1529         }
1530
1531         xd->state_retries = XDOMAIN_RETRIES;
1532         queue_delayed_work(xd->tb->wq, &xd->state_work,
1533                            msecs_to_jiffies(XDOMAIN_DEFAULT_TIMEOUT));
1534 }
1535
1536 static void tb_xdomain_queue_bonding_uuid_low(struct tb_xdomain *xd)
1537 {
1538         xd->state = XDOMAIN_STATE_BONDING_UUID_LOW;
1539         xd->state_retries = XDOMAIN_RETRIES;
1540         queue_delayed_work(xd->tb->wq, &xd->state_work,
1541                            msecs_to_jiffies(XDOMAIN_DEFAULT_TIMEOUT));
1542 }
1543
1544 static void tb_xdomain_queue_properties(struct tb_xdomain *xd)
1545 {
1546         xd->state = XDOMAIN_STATE_PROPERTIES;
1547         xd->state_retries = XDOMAIN_RETRIES;
1548         queue_delayed_work(xd->tb->wq, &xd->state_work,
1549                            msecs_to_jiffies(XDOMAIN_DEFAULT_TIMEOUT));
1550 }
1551
1552 static void tb_xdomain_queue_properties_changed(struct tb_xdomain *xd)
1553 {
1554         xd->properties_changed_retries = XDOMAIN_RETRIES;
1555         queue_delayed_work(xd->tb->wq, &xd->properties_changed_work,
1556                            msecs_to_jiffies(XDOMAIN_SHORT_TIMEOUT));
1557 }
1558
1559 static void tb_xdomain_failed(struct tb_xdomain *xd)
1560 {
1561         xd->state = XDOMAIN_STATE_ERROR;
1562         queue_delayed_work(xd->tb->wq, &xd->state_work,
1563                            msecs_to_jiffies(XDOMAIN_DEFAULT_TIMEOUT));
1564 }
1565
1566 static void tb_xdomain_state_work(struct work_struct *work)
1567 {
1568         struct tb_xdomain *xd = container_of(work, typeof(*xd), state_work.work);
1569         int ret, state = xd->state;
1570
1571         if (WARN_ON_ONCE(state < XDOMAIN_STATE_INIT ||
1572                          state > XDOMAIN_STATE_ERROR))
1573                 return;
1574
1575         dev_dbg(&xd->dev, "running state %s\n", state_names[state]);
1576
1577         switch (state) {
1578         case XDOMAIN_STATE_INIT:
1579                 if (xd->needs_uuid) {
1580                         tb_xdomain_queue_uuid(xd);
1581                 } else {
1582                         tb_xdomain_queue_properties_changed(xd);
1583                         tb_xdomain_queue_properties(xd);
1584                 }
1585                 break;
1586
1587         case XDOMAIN_STATE_UUID:
1588                 ret = tb_xdomain_get_uuid(xd);
1589                 if (ret) {
1590                         if (ret == -EAGAIN)
1591                                 goto retry_state;
1592                         tb_xdomain_failed(xd);
1593                 } else {
1594                         tb_xdomain_queue_properties_changed(xd);
1595                         if (xd->bonding_possible)
1596                                 tb_xdomain_queue_link_status(xd);
1597                         else
1598                                 tb_xdomain_queue_properties(xd);
1599                 }
1600                 break;
1601
1602         case XDOMAIN_STATE_LINK_STATUS:
1603                 ret = tb_xdomain_get_link_status(xd);
1604                 if (ret) {
1605                         if (ret == -EAGAIN)
1606                                 goto retry_state;
1607
1608                         /*
1609                          * If any of the lane bonding states fail we skip
1610                          * bonding completely and try to continue from
1611                          * reading properties.
1612                          */
1613                         tb_xdomain_queue_properties(xd);
1614                 } else {
1615                         tb_xdomain_queue_bonding(xd);
1616                 }
1617                 break;
1618
1619         case XDOMAIN_STATE_LINK_STATE_CHANGE:
1620                 ret = tb_xdomain_link_state_change(xd, 2);
1621                 if (ret) {
1622                         if (ret == -EAGAIN)
1623                                 goto retry_state;
1624                         tb_xdomain_queue_properties(xd);
1625                 } else {
1626                         tb_xdomain_queue_link_status2(xd);
1627                 }
1628                 break;
1629
1630         case XDOMAIN_STATE_LINK_STATUS2:
1631                 ret = tb_xdomain_get_link_status(xd);
1632                 if (ret) {
1633                         if (ret == -EAGAIN)
1634                                 goto retry_state;
1635                         tb_xdomain_queue_properties(xd);
1636                 } else {
1637                         tb_xdomain_queue_bonding_uuid_low(xd);
1638                 }
1639                 break;
1640
1641         case XDOMAIN_STATE_BONDING_UUID_LOW:
1642                 tb_xdomain_lane_bonding_enable(xd);
1643                 tb_xdomain_queue_properties(xd);
1644                 break;
1645
1646         case XDOMAIN_STATE_BONDING_UUID_HIGH:
1647                 if (tb_xdomain_bond_lanes_uuid_high(xd) == -EAGAIN)
1648                         goto retry_state;
1649                 tb_xdomain_queue_properties(xd);
1650                 break;
1651
1652         case XDOMAIN_STATE_PROPERTIES:
1653                 ret = tb_xdomain_get_properties(xd);
1654                 if (ret) {
1655                         if (ret == -EAGAIN)
1656                                 goto retry_state;
1657                         tb_xdomain_failed(xd);
1658                 } else {
1659                         xd->state = XDOMAIN_STATE_ENUMERATED;
1660                 }
1661                 break;
1662
1663         case XDOMAIN_STATE_ENUMERATED:
1664                 tb_xdomain_queue_properties(xd);
1665                 break;
1666
1667         case XDOMAIN_STATE_ERROR:
1668                 dev_dbg(&xd->dev, "discovery failed, stopping handshake\n");
1669                 __stop_handshake(xd);
1670                 break;
1671
1672         default:
1673                 dev_warn(&xd->dev, "unexpected state %d\n", state);
1674                 break;
1675         }
1676
1677         return;
1678
1679 retry_state:
1680         queue_delayed_work(xd->tb->wq, &xd->state_work,
1681                            msecs_to_jiffies(XDOMAIN_DEFAULT_TIMEOUT));
1682 }
1683
1684 static void tb_xdomain_properties_changed(struct work_struct *work)
1685 {
1686         struct tb_xdomain *xd = container_of(work, typeof(*xd),
1687                                              properties_changed_work.work);
1688         int ret;
1689
1690         dev_dbg(&xd->dev, "sending properties changed notification\n");
1691
1692         ret = tb_xdp_properties_changed_request(xd->tb->ctl, xd->route,
1693                                 xd->properties_changed_retries, xd->local_uuid);
1694         if (ret) {
1695                 if (xd->properties_changed_retries-- > 0) {
1696                         dev_dbg(&xd->dev,
1697                                 "failed to send properties changed notification, retrying\n");
1698                         queue_delayed_work(xd->tb->wq,
1699                                            &xd->properties_changed_work,
1700                                            msecs_to_jiffies(XDOMAIN_DEFAULT_TIMEOUT));
1701                 }
1702                 dev_err(&xd->dev, "failed to send properties changed notification\n");
1703                 return;
1704         }
1705
1706         xd->properties_changed_retries = XDOMAIN_RETRIES;
1707 }
1708
1709 static ssize_t device_show(struct device *dev, struct device_attribute *attr,
1710                            char *buf)
1711 {
1712         struct tb_xdomain *xd = container_of(dev, struct tb_xdomain, dev);
1713
1714         return sysfs_emit(buf, "%#x\n", xd->device);
1715 }
1716 static DEVICE_ATTR_RO(device);
1717
1718 static ssize_t
1719 device_name_show(struct device *dev, struct device_attribute *attr, char *buf)
1720 {
1721         struct tb_xdomain *xd = container_of(dev, struct tb_xdomain, dev);
1722         int ret;
1723
1724         if (mutex_lock_interruptible(&xd->lock))
1725                 return -ERESTARTSYS;
1726         ret = sysfs_emit(buf, "%s\n", xd->device_name ?: "");
1727         mutex_unlock(&xd->lock);
1728
1729         return ret;
1730 }
1731 static DEVICE_ATTR_RO(device_name);
1732
1733 static ssize_t maxhopid_show(struct device *dev, struct device_attribute *attr,
1734                              char *buf)
1735 {
1736         struct tb_xdomain *xd = container_of(dev, struct tb_xdomain, dev);
1737
1738         return sysfs_emit(buf, "%d\n", xd->remote_max_hopid);
1739 }
1740 static DEVICE_ATTR_RO(maxhopid);
1741
1742 static ssize_t vendor_show(struct device *dev, struct device_attribute *attr,
1743                            char *buf)
1744 {
1745         struct tb_xdomain *xd = container_of(dev, struct tb_xdomain, dev);
1746
1747         return sysfs_emit(buf, "%#x\n", xd->vendor);
1748 }
1749 static DEVICE_ATTR_RO(vendor);
1750
1751 static ssize_t
1752 vendor_name_show(struct device *dev, struct device_attribute *attr, char *buf)
1753 {
1754         struct tb_xdomain *xd = container_of(dev, struct tb_xdomain, dev);
1755         int ret;
1756
1757         if (mutex_lock_interruptible(&xd->lock))
1758                 return -ERESTARTSYS;
1759         ret = sysfs_emit(buf, "%s\n", xd->vendor_name ?: "");
1760         mutex_unlock(&xd->lock);
1761
1762         return ret;
1763 }
1764 static DEVICE_ATTR_RO(vendor_name);
1765
1766 static ssize_t unique_id_show(struct device *dev, struct device_attribute *attr,
1767                               char *buf)
1768 {
1769         struct tb_xdomain *xd = container_of(dev, struct tb_xdomain, dev);
1770
1771         return sysfs_emit(buf, "%pUb\n", xd->remote_uuid);
1772 }
1773 static DEVICE_ATTR_RO(unique_id);
1774
1775 static ssize_t speed_show(struct device *dev, struct device_attribute *attr,
1776                           char *buf)
1777 {
1778         struct tb_xdomain *xd = container_of(dev, struct tb_xdomain, dev);
1779
1780         return sysfs_emit(buf, "%u.0 Gb/s\n", xd->link_speed);
1781 }
1782
1783 static DEVICE_ATTR(rx_speed, 0444, speed_show, NULL);
1784 static DEVICE_ATTR(tx_speed, 0444, speed_show, NULL);
1785
1786 static ssize_t rx_lanes_show(struct device *dev, struct device_attribute *attr,
1787                              char *buf)
1788 {
1789         struct tb_xdomain *xd = container_of(dev, struct tb_xdomain, dev);
1790         unsigned int width;
1791
1792         switch (xd->link_width) {
1793         case TB_LINK_WIDTH_SINGLE:
1794         case TB_LINK_WIDTH_ASYM_TX:
1795                 width = 1;
1796                 break;
1797         case TB_LINK_WIDTH_DUAL:
1798                 width = 2;
1799                 break;
1800         case TB_LINK_WIDTH_ASYM_RX:
1801                 width = 3;
1802                 break;
1803         default:
1804                 WARN_ON_ONCE(1);
1805                 return -EINVAL;
1806         }
1807
1808         return sysfs_emit(buf, "%u\n", width);
1809 }
1810 static DEVICE_ATTR(rx_lanes, 0444, rx_lanes_show, NULL);
1811
1812 static ssize_t tx_lanes_show(struct device *dev, struct device_attribute *attr,
1813                              char *buf)
1814 {
1815         struct tb_xdomain *xd = container_of(dev, struct tb_xdomain, dev);
1816         unsigned int width;
1817
1818         switch (xd->link_width) {
1819         case TB_LINK_WIDTH_SINGLE:
1820         case TB_LINK_WIDTH_ASYM_RX:
1821                 width = 1;
1822                 break;
1823         case TB_LINK_WIDTH_DUAL:
1824                 width = 2;
1825                 break;
1826         case TB_LINK_WIDTH_ASYM_TX:
1827                 width = 3;
1828                 break;
1829         default:
1830                 WARN_ON_ONCE(1);
1831                 return -EINVAL;
1832         }
1833
1834         return sysfs_emit(buf, "%u\n", width);
1835 }
1836 static DEVICE_ATTR(tx_lanes, 0444, tx_lanes_show, NULL);
1837
1838 static struct attribute *xdomain_attrs[] = {
1839         &dev_attr_device.attr,
1840         &dev_attr_device_name.attr,
1841         &dev_attr_maxhopid.attr,
1842         &dev_attr_rx_lanes.attr,
1843         &dev_attr_rx_speed.attr,
1844         &dev_attr_tx_lanes.attr,
1845         &dev_attr_tx_speed.attr,
1846         &dev_attr_unique_id.attr,
1847         &dev_attr_vendor.attr,
1848         &dev_attr_vendor_name.attr,
1849         NULL,
1850 };
1851
1852 static const struct attribute_group xdomain_attr_group = {
1853         .attrs = xdomain_attrs,
1854 };
1855
1856 static const struct attribute_group *xdomain_attr_groups[] = {
1857         &xdomain_attr_group,
1858         NULL,
1859 };
1860
1861 static void tb_xdomain_release(struct device *dev)
1862 {
1863         struct tb_xdomain *xd = container_of(dev, struct tb_xdomain, dev);
1864
1865         put_device(xd->dev.parent);
1866
1867         kfree(xd->local_property_block);
1868         tb_property_free_dir(xd->remote_properties);
1869         ida_destroy(&xd->out_hopids);
1870         ida_destroy(&xd->in_hopids);
1871         ida_destroy(&xd->service_ids);
1872
1873         kfree(xd->local_uuid);
1874         kfree(xd->remote_uuid);
1875         kfree(xd->device_name);
1876         kfree(xd->vendor_name);
1877         kfree(xd);
1878 }
1879
1880 static int __maybe_unused tb_xdomain_suspend(struct device *dev)
1881 {
1882         stop_handshake(tb_to_xdomain(dev));
1883         return 0;
1884 }
1885
1886 static int __maybe_unused tb_xdomain_resume(struct device *dev)
1887 {
1888         start_handshake(tb_to_xdomain(dev));
1889         return 0;
1890 }
1891
1892 static const struct dev_pm_ops tb_xdomain_pm_ops = {
1893         SET_SYSTEM_SLEEP_PM_OPS(tb_xdomain_suspend, tb_xdomain_resume)
1894 };
1895
1896 const struct device_type tb_xdomain_type = {
1897         .name = "thunderbolt_xdomain",
1898         .release = tb_xdomain_release,
1899         .pm = &tb_xdomain_pm_ops,
1900 };
1901 EXPORT_SYMBOL_GPL(tb_xdomain_type);
1902
1903 static void tb_xdomain_link_init(struct tb_xdomain *xd, struct tb_port *down)
1904 {
1905         if (!down->dual_link_port)
1906                 return;
1907
1908         /*
1909          * Gen 4 links come up already as bonded so only update the port
1910          * structures here.
1911          */
1912         if (tb_port_get_link_generation(down) >= 4) {
1913                 down->bonded = true;
1914                 down->dual_link_port->bonded = true;
1915         } else {
1916                 xd->bonding_possible = true;
1917         }
1918 }
1919
1920 static void tb_xdomain_link_exit(struct tb_xdomain *xd)
1921 {
1922         struct tb_port *down = tb_xdomain_downstream_port(xd);
1923
1924         if (!down->dual_link_port)
1925                 return;
1926
1927         if (tb_port_get_link_generation(down) >= 4) {
1928                 down->bonded = false;
1929                 down->dual_link_port->bonded = false;
1930         } else if (xd->link_width > TB_LINK_WIDTH_SINGLE) {
1931                 /*
1932                  * Just return port structures back to way they were and
1933                  * update credits. No need to update userspace because
1934                  * the XDomain is removed soon anyway.
1935                  */
1936                 tb_port_lane_bonding_disable(down);
1937                 tb_port_update_credits(down);
1938         } else if (down->dual_link_port) {
1939                 /*
1940                  * Re-enable the lane 1 adapter we disabled at the end
1941                  * of tb_xdomain_get_properties().
1942                  */
1943                 tb_port_enable(down->dual_link_port);
1944         }
1945 }
1946
1947 /**
1948  * tb_xdomain_alloc() - Allocate new XDomain object
1949  * @tb: Domain where the XDomain belongs
1950  * @parent: Parent device (the switch through the connection to the
1951  *          other domain is reached).
1952  * @route: Route string used to reach the other domain
1953  * @local_uuid: Our local domain UUID
1954  * @remote_uuid: UUID of the other domain (optional)
1955  *
1956  * Allocates new XDomain structure and returns pointer to that. The
1957  * object must be released by calling tb_xdomain_put().
1958  */
1959 struct tb_xdomain *tb_xdomain_alloc(struct tb *tb, struct device *parent,
1960                                     u64 route, const uuid_t *local_uuid,
1961                                     const uuid_t *remote_uuid)
1962 {
1963         struct tb_switch *parent_sw = tb_to_switch(parent);
1964         struct tb_xdomain *xd;
1965         struct tb_port *down;
1966
1967         /* Make sure the downstream domain is accessible */
1968         down = tb_port_at(route, parent_sw);
1969         tb_port_unlock(down);
1970
1971         xd = kzalloc(sizeof(*xd), GFP_KERNEL);
1972         if (!xd)
1973                 return NULL;
1974
1975         xd->tb = tb;
1976         xd->route = route;
1977         xd->local_max_hopid = down->config.max_in_hop_id;
1978         ida_init(&xd->service_ids);
1979         ida_init(&xd->in_hopids);
1980         ida_init(&xd->out_hopids);
1981         mutex_init(&xd->lock);
1982         INIT_DELAYED_WORK(&xd->state_work, tb_xdomain_state_work);
1983         INIT_DELAYED_WORK(&xd->properties_changed_work,
1984                           tb_xdomain_properties_changed);
1985
1986         xd->local_uuid = kmemdup(local_uuid, sizeof(uuid_t), GFP_KERNEL);
1987         if (!xd->local_uuid)
1988                 goto err_free;
1989
1990         if (remote_uuid) {
1991                 xd->remote_uuid = kmemdup(remote_uuid, sizeof(uuid_t),
1992                                           GFP_KERNEL);
1993                 if (!xd->remote_uuid)
1994                         goto err_free_local_uuid;
1995         } else {
1996                 xd->needs_uuid = true;
1997
1998                 tb_xdomain_link_init(xd, down);
1999         }
2000
2001         device_initialize(&xd->dev);
2002         xd->dev.parent = get_device(parent);
2003         xd->dev.bus = &tb_bus_type;
2004         xd->dev.type = &tb_xdomain_type;
2005         xd->dev.groups = xdomain_attr_groups;
2006         dev_set_name(&xd->dev, "%u-%llx", tb->index, route);
2007
2008         dev_dbg(&xd->dev, "local UUID %pUb\n", local_uuid);
2009         if (remote_uuid)
2010                 dev_dbg(&xd->dev, "remote UUID %pUb\n", remote_uuid);
2011
2012         /*
2013          * This keeps the DMA powered on as long as we have active
2014          * connection to another host.
2015          */
2016         pm_runtime_set_active(&xd->dev);
2017         pm_runtime_get_noresume(&xd->dev);
2018         pm_runtime_enable(&xd->dev);
2019
2020         return xd;
2021
2022 err_free_local_uuid:
2023         kfree(xd->local_uuid);
2024 err_free:
2025         kfree(xd);
2026
2027         return NULL;
2028 }
2029
2030 /**
2031  * tb_xdomain_add() - Add XDomain to the bus
2032  * @xd: XDomain to add
2033  *
2034  * This function starts XDomain discovery protocol handshake and
2035  * eventually adds the XDomain to the bus. After calling this function
2036  * the caller needs to call tb_xdomain_remove() in order to remove and
2037  * release the object regardless whether the handshake succeeded or not.
2038  */
2039 void tb_xdomain_add(struct tb_xdomain *xd)
2040 {
2041         /* Start exchanging properties with the other host */
2042         start_handshake(xd);
2043 }
2044
2045 static int unregister_service(struct device *dev, void *data)
2046 {
2047         device_unregister(dev);
2048         return 0;
2049 }
2050
2051 /**
2052  * tb_xdomain_remove() - Remove XDomain from the bus
2053  * @xd: XDomain to remove
2054  *
2055  * This will stop all ongoing configuration work and remove the XDomain
2056  * along with any services from the bus. When the last reference to @xd
2057  * is released the object will be released as well.
2058  */
2059 void tb_xdomain_remove(struct tb_xdomain *xd)
2060 {
2061         tb_xdomain_debugfs_remove(xd);
2062
2063         stop_handshake(xd);
2064
2065         device_for_each_child_reverse(&xd->dev, xd, unregister_service);
2066
2067         tb_xdomain_link_exit(xd);
2068
2069         /*
2070          * Undo runtime PM here explicitly because it is possible that
2071          * the XDomain was never added to the bus and thus device_del()
2072          * is not called for it (device_del() would handle this otherwise).
2073          */
2074         pm_runtime_disable(&xd->dev);
2075         pm_runtime_put_noidle(&xd->dev);
2076         pm_runtime_set_suspended(&xd->dev);
2077
2078         if (!device_is_registered(&xd->dev)) {
2079                 put_device(&xd->dev);
2080         } else {
2081                 dev_info(&xd->dev, "host disconnected\n");
2082                 device_unregister(&xd->dev);
2083         }
2084 }
2085
2086 /**
2087  * tb_xdomain_lane_bonding_enable() - Enable lane bonding on XDomain
2088  * @xd: XDomain connection
2089  *
2090  * Lane bonding is disabled by default for XDomains. This function tries
2091  * to enable bonding by first enabling the port and waiting for the CL0
2092  * state.
2093  *
2094  * Return: %0 in case of success and negative errno in case of error.
2095  */
2096 int tb_xdomain_lane_bonding_enable(struct tb_xdomain *xd)
2097 {
2098         unsigned int width_mask;
2099         struct tb_port *port;
2100         int ret;
2101
2102         port = tb_xdomain_downstream_port(xd);
2103         if (!port->dual_link_port)
2104                 return -ENODEV;
2105
2106         ret = tb_port_enable(port->dual_link_port);
2107         if (ret)
2108                 return ret;
2109
2110         ret = tb_wait_for_port(port->dual_link_port, true);
2111         if (ret < 0)
2112                 return ret;
2113         if (!ret)
2114                 return -ENOTCONN;
2115
2116         ret = tb_port_lane_bonding_enable(port);
2117         if (ret) {
2118                 tb_port_warn(port, "failed to enable lane bonding\n");
2119                 return ret;
2120         }
2121
2122         /* Any of the widths are all bonded */
2123         width_mask = TB_LINK_WIDTH_DUAL | TB_LINK_WIDTH_ASYM_TX |
2124                      TB_LINK_WIDTH_ASYM_RX;
2125
2126         ret = tb_port_wait_for_link_width(port, width_mask,
2127                                           XDOMAIN_BONDING_TIMEOUT);
2128         if (ret) {
2129                 tb_port_warn(port, "failed to enable lane bonding\n");
2130                 return ret;
2131         }
2132
2133         tb_port_update_credits(port);
2134         tb_xdomain_update_link_attributes(xd);
2135
2136         dev_dbg(&xd->dev, "lane bonding enabled\n");
2137         return 0;
2138 }
2139 EXPORT_SYMBOL_GPL(tb_xdomain_lane_bonding_enable);
2140
2141 /**
2142  * tb_xdomain_lane_bonding_disable() - Disable lane bonding
2143  * @xd: XDomain connection
2144  *
2145  * Lane bonding is disabled by default for XDomains. If bonding has been
2146  * enabled, this function can be used to disable it.
2147  */
2148 void tb_xdomain_lane_bonding_disable(struct tb_xdomain *xd)
2149 {
2150         struct tb_port *port;
2151
2152         port = tb_xdomain_downstream_port(xd);
2153         if (port->dual_link_port) {
2154                 int ret;
2155
2156                 tb_port_lane_bonding_disable(port);
2157                 ret = tb_port_wait_for_link_width(port, TB_LINK_WIDTH_SINGLE, 100);
2158                 if (ret == -ETIMEDOUT)
2159                         tb_port_warn(port, "timeout disabling lane bonding\n");
2160                 tb_port_disable(port->dual_link_port);
2161                 tb_port_update_credits(port);
2162                 tb_xdomain_update_link_attributes(xd);
2163
2164                 dev_dbg(&xd->dev, "lane bonding disabled\n");
2165         }
2166 }
2167 EXPORT_SYMBOL_GPL(tb_xdomain_lane_bonding_disable);
2168
2169 /**
2170  * tb_xdomain_alloc_in_hopid() - Allocate input HopID for tunneling
2171  * @xd: XDomain connection
2172  * @hopid: Preferred HopID or %-1 for next available
2173  *
2174  * Returns allocated HopID or negative errno. Specifically returns
2175  * %-ENOSPC if there are no more available HopIDs. Returned HopID is
2176  * guaranteed to be within range supported by the input lane adapter.
2177  * Call tb_xdomain_release_in_hopid() to release the allocated HopID.
2178  */
2179 int tb_xdomain_alloc_in_hopid(struct tb_xdomain *xd, int hopid)
2180 {
2181         if (hopid < 0)
2182                 hopid = TB_PATH_MIN_HOPID;
2183         if (hopid < TB_PATH_MIN_HOPID || hopid > xd->local_max_hopid)
2184                 return -EINVAL;
2185
2186         return ida_alloc_range(&xd->in_hopids, hopid, xd->local_max_hopid,
2187                                GFP_KERNEL);
2188 }
2189 EXPORT_SYMBOL_GPL(tb_xdomain_alloc_in_hopid);
2190
2191 /**
2192  * tb_xdomain_alloc_out_hopid() - Allocate output HopID for tunneling
2193  * @xd: XDomain connection
2194  * @hopid: Preferred HopID or %-1 for next available
2195  *
2196  * Returns allocated HopID or negative errno. Specifically returns
2197  * %-ENOSPC if there are no more available HopIDs. Returned HopID is
2198  * guaranteed to be within range supported by the output lane adapter.
2199  * Call tb_xdomain_release_in_hopid() to release the allocated HopID.
2200  */
2201 int tb_xdomain_alloc_out_hopid(struct tb_xdomain *xd, int hopid)
2202 {
2203         if (hopid < 0)
2204                 hopid = TB_PATH_MIN_HOPID;
2205         if (hopid < TB_PATH_MIN_HOPID || hopid > xd->remote_max_hopid)
2206                 return -EINVAL;
2207
2208         return ida_alloc_range(&xd->out_hopids, hopid, xd->remote_max_hopid,
2209                                GFP_KERNEL);
2210 }
2211 EXPORT_SYMBOL_GPL(tb_xdomain_alloc_out_hopid);
2212
2213 /**
2214  * tb_xdomain_release_in_hopid() - Release input HopID
2215  * @xd: XDomain connection
2216  * @hopid: HopID to release
2217  */
2218 void tb_xdomain_release_in_hopid(struct tb_xdomain *xd, int hopid)
2219 {
2220         ida_free(&xd->in_hopids, hopid);
2221 }
2222 EXPORT_SYMBOL_GPL(tb_xdomain_release_in_hopid);
2223
2224 /**
2225  * tb_xdomain_release_out_hopid() - Release output HopID
2226  * @xd: XDomain connection
2227  * @hopid: HopID to release
2228  */
2229 void tb_xdomain_release_out_hopid(struct tb_xdomain *xd, int hopid)
2230 {
2231         ida_free(&xd->out_hopids, hopid);
2232 }
2233 EXPORT_SYMBOL_GPL(tb_xdomain_release_out_hopid);
2234
2235 /**
2236  * tb_xdomain_enable_paths() - Enable DMA paths for XDomain connection
2237  * @xd: XDomain connection
2238  * @transmit_path: HopID we are using to send out packets
2239  * @transmit_ring: DMA ring used to send out packets
2240  * @receive_path: HopID the other end is using to send packets to us
2241  * @receive_ring: DMA ring used to receive packets from @receive_path
2242  *
2243  * The function enables DMA paths accordingly so that after successful
2244  * return the caller can send and receive packets using high-speed DMA
2245  * path. If a transmit or receive path is not needed, pass %-1 for those
2246  * parameters.
2247  *
2248  * Return: %0 in case of success and negative errno in case of error
2249  */
2250 int tb_xdomain_enable_paths(struct tb_xdomain *xd, int transmit_path,
2251                             int transmit_ring, int receive_path,
2252                             int receive_ring)
2253 {
2254         return tb_domain_approve_xdomain_paths(xd->tb, xd, transmit_path,
2255                                                transmit_ring, receive_path,
2256                                                receive_ring);
2257 }
2258 EXPORT_SYMBOL_GPL(tb_xdomain_enable_paths);
2259
2260 /**
2261  * tb_xdomain_disable_paths() - Disable DMA paths for XDomain connection
2262  * @xd: XDomain connection
2263  * @transmit_path: HopID we are using to send out packets
2264  * @transmit_ring: DMA ring used to send out packets
2265  * @receive_path: HopID the other end is using to send packets to us
2266  * @receive_ring: DMA ring used to receive packets from @receive_path
2267  *
2268  * This does the opposite of tb_xdomain_enable_paths(). After call to
2269  * this the caller is not expected to use the rings anymore. Passing %-1
2270  * as path/ring parameter means don't care. Normally the callers should
2271  * pass the same values here as they do when paths are enabled.
2272  *
2273  * Return: %0 in case of success and negative errno in case of error
2274  */
2275 int tb_xdomain_disable_paths(struct tb_xdomain *xd, int transmit_path,
2276                              int transmit_ring, int receive_path,
2277                              int receive_ring)
2278 {
2279         return tb_domain_disconnect_xdomain_paths(xd->tb, xd, transmit_path,
2280                                                   transmit_ring, receive_path,
2281                                                   receive_ring);
2282 }
2283 EXPORT_SYMBOL_GPL(tb_xdomain_disable_paths);
2284
2285 struct tb_xdomain_lookup {
2286         const uuid_t *uuid;
2287         u8 link;
2288         u8 depth;
2289         u64 route;
2290 };
2291
2292 static struct tb_xdomain *switch_find_xdomain(struct tb_switch *sw,
2293         const struct tb_xdomain_lookup *lookup)
2294 {
2295         struct tb_port *port;
2296
2297         tb_switch_for_each_port(sw, port) {
2298                 struct tb_xdomain *xd;
2299
2300                 if (port->xdomain) {
2301                         xd = port->xdomain;
2302
2303                         if (lookup->uuid) {
2304                                 if (xd->remote_uuid &&
2305                                     uuid_equal(xd->remote_uuid, lookup->uuid))
2306                                         return xd;
2307                         } else {
2308                                 if (lookup->link && lookup->link == xd->link &&
2309                                     lookup->depth == xd->depth)
2310                                         return xd;
2311                                 if (lookup->route && lookup->route == xd->route)
2312                                         return xd;
2313                         }
2314                 } else if (tb_port_has_remote(port)) {
2315                         xd = switch_find_xdomain(port->remote->sw, lookup);
2316                         if (xd)
2317                                 return xd;
2318                 }
2319         }
2320
2321         return NULL;
2322 }
2323
2324 /**
2325  * tb_xdomain_find_by_uuid() - Find an XDomain by UUID
2326  * @tb: Domain where the XDomain belongs to
2327  * @uuid: UUID to look for
2328  *
2329  * Finds XDomain by walking through the Thunderbolt topology below @tb.
2330  * The returned XDomain will have its reference count increased so the
2331  * caller needs to call tb_xdomain_put() when it is done with the
2332  * object.
2333  *
2334  * This will find all XDomains including the ones that are not yet added
2335  * to the bus (handshake is still in progress).
2336  *
2337  * The caller needs to hold @tb->lock.
2338  */
2339 struct tb_xdomain *tb_xdomain_find_by_uuid(struct tb *tb, const uuid_t *uuid)
2340 {
2341         struct tb_xdomain_lookup lookup;
2342         struct tb_xdomain *xd;
2343
2344         memset(&lookup, 0, sizeof(lookup));
2345         lookup.uuid = uuid;
2346
2347         xd = switch_find_xdomain(tb->root_switch, &lookup);
2348         return tb_xdomain_get(xd);
2349 }
2350 EXPORT_SYMBOL_GPL(tb_xdomain_find_by_uuid);
2351
2352 /**
2353  * tb_xdomain_find_by_link_depth() - Find an XDomain by link and depth
2354  * @tb: Domain where the XDomain belongs to
2355  * @link: Root switch link number
2356  * @depth: Depth in the link
2357  *
2358  * Finds XDomain by walking through the Thunderbolt topology below @tb.
2359  * The returned XDomain will have its reference count increased so the
2360  * caller needs to call tb_xdomain_put() when it is done with the
2361  * object.
2362  *
2363  * This will find all XDomains including the ones that are not yet added
2364  * to the bus (handshake is still in progress).
2365  *
2366  * The caller needs to hold @tb->lock.
2367  */
2368 struct tb_xdomain *tb_xdomain_find_by_link_depth(struct tb *tb, u8 link,
2369                                                  u8 depth)
2370 {
2371         struct tb_xdomain_lookup lookup;
2372         struct tb_xdomain *xd;
2373
2374         memset(&lookup, 0, sizeof(lookup));
2375         lookup.link = link;
2376         lookup.depth = depth;
2377
2378         xd = switch_find_xdomain(tb->root_switch, &lookup);
2379         return tb_xdomain_get(xd);
2380 }
2381
2382 /**
2383  * tb_xdomain_find_by_route() - Find an XDomain by route string
2384  * @tb: Domain where the XDomain belongs to
2385  * @route: XDomain route string
2386  *
2387  * Finds XDomain by walking through the Thunderbolt topology below @tb.
2388  * The returned XDomain will have its reference count increased so the
2389  * caller needs to call tb_xdomain_put() when it is done with the
2390  * object.
2391  *
2392  * This will find all XDomains including the ones that are not yet added
2393  * to the bus (handshake is still in progress).
2394  *
2395  * The caller needs to hold @tb->lock.
2396  */
2397 struct tb_xdomain *tb_xdomain_find_by_route(struct tb *tb, u64 route)
2398 {
2399         struct tb_xdomain_lookup lookup;
2400         struct tb_xdomain *xd;
2401
2402         memset(&lookup, 0, sizeof(lookup));
2403         lookup.route = route;
2404
2405         xd = switch_find_xdomain(tb->root_switch, &lookup);
2406         return tb_xdomain_get(xd);
2407 }
2408 EXPORT_SYMBOL_GPL(tb_xdomain_find_by_route);
2409
2410 bool tb_xdomain_handle_request(struct tb *tb, enum tb_cfg_pkg_type type,
2411                                const void *buf, size_t size)
2412 {
2413         const struct tb_protocol_handler *handler, *tmp;
2414         const struct tb_xdp_header *hdr = buf;
2415         unsigned int length;
2416         int ret = 0;
2417
2418         /* We expect the packet is at least size of the header */
2419         length = hdr->xd_hdr.length_sn & TB_XDOMAIN_LENGTH_MASK;
2420         if (length != size / 4 - sizeof(hdr->xd_hdr) / 4)
2421                 return true;
2422         if (length < sizeof(*hdr) / 4 - sizeof(hdr->xd_hdr) / 4)
2423                 return true;
2424
2425         /*
2426          * Handle XDomain discovery protocol packets directly here. For
2427          * other protocols (based on their UUID) we call registered
2428          * handlers in turn.
2429          */
2430         if (uuid_equal(&hdr->uuid, &tb_xdp_uuid)) {
2431                 if (type == TB_CFG_PKG_XDOMAIN_REQ)
2432                         return tb_xdp_schedule_request(tb, hdr, size);
2433                 return false;
2434         }
2435
2436         mutex_lock(&xdomain_lock);
2437         list_for_each_entry_safe(handler, tmp, &protocol_handlers, list) {
2438                 if (!uuid_equal(&hdr->uuid, handler->uuid))
2439                         continue;
2440
2441                 mutex_unlock(&xdomain_lock);
2442                 ret = handler->callback(buf, size, handler->data);
2443                 mutex_lock(&xdomain_lock);
2444
2445                 if (ret)
2446                         break;
2447         }
2448         mutex_unlock(&xdomain_lock);
2449
2450         return ret > 0;
2451 }
2452
2453 static int update_xdomain(struct device *dev, void *data)
2454 {
2455         struct tb_xdomain *xd;
2456
2457         xd = tb_to_xdomain(dev);
2458         if (xd) {
2459                 queue_delayed_work(xd->tb->wq, &xd->properties_changed_work,
2460                                    msecs_to_jiffies(50));
2461         }
2462
2463         return 0;
2464 }
2465
2466 static void update_all_xdomains(void)
2467 {
2468         bus_for_each_dev(&tb_bus_type, NULL, NULL, update_xdomain);
2469 }
2470
2471 static bool remove_directory(const char *key, const struct tb_property_dir *dir)
2472 {
2473         struct tb_property *p;
2474
2475         p = tb_property_find(xdomain_property_dir, key,
2476                              TB_PROPERTY_TYPE_DIRECTORY);
2477         if (p && p->value.dir == dir) {
2478                 tb_property_remove(p);
2479                 return true;
2480         }
2481         return false;
2482 }
2483
2484 /**
2485  * tb_register_property_dir() - Register property directory to the host
2486  * @key: Key (name) of the directory to add
2487  * @dir: Directory to add
2488  *
2489  * Service drivers can use this function to add new property directory
2490  * to the host available properties. The other connected hosts are
2491  * notified so they can re-read properties of this host if they are
2492  * interested.
2493  *
2494  * Return: %0 on success and negative errno on failure
2495  */
2496 int tb_register_property_dir(const char *key, struct tb_property_dir *dir)
2497 {
2498         int ret;
2499
2500         if (WARN_ON(!xdomain_property_dir))
2501                 return -EAGAIN;
2502
2503         if (!key || strlen(key) > 8)
2504                 return -EINVAL;
2505
2506         mutex_lock(&xdomain_lock);
2507         if (tb_property_find(xdomain_property_dir, key,
2508                              TB_PROPERTY_TYPE_DIRECTORY)) {
2509                 ret = -EEXIST;
2510                 goto err_unlock;
2511         }
2512
2513         ret = tb_property_add_dir(xdomain_property_dir, key, dir);
2514         if (ret)
2515                 goto err_unlock;
2516
2517         xdomain_property_block_gen++;
2518
2519         mutex_unlock(&xdomain_lock);
2520         update_all_xdomains();
2521         return 0;
2522
2523 err_unlock:
2524         mutex_unlock(&xdomain_lock);
2525         return ret;
2526 }
2527 EXPORT_SYMBOL_GPL(tb_register_property_dir);
2528
2529 /**
2530  * tb_unregister_property_dir() - Removes property directory from host
2531  * @key: Key (name) of the directory
2532  * @dir: Directory to remove
2533  *
2534  * This will remove the existing directory from this host and notify the
2535  * connected hosts about the change.
2536  */
2537 void tb_unregister_property_dir(const char *key, struct tb_property_dir *dir)
2538 {
2539         int ret = 0;
2540
2541         mutex_lock(&xdomain_lock);
2542         if (remove_directory(key, dir))
2543                 xdomain_property_block_gen++;
2544         mutex_unlock(&xdomain_lock);
2545
2546         if (!ret)
2547                 update_all_xdomains();
2548 }
2549 EXPORT_SYMBOL_GPL(tb_unregister_property_dir);
2550
2551 int tb_xdomain_init(void)
2552 {
2553         xdomain_property_dir = tb_property_create_dir(NULL);
2554         if (!xdomain_property_dir)
2555                 return -ENOMEM;
2556
2557         /*
2558          * Initialize standard set of properties without any service
2559          * directories. Those will be added by service drivers
2560          * themselves when they are loaded.
2561          *
2562          * Rest of the properties are filled dynamically based on these
2563          * when the P2P connection is made.
2564          */
2565         tb_property_add_immediate(xdomain_property_dir, "vendorid",
2566                                   PCI_VENDOR_ID_INTEL);
2567         tb_property_add_text(xdomain_property_dir, "vendorid", "Intel Corp.");
2568         tb_property_add_immediate(xdomain_property_dir, "deviceid", 0x1);
2569         tb_property_add_immediate(xdomain_property_dir, "devicerv", 0x80000100);
2570
2571         xdomain_property_block_gen = get_random_u32();
2572         return 0;
2573 }
2574
2575 void tb_xdomain_exit(void)
2576 {
2577         tb_property_free_dir(xdomain_property_dir);
2578 }