root/drivers/thunderbolt/domain.c

DEFINITIONS

1. match_service_id
2. __tb_service_match
3. tb_service_match
4. tb_service_probe
5. tb_service_remove
6. tb_service_shutdown
7. boot_acl_show
8. boot_acl_store
9. iommu_dma_protection_show
10. security_show
11. domain_attr_is_visible
12. tb_domain_release
13. tb_domain_alloc
14. tb_domain_event_cb
15. tb_domain_add
16. tb_domain_remove
17. tb_domain_suspend_noirq
18. tb_domain_resume_noirq
19. tb_domain_suspend
20. tb_domain_complete
21. tb_domain_runtime_suspend
22. tb_domain_runtime_resume
23. tb_domain_approve_switch
24. tb_domain_approve_switch_key
25. tb_domain_challenge_switch_key
26. tb_domain_disconnect_pcie_paths
27. tb_domain_approve_xdomain_paths
28. tb_domain_disconnect_xdomain_paths
29. disconnect_xdomain
30. tb_domain_disconnect_all_paths
31. tb_domain_init
32. tb_domain_exit

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  * Thunderbolt bus support
   4  *
   5  * Copyright (C) 2017, Intel Corporation
   6  * Author: Mika Westerberg <mika.westerberg@linux.intel.com>
   7  */
   8 
   9 #include <linux/device.h>
  10 #include <linux/dmar.h>
  11 #include <linux/idr.h>
  12 #include <linux/iommu.h>
  13 #include <linux/module.h>
  14 #include <linux/pm_runtime.h>
  15 #include <linux/slab.h>
  16 #include <linux/random.h>
  17 #include <crypto/hash.h>
  18 
  19 #include "tb.h"
  20 
  21 static DEFINE_IDA(tb_domain_ida);
  22 
  23 static bool match_service_id(const struct tb_service_id *id,
  24                              const struct tb_service *svc)
  25 {
  26         if (id->match_flags & TBSVC_MATCH_PROTOCOL_KEY) {
  27                 if (strcmp(id->protocol_key, svc->key))
  28                         return false;
  29         }
  30 
  31         if (id->match_flags & TBSVC_MATCH_PROTOCOL_ID) {
  32                 if (id->protocol_id != svc->prtcid)
  33                         return false;
  34         }
  35 
  36         if (id->match_flags & TBSVC_MATCH_PROTOCOL_VERSION) {
  37                 if (id->protocol_version != svc->prtcvers)
  38                         return false;
  39         }
  40 
  41         if (id->match_flags & TBSVC_MATCH_PROTOCOL_VERSION) {
  42                 if (id->protocol_revision != svc->prtcrevs)
  43                         return false;
  44         }
  45 
  46         return true;
  47 }
  48 
  49 static const struct tb_service_id *__tb_service_match(struct device *dev,
  50                                                       struct device_driver *drv)
  51 {
  52         struct tb_service_driver *driver;
  53         const struct tb_service_id *ids;
  54         struct tb_service *svc;
  55 
  56         svc = tb_to_service(dev);
  57         if (!svc)
  58                 return NULL;
  59 
  60         driver = container_of(drv, struct tb_service_driver, driver);
  61         if (!driver->id_table)
  62                 return NULL;
  63 
  64         for (ids = driver->id_table; ids->match_flags != 0; ids++) {
  65                 if (match_service_id(ids, svc))
  66                         return ids;
  67         }
  68 
  69         return NULL;
  70 }
  71 
  72 static int tb_service_match(struct device *dev, struct device_driver *drv)
  73 {
  74         return !!__tb_service_match(dev, drv);
  75 }
  76 
  77 static int tb_service_probe(struct device *dev)
  78 {
  79         struct tb_service *svc = tb_to_service(dev);
  80         struct tb_service_driver *driver;
  81         const struct tb_service_id *id;
  82 
  83         driver = container_of(dev->driver, struct tb_service_driver, driver);
  84         id = __tb_service_match(dev, &driver->driver);
  85 
  86         return driver->probe(svc, id);
  87 }
  88 
  89 static int tb_service_remove(struct device *dev)
  90 {
  91         struct tb_service *svc = tb_to_service(dev);
  92         struct tb_service_driver *driver;
  93 
  94         driver = container_of(dev->driver, struct tb_service_driver, driver);
  95         if (driver->remove)
  96                 driver->remove(svc);
  97 
  98         return 0;
  99 }
 100 
 101 static void tb_service_shutdown(struct device *dev)
 102 {
 103         struct tb_service_driver *driver;
 104         struct tb_service *svc;
 105 
 106         svc = tb_to_service(dev);
 107         if (!svc || !dev->driver)
 108                 return;
 109 
 110         driver = container_of(dev->driver, struct tb_service_driver, driver);
 111         if (driver->shutdown)
 112                 driver->shutdown(svc);
 113 }
 114 
 115 static const char * const tb_security_names[] = {
 116         [TB_SECURITY_NONE] = "none",
 117         [TB_SECURITY_USER] = "user",
 118         [TB_SECURITY_SECURE] = "secure",
 119         [TB_SECURITY_DPONLY] = "dponly",
 120         [TB_SECURITY_USBONLY] = "usbonly",
 121 };
 122 
 123 static ssize_t boot_acl_show(struct device *dev, struct device_attribute *attr,
 124                              char *buf)
 125 {
 126         struct tb *tb = container_of(dev, struct tb, dev);
 127         uuid_t *uuids;
 128         ssize_t ret;
 129         int i;
 130 
 131         uuids = kcalloc(tb->nboot_acl, sizeof(uuid_t), GFP_KERNEL);
 132         if (!uuids)
 133                 return -ENOMEM;
 134 
 135         pm_runtime_get_sync(&tb->dev);
 136 
 137         if (mutex_lock_interruptible(&tb->lock)) {
 138                 ret = -ERESTARTSYS;
 139                 goto out;
 140         }
 141         ret = tb->cm_ops->get_boot_acl(tb, uuids, tb->nboot_acl);
 142         if (ret) {
 143                 mutex_unlock(&tb->lock);
 144                 goto out;
 145         }
 146         mutex_unlock(&tb->lock);
 147 
 148         for (ret = 0, i = 0; i < tb->nboot_acl; i++) {
 149                 if (!uuid_is_null(&uuids[i]))
 150                         ret += snprintf(buf + ret, PAGE_SIZE - ret, "%pUb",
 151                                         &uuids[i]);
 152 
 153                 ret += snprintf(buf + ret, PAGE_SIZE - ret, "%s",
 154                                i < tb->nboot_acl - 1 ? "," : "\n");
 155         }
 156 
 157 out:
 158         pm_runtime_mark_last_busy(&tb->dev);
 159         pm_runtime_put_autosuspend(&tb->dev);
 160         kfree(uuids);
 161 
 162         return ret;
 163 }
 164 
 165 static ssize_t boot_acl_store(struct device *dev, struct device_attribute *attr,
 166                               const char *buf, size_t count)
 167 {
 168         struct tb *tb = container_of(dev, struct tb, dev);
 169         char *str, *s, *uuid_str;
 170         ssize_t ret = 0;
 171         uuid_t *acl;
 172         int i = 0;
 173 
 174         /*
 175          * Make sure the value is not bigger than tb->nboot_acl * UUID
 176          * length + commas and optional "\n". Also the smallest allowable
 177          * string is tb->nboot_acl * ",".
 178          */
 179         if (count > (UUID_STRING_LEN + 1) * tb->nboot_acl + 1)
 180                 return -EINVAL;
 181         if (count < tb->nboot_acl - 1)
 182                 return -EINVAL;
 183 
 184         str = kstrdup(buf, GFP_KERNEL);
 185         if (!str)
 186                 return -ENOMEM;
 187 
 188         acl = kcalloc(tb->nboot_acl, sizeof(uuid_t), GFP_KERNEL);
 189         if (!acl) {
 190                 ret = -ENOMEM;
 191                 goto err_free_str;
 192         }
 193 
 194         uuid_str = strim(str);
 195         while ((s = strsep(&uuid_str, ",")) != NULL && i < tb->nboot_acl) {
 196                 size_t len = strlen(s);
 197 
 198                 if (len) {
 199                         if (len != UUID_STRING_LEN) {
 200                                 ret = -EINVAL;
 201                                 goto err_free_acl;
 202                         }
 203                         ret = uuid_parse(s, &acl[i]);
 204                         if (ret)
 205                                 goto err_free_acl;
 206                 }
 207 
 208                 i++;
 209         }
 210 
 211         if (s || i < tb->nboot_acl) {
 212                 ret = -EINVAL;
 213                 goto err_free_acl;
 214         }
 215 
 216         pm_runtime_get_sync(&tb->dev);
 217 
 218         if (mutex_lock_interruptible(&tb->lock)) {
 219                 ret = -ERESTARTSYS;
 220                 goto err_rpm_put;
 221         }
 222         ret = tb->cm_ops->set_boot_acl(tb, acl, tb->nboot_acl);
 223         if (!ret) {
 224                 /* Notify userspace about the change */
 225                 kobject_uevent(&tb->dev.kobj, KOBJ_CHANGE);
 226         }
 227         mutex_unlock(&tb->lock);
 228 
 229 err_rpm_put:
 230         pm_runtime_mark_last_busy(&tb->dev);
 231         pm_runtime_put_autosuspend(&tb->dev);
 232 err_free_acl:
 233         kfree(acl);
 234 err_free_str:
 235         kfree(str);
 236 
 237         return ret ?: count;
 238 }
 239 static DEVICE_ATTR_RW(boot_acl);
 240 
 241 static ssize_t iommu_dma_protection_show(struct device *dev,
 242                                          struct device_attribute *attr,
 243                                          char *buf)
 244 {
 245         /*
 246          * Kernel DMA protection is a feature where Thunderbolt security is
 247          * handled natively using IOMMU. It is enabled when IOMMU is
 248          * enabled and ACPI DMAR table has DMAR_PLATFORM_OPT_IN set.
 249          */
 250         return sprintf(buf, "%d\n",
 251                        iommu_present(&pci_bus_type) && dmar_platform_optin());
 252 }
 253 static DEVICE_ATTR_RO(iommu_dma_protection);
 254 
 255 static ssize_t security_show(struct device *dev, struct device_attribute *attr,
 256                              char *buf)
 257 {
 258         struct tb *tb = container_of(dev, struct tb, dev);
 259         const char *name = "unknown";
 260 
 261         if (tb->security_level < ARRAY_SIZE(tb_security_names))
 262                 name = tb_security_names[tb->security_level];
 263 
 264         return sprintf(buf, "%s\n", name);
 265 }
 266 static DEVICE_ATTR_RO(security);
 267 
 268 static struct attribute *domain_attrs[] = {
 269         &dev_attr_boot_acl.attr,
 270         &dev_attr_iommu_dma_protection.attr,
 271         &dev_attr_security.attr,
 272         NULL,
 273 };
 274 
 275 static umode_t domain_attr_is_visible(struct kobject *kobj,
 276                                       struct attribute *attr, int n)
 277 {
 278         struct device *dev = container_of(kobj, struct device, kobj);
 279         struct tb *tb = container_of(dev, struct tb, dev);
 280 
 281         if (attr == &dev_attr_boot_acl.attr) {
 282                 if (tb->nboot_acl &&
 283                     tb->cm_ops->get_boot_acl &&
 284                     tb->cm_ops->set_boot_acl)
 285                         return attr->mode;
 286                 return 0;
 287         }
 288 
 289         return attr->mode;
 290 }
 291 
 292 static struct attribute_group domain_attr_group = {
 293         .is_visible = domain_attr_is_visible,
 294         .attrs = domain_attrs,
 295 };
 296 
 297 static const struct attribute_group *domain_attr_groups[] = {
 298         &domain_attr_group,
 299         NULL,
 300 };
 301 
 302 struct bus_type tb_bus_type = {
 303         .name = "thunderbolt",
 304         .match = tb_service_match,
 305         .probe = tb_service_probe,
 306         .remove = tb_service_remove,
 307         .shutdown = tb_service_shutdown,
 308 };
 309 
 310 static void tb_domain_release(struct device *dev)
 311 {
 312         struct tb *tb = container_of(dev, struct tb, dev);
 313 
 314         tb_ctl_free(tb->ctl);
 315         destroy_workqueue(tb->wq);
 316         ida_simple_remove(&tb_domain_ida, tb->index);
 317         mutex_destroy(&tb->lock);
 318         kfree(tb);
 319 }
 320 
 321 struct device_type tb_domain_type = {
 322         .name = "thunderbolt_domain",
 323         .release = tb_domain_release,
 324 };
 325 
 326 /**
 327  * tb_domain_alloc() - Allocate a domain
 328  * @nhi: Pointer to the host controller
 329  * @privsize: Size of the connection manager private data
 330  *
 331  * Allocates and initializes a new Thunderbolt domain. Connection
 332  * managers are expected to call this and then fill in @cm_ops
 333  * accordingly.
 334  *
 335  * Call tb_domain_put() to release the domain before it has been added
 336  * to the system.
 337  *
 338  * Return: allocated domain structure on %NULL in case of error
 339  */
 340 struct tb *tb_domain_alloc(struct tb_nhi *nhi, size_t privsize)
 341 {
 342         struct tb *tb;
 343 
 344         /*
 345          * Make sure the structure sizes map with that the hardware
 346          * expects because bit-fields are being used.
 347          */
 348         BUILD_BUG_ON(sizeof(struct tb_regs_switch_header) != 5 * 4);
 349         BUILD_BUG_ON(sizeof(struct tb_regs_port_header) != 8 * 4);
 350         BUILD_BUG_ON(sizeof(struct tb_regs_hop) != 2 * 4);
 351 
 352         tb = kzalloc(sizeof(*tb) + privsize, GFP_KERNEL);
 353         if (!tb)
 354                 return NULL;
 355 
 356         tb->nhi = nhi;
 357         mutex_init(&tb->lock);
 358 
 359         tb->index = ida_simple_get(&tb_domain_ida, 0, 0, GFP_KERNEL);
 360         if (tb->index < 0)
 361                 goto err_free;
 362 
 363         tb->wq = alloc_ordered_workqueue("thunderbolt%d", 0, tb->index);
 364         if (!tb->wq)
 365                 goto err_remove_ida;
 366 
 367         tb->dev.parent = &nhi->pdev->dev;
 368         tb->dev.bus = &tb_bus_type;
 369         tb->dev.type = &tb_domain_type;
 370         tb->dev.groups = domain_attr_groups;
 371         dev_set_name(&tb->dev, "domain%d", tb->index);
 372         device_initialize(&tb->dev);
 373 
 374         return tb;
 375 
 376 err_remove_ida:
 377         ida_simple_remove(&tb_domain_ida, tb->index);
 378 err_free:
 379         kfree(tb);
 380 
 381         return NULL;
 382 }
 383 
 384 static bool tb_domain_event_cb(void *data, enum tb_cfg_pkg_type type,
 385                                const void *buf, size_t size)
 386 {
 387         struct tb *tb = data;
 388 
 389         if (!tb->cm_ops->handle_event) {
 390                 tb_warn(tb, "domain does not have event handler\n");
 391                 return true;
 392         }
 393 
 394         switch (type) {
 395         case TB_CFG_PKG_XDOMAIN_REQ:
 396         case TB_CFG_PKG_XDOMAIN_RESP:
 397                 return tb_xdomain_handle_request(tb, type, buf, size);
 398 
 399         default:
 400                 tb->cm_ops->handle_event(tb, type, buf, size);
 401         }
 402 
 403         return true;
 404 }
 405 
 406 /**
 407  * tb_domain_add() - Add domain to the system
 408  * @tb: Domain to add
 409  *
 410  * Starts the domain and adds it to the system. Hotplugging devices will
 411  * work after this has been returned successfully. In order to remove
 412  * and release the domain after this function has been called, call
 413  * tb_domain_remove().
 414  *
 415  * Return: %0 in case of success and negative errno in case of error
 416  */
 417 int tb_domain_add(struct tb *tb)
 418 {
 419         int ret;
 420 
 421         if (WARN_ON(!tb->cm_ops))
 422                 return -EINVAL;
 423 
 424         mutex_lock(&tb->lock);
 425 
 426         tb->ctl = tb_ctl_alloc(tb->nhi, tb_domain_event_cb, tb);
 427         if (!tb->ctl) {
 428                 ret = -ENOMEM;
 429                 goto err_unlock;
 430         }
 431 
 432         /*
 433          * tb_schedule_hotplug_handler may be called as soon as the config
 434          * channel is started. Thats why we have to hold the lock here.
 435          */
 436         tb_ctl_start(tb->ctl);
 437 
 438         if (tb->cm_ops->driver_ready) {
 439                 ret = tb->cm_ops->driver_ready(tb);
 440                 if (ret)
 441                         goto err_ctl_stop;
 442         }
 443 
 444         ret = device_add(&tb->dev);
 445         if (ret)
 446                 goto err_ctl_stop;
 447 
 448         /* Start the domain */
 449         if (tb->cm_ops->start) {
 450                 ret = tb->cm_ops->start(tb);
 451                 if (ret)
 452                         goto err_domain_del;
 453         }
 454 
 455         /* This starts event processing */
 456         mutex_unlock(&tb->lock);
 457 
 458         pm_runtime_no_callbacks(&tb->dev);
 459         pm_runtime_set_active(&tb->dev);
 460         pm_runtime_enable(&tb->dev);
 461         pm_runtime_set_autosuspend_delay(&tb->dev, TB_AUTOSUSPEND_DELAY);
 462         pm_runtime_mark_last_busy(&tb->dev);
 463         pm_runtime_use_autosuspend(&tb->dev);
 464 
 465         return 0;
 466 
 467 err_domain_del:
 468         device_del(&tb->dev);
 469 err_ctl_stop:
 470         tb_ctl_stop(tb->ctl);
 471 err_unlock:
 472         mutex_unlock(&tb->lock);
 473 
 474         return ret;
 475 }
 476 
 477 /**
 478  * tb_domain_remove() - Removes and releases a domain
 479  * @tb: Domain to remove
 480  *
 481  * Stops the domain, removes it from the system and releases all
 482  * resources once the last reference has been released.
 483  */
 484 void tb_domain_remove(struct tb *tb)
 485 {
 486         mutex_lock(&tb->lock);
 487         if (tb->cm_ops->stop)
 488                 tb->cm_ops->stop(tb);
 489         /* Stop the domain control traffic */
 490         tb_ctl_stop(tb->ctl);
 491         mutex_unlock(&tb->lock);
 492 
 493         flush_workqueue(tb->wq);
 494         device_unregister(&tb->dev);
 495 }
 496 
 497 /**
 498  * tb_domain_suspend_noirq() - Suspend a domain
 499  * @tb: Domain to suspend
 500  *
 501  * Suspends all devices in the domain and stops the control channel.
 502  */
 503 int tb_domain_suspend_noirq(struct tb *tb)
 504 {
 505         int ret = 0;
 506 
 507         /*
 508          * The control channel interrupt is left enabled during suspend
 509          * and taking the lock here prevents any events happening before
 510          * we actually have stopped the domain and the control channel.
 511          */
 512         mutex_lock(&tb->lock);
 513         if (tb->cm_ops->suspend_noirq)
 514                 ret = tb->cm_ops->suspend_noirq(tb);
 515         if (!ret)
 516                 tb_ctl_stop(tb->ctl);
 517         mutex_unlock(&tb->lock);
 518 
 519         return ret;
 520 }
 521 
 522 /**
 523  * tb_domain_resume_noirq() - Resume a domain
 524  * @tb: Domain to resume
 525  *
 526  * Re-starts the control channel, and resumes all devices connected to
 527  * the domain.
 528  */
 529 int tb_domain_resume_noirq(struct tb *tb)
 530 {
 531         int ret = 0;
 532 
 533         mutex_lock(&tb->lock);
 534         tb_ctl_start(tb->ctl);
 535         if (tb->cm_ops->resume_noirq)
 536                 ret = tb->cm_ops->resume_noirq(tb);
 537         mutex_unlock(&tb->lock);
 538 
 539         return ret;
 540 }
 541 
 542 int tb_domain_suspend(struct tb *tb)
 543 {
 544         return tb->cm_ops->suspend ? tb->cm_ops->suspend(tb) : 0;
 545 }
 546 
 547 void tb_domain_complete(struct tb *tb)
 548 {
 549         if (tb->cm_ops->complete)
 550                 tb->cm_ops->complete(tb);
 551 }
 552 
 553 int tb_domain_runtime_suspend(struct tb *tb)
 554 {
 555         if (tb->cm_ops->runtime_suspend) {
 556                 int ret = tb->cm_ops->runtime_suspend(tb);
 557                 if (ret)
 558                         return ret;
 559         }
 560         tb_ctl_stop(tb->ctl);
 561         return 0;
 562 }
 563 
 564 int tb_domain_runtime_resume(struct tb *tb)
 565 {
 566         tb_ctl_start(tb->ctl);
 567         if (tb->cm_ops->runtime_resume) {
 568                 int ret = tb->cm_ops->runtime_resume(tb);
 569                 if (ret)
 570                         return ret;
 571         }
 572         return 0;
 573 }
 574 
 575 /**
 576  * tb_domain_approve_switch() - Approve switch
 577  * @tb: Domain the switch belongs to
 578  * @sw: Switch to approve
 579  *
 580  * This will approve switch by connection manager specific means. In
 581  * case of success the connection manager will create tunnels for all
 582  * supported protocols.
 583  */
 584 int tb_domain_approve_switch(struct tb *tb, struct tb_switch *sw)
 585 {
 586         struct tb_switch *parent_sw;
 587 
 588         if (!tb->cm_ops->approve_switch)
 589                 return -EPERM;
 590 
 591         /* The parent switch must be authorized before this one */
 592         parent_sw = tb_to_switch(sw->dev.parent);
 593         if (!parent_sw || !parent_sw->authorized)
 594                 return -EINVAL;
 595 
 596         return tb->cm_ops->approve_switch(tb, sw);
 597 }
 598 
 599 /**
 600  * tb_domain_approve_switch_key() - Approve switch and add key
 601  * @tb: Domain the switch belongs to
 602  * @sw: Switch to approve
 603  *
 604  * For switches that support secure connect, this function first adds
 605  * key to the switch NVM using connection manager specific means. If
 606  * adding the key is successful, the switch is approved and connected.
 607  *
 608  * Return: %0 on success and negative errno in case of failure.
 609  */
 610 int tb_domain_approve_switch_key(struct tb *tb, struct tb_switch *sw)
 611 {
 612         struct tb_switch *parent_sw;
 613         int ret;
 614 
 615         if (!tb->cm_ops->approve_switch || !tb->cm_ops->add_switch_key)
 616                 return -EPERM;
 617 
 618         /* The parent switch must be authorized before this one */
 619         parent_sw = tb_to_switch(sw->dev.parent);
 620         if (!parent_sw || !parent_sw->authorized)
 621                 return -EINVAL;
 622 
 623         ret = tb->cm_ops->add_switch_key(tb, sw);
 624         if (ret)
 625                 return ret;
 626 
 627         return tb->cm_ops->approve_switch(tb, sw);
 628 }
 629 
 630 /**
 631  * tb_domain_challenge_switch_key() - Challenge and approve switch
 632  * @tb: Domain the switch belongs to
 633  * @sw: Switch to approve
 634  *
 635  * For switches that support secure connect, this function generates
 636  * random challenge and sends it to the switch. The switch responds to
 637  * this and if the response matches our random challenge, the switch is
 638  * approved and connected.
 639  *
 640  * Return: %0 on success and negative errno in case of failure.
 641  */
 642 int tb_domain_challenge_switch_key(struct tb *tb, struct tb_switch *sw)
 643 {
 644         u8 challenge[TB_SWITCH_KEY_SIZE];
 645         u8 response[TB_SWITCH_KEY_SIZE];
 646         u8 hmac[TB_SWITCH_KEY_SIZE];
 647         struct tb_switch *parent_sw;
 648         struct crypto_shash *tfm;
 649         struct shash_desc *shash;
 650         int ret;
 651 
 652         if (!tb->cm_ops->approve_switch || !tb->cm_ops->challenge_switch_key)
 653                 return -EPERM;
 654 
 655         /* The parent switch must be authorized before this one */
 656         parent_sw = tb_to_switch(sw->dev.parent);
 657         if (!parent_sw || !parent_sw->authorized)
 658                 return -EINVAL;
 659 
 660         get_random_bytes(challenge, sizeof(challenge));
 661         ret = tb->cm_ops->challenge_switch_key(tb, sw, challenge, response);
 662         if (ret)
 663                 return ret;
 664 
 665         tfm = crypto_alloc_shash("hmac(sha256)", 0, 0);
 666         if (IS_ERR(tfm))
 667                 return PTR_ERR(tfm);
 668 
 669         ret = crypto_shash_setkey(tfm, sw->key, TB_SWITCH_KEY_SIZE);
 670         if (ret)
 671                 goto err_free_tfm;
 672 
 673         shash = kzalloc(sizeof(*shash) + crypto_shash_descsize(tfm),
 674                         GFP_KERNEL);
 675         if (!shash) {
 676                 ret = -ENOMEM;
 677                 goto err_free_tfm;
 678         }
 679 
 680         shash->tfm = tfm;
 681 
 682         memset(hmac, 0, sizeof(hmac));
 683         ret = crypto_shash_digest(shash, challenge, sizeof(hmac), hmac);
 684         if (ret)
 685                 goto err_free_shash;
 686 
 687         /* The returned HMAC must match the one we calculated */
 688         if (memcmp(response, hmac, sizeof(hmac))) {
 689                 ret = -EKEYREJECTED;
 690                 goto err_free_shash;
 691         }
 692 
 693         crypto_free_shash(tfm);
 694         kfree(shash);
 695 
 696         return tb->cm_ops->approve_switch(tb, sw);
 697 
 698 err_free_shash:
 699         kfree(shash);
 700 err_free_tfm:
 701         crypto_free_shash(tfm);
 702 
 703         return ret;
 704 }
 705 
 706 /**
 707  * tb_domain_disconnect_pcie_paths() - Disconnect all PCIe paths
 708  * @tb: Domain whose PCIe paths to disconnect
 709  *
 710  * This needs to be called in preparation for NVM upgrade of the host
 711  * controller. Makes sure all PCIe paths are disconnected.
 712  *
 713  * Return %0 on success and negative errno in case of error.
 714  */
 715 int tb_domain_disconnect_pcie_paths(struct tb *tb)
 716 {
 717         if (!tb->cm_ops->disconnect_pcie_paths)
 718                 return -EPERM;
 719 
 720         return tb->cm_ops->disconnect_pcie_paths(tb);
 721 }
 722 
 723 /**
 724  * tb_domain_approve_xdomain_paths() - Enable DMA paths for XDomain
 725  * @tb: Domain enabling the DMA paths
 726  * @xd: XDomain DMA paths are created to
 727  *
 728  * Calls connection manager specific method to enable DMA paths to the
 729  * XDomain in question.
 730  *
 731  * Return: 0% in case of success and negative errno otherwise. In
 732  * particular returns %-ENOTSUPP if the connection manager
 733  * implementation does not support XDomains.
 734  */
 735 int tb_domain_approve_xdomain_paths(struct tb *tb, struct tb_xdomain *xd)
 736 {
 737         if (!tb->cm_ops->approve_xdomain_paths)
 738                 return -ENOTSUPP;
 739 
 740         return tb->cm_ops->approve_xdomain_paths(tb, xd);
 741 }
 742 
 743 /**
 744  * tb_domain_disconnect_xdomain_paths() - Disable DMA paths for XDomain
 745  * @tb: Domain disabling the DMA paths
 746  * @xd: XDomain whose DMA paths are disconnected
 747  *
 748  * Calls connection manager specific method to disconnect DMA paths to
 749  * the XDomain in question.
 750  *
 751  * Return: 0% in case of success and negative errno otherwise. In
 752  * particular returns %-ENOTSUPP if the connection manager
 753  * implementation does not support XDomains.
 754  */
 755 int tb_domain_disconnect_xdomain_paths(struct tb *tb, struct tb_xdomain *xd)
 756 {
 757         if (!tb->cm_ops->disconnect_xdomain_paths)
 758                 return -ENOTSUPP;
 759 
 760         return tb->cm_ops->disconnect_xdomain_paths(tb, xd);
 761 }
 762 
 763 static int disconnect_xdomain(struct device *dev, void *data)
 764 {
 765         struct tb_xdomain *xd;
 766         struct tb *tb = data;
 767         int ret = 0;
 768 
 769         xd = tb_to_xdomain(dev);
 770         if (xd && xd->tb == tb)
 771                 ret = tb_xdomain_disable_paths(xd);
 772 
 773         return ret;
 774 }
 775 
 776 /**
 777  * tb_domain_disconnect_all_paths() - Disconnect all paths for the domain
 778  * @tb: Domain whose paths are disconnected
 779  *
 780  * This function can be used to disconnect all paths (PCIe, XDomain) for
 781  * example in preparation for host NVM firmware upgrade. After this is
 782  * called the paths cannot be established without resetting the switch.
 783  *
 784  * Return: %0 in case of success and negative errno otherwise.
 785  */
 786 int tb_domain_disconnect_all_paths(struct tb *tb)
 787 {
 788         int ret;
 789 
 790         ret = tb_domain_disconnect_pcie_paths(tb);
 791         if (ret)
 792                 return ret;
 793 
 794         return bus_for_each_dev(&tb_bus_type, NULL, tb, disconnect_xdomain);
 795 }
 796 
 797 int tb_domain_init(void)
 798 {
 799         int ret;
 800 
 801         ret = tb_xdomain_init();
 802         if (ret)
 803                 return ret;
 804         ret = bus_register(&tb_bus_type);
 805         if (ret)
 806                 tb_xdomain_exit();
 807 
 808         return ret;
 809 }
 810 
 811 void tb_domain_exit(void)
 812 {
 813         bus_unregister(&tb_bus_type);
 814         ida_destroy(&tb_domain_ida);
 815         tb_switch_exit();
 816         tb_xdomain_exit();
 817 }