text: // SPDX-License-Identifier: GPL-2.0
  /*
   * Thunderbolt bus support
   *
   * Copyright (C) 2017, Intel Corporation
   * Author: Mika Westerberg <mika.westerberg@linux.intel.com>
   */
  
  #include <linux/device.h>
  #include <linux/dmar.h>
  #include <linux/idr.h>
  #include <linux/iommu.h>
  #include <linux/module.h>
  #include <linux/pm_runtime.h>
  #include <linux/slab.h>
  #include <linux/random.h>
  #include <crypto/hash.h>
  
  #include "tb.h"
  
  static DEFINE_IDA(tb_domain_ida);
  
  static bool match_service_id(const struct tb_service_id *id,
  			     const struct tb_service *svc)
  {
  	if (id->match_flags & TBSVC_MATCH_PROTOCOL_KEY) {
  		if (strcmp(id->protocol_key, svc->key))
  			return false;
  	}
  
  	if (id->match_flags & TBSVC_MATCH_PROTOCOL_ID) {
  		if (id->protocol_id != svc->prtcid)
  			return false;
  	}
  
  	if (id->match_flags & TBSVC_MATCH_PROTOCOL_VERSION) {
  		if (id->protocol_version != svc->prtcvers)
  			return false;
  	}
  
  	if (id->match_flags & TBSVC_MATCH_PROTOCOL_VERSION) {
  		if (id->protocol_revision != svc->prtcrevs)
  			return false;
  	}
  
  	return true;
  }
  
  static const struct tb_service_id *__tb_service_match(struct device *dev,
  						      struct device_driver *drv)
  {
  	struct tb_service_driver *driver;
  	const struct tb_service_id *ids;
  	struct tb_service *svc;
  
  	svc = tb_to_service(dev);
  	if (!svc)
  		return NULL;
  
  	driver = container_of(drv, struct tb_service_driver, driver);
  	if (!driver->id_table)
  		return NULL;
  
  	for (ids = driver->id_table; ids->match_flags != 0; ids++) {
  		if (match_service_id(ids, svc))
  			return ids;
  	}
  
  	return NULL;
  }
  
  static int tb_service_match(struct device *dev, struct device_driver *drv)
  {
  	return !!__tb_service_match(dev, drv);
  }
  
  static int tb_service_probe(struct device *dev)
  {
  	struct tb_service *svc = tb_to_service(dev);
  	struct tb_service_driver *driver;
  	const struct tb_service_id *id;
  
  	driver = container_of(dev->driver, struct tb_service_driver, driver);
  	id = __tb_service_match(dev, &driver->driver);
  
  	return driver->probe(svc, id);
  }
  
  static int tb_service_remove(struct device *dev)
  {
  	struct tb_service *svc = tb_to_service(dev);
  	struct tb_service_driver *driver;
  
  	driver = container_of(dev->driver, struct tb_service_driver, driver);
  	if (driver->remove)
  		driver->remove(svc);
  
  	return 0;
  }
  
  static void tb_service_shutdown(struct device *dev)
  {
  	struct tb_service_driver *driver;
  	struct tb_service *svc;
  
  	svc = tb_to_service(dev);
  	if (!svc || !dev->driver)
  		return;
  
  	driver = container_of(dev->driver, struct tb_service_driver, driver);
  	if (driver->shutdown)
  		driver->shutdown(svc);
  }
  
  static const char * const tb_security_names[] = {
  	[TB_SECURITY_NONE] = "none",
  	[TB_SECURITY_USER] = "user",
  	[TB_SECURITY_SECURE] = "secure",
  	[TB_SECURITY_DPONLY] = "dponly",
  	[TB_SECURITY_USBONLY] = "usbonly",
  };
  
  static ssize_t boot_acl_show(struct device *dev, struct device_attribute *attr,
  			     char *buf)
  {
  	struct tb *tb = container_of(dev, struct tb, dev);
  	uuid_t *uuids;
  	ssize_t ret;
  	int i;
  
  	uuids = kcalloc(tb->nboot_acl, sizeof(uuid_t), GFP_KERNEL);
  	if (!uuids)
  		return -ENOMEM;
  
  	pm_runtime_get_sync(&tb->dev);
  
  	if (mutex_lock_interruptible(&tb->lock)) {
  		ret = -ERESTARTSYS;
  		goto out;
  	}
  	ret = tb->cm_ops->get_boot_acl(tb, uuids, tb->nboot_acl);
  	if (ret) {
  		mutex_unlock(&tb->lock);
  		goto out;
  	}
  	mutex_unlock(&tb->lock);
  
  	for (ret = 0, i = 0; i < tb->nboot_acl; i++) {
  		if (!uuid_is_null(&uuids[i]))
  			ret += snprintf(buf + ret, PAGE_SIZE - ret, "%pUb",
  					&uuids[i]);
  
  		ret += snprintf(buf + ret, PAGE_SIZE - ret, "%s",
  			       i < tb->nboot_acl - 1 ? "," : "\n");
  	}
  
  out:
  	pm_runtime_mark_last_busy(&tb->dev);
  	pm_runtime_put_autosuspend(&tb->dev);
  	kfree(uuids);
  
  	return ret;
  }
  
  static ssize_t boot_acl_store(struct device *dev, struct device_attribute *attr,
  			      const char *buf, size_t count)
  {
  	struct tb *tb = container_of(dev, struct tb, dev);
  	char *str, *s, *uuid_str;
  	ssize_t ret = 0;
  	uuid_t *acl;
  	int i = 0;
  
  	/*
  	 * Make sure the value is not bigger than tb->nboot_acl * UUID
  	 * length + commas and optional "\n". Also the smallest allowable
  	 * string is tb->nboot_acl * ",".
  	 */
  	if (count > (UUID_STRING_LEN + 1) * tb->nboot_acl + 1)
  		return -EINVAL;
  	if (count < tb->nboot_acl - 1)
  		return -EINVAL;
  
  	str = kstrdup(buf, GFP_KERNEL);
  	if (!str)
  		return -ENOMEM;
  
  	acl = kcalloc(tb->nboot_acl, sizeof(uuid_t), GFP_KERNEL);
  	if (!acl) {
  		ret = -ENOMEM;
  		goto err_free_str;
  	}
  
  	uuid_str = strim(str);
  	while ((s = strsep(&uuid_str, ",")) != NULL && i < tb->nboot_acl) {
  		size_t len = strlen(s);
  
  		if (len) {
  			if (len != UUID_STRING_LEN) {
  				ret = -EINVAL;
  				goto err_free_acl;
  			}
  			ret = uuid_parse(s, &acl[i]);
  			if (ret)
  				goto err_free_acl;
  		}
  
  		i++;
  	}
  
  	if (s || i < tb->nboot_acl) {
  		ret = -EINVAL;
  		goto err_free_acl;
  	}
  
  	pm_runtime_get_sync(&tb->dev);
  
  	if (mutex_lock_interruptible(&tb->lock)) {
  		ret = -ERESTARTSYS;
  		goto err_rpm_put;
  	}
  	ret = tb->cm_ops->set_boot_acl(tb, acl, tb->nboot_acl);
  	if (!ret) {
  		/* Notify userspace about the change */
  		kobject_uevent(&tb->dev.kobj, KOBJ_CHANGE);
  	}
  	mutex_unlock(&tb->lock);
  
  err_rpm_put:
  	pm_runtime_mark_last_busy(&tb->dev);
  	pm_runtime_put_autosuspend(&tb->dev);
  err_free_acl:
  	kfree(acl);
  err_free_str:
  	kfree(str);
  
  	return ret ?: count;
  }
  static DEVICE_ATTR_RW(boot_acl);
  
  static ssize_t iommu_dma_protection_show(struct device *dev,
  					 struct device_attribute *attr,
  					 char *buf)
  {
  	/*
  	 * Kernel DMA protection is a feature where Thunderbolt security is
  	 * handled natively using IOMMU. It is enabled when IOMMU is
  	 * enabled and ACPI DMAR table has DMAR_PLATFORM_OPT_IN set.
  	 */
  	return sprintf(buf, "%d\n",
  		       iommu_present(&pci_bus_type) && dmar_platform_optin());
  }
  static DEVICE_ATTR_RO(iommu_dma_protection);
  
  static ssize_t security_show(struct device *dev, struct device_attribute *attr,
  			     char *buf)
  {
  	struct tb *tb = container_of(dev, struct tb, dev);
  	const char *name = "unknown";
  
  	if (tb->security_level < ARRAY_SIZE(tb_security_names))
  		name = tb_security_names[tb->security_level];
  
  	return sprintf(buf, "%s\n", name);
  }
  static DEVICE_ATTR_RO(security);
  
  static struct attribute *domain_attrs[] = {
  	&dev_attr_boot_acl.attr,
  	&dev_attr_iommu_dma_protection.attr,
  	&dev_attr_security.attr,
  	NULL,
  };
  
  static umode_t domain_attr_is_visible(struct kobject *kobj,
  				      struct attribute *attr, int n)
  {
  	struct device *dev = container_of(kobj, struct device, kobj);
  	struct tb *tb = container_of(dev, struct tb, dev);
  
  	if (attr == &dev_attr_boot_acl.attr) {
  		if (tb->nboot_acl &&
  		    tb->cm_ops->get_boot_acl &&
  		    tb->cm_ops->set_boot_acl)
  			return attr->mode;
  		return 0;
  	}
  
  	return attr->mode;
  }
  
  static struct attribute_group domain_attr_group = {
  	.is_visible = domain_attr_is_visible,
  	.attrs = domain_attrs,
  };
  
  static const struct attribute_group *domain_attr_groups[] = {
  	&domain_attr_group,
  	NULL,
  };
  
  struct bus_type tb_bus_type = {
  	.name = "thunderbolt",
  	.match = tb_service_match,
  	.probe = tb_service_probe,
  	.remove = tb_service_remove,
  	.shutdown = tb_service_shutdown,
  };
  
  static void tb_domain_release(struct device *dev)
  {
  	struct tb *tb = container_of(dev, struct tb, dev);
  
  	tb_ctl_free(tb->ctl);
  	destroy_workqueue(tb->wq);
  	ida_simple_remove(&tb_domain_ida, tb->index);
  	mutex_destroy(&tb->lock);
  	kfree(tb);
  }
  
  struct device_type tb_domain_type = {
  	.name = "thunderbolt_domain",
  	.release = tb_domain_release,
  };
  
  /**
   * tb_domain_alloc() - Allocate a domain
   * @nhi: Pointer to the host controller
   * @privsize: Size of the connection manager private data
   *
   * Allocates and initializes a new Thunderbolt domain. Connection
   * managers are expected to call this and then fill in @cm_ops
   * accordingly.
   *
   * Call tb_domain_put() to release the domain before it has been added
   * to the system.
   *
   * Return: allocated domain structure on %NULL in case of error
   */
  struct tb *tb_domain_alloc(struct tb_nhi *nhi, size_t privsize)
  {
  	struct tb *tb;
  
  	/*
  	 * Make sure the structure sizes map with that the hardware
  	 * expects because bit-fields are being used.
  	 */
  	BUILD_BUG_ON(sizeof(struct tb_regs_switch_header) != 5 * 4);
  	BUILD_BUG_ON(sizeof(struct tb_regs_port_header) != 8 * 4);
  	BUILD_BUG_ON(sizeof(struct tb_regs_hop) != 2 * 4);
  
  	tb = kzalloc(sizeof(*tb) + privsize, GFP_KERNEL);
  	if (!tb)
  		return NULL;
  
  	tb->nhi = nhi;
  	mutex_init(&tb->lock);
  
  	tb->index = ida_simple_get(&tb_domain_ida, 0, 0, GFP_KERNEL);
  	if (tb->index < 0)
  		goto err_free;
  
  	tb->wq = alloc_ordered_workqueue("thunderbolt%d", 0, tb->index);
  	if (!tb->wq)
  		goto err_remove_ida;
  
  	tb->dev.parent = &nhi->pdev->dev;
  	tb->dev.bus = &tb_bus_type;
  	tb->dev.type = &tb_domain_type;
  	tb->dev.groups = domain_attr_groups;
  	dev_set_name(&tb->dev, "domain%d", tb->index);
  	device_initialize(&tb->dev);
  
  	return tb;
  
  err_remove_ida:
  	ida_simple_remove(&tb_domain_ida, tb->index);
  err_free:
  	kfree(tb);
  
  	return NULL;
  }
  
  static bool tb_domain_event_cb(void *data, enum tb_cfg_pkg_type type,
  			       const void *buf, size_t size)
  {
  	struct tb *tb = data;
  
  	if (!tb->cm_ops->handle_event) {
  		tb_warn(tb, "domain does not have event handler\n");
  		return true;
  	}
  
  	switch (type) {
  	case TB_CFG_PKG_XDOMAIN_REQ:
  	case TB_CFG_PKG_XDOMAIN_RESP:
  		return tb_xdomain_handle_request(tb, type, buf, size);
  
  	default:
  		tb->cm_ops->handle_event(tb, type, buf, size);
  	}
  
  	return true;
  }
  
  /**
   * tb_domain_add() - Add domain to the system
   * @tb: Domain to add
   *
   * Starts the domain and adds it to the system. Hotplugging devices will
   * work after this has been returned successfully. In order to remove
   * and release the domain after this function has been called, call
   * tb_domain_remove().
   *
   * Return: %0 in case of success and negative errno in case of error
   */
  int tb_domain_add(struct tb *tb)
  {
  	int ret;
  
  	if (WARN_ON(!tb->cm_ops))
  		return -EINVAL;
  
  	mutex_lock(&tb->lock);
  
  	tb->ctl = tb_ctl_alloc(tb->nhi, tb_domain_event_cb, tb);
  	if (!tb->ctl) {
  		ret = -ENOMEM;
  		goto err_unlock;
  	}
  
  	/*
  	 * tb_schedule_hotplug_handler may be called as soon as the config
  	 * channel is started. Thats why we have to hold the lock here.
  	 */
  	tb_ctl_start(tb->ctl);
  
  	if (tb->cm_ops->driver_ready) {
  		ret = tb->cm_ops->driver_ready(tb);
  		if (ret)
  			goto err_ctl_stop;
  	}
  
  	ret = device_add(&tb->dev);
  	if (ret)
  		goto err_ctl_stop;
  
  	/* Start the domain */
  	if (tb->cm_ops->start) {
  		ret = tb->cm_ops->start(tb);
  		if (ret)
  			goto err_domain_del;
  	}
  
  	/* This starts event processing */
  	mutex_unlock(&tb->lock);
  
  	pm_runtime_no_callbacks(&tb->dev);
  	pm_runtime_set_active(&tb->dev);
  	pm_runtime_enable(&tb->dev);
  	pm_runtime_set_autosuspend_delay(&tb->dev, TB_AUTOSUSPEND_DELAY);
  	pm_runtime_mark_last_busy(&tb->dev);
  	pm_runtime_use_autosuspend(&tb->dev);
  
  	return 0;
  
  err_domain_del:
  	device_del(&tb->dev);
  err_ctl_stop:
  	tb_ctl_stop(tb->ctl);
  err_unlock:
  	mutex_unlock(&tb->lock);
  
  	return ret;
  }
  
  /**
   * tb_domain_remove() - Removes and releases a domain
   * @tb: Domain to remove
   *
   * Stops the domain, removes it from the system and releases all
   * resources once the last reference has been released.
   */
  void tb_domain_remove(struct tb *tb)
  {
  	mutex_lock(&tb->lock);
  	if (tb->cm_ops->stop)
  		tb->cm_ops->stop(tb);
  	/* Stop the domain control traffic */
  	tb_ctl_stop(tb->ctl);
  	mutex_unlock(&tb->lock);
  
  	flush_workqueue(tb->wq);
  	device_unregister(&tb->dev);
  }
  
  /**
   * tb_domain_suspend_noirq() - Suspend a domain
   * @tb: Domain to suspend
   *
   * Suspends all devices in the domain and stops the control channel.
   */
  int tb_domain_suspend_noirq(struct tb *tb)
  {
  	int ret = 0;
  
  	/*
  	 * The control channel interrupt is left enabled during suspend
  	 * and taking the lock here prevents any events happening before
  	 * we actually have stopped the domain and the control channel.
  	 */
  	mutex_lock(&tb->lock);
  	if (tb->cm_ops->suspend_noirq)
  		ret = tb->cm_ops->suspend_noirq(tb);
  	if (!ret)
  		tb_ctl_stop(tb->ctl);
  	mutex_unlock(&tb->lock);
  
  	return ret;
  }
  
  /**
   * tb_domain_resume_noirq() - Resume a domain
   * @tb: Domain to resume
   *
   * Re-starts the control channel, and resumes all devices connected to
   * the domain.
   */
  int tb_domain_resume_noirq(struct tb *tb)
  {
  	int ret = 0;
  
  	mutex_lock(&tb->lock);
  	tb_ctl_start(tb->ctl);
  	if (tb->cm_ops->resume_noirq)
  		ret = tb->cm_ops->resume_noirq(tb);
  	mutex_unlock(&tb->lock);
  
  	return ret;
  }
  
  int tb_domain_suspend(struct tb *tb)
  {
  	return tb->cm_ops->suspend ? tb->cm_ops->suspend(tb) : 0;
  }
  
  void tb_domain_complete(struct tb *tb)
  {
  	if (tb->cm_ops->complete)
  		tb->cm_ops->complete(tb);
  }
  
  int tb_domain_runtime_suspend(struct tb *tb)
  {
  	if (tb->cm_ops->runtime_suspend) {
  		int ret = tb->cm_ops->runtime_suspend(tb);
  		if (ret)
  			return ret;
  	}
  	tb_ctl_stop(tb->ctl);
  	return 0;
  }
  
  int tb_domain_runtime_resume(struct tb *tb)
  {
  	tb_ctl_start(tb->ctl);
  	if (tb->cm_ops->runtime_resume) {
  		int ret = tb->cm_ops->runtime_resume(tb);
  		if (ret)
  			return ret;
  	}
  	return 0;
  }
  
  /**
   * tb_domain_approve_switch() - Approve switch
   * @tb: Domain the switch belongs to
   * @sw: Switch to approve
   *
   * This will approve switch by connection manager specific means. In
   * case of success the connection manager will create tunnels for all
   * supported protocols.
   */
  int tb_domain_approve_switch(struct tb *tb, struct tb_switch *sw)
  {
  	struct tb_switch *parent_sw;
  
  	if (!tb->cm_ops->approve_switch)
  		return -EPERM;
  
  	/* The parent switch must be authorized before this one */
  	parent_sw = tb_to_switch(sw->dev.parent);
  	if (!parent_sw || !parent_sw->authorized)
  		return -EINVAL;
  
  	return tb->cm_ops->approve_switch(tb, sw);
  }
  
  /**
   * tb_domain_approve_switch_key() - Approve switch and add key
   * @tb: Domain the switch belongs to
   * @sw: Switch to approve
   *
   * For switches that support secure connect, this function first adds
   * key to the switch NVM using connection manager specific means. If
   * adding the key is successful, the switch is approved and connected.
   *
   * Return: %0 on success and negative errno in case of failure.
   */
  int tb_domain_approve_switch_key(struct tb *tb, struct tb_switch *sw)
  {
  	struct tb_switch *parent_sw;
  	int ret;
  
  	if (!tb->cm_ops->approve_switch || !tb->cm_ops->add_switch_key)
  		return -EPERM;
  
  	/* The parent switch must be authorized before this one */
  	parent_sw = tb_to_switch(sw->dev.parent);
  	if (!parent_sw || !parent_sw->authorized)
  		return -EINVAL;
  
  	ret = tb->cm_ops->add_switch_key(tb, sw);
  	if (ret)
  		return ret;
  
  	return tb->cm_ops->approve_switch(tb, sw);
  }
  
  /**
   * tb_domain_challenge_switch_key() - Challenge and approve switch
   * @tb: Domain the switch belongs to
   * @sw: Switch to approve
   *
   * For switches that support secure connect, this function generates
   * random challenge and sends it to the switch. The switch responds to
   * this and if the response matches our random challenge, the switch is
   * approved and connected.
   *
   * Return: %0 on success and negative errno in case of failure.
   */
  int tb_domain_challenge_switch_key(struct tb *tb, struct tb_switch *sw)
  {
  	u8 challenge[TB_SWITCH_KEY_SIZE];
  	u8 response[TB_SWITCH_KEY_SIZE];
  	u8 hmac[TB_SWITCH_KEY_SIZE];
  	struct tb_switch *parent_sw;
  	struct crypto_shash *tfm;
  	struct shash_desc *shash;
  	int ret;
  
  	if (!tb->cm_ops->approve_switch || !tb->cm_ops->challenge_switch_key)
  		return -EPERM;
  
  	/* The parent switch must be authorized before this one */
  	parent_sw = tb_to_switch(sw->dev.parent);
  	if (!parent_sw || !parent_sw->authorized)
  		return -EINVAL;
  
  	get_random_bytes(challenge, sizeof(challenge));
  	ret = tb->cm_ops->challenge_switch_key(tb, sw, challenge, response);
  	if (ret)
  		return ret;
  
  	tfm = crypto_alloc_shash("hmac(sha256)", 0, 0);
  	if (IS_ERR(tfm))
  		return PTR_ERR(tfm);
  
  	ret = crypto_shash_setkey(tfm, sw->key, TB_SWITCH_KEY_SIZE);
  	if (ret)
  		goto err_free_tfm;
  
  	shash = kzalloc(sizeof(*shash) + crypto_shash_descsize(tfm),
  			GFP_KERNEL);
  	if (!shash) {
  		ret = -ENOMEM;
  		goto err_free_tfm;
  	}
  
  	shash->tfm = tfm;
  
  	memset(hmac, 0, sizeof(hmac));
  	ret = crypto_shash_digest(shash, challenge, sizeof(hmac), hmac);
  	if (ret)
  		goto err_free_shash;
  
  	/* The returned HMAC must match the one we calculated */
  	if (memcmp(response, hmac, sizeof(hmac))) {
  		ret = -EKEYREJECTED;
  		goto err_free_shash;
  	}
  
  	crypto_free_shash(tfm);
  	kfree(shash);
  
  	return tb->cm_ops->approve_switch(tb, sw);
  
  err_free_shash:
  	kfree(shash);
  err_free_tfm:
  	crypto_free_shash(tfm);
  
  	return ret;
  }
  
  /**
   * tb_domain_disconnect_pcie_paths() - Disconnect all PCIe paths
   * @tb: Domain whose PCIe paths to disconnect
   *
   * This needs to be called in preparation for NVM upgrade of the host
   * controller. Makes sure all PCIe paths are disconnected.
   *
   * Return %0 on success and negative errno in case of error.
   */
  int tb_domain_disconnect_pcie_paths(struct tb *tb)
  {
  	if (!tb->cm_ops->disconnect_pcie_paths)
  		return -EPERM;
  
  	return tb->cm_ops->disconnect_pcie_paths(tb);
  }
  
  /**
   * tb_domain_approve_xdomain_paths() - Enable DMA paths for XDomain
   * @tb: Domain enabling the DMA paths
   * @xd: XDomain DMA paths are created to
   *
   * Calls connection manager specific method to enable DMA paths to the
   * XDomain in question.
   *
   * Return: 0% in case of success and negative errno otherwise. In
   * particular returns %-ENOTSUPP if the connection manager
   * implementation does not support XDomains.
   */
  int tb_domain_approve_xdomain_paths(struct tb *tb, struct tb_xdomain *xd)
  {
  	if (!tb->cm_ops->approve_xdomain_paths)
  		return -ENOTSUPP;
  
  	return tb->cm_ops->approve_xdomain_paths(tb, xd);
  }
  
  /**
   * tb_domain_disconnect_xdomain_paths() - Disable DMA paths for XDomain
   * @tb: Domain disabling the DMA paths
   * @xd: XDomain whose DMA paths are disconnected
   *
   * Calls connection manager specific method to disconnect DMA paths to
   * the XDomain in question.
   *
   * Return: 0% in case of success and negative errno otherwise. In
   * particular returns %-ENOTSUPP if the connection manager
   * implementation does not support XDomains.
   */
  int tb_domain_disconnect_xdomain_paths(struct tb *tb, struct tb_xdomain *xd)
  {
  	if (!tb->cm_ops->disconnect_xdomain_paths)
  		return -ENOTSUPP;
  
  	return tb->cm_ops->disconnect_xdomain_paths(tb, xd);
  }
  
  static int disconnect_xdomain(struct device *dev, void *data)
  {
  	struct tb_xdomain *xd;
  	struct tb *tb = data;
  	int ret = 0;
  
  	xd = tb_to_xdomain(dev);
  	if (xd && xd->tb == tb)
  		ret = tb_xdomain_disable_paths(xd);
  
  	return ret;
  }
  
  /**
   * tb_domain_disconnect_all_paths() - Disconnect all paths for the domain
   * @tb: Domain whose paths are disconnected
   *
   * This function can be used to disconnect all paths (PCIe, XDomain) for
   * example in preparation for host NVM firmware upgrade. After this is
   * called the paths cannot be established without resetting the switch.
   *
   * Return: %0 in case of success and negative errno otherwise.
   */
  int tb_domain_disconnect_all_paths(struct tb *tb)
  {
  	int ret;
  
  	ret = tb_domain_disconnect_pcie_paths(tb);
  	if (ret)
  		return ret;
  
  	return bus_for_each_dev(&tb_bus_type, NULL, tb, disconnect_xdomain);
  }
  
  int tb_domain_init(void)
  {
  	int ret;
  
  	ret = tb_xdomain_init();
  	if (ret)
  		return ret;
  	ret = bus_register(&tb_bus_type);
  	if (ret)
  		tb_xdomain_exit();
  
  	return ret;
  }
  
  void tb_domain_exit(void)
  {
  	bus_unregister(&tb_bus_type);
  	ida_destroy(&tb_domain_ida);
  	tb_switch_exit();
  	tb_xdomain_exit();
  }
  