Merge tag 'trace-printf-v6.13' of git://git.kernel.org/pub/scm/linux/kernel/git/trace...

[drm/drm-misc.git] / drivers / thunderbolt / xdomain.c

// SPDX-License-Identifier: GPL-2.0
/*
 * Thunderbolt XDomain discovery protocol support
 *
 * Copyright (C) 2017, Intel Corporation
 * Authors: Michael Jamet <michael.jamet@intel.com>
 *          Mika Westerberg <mika.westerberg@linux.intel.com>
 */

#include <linux/device.h>
#include <linux/delay.h>
#include <linux/kmod.h>
#include <linux/module.h>
#include <linux/pm_runtime.h>
#include <linux/prandom.h>
#include <linux/string_helpers.h>
#include <linux/utsname.h>
#include <linux/uuid.h>
#include <linux/workqueue.h>

#include "tb.h"

#define XDOMAIN_SHORT_TIMEOUT                   100     /* ms */
#define XDOMAIN_DEFAULT_TIMEOUT                 1000    /* ms */
#define XDOMAIN_BONDING_TIMEOUT                 10000   /* ms */
#define XDOMAIN_RETRIES                         10
#define XDOMAIN_DEFAULT_MAX_HOPID               15

enum {
        XDOMAIN_STATE_INIT,
        XDOMAIN_STATE_UUID,
        XDOMAIN_STATE_LINK_STATUS,
        XDOMAIN_STATE_LINK_STATE_CHANGE,
        XDOMAIN_STATE_LINK_STATUS2,
        XDOMAIN_STATE_BONDING_UUID_LOW,
        XDOMAIN_STATE_BONDING_UUID_HIGH,
        XDOMAIN_STATE_PROPERTIES,
        XDOMAIN_STATE_ENUMERATED,
        XDOMAIN_STATE_ERROR,
};

static const char * const state_names[] = {
        [XDOMAIN_STATE_INIT] = "INIT",
        [XDOMAIN_STATE_UUID] = "UUID",
        [XDOMAIN_STATE_LINK_STATUS] = "LINK_STATUS",
        [XDOMAIN_STATE_LINK_STATE_CHANGE] = "LINK_STATE_CHANGE",
        [XDOMAIN_STATE_LINK_STATUS2] = "LINK_STATUS2",
        [XDOMAIN_STATE_BONDING_UUID_LOW] = "BONDING_UUID_LOW",
        [XDOMAIN_STATE_BONDING_UUID_HIGH] = "BONDING_UUID_HIGH",
        [XDOMAIN_STATE_PROPERTIES] = "PROPERTIES",
        [XDOMAIN_STATE_ENUMERATED] = "ENUMERATED",
        [XDOMAIN_STATE_ERROR] = "ERROR",
};

struct xdomain_request_work {
        struct work_struct work;
        struct tb_xdp_header *pkg;
        struct tb *tb;
};

static bool tb_xdomain_enabled = true;
module_param_named(xdomain, tb_xdomain_enabled, bool, 0444);
MODULE_PARM_DESC(xdomain, "allow XDomain protocol (default: true)");

/*
 * Serializes access to the properties and protocol handlers below. If
 * you need to take both this lock and the struct tb_xdomain lock, take
 * this one first.
 */
static DEFINE_MUTEX(xdomain_lock);

/* Properties exposed to the remote domains */
static struct tb_property_dir *xdomain_property_dir;
static u32 xdomain_property_block_gen;

/* Additional protocol handlers */
static LIST_HEAD(protocol_handlers);

/* UUID for XDomain discovery protocol: b638d70e-42ff-40bb-97c2-90e2c0b2ff07 */
static const uuid_t tb_xdp_uuid =
        UUID_INIT(0xb638d70e, 0x42ff, 0x40bb,
                  0x97, 0xc2, 0x90, 0xe2, 0xc0, 0xb2, 0xff, 0x07);

bool tb_is_xdomain_enabled(void)
{
        return tb_xdomain_enabled && tb_acpi_is_xdomain_allowed();
}

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;

                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;

                /* 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_error_response *res)
{
        if (res->hdr.type != ERROR_RESPONSE)
                return 0;

        switch (res->error) {
        case ERROR_UNKNOWN_PACKET:
        case ERROR_UNKNOWN_DOMAIN:
                return -EIO;
        case ERROR_NOT_SUPPORTED:
                return -EOPNOTSUPP;
        case ERROR_NOT_READY:
                return -EAGAIN;
        default:
                break;
        }

        return 0;
}

static int tb_xdp_uuid_request(struct tb_ctl *ctl, u64 route, int retry,
                               uuid_t *uuid, u64 *remote_route)
{
        struct tb_xdp_uuid_response res;
        struct tb_xdp_uuid req;
        int ret;

        memset(&req, 0, sizeof(req));
        tb_xdp_fill_header(&req.hdr, route, retry % 4, UUID_REQUEST,
                           sizeof(req));

        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;

        ret = tb_xdp_handle_error(&res.err);
        if (ret)
                return ret;

        uuid_copy(uuid, &res.src_uuid);
        *remote_route = (u64)res.src_route_hi << 32 | res.src_route_lo;

        return 0;
}

static int tb_xdp_uuid_response(struct tb_ctl *ctl, u64 route, u8 sequence,
                                const uuid_t *uuid)
{
        struct tb_xdp_uuid_response res;

        memset(&res, 0, sizeof(res));
        tb_xdp_fill_header(&res.hdr, route, sequence, UUID_RESPONSE,
                           sizeof(res));

        uuid_copy(&res.src_uuid, uuid);
        res.src_route_hi = upper_32_bits(route);
        res.src_route_lo = lower_32_bits(route);

        return __tb_xdomain_response(ctl, &res, sizeof(res),
                                     TB_CFG_PKG_XDOMAIN_RESP);
}

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));

        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->err);
                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,
        struct tb_xdomain *xd, u8 sequence, 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(xd->local_uuid, &req->dst_uuid)) {
                tb_xdp_error_response(ctl, xd->route, sequence,
                                      ERROR_UNKNOWN_DOMAIN);
                return 0;
        }

        mutex_lock(&xd->lock);

        if (req->offset >= xd->local_property_block_len) {
                mutex_unlock(&xd->lock);
                return -EINVAL;
        }

        len = xd->local_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(&xd->lock);
                return -ENOMEM;
        }

        tb_xdp_fill_header(&res->hdr, xd->route, sequence, PROPERTIES_RESPONSE,
                           total_size);
        res->generation = xd->local_property_block_gen;
        res->data_length = xd->local_property_block_len;
        res->offset = req->offset;
        uuid_copy(&res->src_uuid, xd->local_uuid);
        uuid_copy(&res->dst_uuid, &req->src_uuid);
        memcpy(res->data, &xd->local_property_block[req->offset], len * 4);

        mutex_unlock(&xd->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.err);
}

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);
}

static int tb_xdp_link_state_status_request(struct tb_ctl *ctl, u64 route,
                                            u8 sequence, u8 *slw, u8 *tlw,
                                            u8 *sls, u8 *tls)
{
        struct tb_xdp_link_state_status_response res;
        struct tb_xdp_link_state_status req;
        int ret;

        memset(&req, 0, sizeof(req));
        tb_xdp_fill_header(&req.hdr, route, sequence, LINK_STATE_STATUS_REQUEST,
                           sizeof(req));

        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;

        ret = tb_xdp_handle_error(&res.err);
        if (ret)
                return ret;

        if (res.status != 0)
                return -EREMOTEIO;

        *slw = res.slw;
        *tlw = res.tlw;
        *sls = res.sls;
        *tls = res.tls;

        return 0;
}

static int tb_xdp_link_state_status_response(struct tb *tb, struct tb_ctl *ctl,
                                             struct tb_xdomain *xd, u8 sequence)
{
        struct tb_xdp_link_state_status_response res;
        struct tb_port *port = tb_xdomain_downstream_port(xd);
        u32 val[2];
        int ret;

        memset(&res, 0, sizeof(res));
        tb_xdp_fill_header(&res.hdr, xd->route, sequence,
                           LINK_STATE_STATUS_RESPONSE, sizeof(res));

        ret = tb_port_read(port, val, TB_CFG_PORT,
                           port->cap_phy + LANE_ADP_CS_0, ARRAY_SIZE(val));
        if (ret)
                return ret;

        res.slw = (val[0] & LANE_ADP_CS_0_SUPPORTED_WIDTH_MASK) >>
                        LANE_ADP_CS_0_SUPPORTED_WIDTH_SHIFT;
        res.sls = (val[0] & LANE_ADP_CS_0_SUPPORTED_SPEED_MASK) >>
                        LANE_ADP_CS_0_SUPPORTED_SPEED_SHIFT;
        res.tls = val[1] & LANE_ADP_CS_1_TARGET_SPEED_MASK;
        res.tlw = (val[1] & LANE_ADP_CS_1_TARGET_WIDTH_MASK) >>
                        LANE_ADP_CS_1_TARGET_WIDTH_SHIFT;

        return __tb_xdomain_response(ctl, &res, sizeof(res),
                                     TB_CFG_PKG_XDOMAIN_RESP);
}

static int tb_xdp_link_state_change_request(struct tb_ctl *ctl, u64 route,
                                            u8 sequence, u8 tlw, u8 tls)
{
        struct tb_xdp_link_state_change_response res;
        struct tb_xdp_link_state_change req;
        int ret;

        memset(&req, 0, sizeof(req));
        tb_xdp_fill_header(&req.hdr, route, sequence, LINK_STATE_CHANGE_REQUEST,
                           sizeof(req));
        req.tlw = tlw;
        req.tls = tls;

        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;

        ret = tb_xdp_handle_error(&res.err);
        if (ret)
                return ret;

        return res.status != 0 ? -EREMOTEIO : 0;
}

static int tb_xdp_link_state_change_response(struct tb_ctl *ctl, u64 route,
                                             u8 sequence, u32 status)
{
        struct tb_xdp_link_state_change_response res;

        memset(&res, 0, sizeof(res));
        tb_xdp_fill_header(&res.hdr, route, sequence, LINK_STATE_CHANGE_RESPONSE,
                           sizeof(res));

        res.status = status;

        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 update_property_block(struct tb_xdomain *xd)
{
        mutex_lock(&xdomain_lock);
        mutex_lock(&xd->lock);
        /*
         * If the local property block is not up-to-date, rebuild it now
         * based on the global property template.
         */
        if (!xd->local_property_block ||
            xd->local_property_block_gen < xdomain_property_block_gen) {
                struct tb_property_dir *dir;
                int ret, block_len;
                u32 *block;

                dir = tb_property_copy_dir(xdomain_property_dir);
                if (!dir) {
                        dev_warn(&xd->dev, "failed to copy properties\n");
                        goto out_unlock;
                }

                /* Fill in non-static properties now */
                tb_property_add_text(dir, "deviceid", utsname()->nodename);
                tb_property_add_immediate(dir, "maxhopid", xd->local_max_hopid);

                ret = tb_property_format_dir(dir, NULL, 0);
                if (ret < 0) {
                        dev_warn(&xd->dev, "local property block creation failed\n");
                        tb_property_free_dir(dir);
                        goto out_unlock;
                }

                block_len = ret;
                block = kcalloc(block_len, sizeof(*block), GFP_KERNEL);
                if (!block) {
                        tb_property_free_dir(dir);
                        goto out_unlock;
                }

                ret = tb_property_format_dir(dir, block, block_len);
                if (ret) {
                        dev_warn(&xd->dev, "property block generation failed\n");
                        tb_property_free_dir(dir);
                        kfree(block);
                        goto out_unlock;
                }

                tb_property_free_dir(dir);
                /* Release the previous block */
                kfree(xd->local_property_block);
                /* Assign new one */
                xd->local_property_block = block;
                xd->local_property_block_len = block_len;
                xd->local_property_block_gen = xdomain_property_block_gen;
        }

out_unlock:
        mutex_unlock(&xd->lock);
        mutex_unlock(&xdomain_lock);
}

static void start_handshake(struct tb_xdomain *xd)
{
        xd->state = XDOMAIN_STATE_INIT;
        queue_delayed_work(xd->tb->wq, &xd->state_work,
                           msecs_to_jiffies(XDOMAIN_SHORT_TIMEOUT));
}

/* Can be called from state_work */
static void __stop_handshake(struct tb_xdomain *xd)
{
        cancel_delayed_work_sync(&xd->properties_changed_work);
        xd->properties_changed_retries = 0;
        xd->state_retries = 0;
}

static void stop_handshake(struct tb_xdomain *xd)
{
        cancel_delayed_work_sync(&xd->state_work);
        __stop_handshake(xd);
}

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;
        struct tb_xdomain *xd;
        const uuid_t *uuid;
        int ret = 0;
        u32 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;
        }

        xd = tb_xdomain_find_by_route_locked(tb, route);
        if (xd)
                update_property_block(xd);

        switch (pkg->type) {
        case PROPERTIES_REQUEST:
                tb_dbg(tb, "%llx: received XDomain properties request\n", route);
                if (xd) {
                        ret = tb_xdp_properties_response(tb, ctl, xd, sequence,
                                (const struct tb_xdp_properties *)pkg);
                }
                break;

        case PROPERTIES_CHANGED_REQUEST:
                tb_dbg(tb, "%llx: received XDomain properties changed request\n",
                       route);

                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.
                 */
                if (xd && device_is_registered(&xd->dev))
                        queue_delayed_work(tb->wq, &xd->state_work,
                                           msecs_to_jiffies(XDOMAIN_SHORT_TIMEOUT));
                break;

        case UUID_REQUEST_OLD:
        case UUID_REQUEST:
                tb_dbg(tb, "%llx: received XDomain UUID request\n", route);
                ret = tb_xdp_uuid_response(ctl, route, sequence, uuid);
                /*
                 * If we've stopped the discovery with an error such as
                 * timing out, we will restart the handshake now that we
                 * received UUID request from the remote host.
                 */
                if (!ret && xd && xd->state == XDOMAIN_STATE_ERROR) {
                        dev_dbg(&xd->dev, "restarting handshake\n");
                        start_handshake(xd);
                }
                break;

        case LINK_STATE_STATUS_REQUEST:
                tb_dbg(tb, "%llx: received XDomain link state status request\n",
                       route);

                if (xd) {
                        ret = tb_xdp_link_state_status_response(tb, ctl, xd,
                                                                sequence);
                } else {
                        tb_xdp_error_response(ctl, route, sequence,
                                              ERROR_NOT_READY);
                }
                break;

        case LINK_STATE_CHANGE_REQUEST:
                tb_dbg(tb, "%llx: received XDomain link state change request\n",
                       route);

                if (xd && xd->state == XDOMAIN_STATE_BONDING_UUID_HIGH) {
                        const struct tb_xdp_link_state_change *lsc =
                                (const struct tb_xdp_link_state_change *)pkg;

                        ret = tb_xdp_link_state_change_response(ctl, route,
                                                                sequence, 0);
                        xd->target_link_width = lsc->tlw;
                        queue_delayed_work(tb->wq, &xd->state_work,
                                           msecs_to_jiffies(XDOMAIN_SHORT_TIMEOUT));
                } else {
                        tb_xdp_error_response(ctl, route, sequence,
                                              ERROR_NOT_READY);
                }
                break;

        default:
                tb_dbg(tb, "%llx: unknown XDomain request %#x\n", route, pkg->type);
                tb_xdp_error_response(ctl, route, sequence,
                                      ERROR_NOT_SUPPORTED);
                break;
        }

        tb_xdomain_put(xd);

        if (ret) {
                tb_warn(tb, "failed to send XDomain response for %#x\n",
                        pkg->type);
        }

out:
        kfree(xw->pkg);
        kfree(xw);

        tb_domain_put(tb);
}

static bool
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 false;

        INIT_WORK(&xw->work, tb_xdp_handle_request);
        xw->pkg = kmemdup(hdr, size, GFP_KERNEL);
        if (!xw->pkg) {
                kfree(xw);
                return false;
        }
        xw->tb = tb_domain_get(tb);

        schedule_work(&xw->work);
        return true;
}

/**
 * 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
 * @drv: 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 sysfs_emit(buf, "%*pE\n", (int)strlen(svc->key), svc->key);
}
static DEVICE_ATTR_RO(key);

static int get_modalias(const 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 strlen(strcat(buf, "\n"));
}
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 sysfs_emit(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 sysfs_emit(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 sysfs_emit(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 sysfs_emit(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 const 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(const struct device *dev, struct kobj_uevent_env *env)
{
        const struct tb_service *svc = container_of_const(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);

        tb_service_debugfs_remove(svc);
        ida_free(&xd->service_ids, svc->id);
        kfree(svc->key);
        kfree(svc);
}

const 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->remote_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;
        int id;

        /*
         * 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->remote_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;
                }

                id = ida_alloc(&xd->service_ids, GFP_KERNEL);
                if (id < 0) {
                        kfree(svc->key);
                        kfree(svc);
                        break;
                }
                svc->id = id;
                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);

                tb_service_debugfs_init(svc);

                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;

        p = tb_property_find(dir, "maxhopid", TB_PROPERTY_TYPE_VALUE);
        /*
         * USB4 inter-domain spec suggests using 15 as HopID if the
         * other end does not announce it in a property. This is for
         * TBT3 compatibility.
         */
        xd->remote_max_hopid = p ? p->value.immediate : XDOMAIN_DEFAULT_MAX_HOPID;

        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;
}

static int tb_xdomain_update_link_attributes(struct tb_xdomain *xd)
{
        bool change = false;
        struct tb_port *port;
        int ret;

        port = tb_xdomain_downstream_port(xd);

        ret = tb_port_get_link_speed(port);
        if (ret < 0)
                return ret;

        if (xd->link_speed != ret)
                change = true;

        xd->link_speed = ret;

        ret = tb_port_get_link_width(port);
        if (ret < 0)
                return ret;

        if (xd->link_width != ret)
                change = true;

        xd->link_width = ret;

        if (change)
                kobject_uevent(&xd->dev.kobj, KOBJ_CHANGE);

        return 0;
}

static int tb_xdomain_get_uuid(struct tb_xdomain *xd)
{
        struct tb *tb = xd->tb;
        uuid_t uuid;
        u64 route;
        int ret;

        dev_dbg(&xd->dev, "requesting remote UUID\n");

        ret = tb_xdp_uuid_request(tb->ctl, xd->route, xd->state_retries, &uuid,
                                  &route);
        if (ret < 0) {
                if (xd->state_retries-- > 0) {
                        dev_dbg(&xd->dev, "failed to request UUID, retrying\n");
                        return -EAGAIN;
                }
                dev_dbg(&xd->dev, "failed to read remote UUID\n");
                return ret;
        }

        dev_dbg(&xd->dev, "got remote UUID %pUb\n", &uuid);

        if (uuid_equal(&uuid, xd->local_uuid)) {
                if (route == xd->route)
                        dev_dbg(&xd->dev, "loop back detected\n");
                else
                        dev_dbg(&xd->dev, "intra-domain loop detected\n");

                /* Don't bond lanes automatically for loops */
                xd->bonding_possible = false;
        }

        /*
         * If the UUID is different, there is another domain connected
         * so mark this one unplugged and wait for the connection
         * manager to replace it.
         */
        if (xd->remote_uuid && !uuid_equal(&uuid, xd->remote_uuid)) {
                dev_dbg(&xd->dev, "remote UUID is different, unplugging\n");
                xd->is_unplugged = true;
                return -ENODEV;
        }

        /* First time fill in the missing UUID */
        if (!xd->remote_uuid) {
                xd->remote_uuid = kmemdup(&uuid, sizeof(uuid_t), GFP_KERNEL);
                if (!xd->remote_uuid)
                        return -ENOMEM;
        }

        return 0;
}

static int tb_xdomain_get_link_status(struct tb_xdomain *xd)
{
        struct tb *tb = xd->tb;
        u8 slw, tlw, sls, tls;
        int ret;

        dev_dbg(&xd->dev, "sending link state status request to %pUb\n",
                xd->remote_uuid);

        ret = tb_xdp_link_state_status_request(tb->ctl, xd->route,
                                               xd->state_retries, &slw, &tlw, &sls,
                                               &tls);
        if (ret) {
                if (ret != -EOPNOTSUPP && xd->state_retries-- > 0) {
                        dev_dbg(&xd->dev,
                                "failed to request remote link status, retrying\n");
                        return -EAGAIN;
                }
                dev_dbg(&xd->dev, "failed to receive remote link status\n");
                return ret;
        }

        dev_dbg(&xd->dev, "remote link supports width %#x speed %#x\n", slw, sls);

        if (slw < LANE_ADP_CS_0_SUPPORTED_WIDTH_DUAL) {
                dev_dbg(&xd->dev, "remote adapter is single lane only\n");
                return -EOPNOTSUPP;
        }

        return 0;
}

static int tb_xdomain_link_state_change(struct tb_xdomain *xd,
                                        unsigned int width)
{
        struct tb_port *port = tb_xdomain_downstream_port(xd);
        struct tb *tb = xd->tb;
        u8 tlw, tls;
        u32 val;
        int ret;

        if (width == 2)
                tlw = LANE_ADP_CS_1_TARGET_WIDTH_DUAL;
        else if (width == 1)
                tlw = LANE_ADP_CS_1_TARGET_WIDTH_SINGLE;
        else
                return -EINVAL;

        /* Use the current target speed */
        ret = tb_port_read(port, &val, TB_CFG_PORT, port->cap_phy + LANE_ADP_CS_1, 1);
        if (ret)
                return ret;
        tls = val & LANE_ADP_CS_1_TARGET_SPEED_MASK;

        dev_dbg(&xd->dev, "sending link state change request with width %#x speed %#x\n",
                tlw, tls);

        ret = tb_xdp_link_state_change_request(tb->ctl, xd->route,
                                               xd->state_retries, tlw, tls);
        if (ret) {
                if (ret != -EOPNOTSUPP && xd->state_retries-- > 0) {
                        dev_dbg(&xd->dev,
                                "failed to change remote link state, retrying\n");
                        return -EAGAIN;
                }
                dev_err(&xd->dev, "failed request link state change, aborting\n");
                return ret;
        }

        dev_dbg(&xd->dev, "received link state change response\n");
        return 0;
}

static int tb_xdomain_bond_lanes_uuid_high(struct tb_xdomain *xd)
{
        unsigned int width, width_mask;
        struct tb_port *port;
        int ret;

        if (xd->target_link_width == LANE_ADP_CS_1_TARGET_WIDTH_SINGLE) {
                width = TB_LINK_WIDTH_SINGLE;
                width_mask = width;
        } else if (xd->target_link_width == LANE_ADP_CS_1_TARGET_WIDTH_DUAL) {
                width = TB_LINK_WIDTH_DUAL;
                width_mask = width | TB_LINK_WIDTH_ASYM_TX | TB_LINK_WIDTH_ASYM_RX;
        } else {
                if (xd->state_retries-- > 0) {
                        dev_dbg(&xd->dev,
                                "link state change request not received yet, retrying\n");
                        return -EAGAIN;
                }
                dev_dbg(&xd->dev, "timeout waiting for link change request\n");
                return -ETIMEDOUT;
        }

        port = tb_xdomain_downstream_port(xd);

        /*
         * We can't use tb_xdomain_lane_bonding_enable() here because it
         * is the other side that initiates lane bonding. So here we
         * just set the width to both lane adapters and wait for the
         * link to transition bonded.
         */
        ret = tb_port_set_link_width(port->dual_link_port, width);
        if (ret) {
                tb_port_warn(port->dual_link_port,
                             "failed to set link width to %d\n", width);
                return ret;
        }

        ret = tb_port_set_link_width(port, width);
        if (ret) {
                tb_port_warn(port, "failed to set link width to %d\n", width);
                return ret;
        }

        ret = tb_port_wait_for_link_width(port, width_mask,
                                          XDOMAIN_BONDING_TIMEOUT);
        if (ret) {
                dev_warn(&xd->dev, "error waiting for link width to become %d\n",
                         width_mask);
                return ret;
        }

        port->bonded = width > TB_LINK_WIDTH_SINGLE;
        port->dual_link_port->bonded = width > TB_LINK_WIDTH_SINGLE;

        tb_port_update_credits(port);
        tb_xdomain_update_link_attributes(xd);

        dev_dbg(&xd->dev, "lane bonding %s\n", str_enabled_disabled(width == 2));
        return 0;
}

static int tb_xdomain_get_properties(struct tb_xdomain *xd)
{
        struct tb_property_dir *dir;
        struct tb *tb = xd->tb;
        bool update = false;
        u32 *block = NULL;
        u32 gen = 0;
        int ret;

        dev_dbg(&xd->dev, "requesting remote properties\n");

        ret = tb_xdp_properties_request(tb->ctl, xd->route, xd->local_uuid,
                                        xd->remote_uuid, xd->state_retries,
                                        &block, &gen);
        if (ret < 0) {
                if (xd->state_retries-- > 0) {
                        dev_dbg(&xd->dev,
                                "failed to request remote properties, retrying\n");
                        return -EAGAIN;
                }
                /* Give up now */
                dev_err(&xd->dev, "failed read XDomain properties from %pUb\n",
                        xd->remote_uuid);

                return ret;
        }

        mutex_lock(&xd->lock);

        /* Only accept newer generation properties */
        if (xd->remote_properties && gen <= xd->remote_property_block_gen) {
                ret = 0;
                goto err_free_block;
        }

        dir = tb_property_parse_dir(block, ret);
        if (!dir) {
                dev_err(&xd->dev, "failed to parse XDomain properties\n");
                ret = -ENOMEM;
                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->remote_properties) {
                tb_property_free_dir(xd->remote_properties);
                update = true;
        }

        xd->remote_properties = dir;
        xd->remote_property_block_gen = gen;

        tb_xdomain_update_link_attributes(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) {
                /*
                 * Now disable lane 1 if bonding was not enabled. Do
                 * this only if bonding was possible at the beginning
                 * (that is we are the connection manager and there are
                 * two lanes).
                 */
                if (xd->bonding_possible) {
                        struct tb_port *port;

                        port = tb_xdomain_downstream_port(xd);
                        if (!port->bonded)
                                tb_port_disable(port->dual_link_port);
                }

                dev_dbg(&xd->dev, "current link speed %u.0 Gb/s\n",
                        xd->link_speed);
                dev_dbg(&xd->dev, "current link width %s\n",
                        tb_width_name(xd->link_width));

                if (device_add(&xd->dev)) {
                        dev_err(&xd->dev, "failed to add XDomain device\n");
                        return -ENODEV;
                }
                dev_info(&xd->dev, "new host found, vendor=%#x device=%#x\n",
                         xd->vendor, xd->device);
                if (xd->vendor_name && xd->device_name)
                        dev_info(&xd->dev, "%s %s\n", xd->vendor_name,
                                 xd->device_name);

                tb_xdomain_debugfs_init(xd);
        } else {
                kobject_uevent(&xd->dev.kobj, KOBJ_CHANGE);
        }

        enumerate_services(xd);
        return 0;

err_free_dir:
        tb_property_free_dir(dir);
err_free_block:
        kfree(block);
        mutex_unlock(&xd->lock);

        return ret;
}

static void tb_xdomain_queue_uuid(struct tb_xdomain *xd)
{
        xd->state = XDOMAIN_STATE_UUID;
        xd->state_retries = XDOMAIN_RETRIES;
        queue_delayed_work(xd->tb->wq, &xd->state_work,
                           msecs_to_jiffies(XDOMAIN_SHORT_TIMEOUT));
}

static void tb_xdomain_queue_link_status(struct tb_xdomain *xd)
{
        xd->state = XDOMAIN_STATE_LINK_STATUS;
        xd->state_retries = XDOMAIN_RETRIES;
        queue_delayed_work(xd->tb->wq, &xd->state_work,
                           msecs_to_jiffies(XDOMAIN_DEFAULT_TIMEOUT));
}

static void tb_xdomain_queue_link_status2(struct tb_xdomain *xd)
{
        xd->state = XDOMAIN_STATE_LINK_STATUS2;
        xd->state_retries = XDOMAIN_RETRIES;
        queue_delayed_work(xd->tb->wq, &xd->state_work,
                           msecs_to_jiffies(XDOMAIN_DEFAULT_TIMEOUT));
}

static void tb_xdomain_queue_bonding(struct tb_xdomain *xd)
{
        if (memcmp(xd->local_uuid, xd->remote_uuid, UUID_SIZE) > 0) {
                dev_dbg(&xd->dev, "we have higher UUID, other side bonds the lanes\n");
                xd->state = XDOMAIN_STATE_BONDING_UUID_HIGH;
        } else {
                dev_dbg(&xd->dev, "we have lower UUID, bonding lanes\n");
                xd->state = XDOMAIN_STATE_LINK_STATE_CHANGE;
        }

        xd->state_retries = XDOMAIN_RETRIES;
        queue_delayed_work(xd->tb->wq, &xd->state_work,
                           msecs_to_jiffies(XDOMAIN_DEFAULT_TIMEOUT));
}

static void tb_xdomain_queue_bonding_uuid_low(struct tb_xdomain *xd)
{
        xd->state = XDOMAIN_STATE_BONDING_UUID_LOW;
        xd->state_retries = XDOMAIN_RETRIES;
        queue_delayed_work(xd->tb->wq, &xd->state_work,
                           msecs_to_jiffies(XDOMAIN_DEFAULT_TIMEOUT));
}

static void tb_xdomain_queue_properties(struct tb_xdomain *xd)
{
        xd->state = XDOMAIN_STATE_PROPERTIES;
        xd->state_retries = XDOMAIN_RETRIES;
        queue_delayed_work(xd->tb->wq, &xd->state_work,
                           msecs_to_jiffies(XDOMAIN_DEFAULT_TIMEOUT));
}

static void tb_xdomain_queue_properties_changed(struct tb_xdomain *xd)
{
        xd->properties_changed_retries = XDOMAIN_RETRIES;
        queue_delayed_work(xd->tb->wq, &xd->properties_changed_work,
                           msecs_to_jiffies(XDOMAIN_SHORT_TIMEOUT));
}

static void tb_xdomain_failed(struct tb_xdomain *xd)
{
        xd->state = XDOMAIN_STATE_ERROR;
        queue_delayed_work(xd->tb->wq, &xd->state_work,
                           msecs_to_jiffies(XDOMAIN_DEFAULT_TIMEOUT));
}

static void tb_xdomain_state_work(struct work_struct *work)
{
        struct tb_xdomain *xd = container_of(work, typeof(*xd), state_work.work);
        int ret, state = xd->state;

        if (WARN_ON_ONCE(state < XDOMAIN_STATE_INIT ||
                         state > XDOMAIN_STATE_ERROR))
                return;

        dev_dbg(&xd->dev, "running state %s\n", state_names[state]);

        switch (state) {
        case XDOMAIN_STATE_INIT:
                if (xd->needs_uuid) {
                        tb_xdomain_queue_uuid(xd);
                } else {
                        tb_xdomain_queue_properties_changed(xd);
                        tb_xdomain_queue_properties(xd);
                }
                break;

        case XDOMAIN_STATE_UUID:
                ret = tb_xdomain_get_uuid(xd);
                if (ret) {
                        if (ret == -EAGAIN)
                                goto retry_state;
                        tb_xdomain_failed(xd);
                } else {
                        tb_xdomain_queue_properties_changed(xd);
                        if (xd->bonding_possible)
                                tb_xdomain_queue_link_status(xd);
                        else
                                tb_xdomain_queue_properties(xd);
                }
                break;

        case XDOMAIN_STATE_LINK_STATUS:
                ret = tb_xdomain_get_link_status(xd);
                if (ret) {
                        if (ret == -EAGAIN)
                                goto retry_state;

                        /*
                         * If any of the lane bonding states fail we skip
                         * bonding completely and try to continue from
                         * reading properties.
                         */
                        tb_xdomain_queue_properties(xd);
                } else {
                        tb_xdomain_queue_bonding(xd);
                }
                break;

        case XDOMAIN_STATE_LINK_STATE_CHANGE:
                ret = tb_xdomain_link_state_change(xd, 2);
                if (ret) {
                        if (ret == -EAGAIN)
                                goto retry_state;
                        tb_xdomain_queue_properties(xd);
                } else {
                        tb_xdomain_queue_link_status2(xd);
                }
                break;

        case XDOMAIN_STATE_LINK_STATUS2:
                ret = tb_xdomain_get_link_status(xd);
                if (ret) {
                        if (ret == -EAGAIN)
                                goto retry_state;
                        tb_xdomain_queue_properties(xd);
                } else {
                        tb_xdomain_queue_bonding_uuid_low(xd);
                }
                break;

        case XDOMAIN_STATE_BONDING_UUID_LOW:
                tb_xdomain_lane_bonding_enable(xd);
                tb_xdomain_queue_properties(xd);
                break;

        case XDOMAIN_STATE_BONDING_UUID_HIGH:
                if (tb_xdomain_bond_lanes_uuid_high(xd) == -EAGAIN)
                        goto retry_state;
                tb_xdomain_queue_properties(xd);
                break;

        case XDOMAIN_STATE_PROPERTIES:
                ret = tb_xdomain_get_properties(xd);
                if (ret) {
                        if (ret == -EAGAIN)
                                goto retry_state;
                        tb_xdomain_failed(xd);
                } else {
                        xd->state = XDOMAIN_STATE_ENUMERATED;
                }
                break;

        case XDOMAIN_STATE_ENUMERATED:
                tb_xdomain_queue_properties(xd);
                break;

        case XDOMAIN_STATE_ERROR:
                dev_dbg(&xd->dev, "discovery failed, stopping handshake\n");
                __stop_handshake(xd);
                break;

        default:
                dev_warn(&xd->dev, "unexpected state %d\n", state);
                break;
        }

        return;

retry_state:
        queue_delayed_work(xd->tb->wq, &xd->state_work,
                           msecs_to_jiffies(XDOMAIN_DEFAULT_TIMEOUT));
}

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;

        dev_dbg(&xd->dev, "sending properties changed notification\n");

        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) {
                        dev_dbg(&xd->dev,
                                "failed to send properties changed notification, retrying\n");
                        queue_delayed_work(xd->tb->wq,
                                           &xd->properties_changed_work,
                                           msecs_to_jiffies(XDOMAIN_DEFAULT_TIMEOUT));
                }
                dev_err(&xd->dev, "failed to send properties changed notification\n");
                return;
        }

        xd->properties_changed_retries = XDOMAIN_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 sysfs_emit(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 = sysfs_emit(buf, "%s\n", xd->device_name ?: "");
        mutex_unlock(&xd->lock);

        return ret;
}
static DEVICE_ATTR_RO(device_name);

static ssize_t maxhopid_show(struct device *dev, struct device_attribute *attr,
                             char *buf)
{
        struct tb_xdomain *xd = container_of(dev, struct tb_xdomain, dev);

        return sysfs_emit(buf, "%d\n", xd->remote_max_hopid);
}
static DEVICE_ATTR_RO(maxhopid);

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 sysfs_emit(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 = sysfs_emit(buf, "%s\n", 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 sysfs_emit(buf, "%pUb\n", xd->remote_uuid);
}
static DEVICE_ATTR_RO(unique_id);

static ssize_t speed_show(struct device *dev, struct device_attribute *attr,
                          char *buf)
{
        struct tb_xdomain *xd = container_of(dev, struct tb_xdomain, dev);

        return sysfs_emit(buf, "%u.0 Gb/s\n", xd->link_speed);
}

static DEVICE_ATTR(rx_speed, 0444, speed_show, NULL);
static DEVICE_ATTR(tx_speed, 0444, speed_show, NULL);

static ssize_t rx_lanes_show(struct device *dev, struct device_attribute *attr,
                             char *buf)
{
        struct tb_xdomain *xd = container_of(dev, struct tb_xdomain, dev);
        unsigned int width;

        switch (xd->link_width) {
        case TB_LINK_WIDTH_SINGLE:
        case TB_LINK_WIDTH_ASYM_TX:
                width = 1;
                break;
        case TB_LINK_WIDTH_DUAL:
                width = 2;
                break;
        case TB_LINK_WIDTH_ASYM_RX:
                width = 3;
                break;
        default:
                WARN_ON_ONCE(1);
                return -EINVAL;
        }

        return sysfs_emit(buf, "%u\n", width);
}
static DEVICE_ATTR(rx_lanes, 0444, rx_lanes_show, NULL);

static ssize_t tx_lanes_show(struct device *dev, struct device_attribute *attr,
                             char *buf)
{
        struct tb_xdomain *xd = container_of(dev, struct tb_xdomain, dev);
        unsigned int width;

        switch (xd->link_width) {
        case TB_LINK_WIDTH_SINGLE:
        case TB_LINK_WIDTH_ASYM_RX:
                width = 1;
                break;
        case TB_LINK_WIDTH_DUAL:
                width = 2;
                break;
        case TB_LINK_WIDTH_ASYM_TX:
                width = 3;
                break;
        default:
                WARN_ON_ONCE(1);
                return -EINVAL;
        }

        return sysfs_emit(buf, "%u\n", width);
}
static DEVICE_ATTR(tx_lanes, 0444, tx_lanes_show, NULL);

static struct attribute *xdomain_attrs[] = {
        &dev_attr_device.attr,
        &dev_attr_device_name.attr,
        &dev_attr_maxhopid.attr,
        &dev_attr_rx_lanes.attr,
        &dev_attr_rx_speed.attr,
        &dev_attr_tx_lanes.attr,
        &dev_attr_tx_speed.attr,
        &dev_attr_unique_id.attr,
        &dev_attr_vendor.attr,
        &dev_attr_vendor_name.attr,
        NULL,
};

static const 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);

        kfree(xd->local_property_block);
        tb_property_free_dir(xd->remote_properties);
        ida_destroy(&xd->out_hopids);
        ida_destroy(&xd->in_hopids);
        ida_destroy(&xd->service_ids);

        kfree(xd->local_uuid);
        kfree(xd->remote_uuid);
        kfree(xd->device_name);
        kfree(xd->vendor_name);
        kfree(xd);
}

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)
{
        start_handshake(tb_to_xdomain(dev));
        return 0;
}

static const struct dev_pm_ops tb_xdomain_pm_ops = {
        SET_SYSTEM_SLEEP_PM_OPS(tb_xdomain_suspend, tb_xdomain_resume)
};

const struct device_type tb_xdomain_type = {
        .name = "thunderbolt_xdomain",
        .release = tb_xdomain_release,
        .pm = &tb_xdomain_pm_ops,
};
EXPORT_SYMBOL_GPL(tb_xdomain_type);

static void tb_xdomain_link_init(struct tb_xdomain *xd, struct tb_port *down)
{
        if (!down->dual_link_port)
                return;

        /*
         * Gen 4 links come up already as bonded so only update the port
         * structures here.
         */
        if (tb_port_get_link_generation(down) >= 4) {
                down->bonded = true;
                down->dual_link_port->bonded = true;
        } else {
                xd->bonding_possible = true;
        }
}

static void tb_xdomain_link_exit(struct tb_xdomain *xd)
{
        struct tb_port *down = tb_xdomain_downstream_port(xd);

        if (!down->dual_link_port)
                return;

        if (tb_port_get_link_generation(down) >= 4) {
                down->bonded = false;
                down->dual_link_port->bonded = false;
        } else if (xd->link_width > TB_LINK_WIDTH_SINGLE) {
                /*
                 * Just return port structures back to way they were and
                 * update credits. No need to update userspace because
                 * the XDomain is removed soon anyway.
                 */
                tb_port_lane_bonding_disable(down);
                tb_port_update_credits(down);
        } else if (down->dual_link_port) {
                /*
                 * Re-enable the lane 1 adapter we disabled at the end
                 * of tb_xdomain_get_properties().
                 */
                tb_port_enable(down->dual_link_port);
        }
}

/**
 * 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 (optional)
 *
 * 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_switch *parent_sw = tb_to_switch(parent);
        struct tb_xdomain *xd;
        struct tb_port *down;

        /* Make sure the downstream domain is accessible */
        down = tb_port_at(route, parent_sw);
        tb_port_unlock(down);

        xd = kzalloc(sizeof(*xd), GFP_KERNEL);
        if (!xd)
                return NULL;

        xd->tb = tb;
        xd->route = route;
        xd->local_max_hopid = down->config.max_in_hop_id;
        ida_init(&xd->service_ids);
        ida_init(&xd->in_hopids);
        ida_init(&xd->out_hopids);
        mutex_init(&xd->lock);
        INIT_DELAYED_WORK(&xd->state_work, tb_xdomain_state_work);
        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;

        if (remote_uuid) {
                xd->remote_uuid = kmemdup(remote_uuid, sizeof(uuid_t),
                                          GFP_KERNEL);
                if (!xd->remote_uuid)
                        goto err_free_local_uuid;
        } else {
                xd->needs_uuid = true;

                tb_xdomain_link_init(xd, down);
        }

        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);

        dev_dbg(&xd->dev, "local UUID %pUb\n", local_uuid);
        if (remote_uuid)
                dev_dbg(&xd->dev, "remote UUID %pUb\n", remote_uuid);

        /*
         * This keeps the DMA powered on as long as we have active
         * connection to another host.
         */
        pm_runtime_set_active(&xd->dev);
        pm_runtime_get_noresume(&xd->dev);
        pm_runtime_enable(&xd->dev);

        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)
{
        tb_xdomain_debugfs_remove(xd);

        stop_handshake(xd);

        device_for_each_child_reverse(&xd->dev, xd, unregister_service);

        tb_xdomain_link_exit(xd);

        /*
         * Undo runtime PM here explicitly because it is possible that
         * the XDomain was never added to the bus and thus device_del()
         * is not called for it (device_del() would handle this otherwise).
         */
        pm_runtime_disable(&xd->dev);
        pm_runtime_put_noidle(&xd->dev);
        pm_runtime_set_suspended(&xd->dev);

        if (!device_is_registered(&xd->dev)) {
                put_device(&xd->dev);
        } else {
                dev_info(&xd->dev, "host disconnected\n");
                device_unregister(&xd->dev);
        }
}

/**
 * tb_xdomain_lane_bonding_enable() - Enable lane bonding on XDomain
 * @xd: XDomain connection
 *
 * Lane bonding is disabled by default for XDomains. This function tries
 * to enable bonding by first enabling the port and waiting for the CL0
 * state.
 *
 * Return: %0 in case of success and negative errno in case of error.
 */
int tb_xdomain_lane_bonding_enable(struct tb_xdomain *xd)
{
        unsigned int width_mask;
        struct tb_port *port;
        int ret;

        port = tb_xdomain_downstream_port(xd);
        if (!port->dual_link_port)
                return -ENODEV;

        ret = tb_port_enable(port->dual_link_port);
        if (ret)
                return ret;

        ret = tb_wait_for_port(port->dual_link_port, true);
        if (ret < 0)
                return ret;
        if (!ret)
                return -ENOTCONN;

        ret = tb_port_lane_bonding_enable(port);
        if (ret) {
                tb_port_warn(port, "failed to enable lane bonding\n");
                return ret;
        }

        /* Any of the widths are all bonded */
        width_mask = TB_LINK_WIDTH_DUAL | TB_LINK_WIDTH_ASYM_TX |
                     TB_LINK_WIDTH_ASYM_RX;

        ret = tb_port_wait_for_link_width(port, width_mask,
                                          XDOMAIN_BONDING_TIMEOUT);
        if (ret) {
                tb_port_warn(port, "failed to enable lane bonding\n");
                return ret;
        }

        tb_port_update_credits(port);
        tb_xdomain_update_link_attributes(xd);

        dev_dbg(&xd->dev, "lane bonding enabled\n");
        return 0;
}
EXPORT_SYMBOL_GPL(tb_xdomain_lane_bonding_enable);

/**
 * tb_xdomain_lane_bonding_disable() - Disable lane bonding
 * @xd: XDomain connection
 *
 * Lane bonding is disabled by default for XDomains. If bonding has been
 * enabled, this function can be used to disable it.
 */
void tb_xdomain_lane_bonding_disable(struct tb_xdomain *xd)
{
        struct tb_port *port;

        port = tb_xdomain_downstream_port(xd);
        if (port->dual_link_port) {
                int ret;

                tb_port_lane_bonding_disable(port);
                ret = tb_port_wait_for_link_width(port, TB_LINK_WIDTH_SINGLE, 100);
                if (ret == -ETIMEDOUT)
                        tb_port_warn(port, "timeout disabling lane bonding\n");
                tb_port_disable(port->dual_link_port);
                tb_port_update_credits(port);
                tb_xdomain_update_link_attributes(xd);

                dev_dbg(&xd->dev, "lane bonding disabled\n");
        }
}
EXPORT_SYMBOL_GPL(tb_xdomain_lane_bonding_disable);

/**
 * tb_xdomain_alloc_in_hopid() - Allocate input HopID for tunneling
 * @xd: XDomain connection
 * @hopid: Preferred HopID or %-1 for next available
 *
 * Returns allocated HopID or negative errno. Specifically returns
 * %-ENOSPC if there are no more available HopIDs. Returned HopID is
 * guaranteed to be within range supported by the input lane adapter.
 * Call tb_xdomain_release_in_hopid() to release the allocated HopID.
 */
int tb_xdomain_alloc_in_hopid(struct tb_xdomain *xd, int hopid)
{
        if (hopid < 0)
                hopid = TB_PATH_MIN_HOPID;
        if (hopid < TB_PATH_MIN_HOPID || hopid > xd->local_max_hopid)
                return -EINVAL;

        return ida_alloc_range(&xd->in_hopids, hopid, xd->local_max_hopid,
                               GFP_KERNEL);
}
EXPORT_SYMBOL_GPL(tb_xdomain_alloc_in_hopid);

/**
 * tb_xdomain_alloc_out_hopid() - Allocate output HopID for tunneling
 * @xd: XDomain connection
 * @hopid: Preferred HopID or %-1 for next available
 *
 * Returns allocated HopID or negative errno. Specifically returns
 * %-ENOSPC if there are no more available HopIDs. Returned HopID is
 * guaranteed to be within range supported by the output lane adapter.
 * Call tb_xdomain_release_in_hopid() to release the allocated HopID.
 */
int tb_xdomain_alloc_out_hopid(struct tb_xdomain *xd, int hopid)
{
        if (hopid < 0)
                hopid = TB_PATH_MIN_HOPID;
        if (hopid < TB_PATH_MIN_HOPID || hopid > xd->remote_max_hopid)
                return -EINVAL;

        return ida_alloc_range(&xd->out_hopids, hopid, xd->remote_max_hopid,
                               GFP_KERNEL);
}
EXPORT_SYMBOL_GPL(tb_xdomain_alloc_out_hopid);

/**
 * tb_xdomain_release_in_hopid() - Release input HopID
 * @xd: XDomain connection
 * @hopid: HopID to release
 */
void tb_xdomain_release_in_hopid(struct tb_xdomain *xd, int hopid)
{
        ida_free(&xd->in_hopids, hopid);
}
EXPORT_SYMBOL_GPL(tb_xdomain_release_in_hopid);

/**
 * tb_xdomain_release_out_hopid() - Release output HopID
 * @xd: XDomain connection
 * @hopid: HopID to release
 */
void tb_xdomain_release_out_hopid(struct tb_xdomain *xd, int hopid)
{
        ida_free(&xd->out_hopids, hopid);
}
EXPORT_SYMBOL_GPL(tb_xdomain_release_out_hopid);

/**
 * tb_xdomain_enable_paths() - Enable DMA paths for XDomain connection
 * @xd: XDomain connection
 * @transmit_path: HopID we are using to send out packets
 * @transmit_ring: DMA ring used to send out packets
 * @receive_path: HopID the other end is using to send packets to us
 * @receive_ring: DMA ring used to receive packets from @receive_path
 *
 * The function enables DMA paths accordingly so that after successful
 * return the caller can send and receive packets using high-speed DMA
 * path. If a transmit or receive path is not needed, pass %-1 for those
 * parameters.
 *
 * Return: %0 in case of success and negative errno in case of error
 */
int tb_xdomain_enable_paths(struct tb_xdomain *xd, int transmit_path,
                            int transmit_ring, int receive_path,
                            int receive_ring)
{
        return tb_domain_approve_xdomain_paths(xd->tb, xd, transmit_path,
                                               transmit_ring, receive_path,
                                               receive_ring);
}
EXPORT_SYMBOL_GPL(tb_xdomain_enable_paths);

/**
 * tb_xdomain_disable_paths() - Disable DMA paths for XDomain connection
 * @xd: XDomain connection
 * @transmit_path: HopID we are using to send out packets
 * @transmit_ring: DMA ring used to send out packets
 * @receive_path: HopID the other end is using to send packets to us
 * @receive_ring: DMA ring used to receive packets from @receive_path
 *
 * This does the opposite of tb_xdomain_enable_paths(). After call to
 * this the caller is not expected to use the rings anymore. Passing %-1
 * as path/ring parameter means don't care. Normally the callers should
 * pass the same values here as they do when paths are enabled.
 *
 * Return: %0 in case of success and negative errno in case of error
 */
int tb_xdomain_disable_paths(struct tb_xdomain *xd, int transmit_path,
                             int transmit_ring, int receive_path,
                             int receive_ring)
{
        return tb_domain_disconnect_xdomain_paths(xd->tb, xd, transmit_path,
                                                  transmit_ring, receive_path,
                                                  receive_ring);
}
EXPORT_SYMBOL_GPL(tb_xdomain_disable_paths);

struct tb_xdomain_lookup {
        const uuid_t *uuid;
        u8 link;
        u8 depth;
        u64 route;
};

static struct tb_xdomain *switch_find_xdomain(struct tb_switch *sw,
        const struct tb_xdomain_lookup *lookup)
{
        struct tb_port *port;

        tb_switch_for_each_port(sw, port) {
                struct tb_xdomain *xd;

                if (port->xdomain) {
                        xd = port->xdomain;

                        if (lookup->uuid) {
                                if (xd->remote_uuid &&
                                    uuid_equal(xd->remote_uuid, lookup->uuid))
                                        return xd;
                        } else {
                                if (lookup->link && lookup->link == xd->link &&
                                    lookup->depth == xd->depth)
                                        return xd;
                                if (lookup->route && lookup->route == xd->route)
                                        return xd;
                        }
                } else if (tb_port_has_remote(port)) {
                        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);
        return tb_xdomain_get(xd);
}
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);
        return tb_xdomain_get(xd);
}

/**
 * tb_xdomain_find_by_route() - Find an XDomain by route string
 * @tb: Domain where the XDomain belongs to
 * @route: XDomain route string
 *
 * 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_route(struct tb *tb, u64 route)
{
        struct tb_xdomain_lookup lookup;
        struct tb_xdomain *xd;

        memset(&lookup, 0, sizeof(lookup));
        lookup.route = route;

        xd = switch_find_xdomain(tb->root_switch, &lookup);
        return tb_xdomain_get(xd);
}
EXPORT_SYMBOL_GPL(tb_xdomain_find_by_route);

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)
                        return tb_xdp_schedule_request(tb, hdr, size);
                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 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 (WARN_ON(!xdomain_property_dir))
                return -EAGAIN;

        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;

        xdomain_property_block_gen++;

        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))
                xdomain_property_block_gen++;
        mutex_unlock(&xdomain_lock);

        if (!ret)
                update_all_xdomains();
}
EXPORT_SYMBOL_GPL(tb_unregister_property_dir);

int tb_xdomain_init(void)
{
        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.
         *
         * Rest of the properties are filled dynamically based on these
         * when the P2P connection is made.
         */
        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_immediate(xdomain_property_dir, "devicerv", 0x80000100);

        xdomain_property_block_gen = get_random_u32();
        return 0;
}

void tb_xdomain_exit(void)
{
        tb_property_free_dir(xdomain_property_dir);
}