Re: [PATCH 06/16] thunderbolt: Add support for XDomain discovery protocol

[Dan Williams]

On Mon, 2017-09-18 at 18:30 +0300, Mika Westerberg wrote:
> When two hosts are connected over a Thunderbolt cable, there is a
> protocol they can use to communicate capabilities supported by the
> host.
> The discovery protocol uses automatically configured control channel
> (ring 0) and is build on top of request/response transactions using
> special XDomain primitives provided by the Thunderbolt base protocol.
> 
> The capabilities consists of a root directory block of basic
> properties
> used for identification of the host, and then there can be zero or
> more
> directories each describing a Thunderbolt service and its
> capabilities.
> 
> Once both sides have discovered what is supported the two hosts can
> setup high-speed DMA paths and transfer data to the other side using
> whatever protocol was agreed based on the properties. The software
> protocol used to communicate which DMA paths to enable is service
> specific.
> 
> This patch adds support for the XDomain discovery protocol to the
> Thunderbolt bus. We model each remote host connection as a Linux
> XDomain
> device. For each Thunderbolt service found supported on the XDomain
> device, we create Linux Thunderbolt service device which Thunderbolt
> service drivers can then bind to based on the protocol identification
> information retrieved from the property directory describing the
> service.
> 
> This code is based on the work done by Amir Levy and Michael Jamet.
> 
> Signed-off-by: Michael Jamet <michael.jamet@xxxxxxxxx>
> Signed-off-by: Mika Westerberg <mika.westerberg@xxxxxxxxxxxxxxx>
> Reviewed-by: Yehezkel Bernat <yehezkel.bernat@xxxxxxxxx>
> ---
> ÂDocumentation/ABI/testing/sysfs-bus-thunderbolt |ÂÂÂ48 +
> Âdrivers/thunderbolt/MakefileÂÂÂÂÂÂÂÂÂÂÂÂÂÂÂÂÂÂÂÂ|ÂÂÂÂ2 +-
> Âdrivers/thunderbolt/ctl.cÂÂÂÂÂÂÂÂÂÂÂÂÂÂÂÂÂÂÂÂÂÂÂ|ÂÂÂ11 +-
> Âdrivers/thunderbolt/ctl.hÂÂÂÂÂÂÂÂÂÂÂÂÂÂÂÂÂÂÂÂÂÂÂ|ÂÂÂÂ2 +-
> Âdrivers/thunderbolt/domain.cÂÂÂÂÂÂÂÂÂÂÂÂÂÂÂÂÂÂÂÂ|ÂÂ197 ++-
> Âdrivers/thunderbolt/icm.cÂÂÂÂÂÂÂÂÂÂÂÂÂÂÂÂÂÂÂÂÂÂÂ|ÂÂ218 +++-
> Âdrivers/thunderbolt/nhi.hÂÂÂÂÂÂÂÂÂÂÂÂÂÂÂÂÂÂÂÂÂÂÂ|ÂÂÂÂ2 +
> Âdrivers/thunderbolt/switch.cÂÂÂÂÂÂÂÂÂÂÂÂÂÂÂÂÂÂÂÂ|ÂÂÂÂ7 +-
> Âdrivers/thunderbolt/tb.hÂÂÂÂÂÂÂÂÂÂÂÂÂÂÂÂÂÂÂÂÂÂÂÂ|ÂÂÂ39 +-
> Âdrivers/thunderbolt/tb_msgs.hÂÂÂÂÂÂÂÂÂÂÂÂÂÂÂÂÂÂÂ|ÂÂ123 ++
> Âdrivers/thunderbolt/xdomain.cÂÂÂÂÂÂÂÂÂÂÂÂÂÂÂÂÂÂÂ| 1576
> +++++++++++++++++++++++
> Âinclude/linux/mod_devicetable.hÂÂÂÂÂÂÂÂÂÂÂÂÂÂÂÂÂ|ÂÂÂ26 +
> Âinclude/linux/thunderbolt.hÂÂÂÂÂÂÂÂÂÂÂÂÂÂÂÂÂÂÂÂÂ|ÂÂ242 ++++
> Âscripts/mod/devicetable-offsets.cÂÂÂÂÂÂÂÂÂÂÂÂÂÂÂ|ÂÂÂÂ7 +
> Âscripts/mod/file2alias.cÂÂÂÂÂÂÂÂÂÂÂÂÂÂÂÂÂÂÂÂÂÂÂÂ|ÂÂÂ25 +
> Â15 files changed, 2507 insertions(+), 18 deletions(-)
> Âcreate mode 100644 drivers/thunderbolt/xdomain.c
> 
> diff --git a/Documentation/ABI/testing/sysfs-bus-thunderbolt
> b/Documentation/ABI/testing/sysfs-bus-thunderbolt
> index 392bef5bd399..cb48850bd79b 100644
> --- a/Documentation/ABI/testing/sysfs-bus-thunderbolt
> +++ b/Documentation/ABI/testing/sysfs-bus-thunderbolt
> @@ -110,3 +110,51 @@ Description:	When new NVM image is
> written to the non-active NVM
> Â		is directly the status value from the DMA
> configuration
> Â		based mailbox before the device is power cycled.
> Writing
> Â		0 here clears the status.
> +
> +What:		/sys/bus/thunderbolt/devices/<xdomain>.<service
> >/key
> +Date:		Dec 2017
> +KernelVersion:	4.14
> +Contact:	thunderbolt-software@xxxxxxxxxxxx
> +Description:	This contains name of the property directory the
> XDomain
> +		service exposes. This entry describes the protocol
> in
> +		question. Following directories are already reserved
> by
> +		the Apple XDomain specification:
> +
> +		network:ÂÂIP/ethernet over Thunderbolt
> +		targetdm: Target disk mode protocol over Thunderbolt
> +		extdisp:ÂÂExternal display mode protocol over
> Thunderbolt
> +
> +What:		/sys/bus/thunderbolt/devices/<xdomain>.<service
> >/modalias
> +Date:		Dec 2017
> +KernelVersion:	4.14
> +Contact:	thunderbolt-software@xxxxxxxxxxxx
> +Description:	Stores the same MODALIAS value emitted by uevent
> for
> +		the XDomain service. Format: tbtsvc:kSpNvNrN
> +
> +What:		/sys/bus/thunderbolt/devices/<xdomain>.<service
> >/prtcid
> +Date:		Dec 2017
> +KernelVersion:	4.14
> +Contact:	thunderbolt-software@xxxxxxxxxxxx
> +Description:	This contains XDomain protocol identifier the
> XDomain
> +		service supports.
> +
> +What:		/sys/bus/thunderbolt/devices/<xdomain>.<service
> >/prtcvers
> +Date:		Dec 2017
> +KernelVersion:	4.14
> +Contact:	thunderbolt-software@xxxxxxxxxxxx
> +Description:	This contains XDomain protocol version the
> XDomain
> +		service supports.
> +
> +What:		/sys/bus/thunderbolt/devices/<xdomain>.<service
> >/prtcrevs
> +Date:		Dec 2017
> +KernelVersion:	4.14
> +Contact:	thunderbolt-software@xxxxxxxxxxxx
> +Description:	This contains XDomain software version the
> XDomain
> +		service supports.
> +
> +What:		/sys/bus/thunderbolt/devices/<xdomain>.<service
> >/prtcstns
> +Date:		Dec 2017
> +KernelVersion:	4.14
> +Contact:	thunderbolt-software@xxxxxxxxxxxx
> +Description:	This contains XDomain service specific settings
> as
> +		bitmask. Format: %x
> diff --git a/drivers/thunderbolt/Makefile
> b/drivers/thunderbolt/Makefile
> index 7afd21f5383a..f2f0de27252b 100644
> --- a/drivers/thunderbolt/Makefile
> +++ b/drivers/thunderbolt/Makefile
> @@ -1,3 +1,3 @@
> Âobj-${CONFIG_THUNDERBOLT} := thunderbolt.o
> Âthunderbolt-objs := nhi.o ctl.o tb.o switch.o cap.o path.o
> tunnel_pci.o eeprom.o
> -thunderbolt-objs += domain.o dma_port.o icm.o property.o
> +thunderbolt-objs += domain.o dma_port.o icm.o property.o xdomain.o
> diff --git a/drivers/thunderbolt/ctl.c b/drivers/thunderbolt/ctl.c
> index e6a4c9458c76..46e393c5fd1d 100644
> --- a/drivers/thunderbolt/ctl.c
> +++ b/drivers/thunderbolt/ctl.c
> @@ -368,10 +368,10 @@ static int tb_ctl_tx(struct tb_ctl *ctl, const
> void *data, size_t len,
> Â/**
> Â * tb_ctl_handle_event() - acknowledge a plug event, invoke ctl-
> >callback
> Â */
> -static void tb_ctl_handle_event(struct tb_ctl *ctl, enum
> tb_cfg_pkg_type type,
> +static bool tb_ctl_handle_event(struct tb_ctl *ctl, enum
> tb_cfg_pkg_type type,
> Â				struct ctl_pkg *pkg, size_t size)
> Â{
> -	ctl->callback(ctl->callback_data, type, pkg->buffer, size);
> +	return ctl->callback(ctl->callback_data, type, pkg->buffer,
> size);
> Â}
> Â
> Âstatic void tb_ctl_rx_submit(struct ctl_pkg *pkg)
> @@ -444,6 +444,8 @@ static void tb_ctl_rx_callback(struct tb_ring
> *ring, struct ring_frame *frame,
> Â		break;
> Â
> Â	case TB_CFG_PKG_EVENT:
> +	case TB_CFG_PKG_XDOMAIN_RESP:
> +	case TB_CFG_PKG_XDOMAIN_REQ:
> Â		if (*(__be32 *)(pkg->buffer + frame->size) != crc32)
> {
> Â			tb_ctl_err(pkg->ctl,
> Â				ÂÂÂ"RX: checksum mismatch, dropping
> packet\n");
> @@ -451,8 +453,9 @@ static void tb_ctl_rx_callback(struct tb_ring
> *ring, struct ring_frame *frame,
> Â		}
> Â		/* Fall through */
> Â	case TB_CFG_PKG_ICM_EVENT:
> -		tb_ctl_handle_event(pkg->ctl, frame->eof, pkg,
> frame->size);
> -		goto rx;
> +		if (tb_ctl_handle_event(pkg->ctl, frame->eof, pkg,
> frame->size))
> +			goto rx;
> +		break;
> Â
> Â	default:
> Â		break;
> diff --git a/drivers/thunderbolt/ctl.h b/drivers/thunderbolt/ctl.h
> index d0f21e1e0b8b..85c49dd301ea 100644
> --- a/drivers/thunderbolt/ctl.h
> +++ b/drivers/thunderbolt/ctl.h
> @@ -16,7 +16,7 @@
> Â/* control channel */
> Âstruct tb_ctl;
> Â
> -typedef void (*event_cb)(void *data, enum tb_cfg_pkg_type type,
> +typedef bool (*event_cb)(void *data, enum tb_cfg_pkg_type type,
> Â			Âconst void *buf, size_t size);
> Â
> Âstruct tb_ctl *tb_ctl_alloc(struct tb_nhi *nhi, event_cb cb, void
> *cb_data);
> diff --git a/drivers/thunderbolt/domain.c
> b/drivers/thunderbolt/domain.c
> index 9f2dcd48974d..29d6436ec8ce 100644
> --- a/drivers/thunderbolt/domain.c
> +++ b/drivers/thunderbolt/domain.c
> @@ -20,6 +20,98 @@
> Â
> Â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);

Could you pass 'dev' to the probe function so that things like the
network sub-driver can sensibly link the netdev to the parent hardware
in sysfs with SET_NETDEV_DEV()?

Dan

> +}
> +
> +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",
> @@ -52,6 +144,10 @@ static const struct attribute_group
> *domain_attr_groups[] = {
> Â
> Â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)
> @@ -128,17 +224,26 @@ struct tb *tb_domain_alloc(struct tb_nhi *nhi,
> size_t privsize)
> Â	return NULL;
> Â}
> Â
> -static void tb_domain_event_cb(void *data, enum tb_cfg_pkg_type
> type,
> +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;
> +		return true;
> Â	}
> Â
> -	tb->cm_ops->handle_event(tb, type, buf, size);
> +	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;
> Â}
> Â
> Â/**
> @@ -443,9 +548,92 @@ int tb_domain_disconnect_pcie_paths(struct tb
> *tb)
> Â	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 reseting 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)
> Â{
> -	return bus_register(&tb_bus_type);
> +	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)
> @@ -453,4 +641,5 @@ void tb_domain_exit(void)
> Â	bus_unregister(&tb_bus_type);
> Â	ida_destroy(&tb_domain_ida);
> Â	tb_switch_exit();
> +	tb_xdomain_exit();
> Â}
> diff --git a/drivers/thunderbolt/icm.c b/drivers/thunderbolt/icm.c
> index 8c22b91ed040..ab02d13f40b7 100644
> --- a/drivers/thunderbolt/icm.c
> +++ b/drivers/thunderbolt/icm.c
> @@ -60,6 +60,8 @@
> Â * @get_route: Find a route string for given switch
> Â * @device_connected: Handle device connected ICM message
> Â * @device_disconnected: Handle device disconnected ICM message
> + * @xdomain_connected - Handle XDomain connected ICM message
> + * @xdomain_disconnected - Handle XDomain disconnected ICM message
> Â */
> Âstruct icm {
> Â	struct mutex request_lock;
> @@ -74,6 +76,10 @@ struct icm {
> Â				Âconst struct icm_pkg_header *hdr);
> Â	void (*device_disconnected)(struct tb *tb,
> Â				ÂÂÂÂconst struct icm_pkg_header
> *hdr);
> +	void (*xdomain_connected)(struct tb *tb,
> +				ÂÂconst struct icm_pkg_header *hdr);
> +	void (*xdomain_disconnected)(struct tb *tb,
> +				ÂÂÂÂÂconst struct icm_pkg_header
> *hdr);
> Â};
> Â
> Âstruct icm_notification {
> @@ -89,7 +95,10 @@ static inline struct tb *icm_to_tb(struct icm
> *icm)
> Â
> Âstatic inline u8 phy_port_from_route(u64 route, u8 depth)
> Â{
> -	return tb_phy_port_from_link(route >> ((depth - 1) * 8));
> +	u8 link;
> +
> +	link = depth ? route >> ((depth - 1) * 8) : route;
> +	return tb_phy_port_from_link(link);
> Â}
> Â
> Âstatic inline u8 dual_link_from_link(u8 link)
> @@ -320,6 +329,51 @@ static int icm_fr_challenge_switch_key(struct tb
> *tb, struct tb_switch *sw,
> Â	return 0;
> Â}
> Â
> +static int icm_fr_approve_xdomain_paths(struct tb *tb, struct
> tb_xdomain *xd)
> +{
> +	struct icm_fr_pkg_approve_xdomain_response reply;
> +	struct icm_fr_pkg_approve_xdomain request;
> +	int ret;
> +
> +	memset(&request, 0, sizeof(request));
> +	request.hdr.code = ICM_APPROVE_XDOMAIN;
> +	request.link_info = xd->depth << ICM_LINK_INFO_DEPTH_SHIFT |
> xd->link;
> +	memcpy(&request.remote_uuid, xd->remote_uuid, sizeof(*xd-
> >remote_uuid));
> +
> +	request.transmit_path = xd->transmit_path;
> +	request.transmit_ring = xd->transmit_ring;
> +	request.receive_path = xd->receive_path;
> +	request.receive_ring = xd->receive_ring;
> +
> +	memset(&reply, 0, sizeof(reply));
> +	ret = icm_request(tb, &request, sizeof(request), &reply,
> sizeof(reply),
> +			ÂÂ1, ICM_TIMEOUT);
> +	if (ret)
> +		return ret;
> +
> +	if (reply.hdr.flags & ICM_FLAGS_ERROR)
> +		return -EIO;
> +
> +	return 0;
> +}
> +
> +static int icm_fr_disconnect_xdomain_paths(struct tb *tb, struct
> tb_xdomain *xd)
> +{
> +	u8 phy_port;
> +	u8 cmd;
> +
> +	phy_port = tb_phy_port_from_link(xd->link);
> +	if (phy_port == 0)
> +		cmd = NHI_MAILBOX_DISCONNECT_PA;
> +	else
> +		cmd = NHI_MAILBOX_DISCONNECT_PB;
> +
> +	nhi_mailbox_cmd(tb->nhi, cmd, 1);
> +	usleep_range(10, 50);
> +	nhi_mailbox_cmd(tb->nhi, cmd, 2);
> +	return 0;
> +}
> +
> Âstatic void remove_switch(struct tb_switch *sw)
> Â{
> Â	struct tb_switch *parent_sw;
> @@ -475,6 +529,141 @@ icm_fr_device_disconnected(struct tb *tb, const
> struct icm_pkg_header *hdr)
> Â	tb_switch_put(sw);
> Â}
> Â
> +static void remove_xdomain(struct tb_xdomain *xd)
> +{
> +	struct tb_switch *sw;
> +
> +	sw = tb_to_switch(xd->dev.parent);
> +	tb_port_at(xd->route, sw)->xdomain = NULL;
> +	tb_xdomain_remove(xd);
> +}
> +
> +static void
> +icm_fr_xdomain_connected(struct tb *tb, const struct icm_pkg_header
> *hdr)
> +{
> +	const struct icm_fr_event_xdomain_connected *pkg =
> +		(const struct icm_fr_event_xdomain_connected *)hdr;
> +	struct tb_xdomain *xd;
> +	struct tb_switch *sw;
> +	u8 link, depth;
> +	bool approved;
> +	u64 route;
> +
> +	/*
> +	Â* After NVM upgrade adding root switch device fails because
> we
> +	Â* initiated reset. During that time ICM might still send
> +	Â* XDomain connected message which we ignore here.
> +	Â*/
> +	if (!tb->root_switch)
> +		return;
> +
> +	link = pkg->link_info & ICM_LINK_INFO_LINK_MASK;
> +	depth = (pkg->link_info & ICM_LINK_INFO_DEPTH_MASK) >>
> +		ICM_LINK_INFO_DEPTH_SHIFT;
> +	approved = pkg->link_info & ICM_LINK_INFO_APPROVED;
> +
> +	if (link > ICM_MAX_LINK || depth > ICM_MAX_DEPTH) {
> +		tb_warn(tb, "invalid topology %u.%u, ignoring\n",
> link, depth);
> +		return;
> +	}
> +
> +	route = get_route(pkg->local_route_hi, pkg->local_route_lo);
> +
> +	xd = tb_xdomain_find_by_uuid(tb, &pkg->remote_uuid);
> +	if (xd) {
> +		u8 xd_phy_port, phy_port;
> +
> +		xd_phy_port = phy_port_from_route(xd->route, xd-
> >depth);
> +		phy_port = phy_port_from_route(route, depth);
> +
> +		if (xd->depth == depth && xd_phy_port == phy_port) {
> +			xd->link = link;
> +			xd->route = route;
> +			xd->is_unplugged = false;
> +			tb_xdomain_put(xd);
> +			return;
> +		}
> +
> +		/*
> +		Â* If we find an existing XDomain connection remove
> it
> +		Â* now. We need to go through login handshake and
> +		Â* everything anyway to be able to re-establish the
> +		Â* connection.
> +		Â*/
> +		remove_xdomain(xd);
> +		tb_xdomain_put(xd);
> +	}
> +
> +	/*
> +	Â* Look if there already exists an XDomain in the same place
> +	Â* than the new one and in that case remove it because it is
> +	Â* most likely another host that got disconnected.
> +	Â*/
> +	xd = tb_xdomain_find_by_link_depth(tb, link, depth);
> +	if (!xd) {
> +		u8 dual_link;
> +
> +		dual_link = dual_link_from_link(link);
> +		if (dual_link)
> +			xd = tb_xdomain_find_by_link_depth(tb,
> dual_link,
> +							ÂÂÂdepth);
> +	}
> +	if (xd) {
> +		remove_xdomain(xd);
> +		tb_xdomain_put(xd);
> +	}
> +
> +	/*
> +	Â* If the user disconnected a switch during suspend and
> +	Â* connected another host to the same port, remove the
> switch
> +	Â* first.
> +	Â*/
> +	sw = get_switch_at_route(tb->root_switch, route);
> +	if (sw)
> +		remove_switch(sw);
> +
> +	sw = tb_switch_find_by_link_depth(tb, link, depth);
> +	if (!sw) {
> +		tb_warn(tb, "no switch exists at %u.%u, ignoring\n",
> link,
> +			depth);
> +		return;
> +	}
> +
> +	xd = tb_xdomain_alloc(sw->tb, &sw->dev, route,
> +			ÂÂÂÂÂÂ&pkg->local_uuid, &pkg->remote_uuid);
> +	if (!xd) {
> +		tb_switch_put(sw);
> +		return;
> +	}
> +
> +	xd->link = link;
> +	xd->depth = depth;
> +
> +	tb_port_at(route, sw)->xdomain = xd;
> +
> +	tb_xdomain_add(xd);
> +	tb_switch_put(sw);
> +}
> +
> +static void
> +icm_fr_xdomain_disconnected(struct tb *tb, const struct
> icm_pkg_header *hdr)
> +{
> +	const struct icm_fr_event_xdomain_disconnected *pkg =
> +		(const struct icm_fr_event_xdomain_disconnected
> *)hdr;
> +	struct tb_xdomain *xd;
> +
> +	/*
> +	Â* If the connection is through one or multiple devices, the
> +	Â* XDomain device is removed along with them so it is fine
> if we
> +	Â* cannot find it here.
> +	Â*/
> +	xd = tb_xdomain_find_by_uuid(tb, &pkg->remote_uuid);
> +	if (xd) {
> +		remove_xdomain(xd);
> +		tb_xdomain_put(xd);
> +	}
> +}
> +
> Âstatic struct pci_dev *get_upstream_port(struct pci_dev *pdev)
> Â{
> Â	struct pci_dev *parent;
> @@ -594,6 +783,12 @@ static void icm_handle_notification(struct
> work_struct *work)
> Â	case ICM_EVENT_DEVICE_DISCONNECTED:
> Â		icm->device_disconnected(tb, n->pkg);
> Â		break;
> +	case ICM_EVENT_XDOMAIN_CONNECTED:
> +		icm->xdomain_connected(tb, n->pkg);
> +		break;
> +	case ICM_EVENT_XDOMAIN_DISCONNECTED:
> +		icm->xdomain_disconnected(tb, n->pkg);
> +		break;
> Â	}
> Â
> Â	mutex_unlock(&tb->lock);
> @@ -927,6 +1122,10 @@ static void icm_unplug_children(struct
> tb_switch *sw)
> Â
> Â		if (tb_is_upstream_port(port))
> Â			continue;
> +		if (port->xdomain) {
> +			port->xdomain->is_unplugged = true;
> +			continue;
> +		}
> Â		if (!port->remote)
> Â			continue;
> Â
> @@ -943,6 +1142,13 @@ static void icm_free_unplugged_children(struct
> tb_switch *sw)
> Â
> Â		if (tb_is_upstream_port(port))
> Â			continue;
> +
> +		if (port->xdomain && port->xdomain->is_unplugged) {
> +			tb_xdomain_remove(port->xdomain);
> +			port->xdomain = NULL;
> +			continue;
> +		}
> +
> Â		if (!port->remote)
> Â			continue;
> Â
> @@ -1009,8 +1215,10 @@ static int icm_start(struct tb *tb)
> Â	tb->root_switch->no_nvm_upgrade = x86_apple_machine;
> Â
> Â	ret = tb_switch_add(tb->root_switch);
> -	if (ret)
> +	if (ret) {
> Â		tb_switch_put(tb->root_switch);
> +		tb->root_switch = NULL;
> +	}
> Â
> Â	return ret;
> Â}
> @@ -1042,6 +1250,8 @@ static const struct tb_cm_ops icm_fr_ops = {
> Â	.add_switch_key = icm_fr_add_switch_key,
> Â	.challenge_switch_key = icm_fr_challenge_switch_key,
> Â	.disconnect_pcie_paths = icm_disconnect_pcie_paths,
> +	.approve_xdomain_paths = icm_fr_approve_xdomain_paths,
> +	.disconnect_xdomain_paths = icm_fr_disconnect_xdomain_paths,
> Â};
> Â
> Âstruct tb *icm_probe(struct tb_nhi *nhi)
> @@ -1064,6 +1274,8 @@ struct tb *icm_probe(struct tb_nhi *nhi)
> Â		icm->get_route = icm_fr_get_route;
> Â		icm->device_connected = icm_fr_device_connected;
> Â		icm->device_disconnected =
> icm_fr_device_disconnected;
> +		icm->xdomain_connected = icm_fr_xdomain_connected;
> +		icm->xdomain_disconnected =
> icm_fr_xdomain_disconnected;
> Â		tb->cm_ops = &icm_fr_ops;
> Â		break;
> Â
> @@ -1077,6 +1289,8 @@ struct tb *icm_probe(struct tb_nhi *nhi)
> Â		icm->get_route = icm_ar_get_route;
> Â		icm->device_connected = icm_fr_device_connected;
> Â		icm->device_disconnected =
> icm_fr_device_disconnected;
> +		icm->xdomain_connected = icm_fr_xdomain_connected;
> +		icm->xdomain_disconnected =
> icm_fr_xdomain_disconnected;
> Â		tb->cm_ops = &icm_fr_ops;
> Â		break;
> Â	}
> diff --git a/drivers/thunderbolt/nhi.h b/drivers/thunderbolt/nhi.h
> index 5b5bb2c436be..0e05828983db 100644
> --- a/drivers/thunderbolt/nhi.h
> +++ b/drivers/thunderbolt/nhi.h
> @@ -157,6 +157,8 @@ enum nhi_mailbox_cmd {
> Â	NHI_MAILBOX_SAVE_DEVS = 0x05,
> Â	NHI_MAILBOX_DISCONNECT_PCIE_PATHS = 0x06,
> Â	NHI_MAILBOX_DRV_UNLOADS = 0x07,
> +	NHI_MAILBOX_DISCONNECT_PA = 0x10,
> +	NHI_MAILBOX_DISCONNECT_PB = 0x11,
> Â	NHI_MAILBOX_ALLOW_ALL_DEVS = 0x23,
> Â};
> Â
> diff --git a/drivers/thunderbolt/switch.c
> b/drivers/thunderbolt/switch.c
> index 53f40c57df59..dfc357d33e1e 100644
> --- a/drivers/thunderbolt/switch.c
> +++ b/drivers/thunderbolt/switch.c
> @@ -171,11 +171,11 @@ static int nvm_authenticate_host(struct
> tb_switch *sw)
> Â
> Â	/*
> Â	Â* Root switch NVM upgrade requires that we disconnect the
> -	Â* existing PCIe paths first (in case it is not in safe mode
> +	Â* existing paths first (in case it is not in safe mode
> Â	Â* already).
> Â	Â*/
> Â	if (!sw->safe_mode) {
> -		ret = tb_domain_disconnect_pcie_paths(sw->tb);
> +		ret = tb_domain_disconnect_all_paths(sw->tb);
> Â		if (ret)
> Â			return ret;
> Â		/*
> @@ -1363,6 +1363,9 @@ void tb_switch_remove(struct tb_switch *sw)
> Â		if (sw->ports[i].remote)
> Â			tb_switch_remove(sw->ports[i].remote->sw);
> Â		sw->ports[i].remote = NULL;
> +		if (sw->ports[i].xdomain)
> +			tb_xdomain_remove(sw->ports[i].xdomain);
> +		sw->ports[i].xdomain = NULL;
> Â	}
> Â
> Â	if (!sw->is_unplugged)
> diff --git a/drivers/thunderbolt/tb.h b/drivers/thunderbolt/tb.h
> index ea21d927bd09..74af9d4929ab 100644
> --- a/drivers/thunderbolt/tb.h
> +++ b/drivers/thunderbolt/tb.h
> @@ -9,6 +9,7 @@
> Â
> Â#include <linux/nvmem-provider.h>
> Â#include <linux/pci.h>
> +#include <linux/thunderbolt.h>
> Â#include <linux/uuid.h>
> Â
> Â#include "tb_regs.h"
> @@ -109,14 +110,25 @@ struct tb_switch {
> Â
> Â/**
> Â * struct tb_port - a thunderbolt port, part of a tb_switch
> + * @config: Cached port configuration read from registers
> + * @sw: Switch the port belongs to
> + * @remote: Remote port (%NULL if not connected)
> + * @xdomain: Remote host (%NULL if not connected)
> + * @cap_phy: Offset, zero if not found
> + * @port: Port number on switch
> + * @disabled: Disabled by eeprom
> + * @dual_link_port: If the switch is connected using two ports,
> points
> + *		ÂÂÂÂto the other port.
> + * @link_nr: Is this primary or secondary port on the dual_link.
> Â */
> Âstruct tb_port {
> Â	struct tb_regs_port_header config;
> Â	struct tb_switch *sw;
> -	struct tb_port *remote; /* remote port, NULL if not
> connected */
> -	int cap_phy; /* offset, zero if not found */
> -	u8 port; /* port number on switch */
> -	bool disabled; /* disabled by eeprom */
> +	struct tb_port *remote;
> +	struct tb_xdomain *xdomain;
> +	int cap_phy;
> +	u8 port;
> +	bool disabled;
> Â	struct tb_port *dual_link_port;
> Â	u8 link_nr:1;
> Â};
> @@ -189,6 +201,8 @@ struct tb_path {
> Â * @add_switch_key: Add key to switch
> Â * @challenge_switch_key: Challenge switch using key
> Â * @disconnect_pcie_paths: Disconnects PCIe paths before NVM update
> + * @approve_xdomain_paths: Approve (establish) XDomain DMA paths
> + * @disconnect_xdomain_paths: Disconnect XDomain DMA paths
> Â */
> Âstruct tb_cm_ops {
> Â	int (*driver_ready)(struct tb *tb);
> @@ -205,6 +219,8 @@ struct tb_cm_ops {
> Â	int (*challenge_switch_key)(struct tb *tb, struct tb_switch
> *sw,
> Â				ÂÂÂÂconst u8 *challenge, u8
> *response);
> Â	int (*disconnect_pcie_paths)(struct tb *tb);
> +	int (*approve_xdomain_paths)(struct tb *tb, struct
> tb_xdomain *xd);
> +	int (*disconnect_xdomain_paths)(struct tb *tb, struct
> tb_xdomain *xd);
> Â};
> Â
> Âstatic inline void *tb_priv(struct tb *tb)
> @@ -331,6 +347,8 @@ extern struct device_type tb_switch_type;
> Âint tb_domain_init(void);
> Âvoid tb_domain_exit(void);
> Âvoid tb_switch_exit(void);
> +int tb_xdomain_init(void);
> +void tb_xdomain_exit(void);
> Â
> Âstruct tb *tb_domain_alloc(struct tb_nhi *nhi, size_t privsize);
> Âint tb_domain_add(struct tb *tb);
> @@ -343,6 +361,9 @@ int tb_domain_approve_switch(struct tb *tb,
> struct tb_switch *sw);
> Âint tb_domain_approve_switch_key(struct tb *tb, struct tb_switch
> *sw);
> Âint tb_domain_challenge_switch_key(struct tb *tb, struct tb_switch
> *sw);
> Âint tb_domain_disconnect_pcie_paths(struct tb *tb);
> +int tb_domain_approve_xdomain_paths(struct tb *tb, struct tb_xdomain
> *xd);
> +int tb_domain_disconnect_xdomain_paths(struct tb *tb, struct
> tb_xdomain *xd);
> +int tb_domain_disconnect_all_paths(struct tb *tb);
> Â
> Âstatic inline void tb_domain_put(struct tb *tb)
> Â{
> @@ -422,4 +443,14 @@ static inline u64 tb_downstream_route(struct
> tb_port *port)
> Â	ÂÂÂÂÂÂÂ| ((u64) port->port << (port->sw->config.depth * 8));
> Â}
> Â
> +bool tb_xdomain_handle_request(struct tb *tb, enum tb_cfg_pkg_type
> type,
> +			ÂÂÂÂÂÂÂconst void *buf, size_t size);
> +struct tb_xdomain *tb_xdomain_alloc(struct tb *tb, struct device
> *parent,
> +				ÂÂÂÂu64 route, const uuid_t
> *local_uuid,
> +				ÂÂÂÂconst uuid_t *remote_uuid);
> +void tb_xdomain_add(struct tb_xdomain *xd);
> +void tb_xdomain_remove(struct tb_xdomain *xd);
> +struct tb_xdomain *tb_xdomain_find_by_link_depth(struct tb *tb, u8
> link,
> +						Âu8 depth);
> +
> Â#endif
> diff --git a/drivers/thunderbolt/tb_msgs.h
> b/drivers/thunderbolt/tb_msgs.h
> index fe3039b05da6..2a76908537a6 100644
> --- a/drivers/thunderbolt/tb_msgs.h
> +++ b/drivers/thunderbolt/tb_msgs.h
> @@ -101,11 +101,14 @@ enum icm_pkg_code {
> Â	ICM_CHALLENGE_DEVICE = 0x5,
> Â	ICM_ADD_DEVICE_KEY = 0x6,
> Â	ICM_GET_ROUTE = 0xa,
> +	ICM_APPROVE_XDOMAIN = 0x10,
> Â};
> Â
> Âenum icm_event_code {
> Â	ICM_EVENT_DEVICE_CONNECTED = 3,
> Â	ICM_EVENT_DEVICE_DISCONNECTED = 4,
> +	ICM_EVENT_XDOMAIN_CONNECTED = 6,
> +	ICM_EVENT_XDOMAIN_DISCONNECTED = 7,
> Â};
> Â
> Âstruct icm_pkg_header {
> @@ -188,6 +191,25 @@ struct icm_fr_event_device_disconnected {
> Â	u16 link_info;
> Â} __packed;
> Â
> +struct icm_fr_event_xdomain_connected {
> +	struct icm_pkg_header hdr;
> +	u16 reserved;
> +	u16 link_info;
> +	uuid_t remote_uuid;
> +	uuid_t local_uuid;
> +	u32 local_route_hi;
> +	u32 local_route_lo;
> +	u32 remote_route_hi;
> +	u32 remote_route_lo;
> +} __packed;
> +
> +struct icm_fr_event_xdomain_disconnected {
> +	struct icm_pkg_header hdr;
> +	u16 reserved;
> +	u16 link_info;
> +	uuid_t remote_uuid;
> +} __packed;
> +
> Âstruct icm_fr_pkg_add_device_key {
> Â	struct icm_pkg_header hdr;
> Â	uuid_t ep_uuid;
> @@ -224,6 +246,28 @@ struct icm_fr_pkg_challenge_device_response {
> Â	u32 response[8];
> Â} __packed;
> Â
> +struct icm_fr_pkg_approve_xdomain {
> +	struct icm_pkg_header hdr;
> +	u16 reserved;
> +	u16 link_info;
> +	uuid_t remote_uuid;
> +	u16 transmit_path;
> +	u16 transmit_ring;
> +	u16 receive_path;
> +	u16 receive_ring;
> +} __packed;
> +
> +struct icm_fr_pkg_approve_xdomain_response {
> +	struct icm_pkg_header hdr;
> +	u16 reserved;
> +	u16 link_info;
> +	uuid_t remote_uuid;
> +	u16 transmit_path;
> +	u16 transmit_ring;
> +	u16 receive_path;
> +	u16 receive_ring;
> +} __packed;
> +
> Â/* Alpine Ridge only messages */
> Â
> Âstruct icm_ar_pkg_get_route {
> @@ -240,4 +284,83 @@ struct icm_ar_pkg_get_route_response {
> Â	u32 route_lo;
> Â} __packed;
> Â
> +/* XDomain messages */
> +
> +struct tb_xdomain_header {
> +	u32 route_hi;
> +	u32 route_lo;
> +	u32 length_sn;
> +} __packed;
> +
> +#define TB_XDOMAIN_LENGTH_MASK	GENMASK(5, 0)
> +#define TB_XDOMAIN_SN_MASK	GENMASK(28, 27)
> +#define TB_XDOMAIN_SN_SHIFT	27
> +
> +enum tb_xdp_type {
> +	UUID_REQUEST_OLD = 1,
> +	UUID_RESPONSE = 2,
> +	PROPERTIES_REQUEST,
> +	PROPERTIES_RESPONSE,
> +	PROPERTIES_CHANGED_REQUEST,
> +	PROPERTIES_CHANGED_RESPONSE,
> +	ERROR_RESPONSE,
> +	UUID_REQUEST = 12,
> +};
> +
> +struct tb_xdp_header {
> +	struct tb_xdomain_header xd_hdr;
> +	uuid_t uuid;
> +	u32 type;
> +} __packed;
> +
> +struct tb_xdp_properties {
> +	struct tb_xdp_header hdr;
> +	uuid_t src_uuid;
> +	uuid_t dst_uuid;
> +	u16 offset;
> +	u16 reserved;
> +} __packed;
> +
> +struct tb_xdp_properties_response {
> +	struct tb_xdp_header hdr;
> +	uuid_t src_uuid;
> +	uuid_t dst_uuid;
> +	u16 offset;
> +	u16 data_length;
> +	u32 generation;
> +	u32 data[0];
> +} __packed;
> +
> +/*
> + * Max length of data array single XDomain property response is
> allowed
> + * to carry.
> + */
> +#define TB_XDP_PROPERTIES_MAX_DATA_LENGTH	\
> +	(((256 - 4 - sizeof(struct tb_xdp_properties_response))) /
> 4)
> +
> +/* Maximum size of the total property block in dwords we allow */
> +#define TB_XDP_PROPERTIES_MAX_LENGTH		500
> +
> +struct tb_xdp_properties_changed {
> +	struct tb_xdp_header hdr;
> +	uuid_t src_uuid;
> +} __packed;
> +
> +struct tb_xdp_properties_changed_response {
> +	struct tb_xdp_header hdr;
> +} __packed;
> +
> +enum tb_xdp_error {
> +	ERROR_SUCCESS,
> +	ERROR_UNKNOWN_PACKET,
> +	ERROR_UNKNOWN_DOMAIN,
> +	ERROR_NOT_SUPPORTED,
> +	ERROR_NOT_READY,
> +};
> +
> +struct tb_xdp_error_response {
> +	struct tb_xdp_header hdr;
> +	u32 error;
> +} __packed;
> +
> Â#endif
> diff --git a/drivers/thunderbolt/xdomain.c
> b/drivers/thunderbolt/xdomain.c
> new file mode 100644
> index 000000000000..1b929be8fdd6
> --- /dev/null
> +++ b/drivers/thunderbolt/xdomain.c
> @@ -0,0 +1,1576 @@
> +/*
> + * Thunderbolt XDomain discovery protocol support
> + *
> + * Copyright (C) 2017, Intel Corporation
> + * Authors: Michael Jamet <michael.jamet@xxxxxxxxx>
> + *ÂÂÂÂÂÂÂÂÂÂMika Westerberg <mika.westerberg@xxxxxxxxxxxxxxx>
> + *
> + * This program is free software; you can redistribute it and/or
> modify
> + * it under the terms of the GNU General Public License version 2 as
> + * published by the Free Software Foundation.
> + */
> +
> +#include <linux/device.h>
> +#include <linux/kmod.h>
> +#include <linux/module.h>
> +#include <linux/utsname.h>
> +#include <linux/uuid.h>
> +#include <linux/workqueue.h>
> +
> +#include "tb.h"
> +
> +#define XDOMAIN_DEFAULT_TIMEOUT			5000 /* ms */
> +#define XDOMAIN_PROPERTIES_RETRIES		60
> +#define XDOMAIN_PROPERTIES_CHANGED_RETRIES	10
> +
> +struct xdomain_request_work {
> +	struct work_struct work;
> +	struct tb_xdp_header *pkg;
> +	struct tb *tb;
> +};
> +
> +/* Serializes access to the properties and protocol handlers below
> */
> +static DEFINE_MUTEX(xdomain_lock);
> +
> +/* Properties exposed to the remote domains */
> +static struct tb_property_dir *xdomain_property_dir;
> +static u32 *xdomain_property_block;
> +static u32 xdomain_property_block_len;
> +static u32 xdomain_property_block_gen;
> +
> +/* Additional protocol handlers */
> +static LIST_HEAD(protocol_handlers);
> +
> +/* UUID for XDomain discovery protocol */
> +static const uuid_t tb_xdp_uuid =
> +	UUID_INIT(0xb638d70e, 0x42ff, 0x40bb,
> +		ÂÂ0x97, 0xc2, 0x90, 0xe2, 0xc0, 0xb2, 0xff, 0x07);
> +
> +static bool tb_xdomain_match(const struct tb_cfg_request *req,
> +			ÂÂÂÂÂconst struct ctl_pkg *pkg)
> +{
> +	switch (pkg->frame.eof) {
> +	case TB_CFG_PKG_ERROR:
> +		return true;
> +
> +	case TB_CFG_PKG_XDOMAIN_RESP: {
> +		const struct tb_xdp_header *res_hdr = pkg->buffer;
> +		const struct tb_xdp_header *req_hdr = req->request;
> +		u8 req_seq, res_seq;
> +
> +		if (pkg->frame.size < req->response_size / 4)
> +			return false;
> +
> +		/* Make sure route matches */
> +		if ((res_hdr->xd_hdr.route_hi & ~BIT(31)) !=
> +		ÂÂÂÂÂreq_hdr->xd_hdr.route_hi)
> +			return false;
> +		if ((res_hdr->xd_hdr.route_lo) != req_hdr-
> >xd_hdr.route_lo)
> +			return false;
> +
> +		/* Then check that the sequence number matches */
> +		res_seq = res_hdr->xd_hdr.length_sn &
> TB_XDOMAIN_SN_MASK;
> +		res_seq >>= TB_XDOMAIN_SN_SHIFT;
> +		req_seq = req_hdr->xd_hdr.length_sn &
> TB_XDOMAIN_SN_MASK;
> +		req_seq >>= TB_XDOMAIN_SN_SHIFT;
> +		if (res_seq != req_seq)
> +			return false;
> +
> +		/* Check that the XDomain protocol matches */
> +		if (!uuid_equal(&res_hdr->uuid, &req_hdr->uuid))
> +			return false;
> +
> +		return true;
> +	}
> +
> +	default:
> +		return false;
> +	}
> +}
> +
> +static bool tb_xdomain_copy(struct tb_cfg_request *req,
> +			ÂÂÂÂconst struct ctl_pkg *pkg)
> +{
> +	memcpy(req->response, pkg->buffer, req->response_size);
> +	req->result.err = 0;
> +	return true;
> +}
> +
> +static void response_ready(void *data)
> +{
> +	tb_cfg_request_put(data);
> +}
> +
> +static int __tb_xdomain_response(struct tb_ctl *ctl, const void
> *response,
> +				Âsize_t size, enum tb_cfg_pkg_type
> type)
> +{
> +	struct tb_cfg_request *req;
> +
> +	req = tb_cfg_request_alloc();
> +	if (!req)
> +		return -ENOMEM;
> +
> +	req->match = tb_xdomain_match;
> +	req->copy = tb_xdomain_copy;
> +	req->request = response;
> +	req->request_size = size;
> +	req->request_type = type;
> +
> +	return tb_cfg_request(ctl, req, response_ready, req);
> +}
> +
> +/**
> + * tb_xdomain_response() - Send a XDomain response message
> + * @xd: XDomain to send the message
> + * @response: Response to send
> + * @size: Size of the response
> + * @type: PDF type of the response
> + *
> + * This can be used to send a XDomain response message to the other
> + * domain. No response for the message is expected.
> + *
> + * Return: %0 in case of success and negative errno in case of
> failure
> + */
> +int tb_xdomain_response(struct tb_xdomain *xd, const void *response,
> +			size_t size, enum tb_cfg_pkg_type type)
> +{
> +	return __tb_xdomain_response(xd->tb->ctl, response, size,
> type);
> +}
> +EXPORT_SYMBOL_GPL(tb_xdomain_response);
> +
> +static int __tb_xdomain_request(struct tb_ctl *ctl, const void
> *request,
> +	size_t request_size, enum tb_cfg_pkg_type request_type, void
> *response,
> +	size_t response_size, enum tb_cfg_pkg_type response_type,
> +	unsigned int timeout_msec)
> +{
> +	struct tb_cfg_request *req;
> +	struct tb_cfg_result res;
> +
> +	req = tb_cfg_request_alloc();
> +	if (!req)
> +		return -ENOMEM;
> +
> +	req->match = tb_xdomain_match;
> +	req->copy = tb_xdomain_copy;
> +	req->request = request;
> +	req->request_size = request_size;
> +	req->request_type = request_type;
> +	req->response = response;
> +	req->response_size = response_size;
> +	req->response_type = response_type;
> +
> +	res = tb_cfg_request_sync(ctl, req, timeout_msec);
> +
> +	tb_cfg_request_put(req);
> +
> +	return res.err == 1 ? -EIO : res.err;
> +}
> +
> +/**
> + * tb_xdomain_request() - Send a XDomain request
> + * @xd: XDomain to send the request
> + * @request: Request to send
> + * @request_size: Size of the request in bytes
> + * @request_type: PDF type of the request
> + * @response: Response is copied here
> + * @response_size: Expected size of the response in bytes
> + * @response_type: Expected PDF type of the response
> + * @timeout_msec: Timeout in milliseconds to wait for the response
> + *
> + * This function can be used to send XDomain control channel
> messages to
> + * the other domain. The function waits until the response is
> received
> + * or when timeout triggers. Whichever comes first.
> + *
> + * Return: %0 in case of success and negative errno in case of
> failure
> + */
> +int tb_xdomain_request(struct tb_xdomain *xd, const void *request,
> +	size_t request_size, enum tb_cfg_pkg_type request_type,
> +	void *response, size_t response_size,
> +	enum tb_cfg_pkg_type response_type, unsigned int
> timeout_msec)
> +{
> +	return __tb_xdomain_request(xd->tb->ctl, request,
> request_size,
> +				ÂÂÂÂrequest_type, response,
> response_size,
> +				ÂÂÂÂresponse_type, timeout_msec);
> +}
> +EXPORT_SYMBOL_GPL(tb_xdomain_request);
> +
> +static inline void tb_xdp_fill_header(struct tb_xdp_header *hdr, u64
> route,
> +	u8 sequence, enum tb_xdp_type type, size_t size)
> +{
> +	u32 length_sn;
> +
> +	length_sn = (size - sizeof(hdr->xd_hdr)) / 4;
> +	length_sn |= (sequence << TB_XDOMAIN_SN_SHIFT) &
> TB_XDOMAIN_SN_MASK;
> +
> +	hdr->xd_hdr.route_hi = upper_32_bits(route);
> +	hdr->xd_hdr.route_lo = lower_32_bits(route);
> +	hdr->xd_hdr.length_sn = length_sn;
> +	hdr->type = type;
> +	memcpy(&hdr->uuid, &tb_xdp_uuid, sizeof(tb_xdp_uuid));
> +}
> +
> +static int tb_xdp_handle_error(const struct tb_xdp_header *hdr)
> +{
> +	const struct tb_xdp_error_response *error;
> +
> +	if (hdr->type != ERROR_RESPONSE)
> +		return 0;
> +
> +	error = (const struct tb_xdp_error_response *)hdr;
> +
> +	switch (error->error) {
> +	case ERROR_UNKNOWN_PACKET:
> +	case ERROR_UNKNOWN_DOMAIN:
> +		return -EIO;
> +	case ERROR_NOT_SUPPORTED:
> +		return -ENOTSUPP;
> +	case ERROR_NOT_READY:
> +		return -EAGAIN;
> +	default:
> +		break;
> +	}
> +
> +	return 0;
> +}
> +
> +static int tb_xdp_error_response(struct tb_ctl *ctl, u64 route, u8
> sequence,
> +				Âenum tb_xdp_error error)
> +{
> +	struct tb_xdp_error_response res;
> +
> +	memset(&res, 0, sizeof(res));
> +	tb_xdp_fill_header(&res.hdr, route, sequence,
> ERROR_RESPONSE,
> +			ÂÂÂsizeof(res));
> +	res.error = error;
> +
> +	return __tb_xdomain_response(ctl, &res, sizeof(res),
> +				ÂÂÂÂÂTB_CFG_PKG_XDOMAIN_RESP);
> +}
> +
> +static int tb_xdp_properties_request(struct tb_ctl *ctl, u64 route,
> +	const uuid_t *src_uuid, const uuid_t *dst_uuid, int retry,
> +	u32 **block, u32 *generation)
> +{
> +	struct tb_xdp_properties_response *res;
> +	struct tb_xdp_properties req;
> +	u16 data_len, len;
> +	size_t total_size;
> +	u32 *data = NULL;
> +	int ret;
> +
> +	total_size = sizeof(*res) +
> TB_XDP_PROPERTIES_MAX_DATA_LENGTH * 4;
> +	res = kzalloc(total_size, GFP_KERNEL);
> +	if (!res)
> +		return -ENOMEM;
> +
> +	memset(&req, 0, sizeof(req));
> +	tb_xdp_fill_header(&req.hdr, route, retry % 4,
> PROPERTIES_REQUEST,
> +			ÂÂÂsizeof(req));
> +	memcpy(&req.src_uuid, src_uuid, sizeof(*src_uuid));
> +	memcpy(&req.dst_uuid, dst_uuid, sizeof(*dst_uuid));
> +
> +	len = 0;
> +	data_len = 0;
> +
> +	do {
> +		ret = __tb_xdomain_request(ctl, &req, sizeof(req),
> +					ÂÂÂTB_CFG_PKG_XDOMAIN_REQ,
> res,
> +					ÂÂÂtotal_size,
> TB_CFG_PKG_XDOMAIN_RESP,
> +					ÂÂÂXDOMAIN_DEFAULT_TIMEOUT);
> +		if (ret)
> +			goto err;
> +
> +		ret = tb_xdp_handle_error(&res->hdr);
> +		if (ret)
> +			goto err;
> +
> +		/*
> +		Â* Package length includes the whole payload without
> the
> +		Â* XDomain header. Validate first that the package
> is at
> +		Â* least size of the response structure.
> +		Â*/
> +		len = res->hdr.xd_hdr.length_sn &
> TB_XDOMAIN_LENGTH_MASK;
> +		if (len < sizeof(*res) / 4) {
> +			ret = -EINVAL;
> +			goto err;
> +		}
> +
> +		len += sizeof(res->hdr.xd_hdr) / 4;
> +		len -= sizeof(*res) / 4;
> +
> +		if (res->offset != req.offset) {
> +			ret = -EINVAL;
> +			goto err;
> +		}
> +
> +		/*
> +		Â* First time allocate block that has enough space
> for
> +		Â* the whole properties block.
> +		Â*/
> +		if (!data) {
> +			data_len = res->data_length;
> +			if (data_len > TB_XDP_PROPERTIES_MAX_LENGTH)
> {
> +				ret = -E2BIG;
> +				goto err;
> +			}
> +
> +			data = kcalloc(data_len, sizeof(u32),
> GFP_KERNEL);
> +			if (!data) {
> +				ret = -ENOMEM;
> +				goto err;
> +			}
> +		}
> +
> +		memcpy(data + req.offset, res->data, len * 4);
> +		req.offset += len;
> +	} while (!data_len || req.offset < data_len);
> +
> +	*block = data;
> +	*generation = res->generation;
> +
> +	kfree(res);
> +
> +	return data_len;
> +
> +err:
> +	kfree(data);
> +	kfree(res);
> +
> +	return ret;
> +}
> +
> +static int tb_xdp_properties_response(struct tb *tb, struct tb_ctl
> *ctl,
> +	u64 route, u8 sequence, const uuid_t *src_uuid,
> +	const struct tb_xdp_properties *req)
> +{
> +	struct tb_xdp_properties_response *res;
> +	size_t total_size;
> +	u16 len;
> +	int ret;
> +
> +	/*
> +	Â* Currently we expect all requests to be directed to us.
> The
> +	Â* protocol supports forwarding, though which we might add
> +	Â* support later on.
> +	Â*/
> +	if (!uuid_equal(src_uuid, &req->dst_uuid)) {
> +		tb_xdp_error_response(ctl, route, sequence,
> +				ÂÂÂÂÂÂERROR_UNKNOWN_DOMAIN);
> +		return 0;
> +	}
> +
> +	mutex_lock(&xdomain_lock);
> +
> +	if (req->offset >= xdomain_property_block_len) {
> +		mutex_unlock(&xdomain_lock);
> +		return -EINVAL;
> +	}
> +
> +	len = xdomain_property_block_len - req->offset;
> +	len = min_t(u16, len, TB_XDP_PROPERTIES_MAX_DATA_LENGTH);
> +	total_size = sizeof(*res) + len * 4;
> +
> +	res = kzalloc(total_size, GFP_KERNEL);
> +	if (!res) {
> +		mutex_unlock(&xdomain_lock);
> +		return -ENOMEM;
> +	}
> +
> +	tb_xdp_fill_header(&res->hdr, route, sequence,
> PROPERTIES_RESPONSE,
> +			ÂÂÂtotal_size);
> +	res->generation = xdomain_property_block_gen;
> +	res->data_length = xdomain_property_block_len;
> +	res->offset = req->offset;
> +	uuid_copy(&res->src_uuid, src_uuid);
> +	uuid_copy(&res->dst_uuid, &req->src_uuid);
> +	memcpy(res->data, &xdomain_property_block[req->offset], len
> * 4);
> +
> +	mutex_unlock(&xdomain_lock);
> +
> +	ret = __tb_xdomain_response(ctl, res, total_size,
> +				ÂÂÂÂTB_CFG_PKG_XDOMAIN_RESP);
> +
> +	kfree(res);
> +	return ret;
> +}
> +
> +static int tb_xdp_properties_changed_request(struct tb_ctl *ctl, u64
> route,
> +					ÂÂÂÂÂint retry, const uuid_t
> *uuid)
> +{
> +	struct tb_xdp_properties_changed_response res;
> +	struct tb_xdp_properties_changed req;
> +	int ret;
> +
> +	memset(&req, 0, sizeof(req));
> +	tb_xdp_fill_header(&req.hdr, route, retry % 4,
> +			ÂÂÂPROPERTIES_CHANGED_REQUEST, sizeof(req));
> +	uuid_copy(&req.src_uuid, uuid);
> +
> +	memset(&res, 0, sizeof(res));
> +	ret = __tb_xdomain_request(ctl, &req, sizeof(req),
> +				ÂÂÂTB_CFG_PKG_XDOMAIN_REQ, &res,
> sizeof(res),
> +				ÂÂÂTB_CFG_PKG_XDOMAIN_RESP,
> +				ÂÂÂXDOMAIN_DEFAULT_TIMEOUT);
> +	if (ret)
> +		return ret;
> +
> +	return tb_xdp_handle_error(&res.hdr);
> +}
> +
> +static int
> +tb_xdp_properties_changed_response(struct tb_ctl *ctl, u64 route, u8
> sequence)
> +{
> +	struct tb_xdp_properties_changed_response res;
> +
> +	memset(&res, 0, sizeof(res));
> +	tb_xdp_fill_header(&res.hdr, route, sequence,
> +			ÂÂÂPROPERTIES_CHANGED_RESPONSE,
> sizeof(res));
> +	return __tb_xdomain_response(ctl, &res, sizeof(res),
> +				ÂÂÂÂÂTB_CFG_PKG_XDOMAIN_RESP);
> +}
> +
> +/**
> + * tb_register_protocol_handler() - Register protocol handler
> + * @handler: Handler to register
> + *
> + * This allows XDomain service drivers to hook into incoming XDomain
> + * messages. After this function is called the service driver needs
> to
> + * be able to handle calls to callback whenever a package with the
> + * registered protocol is received.
> + */
> +int tb_register_protocol_handler(struct tb_protocol_handler
> *handler)
> +{
> +	if (!handler->uuid || !handler->callback)
> +		return -EINVAL;
> +	if (uuid_equal(handler->uuid, &tb_xdp_uuid))
> +		return -EINVAL;
> +
> +	mutex_lock(&xdomain_lock);
> +	list_add_tail(&handler->list, &protocol_handlers);
> +	mutex_unlock(&xdomain_lock);
> +
> +	return 0;
> +}
> +EXPORT_SYMBOL_GPL(tb_register_protocol_handler);
> +
> +/**
> + * tb_unregister_protocol_handler() - Unregister protocol handler
> + * @handler: Handler to unregister
> + *
> + * Removes the previously registered protocol handler.
> + */
> +void tb_unregister_protocol_handler(struct tb_protocol_handler
> *handler)
> +{
> +	mutex_lock(&xdomain_lock);
> +	list_del_init(&handler->list);
> +	mutex_unlock(&xdomain_lock);
> +}
> +EXPORT_SYMBOL_GPL(tb_unregister_protocol_handler);
> +
> +static void tb_xdp_handle_request(struct work_struct *work)
> +{
> +	struct xdomain_request_work *xw = container_of(work,
> typeof(*xw), work);
> +	const struct tb_xdp_header *pkg = xw->pkg;
> +	const struct tb_xdomain_header *xhdr = &pkg->xd_hdr;
> +	struct tb *tb = xw->tb;
> +	struct tb_ctl *ctl = tb->ctl;
> +	const uuid_t *uuid;
> +	int ret = 0;
> +	u8 sequence;
> +	u64 route;
> +
> +	route = ((u64)xhdr->route_hi << 32 | xhdr->route_lo) &
> ~BIT_ULL(63);
> +	sequence = xhdr->length_sn & TB_XDOMAIN_SN_MASK;
> +	sequence >>= TB_XDOMAIN_SN_SHIFT;
> +
> +	mutex_lock(&tb->lock);
> +	if (tb->root_switch)
> +		uuid = tb->root_switch->uuid;
> +	else
> +		uuid = NULL;
> +	mutex_unlock(&tb->lock);
> +
> +	if (!uuid) {
> +		tb_xdp_error_response(ctl, route, sequence,
> ERROR_NOT_READY);
> +		goto out;
> +	}
> +
> +	switch (pkg->type) {
> +	case PROPERTIES_REQUEST:
> +		ret = tb_xdp_properties_response(tb, ctl, route,
> sequence, uuid,
> +			(const struct tb_xdp_properties *)pkg);
> +		break;
> +
> +	case PROPERTIES_CHANGED_REQUEST: {
> +		const struct tb_xdp_properties_changed *xchg =
> +			(const struct tb_xdp_properties_changed
> *)pkg;
> +		struct tb_xdomain *xd;
> +
> +		ret = tb_xdp_properties_changed_response(ctl, route,
> sequence);
> +
> +		/*
> +		Â* Since the properties have been changed, let's
> update
> +		Â* the xdomain related to this connection as well in
> +		Â* case there is a change in services it offers.
> +		Â*/
> +		xd = tb_xdomain_find_by_uuid_locked(tb, &xchg-
> >src_uuid);
> +		if (xd) {
> +			queue_delayed_work(tb->wq, &xd-
> >get_properties_work,
> +					ÂÂÂmsecs_to_jiffies(50));
> +			tb_xdomain_put(xd);
> +		}
> +
> +		break;
> +	}
> +
> +	default:
> +		break;
> +	}
> +
> +	if (ret) {
> +		tb_warn(tb, "failed to send XDomain response for
> %#x\n",
> +			pkg->type);
> +	}
> +
> +out:
> +	kfree(xw->pkg);
> +	kfree(xw);
> +}
> +
> +static void
> +tb_xdp_schedule_request(struct tb *tb, const struct tb_xdp_header
> *hdr,
> +			size_t size)
> +{
> +	struct xdomain_request_work *xw;
> +
> +	xw = kmalloc(sizeof(*xw), GFP_KERNEL);
> +	if (!xw)
> +		return;
> +
> +	INIT_WORK(&xw->work, tb_xdp_handle_request);
> +	xw->pkg = kmemdup(hdr, size, GFP_KERNEL);
> +	xw->tb = tb;
> +
> +	queue_work(tb->wq, &xw->work);
> +}
> +
> +/**
> + * tb_register_service_driver() - Register XDomain service driver
> + * @drv: Driver to register
> + *
> + * Registers new service driver from @drv to the bus.
> + */
> +int tb_register_service_driver(struct tb_service_driver *drv)
> +{
> +	drv->driver.bus = &tb_bus_type;
> +	return driver_register(&drv->driver);
> +}
> +EXPORT_SYMBOL_GPL(tb_register_service_driver);
> +
> +/**
> + * tb_unregister_service_driver() - Unregister XDomain service
> driver
> + * @xdrv: Driver to unregister
> + *
> + * Unregisters XDomain service driver from the bus.
> + */
> +void tb_unregister_service_driver(struct tb_service_driver *drv)
> +{
> +	driver_unregister(&drv->driver);
> +}
> +EXPORT_SYMBOL_GPL(tb_unregister_service_driver);
> +
> +static ssize_t key_show(struct device *dev, struct device_attribute
> *attr,
> +			char *buf)
> +{
> +	struct tb_service *svc = container_of(dev, struct
> tb_service, dev);
> +
> +	/*
> +	Â* It should be null terminated but anything else is pretty
> much
> +	Â* allowed.
> +	Â*/
> +	return sprintf(buf, "%*pEp\n", (int)strlen(svc->key), svc-
> >key);
> +}
> +static DEVICE_ATTR_RO(key);
> +
> +static int get_modalias(struct tb_service *svc, char *buf, size_t
> size)
> +{
> +	return snprintf(buf, size, "tbsvc:k%sp%08Xv%08Xr%08X", svc-
> >key,
> +			svc->prtcid, svc->prtcvers, svc->prtcrevs);
> +}
> +
> +static ssize_t modalias_show(struct device *dev, struct
> device_attribute *attr,
> +			ÂÂÂÂÂchar *buf)
> +{
> +	struct tb_service *svc = container_of(dev, struct
> tb_service, dev);
> +
> +	/* Full buffer size except new line and null termination */
> +	get_modalias(svc, buf, PAGE_SIZE - 2);
> +	return sprintf(buf, "%s\n", buf);
> +}
> +static DEVICE_ATTR_RO(modalias);
> +
> +static ssize_t prtcid_show(struct device *dev, struct
> device_attribute *attr,
> +			ÂÂÂchar *buf)
> +{
> +	struct tb_service *svc = container_of(dev, struct
> tb_service, dev);
> +
> +	return sprintf(buf, "%u\n", svc->prtcid);
> +}
> +static DEVICE_ATTR_RO(prtcid);
> +
> +static ssize_t prtcvers_show(struct device *dev, struct
> device_attribute *attr,
> +			ÂÂÂÂÂchar *buf)
> +{
> +	struct tb_service *svc = container_of(dev, struct
> tb_service, dev);
> +
> +	return sprintf(buf, "%u\n", svc->prtcvers);
> +}
> +static DEVICE_ATTR_RO(prtcvers);
> +
> +static ssize_t prtcrevs_show(struct device *dev, struct
> device_attribute *attr,
> +			ÂÂÂÂÂchar *buf)
> +{
> +	struct tb_service *svc = container_of(dev, struct
> tb_service, dev);
> +
> +	return sprintf(buf, "%u\n", svc->prtcrevs);
> +}
> +static DEVICE_ATTR_RO(prtcrevs);
> +
> +static ssize_t prtcstns_show(struct device *dev, struct
> device_attribute *attr,
> +			ÂÂÂÂÂchar *buf)
> +{
> +	struct tb_service *svc = container_of(dev, struct
> tb_service, dev);
> +
> +	return sprintf(buf, "0x%08x\n", svc->prtcstns);
> +}
> +static DEVICE_ATTR_RO(prtcstns);
> +
> +static struct attribute *tb_service_attrs[] = {
> +	&dev_attr_key.attr,
> +	&dev_attr_modalias.attr,
> +	&dev_attr_prtcid.attr,
> +	&dev_attr_prtcvers.attr,
> +	&dev_attr_prtcrevs.attr,
> +	&dev_attr_prtcstns.attr,
> +	NULL,
> +};
> +
> +static struct attribute_group tb_service_attr_group = {
> +	.attrs = tb_service_attrs,
> +};
> +
> +static const struct attribute_group *tb_service_attr_groups[] = {
> +	&tb_service_attr_group,
> +	NULL,
> +};
> +
> +static int tb_service_uevent(struct device *dev, struct
> kobj_uevent_env *env)
> +{
> +	struct tb_service *svc = container_of(dev, struct
> tb_service, dev);
> +	char modalias[64];
> +
> +	get_modalias(svc, modalias, sizeof(modalias));
> +	return add_uevent_var(env, "MODALIAS=%s", modalias);
> +}
> +
> +static void tb_service_release(struct device *dev)
> +{
> +	struct tb_service *svc = container_of(dev, struct
> tb_service, dev);
> +	struct tb_xdomain *xd = tb_service_parent(svc);
> +
> +	ida_simple_remove(&xd->service_ids, svc->id);
> +	kfree(svc->key);
> +	kfree(svc);
> +}
> +
> +struct device_type tb_service_type = {
> +	.name = "thunderbolt_service",
> +	.groups = tb_service_attr_groups,
> +	.uevent = tb_service_uevent,
> +	.release = tb_service_release,
> +};
> +EXPORT_SYMBOL_GPL(tb_service_type);
> +
> +static int remove_missing_service(struct device *dev, void *data)
> +{
> +	struct tb_xdomain *xd = data;
> +	struct tb_service *svc;
> +
> +	svc = tb_to_service(dev);
> +	if (!svc)
> +		return 0;
> +
> +	if (!tb_property_find(xd->properties, svc->key,
> +			ÂÂÂÂÂÂTB_PROPERTY_TYPE_DIRECTORY))
> +		device_unregister(dev);
> +
> +	return 0;
> +}
> +
> +static int find_service(struct device *dev, void *data)
> +{
> +	const struct tb_property *p = data;
> +	struct tb_service *svc;
> +
> +	svc = tb_to_service(dev);
> +	if (!svc)
> +		return 0;
> +
> +	return !strcmp(svc->key, p->key);
> +}
> +
> +static int populate_service(struct tb_service *svc,
> +			ÂÂÂÂstruct tb_property *property)
> +{
> +	struct tb_property_dir *dir = property->value.dir;
> +	struct tb_property *p;
> +
> +	/* Fill in standard properties */
> +	p = tb_property_find(dir, "prtcid", TB_PROPERTY_TYPE_VALUE);
> +	if (p)
> +		svc->prtcid = p->value.immediate;
> +	p = tb_property_find(dir, "prtcvers",
> TB_PROPERTY_TYPE_VALUE);
> +	if (p)
> +		svc->prtcvers = p->value.immediate;
> +	p = tb_property_find(dir, "prtcrevs",
> TB_PROPERTY_TYPE_VALUE);
> +	if (p)
> +		svc->prtcrevs = p->value.immediate;
> +	p = tb_property_find(dir, "prtcstns",
> TB_PROPERTY_TYPE_VALUE);
> +	if (p)
> +		svc->prtcstns = p->value.immediate;
> +
> +	svc->key = kstrdup(property->key, GFP_KERNEL);
> +	if (!svc->key)
> +		return -ENOMEM;
> +
> +	return 0;
> +}
> +
> +static void enumerate_services(struct tb_xdomain *xd)
> +{
> +	struct tb_service *svc;
> +	struct tb_property *p;
> +	struct device *dev;
> +
> +	/*
> +	Â* First remove all services that are not available anymore
> in
> +	Â* the updated property block.
> +	Â*/
> +	device_for_each_child_reverse(&xd->dev, xd,
> remove_missing_service);
> +
> +	/* Then re-enumerate properties creating new services as we
> go */
> +	tb_property_for_each(xd->properties, p) {
> +		if (p->type != TB_PROPERTY_TYPE_DIRECTORY)
> +			continue;
> +
> +		/* If the service exists already we are fine */
> +		dev = device_find_child(&xd->dev, p, find_service);
> +		if (dev) {
> +			put_device(dev);
> +			continue;
> +		}
> +
> +		svc = kzalloc(sizeof(*svc), GFP_KERNEL);
> +		if (!svc)
> +			break;
> +
> +		if (populate_service(svc, p)) {
> +			kfree(svc);
> +			break;
> +		}
> +
> +		svc->id = ida_simple_get(&xd->service_ids, 0, 0,
> GFP_KERNEL);
> +		svc->dev.bus = &tb_bus_type;
> +		svc->dev.type = &tb_service_type;
> +		svc->dev.parent = &xd->dev;
> +		dev_set_name(&svc->dev, "%s.%d", dev_name(&xd->dev), 
> svc->id);
> +
> +		if (device_register(&svc->dev)) {
> +			put_device(&svc->dev);
> +			break;
> +		}
> +	}
> +}
> +
> +static int populate_properties(struct tb_xdomain *xd,
> +			ÂÂÂÂÂÂÂstruct tb_property_dir *dir)
> +{
> +	const struct tb_property *p;
> +
> +	/* Required properties */
> +	p = tb_property_find(dir, "deviceid",
> TB_PROPERTY_TYPE_VALUE);
> +	if (!p)
> +		return -EINVAL;
> +	xd->device = p->value.immediate;
> +
> +	p = tb_property_find(dir, "vendorid",
> TB_PROPERTY_TYPE_VALUE);
> +	if (!p)
> +		return -EINVAL;
> +	xd->vendor = p->value.immediate;
> +
> +	kfree(xd->device_name);
> +	xd->device_name = NULL;
> +	kfree(xd->vendor_name);
> +	xd->vendor_name = NULL;
> +
> +	/* Optional properties */
> +	p = tb_property_find(dir, "deviceid",
> TB_PROPERTY_TYPE_TEXT);
> +	if (p)
> +		xd->device_name = kstrdup(p->value.text,
> GFP_KERNEL);
> +	p = tb_property_find(dir, "vendorid",
> TB_PROPERTY_TYPE_TEXT);
> +	if (p)
> +		xd->vendor_name = kstrdup(p->value.text,
> GFP_KERNEL);
> +
> +	return 0;
> +}
> +
> +/* Called with @xd->lock held */
> +static void tb_xdomain_restore_paths(struct tb_xdomain *xd)
> +{
> +	if (!xd->resume)
> +		return;
> +
> +	xd->resume = false;
> +	if (xd->transmit_path) {
> +		dev_dbg(&xd->dev, "re-establishing DMA path\n");
> +		tb_domain_approve_xdomain_paths(xd->tb, xd);
> +	}
> +}
> +
> +static void tb_xdomain_get_properties(struct work_struct *work)
> +{
> +	struct tb_xdomain *xd = container_of(work, typeof(*xd),
> +					ÂÂÂÂÂget_properties_work.wor
> k);
> +	struct tb_property_dir *dir;
> +	struct tb *tb = xd->tb;
> +	bool update = false;
> +	u32 *block = NULL;
> +	u32 gen = 0;
> +	int ret;
> +
> +	ret = tb_xdp_properties_request(tb->ctl, xd->route, xd-
> >local_uuid,
> +					xd->remote_uuid, xd-
> >properties_retries,
> +					&block, &gen);
> +	if (ret < 0) {
> +		if (xd->properties_retries-- > 0) {
> +			queue_delayed_work(xd->tb->wq, &xd-
> >get_properties_work,
> +					ÂÂÂmsecs_to_jiffies(1000));
> +		} else {
> +			/* Give up now */
> +			dev_err(&xd->dev,
> +				"failed read XDomain properties from
> %pUb\n",
> +				xd->remote_uuid);
> +		}
> +		return;
> +	}
> +
> +	xd->properties_retries = XDOMAIN_PROPERTIES_RETRIES;
> +
> +	mutex_lock(&xd->lock);
> +
> +	/* Only accept newer generation properties */
> +	if (xd->properties && gen <= xd->property_block_gen) {
> +		/*
> +		Â* On resume it is likely that the properties block
> is
> +		Â* not changed (unless the other end added or
> removed
> +		Â* services). However, we need to make sure the
> existing
> +		Â* DMA paths are restored properly.
> +		Â*/
> +		tb_xdomain_restore_paths(xd);
> +		goto err_free_block;
> +	}
> +
> +	dir = tb_property_parse_dir(block, ret);
> +	if (!dir) {
> +		dev_err(&xd->dev, "failed to parse XDomain
> properties\n");
> +		goto err_free_block;
> +	}
> +
> +	ret = populate_properties(xd, dir);
> +	if (ret) {
> +		dev_err(&xd->dev, "missing XDomain properties in
> response\n");
> +		goto err_free_dir;
> +	}
> +
> +	/* Release the existing one */
> +	if (xd->properties) {
> +		tb_property_free_dir(xd->properties);
> +		update = true;
> +	}
> +
> +	xd->properties = dir;
> +	xd->property_block_gen = gen;
> +
> +	tb_xdomain_restore_paths(xd);
> +
> +	mutex_unlock(&xd->lock);
> +
> +	kfree(block);
> +
> +	/*
> +	Â* Now the device should be ready enough so we can add it to
> the
> +	Â* bus and let userspace know about it. If the device is
> already
> +	Â* registered, we notify the userspace that it has changed.
> +	Â*/
> +	if (!update) {
> +		if (device_add(&xd->dev)) {
> +			dev_err(&xd->dev, "failed to add XDomain
> device\n");
> +			return;
> +		}
> +	} else {
> +		kobject_uevent(&xd->dev.kobj, KOBJ_CHANGE);
> +	}
> +
> +	enumerate_services(xd);
> +	return;
> +
> +err_free_dir:
> +	tb_property_free_dir(dir);
> +err_free_block:
> +	kfree(block);
> +	mutex_unlock(&xd->lock);
> +}
> +
> +static void tb_xdomain_properties_changed(struct work_struct *work)
> +{
> +	struct tb_xdomain *xd = container_of(work, typeof(*xd),
> +					ÂÂÂÂÂproperties_changed_work
> .work);
> +	int ret;
> +
> +	ret = tb_xdp_properties_changed_request(xd->tb->ctl, xd-
> >route,
> +				xd->properties_changed_retries, xd-
> >local_uuid);
> +	if (ret) {
> +		if (xd->properties_changed_retries-- > 0)
> +			queue_delayed_work(xd->tb->wq,
> +					ÂÂÂ&xd-
> >properties_changed_work,
> +					ÂÂÂmsecs_to_jiffies(1000));
> +		return;
> +	}
> +
> +	xd->properties_changed_retries =
> XDOMAIN_PROPERTIES_CHANGED_RETRIES;
> +}
> +
> +static ssize_t device_show(struct device *dev, struct
> device_attribute *attr,
> +			ÂÂÂchar *buf)
> +{
> +	struct tb_xdomain *xd = container_of(dev, struct tb_xdomain,
> dev);
> +
> +	return sprintf(buf, "%#x\n", xd->device);
> +}
> +static DEVICE_ATTR_RO(device);
> +
> +static ssize_t
> +device_name_show(struct device *dev, struct device_attribute *attr,
> char *buf)
> +{
> +	struct tb_xdomain *xd = container_of(dev, struct tb_xdomain,
> dev);
> +	int ret;
> +
> +	if (mutex_lock_interruptible(&xd->lock))
> +		return -ERESTARTSYS;
> +	ret = sprintf(buf, "%s\n", xd->device_name ? xd->device_name 
> : "");
> +	mutex_unlock(&xd->lock);
> +
> +	return ret;
> +}
> +static DEVICE_ATTR_RO(device_name);
> +
> +static ssize_t vendor_show(struct device *dev, struct
> device_attribute *attr,
> +			ÂÂÂchar *buf)
> +{
> +	struct tb_xdomain *xd = container_of(dev, struct tb_xdomain,
> dev);
> +
> +	return sprintf(buf, "%#x\n", xd->vendor);
> +}
> +static DEVICE_ATTR_RO(vendor);
> +
> +static ssize_t
> +vendor_name_show(struct device *dev, struct device_attribute *attr,
> char *buf)
> +{
> +	struct tb_xdomain *xd = container_of(dev, struct tb_xdomain,
> dev);
> +	int ret;
> +
> +	if (mutex_lock_interruptible(&xd->lock))
> +		return -ERESTARTSYS;
> +	ret = sprintf(buf, "%s\n", xd->vendor_name ? xd->vendor_name 
> : "");
> +	mutex_unlock(&xd->lock);
> +
> +	return ret;
> +}
> +static DEVICE_ATTR_RO(vendor_name);
> +
> +static ssize_t unique_id_show(struct device *dev, struct
> device_attribute *attr,
> +			ÂÂÂÂÂÂchar *buf)
> +{
> +	struct tb_xdomain *xd = container_of(dev, struct tb_xdomain,
> dev);
> +
> +	return sprintf(buf, "%pUb\n", xd->remote_uuid);
> +}
> +static DEVICE_ATTR_RO(unique_id);
> +
> +static struct attribute *xdomain_attrs[] = {
> +	&dev_attr_device.attr,
> +	&dev_attr_device_name.attr,
> +	&dev_attr_unique_id.attr,
> +	&dev_attr_vendor.attr,
> +	&dev_attr_vendor_name.attr,
> +	NULL,
> +};
> +
> +static struct attribute_group xdomain_attr_group = {
> +	.attrs = xdomain_attrs,
> +};
> +
> +static const struct attribute_group *xdomain_attr_groups[] = {
> +	&xdomain_attr_group,
> +	NULL,
> +};
> +
> +static void tb_xdomain_release(struct device *dev)
> +{
> +	struct tb_xdomain *xd = container_of(dev, struct tb_xdomain,
> dev);
> +
> +	put_device(xd->dev.parent);
> +
> +	tb_property_free_dir(xd->properties);
> +	ida_destroy(&xd->service_ids);
> +
> +	kfree(xd->local_uuid);
> +	kfree(xd->remote_uuid);
> +	kfree(xd->device_name);
> +	kfree(xd->vendor_name);
> +	kfree(xd);
> +}
> +
> +static void start_handshake(struct tb_xdomain *xd)
> +{
> +	xd->properties_retries = XDOMAIN_PROPERTIES_RETRIES;
> +	xd->properties_changed_retries =
> XDOMAIN_PROPERTIES_CHANGED_RETRIES;
> +
> +	/* Start exchanging properties with the other host */
> +	queue_delayed_work(xd->tb->wq, &xd->properties_changed_work,
> +			ÂÂÂmsecs_to_jiffies(100));
> +	queue_delayed_work(xd->tb->wq, &xd->get_properties_work,
> +			ÂÂÂmsecs_to_jiffies(1000));
> +}
> +
> +static void stop_handshake(struct tb_xdomain *xd)
> +{
> +	xd->properties_retries = 0;
> +	xd->properties_changed_retries = 0;
> +
> +	cancel_delayed_work_sync(&xd->get_properties_work);
> +	cancel_delayed_work_sync(&xd->properties_changed_work);
> +}
> +
> +static int __maybe_unused tb_xdomain_suspend(struct device *dev)
> +{
> +	stop_handshake(tb_to_xdomain(dev));
> +	return 0;
> +}
> +
> +static int __maybe_unused tb_xdomain_resume(struct device *dev)
> +{
> +	struct tb_xdomain *xd = tb_to_xdomain(dev);
> +
> +	/*
> +	Â* Ask tb_xdomain_get_properties() restore any existing DMA
> +	Â* paths after properties are re-read.
> +	Â*/
> +	xd->resume = true;
> +	start_handshake(xd);
> +
> +	return 0;
> +}
> +
> +static const struct dev_pm_ops tb_xdomain_pm_ops = {
> +	SET_SYSTEM_SLEEP_PM_OPS(tb_xdomain_suspend,
> tb_xdomain_resume)
> +};
> +
> +struct device_type tb_xdomain_type = {
> +	.name = "thunderbolt_xdomain",
> +	.release = tb_xdomain_release,
> +	.pm = &tb_xdomain_pm_ops,
> +};
> +EXPORT_SYMBOL_GPL(tb_xdomain_type);
> +
> +/**
> + * tb_xdomain_alloc() - Allocate new XDomain object
> + * @tb: Domain where the XDomain belongs
> + * @parent: Parent device (the switch through the connection to the
> + *	ÂÂÂÂother domain is reached).
> + * @route: Route string used to reach the other domain
> + * @local_uuid: Our local domain UUID
> + * @remote_uuid: UUID of the other domain
> + *
> + * Allocates new XDomain structure and returns pointer to that. The
> + * object must be released by calling tb_xdomain_put().
> + */
> +struct tb_xdomain *tb_xdomain_alloc(struct tb *tb, struct device
> *parent,
> +				ÂÂÂÂu64 route, const uuid_t
> *local_uuid,
> +				ÂÂÂÂconst uuid_t *remote_uuid)
> +{
> +	struct tb_xdomain *xd;
> +
> +	xd = kzalloc(sizeof(*xd), GFP_KERNEL);
> +	if (!xd)
> +		return NULL;
> +
> +	xd->tb = tb;
> +	xd->route = route;
> +	ida_init(&xd->service_ids);
> +	mutex_init(&xd->lock);
> +	INIT_DELAYED_WORK(&xd->get_properties_work,
> tb_xdomain_get_properties);
> +	INIT_DELAYED_WORK(&xd->properties_changed_work,
> +			ÂÂtb_xdomain_properties_changed);
> +
> +	xd->local_uuid = kmemdup(local_uuid, sizeof(uuid_t),
> GFP_KERNEL);
> +	if (!xd->local_uuid)
> +		goto err_free;
> +
> +	xd->remote_uuid = kmemdup(remote_uuid, sizeof(uuid_t),
> GFP_KERNEL);
> +	if (!xd->remote_uuid)
> +		goto err_free_local_uuid;
> +
> +	device_initialize(&xd->dev);
> +	xd->dev.parent = get_device(parent);
> +	xd->dev.bus = &tb_bus_type;
> +	xd->dev.type = &tb_xdomain_type;
> +	xd->dev.groups = xdomain_attr_groups;
> +	dev_set_name(&xd->dev, "%u-%llx", tb->index, route);
> +
> +	return xd;
> +
> +err_free_local_uuid:
> +	kfree(xd->local_uuid);
> +err_free:
> +	kfree(xd);
> +
> +	return NULL;
> +}
> +
> +/**
> + * tb_xdomain_add() - Add XDomain to the bus
> + * @xd: XDomain to add
> + *
> + * This function starts XDomain discovery protocol handshake and
> + * eventually adds the XDomain to the bus. After calling this
> function
> + * the caller needs to call tb_xdomain_remove() in order to remove
> and
> + * release the object regardless whether the handshake succeeded or
> not.
> + */
> +void tb_xdomain_add(struct tb_xdomain *xd)
> +{
> +	/* Start exchanging properties with the other host */
> +	start_handshake(xd);
> +}
> +
> +static int unregister_service(struct device *dev, void *data)
> +{
> +	device_unregister(dev);
> +	return 0;
> +}
> +
> +/**
> + * tb_xdomain_remove() - Remove XDomain from the bus
> + * @xd: XDomain to remove
> + *
> + * This will stop all ongoing configuration work and remove the
> XDomain
> + * along with any services from the bus. When the last reference to
> @xd
> + * is released the object will be released as well.
> + */
> +void tb_xdomain_remove(struct tb_xdomain *xd)
> +{
> +	stop_handshake(xd);
> +
> +	device_for_each_child_reverse(&xd->dev, xd,
> unregister_service);
> +
> +	if (!device_is_registered(&xd->dev))
> +		put_device(&xd->dev);
> +	else
> +		device_unregister(&xd->dev);
> +}
> +
> +/**
> + * tb_xdomain_enable_paths() - Enable DMA paths for XDomain
> connection
> + * @xd: XDomain connection
> + * @transmit_path: HopID of the transmit path the other end is using
> to
> + *		ÂÂÂsend packets
> + * @transmit_ring: DMA ring used to receive packets from the other
> end
> + * @receive_path: HopID of the receive path the other end is using
> to
> + *		ÂÂreceive packets
> + * @receive_ring: DMA ring used to send packets to the other end
> + *
> + * The function enables DMA paths accordingly so that after
> successful
> + * return the caller can send and receive packets using high-speed
> DMA
> + * path.
> + *
> + * Return: %0 in case of success and negative errno in case of error
> + */
> +int tb_xdomain_enable_paths(struct tb_xdomain *xd, u16
> transmit_path,
> +			ÂÂÂÂu16 transmit_ring, u16 receive_path,
> +			ÂÂÂÂu16 receive_ring)
> +{
> +	int ret;
> +
> +	mutex_lock(&xd->lock);
> +
> +	if (xd->transmit_path) {
> +		ret = xd->transmit_path == transmit_path ? 0 :
> -EBUSY;
> +		goto exit_unlock;
> +	}
> +
> +	xd->transmit_path = transmit_path;
> +	xd->transmit_ring = transmit_ring;
> +	xd->receive_path = receive_path;
> +	xd->receive_ring = receive_ring;
> +
> +	ret = tb_domain_approve_xdomain_paths(xd->tb, xd);
> +
> +exit_unlock:
> +	mutex_unlock(&xd->lock);
> +
> +	return ret;
> +}
> +EXPORT_SYMBOL_GPL(tb_xdomain_enable_paths);
> +
> +/**
> + * tb_xdomain_disable_paths() - Disable DMA paths for XDomain
> connection
> + * @xd: XDomain connection
> + *
> + * This does the opposite of tb_xdomain_enable_paths(). After call
> to
> + * this the caller is not expected to use the rings anymore.
> + *
> + * Return: %0 in case of success and negative errno in case of error
> + */
> +int tb_xdomain_disable_paths(struct tb_xdomain *xd)
> +{
> +	int ret = 0;
> +
> +	mutex_lock(&xd->lock);
> +	if (xd->transmit_path) {
> +		xd->transmit_path = 0;
> +		xd->transmit_ring = 0;
> +		xd->receive_path = 0;
> +		xd->receive_ring = 0;
> +
> +		ret = tb_domain_disconnect_xdomain_paths(xd->tb,
> xd);
> +	}
> +	mutex_unlock(&xd->lock);
> +
> +	return ret;
> +}
> +EXPORT_SYMBOL_GPL(tb_xdomain_disable_paths);
> +
> +struct tb_xdomain_lookup {
> +	const uuid_t *uuid;
> +	u8 link;
> +	u8 depth;
> +};
> +
> +static struct tb_xdomain *switch_find_xdomain(struct tb_switch *sw,
> +	const struct tb_xdomain_lookup *lookup)
> +{
> +	int i;
> +
> +	for (i = 1; i <= sw->config.max_port_number; i++) {
> +		struct tb_port *port = &sw->ports[i];
> +		struct tb_xdomain *xd;
> +
> +		if (tb_is_upstream_port(port))
> +			continue;
> +
> +		if (port->xdomain) {
> +			xd = port->xdomain;
> +
> +			if (lookup->uuid) {
> +				if (uuid_equal(xd->remote_uuid,
> lookup->uuid))
> +					return xd;
> +			} else if (lookup->link == xd->link &&
> +				ÂÂÂlookup->depth == xd->depth) {
> +				return xd;
> +			}
> +		} else if (port->remote) {
> +			xd = switch_find_xdomain(port->remote->sw,
> lookup);
> +			if (xd)
> +				return xd;
> +		}
> +	}
> +
> +	return NULL;
> +}
> +
> +/**
> + * tb_xdomain_find_by_uuid() - Find an XDomain by UUID
> + * @tb: Domain where the XDomain belongs to
> + * @uuid: UUID to look for
> + *
> + * Finds XDomain by walking through the Thunderbolt topology below
> @tb.
> + * The returned XDomain will have its reference count increased so
> the
> + * caller needs to call tb_xdomain_put() when it is done with the
> + * object.
> + *
> + * This will find all XDomains including the ones that are not yet
> added
> + * to the bus (handshake is still in progress).
> + *
> + * The caller needs to hold @tb->lock.
> + */
> +struct tb_xdomain *tb_xdomain_find_by_uuid(struct tb *tb, const
> uuid_t *uuid)
> +{
> +	struct tb_xdomain_lookup lookup;
> +	struct tb_xdomain *xd;
> +
> +	memset(&lookup, 0, sizeof(lookup));
> +	lookup.uuid = uuid;
> +
> +	xd = switch_find_xdomain(tb->root_switch, &lookup);
> +	if (xd) {
> +		get_device(&xd->dev);
> +		return xd;
> +	}
> +
> +	return NULL;
> +}
> +EXPORT_SYMBOL_GPL(tb_xdomain_find_by_uuid);
> +
> +/**
> + * tb_xdomain_find_by_link_depth() - Find an XDomain by link and
> depth
> + * @tb: Domain where the XDomain belongs to
> + * @link: Root switch link number
> + * @depth: Depth in the link
> + *
> + * Finds XDomain by walking through the Thunderbolt topology below
> @tb.
> + * The returned XDomain will have its reference count increased so
> the
> + * caller needs to call tb_xdomain_put() when it is done with the
> + * object.
> + *
> + * This will find all XDomains including the ones that are not yet
> added
> + * to the bus (handshake is still in progress).
> + *
> + * The caller needs to hold @tb->lock.
> + */
> +struct tb_xdomain *tb_xdomain_find_by_link_depth(struct tb *tb, u8
> link,
> +						Âu8 depth)
> +{
> +	struct tb_xdomain_lookup lookup;
> +	struct tb_xdomain *xd;
> +
> +	memset(&lookup, 0, sizeof(lookup));
> +	lookup.link = link;
> +	lookup.depth = depth;
> +
> +	xd = switch_find_xdomain(tb->root_switch, &lookup);
> +	if (xd) {
> +		get_device(&xd->dev);
> +		return xd;
> +	}
> +
> +	return NULL;
> +}
> +
> +bool tb_xdomain_handle_request(struct tb *tb, enum tb_cfg_pkg_type
> type,
> +			ÂÂÂÂÂÂÂconst void *buf, size_t size)
> +{
> +	const struct tb_protocol_handler *handler, *tmp;
> +	const struct tb_xdp_header *hdr = buf;
> +	unsigned int length;
> +	int ret = 0;
> +
> +	/* We expect the packet is at least size of the header */
> +	length = hdr->xd_hdr.length_sn & TB_XDOMAIN_LENGTH_MASK;
> +	if (length != size / 4 - sizeof(hdr->xd_hdr) / 4)
> +		return true;
> +	if (length < sizeof(*hdr) / 4 - sizeof(hdr->xd_hdr) / 4)
> +		return true;
> +
> +	/*
> +	Â* Handle XDomain discovery protocol packets directly here.
> For
> +	Â* other protocols (based on their UUID) we call registered
> +	Â* handlers in turn.
> +	Â*/
> +	if (uuid_equal(&hdr->uuid, &tb_xdp_uuid)) {
> +		if (type == TB_CFG_PKG_XDOMAIN_REQ) {
> +			tb_xdp_schedule_request(tb, hdr, size);
> +			return true;
> +		}
> +		return false;
> +	}
> +
> +	mutex_lock(&xdomain_lock);
> +	list_for_each_entry_safe(handler, tmp, &protocol_handlers,
> list) {
> +		if (!uuid_equal(&hdr->uuid, handler->uuid))
> +			continue;
> +
> +		mutex_unlock(&xdomain_lock);
> +		ret = handler->callback(buf, size, handler->data);
> +		mutex_lock(&xdomain_lock);
> +
> +		if (ret)
> +			break;
> +	}
> +	mutex_unlock(&xdomain_lock);
> +
> +	return ret > 0;
> +}
> +
> +static int rebuild_property_block(void)
> +{
> +	u32 *block, len;
> +	int ret;
> +
> +	ret = tb_property_format_dir(xdomain_property_dir, NULL, 0);
> +	if (ret < 0)
> +		return ret;
> +
> +	len = ret;
> +
> +	block = kcalloc(len, sizeof(u32), GFP_KERNEL);
> +	if (!block)
> +		return -ENOMEM;
> +
> +	ret = tb_property_format_dir(xdomain_property_dir, block,
> len);
> +	if (ret) {
> +		kfree(block);
> +		return ret;
> +	}
> +
> +	kfree(xdomain_property_block);
> +	xdomain_property_block = block;
> +	xdomain_property_block_len = len;
> +	xdomain_property_block_gen++;
> +
> +	return 0;
> +}
> +
> +static int update_xdomain(struct device *dev, void *data)
> +{
> +	struct tb_xdomain *xd;
> +
> +	xd = tb_to_xdomain(dev);
> +	if (xd) {
> +		queue_delayed_work(xd->tb->wq, &xd-
> >properties_changed_work,
> +				ÂÂÂmsecs_to_jiffies(50));
> +	}
> +
> +	return 0;
> +}
> +
> +static void update_all_xdomains(void)
> +{
> +	bus_for_each_dev(&tb_bus_type, NULL, NULL, update_xdomain);
> +}
> +
> +static bool remove_directory(const char *key, const struct
> tb_property_dir *dir)
> +{
> +	struct tb_property *p;
> +
> +	p = tb_property_find(xdomain_property_dir, key,
> +			ÂÂÂÂÂTB_PROPERTY_TYPE_DIRECTORY);
> +	if (p && p->value.dir == dir) {
> +		tb_property_remove(p);
> +		return true;
> +	}
> +	return false;
> +}
> +
> +/**
> + * tb_register_property_dir() - Register property directory to the
> host
> + * @key: Key (name) of the directory to add
> + * @dir: Directory to add
> + *
> + * Service drivers can use this function to add new property
> directory
> + * to the host available properties. The other connected hosts are
> + * notified so they can re-read properties of this host if they are
> + * interested.
> + *
> + * Return: %0 on success and negative errno on failure
> + */
> +int tb_register_property_dir(const char *key, struct tb_property_dir
> *dir)
> +{
> +	int ret;
> +
> +	if (!key || strlen(key) > 8)
> +		return -EINVAL;
> +
> +	mutex_lock(&xdomain_lock);
> +	if (tb_property_find(xdomain_property_dir, key,
> +			ÂÂÂÂÂTB_PROPERTY_TYPE_DIRECTORY)) {
> +		ret = -EEXIST;
> +		goto err_unlock;
> +	}
> +
> +	ret = tb_property_add_dir(xdomain_property_dir, key, dir);
> +	if (ret)
> +		goto err_unlock;
> +
> +	ret = rebuild_property_block();
> +	if (ret) {
> +		remove_directory(key, dir);
> +		goto err_unlock;
> +	}
> +
> +	mutex_unlock(&xdomain_lock);
> +	update_all_xdomains();
> +	return 0;
> +
> +err_unlock:
> +	mutex_unlock(&xdomain_lock);
> +	return ret;
> +}
> +EXPORT_SYMBOL_GPL(tb_register_property_dir);
> +
> +/**
> + * tb_unregister_property_dir() - Removes property directory from
> host
> + * @key: Key (name) of the directory
> + * @dir: Directory to remove
> + *
> + * This will remove the existing directory from this host and notify
> the
> + * connected hosts about the change.
> + */
> +void tb_unregister_property_dir(const char *key, struct
> tb_property_dir *dir)
> +{
> +	int ret = 0;
> +
> +	mutex_lock(&xdomain_lock);
> +	if (remove_directory(key, dir))
> +		ret = rebuild_property_block();
> +	mutex_unlock(&xdomain_lock);
> +
> +	if (!ret)
> +		update_all_xdomains();
> +}
> +EXPORT_SYMBOL_GPL(tb_unregister_property_dir);
> +
> +int tb_xdomain_init(void)
> +{
> +	int ret;
> +
> +	xdomain_property_dir = tb_property_create_dir(NULL);
> +	if (!xdomain_property_dir)
> +		return -ENOMEM;
> +
> +	/*
> +	Â* Initialize standard set of properties without any service
> +	Â* directories. Those will be added by service drivers
> +	Â* themselves when they are loaded.
> +	Â*/
> +	tb_property_add_immediate(xdomain_property_dir, "vendorid",
> +				ÂÂPCI_VENDOR_ID_INTEL);
> +	tb_property_add_text(xdomain_property_dir, "vendorid",
> "Intel Corp.");
> +	tb_property_add_immediate(xdomain_property_dir, "deviceid",
> 0x1);
> +	tb_property_add_text(xdomain_property_dir, "deviceid",
> +			ÂÂÂÂÂutsname()->nodename);
> +	tb_property_add_immediate(xdomain_property_dir, "devicerv",
> 0x80000100);
> +
> +	ret = rebuild_property_block();
> +	if (ret) {
> +		tb_property_free_dir(xdomain_property_dir);
> +		xdomain_property_dir = NULL;
> +	}
> +
> +	return ret;
> +}
> +
> +void tb_xdomain_exit(void)
> +{
> +	kfree(xdomain_property_block);
> +	tb_property_free_dir(xdomain_property_dir);
> +}
> diff --git a/include/linux/mod_devicetable.h
> b/include/linux/mod_devicetable.h
> index 694cebb50f72..7625c3b81f84 100644
> --- a/include/linux/mod_devicetable.h
> +++ b/include/linux/mod_devicetable.h
> @@ -683,5 +683,31 @@ struct fsl_mc_device_id {
> Â	const char obj_type[16];
> Â};
> Â
> +/**
> + * struct tb_service_id - Thunderbolt service identifiers
> + * @match_flags: Flags used to match the structure
> + * @protocol_key: Protocol key the service supports
> + * @protocol_id: Protocol id the service supports
> + * @protocol_version: Version of the protocol
> + * @protocol_revision: Revision of the protocol software
> + * @driver_data: Driver specific data
> + *
> + * Thunderbolt XDomain services are exposed as devices where each
> device
> + * carries the protocol information the service supports.
> Thunderbolt
> + * XDomain service drivers match against that information.
> + */
> +struct tb_service_id {
> +	__u32 match_flags;
> +	char protocol_key[8 + 1];
> +	__u32 protocol_id;
> +	__u32 protocol_version;
> +	__u32 protocol_revision;
> +	kernel_ulong_t driver_data;
> +};
> +
> +#define TBSVC_MATCH_PROTOCOL_KEY	0x0001
> +#define TBSVC_MATCH_PROTOCOL_ID		0x0002
> +#define TBSVC_MATCH_PROTOCOL_VERSION	0x0004
> +#define TBSVC_MATCH_PROTOCOL_REVISION	0x0008
> Â
> Â#endif /* LINUX_MOD_DEVICETABLE_H */
> diff --git a/include/linux/thunderbolt.h
> b/include/linux/thunderbolt.h
> index 4011d6537a8c..79abdaf1c296 100644
> --- a/include/linux/thunderbolt.h
> +++ b/include/linux/thunderbolt.h
> @@ -17,6 +17,7 @@
> Â#include <linux/device.h>
> Â#include <linux/list.h>
> Â#include <linux/mutex.h>
> +#include <linux/mod_devicetable.h>
> Â#include <linux/uuid.h>
> Â
> Âenum tb_cfg_pkg_type {
> @@ -77,6 +78,8 @@ struct tb {
> Â};
> Â
> Âextern struct bus_type tb_bus_type;
> +extern struct device_type tb_service_type;
> +extern struct device_type tb_xdomain_type;
> Â
> Â#define TB_LINKS_PER_PHY_PORT	2
> Â
> @@ -155,4 +158,243 @@ struct tb_property *tb_property_get_next(struct
> tb_property_dir *dir,
> Â	ÂÂÂÂÂproperty;						
> \
> Â	ÂÂÂÂÂproperty = tb_property_get_next(dir, property))
> Â
> +int tb_register_property_dir(const char *key, struct tb_property_dir
> *dir);
> +void tb_unregister_property_dir(const char *key, struct
> tb_property_dir *dir);
> +
> +/**
> + * struct tb_xdomain - Cross-domain (XDomain) connection
> + * @dev: XDomain device
> + * @tb: Pointer to the domain
> + * @remote_uuid: UUID of the remote domain (host)
> + * @local_uuid: Cached local UUID
> + * @route: Route string the other domain can be reached
> + * @vendor: Vendor ID of the remote domain
> + * @device: Device ID of the demote domain
> + * @lock: Lock to serialize access to the following fields of this
> structure
> + * @vendor_name: Name of the vendor (or %NULL if not known)
> + * @device_name: Name of the device (or %NULL if not known)
> + * @is_unplugged: The XDomain is unplugged
> + * @resume: The XDomain is being resumed
> + * @transmit_path: HopID which the remote end expects us to transmit
> + * @transmit_ring: Local ring (hop) where outgoing packets are
> pushed
> + * @receive_path: HopID which we expect the remote end to transmit
> + * @receive_ring: Local ring (hop) where incoming packets arrive
> + * @service_ids: Used to generate IDs for the services
> + * @properties: Properties exported by the remote domain
> + * @property_block_gen: Generation of @properties
> + * @properties_lock: Lock protecting @properties.
> + * @get_properties_work: Work used to get remote domain properties
> + * @properties_retries: Number of times left to read properties
> + * @properties_changed_work: Work used to notify the remote domain
> that
> + *			ÂÂÂÂÂour properties have changed
> + * @properties_changed_retries: Number of times left to send
> properties
> + *				changed notification
> + * @link: Root switch link the remote domain is connected (ICM only)
> + * @depth: Depth in the chain the remote domain is connected (ICM
> only)
> + *
> + * This structure represents connection across two domains (hosts).
> + * Each XDomain contains zero or more services which are exposed as
> + * &struct tb_service objects.
> + *
> + * Service drivers may access this structure if they need to
> enumerate
> + * non-standard properties but they need hold @lock when doing so
> + * because properties can be changed asynchronously in response to
> + * changes in the remote domain.
> + */
> +struct tb_xdomain {
> +	struct device dev;
> +	struct tb *tb;
> +	uuid_t *remote_uuid;
> +	const uuid_t *local_uuid;
> +	u64 route;
> +	u16 vendor;
> +	u16 device;
> +	struct mutex lock;
> +	const char *vendor_name;
> +	const char *device_name;
> +	bool is_unplugged;
> +	bool resume;
> +	u16 transmit_path;
> +	u16 transmit_ring;
> +	u16 receive_path;
> +	u16 receive_ring;
> +	struct ida service_ids;
> +	struct tb_property_dir *properties;
> +	u32 property_block_gen;
> +	struct delayed_work get_properties_work;
> +	int properties_retries;
> +	struct delayed_work properties_changed_work;
> +	int properties_changed_retries;
> +	u8 link;
> +	u8 depth;
> +};
> +
> +int tb_xdomain_enable_paths(struct tb_xdomain *xd, u16
> transmit_path,
> +			ÂÂÂÂu16 transmit_ring, u16 receive_path,
> +			ÂÂÂÂu16 receive_ring);
> +int tb_xdomain_disable_paths(struct tb_xdomain *xd);
> +struct tb_xdomain *tb_xdomain_find_by_uuid(struct tb *tb, const
> uuid_t *uuid);
> +
> +static inline struct tb_xdomain *
> +tb_xdomain_find_by_uuid_locked(struct tb *tb, const uuid_t *uuid)
> +{
> +	struct tb_xdomain *xd;
> +
> +	mutex_lock(&tb->lock);
> +	xd = tb_xdomain_find_by_uuid(tb, uuid);
> +	mutex_unlock(&tb->lock);
> +
> +	return xd;
> +}
> +
> +static inline struct tb_xdomain *tb_xdomain_get(struct tb_xdomain
> *xd)
> +{
> +	if (xd)
> +		get_device(&xd->dev);
> +	return xd;
> +}
> +
> +static inline void tb_xdomain_put(struct tb_xdomain *xd)
> +{
> +	if (xd)
> +		put_device(&xd->dev);
> +}
> +
> +static inline bool tb_is_xdomain(const struct device *dev)
> +{
> +	return dev->type == &tb_xdomain_type;
> +}
> +
> +static inline struct tb_xdomain *tb_to_xdomain(struct device *dev)
> +{
> +	if (tb_is_xdomain(dev))
> +		return container_of(dev, struct tb_xdomain, dev);
> +	return NULL;
> +}
> +
> +int tb_xdomain_response(struct tb_xdomain *xd, const void *response,
> +			size_t size, enum tb_cfg_pkg_type type);
> +int tb_xdomain_request(struct tb_xdomain *xd, const void *request,
> +		ÂÂÂÂÂÂÂsize_t request_size, enum tb_cfg_pkg_type
> request_type,
> +		ÂÂÂÂÂÂÂvoid *response, size_t response_size,
> +		ÂÂÂÂÂÂÂenum tb_cfg_pkg_type response_type,
> +		ÂÂÂÂÂÂÂunsigned int timeout_msec);
> +
> +/**
> + * tb_protocol_handler - Protocol specific handler
> + * @uuid: XDomain messages with this UUID are dispatched to this
> handler
> + * @callback: Callback called with the XDomain message. Returning %1
> + *	ÂÂÂÂÂÂhere tells the XDomain core that the message was
> handled
> + *	ÂÂÂÂÂÂby this handler and should not be forwared to other
> + *	ÂÂÂÂÂÂhandlers.
> + * @data: Data passed with the callback
> + * @list: Handlers are linked using this
> + *
> + * Thunderbolt services can hook into incoming XDomain requests by
> + * registering protocol handler. Only limitation is that the XDomain
> + * discovery protocol UUID cannot be registered since it is handled
> by
> + * the core XDomain code.
> + *
> + * The @callback must check that the message is really directed to
> the
> + * service the driver implements.
> + */
> +struct tb_protocol_handler {
> +	const uuid_t *uuid;
> +	int (*callback)(const void *buf, size_t size, void *data);
> +	void *data;
> +	struct list_head list;
> +};
> +
> +int tb_register_protocol_handler(struct tb_protocol_handler
> *handler);
> +void tb_unregister_protocol_handler(struct tb_protocol_handler
> *handler);
> +
> +/**
> + * struct tb_service - Thunderbolt service
> + * @dev: XDomain device
> + * @id: ID of the service (shown in sysfs)
> + * @key: Protocol key from the properties directory
> + * @prtcid: Protocol ID from the properties directory
> + * @prtcvers: Protocol version from the properties directory
> + * @prtcrevs: Protocol software revision from the properties
> directory
> + * @prtcstns: Protocol settings mask from the properties directory
> + *
> + * Each domain exposes set of services it supports as collection of
> + * properties. For each service there will be one corresponding
> + * &struct tb_service. Service drivers are bound to these.
> + */
> +struct tb_service {
> +	struct device dev;
> +	int id;
> +	const char *key;
> +	u32 prtcid;
> +	u32 prtcvers;
> +	u32 prtcrevs;
> +	u32 prtcstns;
> +};
> +
> +static inline struct tb_service *tb_service_get(struct tb_service
> *svc)
> +{
> +	if (svc)
> +		get_device(&svc->dev);
> +	return svc;
> +}
> +
> +static inline void tb_service_put(struct tb_service *svc)
> +{
> +	if (svc)
> +		put_device(&svc->dev);
> +}
> +
> +static inline bool tb_is_service(const struct device *dev)
> +{
> +	return dev->type == &tb_service_type;
> +}
> +
> +static inline struct tb_service *tb_to_service(struct device *dev)
> +{
> +	if (tb_is_service(dev))
> +		return container_of(dev, struct tb_service, dev);
> +	return NULL;
> +}
> +
> +/**
> + * tb_service_driver - Thunderbolt service driver
> + * @driver: Driver structure
> + * @probe: Called when the driver is probed
> + * @remove: Called when the driver is removed (optional)
> + * @shutdown: Called at shutdown time to stop the service (optional)
> + * @id_table: Table of service identifiers the driver supports
> + */
> +struct tb_service_driver {
> +	struct device_driver driver;
> +	int (*probe)(struct tb_service *svc, const struct
> tb_service_id *id);
> +	void (*remove)(struct tb_service *svc);
> +	void (*shutdown)(struct tb_service *svc);
> +	const struct tb_service_id *id_table;
> +};
> +
> +#define TB_SERVICE(key, id)				\
> +	.match_flags = TBSVC_MATCH_PROTOCOL_KEY |	\
> +		ÂÂÂÂÂÂÂTBSVC_MATCH_PROTOCOL_ID,		\
> +	.protocol_key = (key),				\
> +	.protocol_id = (id)
> +
> +int tb_register_service_driver(struct tb_service_driver *drv);
> +void tb_unregister_service_driver(struct tb_service_driver *drv);
> +
> +static inline void *tb_service_get_drvdata(const struct tb_service
> *svc)
> +{
> +	return dev_get_drvdata(&svc->dev);
> +}
> +
> +static inline void tb_service_set_drvdata(struct tb_service *svc,
> void *data)
> +{
> +	dev_set_drvdata(&svc->dev, data);
> +}
> +
> +static inline struct tb_xdomain *tb_service_parent(struct tb_service
> *svc)
> +{
> +	return tb_to_xdomain(svc->dev.parent);
> +}
> +
> Â#endif /* THUNDERBOLT_H_ */
> diff --git a/scripts/mod/devicetable-offsets.c
> b/scripts/mod/devicetable-offsets.c
> index e4d90e50f6fe..57263f2f8f2f 100644
> --- a/scripts/mod/devicetable-offsets.c
> +++ b/scripts/mod/devicetable-offsets.c
> @@ -206,5 +206,12 @@ int main(void)
> Â	DEVID_FIELD(fsl_mc_device_id, vendor);
> Â	DEVID_FIELD(fsl_mc_device_id, obj_type);
> Â
> +	DEVID(tb_service_id);
> +	DEVID_FIELD(tb_service_id, match_flags);
> +	DEVID_FIELD(tb_service_id, protocol_key);
> +	DEVID_FIELD(tb_service_id, protocol_id);
> +	DEVID_FIELD(tb_service_id, protocol_version);
> +	DEVID_FIELD(tb_service_id, protocol_revision);
> +
> Â	return 0;
> Â}
> diff --git a/scripts/mod/file2alias.c b/scripts/mod/file2alias.c
> index 29d6699d5a06..6ef6e63f96fd 100644
> --- a/scripts/mod/file2alias.c
> +++ b/scripts/mod/file2alias.c
> @@ -1301,6 +1301,31 @@ static int do_fsl_mc_entry(const char
> *filename, void *symval,
> Â}
> ÂADD_TO_DEVTABLE("fslmc", fsl_mc_device_id, do_fsl_mc_entry);
> Â
> +/* Looks like: tbsvc:kSpNvNrN */
> +static int do_tbsvc_entry(const char *filename, void *symval, char
> *alias)
> +{
> +	DEF_FIELD(symval, tb_service_id, match_flags);
> +	DEF_FIELD_ADDR(symval, tb_service_id, protocol_key);
> +	DEF_FIELD(symval, tb_service_id, protocol_id);
> +	DEF_FIELD(symval, tb_service_id, protocol_version);
> +	DEF_FIELD(symval, tb_service_id, protocol_revision);
> +
> +	strcpy(alias, "tbsvc:");
> +	if (match_flags & TBSVC_MATCH_PROTOCOL_KEY)
> +		sprintf(alias + strlen(alias), "k%s",
> *protocol_key);
> +	else
> +		strcat(alias + strlen(alias), "k*");
> +	ADD(alias, "p", match_flags & TBSVC_MATCH_PROTOCOL_ID,
> protocol_id);
> +	ADD(alias, "v", match_flags & TBSVC_MATCH_PROTOCOL_VERSION,
> +	ÂÂÂÂprotocol_version);
> +	ADD(alias, "r", match_flags & TBSVC_MATCH_PROTOCOL_REVISION,
> +	ÂÂÂÂprotocol_revision);
> +
> +	add_wildcard(alias);
> +	return 1;
> +}
> +ADD_TO_DEVTABLE("tbsvc", tb_service_id, do_tbsvc_entry);
> +
> Â/* Does namelen bytes of name exactly match the symbol? */
> Âstatic bool sym_is(const char *name, unsigned namelen, const char
> *symbol)
> Â{