1fd3b339cSMika Westerberg // SPDX-License-Identifier: GPL-2.0 2d1ff7024SMika Westerberg /* 3d1ff7024SMika Westerberg * Thunderbolt XDomain discovery protocol support 4d1ff7024SMika Westerberg * 5d1ff7024SMika Westerberg * Copyright (C) 2017, Intel Corporation 6d1ff7024SMika Westerberg * Authors: Michael Jamet <michael.jamet@intel.com> 7d1ff7024SMika Westerberg * Mika Westerberg <mika.westerberg@linux.intel.com> 8d1ff7024SMika Westerberg */ 9d1ff7024SMika Westerberg 10d1ff7024SMika Westerberg #include <linux/device.h> 11d1ff7024SMika Westerberg #include <linux/kmod.h> 12d1ff7024SMika Westerberg #include <linux/module.h> 132d8ff0b5SMika Westerberg #include <linux/pm_runtime.h> 14d1ff7024SMika Westerberg #include <linux/utsname.h> 15d1ff7024SMika Westerberg #include <linux/uuid.h> 16d1ff7024SMika Westerberg #include <linux/workqueue.h> 17d1ff7024SMika Westerberg 18d1ff7024SMika Westerberg #include "tb.h" 19d1ff7024SMika Westerberg 20d1ff7024SMika Westerberg #define XDOMAIN_DEFAULT_TIMEOUT 5000 /* ms */ 213b4b3235SMika Westerberg #define XDOMAIN_UUID_RETRIES 10 22d1ff7024SMika Westerberg #define XDOMAIN_PROPERTIES_RETRIES 60 23d1ff7024SMika Westerberg #define XDOMAIN_PROPERTIES_CHANGED_RETRIES 10 24d1ff7024SMika Westerberg 25d1ff7024SMika Westerberg struct xdomain_request_work { 26d1ff7024SMika Westerberg struct work_struct work; 27d1ff7024SMika Westerberg struct tb_xdp_header *pkg; 28d1ff7024SMika Westerberg struct tb *tb; 29d1ff7024SMika Westerberg }; 30d1ff7024SMika Westerberg 31d1ff7024SMika Westerberg /* Serializes access to the properties and protocol handlers below */ 32d1ff7024SMika Westerberg static DEFINE_MUTEX(xdomain_lock); 33d1ff7024SMika Westerberg 34d1ff7024SMika Westerberg /* Properties exposed to the remote domains */ 35d1ff7024SMika Westerberg static struct tb_property_dir *xdomain_property_dir; 36d1ff7024SMika Westerberg static u32 *xdomain_property_block; 37d1ff7024SMika Westerberg static u32 xdomain_property_block_len; 38d1ff7024SMika Westerberg static u32 xdomain_property_block_gen; 39d1ff7024SMika Westerberg 40d1ff7024SMika Westerberg /* Additional protocol handlers */ 41d1ff7024SMika Westerberg static LIST_HEAD(protocol_handlers); 42d1ff7024SMika Westerberg 43d1ff7024SMika Westerberg /* UUID for XDomain discovery protocol: b638d70e-42ff-40bb-97c2-90e2c0b2ff07 */ 44d1ff7024SMika Westerberg static const uuid_t tb_xdp_uuid = 45d1ff7024SMika Westerberg UUID_INIT(0xb638d70e, 0x42ff, 0x40bb, 46d1ff7024SMika Westerberg 0x97, 0xc2, 0x90, 0xe2, 0xc0, 0xb2, 0xff, 0x07); 47d1ff7024SMika Westerberg 48d1ff7024SMika Westerberg static bool tb_xdomain_match(const struct tb_cfg_request *req, 49d1ff7024SMika Westerberg const struct ctl_pkg *pkg) 50d1ff7024SMika Westerberg { 51d1ff7024SMika Westerberg switch (pkg->frame.eof) { 52d1ff7024SMika Westerberg case TB_CFG_PKG_ERROR: 53d1ff7024SMika Westerberg return true; 54d1ff7024SMika Westerberg 55d1ff7024SMika Westerberg case TB_CFG_PKG_XDOMAIN_RESP: { 56d1ff7024SMika Westerberg const struct tb_xdp_header *res_hdr = pkg->buffer; 57d1ff7024SMika Westerberg const struct tb_xdp_header *req_hdr = req->request; 58d1ff7024SMika Westerberg 59d1ff7024SMika Westerberg if (pkg->frame.size < req->response_size / 4) 60d1ff7024SMika Westerberg return false; 61d1ff7024SMika Westerberg 62d1ff7024SMika Westerberg /* Make sure route matches */ 63d1ff7024SMika Westerberg if ((res_hdr->xd_hdr.route_hi & ~BIT(31)) != 64d1ff7024SMika Westerberg req_hdr->xd_hdr.route_hi) 65d1ff7024SMika Westerberg return false; 66d1ff7024SMika Westerberg if ((res_hdr->xd_hdr.route_lo) != req_hdr->xd_hdr.route_lo) 67d1ff7024SMika Westerberg return false; 68d1ff7024SMika Westerberg 69d1ff7024SMika Westerberg /* Check that the XDomain protocol matches */ 70d1ff7024SMika Westerberg if (!uuid_equal(&res_hdr->uuid, &req_hdr->uuid)) 71d1ff7024SMika Westerberg return false; 72d1ff7024SMika Westerberg 73d1ff7024SMika Westerberg return true; 74d1ff7024SMika Westerberg } 75d1ff7024SMika Westerberg 76d1ff7024SMika Westerberg default: 77d1ff7024SMika Westerberg return false; 78d1ff7024SMika Westerberg } 79d1ff7024SMika Westerberg } 80d1ff7024SMika Westerberg 81d1ff7024SMika Westerberg static bool tb_xdomain_copy(struct tb_cfg_request *req, 82d1ff7024SMika Westerberg const struct ctl_pkg *pkg) 83d1ff7024SMika Westerberg { 84d1ff7024SMika Westerberg memcpy(req->response, pkg->buffer, req->response_size); 85d1ff7024SMika Westerberg req->result.err = 0; 86d1ff7024SMika Westerberg return true; 87d1ff7024SMika Westerberg } 88d1ff7024SMika Westerberg 89d1ff7024SMika Westerberg static void response_ready(void *data) 90d1ff7024SMika Westerberg { 91d1ff7024SMika Westerberg tb_cfg_request_put(data); 92d1ff7024SMika Westerberg } 93d1ff7024SMika Westerberg 94d1ff7024SMika Westerberg static int __tb_xdomain_response(struct tb_ctl *ctl, const void *response, 95d1ff7024SMika Westerberg size_t size, enum tb_cfg_pkg_type type) 96d1ff7024SMika Westerberg { 97d1ff7024SMika Westerberg struct tb_cfg_request *req; 98d1ff7024SMika Westerberg 99d1ff7024SMika Westerberg req = tb_cfg_request_alloc(); 100d1ff7024SMika Westerberg if (!req) 101d1ff7024SMika Westerberg return -ENOMEM; 102d1ff7024SMika Westerberg 103d1ff7024SMika Westerberg req->match = tb_xdomain_match; 104d1ff7024SMika Westerberg req->copy = tb_xdomain_copy; 105d1ff7024SMika Westerberg req->request = response; 106d1ff7024SMika Westerberg req->request_size = size; 107d1ff7024SMika Westerberg req->request_type = type; 108d1ff7024SMika Westerberg 109d1ff7024SMika Westerberg return tb_cfg_request(ctl, req, response_ready, req); 110d1ff7024SMika Westerberg } 111d1ff7024SMika Westerberg 112d1ff7024SMika Westerberg /** 113d1ff7024SMika Westerberg * tb_xdomain_response() - Send a XDomain response message 114d1ff7024SMika Westerberg * @xd: XDomain to send the message 115d1ff7024SMika Westerberg * @response: Response to send 116d1ff7024SMika Westerberg * @size: Size of the response 117d1ff7024SMika Westerberg * @type: PDF type of the response 118d1ff7024SMika Westerberg * 119d1ff7024SMika Westerberg * This can be used to send a XDomain response message to the other 120d1ff7024SMika Westerberg * domain. No response for the message is expected. 121d1ff7024SMika Westerberg * 122d1ff7024SMika Westerberg * Return: %0 in case of success and negative errno in case of failure 123d1ff7024SMika Westerberg */ 124d1ff7024SMika Westerberg int tb_xdomain_response(struct tb_xdomain *xd, const void *response, 125d1ff7024SMika Westerberg size_t size, enum tb_cfg_pkg_type type) 126d1ff7024SMika Westerberg { 127d1ff7024SMika Westerberg return __tb_xdomain_response(xd->tb->ctl, response, size, type); 128d1ff7024SMika Westerberg } 129d1ff7024SMika Westerberg EXPORT_SYMBOL_GPL(tb_xdomain_response); 130d1ff7024SMika Westerberg 131d1ff7024SMika Westerberg static int __tb_xdomain_request(struct tb_ctl *ctl, const void *request, 132d1ff7024SMika Westerberg size_t request_size, enum tb_cfg_pkg_type request_type, void *response, 133d1ff7024SMika Westerberg size_t response_size, enum tb_cfg_pkg_type response_type, 134d1ff7024SMika Westerberg unsigned int timeout_msec) 135d1ff7024SMika Westerberg { 136d1ff7024SMika Westerberg struct tb_cfg_request *req; 137d1ff7024SMika Westerberg struct tb_cfg_result res; 138d1ff7024SMika Westerberg 139d1ff7024SMika Westerberg req = tb_cfg_request_alloc(); 140d1ff7024SMika Westerberg if (!req) 141d1ff7024SMika Westerberg return -ENOMEM; 142d1ff7024SMika Westerberg 143d1ff7024SMika Westerberg req->match = tb_xdomain_match; 144d1ff7024SMika Westerberg req->copy = tb_xdomain_copy; 145d1ff7024SMika Westerberg req->request = request; 146d1ff7024SMika Westerberg req->request_size = request_size; 147d1ff7024SMika Westerberg req->request_type = request_type; 148d1ff7024SMika Westerberg req->response = response; 149d1ff7024SMika Westerberg req->response_size = response_size; 150d1ff7024SMika Westerberg req->response_type = response_type; 151d1ff7024SMika Westerberg 152d1ff7024SMika Westerberg res = tb_cfg_request_sync(ctl, req, timeout_msec); 153d1ff7024SMika Westerberg 154d1ff7024SMika Westerberg tb_cfg_request_put(req); 155d1ff7024SMika Westerberg 156d1ff7024SMika Westerberg return res.err == 1 ? -EIO : res.err; 157d1ff7024SMika Westerberg } 158d1ff7024SMika Westerberg 159d1ff7024SMika Westerberg /** 160d1ff7024SMika Westerberg * tb_xdomain_request() - Send a XDomain request 161d1ff7024SMika Westerberg * @xd: XDomain to send the request 162d1ff7024SMika Westerberg * @request: Request to send 163d1ff7024SMika Westerberg * @request_size: Size of the request in bytes 164d1ff7024SMika Westerberg * @request_type: PDF type of the request 165d1ff7024SMika Westerberg * @response: Response is copied here 166d1ff7024SMika Westerberg * @response_size: Expected size of the response in bytes 167d1ff7024SMika Westerberg * @response_type: Expected PDF type of the response 168d1ff7024SMika Westerberg * @timeout_msec: Timeout in milliseconds to wait for the response 169d1ff7024SMika Westerberg * 170d1ff7024SMika Westerberg * This function can be used to send XDomain control channel messages to 171d1ff7024SMika Westerberg * the other domain. The function waits until the response is received 172d1ff7024SMika Westerberg * or when timeout triggers. Whichever comes first. 173d1ff7024SMika Westerberg * 174d1ff7024SMika Westerberg * Return: %0 in case of success and negative errno in case of failure 175d1ff7024SMika Westerberg */ 176d1ff7024SMika Westerberg int tb_xdomain_request(struct tb_xdomain *xd, const void *request, 177d1ff7024SMika Westerberg size_t request_size, enum tb_cfg_pkg_type request_type, 178d1ff7024SMika Westerberg void *response, size_t response_size, 179d1ff7024SMika Westerberg enum tb_cfg_pkg_type response_type, unsigned int timeout_msec) 180d1ff7024SMika Westerberg { 181d1ff7024SMika Westerberg return __tb_xdomain_request(xd->tb->ctl, request, request_size, 182d1ff7024SMika Westerberg request_type, response, response_size, 183d1ff7024SMika Westerberg response_type, timeout_msec); 184d1ff7024SMika Westerberg } 185d1ff7024SMika Westerberg EXPORT_SYMBOL_GPL(tb_xdomain_request); 186d1ff7024SMika Westerberg 187d1ff7024SMika Westerberg static inline void tb_xdp_fill_header(struct tb_xdp_header *hdr, u64 route, 188d1ff7024SMika Westerberg u8 sequence, enum tb_xdp_type type, size_t size) 189d1ff7024SMika Westerberg { 190d1ff7024SMika Westerberg u32 length_sn; 191d1ff7024SMika Westerberg 192d1ff7024SMika Westerberg length_sn = (size - sizeof(hdr->xd_hdr)) / 4; 193d1ff7024SMika Westerberg length_sn |= (sequence << TB_XDOMAIN_SN_SHIFT) & TB_XDOMAIN_SN_MASK; 194d1ff7024SMika Westerberg 195d1ff7024SMika Westerberg hdr->xd_hdr.route_hi = upper_32_bits(route); 196d1ff7024SMika Westerberg hdr->xd_hdr.route_lo = lower_32_bits(route); 197d1ff7024SMika Westerberg hdr->xd_hdr.length_sn = length_sn; 198d1ff7024SMika Westerberg hdr->type = type; 199d1ff7024SMika Westerberg memcpy(&hdr->uuid, &tb_xdp_uuid, sizeof(tb_xdp_uuid)); 200d1ff7024SMika Westerberg } 201d1ff7024SMika Westerberg 202d1ff7024SMika Westerberg static int tb_xdp_handle_error(const struct tb_xdp_header *hdr) 203d1ff7024SMika Westerberg { 204d1ff7024SMika Westerberg const struct tb_xdp_error_response *error; 205d1ff7024SMika Westerberg 206d1ff7024SMika Westerberg if (hdr->type != ERROR_RESPONSE) 207d1ff7024SMika Westerberg return 0; 208d1ff7024SMika Westerberg 209d1ff7024SMika Westerberg error = (const struct tb_xdp_error_response *)hdr; 210d1ff7024SMika Westerberg 211d1ff7024SMika Westerberg switch (error->error) { 212d1ff7024SMika Westerberg case ERROR_UNKNOWN_PACKET: 213d1ff7024SMika Westerberg case ERROR_UNKNOWN_DOMAIN: 214d1ff7024SMika Westerberg return -EIO; 215d1ff7024SMika Westerberg case ERROR_NOT_SUPPORTED: 216d1ff7024SMika Westerberg return -ENOTSUPP; 217d1ff7024SMika Westerberg case ERROR_NOT_READY: 218d1ff7024SMika Westerberg return -EAGAIN; 219d1ff7024SMika Westerberg default: 220d1ff7024SMika Westerberg break; 221d1ff7024SMika Westerberg } 222d1ff7024SMika Westerberg 223d1ff7024SMika Westerberg return 0; 224d1ff7024SMika Westerberg } 225d1ff7024SMika Westerberg 2263b4b3235SMika Westerberg static int tb_xdp_uuid_request(struct tb_ctl *ctl, u64 route, int retry, 2273b4b3235SMika Westerberg uuid_t *uuid) 2283b4b3235SMika Westerberg { 2293b4b3235SMika Westerberg struct tb_xdp_uuid_response res; 2303b4b3235SMika Westerberg struct tb_xdp_uuid req; 2313b4b3235SMika Westerberg int ret; 2323b4b3235SMika Westerberg 2333b4b3235SMika Westerberg memset(&req, 0, sizeof(req)); 2343b4b3235SMika Westerberg tb_xdp_fill_header(&req.hdr, route, retry % 4, UUID_REQUEST, 2353b4b3235SMika Westerberg sizeof(req)); 2363b4b3235SMika Westerberg 2373b4b3235SMika Westerberg memset(&res, 0, sizeof(res)); 2383b4b3235SMika Westerberg ret = __tb_xdomain_request(ctl, &req, sizeof(req), 2393b4b3235SMika Westerberg TB_CFG_PKG_XDOMAIN_REQ, &res, sizeof(res), 2403b4b3235SMika Westerberg TB_CFG_PKG_XDOMAIN_RESP, 2413b4b3235SMika Westerberg XDOMAIN_DEFAULT_TIMEOUT); 2423b4b3235SMika Westerberg if (ret) 2433b4b3235SMika Westerberg return ret; 2443b4b3235SMika Westerberg 2453b4b3235SMika Westerberg ret = tb_xdp_handle_error(&res.hdr); 2463b4b3235SMika Westerberg if (ret) 2473b4b3235SMika Westerberg return ret; 2483b4b3235SMika Westerberg 2493b4b3235SMika Westerberg uuid_copy(uuid, &res.src_uuid); 2503b4b3235SMika Westerberg return 0; 2513b4b3235SMika Westerberg } 2523b4b3235SMika Westerberg 2533b4b3235SMika Westerberg static int tb_xdp_uuid_response(struct tb_ctl *ctl, u64 route, u8 sequence, 2543b4b3235SMika Westerberg const uuid_t *uuid) 2553b4b3235SMika Westerberg { 2563b4b3235SMika Westerberg struct tb_xdp_uuid_response res; 2573b4b3235SMika Westerberg 2583b4b3235SMika Westerberg memset(&res, 0, sizeof(res)); 2593b4b3235SMika Westerberg tb_xdp_fill_header(&res.hdr, route, sequence, UUID_RESPONSE, 2603b4b3235SMika Westerberg sizeof(res)); 2613b4b3235SMika Westerberg 2623b4b3235SMika Westerberg uuid_copy(&res.src_uuid, uuid); 2633b4b3235SMika Westerberg res.src_route_hi = upper_32_bits(route); 2643b4b3235SMika Westerberg res.src_route_lo = lower_32_bits(route); 2653b4b3235SMika Westerberg 2663b4b3235SMika Westerberg return __tb_xdomain_response(ctl, &res, sizeof(res), 2673b4b3235SMika Westerberg TB_CFG_PKG_XDOMAIN_RESP); 2683b4b3235SMika Westerberg } 2693b4b3235SMika Westerberg 270d1ff7024SMika Westerberg static int tb_xdp_error_response(struct tb_ctl *ctl, u64 route, u8 sequence, 271d1ff7024SMika Westerberg enum tb_xdp_error error) 272d1ff7024SMika Westerberg { 273d1ff7024SMika Westerberg struct tb_xdp_error_response res; 274d1ff7024SMika Westerberg 275d1ff7024SMika Westerberg memset(&res, 0, sizeof(res)); 276d1ff7024SMika Westerberg tb_xdp_fill_header(&res.hdr, route, sequence, ERROR_RESPONSE, 277d1ff7024SMika Westerberg sizeof(res)); 278d1ff7024SMika Westerberg res.error = error; 279d1ff7024SMika Westerberg 280d1ff7024SMika Westerberg return __tb_xdomain_response(ctl, &res, sizeof(res), 281d1ff7024SMika Westerberg TB_CFG_PKG_XDOMAIN_RESP); 282d1ff7024SMika Westerberg } 283d1ff7024SMika Westerberg 284d1ff7024SMika Westerberg static int tb_xdp_properties_request(struct tb_ctl *ctl, u64 route, 285d1ff7024SMika Westerberg const uuid_t *src_uuid, const uuid_t *dst_uuid, int retry, 286d1ff7024SMika Westerberg u32 **block, u32 *generation) 287d1ff7024SMika Westerberg { 288d1ff7024SMika Westerberg struct tb_xdp_properties_response *res; 289d1ff7024SMika Westerberg struct tb_xdp_properties req; 290d1ff7024SMika Westerberg u16 data_len, len; 291d1ff7024SMika Westerberg size_t total_size; 292d1ff7024SMika Westerberg u32 *data = NULL; 293d1ff7024SMika Westerberg int ret; 294d1ff7024SMika Westerberg 295d1ff7024SMika Westerberg total_size = sizeof(*res) + TB_XDP_PROPERTIES_MAX_DATA_LENGTH * 4; 296d1ff7024SMika Westerberg res = kzalloc(total_size, GFP_KERNEL); 297d1ff7024SMika Westerberg if (!res) 298d1ff7024SMika Westerberg return -ENOMEM; 299d1ff7024SMika Westerberg 300d1ff7024SMika Westerberg memset(&req, 0, sizeof(req)); 301d1ff7024SMika Westerberg tb_xdp_fill_header(&req.hdr, route, retry % 4, PROPERTIES_REQUEST, 302d1ff7024SMika Westerberg sizeof(req)); 303d1ff7024SMika Westerberg memcpy(&req.src_uuid, src_uuid, sizeof(*src_uuid)); 304d1ff7024SMika Westerberg memcpy(&req.dst_uuid, dst_uuid, sizeof(*dst_uuid)); 305d1ff7024SMika Westerberg 306d1ff7024SMika Westerberg len = 0; 307d1ff7024SMika Westerberg data_len = 0; 308d1ff7024SMika Westerberg 309d1ff7024SMika Westerberg do { 310d1ff7024SMika Westerberg ret = __tb_xdomain_request(ctl, &req, sizeof(req), 311d1ff7024SMika Westerberg TB_CFG_PKG_XDOMAIN_REQ, res, 312d1ff7024SMika Westerberg total_size, TB_CFG_PKG_XDOMAIN_RESP, 313d1ff7024SMika Westerberg XDOMAIN_DEFAULT_TIMEOUT); 314d1ff7024SMika Westerberg if (ret) 315d1ff7024SMika Westerberg goto err; 316d1ff7024SMika Westerberg 317d1ff7024SMika Westerberg ret = tb_xdp_handle_error(&res->hdr); 318d1ff7024SMika Westerberg if (ret) 319d1ff7024SMika Westerberg goto err; 320d1ff7024SMika Westerberg 321d1ff7024SMika Westerberg /* 322d1ff7024SMika Westerberg * Package length includes the whole payload without the 323d1ff7024SMika Westerberg * XDomain header. Validate first that the package is at 324d1ff7024SMika Westerberg * least size of the response structure. 325d1ff7024SMika Westerberg */ 326d1ff7024SMika Westerberg len = res->hdr.xd_hdr.length_sn & TB_XDOMAIN_LENGTH_MASK; 327d1ff7024SMika Westerberg if (len < sizeof(*res) / 4) { 328d1ff7024SMika Westerberg ret = -EINVAL; 329d1ff7024SMika Westerberg goto err; 330d1ff7024SMika Westerberg } 331d1ff7024SMika Westerberg 332d1ff7024SMika Westerberg len += sizeof(res->hdr.xd_hdr) / 4; 333d1ff7024SMika Westerberg len -= sizeof(*res) / 4; 334d1ff7024SMika Westerberg 335d1ff7024SMika Westerberg if (res->offset != req.offset) { 336d1ff7024SMika Westerberg ret = -EINVAL; 337d1ff7024SMika Westerberg goto err; 338d1ff7024SMika Westerberg } 339d1ff7024SMika Westerberg 340d1ff7024SMika Westerberg /* 341d1ff7024SMika Westerberg * First time allocate block that has enough space for 342d1ff7024SMika Westerberg * the whole properties block. 343d1ff7024SMika Westerberg */ 344d1ff7024SMika Westerberg if (!data) { 345d1ff7024SMika Westerberg data_len = res->data_length; 346d1ff7024SMika Westerberg if (data_len > TB_XDP_PROPERTIES_MAX_LENGTH) { 347d1ff7024SMika Westerberg ret = -E2BIG; 348d1ff7024SMika Westerberg goto err; 349d1ff7024SMika Westerberg } 350d1ff7024SMika Westerberg 351d1ff7024SMika Westerberg data = kcalloc(data_len, sizeof(u32), GFP_KERNEL); 352d1ff7024SMika Westerberg if (!data) { 353d1ff7024SMika Westerberg ret = -ENOMEM; 354d1ff7024SMika Westerberg goto err; 355d1ff7024SMika Westerberg } 356d1ff7024SMika Westerberg } 357d1ff7024SMika Westerberg 358d1ff7024SMika Westerberg memcpy(data + req.offset, res->data, len * 4); 359d1ff7024SMika Westerberg req.offset += len; 360d1ff7024SMika Westerberg } while (!data_len || req.offset < data_len); 361d1ff7024SMika Westerberg 362d1ff7024SMika Westerberg *block = data; 363d1ff7024SMika Westerberg *generation = res->generation; 364d1ff7024SMika Westerberg 365d1ff7024SMika Westerberg kfree(res); 366d1ff7024SMika Westerberg 367d1ff7024SMika Westerberg return data_len; 368d1ff7024SMika Westerberg 369d1ff7024SMika Westerberg err: 370d1ff7024SMika Westerberg kfree(data); 371d1ff7024SMika Westerberg kfree(res); 372d1ff7024SMika Westerberg 373d1ff7024SMika Westerberg return ret; 374d1ff7024SMika Westerberg } 375d1ff7024SMika Westerberg 376d1ff7024SMika Westerberg static int tb_xdp_properties_response(struct tb *tb, struct tb_ctl *ctl, 377d1ff7024SMika Westerberg u64 route, u8 sequence, const uuid_t *src_uuid, 378d1ff7024SMika Westerberg const struct tb_xdp_properties *req) 379d1ff7024SMika Westerberg { 380d1ff7024SMika Westerberg struct tb_xdp_properties_response *res; 381d1ff7024SMika Westerberg size_t total_size; 382d1ff7024SMika Westerberg u16 len; 383d1ff7024SMika Westerberg int ret; 384d1ff7024SMika Westerberg 385d1ff7024SMika Westerberg /* 386d1ff7024SMika Westerberg * Currently we expect all requests to be directed to us. The 387d1ff7024SMika Westerberg * protocol supports forwarding, though which we might add 388d1ff7024SMika Westerberg * support later on. 389d1ff7024SMika Westerberg */ 390d1ff7024SMika Westerberg if (!uuid_equal(src_uuid, &req->dst_uuid)) { 391d1ff7024SMika Westerberg tb_xdp_error_response(ctl, route, sequence, 392d1ff7024SMika Westerberg ERROR_UNKNOWN_DOMAIN); 393d1ff7024SMika Westerberg return 0; 394d1ff7024SMika Westerberg } 395d1ff7024SMika Westerberg 396d1ff7024SMika Westerberg mutex_lock(&xdomain_lock); 397d1ff7024SMika Westerberg 398d1ff7024SMika Westerberg if (req->offset >= xdomain_property_block_len) { 399d1ff7024SMika Westerberg mutex_unlock(&xdomain_lock); 400d1ff7024SMika Westerberg return -EINVAL; 401d1ff7024SMika Westerberg } 402d1ff7024SMika Westerberg 403d1ff7024SMika Westerberg len = xdomain_property_block_len - req->offset; 404d1ff7024SMika Westerberg len = min_t(u16, len, TB_XDP_PROPERTIES_MAX_DATA_LENGTH); 405d1ff7024SMika Westerberg total_size = sizeof(*res) + len * 4; 406d1ff7024SMika Westerberg 407d1ff7024SMika Westerberg res = kzalloc(total_size, GFP_KERNEL); 408d1ff7024SMika Westerberg if (!res) { 409d1ff7024SMika Westerberg mutex_unlock(&xdomain_lock); 410d1ff7024SMika Westerberg return -ENOMEM; 411d1ff7024SMika Westerberg } 412d1ff7024SMika Westerberg 413d1ff7024SMika Westerberg tb_xdp_fill_header(&res->hdr, route, sequence, PROPERTIES_RESPONSE, 414d1ff7024SMika Westerberg total_size); 415d1ff7024SMika Westerberg res->generation = xdomain_property_block_gen; 416d1ff7024SMika Westerberg res->data_length = xdomain_property_block_len; 417d1ff7024SMika Westerberg res->offset = req->offset; 418d1ff7024SMika Westerberg uuid_copy(&res->src_uuid, src_uuid); 419d1ff7024SMika Westerberg uuid_copy(&res->dst_uuid, &req->src_uuid); 420d1ff7024SMika Westerberg memcpy(res->data, &xdomain_property_block[req->offset], len * 4); 421d1ff7024SMika Westerberg 422d1ff7024SMika Westerberg mutex_unlock(&xdomain_lock); 423d1ff7024SMika Westerberg 424d1ff7024SMika Westerberg ret = __tb_xdomain_response(ctl, res, total_size, 425d1ff7024SMika Westerberg TB_CFG_PKG_XDOMAIN_RESP); 426d1ff7024SMika Westerberg 427d1ff7024SMika Westerberg kfree(res); 428d1ff7024SMika Westerberg return ret; 429d1ff7024SMika Westerberg } 430d1ff7024SMika Westerberg 431d1ff7024SMika Westerberg static int tb_xdp_properties_changed_request(struct tb_ctl *ctl, u64 route, 432d1ff7024SMika Westerberg int retry, const uuid_t *uuid) 433d1ff7024SMika Westerberg { 434d1ff7024SMika Westerberg struct tb_xdp_properties_changed_response res; 435d1ff7024SMika Westerberg struct tb_xdp_properties_changed req; 436d1ff7024SMika Westerberg int ret; 437d1ff7024SMika Westerberg 438d1ff7024SMika Westerberg memset(&req, 0, sizeof(req)); 439d1ff7024SMika Westerberg tb_xdp_fill_header(&req.hdr, route, retry % 4, 440d1ff7024SMika Westerberg PROPERTIES_CHANGED_REQUEST, sizeof(req)); 441d1ff7024SMika Westerberg uuid_copy(&req.src_uuid, uuid); 442d1ff7024SMika Westerberg 443d1ff7024SMika Westerberg memset(&res, 0, sizeof(res)); 444d1ff7024SMika Westerberg ret = __tb_xdomain_request(ctl, &req, sizeof(req), 445d1ff7024SMika Westerberg TB_CFG_PKG_XDOMAIN_REQ, &res, sizeof(res), 446d1ff7024SMika Westerberg TB_CFG_PKG_XDOMAIN_RESP, 447d1ff7024SMika Westerberg XDOMAIN_DEFAULT_TIMEOUT); 448d1ff7024SMika Westerberg if (ret) 449d1ff7024SMika Westerberg return ret; 450d1ff7024SMika Westerberg 451d1ff7024SMika Westerberg return tb_xdp_handle_error(&res.hdr); 452d1ff7024SMika Westerberg } 453d1ff7024SMika Westerberg 454d1ff7024SMika Westerberg static int 455d1ff7024SMika Westerberg tb_xdp_properties_changed_response(struct tb_ctl *ctl, u64 route, u8 sequence) 456d1ff7024SMika Westerberg { 457d1ff7024SMika Westerberg struct tb_xdp_properties_changed_response res; 458d1ff7024SMika Westerberg 459d1ff7024SMika Westerberg memset(&res, 0, sizeof(res)); 460d1ff7024SMika Westerberg tb_xdp_fill_header(&res.hdr, route, sequence, 461d1ff7024SMika Westerberg PROPERTIES_CHANGED_RESPONSE, sizeof(res)); 462d1ff7024SMika Westerberg return __tb_xdomain_response(ctl, &res, sizeof(res), 463d1ff7024SMika Westerberg TB_CFG_PKG_XDOMAIN_RESP); 464d1ff7024SMika Westerberg } 465d1ff7024SMika Westerberg 466d1ff7024SMika Westerberg /** 467d1ff7024SMika Westerberg * tb_register_protocol_handler() - Register protocol handler 468d1ff7024SMika Westerberg * @handler: Handler to register 469d1ff7024SMika Westerberg * 470d1ff7024SMika Westerberg * This allows XDomain service drivers to hook into incoming XDomain 471d1ff7024SMika Westerberg * messages. After this function is called the service driver needs to 472d1ff7024SMika Westerberg * be able to handle calls to callback whenever a package with the 473d1ff7024SMika Westerberg * registered protocol is received. 474d1ff7024SMika Westerberg */ 475d1ff7024SMika Westerberg int tb_register_protocol_handler(struct tb_protocol_handler *handler) 476d1ff7024SMika Westerberg { 477d1ff7024SMika Westerberg if (!handler->uuid || !handler->callback) 478d1ff7024SMika Westerberg return -EINVAL; 479d1ff7024SMika Westerberg if (uuid_equal(handler->uuid, &tb_xdp_uuid)) 480d1ff7024SMika Westerberg return -EINVAL; 481d1ff7024SMika Westerberg 482d1ff7024SMika Westerberg mutex_lock(&xdomain_lock); 483d1ff7024SMika Westerberg list_add_tail(&handler->list, &protocol_handlers); 484d1ff7024SMika Westerberg mutex_unlock(&xdomain_lock); 485d1ff7024SMika Westerberg 486d1ff7024SMika Westerberg return 0; 487d1ff7024SMika Westerberg } 488d1ff7024SMika Westerberg EXPORT_SYMBOL_GPL(tb_register_protocol_handler); 489d1ff7024SMika Westerberg 490d1ff7024SMika Westerberg /** 491d1ff7024SMika Westerberg * tb_unregister_protocol_handler() - Unregister protocol handler 492d1ff7024SMika Westerberg * @handler: Handler to unregister 493d1ff7024SMika Westerberg * 494d1ff7024SMika Westerberg * Removes the previously registered protocol handler. 495d1ff7024SMika Westerberg */ 496d1ff7024SMika Westerberg void tb_unregister_protocol_handler(struct tb_protocol_handler *handler) 497d1ff7024SMika Westerberg { 498d1ff7024SMika Westerberg mutex_lock(&xdomain_lock); 499d1ff7024SMika Westerberg list_del_init(&handler->list); 500d1ff7024SMika Westerberg mutex_unlock(&xdomain_lock); 501d1ff7024SMika Westerberg } 502d1ff7024SMika Westerberg EXPORT_SYMBOL_GPL(tb_unregister_protocol_handler); 503d1ff7024SMika Westerberg 5048a00c67eSMika Westerberg static int rebuild_property_block(void) 5058a00c67eSMika Westerberg { 5068a00c67eSMika Westerberg u32 *block, len; 5078a00c67eSMika Westerberg int ret; 5088a00c67eSMika Westerberg 5098a00c67eSMika Westerberg ret = tb_property_format_dir(xdomain_property_dir, NULL, 0); 5108a00c67eSMika Westerberg if (ret < 0) 5118a00c67eSMika Westerberg return ret; 5128a00c67eSMika Westerberg 5138a00c67eSMika Westerberg len = ret; 5148a00c67eSMika Westerberg 5158a00c67eSMika Westerberg block = kcalloc(len, sizeof(u32), GFP_KERNEL); 5168a00c67eSMika Westerberg if (!block) 5178a00c67eSMika Westerberg return -ENOMEM; 5188a00c67eSMika Westerberg 5198a00c67eSMika Westerberg ret = tb_property_format_dir(xdomain_property_dir, block, len); 5208a00c67eSMika Westerberg if (ret) { 5218a00c67eSMika Westerberg kfree(block); 5228a00c67eSMika Westerberg return ret; 5238a00c67eSMika Westerberg } 5248a00c67eSMika Westerberg 5258a00c67eSMika Westerberg kfree(xdomain_property_block); 5268a00c67eSMika Westerberg xdomain_property_block = block; 5278a00c67eSMika Westerberg xdomain_property_block_len = len; 5288a00c67eSMika Westerberg xdomain_property_block_gen++; 5298a00c67eSMika Westerberg 5308a00c67eSMika Westerberg return 0; 5318a00c67eSMika Westerberg } 5328a00c67eSMika Westerberg 5338a00c67eSMika Westerberg static void finalize_property_block(void) 5348a00c67eSMika Westerberg { 5358a00c67eSMika Westerberg const struct tb_property *nodename; 5368a00c67eSMika Westerberg 5378a00c67eSMika Westerberg /* 5388a00c67eSMika Westerberg * On first XDomain connection we set up the the system 5398a00c67eSMika Westerberg * nodename. This delayed here because userspace may not have it 5408a00c67eSMika Westerberg * set when the driver is first probed. 5418a00c67eSMika Westerberg */ 5428a00c67eSMika Westerberg mutex_lock(&xdomain_lock); 5438a00c67eSMika Westerberg nodename = tb_property_find(xdomain_property_dir, "deviceid", 5448a00c67eSMika Westerberg TB_PROPERTY_TYPE_TEXT); 5458a00c67eSMika Westerberg if (!nodename) { 5468a00c67eSMika Westerberg tb_property_add_text(xdomain_property_dir, "deviceid", 5478a00c67eSMika Westerberg utsname()->nodename); 5488a00c67eSMika Westerberg rebuild_property_block(); 5498a00c67eSMika Westerberg } 5508a00c67eSMika Westerberg mutex_unlock(&xdomain_lock); 5518a00c67eSMika Westerberg } 5528a00c67eSMika Westerberg 553d1ff7024SMika Westerberg static void tb_xdp_handle_request(struct work_struct *work) 554d1ff7024SMika Westerberg { 555d1ff7024SMika Westerberg struct xdomain_request_work *xw = container_of(work, typeof(*xw), work); 556d1ff7024SMika Westerberg const struct tb_xdp_header *pkg = xw->pkg; 557d1ff7024SMika Westerberg const struct tb_xdomain_header *xhdr = &pkg->xd_hdr; 558d1ff7024SMika Westerberg struct tb *tb = xw->tb; 559d1ff7024SMika Westerberg struct tb_ctl *ctl = tb->ctl; 560d1ff7024SMika Westerberg const uuid_t *uuid; 561d1ff7024SMika Westerberg int ret = 0; 5629a03c3d3SDan Carpenter u32 sequence; 563d1ff7024SMika Westerberg u64 route; 564d1ff7024SMika Westerberg 565d1ff7024SMika Westerberg route = ((u64)xhdr->route_hi << 32 | xhdr->route_lo) & ~BIT_ULL(63); 566d1ff7024SMika Westerberg sequence = xhdr->length_sn & TB_XDOMAIN_SN_MASK; 567d1ff7024SMika Westerberg sequence >>= TB_XDOMAIN_SN_SHIFT; 568d1ff7024SMika Westerberg 569d1ff7024SMika Westerberg mutex_lock(&tb->lock); 570d1ff7024SMika Westerberg if (tb->root_switch) 571d1ff7024SMika Westerberg uuid = tb->root_switch->uuid; 572d1ff7024SMika Westerberg else 573d1ff7024SMika Westerberg uuid = NULL; 574d1ff7024SMika Westerberg mutex_unlock(&tb->lock); 575d1ff7024SMika Westerberg 576d1ff7024SMika Westerberg if (!uuid) { 577d1ff7024SMika Westerberg tb_xdp_error_response(ctl, route, sequence, ERROR_NOT_READY); 578d1ff7024SMika Westerberg goto out; 579d1ff7024SMika Westerberg } 580d1ff7024SMika Westerberg 5818a00c67eSMika Westerberg finalize_property_block(); 5828a00c67eSMika Westerberg 583d1ff7024SMika Westerberg switch (pkg->type) { 584d1ff7024SMika Westerberg case PROPERTIES_REQUEST: 585d1ff7024SMika Westerberg ret = tb_xdp_properties_response(tb, ctl, route, sequence, uuid, 586d1ff7024SMika Westerberg (const struct tb_xdp_properties *)pkg); 587d1ff7024SMika Westerberg break; 588d1ff7024SMika Westerberg 589d1ff7024SMika Westerberg case PROPERTIES_CHANGED_REQUEST: { 590d1ff7024SMika Westerberg const struct tb_xdp_properties_changed *xchg = 591d1ff7024SMika Westerberg (const struct tb_xdp_properties_changed *)pkg; 592d1ff7024SMika Westerberg struct tb_xdomain *xd; 593d1ff7024SMika Westerberg 594d1ff7024SMika Westerberg ret = tb_xdp_properties_changed_response(ctl, route, sequence); 595d1ff7024SMika Westerberg 596d1ff7024SMika Westerberg /* 597d1ff7024SMika Westerberg * Since the properties have been changed, let's update 598d1ff7024SMika Westerberg * the xdomain related to this connection as well in 599d1ff7024SMika Westerberg * case there is a change in services it offers. 600d1ff7024SMika Westerberg */ 601d1ff7024SMika Westerberg xd = tb_xdomain_find_by_uuid_locked(tb, &xchg->src_uuid); 602d1ff7024SMika Westerberg if (xd) { 603d1ff7024SMika Westerberg queue_delayed_work(tb->wq, &xd->get_properties_work, 604d1ff7024SMika Westerberg msecs_to_jiffies(50)); 605d1ff7024SMika Westerberg tb_xdomain_put(xd); 606d1ff7024SMika Westerberg } 607d1ff7024SMika Westerberg 608d1ff7024SMika Westerberg break; 609d1ff7024SMika Westerberg } 610d1ff7024SMika Westerberg 6113b4b3235SMika Westerberg case UUID_REQUEST_OLD: 6123b4b3235SMika Westerberg case UUID_REQUEST: 6133b4b3235SMika Westerberg ret = tb_xdp_uuid_response(ctl, route, sequence, uuid); 6143b4b3235SMika Westerberg break; 6153b4b3235SMika Westerberg 616d1ff7024SMika Westerberg default: 6173b4b3235SMika Westerberg tb_xdp_error_response(ctl, route, sequence, 6183b4b3235SMika Westerberg ERROR_NOT_SUPPORTED); 619d1ff7024SMika Westerberg break; 620d1ff7024SMika Westerberg } 621d1ff7024SMika Westerberg 622d1ff7024SMika Westerberg if (ret) { 623d1ff7024SMika Westerberg tb_warn(tb, "failed to send XDomain response for %#x\n", 624d1ff7024SMika Westerberg pkg->type); 625d1ff7024SMika Westerberg } 626d1ff7024SMika Westerberg 627d1ff7024SMika Westerberg out: 628d1ff7024SMika Westerberg kfree(xw->pkg); 629d1ff7024SMika Westerberg kfree(xw); 630559c1e1eSMika Westerberg 631559c1e1eSMika Westerberg tb_domain_put(tb); 632d1ff7024SMika Westerberg } 633d1ff7024SMika Westerberg 63448f40b96SAditya Pakki static bool 635d1ff7024SMika Westerberg tb_xdp_schedule_request(struct tb *tb, const struct tb_xdp_header *hdr, 636d1ff7024SMika Westerberg size_t size) 637d1ff7024SMika Westerberg { 638d1ff7024SMika Westerberg struct xdomain_request_work *xw; 639d1ff7024SMika Westerberg 640d1ff7024SMika Westerberg xw = kmalloc(sizeof(*xw), GFP_KERNEL); 641d1ff7024SMika Westerberg if (!xw) 64248f40b96SAditya Pakki return false; 643d1ff7024SMika Westerberg 644d1ff7024SMika Westerberg INIT_WORK(&xw->work, tb_xdp_handle_request); 645d1ff7024SMika Westerberg xw->pkg = kmemdup(hdr, size, GFP_KERNEL); 64648f40b96SAditya Pakki if (!xw->pkg) { 64748f40b96SAditya Pakki kfree(xw); 64848f40b96SAditya Pakki return false; 64948f40b96SAditya Pakki } 650559c1e1eSMika Westerberg xw->tb = tb_domain_get(tb); 651d1ff7024SMika Westerberg 652559c1e1eSMika Westerberg schedule_work(&xw->work); 65348f40b96SAditya Pakki return true; 654d1ff7024SMika Westerberg } 655d1ff7024SMika Westerberg 656d1ff7024SMika Westerberg /** 657d1ff7024SMika Westerberg * tb_register_service_driver() - Register XDomain service driver 658d1ff7024SMika Westerberg * @drv: Driver to register 659d1ff7024SMika Westerberg * 660d1ff7024SMika Westerberg * Registers new service driver from @drv to the bus. 661d1ff7024SMika Westerberg */ 662d1ff7024SMika Westerberg int tb_register_service_driver(struct tb_service_driver *drv) 663d1ff7024SMika Westerberg { 664d1ff7024SMika Westerberg drv->driver.bus = &tb_bus_type; 665d1ff7024SMika Westerberg return driver_register(&drv->driver); 666d1ff7024SMika Westerberg } 667d1ff7024SMika Westerberg EXPORT_SYMBOL_GPL(tb_register_service_driver); 668d1ff7024SMika Westerberg 669d1ff7024SMika Westerberg /** 670d1ff7024SMika Westerberg * tb_unregister_service_driver() - Unregister XDomain service driver 671d1ff7024SMika Westerberg * @xdrv: Driver to unregister 672d1ff7024SMika Westerberg * 673d1ff7024SMika Westerberg * Unregisters XDomain service driver from the bus. 674d1ff7024SMika Westerberg */ 675d1ff7024SMika Westerberg void tb_unregister_service_driver(struct tb_service_driver *drv) 676d1ff7024SMika Westerberg { 677d1ff7024SMika Westerberg driver_unregister(&drv->driver); 678d1ff7024SMika Westerberg } 679d1ff7024SMika Westerberg EXPORT_SYMBOL_GPL(tb_unregister_service_driver); 680d1ff7024SMika Westerberg 681d1ff7024SMika Westerberg static ssize_t key_show(struct device *dev, struct device_attribute *attr, 682d1ff7024SMika Westerberg char *buf) 683d1ff7024SMika Westerberg { 684d1ff7024SMika Westerberg struct tb_service *svc = container_of(dev, struct tb_service, dev); 685d1ff7024SMika Westerberg 686d1ff7024SMika Westerberg /* 687d1ff7024SMika Westerberg * It should be null terminated but anything else is pretty much 688d1ff7024SMika Westerberg * allowed. 689d1ff7024SMika Westerberg */ 69004f77453SJ. Bruce Fields return sprintf(buf, "%*pE\n", (int)strlen(svc->key), svc->key); 691d1ff7024SMika Westerberg } 692d1ff7024SMika Westerberg static DEVICE_ATTR_RO(key); 693d1ff7024SMika Westerberg 694d1ff7024SMika Westerberg static int get_modalias(struct tb_service *svc, char *buf, size_t size) 695d1ff7024SMika Westerberg { 696d1ff7024SMika Westerberg return snprintf(buf, size, "tbsvc:k%sp%08Xv%08Xr%08X", svc->key, 697d1ff7024SMika Westerberg svc->prtcid, svc->prtcvers, svc->prtcrevs); 698d1ff7024SMika Westerberg } 699d1ff7024SMika Westerberg 700d1ff7024SMika Westerberg static ssize_t modalias_show(struct device *dev, struct device_attribute *attr, 701d1ff7024SMika Westerberg char *buf) 702d1ff7024SMika Westerberg { 703d1ff7024SMika Westerberg struct tb_service *svc = container_of(dev, struct tb_service, dev); 704d1ff7024SMika Westerberg 705d1ff7024SMika Westerberg /* Full buffer size except new line and null termination */ 706d1ff7024SMika Westerberg get_modalias(svc, buf, PAGE_SIZE - 2); 707d1ff7024SMika Westerberg return sprintf(buf, "%s\n", buf); 708d1ff7024SMika Westerberg } 709d1ff7024SMika Westerberg static DEVICE_ATTR_RO(modalias); 710d1ff7024SMika Westerberg 711d1ff7024SMika Westerberg static ssize_t prtcid_show(struct device *dev, struct device_attribute *attr, 712d1ff7024SMika Westerberg char *buf) 713d1ff7024SMika Westerberg { 714d1ff7024SMika Westerberg struct tb_service *svc = container_of(dev, struct tb_service, dev); 715d1ff7024SMika Westerberg 716d1ff7024SMika Westerberg return sprintf(buf, "%u\n", svc->prtcid); 717d1ff7024SMika Westerberg } 718d1ff7024SMika Westerberg static DEVICE_ATTR_RO(prtcid); 719d1ff7024SMika Westerberg 720d1ff7024SMika Westerberg static ssize_t prtcvers_show(struct device *dev, struct device_attribute *attr, 721d1ff7024SMika Westerberg char *buf) 722d1ff7024SMika Westerberg { 723d1ff7024SMika Westerberg struct tb_service *svc = container_of(dev, struct tb_service, dev); 724d1ff7024SMika Westerberg 725d1ff7024SMika Westerberg return sprintf(buf, "%u\n", svc->prtcvers); 726d1ff7024SMika Westerberg } 727d1ff7024SMika Westerberg static DEVICE_ATTR_RO(prtcvers); 728d1ff7024SMika Westerberg 729d1ff7024SMika Westerberg static ssize_t prtcrevs_show(struct device *dev, struct device_attribute *attr, 730d1ff7024SMika Westerberg char *buf) 731d1ff7024SMika Westerberg { 732d1ff7024SMika Westerberg struct tb_service *svc = container_of(dev, struct tb_service, dev); 733d1ff7024SMika Westerberg 734d1ff7024SMika Westerberg return sprintf(buf, "%u\n", svc->prtcrevs); 735d1ff7024SMika Westerberg } 736d1ff7024SMika Westerberg static DEVICE_ATTR_RO(prtcrevs); 737d1ff7024SMika Westerberg 738d1ff7024SMika Westerberg static ssize_t prtcstns_show(struct device *dev, struct device_attribute *attr, 739d1ff7024SMika Westerberg char *buf) 740d1ff7024SMika Westerberg { 741d1ff7024SMika Westerberg struct tb_service *svc = container_of(dev, struct tb_service, dev); 742d1ff7024SMika Westerberg 743d1ff7024SMika Westerberg return sprintf(buf, "0x%08x\n", svc->prtcstns); 744d1ff7024SMika Westerberg } 745d1ff7024SMika Westerberg static DEVICE_ATTR_RO(prtcstns); 746d1ff7024SMika Westerberg 747d1ff7024SMika Westerberg static struct attribute *tb_service_attrs[] = { 748d1ff7024SMika Westerberg &dev_attr_key.attr, 749d1ff7024SMika Westerberg &dev_attr_modalias.attr, 750d1ff7024SMika Westerberg &dev_attr_prtcid.attr, 751d1ff7024SMika Westerberg &dev_attr_prtcvers.attr, 752d1ff7024SMika Westerberg &dev_attr_prtcrevs.attr, 753d1ff7024SMika Westerberg &dev_attr_prtcstns.attr, 754d1ff7024SMika Westerberg NULL, 755d1ff7024SMika Westerberg }; 756d1ff7024SMika Westerberg 757d1ff7024SMika Westerberg static struct attribute_group tb_service_attr_group = { 758d1ff7024SMika Westerberg .attrs = tb_service_attrs, 759d1ff7024SMika Westerberg }; 760d1ff7024SMika Westerberg 761d1ff7024SMika Westerberg static const struct attribute_group *tb_service_attr_groups[] = { 762d1ff7024SMika Westerberg &tb_service_attr_group, 763d1ff7024SMika Westerberg NULL, 764d1ff7024SMika Westerberg }; 765d1ff7024SMika Westerberg 766d1ff7024SMika Westerberg static int tb_service_uevent(struct device *dev, struct kobj_uevent_env *env) 767d1ff7024SMika Westerberg { 768d1ff7024SMika Westerberg struct tb_service *svc = container_of(dev, struct tb_service, dev); 769d1ff7024SMika Westerberg char modalias[64]; 770d1ff7024SMika Westerberg 771d1ff7024SMika Westerberg get_modalias(svc, modalias, sizeof(modalias)); 772d1ff7024SMika Westerberg return add_uevent_var(env, "MODALIAS=%s", modalias); 773d1ff7024SMika Westerberg } 774d1ff7024SMika Westerberg 775d1ff7024SMika Westerberg static void tb_service_release(struct device *dev) 776d1ff7024SMika Westerberg { 777d1ff7024SMika Westerberg struct tb_service *svc = container_of(dev, struct tb_service, dev); 778d1ff7024SMika Westerberg struct tb_xdomain *xd = tb_service_parent(svc); 779d1ff7024SMika Westerberg 780d1ff7024SMika Westerberg ida_simple_remove(&xd->service_ids, svc->id); 781d1ff7024SMika Westerberg kfree(svc->key); 782d1ff7024SMika Westerberg kfree(svc); 783d1ff7024SMika Westerberg } 784d1ff7024SMika Westerberg 785d1ff7024SMika Westerberg struct device_type tb_service_type = { 786d1ff7024SMika Westerberg .name = "thunderbolt_service", 787d1ff7024SMika Westerberg .groups = tb_service_attr_groups, 788d1ff7024SMika Westerberg .uevent = tb_service_uevent, 789d1ff7024SMika Westerberg .release = tb_service_release, 790d1ff7024SMika Westerberg }; 791d1ff7024SMika Westerberg EXPORT_SYMBOL_GPL(tb_service_type); 792d1ff7024SMika Westerberg 793d1ff7024SMika Westerberg static int remove_missing_service(struct device *dev, void *data) 794d1ff7024SMika Westerberg { 795d1ff7024SMika Westerberg struct tb_xdomain *xd = data; 796d1ff7024SMika Westerberg struct tb_service *svc; 797d1ff7024SMika Westerberg 798d1ff7024SMika Westerberg svc = tb_to_service(dev); 799d1ff7024SMika Westerberg if (!svc) 800d1ff7024SMika Westerberg return 0; 801d1ff7024SMika Westerberg 802d1ff7024SMika Westerberg if (!tb_property_find(xd->properties, svc->key, 803d1ff7024SMika Westerberg TB_PROPERTY_TYPE_DIRECTORY)) 804d1ff7024SMika Westerberg device_unregister(dev); 805d1ff7024SMika Westerberg 806d1ff7024SMika Westerberg return 0; 807d1ff7024SMika Westerberg } 808d1ff7024SMika Westerberg 809d1ff7024SMika Westerberg static int find_service(struct device *dev, void *data) 810d1ff7024SMika Westerberg { 811d1ff7024SMika Westerberg const struct tb_property *p = data; 812d1ff7024SMika Westerberg struct tb_service *svc; 813d1ff7024SMika Westerberg 814d1ff7024SMika Westerberg svc = tb_to_service(dev); 815d1ff7024SMika Westerberg if (!svc) 816d1ff7024SMika Westerberg return 0; 817d1ff7024SMika Westerberg 818d1ff7024SMika Westerberg return !strcmp(svc->key, p->key); 819d1ff7024SMika Westerberg } 820d1ff7024SMika Westerberg 821d1ff7024SMika Westerberg static int populate_service(struct tb_service *svc, 822d1ff7024SMika Westerberg struct tb_property *property) 823d1ff7024SMika Westerberg { 824d1ff7024SMika Westerberg struct tb_property_dir *dir = property->value.dir; 825d1ff7024SMika Westerberg struct tb_property *p; 826d1ff7024SMika Westerberg 827d1ff7024SMika Westerberg /* Fill in standard properties */ 828d1ff7024SMika Westerberg p = tb_property_find(dir, "prtcid", TB_PROPERTY_TYPE_VALUE); 829d1ff7024SMika Westerberg if (p) 830d1ff7024SMika Westerberg svc->prtcid = p->value.immediate; 831d1ff7024SMika Westerberg p = tb_property_find(dir, "prtcvers", TB_PROPERTY_TYPE_VALUE); 832d1ff7024SMika Westerberg if (p) 833d1ff7024SMika Westerberg svc->prtcvers = p->value.immediate; 834d1ff7024SMika Westerberg p = tb_property_find(dir, "prtcrevs", TB_PROPERTY_TYPE_VALUE); 835d1ff7024SMika Westerberg if (p) 836d1ff7024SMika Westerberg svc->prtcrevs = p->value.immediate; 837d1ff7024SMika Westerberg p = tb_property_find(dir, "prtcstns", TB_PROPERTY_TYPE_VALUE); 838d1ff7024SMika Westerberg if (p) 839d1ff7024SMika Westerberg svc->prtcstns = p->value.immediate; 840d1ff7024SMika Westerberg 841d1ff7024SMika Westerberg svc->key = kstrdup(property->key, GFP_KERNEL); 842d1ff7024SMika Westerberg if (!svc->key) 843d1ff7024SMika Westerberg return -ENOMEM; 844d1ff7024SMika Westerberg 845d1ff7024SMika Westerberg return 0; 846d1ff7024SMika Westerberg } 847d1ff7024SMika Westerberg 848d1ff7024SMika Westerberg static void enumerate_services(struct tb_xdomain *xd) 849d1ff7024SMika Westerberg { 850d1ff7024SMika Westerberg struct tb_service *svc; 851d1ff7024SMika Westerberg struct tb_property *p; 852d1ff7024SMika Westerberg struct device *dev; 8539aabb685SAditya Pakki int id; 854d1ff7024SMika Westerberg 855d1ff7024SMika Westerberg /* 856d1ff7024SMika Westerberg * First remove all services that are not available anymore in 857d1ff7024SMika Westerberg * the updated property block. 858d1ff7024SMika Westerberg */ 859d1ff7024SMika Westerberg device_for_each_child_reverse(&xd->dev, xd, remove_missing_service); 860d1ff7024SMika Westerberg 861d1ff7024SMika Westerberg /* Then re-enumerate properties creating new services as we go */ 862d1ff7024SMika Westerberg tb_property_for_each(xd->properties, p) { 863d1ff7024SMika Westerberg if (p->type != TB_PROPERTY_TYPE_DIRECTORY) 864d1ff7024SMika Westerberg continue; 865d1ff7024SMika Westerberg 866d1ff7024SMika Westerberg /* If the service exists already we are fine */ 867d1ff7024SMika Westerberg dev = device_find_child(&xd->dev, p, find_service); 868d1ff7024SMika Westerberg if (dev) { 869d1ff7024SMika Westerberg put_device(dev); 870d1ff7024SMika Westerberg continue; 871d1ff7024SMika Westerberg } 872d1ff7024SMika Westerberg 873d1ff7024SMika Westerberg svc = kzalloc(sizeof(*svc), GFP_KERNEL); 874d1ff7024SMika Westerberg if (!svc) 875d1ff7024SMika Westerberg break; 876d1ff7024SMika Westerberg 877d1ff7024SMika Westerberg if (populate_service(svc, p)) { 878d1ff7024SMika Westerberg kfree(svc); 879d1ff7024SMika Westerberg break; 880d1ff7024SMika Westerberg } 881d1ff7024SMika Westerberg 8829aabb685SAditya Pakki id = ida_simple_get(&xd->service_ids, 0, 0, GFP_KERNEL); 8839aabb685SAditya Pakki if (id < 0) { 884*a663e0dfSMika Westerberg kfree(svc->key); 8859aabb685SAditya Pakki kfree(svc); 8869aabb685SAditya Pakki break; 8879aabb685SAditya Pakki } 8889aabb685SAditya Pakki svc->id = id; 889d1ff7024SMika Westerberg svc->dev.bus = &tb_bus_type; 890d1ff7024SMika Westerberg svc->dev.type = &tb_service_type; 891d1ff7024SMika Westerberg svc->dev.parent = &xd->dev; 892d1ff7024SMika Westerberg dev_set_name(&svc->dev, "%s.%d", dev_name(&xd->dev), svc->id); 893d1ff7024SMika Westerberg 894d1ff7024SMika Westerberg if (device_register(&svc->dev)) { 895d1ff7024SMika Westerberg put_device(&svc->dev); 896d1ff7024SMika Westerberg break; 897d1ff7024SMika Westerberg } 898d1ff7024SMika Westerberg } 899d1ff7024SMika Westerberg } 900d1ff7024SMika Westerberg 901d1ff7024SMika Westerberg static int populate_properties(struct tb_xdomain *xd, 902d1ff7024SMika Westerberg struct tb_property_dir *dir) 903d1ff7024SMika Westerberg { 904d1ff7024SMika Westerberg const struct tb_property *p; 905d1ff7024SMika Westerberg 906d1ff7024SMika Westerberg /* Required properties */ 907d1ff7024SMika Westerberg p = tb_property_find(dir, "deviceid", TB_PROPERTY_TYPE_VALUE); 908d1ff7024SMika Westerberg if (!p) 909d1ff7024SMika Westerberg return -EINVAL; 910d1ff7024SMika Westerberg xd->device = p->value.immediate; 911d1ff7024SMika Westerberg 912d1ff7024SMika Westerberg p = tb_property_find(dir, "vendorid", TB_PROPERTY_TYPE_VALUE); 913d1ff7024SMika Westerberg if (!p) 914d1ff7024SMika Westerberg return -EINVAL; 915d1ff7024SMika Westerberg xd->vendor = p->value.immediate; 916d1ff7024SMika Westerberg 917d1ff7024SMika Westerberg kfree(xd->device_name); 918d1ff7024SMika Westerberg xd->device_name = NULL; 919d1ff7024SMika Westerberg kfree(xd->vendor_name); 920d1ff7024SMika Westerberg xd->vendor_name = NULL; 921d1ff7024SMika Westerberg 922d1ff7024SMika Westerberg /* Optional properties */ 923d1ff7024SMika Westerberg p = tb_property_find(dir, "deviceid", TB_PROPERTY_TYPE_TEXT); 924d1ff7024SMika Westerberg if (p) 925d1ff7024SMika Westerberg xd->device_name = kstrdup(p->value.text, GFP_KERNEL); 926d1ff7024SMika Westerberg p = tb_property_find(dir, "vendorid", TB_PROPERTY_TYPE_TEXT); 927d1ff7024SMika Westerberg if (p) 928d1ff7024SMika Westerberg xd->vendor_name = kstrdup(p->value.text, GFP_KERNEL); 929d1ff7024SMika Westerberg 930d1ff7024SMika Westerberg return 0; 931d1ff7024SMika Westerberg } 932d1ff7024SMika Westerberg 933d1ff7024SMika Westerberg /* Called with @xd->lock held */ 934d1ff7024SMika Westerberg static void tb_xdomain_restore_paths(struct tb_xdomain *xd) 935d1ff7024SMika Westerberg { 936d1ff7024SMika Westerberg if (!xd->resume) 937d1ff7024SMika Westerberg return; 938d1ff7024SMika Westerberg 939d1ff7024SMika Westerberg xd->resume = false; 940d1ff7024SMika Westerberg if (xd->transmit_path) { 941d1ff7024SMika Westerberg dev_dbg(&xd->dev, "re-establishing DMA path\n"); 942d1ff7024SMika Westerberg tb_domain_approve_xdomain_paths(xd->tb, xd); 943d1ff7024SMika Westerberg } 944d1ff7024SMika Westerberg } 945d1ff7024SMika Westerberg 9463b4b3235SMika Westerberg static void tb_xdomain_get_uuid(struct work_struct *work) 9473b4b3235SMika Westerberg { 9483b4b3235SMika Westerberg struct tb_xdomain *xd = container_of(work, typeof(*xd), 9493b4b3235SMika Westerberg get_uuid_work.work); 9503b4b3235SMika Westerberg struct tb *tb = xd->tb; 9513b4b3235SMika Westerberg uuid_t uuid; 9523b4b3235SMika Westerberg int ret; 9533b4b3235SMika Westerberg 9543b4b3235SMika Westerberg ret = tb_xdp_uuid_request(tb->ctl, xd->route, xd->uuid_retries, &uuid); 9553b4b3235SMika Westerberg if (ret < 0) { 9563b4b3235SMika Westerberg if (xd->uuid_retries-- > 0) { 9573b4b3235SMika Westerberg queue_delayed_work(xd->tb->wq, &xd->get_uuid_work, 9583b4b3235SMika Westerberg msecs_to_jiffies(100)); 9593b4b3235SMika Westerberg } else { 9603b4b3235SMika Westerberg dev_dbg(&xd->dev, "failed to read remote UUID\n"); 9613b4b3235SMika Westerberg } 9623b4b3235SMika Westerberg return; 9633b4b3235SMika Westerberg } 9643b4b3235SMika Westerberg 9653b4b3235SMika Westerberg if (uuid_equal(&uuid, xd->local_uuid)) { 9663b4b3235SMika Westerberg dev_dbg(&xd->dev, "intra-domain loop detected\n"); 9673b4b3235SMika Westerberg return; 9683b4b3235SMika Westerberg } 9693b4b3235SMika Westerberg 9703b4b3235SMika Westerberg /* 9713b4b3235SMika Westerberg * If the UUID is different, there is another domain connected 9723b4b3235SMika Westerberg * so mark this one unplugged and wait for the connection 9733b4b3235SMika Westerberg * manager to replace it. 9743b4b3235SMika Westerberg */ 9753b4b3235SMika Westerberg if (xd->remote_uuid && !uuid_equal(&uuid, xd->remote_uuid)) { 9763b4b3235SMika Westerberg dev_dbg(&xd->dev, "remote UUID is different, unplugging\n"); 9773b4b3235SMika Westerberg xd->is_unplugged = true; 9783b4b3235SMika Westerberg return; 9793b4b3235SMika Westerberg } 9803b4b3235SMika Westerberg 9813b4b3235SMika Westerberg /* First time fill in the missing UUID */ 9823b4b3235SMika Westerberg if (!xd->remote_uuid) { 9833b4b3235SMika Westerberg xd->remote_uuid = kmemdup(&uuid, sizeof(uuid_t), GFP_KERNEL); 9843b4b3235SMika Westerberg if (!xd->remote_uuid) 9853b4b3235SMika Westerberg return; 9863b4b3235SMika Westerberg } 9873b4b3235SMika Westerberg 9883b4b3235SMika Westerberg /* Now we can start the normal properties exchange */ 9893b4b3235SMika Westerberg queue_delayed_work(xd->tb->wq, &xd->properties_changed_work, 9903b4b3235SMika Westerberg msecs_to_jiffies(100)); 9913b4b3235SMika Westerberg queue_delayed_work(xd->tb->wq, &xd->get_properties_work, 9923b4b3235SMika Westerberg msecs_to_jiffies(1000)); 9933b4b3235SMika Westerberg } 9943b4b3235SMika Westerberg 995d1ff7024SMika Westerberg static void tb_xdomain_get_properties(struct work_struct *work) 996d1ff7024SMika Westerberg { 997d1ff7024SMika Westerberg struct tb_xdomain *xd = container_of(work, typeof(*xd), 998d1ff7024SMika Westerberg get_properties_work.work); 999d1ff7024SMika Westerberg struct tb_property_dir *dir; 1000d1ff7024SMika Westerberg struct tb *tb = xd->tb; 1001d1ff7024SMika Westerberg bool update = false; 1002d1ff7024SMika Westerberg u32 *block = NULL; 1003d1ff7024SMika Westerberg u32 gen = 0; 1004d1ff7024SMika Westerberg int ret; 1005d1ff7024SMika Westerberg 1006d1ff7024SMika Westerberg ret = tb_xdp_properties_request(tb->ctl, xd->route, xd->local_uuid, 1007d1ff7024SMika Westerberg xd->remote_uuid, xd->properties_retries, 1008d1ff7024SMika Westerberg &block, &gen); 1009d1ff7024SMika Westerberg if (ret < 0) { 1010d1ff7024SMika Westerberg if (xd->properties_retries-- > 0) { 1011d1ff7024SMika Westerberg queue_delayed_work(xd->tb->wq, &xd->get_properties_work, 1012d1ff7024SMika Westerberg msecs_to_jiffies(1000)); 1013d1ff7024SMika Westerberg } else { 1014d1ff7024SMika Westerberg /* Give up now */ 1015d1ff7024SMika Westerberg dev_err(&xd->dev, 1016d1ff7024SMika Westerberg "failed read XDomain properties from %pUb\n", 1017d1ff7024SMika Westerberg xd->remote_uuid); 1018d1ff7024SMika Westerberg } 1019d1ff7024SMika Westerberg return; 1020d1ff7024SMika Westerberg } 1021d1ff7024SMika Westerberg 1022d1ff7024SMika Westerberg xd->properties_retries = XDOMAIN_PROPERTIES_RETRIES; 1023d1ff7024SMika Westerberg 1024d1ff7024SMika Westerberg mutex_lock(&xd->lock); 1025d1ff7024SMika Westerberg 1026d1ff7024SMika Westerberg /* Only accept newer generation properties */ 1027d1ff7024SMika Westerberg if (xd->properties && gen <= xd->property_block_gen) { 1028d1ff7024SMika Westerberg /* 1029d1ff7024SMika Westerberg * On resume it is likely that the properties block is 1030d1ff7024SMika Westerberg * not changed (unless the other end added or removed 1031d1ff7024SMika Westerberg * services). However, we need to make sure the existing 1032d1ff7024SMika Westerberg * DMA paths are restored properly. 1033d1ff7024SMika Westerberg */ 1034d1ff7024SMika Westerberg tb_xdomain_restore_paths(xd); 1035d1ff7024SMika Westerberg goto err_free_block; 1036d1ff7024SMika Westerberg } 1037d1ff7024SMika Westerberg 1038d1ff7024SMika Westerberg dir = tb_property_parse_dir(block, ret); 1039d1ff7024SMika Westerberg if (!dir) { 1040d1ff7024SMika Westerberg dev_err(&xd->dev, "failed to parse XDomain properties\n"); 1041d1ff7024SMika Westerberg goto err_free_block; 1042d1ff7024SMika Westerberg } 1043d1ff7024SMika Westerberg 1044d1ff7024SMika Westerberg ret = populate_properties(xd, dir); 1045d1ff7024SMika Westerberg if (ret) { 1046d1ff7024SMika Westerberg dev_err(&xd->dev, "missing XDomain properties in response\n"); 1047d1ff7024SMika Westerberg goto err_free_dir; 1048d1ff7024SMika Westerberg } 1049d1ff7024SMika Westerberg 1050d1ff7024SMika Westerberg /* Release the existing one */ 1051d1ff7024SMika Westerberg if (xd->properties) { 1052d1ff7024SMika Westerberg tb_property_free_dir(xd->properties); 1053d1ff7024SMika Westerberg update = true; 1054d1ff7024SMika Westerberg } 1055d1ff7024SMika Westerberg 1056d1ff7024SMika Westerberg xd->properties = dir; 1057d1ff7024SMika Westerberg xd->property_block_gen = gen; 1058d1ff7024SMika Westerberg 1059d1ff7024SMika Westerberg tb_xdomain_restore_paths(xd); 1060d1ff7024SMika Westerberg 1061d1ff7024SMika Westerberg mutex_unlock(&xd->lock); 1062d1ff7024SMika Westerberg 1063d1ff7024SMika Westerberg kfree(block); 1064d1ff7024SMika Westerberg 1065d1ff7024SMika Westerberg /* 1066d1ff7024SMika Westerberg * Now the device should be ready enough so we can add it to the 1067d1ff7024SMika Westerberg * bus and let userspace know about it. If the device is already 1068d1ff7024SMika Westerberg * registered, we notify the userspace that it has changed. 1069d1ff7024SMika Westerberg */ 1070d1ff7024SMika Westerberg if (!update) { 1071d1ff7024SMika Westerberg if (device_add(&xd->dev)) { 1072d1ff7024SMika Westerberg dev_err(&xd->dev, "failed to add XDomain device\n"); 1073d1ff7024SMika Westerberg return; 1074d1ff7024SMika Westerberg } 1075d1ff7024SMika Westerberg } else { 1076d1ff7024SMika Westerberg kobject_uevent(&xd->dev.kobj, KOBJ_CHANGE); 1077d1ff7024SMika Westerberg } 1078d1ff7024SMika Westerberg 1079d1ff7024SMika Westerberg enumerate_services(xd); 1080d1ff7024SMika Westerberg return; 1081d1ff7024SMika Westerberg 1082d1ff7024SMika Westerberg err_free_dir: 1083d1ff7024SMika Westerberg tb_property_free_dir(dir); 1084d1ff7024SMika Westerberg err_free_block: 1085d1ff7024SMika Westerberg kfree(block); 1086d1ff7024SMika Westerberg mutex_unlock(&xd->lock); 1087d1ff7024SMika Westerberg } 1088d1ff7024SMika Westerberg 1089d1ff7024SMika Westerberg static void tb_xdomain_properties_changed(struct work_struct *work) 1090d1ff7024SMika Westerberg { 1091d1ff7024SMika Westerberg struct tb_xdomain *xd = container_of(work, typeof(*xd), 1092d1ff7024SMika Westerberg properties_changed_work.work); 1093d1ff7024SMika Westerberg int ret; 1094d1ff7024SMika Westerberg 1095d1ff7024SMika Westerberg ret = tb_xdp_properties_changed_request(xd->tb->ctl, xd->route, 1096d1ff7024SMika Westerberg xd->properties_changed_retries, xd->local_uuid); 1097d1ff7024SMika Westerberg if (ret) { 1098d1ff7024SMika Westerberg if (xd->properties_changed_retries-- > 0) 1099d1ff7024SMika Westerberg queue_delayed_work(xd->tb->wq, 1100d1ff7024SMika Westerberg &xd->properties_changed_work, 1101d1ff7024SMika Westerberg msecs_to_jiffies(1000)); 1102d1ff7024SMika Westerberg return; 1103d1ff7024SMika Westerberg } 1104d1ff7024SMika Westerberg 1105d1ff7024SMika Westerberg xd->properties_changed_retries = XDOMAIN_PROPERTIES_CHANGED_RETRIES; 1106d1ff7024SMika Westerberg } 1107d1ff7024SMika Westerberg 1108d1ff7024SMika Westerberg static ssize_t device_show(struct device *dev, struct device_attribute *attr, 1109d1ff7024SMika Westerberg char *buf) 1110d1ff7024SMika Westerberg { 1111d1ff7024SMika Westerberg struct tb_xdomain *xd = container_of(dev, struct tb_xdomain, dev); 1112d1ff7024SMika Westerberg 1113d1ff7024SMika Westerberg return sprintf(buf, "%#x\n", xd->device); 1114d1ff7024SMika Westerberg } 1115d1ff7024SMika Westerberg static DEVICE_ATTR_RO(device); 1116d1ff7024SMika Westerberg 1117d1ff7024SMika Westerberg static ssize_t 1118d1ff7024SMika Westerberg device_name_show(struct device *dev, struct device_attribute *attr, char *buf) 1119d1ff7024SMika Westerberg { 1120d1ff7024SMika Westerberg struct tb_xdomain *xd = container_of(dev, struct tb_xdomain, dev); 1121d1ff7024SMika Westerberg int ret; 1122d1ff7024SMika Westerberg 1123d1ff7024SMika Westerberg if (mutex_lock_interruptible(&xd->lock)) 1124d1ff7024SMika Westerberg return -ERESTARTSYS; 1125d1ff7024SMika Westerberg ret = sprintf(buf, "%s\n", xd->device_name ? xd->device_name : ""); 1126d1ff7024SMika Westerberg mutex_unlock(&xd->lock); 1127d1ff7024SMika Westerberg 1128d1ff7024SMika Westerberg return ret; 1129d1ff7024SMika Westerberg } 1130d1ff7024SMika Westerberg static DEVICE_ATTR_RO(device_name); 1131d1ff7024SMika Westerberg 1132d1ff7024SMika Westerberg static ssize_t vendor_show(struct device *dev, struct device_attribute *attr, 1133d1ff7024SMika Westerberg char *buf) 1134d1ff7024SMika Westerberg { 1135d1ff7024SMika Westerberg struct tb_xdomain *xd = container_of(dev, struct tb_xdomain, dev); 1136d1ff7024SMika Westerberg 1137d1ff7024SMika Westerberg return sprintf(buf, "%#x\n", xd->vendor); 1138d1ff7024SMika Westerberg } 1139d1ff7024SMika Westerberg static DEVICE_ATTR_RO(vendor); 1140d1ff7024SMika Westerberg 1141d1ff7024SMika Westerberg static ssize_t 1142d1ff7024SMika Westerberg vendor_name_show(struct device *dev, struct device_attribute *attr, char *buf) 1143d1ff7024SMika Westerberg { 1144d1ff7024SMika Westerberg struct tb_xdomain *xd = container_of(dev, struct tb_xdomain, dev); 1145d1ff7024SMika Westerberg int ret; 1146d1ff7024SMika Westerberg 1147d1ff7024SMika Westerberg if (mutex_lock_interruptible(&xd->lock)) 1148d1ff7024SMika Westerberg return -ERESTARTSYS; 1149d1ff7024SMika Westerberg ret = sprintf(buf, "%s\n", xd->vendor_name ? xd->vendor_name : ""); 1150d1ff7024SMika Westerberg mutex_unlock(&xd->lock); 1151d1ff7024SMika Westerberg 1152d1ff7024SMika Westerberg return ret; 1153d1ff7024SMika Westerberg } 1154d1ff7024SMika Westerberg static DEVICE_ATTR_RO(vendor_name); 1155d1ff7024SMika Westerberg 1156d1ff7024SMika Westerberg static ssize_t unique_id_show(struct device *dev, struct device_attribute *attr, 1157d1ff7024SMika Westerberg char *buf) 1158d1ff7024SMika Westerberg { 1159d1ff7024SMika Westerberg struct tb_xdomain *xd = container_of(dev, struct tb_xdomain, dev); 1160d1ff7024SMika Westerberg 1161d1ff7024SMika Westerberg return sprintf(buf, "%pUb\n", xd->remote_uuid); 1162d1ff7024SMika Westerberg } 1163d1ff7024SMika Westerberg static DEVICE_ATTR_RO(unique_id); 1164d1ff7024SMika Westerberg 1165d1ff7024SMika Westerberg static struct attribute *xdomain_attrs[] = { 1166d1ff7024SMika Westerberg &dev_attr_device.attr, 1167d1ff7024SMika Westerberg &dev_attr_device_name.attr, 1168d1ff7024SMika Westerberg &dev_attr_unique_id.attr, 1169d1ff7024SMika Westerberg &dev_attr_vendor.attr, 1170d1ff7024SMika Westerberg &dev_attr_vendor_name.attr, 1171d1ff7024SMika Westerberg NULL, 1172d1ff7024SMika Westerberg }; 1173d1ff7024SMika Westerberg 1174d1ff7024SMika Westerberg static struct attribute_group xdomain_attr_group = { 1175d1ff7024SMika Westerberg .attrs = xdomain_attrs, 1176d1ff7024SMika Westerberg }; 1177d1ff7024SMika Westerberg 1178d1ff7024SMika Westerberg static const struct attribute_group *xdomain_attr_groups[] = { 1179d1ff7024SMika Westerberg &xdomain_attr_group, 1180d1ff7024SMika Westerberg NULL, 1181d1ff7024SMika Westerberg }; 1182d1ff7024SMika Westerberg 1183d1ff7024SMika Westerberg static void tb_xdomain_release(struct device *dev) 1184d1ff7024SMika Westerberg { 1185d1ff7024SMika Westerberg struct tb_xdomain *xd = container_of(dev, struct tb_xdomain, dev); 1186d1ff7024SMika Westerberg 1187d1ff7024SMika Westerberg put_device(xd->dev.parent); 1188d1ff7024SMika Westerberg 1189d1ff7024SMika Westerberg tb_property_free_dir(xd->properties); 1190d1ff7024SMika Westerberg ida_destroy(&xd->service_ids); 1191d1ff7024SMika Westerberg 1192d1ff7024SMika Westerberg kfree(xd->local_uuid); 1193d1ff7024SMika Westerberg kfree(xd->remote_uuid); 1194d1ff7024SMika Westerberg kfree(xd->device_name); 1195d1ff7024SMika Westerberg kfree(xd->vendor_name); 1196d1ff7024SMika Westerberg kfree(xd); 1197d1ff7024SMika Westerberg } 1198d1ff7024SMika Westerberg 1199d1ff7024SMika Westerberg static void start_handshake(struct tb_xdomain *xd) 1200d1ff7024SMika Westerberg { 12013b4b3235SMika Westerberg xd->uuid_retries = XDOMAIN_UUID_RETRIES; 1202d1ff7024SMika Westerberg xd->properties_retries = XDOMAIN_PROPERTIES_RETRIES; 1203d1ff7024SMika Westerberg xd->properties_changed_retries = XDOMAIN_PROPERTIES_CHANGED_RETRIES; 1204d1ff7024SMika Westerberg 12053b4b3235SMika Westerberg if (xd->needs_uuid) { 12063b4b3235SMika Westerberg queue_delayed_work(xd->tb->wq, &xd->get_uuid_work, 12073b4b3235SMika Westerberg msecs_to_jiffies(100)); 12083b4b3235SMika Westerberg } else { 1209d1ff7024SMika Westerberg /* Start exchanging properties with the other host */ 1210d1ff7024SMika Westerberg queue_delayed_work(xd->tb->wq, &xd->properties_changed_work, 1211d1ff7024SMika Westerberg msecs_to_jiffies(100)); 1212d1ff7024SMika Westerberg queue_delayed_work(xd->tb->wq, &xd->get_properties_work, 1213d1ff7024SMika Westerberg msecs_to_jiffies(1000)); 1214d1ff7024SMika Westerberg } 12153b4b3235SMika Westerberg } 1216d1ff7024SMika Westerberg 1217d1ff7024SMika Westerberg static void stop_handshake(struct tb_xdomain *xd) 1218d1ff7024SMika Westerberg { 12193b4b3235SMika Westerberg xd->uuid_retries = 0; 1220d1ff7024SMika Westerberg xd->properties_retries = 0; 1221d1ff7024SMika Westerberg xd->properties_changed_retries = 0; 1222d1ff7024SMika Westerberg 12233b4b3235SMika Westerberg cancel_delayed_work_sync(&xd->get_uuid_work); 1224d1ff7024SMika Westerberg cancel_delayed_work_sync(&xd->get_properties_work); 1225d1ff7024SMika Westerberg cancel_delayed_work_sync(&xd->properties_changed_work); 1226d1ff7024SMika Westerberg } 1227d1ff7024SMika Westerberg 1228d1ff7024SMika Westerberg static int __maybe_unused tb_xdomain_suspend(struct device *dev) 1229d1ff7024SMika Westerberg { 1230d1ff7024SMika Westerberg stop_handshake(tb_to_xdomain(dev)); 1231d1ff7024SMika Westerberg return 0; 1232d1ff7024SMika Westerberg } 1233d1ff7024SMika Westerberg 1234d1ff7024SMika Westerberg static int __maybe_unused tb_xdomain_resume(struct device *dev) 1235d1ff7024SMika Westerberg { 1236d1ff7024SMika Westerberg struct tb_xdomain *xd = tb_to_xdomain(dev); 1237d1ff7024SMika Westerberg 1238d1ff7024SMika Westerberg /* 1239d1ff7024SMika Westerberg * Ask tb_xdomain_get_properties() restore any existing DMA 1240d1ff7024SMika Westerberg * paths after properties are re-read. 1241d1ff7024SMika Westerberg */ 1242d1ff7024SMika Westerberg xd->resume = true; 1243d1ff7024SMika Westerberg start_handshake(xd); 1244d1ff7024SMika Westerberg 1245d1ff7024SMika Westerberg return 0; 1246d1ff7024SMika Westerberg } 1247d1ff7024SMika Westerberg 1248d1ff7024SMika Westerberg static const struct dev_pm_ops tb_xdomain_pm_ops = { 1249d1ff7024SMika Westerberg SET_SYSTEM_SLEEP_PM_OPS(tb_xdomain_suspend, tb_xdomain_resume) 1250d1ff7024SMika Westerberg }; 1251d1ff7024SMika Westerberg 1252d1ff7024SMika Westerberg struct device_type tb_xdomain_type = { 1253d1ff7024SMika Westerberg .name = "thunderbolt_xdomain", 1254d1ff7024SMika Westerberg .release = tb_xdomain_release, 1255d1ff7024SMika Westerberg .pm = &tb_xdomain_pm_ops, 1256d1ff7024SMika Westerberg }; 1257d1ff7024SMika Westerberg EXPORT_SYMBOL_GPL(tb_xdomain_type); 1258d1ff7024SMika Westerberg 1259d1ff7024SMika Westerberg /** 1260d1ff7024SMika Westerberg * tb_xdomain_alloc() - Allocate new XDomain object 1261d1ff7024SMika Westerberg * @tb: Domain where the XDomain belongs 1262d1ff7024SMika Westerberg * @parent: Parent device (the switch through the connection to the 1263d1ff7024SMika Westerberg * other domain is reached). 1264d1ff7024SMika Westerberg * @route: Route string used to reach the other domain 1265d1ff7024SMika Westerberg * @local_uuid: Our local domain UUID 12663b4b3235SMika Westerberg * @remote_uuid: UUID of the other domain (optional) 1267d1ff7024SMika Westerberg * 1268d1ff7024SMika Westerberg * Allocates new XDomain structure and returns pointer to that. The 1269d1ff7024SMika Westerberg * object must be released by calling tb_xdomain_put(). 1270d1ff7024SMika Westerberg */ 1271d1ff7024SMika Westerberg struct tb_xdomain *tb_xdomain_alloc(struct tb *tb, struct device *parent, 1272d1ff7024SMika Westerberg u64 route, const uuid_t *local_uuid, 1273d1ff7024SMika Westerberg const uuid_t *remote_uuid) 1274d1ff7024SMika Westerberg { 1275b0407983SMika Westerberg struct tb_switch *parent_sw = tb_to_switch(parent); 1276d1ff7024SMika Westerberg struct tb_xdomain *xd; 1277b0407983SMika Westerberg struct tb_port *down; 1278b0407983SMika Westerberg 1279b0407983SMika Westerberg /* Make sure the downstream domain is accessible */ 1280b0407983SMika Westerberg down = tb_port_at(route, parent_sw); 1281b0407983SMika Westerberg tb_port_unlock(down); 1282d1ff7024SMika Westerberg 1283d1ff7024SMika Westerberg xd = kzalloc(sizeof(*xd), GFP_KERNEL); 1284d1ff7024SMika Westerberg if (!xd) 1285d1ff7024SMika Westerberg return NULL; 1286d1ff7024SMika Westerberg 1287d1ff7024SMika Westerberg xd->tb = tb; 1288d1ff7024SMika Westerberg xd->route = route; 1289d1ff7024SMika Westerberg ida_init(&xd->service_ids); 1290d1ff7024SMika Westerberg mutex_init(&xd->lock); 12913b4b3235SMika Westerberg INIT_DELAYED_WORK(&xd->get_uuid_work, tb_xdomain_get_uuid); 1292d1ff7024SMika Westerberg INIT_DELAYED_WORK(&xd->get_properties_work, tb_xdomain_get_properties); 1293d1ff7024SMika Westerberg INIT_DELAYED_WORK(&xd->properties_changed_work, 1294d1ff7024SMika Westerberg tb_xdomain_properties_changed); 1295d1ff7024SMika Westerberg 1296d1ff7024SMika Westerberg xd->local_uuid = kmemdup(local_uuid, sizeof(uuid_t), GFP_KERNEL); 1297d1ff7024SMika Westerberg if (!xd->local_uuid) 1298d1ff7024SMika Westerberg goto err_free; 1299d1ff7024SMika Westerberg 13003b4b3235SMika Westerberg if (remote_uuid) { 13013b4b3235SMika Westerberg xd->remote_uuid = kmemdup(remote_uuid, sizeof(uuid_t), 13023b4b3235SMika Westerberg GFP_KERNEL); 1303d1ff7024SMika Westerberg if (!xd->remote_uuid) 1304d1ff7024SMika Westerberg goto err_free_local_uuid; 13053b4b3235SMika Westerberg } else { 13063b4b3235SMika Westerberg xd->needs_uuid = true; 13073b4b3235SMika Westerberg } 1308d1ff7024SMika Westerberg 1309d1ff7024SMika Westerberg device_initialize(&xd->dev); 1310d1ff7024SMika Westerberg xd->dev.parent = get_device(parent); 1311d1ff7024SMika Westerberg xd->dev.bus = &tb_bus_type; 1312d1ff7024SMika Westerberg xd->dev.type = &tb_xdomain_type; 1313d1ff7024SMika Westerberg xd->dev.groups = xdomain_attr_groups; 1314d1ff7024SMika Westerberg dev_set_name(&xd->dev, "%u-%llx", tb->index, route); 1315d1ff7024SMika Westerberg 13162d8ff0b5SMika Westerberg /* 13172d8ff0b5SMika Westerberg * This keeps the DMA powered on as long as we have active 13182d8ff0b5SMika Westerberg * connection to another host. 13192d8ff0b5SMika Westerberg */ 13202d8ff0b5SMika Westerberg pm_runtime_set_active(&xd->dev); 13212d8ff0b5SMika Westerberg pm_runtime_get_noresume(&xd->dev); 13222d8ff0b5SMika Westerberg pm_runtime_enable(&xd->dev); 13232d8ff0b5SMika Westerberg 1324d1ff7024SMika Westerberg return xd; 1325d1ff7024SMika Westerberg 1326d1ff7024SMika Westerberg err_free_local_uuid: 1327d1ff7024SMika Westerberg kfree(xd->local_uuid); 1328d1ff7024SMika Westerberg err_free: 1329d1ff7024SMika Westerberg kfree(xd); 1330d1ff7024SMika Westerberg 1331d1ff7024SMika Westerberg return NULL; 1332d1ff7024SMika Westerberg } 1333d1ff7024SMika Westerberg 1334d1ff7024SMika Westerberg /** 1335d1ff7024SMika Westerberg * tb_xdomain_add() - Add XDomain to the bus 1336d1ff7024SMika Westerberg * @xd: XDomain to add 1337d1ff7024SMika Westerberg * 1338d1ff7024SMika Westerberg * This function starts XDomain discovery protocol handshake and 1339d1ff7024SMika Westerberg * eventually adds the XDomain to the bus. After calling this function 1340d1ff7024SMika Westerberg * the caller needs to call tb_xdomain_remove() in order to remove and 1341d1ff7024SMika Westerberg * release the object regardless whether the handshake succeeded or not. 1342d1ff7024SMika Westerberg */ 1343d1ff7024SMika Westerberg void tb_xdomain_add(struct tb_xdomain *xd) 1344d1ff7024SMika Westerberg { 1345d1ff7024SMika Westerberg /* Start exchanging properties with the other host */ 1346d1ff7024SMika Westerberg start_handshake(xd); 1347d1ff7024SMika Westerberg } 1348d1ff7024SMika Westerberg 1349d1ff7024SMika Westerberg static int unregister_service(struct device *dev, void *data) 1350d1ff7024SMika Westerberg { 1351d1ff7024SMika Westerberg device_unregister(dev); 1352d1ff7024SMika Westerberg return 0; 1353d1ff7024SMika Westerberg } 1354d1ff7024SMika Westerberg 1355d1ff7024SMika Westerberg /** 1356d1ff7024SMika Westerberg * tb_xdomain_remove() - Remove XDomain from the bus 1357d1ff7024SMika Westerberg * @xd: XDomain to remove 1358d1ff7024SMika Westerberg * 1359d1ff7024SMika Westerberg * This will stop all ongoing configuration work and remove the XDomain 1360d1ff7024SMika Westerberg * along with any services from the bus. When the last reference to @xd 1361d1ff7024SMika Westerberg * is released the object will be released as well. 1362d1ff7024SMika Westerberg */ 1363d1ff7024SMika Westerberg void tb_xdomain_remove(struct tb_xdomain *xd) 1364d1ff7024SMika Westerberg { 1365d1ff7024SMika Westerberg stop_handshake(xd); 1366d1ff7024SMika Westerberg 1367d1ff7024SMika Westerberg device_for_each_child_reverse(&xd->dev, xd, unregister_service); 1368d1ff7024SMika Westerberg 13692d8ff0b5SMika Westerberg /* 13702d8ff0b5SMika Westerberg * Undo runtime PM here explicitly because it is possible that 13712d8ff0b5SMika Westerberg * the XDomain was never added to the bus and thus device_del() 13722d8ff0b5SMika Westerberg * is not called for it (device_del() would handle this otherwise). 13732d8ff0b5SMika Westerberg */ 13742d8ff0b5SMika Westerberg pm_runtime_disable(&xd->dev); 13752d8ff0b5SMika Westerberg pm_runtime_put_noidle(&xd->dev); 13762d8ff0b5SMika Westerberg pm_runtime_set_suspended(&xd->dev); 13772d8ff0b5SMika Westerberg 1378d1ff7024SMika Westerberg if (!device_is_registered(&xd->dev)) 1379d1ff7024SMika Westerberg put_device(&xd->dev); 1380d1ff7024SMika Westerberg else 1381d1ff7024SMika Westerberg device_unregister(&xd->dev); 1382d1ff7024SMika Westerberg } 1383d1ff7024SMika Westerberg 1384d1ff7024SMika Westerberg /** 1385d1ff7024SMika Westerberg * tb_xdomain_enable_paths() - Enable DMA paths for XDomain connection 1386d1ff7024SMika Westerberg * @xd: XDomain connection 1387d1ff7024SMika Westerberg * @transmit_path: HopID of the transmit path the other end is using to 1388d1ff7024SMika Westerberg * send packets 1389d1ff7024SMika Westerberg * @transmit_ring: DMA ring used to receive packets from the other end 1390d1ff7024SMika Westerberg * @receive_path: HopID of the receive path the other end is using to 1391d1ff7024SMika Westerberg * receive packets 1392d1ff7024SMika Westerberg * @receive_ring: DMA ring used to send packets to the other end 1393d1ff7024SMika Westerberg * 1394d1ff7024SMika Westerberg * The function enables DMA paths accordingly so that after successful 1395d1ff7024SMika Westerberg * return the caller can send and receive packets using high-speed DMA 1396d1ff7024SMika Westerberg * path. 1397d1ff7024SMika Westerberg * 1398d1ff7024SMika Westerberg * Return: %0 in case of success and negative errno in case of error 1399d1ff7024SMika Westerberg */ 1400d1ff7024SMika Westerberg int tb_xdomain_enable_paths(struct tb_xdomain *xd, u16 transmit_path, 1401d1ff7024SMika Westerberg u16 transmit_ring, u16 receive_path, 1402d1ff7024SMika Westerberg u16 receive_ring) 1403d1ff7024SMika Westerberg { 1404d1ff7024SMika Westerberg int ret; 1405d1ff7024SMika Westerberg 1406d1ff7024SMika Westerberg mutex_lock(&xd->lock); 1407d1ff7024SMika Westerberg 1408d1ff7024SMika Westerberg if (xd->transmit_path) { 1409d1ff7024SMika Westerberg ret = xd->transmit_path == transmit_path ? 0 : -EBUSY; 1410d1ff7024SMika Westerberg goto exit_unlock; 1411d1ff7024SMika Westerberg } 1412d1ff7024SMika Westerberg 1413d1ff7024SMika Westerberg xd->transmit_path = transmit_path; 1414d1ff7024SMika Westerberg xd->transmit_ring = transmit_ring; 1415d1ff7024SMika Westerberg xd->receive_path = receive_path; 1416d1ff7024SMika Westerberg xd->receive_ring = receive_ring; 1417d1ff7024SMika Westerberg 1418d1ff7024SMika Westerberg ret = tb_domain_approve_xdomain_paths(xd->tb, xd); 1419d1ff7024SMika Westerberg 1420d1ff7024SMika Westerberg exit_unlock: 1421d1ff7024SMika Westerberg mutex_unlock(&xd->lock); 1422d1ff7024SMika Westerberg 1423d1ff7024SMika Westerberg return ret; 1424d1ff7024SMika Westerberg } 1425d1ff7024SMika Westerberg EXPORT_SYMBOL_GPL(tb_xdomain_enable_paths); 1426d1ff7024SMika Westerberg 1427d1ff7024SMika Westerberg /** 1428d1ff7024SMika Westerberg * tb_xdomain_disable_paths() - Disable DMA paths for XDomain connection 1429d1ff7024SMika Westerberg * @xd: XDomain connection 1430d1ff7024SMika Westerberg * 1431d1ff7024SMika Westerberg * This does the opposite of tb_xdomain_enable_paths(). After call to 1432d1ff7024SMika Westerberg * this the caller is not expected to use the rings anymore. 1433d1ff7024SMika Westerberg * 1434d1ff7024SMika Westerberg * Return: %0 in case of success and negative errno in case of error 1435d1ff7024SMika Westerberg */ 1436d1ff7024SMika Westerberg int tb_xdomain_disable_paths(struct tb_xdomain *xd) 1437d1ff7024SMika Westerberg { 1438d1ff7024SMika Westerberg int ret = 0; 1439d1ff7024SMika Westerberg 1440d1ff7024SMika Westerberg mutex_lock(&xd->lock); 1441d1ff7024SMika Westerberg if (xd->transmit_path) { 1442d1ff7024SMika Westerberg xd->transmit_path = 0; 1443d1ff7024SMika Westerberg xd->transmit_ring = 0; 1444d1ff7024SMika Westerberg xd->receive_path = 0; 1445d1ff7024SMika Westerberg xd->receive_ring = 0; 1446d1ff7024SMika Westerberg 1447d1ff7024SMika Westerberg ret = tb_domain_disconnect_xdomain_paths(xd->tb, xd); 1448d1ff7024SMika Westerberg } 1449d1ff7024SMika Westerberg mutex_unlock(&xd->lock); 1450d1ff7024SMika Westerberg 1451d1ff7024SMika Westerberg return ret; 1452d1ff7024SMika Westerberg } 1453d1ff7024SMika Westerberg EXPORT_SYMBOL_GPL(tb_xdomain_disable_paths); 1454d1ff7024SMika Westerberg 1455d1ff7024SMika Westerberg struct tb_xdomain_lookup { 1456d1ff7024SMika Westerberg const uuid_t *uuid; 1457d1ff7024SMika Westerberg u8 link; 1458d1ff7024SMika Westerberg u8 depth; 1459484cb153SRadion Mirchevsky u64 route; 1460d1ff7024SMika Westerberg }; 1461d1ff7024SMika Westerberg 1462d1ff7024SMika Westerberg static struct tb_xdomain *switch_find_xdomain(struct tb_switch *sw, 1463d1ff7024SMika Westerberg const struct tb_xdomain_lookup *lookup) 1464d1ff7024SMika Westerberg { 1465b433d010SMika Westerberg struct tb_port *port; 1466d1ff7024SMika Westerberg 1467b433d010SMika Westerberg tb_switch_for_each_port(sw, port) { 1468d1ff7024SMika Westerberg struct tb_xdomain *xd; 1469d1ff7024SMika Westerberg 1470d1ff7024SMika Westerberg if (port->xdomain) { 1471d1ff7024SMika Westerberg xd = port->xdomain; 1472d1ff7024SMika Westerberg 1473d1ff7024SMika Westerberg if (lookup->uuid) { 14743b4b3235SMika Westerberg if (xd->remote_uuid && 14753b4b3235SMika Westerberg uuid_equal(xd->remote_uuid, lookup->uuid)) 1476d1ff7024SMika Westerberg return xd; 1477484cb153SRadion Mirchevsky } else if (lookup->link && 1478484cb153SRadion Mirchevsky lookup->link == xd->link && 1479d1ff7024SMika Westerberg lookup->depth == xd->depth) { 1480d1ff7024SMika Westerberg return xd; 1481484cb153SRadion Mirchevsky } else if (lookup->route && 1482484cb153SRadion Mirchevsky lookup->route == xd->route) { 1483484cb153SRadion Mirchevsky return xd; 1484d1ff7024SMika Westerberg } 1485dfe40ca4SMika Westerberg } else if (tb_port_has_remote(port)) { 1486d1ff7024SMika Westerberg xd = switch_find_xdomain(port->remote->sw, lookup); 1487d1ff7024SMika Westerberg if (xd) 1488d1ff7024SMika Westerberg return xd; 1489d1ff7024SMika Westerberg } 1490d1ff7024SMika Westerberg } 1491d1ff7024SMika Westerberg 1492d1ff7024SMika Westerberg return NULL; 1493d1ff7024SMika Westerberg } 1494d1ff7024SMika Westerberg 1495d1ff7024SMika Westerberg /** 1496d1ff7024SMika Westerberg * tb_xdomain_find_by_uuid() - Find an XDomain by UUID 1497d1ff7024SMika Westerberg * @tb: Domain where the XDomain belongs to 1498d1ff7024SMika Westerberg * @uuid: UUID to look for 1499d1ff7024SMika Westerberg * 1500d1ff7024SMika Westerberg * Finds XDomain by walking through the Thunderbolt topology below @tb. 1501d1ff7024SMika Westerberg * The returned XDomain will have its reference count increased so the 1502d1ff7024SMika Westerberg * caller needs to call tb_xdomain_put() when it is done with the 1503d1ff7024SMika Westerberg * object. 1504d1ff7024SMika Westerberg * 1505d1ff7024SMika Westerberg * This will find all XDomains including the ones that are not yet added 1506d1ff7024SMika Westerberg * to the bus (handshake is still in progress). 1507d1ff7024SMika Westerberg * 1508d1ff7024SMika Westerberg * The caller needs to hold @tb->lock. 1509d1ff7024SMika Westerberg */ 1510d1ff7024SMika Westerberg struct tb_xdomain *tb_xdomain_find_by_uuid(struct tb *tb, const uuid_t *uuid) 1511d1ff7024SMika Westerberg { 1512d1ff7024SMika Westerberg struct tb_xdomain_lookup lookup; 1513d1ff7024SMika Westerberg struct tb_xdomain *xd; 1514d1ff7024SMika Westerberg 1515d1ff7024SMika Westerberg memset(&lookup, 0, sizeof(lookup)); 1516d1ff7024SMika Westerberg lookup.uuid = uuid; 1517d1ff7024SMika Westerberg 1518d1ff7024SMika Westerberg xd = switch_find_xdomain(tb->root_switch, &lookup); 1519484cb153SRadion Mirchevsky return tb_xdomain_get(xd); 1520d1ff7024SMika Westerberg } 1521d1ff7024SMika Westerberg EXPORT_SYMBOL_GPL(tb_xdomain_find_by_uuid); 1522d1ff7024SMika Westerberg 1523d1ff7024SMika Westerberg /** 1524d1ff7024SMika Westerberg * tb_xdomain_find_by_link_depth() - Find an XDomain by link and depth 1525d1ff7024SMika Westerberg * @tb: Domain where the XDomain belongs to 1526d1ff7024SMika Westerberg * @link: Root switch link number 1527d1ff7024SMika Westerberg * @depth: Depth in the link 1528d1ff7024SMika Westerberg * 1529d1ff7024SMika Westerberg * Finds XDomain by walking through the Thunderbolt topology below @tb. 1530d1ff7024SMika Westerberg * The returned XDomain will have its reference count increased so the 1531d1ff7024SMika Westerberg * caller needs to call tb_xdomain_put() when it is done with the 1532d1ff7024SMika Westerberg * object. 1533d1ff7024SMika Westerberg * 1534d1ff7024SMika Westerberg * This will find all XDomains including the ones that are not yet added 1535d1ff7024SMika Westerberg * to the bus (handshake is still in progress). 1536d1ff7024SMika Westerberg * 1537d1ff7024SMika Westerberg * The caller needs to hold @tb->lock. 1538d1ff7024SMika Westerberg */ 1539d1ff7024SMika Westerberg struct tb_xdomain *tb_xdomain_find_by_link_depth(struct tb *tb, u8 link, 1540d1ff7024SMika Westerberg u8 depth) 1541d1ff7024SMika Westerberg { 1542d1ff7024SMika Westerberg struct tb_xdomain_lookup lookup; 1543d1ff7024SMika Westerberg struct tb_xdomain *xd; 1544d1ff7024SMika Westerberg 1545d1ff7024SMika Westerberg memset(&lookup, 0, sizeof(lookup)); 1546d1ff7024SMika Westerberg lookup.link = link; 1547d1ff7024SMika Westerberg lookup.depth = depth; 1548d1ff7024SMika Westerberg 1549d1ff7024SMika Westerberg xd = switch_find_xdomain(tb->root_switch, &lookup); 1550484cb153SRadion Mirchevsky return tb_xdomain_get(xd); 1551d1ff7024SMika Westerberg } 1552d1ff7024SMika Westerberg 1553484cb153SRadion Mirchevsky /** 1554484cb153SRadion Mirchevsky * tb_xdomain_find_by_route() - Find an XDomain by route string 1555484cb153SRadion Mirchevsky * @tb: Domain where the XDomain belongs to 1556484cb153SRadion Mirchevsky * @route: XDomain route string 1557484cb153SRadion Mirchevsky * 1558484cb153SRadion Mirchevsky * Finds XDomain by walking through the Thunderbolt topology below @tb. 1559484cb153SRadion Mirchevsky * The returned XDomain will have its reference count increased so the 1560484cb153SRadion Mirchevsky * caller needs to call tb_xdomain_put() when it is done with the 1561484cb153SRadion Mirchevsky * object. 1562484cb153SRadion Mirchevsky * 1563484cb153SRadion Mirchevsky * This will find all XDomains including the ones that are not yet added 1564484cb153SRadion Mirchevsky * to the bus (handshake is still in progress). 1565484cb153SRadion Mirchevsky * 1566484cb153SRadion Mirchevsky * The caller needs to hold @tb->lock. 1567484cb153SRadion Mirchevsky */ 1568484cb153SRadion Mirchevsky struct tb_xdomain *tb_xdomain_find_by_route(struct tb *tb, u64 route) 1569484cb153SRadion Mirchevsky { 1570484cb153SRadion Mirchevsky struct tb_xdomain_lookup lookup; 1571484cb153SRadion Mirchevsky struct tb_xdomain *xd; 1572484cb153SRadion Mirchevsky 1573484cb153SRadion Mirchevsky memset(&lookup, 0, sizeof(lookup)); 1574484cb153SRadion Mirchevsky lookup.route = route; 1575484cb153SRadion Mirchevsky 1576484cb153SRadion Mirchevsky xd = switch_find_xdomain(tb->root_switch, &lookup); 1577484cb153SRadion Mirchevsky return tb_xdomain_get(xd); 1578d1ff7024SMika Westerberg } 1579484cb153SRadion Mirchevsky EXPORT_SYMBOL_GPL(tb_xdomain_find_by_route); 1580d1ff7024SMika Westerberg 1581d1ff7024SMika Westerberg bool tb_xdomain_handle_request(struct tb *tb, enum tb_cfg_pkg_type type, 1582d1ff7024SMika Westerberg const void *buf, size_t size) 1583d1ff7024SMika Westerberg { 1584d1ff7024SMika Westerberg const struct tb_protocol_handler *handler, *tmp; 1585d1ff7024SMika Westerberg const struct tb_xdp_header *hdr = buf; 1586d1ff7024SMika Westerberg unsigned int length; 1587d1ff7024SMika Westerberg int ret = 0; 1588d1ff7024SMika Westerberg 1589d1ff7024SMika Westerberg /* We expect the packet is at least size of the header */ 1590d1ff7024SMika Westerberg length = hdr->xd_hdr.length_sn & TB_XDOMAIN_LENGTH_MASK; 1591d1ff7024SMika Westerberg if (length != size / 4 - sizeof(hdr->xd_hdr) / 4) 1592d1ff7024SMika Westerberg return true; 1593d1ff7024SMika Westerberg if (length < sizeof(*hdr) / 4 - sizeof(hdr->xd_hdr) / 4) 1594d1ff7024SMika Westerberg return true; 1595d1ff7024SMika Westerberg 1596d1ff7024SMika Westerberg /* 1597d1ff7024SMika Westerberg * Handle XDomain discovery protocol packets directly here. For 1598d1ff7024SMika Westerberg * other protocols (based on their UUID) we call registered 1599d1ff7024SMika Westerberg * handlers in turn. 1600d1ff7024SMika Westerberg */ 1601d1ff7024SMika Westerberg if (uuid_equal(&hdr->uuid, &tb_xdp_uuid)) { 160248f40b96SAditya Pakki if (type == TB_CFG_PKG_XDOMAIN_REQ) 160348f40b96SAditya Pakki return tb_xdp_schedule_request(tb, hdr, size); 1604d1ff7024SMika Westerberg return false; 1605d1ff7024SMika Westerberg } 1606d1ff7024SMika Westerberg 1607d1ff7024SMika Westerberg mutex_lock(&xdomain_lock); 1608d1ff7024SMika Westerberg list_for_each_entry_safe(handler, tmp, &protocol_handlers, list) { 1609d1ff7024SMika Westerberg if (!uuid_equal(&hdr->uuid, handler->uuid)) 1610d1ff7024SMika Westerberg continue; 1611d1ff7024SMika Westerberg 1612d1ff7024SMika Westerberg mutex_unlock(&xdomain_lock); 1613d1ff7024SMika Westerberg ret = handler->callback(buf, size, handler->data); 1614d1ff7024SMika Westerberg mutex_lock(&xdomain_lock); 1615d1ff7024SMika Westerberg 1616d1ff7024SMika Westerberg if (ret) 1617d1ff7024SMika Westerberg break; 1618d1ff7024SMika Westerberg } 1619d1ff7024SMika Westerberg mutex_unlock(&xdomain_lock); 1620d1ff7024SMika Westerberg 1621d1ff7024SMika Westerberg return ret > 0; 1622d1ff7024SMika Westerberg } 1623d1ff7024SMika Westerberg 1624d1ff7024SMika Westerberg static int update_xdomain(struct device *dev, void *data) 1625d1ff7024SMika Westerberg { 1626d1ff7024SMika Westerberg struct tb_xdomain *xd; 1627d1ff7024SMika Westerberg 1628d1ff7024SMika Westerberg xd = tb_to_xdomain(dev); 1629d1ff7024SMika Westerberg if (xd) { 1630d1ff7024SMika Westerberg queue_delayed_work(xd->tb->wq, &xd->properties_changed_work, 1631d1ff7024SMika Westerberg msecs_to_jiffies(50)); 1632d1ff7024SMika Westerberg } 1633d1ff7024SMika Westerberg 1634d1ff7024SMika Westerberg return 0; 1635d1ff7024SMika Westerberg } 1636d1ff7024SMika Westerberg 1637d1ff7024SMika Westerberg static void update_all_xdomains(void) 1638d1ff7024SMika Westerberg { 1639d1ff7024SMika Westerberg bus_for_each_dev(&tb_bus_type, NULL, NULL, update_xdomain); 1640d1ff7024SMika Westerberg } 1641d1ff7024SMika Westerberg 1642d1ff7024SMika Westerberg static bool remove_directory(const char *key, const struct tb_property_dir *dir) 1643d1ff7024SMika Westerberg { 1644d1ff7024SMika Westerberg struct tb_property *p; 1645d1ff7024SMika Westerberg 1646d1ff7024SMika Westerberg p = tb_property_find(xdomain_property_dir, key, 1647d1ff7024SMika Westerberg TB_PROPERTY_TYPE_DIRECTORY); 1648d1ff7024SMika Westerberg if (p && p->value.dir == dir) { 1649d1ff7024SMika Westerberg tb_property_remove(p); 1650d1ff7024SMika Westerberg return true; 1651d1ff7024SMika Westerberg } 1652d1ff7024SMika Westerberg return false; 1653d1ff7024SMika Westerberg } 1654d1ff7024SMika Westerberg 1655d1ff7024SMika Westerberg /** 1656d1ff7024SMika Westerberg * tb_register_property_dir() - Register property directory to the host 1657d1ff7024SMika Westerberg * @key: Key (name) of the directory to add 1658d1ff7024SMika Westerberg * @dir: Directory to add 1659d1ff7024SMika Westerberg * 1660d1ff7024SMika Westerberg * Service drivers can use this function to add new property directory 1661d1ff7024SMika Westerberg * to the host available properties. The other connected hosts are 1662d1ff7024SMika Westerberg * notified so they can re-read properties of this host if they are 1663d1ff7024SMika Westerberg * interested. 1664d1ff7024SMika Westerberg * 1665d1ff7024SMika Westerberg * Return: %0 on success and negative errno on failure 1666d1ff7024SMika Westerberg */ 1667d1ff7024SMika Westerberg int tb_register_property_dir(const char *key, struct tb_property_dir *dir) 1668d1ff7024SMika Westerberg { 1669d1ff7024SMika Westerberg int ret; 1670d1ff7024SMika Westerberg 1671acb40d84SMika Westerberg if (WARN_ON(!xdomain_property_dir)) 1672acb40d84SMika Westerberg return -EAGAIN; 1673acb40d84SMika Westerberg 1674d1ff7024SMika Westerberg if (!key || strlen(key) > 8) 1675d1ff7024SMika Westerberg return -EINVAL; 1676d1ff7024SMika Westerberg 1677d1ff7024SMika Westerberg mutex_lock(&xdomain_lock); 1678d1ff7024SMika Westerberg if (tb_property_find(xdomain_property_dir, key, 1679d1ff7024SMika Westerberg TB_PROPERTY_TYPE_DIRECTORY)) { 1680d1ff7024SMika Westerberg ret = -EEXIST; 1681d1ff7024SMika Westerberg goto err_unlock; 1682d1ff7024SMika Westerberg } 1683d1ff7024SMika Westerberg 1684d1ff7024SMika Westerberg ret = tb_property_add_dir(xdomain_property_dir, key, dir); 1685d1ff7024SMika Westerberg if (ret) 1686d1ff7024SMika Westerberg goto err_unlock; 1687d1ff7024SMika Westerberg 1688d1ff7024SMika Westerberg ret = rebuild_property_block(); 1689d1ff7024SMika Westerberg if (ret) { 1690d1ff7024SMika Westerberg remove_directory(key, dir); 1691d1ff7024SMika Westerberg goto err_unlock; 1692d1ff7024SMika Westerberg } 1693d1ff7024SMika Westerberg 1694d1ff7024SMika Westerberg mutex_unlock(&xdomain_lock); 1695d1ff7024SMika Westerberg update_all_xdomains(); 1696d1ff7024SMika Westerberg return 0; 1697d1ff7024SMika Westerberg 1698d1ff7024SMika Westerberg err_unlock: 1699d1ff7024SMika Westerberg mutex_unlock(&xdomain_lock); 1700d1ff7024SMika Westerberg return ret; 1701d1ff7024SMika Westerberg } 1702d1ff7024SMika Westerberg EXPORT_SYMBOL_GPL(tb_register_property_dir); 1703d1ff7024SMika Westerberg 1704d1ff7024SMika Westerberg /** 1705d1ff7024SMika Westerberg * tb_unregister_property_dir() - Removes property directory from host 1706d1ff7024SMika Westerberg * @key: Key (name) of the directory 1707d1ff7024SMika Westerberg * @dir: Directory to remove 1708d1ff7024SMika Westerberg * 1709d1ff7024SMika Westerberg * This will remove the existing directory from this host and notify the 1710d1ff7024SMika Westerberg * connected hosts about the change. 1711d1ff7024SMika Westerberg */ 1712d1ff7024SMika Westerberg void tb_unregister_property_dir(const char *key, struct tb_property_dir *dir) 1713d1ff7024SMika Westerberg { 1714d1ff7024SMika Westerberg int ret = 0; 1715d1ff7024SMika Westerberg 1716d1ff7024SMika Westerberg mutex_lock(&xdomain_lock); 1717d1ff7024SMika Westerberg if (remove_directory(key, dir)) 1718d1ff7024SMika Westerberg ret = rebuild_property_block(); 1719d1ff7024SMika Westerberg mutex_unlock(&xdomain_lock); 1720d1ff7024SMika Westerberg 1721d1ff7024SMika Westerberg if (!ret) 1722d1ff7024SMika Westerberg update_all_xdomains(); 1723d1ff7024SMika Westerberg } 1724d1ff7024SMika Westerberg EXPORT_SYMBOL_GPL(tb_unregister_property_dir); 1725d1ff7024SMika Westerberg 1726d1ff7024SMika Westerberg int tb_xdomain_init(void) 1727d1ff7024SMika Westerberg { 1728d1ff7024SMika Westerberg xdomain_property_dir = tb_property_create_dir(NULL); 1729d1ff7024SMika Westerberg if (!xdomain_property_dir) 1730d1ff7024SMika Westerberg return -ENOMEM; 1731d1ff7024SMika Westerberg 1732d1ff7024SMika Westerberg /* 1733d1ff7024SMika Westerberg * Initialize standard set of properties without any service 1734d1ff7024SMika Westerberg * directories. Those will be added by service drivers 1735d1ff7024SMika Westerberg * themselves when they are loaded. 17368a00c67eSMika Westerberg * 17378a00c67eSMika Westerberg * We also add node name later when first connection is made. 1738d1ff7024SMika Westerberg */ 1739d1ff7024SMika Westerberg tb_property_add_immediate(xdomain_property_dir, "vendorid", 1740d1ff7024SMika Westerberg PCI_VENDOR_ID_INTEL); 1741d1ff7024SMika Westerberg tb_property_add_text(xdomain_property_dir, "vendorid", "Intel Corp."); 1742d1ff7024SMika Westerberg tb_property_add_immediate(xdomain_property_dir, "deviceid", 0x1); 1743d1ff7024SMika Westerberg tb_property_add_immediate(xdomain_property_dir, "devicerv", 0x80000100); 1744d1ff7024SMika Westerberg 17458a00c67eSMika Westerberg return 0; 1746d1ff7024SMika Westerberg } 1747d1ff7024SMika Westerberg 1748d1ff7024SMika Westerberg void tb_xdomain_exit(void) 1749d1ff7024SMika Westerberg { 1750d1ff7024SMika Westerberg kfree(xdomain_property_block); 1751d1ff7024SMika Westerberg tb_property_free_dir(xdomain_property_dir); 1752d1ff7024SMika Westerberg } 1753