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