drivers/thunderbolt/domain.c

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