1d1ff7024SMika Westerberg /* 2d1ff7024SMika Westerberg * Thunderbolt XDomain discovery protocol support 3d1ff7024SMika Westerberg * 4d1ff7024SMika Westerberg * Copyright (C) 2017, Intel Corporation 5d1ff7024SMika Westerberg * Authors: Michael Jamet <michael.jamet@intel.com> 6d1ff7024SMika Westerberg * Mika Westerberg <mika.westerberg@linux.intel.com> 7d1ff7024SMika Westerberg * 8d1ff7024SMika Westerberg * This program is free software; you can redistribute it and/or modify 9d1ff7024SMika Westerberg * it under the terms of the GNU General Public License version 2 as 10d1ff7024SMika Westerberg * published by the Free Software Foundation. 11d1ff7024SMika Westerberg */ 12d1ff7024SMika Westerberg 13d1ff7024SMika Westerberg #include <linux/device.h> 14d1ff7024SMika Westerberg #include <linux/kmod.h> 15d1ff7024SMika Westerberg #include <linux/module.h> 16d1ff7024SMika Westerberg #include <linux/utsname.h> 17d1ff7024SMika Westerberg #include <linux/uuid.h> 18d1ff7024SMika Westerberg #include <linux/workqueue.h> 19d1ff7024SMika Westerberg 20d1ff7024SMika Westerberg #include "tb.h" 21d1ff7024SMika Westerberg 22d1ff7024SMika Westerberg #define XDOMAIN_DEFAULT_TIMEOUT 5000 /* ms */ 23d1ff7024SMika Westerberg #define XDOMAIN_PROPERTIES_RETRIES 60 24d1ff7024SMika Westerberg #define XDOMAIN_PROPERTIES_CHANGED_RETRIES 10 25d1ff7024SMika Westerberg 26d1ff7024SMika Westerberg struct xdomain_request_work { 27d1ff7024SMika Westerberg struct work_struct work; 28d1ff7024SMika Westerberg struct tb_xdp_header *pkg; 29d1ff7024SMika Westerberg struct tb *tb; 30d1ff7024SMika Westerberg }; 31d1ff7024SMika Westerberg 32d1ff7024SMika Westerberg /* Serializes access to the properties and protocol handlers below */ 33d1ff7024SMika Westerberg static DEFINE_MUTEX(xdomain_lock); 34d1ff7024SMika Westerberg 35d1ff7024SMika Westerberg /* Properties exposed to the remote domains */ 36d1ff7024SMika Westerberg static struct tb_property_dir *xdomain_property_dir; 37d1ff7024SMika Westerberg static u32 *xdomain_property_block; 38d1ff7024SMika Westerberg static u32 xdomain_property_block_len; 39d1ff7024SMika Westerberg static u32 xdomain_property_block_gen; 40d1ff7024SMika Westerberg 41d1ff7024SMika Westerberg /* Additional protocol handlers */ 42d1ff7024SMika Westerberg static LIST_HEAD(protocol_handlers); 43d1ff7024SMika Westerberg 44d1ff7024SMika Westerberg /* UUID for XDomain discovery protocol: b638d70e-42ff-40bb-97c2-90e2c0b2ff07 */ 45d1ff7024SMika Westerberg static const uuid_t tb_xdp_uuid = 46d1ff7024SMika Westerberg UUID_INIT(0xb638d70e, 0x42ff, 0x40bb, 47d1ff7024SMika Westerberg 0x97, 0xc2, 0x90, 0xe2, 0xc0, 0xb2, 0xff, 0x07); 48d1ff7024SMika Westerberg 49d1ff7024SMika Westerberg static bool tb_xdomain_match(const struct tb_cfg_request *req, 50d1ff7024SMika Westerberg const struct ctl_pkg *pkg) 51d1ff7024SMika Westerberg { 52d1ff7024SMika Westerberg switch (pkg->frame.eof) { 53d1ff7024SMika Westerberg case TB_CFG_PKG_ERROR: 54d1ff7024SMika Westerberg return true; 55d1ff7024SMika Westerberg 56d1ff7024SMika Westerberg case TB_CFG_PKG_XDOMAIN_RESP: { 57d1ff7024SMika Westerberg const struct tb_xdp_header *res_hdr = pkg->buffer; 58d1ff7024SMika Westerberg const struct tb_xdp_header *req_hdr = req->request; 59*9a03c3d3SDan Carpenter u32 req_seq, res_seq; 60d1ff7024SMika Westerberg 61d1ff7024SMika Westerberg if (pkg->frame.size < req->response_size / 4) 62d1ff7024SMika Westerberg return false; 63d1ff7024SMika Westerberg 64d1ff7024SMika Westerberg /* Make sure route matches */ 65d1ff7024SMika Westerberg if ((res_hdr->xd_hdr.route_hi & ~BIT(31)) != 66d1ff7024SMika Westerberg req_hdr->xd_hdr.route_hi) 67d1ff7024SMika Westerberg return false; 68d1ff7024SMika Westerberg if ((res_hdr->xd_hdr.route_lo) != req_hdr->xd_hdr.route_lo) 69d1ff7024SMika Westerberg return false; 70d1ff7024SMika Westerberg 71d1ff7024SMika Westerberg /* Then check that the sequence number matches */ 72d1ff7024SMika Westerberg res_seq = res_hdr->xd_hdr.length_sn & TB_XDOMAIN_SN_MASK; 73d1ff7024SMika Westerberg res_seq >>= TB_XDOMAIN_SN_SHIFT; 74d1ff7024SMika Westerberg req_seq = req_hdr->xd_hdr.length_sn & TB_XDOMAIN_SN_MASK; 75d1ff7024SMika Westerberg req_seq >>= TB_XDOMAIN_SN_SHIFT; 76d1ff7024SMika Westerberg if (res_seq != req_seq) 77d1ff7024SMika Westerberg return false; 78d1ff7024SMika Westerberg 79d1ff7024SMika Westerberg /* Check that the XDomain protocol matches */ 80d1ff7024SMika Westerberg if (!uuid_equal(&res_hdr->uuid, &req_hdr->uuid)) 81d1ff7024SMika Westerberg return false; 82d1ff7024SMika Westerberg 83d1ff7024SMika Westerberg return true; 84d1ff7024SMika Westerberg } 85d1ff7024SMika Westerberg 86d1ff7024SMika Westerberg default: 87d1ff7024SMika Westerberg return false; 88d1ff7024SMika Westerberg } 89d1ff7024SMika Westerberg } 90d1ff7024SMika Westerberg 91d1ff7024SMika Westerberg static bool tb_xdomain_copy(struct tb_cfg_request *req, 92d1ff7024SMika Westerberg const struct ctl_pkg *pkg) 93d1ff7024SMika Westerberg { 94d1ff7024SMika Westerberg memcpy(req->response, pkg->buffer, req->response_size); 95d1ff7024SMika Westerberg req->result.err = 0; 96d1ff7024SMika Westerberg return true; 97d1ff7024SMika Westerberg } 98d1ff7024SMika Westerberg 99d1ff7024SMika Westerberg static void response_ready(void *data) 100d1ff7024SMika Westerberg { 101d1ff7024SMika Westerberg tb_cfg_request_put(data); 102d1ff7024SMika Westerberg } 103d1ff7024SMika Westerberg 104d1ff7024SMika Westerberg static int __tb_xdomain_response(struct tb_ctl *ctl, const void *response, 105d1ff7024SMika Westerberg size_t size, enum tb_cfg_pkg_type type) 106d1ff7024SMika Westerberg { 107d1ff7024SMika Westerberg struct tb_cfg_request *req; 108d1ff7024SMika Westerberg 109d1ff7024SMika Westerberg req = tb_cfg_request_alloc(); 110d1ff7024SMika Westerberg if (!req) 111d1ff7024SMika Westerberg return -ENOMEM; 112d1ff7024SMika Westerberg 113d1ff7024SMika Westerberg req->match = tb_xdomain_match; 114d1ff7024SMika Westerberg req->copy = tb_xdomain_copy; 115d1ff7024SMika Westerberg req->request = response; 116d1ff7024SMika Westerberg req->request_size = size; 117d1ff7024SMika Westerberg req->request_type = type; 118d1ff7024SMika Westerberg 119d1ff7024SMika Westerberg return tb_cfg_request(ctl, req, response_ready, req); 120d1ff7024SMika Westerberg } 121d1ff7024SMika Westerberg 122d1ff7024SMika Westerberg /** 123d1ff7024SMika Westerberg * tb_xdomain_response() - Send a XDomain response message 124d1ff7024SMika Westerberg * @xd: XDomain to send the message 125d1ff7024SMika Westerberg * @response: Response to send 126d1ff7024SMika Westerberg * @size: Size of the response 127d1ff7024SMika Westerberg * @type: PDF type of the response 128d1ff7024SMika Westerberg * 129d1ff7024SMika Westerberg * This can be used to send a XDomain response message to the other 130d1ff7024SMika Westerberg * domain. No response for the message is expected. 131d1ff7024SMika Westerberg * 132d1ff7024SMika Westerberg * Return: %0 in case of success and negative errno in case of failure 133d1ff7024SMika Westerberg */ 134d1ff7024SMika Westerberg int tb_xdomain_response(struct tb_xdomain *xd, const void *response, 135d1ff7024SMika Westerberg size_t size, enum tb_cfg_pkg_type type) 136d1ff7024SMika Westerberg { 137d1ff7024SMika Westerberg return __tb_xdomain_response(xd->tb->ctl, response, size, type); 138d1ff7024SMika Westerberg } 139d1ff7024SMika Westerberg EXPORT_SYMBOL_GPL(tb_xdomain_response); 140d1ff7024SMika Westerberg 141d1ff7024SMika Westerberg static int __tb_xdomain_request(struct tb_ctl *ctl, const void *request, 142d1ff7024SMika Westerberg size_t request_size, enum tb_cfg_pkg_type request_type, void *response, 143d1ff7024SMika Westerberg size_t response_size, enum tb_cfg_pkg_type response_type, 144d1ff7024SMika Westerberg unsigned int timeout_msec) 145d1ff7024SMika Westerberg { 146d1ff7024SMika Westerberg struct tb_cfg_request *req; 147d1ff7024SMika Westerberg struct tb_cfg_result res; 148d1ff7024SMika Westerberg 149d1ff7024SMika Westerberg req = tb_cfg_request_alloc(); 150d1ff7024SMika Westerberg if (!req) 151d1ff7024SMika Westerberg return -ENOMEM; 152d1ff7024SMika Westerberg 153d1ff7024SMika Westerberg req->match = tb_xdomain_match; 154d1ff7024SMika Westerberg req->copy = tb_xdomain_copy; 155d1ff7024SMika Westerberg req->request = request; 156d1ff7024SMika Westerberg req->request_size = request_size; 157d1ff7024SMika Westerberg req->request_type = request_type; 158d1ff7024SMika Westerberg req->response = response; 159d1ff7024SMika Westerberg req->response_size = response_size; 160d1ff7024SMika Westerberg req->response_type = response_type; 161d1ff7024SMika Westerberg 162d1ff7024SMika Westerberg res = tb_cfg_request_sync(ctl, req, timeout_msec); 163d1ff7024SMika Westerberg 164d1ff7024SMika Westerberg tb_cfg_request_put(req); 165d1ff7024SMika Westerberg 166d1ff7024SMika Westerberg return res.err == 1 ? -EIO : res.err; 167d1ff7024SMika Westerberg } 168d1ff7024SMika Westerberg 169d1ff7024SMika Westerberg /** 170d1ff7024SMika Westerberg * tb_xdomain_request() - Send a XDomain request 171d1ff7024SMika Westerberg * @xd: XDomain to send the request 172d1ff7024SMika Westerberg * @request: Request to send 173d1ff7024SMika Westerberg * @request_size: Size of the request in bytes 174d1ff7024SMika Westerberg * @request_type: PDF type of the request 175d1ff7024SMika Westerberg * @response: Response is copied here 176d1ff7024SMika Westerberg * @response_size: Expected size of the response in bytes 177d1ff7024SMika Westerberg * @response_type: Expected PDF type of the response 178d1ff7024SMika Westerberg * @timeout_msec: Timeout in milliseconds to wait for the response 179d1ff7024SMika Westerberg * 180d1ff7024SMika Westerberg * This function can be used to send XDomain control channel messages to 181d1ff7024SMika Westerberg * the other domain. The function waits until the response is received 182d1ff7024SMika Westerberg * or when timeout triggers. Whichever comes first. 183d1ff7024SMika Westerberg * 184d1ff7024SMika Westerberg * Return: %0 in case of success and negative errno in case of failure 185d1ff7024SMika Westerberg */ 186d1ff7024SMika Westerberg int tb_xdomain_request(struct tb_xdomain *xd, const void *request, 187d1ff7024SMika Westerberg size_t request_size, enum tb_cfg_pkg_type request_type, 188d1ff7024SMika Westerberg void *response, size_t response_size, 189d1ff7024SMika Westerberg enum tb_cfg_pkg_type response_type, unsigned int timeout_msec) 190d1ff7024SMika Westerberg { 191d1ff7024SMika Westerberg return __tb_xdomain_request(xd->tb->ctl, request, request_size, 192d1ff7024SMika Westerberg request_type, response, response_size, 193d1ff7024SMika Westerberg response_type, timeout_msec); 194d1ff7024SMika Westerberg } 195d1ff7024SMika Westerberg EXPORT_SYMBOL_GPL(tb_xdomain_request); 196d1ff7024SMika Westerberg 197d1ff7024SMika Westerberg static inline void tb_xdp_fill_header(struct tb_xdp_header *hdr, u64 route, 198d1ff7024SMika Westerberg u8 sequence, enum tb_xdp_type type, size_t size) 199d1ff7024SMika Westerberg { 200d1ff7024SMika Westerberg u32 length_sn; 201d1ff7024SMika Westerberg 202d1ff7024SMika Westerberg length_sn = (size - sizeof(hdr->xd_hdr)) / 4; 203d1ff7024SMika Westerberg length_sn |= (sequence << TB_XDOMAIN_SN_SHIFT) & TB_XDOMAIN_SN_MASK; 204d1ff7024SMika Westerberg 205d1ff7024SMika Westerberg hdr->xd_hdr.route_hi = upper_32_bits(route); 206d1ff7024SMika Westerberg hdr->xd_hdr.route_lo = lower_32_bits(route); 207d1ff7024SMika Westerberg hdr->xd_hdr.length_sn = length_sn; 208d1ff7024SMika Westerberg hdr->type = type; 209d1ff7024SMika Westerberg memcpy(&hdr->uuid, &tb_xdp_uuid, sizeof(tb_xdp_uuid)); 210d1ff7024SMika Westerberg } 211d1ff7024SMika Westerberg 212d1ff7024SMika Westerberg static int tb_xdp_handle_error(const struct tb_xdp_header *hdr) 213d1ff7024SMika Westerberg { 214d1ff7024SMika Westerberg const struct tb_xdp_error_response *error; 215d1ff7024SMika Westerberg 216d1ff7024SMika Westerberg if (hdr->type != ERROR_RESPONSE) 217d1ff7024SMika Westerberg return 0; 218d1ff7024SMika Westerberg 219d1ff7024SMika Westerberg error = (const struct tb_xdp_error_response *)hdr; 220d1ff7024SMika Westerberg 221d1ff7024SMika Westerberg switch (error->error) { 222d1ff7024SMika Westerberg case ERROR_UNKNOWN_PACKET: 223d1ff7024SMika Westerberg case ERROR_UNKNOWN_DOMAIN: 224d1ff7024SMika Westerberg return -EIO; 225d1ff7024SMika Westerberg case ERROR_NOT_SUPPORTED: 226d1ff7024SMika Westerberg return -ENOTSUPP; 227d1ff7024SMika Westerberg case ERROR_NOT_READY: 228d1ff7024SMika Westerberg return -EAGAIN; 229d1ff7024SMika Westerberg default: 230d1ff7024SMika Westerberg break; 231d1ff7024SMika Westerberg } 232d1ff7024SMika Westerberg 233d1ff7024SMika Westerberg return 0; 234d1ff7024SMika Westerberg } 235d1ff7024SMika Westerberg 236d1ff7024SMika Westerberg static int tb_xdp_error_response(struct tb_ctl *ctl, u64 route, u8 sequence, 237d1ff7024SMika Westerberg enum tb_xdp_error error) 238d1ff7024SMika Westerberg { 239d1ff7024SMika Westerberg struct tb_xdp_error_response res; 240d1ff7024SMika Westerberg 241d1ff7024SMika Westerberg memset(&res, 0, sizeof(res)); 242d1ff7024SMika Westerberg tb_xdp_fill_header(&res.hdr, route, sequence, ERROR_RESPONSE, 243d1ff7024SMika Westerberg sizeof(res)); 244d1ff7024SMika Westerberg res.error = error; 245d1ff7024SMika Westerberg 246d1ff7024SMika Westerberg return __tb_xdomain_response(ctl, &res, sizeof(res), 247d1ff7024SMika Westerberg TB_CFG_PKG_XDOMAIN_RESP); 248d1ff7024SMika Westerberg } 249d1ff7024SMika Westerberg 250d1ff7024SMika Westerberg static int tb_xdp_properties_request(struct tb_ctl *ctl, u64 route, 251d1ff7024SMika Westerberg const uuid_t *src_uuid, const uuid_t *dst_uuid, int retry, 252d1ff7024SMika Westerberg u32 **block, u32 *generation) 253d1ff7024SMika Westerberg { 254d1ff7024SMika Westerberg struct tb_xdp_properties_response *res; 255d1ff7024SMika Westerberg struct tb_xdp_properties req; 256d1ff7024SMika Westerberg u16 data_len, len; 257d1ff7024SMika Westerberg size_t total_size; 258d1ff7024SMika Westerberg u32 *data = NULL; 259d1ff7024SMika Westerberg int ret; 260d1ff7024SMika Westerberg 261d1ff7024SMika Westerberg total_size = sizeof(*res) + TB_XDP_PROPERTIES_MAX_DATA_LENGTH * 4; 262d1ff7024SMika Westerberg res = kzalloc(total_size, GFP_KERNEL); 263d1ff7024SMika Westerberg if (!res) 264d1ff7024SMika Westerberg return -ENOMEM; 265d1ff7024SMika Westerberg 266d1ff7024SMika Westerberg memset(&req, 0, sizeof(req)); 267d1ff7024SMika Westerberg tb_xdp_fill_header(&req.hdr, route, retry % 4, PROPERTIES_REQUEST, 268d1ff7024SMika Westerberg sizeof(req)); 269d1ff7024SMika Westerberg memcpy(&req.src_uuid, src_uuid, sizeof(*src_uuid)); 270d1ff7024SMika Westerberg memcpy(&req.dst_uuid, dst_uuid, sizeof(*dst_uuid)); 271d1ff7024SMika Westerberg 272d1ff7024SMika Westerberg len = 0; 273d1ff7024SMika Westerberg data_len = 0; 274d1ff7024SMika Westerberg 275d1ff7024SMika Westerberg do { 276d1ff7024SMika Westerberg ret = __tb_xdomain_request(ctl, &req, sizeof(req), 277d1ff7024SMika Westerberg TB_CFG_PKG_XDOMAIN_REQ, res, 278d1ff7024SMika Westerberg total_size, TB_CFG_PKG_XDOMAIN_RESP, 279d1ff7024SMika Westerberg XDOMAIN_DEFAULT_TIMEOUT); 280d1ff7024SMika Westerberg if (ret) 281d1ff7024SMika Westerberg goto err; 282d1ff7024SMika Westerberg 283d1ff7024SMika Westerberg ret = tb_xdp_handle_error(&res->hdr); 284d1ff7024SMika Westerberg if (ret) 285d1ff7024SMika Westerberg goto err; 286d1ff7024SMika Westerberg 287d1ff7024SMika Westerberg /* 288d1ff7024SMika Westerberg * Package length includes the whole payload without the 289d1ff7024SMika Westerberg * XDomain header. Validate first that the package is at 290d1ff7024SMika Westerberg * least size of the response structure. 291d1ff7024SMika Westerberg */ 292d1ff7024SMika Westerberg len = res->hdr.xd_hdr.length_sn & TB_XDOMAIN_LENGTH_MASK; 293d1ff7024SMika Westerberg if (len < sizeof(*res) / 4) { 294d1ff7024SMika Westerberg ret = -EINVAL; 295d1ff7024SMika Westerberg goto err; 296d1ff7024SMika Westerberg } 297d1ff7024SMika Westerberg 298d1ff7024SMika Westerberg len += sizeof(res->hdr.xd_hdr) / 4; 299d1ff7024SMika Westerberg len -= sizeof(*res) / 4; 300d1ff7024SMika Westerberg 301d1ff7024SMika Westerberg if (res->offset != req.offset) { 302d1ff7024SMika Westerberg ret = -EINVAL; 303d1ff7024SMika Westerberg goto err; 304d1ff7024SMika Westerberg } 305d1ff7024SMika Westerberg 306d1ff7024SMika Westerberg /* 307d1ff7024SMika Westerberg * First time allocate block that has enough space for 308d1ff7024SMika Westerberg * the whole properties block. 309d1ff7024SMika Westerberg */ 310d1ff7024SMika Westerberg if (!data) { 311d1ff7024SMika Westerberg data_len = res->data_length; 312d1ff7024SMika Westerberg if (data_len > TB_XDP_PROPERTIES_MAX_LENGTH) { 313d1ff7024SMika Westerberg ret = -E2BIG; 314d1ff7024SMika Westerberg goto err; 315d1ff7024SMika Westerberg } 316d1ff7024SMika Westerberg 317d1ff7024SMika Westerberg data = kcalloc(data_len, sizeof(u32), GFP_KERNEL); 318d1ff7024SMika Westerberg if (!data) { 319d1ff7024SMika Westerberg ret = -ENOMEM; 320d1ff7024SMika Westerberg goto err; 321d1ff7024SMika Westerberg } 322d1ff7024SMika Westerberg } 323d1ff7024SMika Westerberg 324d1ff7024SMika Westerberg memcpy(data + req.offset, res->data, len * 4); 325d1ff7024SMika Westerberg req.offset += len; 326d1ff7024SMika Westerberg } while (!data_len || req.offset < data_len); 327d1ff7024SMika Westerberg 328d1ff7024SMika Westerberg *block = data; 329d1ff7024SMika Westerberg *generation = res->generation; 330d1ff7024SMika Westerberg 331d1ff7024SMika Westerberg kfree(res); 332d1ff7024SMika Westerberg 333d1ff7024SMika Westerberg return data_len; 334d1ff7024SMika Westerberg 335d1ff7024SMika Westerberg err: 336d1ff7024SMika Westerberg kfree(data); 337d1ff7024SMika Westerberg kfree(res); 338d1ff7024SMika Westerberg 339d1ff7024SMika Westerberg return ret; 340d1ff7024SMika Westerberg } 341d1ff7024SMika Westerberg 342d1ff7024SMika Westerberg static int tb_xdp_properties_response(struct tb *tb, struct tb_ctl *ctl, 343d1ff7024SMika Westerberg u64 route, u8 sequence, const uuid_t *src_uuid, 344d1ff7024SMika Westerberg const struct tb_xdp_properties *req) 345d1ff7024SMika Westerberg { 346d1ff7024SMika Westerberg struct tb_xdp_properties_response *res; 347d1ff7024SMika Westerberg size_t total_size; 348d1ff7024SMika Westerberg u16 len; 349d1ff7024SMika Westerberg int ret; 350d1ff7024SMika Westerberg 351d1ff7024SMika Westerberg /* 352d1ff7024SMika Westerberg * Currently we expect all requests to be directed to us. The 353d1ff7024SMika Westerberg * protocol supports forwarding, though which we might add 354d1ff7024SMika Westerberg * support later on. 355d1ff7024SMika Westerberg */ 356d1ff7024SMika Westerberg if (!uuid_equal(src_uuid, &req->dst_uuid)) { 357d1ff7024SMika Westerberg tb_xdp_error_response(ctl, route, sequence, 358d1ff7024SMika Westerberg ERROR_UNKNOWN_DOMAIN); 359d1ff7024SMika Westerberg return 0; 360d1ff7024SMika Westerberg } 361d1ff7024SMika Westerberg 362d1ff7024SMika Westerberg mutex_lock(&xdomain_lock); 363d1ff7024SMika Westerberg 364d1ff7024SMika Westerberg if (req->offset >= xdomain_property_block_len) { 365d1ff7024SMika Westerberg mutex_unlock(&xdomain_lock); 366d1ff7024SMika Westerberg return -EINVAL; 367d1ff7024SMika Westerberg } 368d1ff7024SMika Westerberg 369d1ff7024SMika Westerberg len = xdomain_property_block_len - req->offset; 370d1ff7024SMika Westerberg len = min_t(u16, len, TB_XDP_PROPERTIES_MAX_DATA_LENGTH); 371d1ff7024SMika Westerberg total_size = sizeof(*res) + len * 4; 372d1ff7024SMika Westerberg 373d1ff7024SMika Westerberg res = kzalloc(total_size, GFP_KERNEL); 374d1ff7024SMika Westerberg if (!res) { 375d1ff7024SMika Westerberg mutex_unlock(&xdomain_lock); 376d1ff7024SMika Westerberg return -ENOMEM; 377d1ff7024SMika Westerberg } 378d1ff7024SMika Westerberg 379d1ff7024SMika Westerberg tb_xdp_fill_header(&res->hdr, route, sequence, PROPERTIES_RESPONSE, 380d1ff7024SMika Westerberg total_size); 381d1ff7024SMika Westerberg res->generation = xdomain_property_block_gen; 382d1ff7024SMika Westerberg res->data_length = xdomain_property_block_len; 383d1ff7024SMika Westerberg res->offset = req->offset; 384d1ff7024SMika Westerberg uuid_copy(&res->src_uuid, src_uuid); 385d1ff7024SMika Westerberg uuid_copy(&res->dst_uuid, &req->src_uuid); 386d1ff7024SMika Westerberg memcpy(res->data, &xdomain_property_block[req->offset], len * 4); 387d1ff7024SMika Westerberg 388d1ff7024SMika Westerberg mutex_unlock(&xdomain_lock); 389d1ff7024SMika Westerberg 390d1ff7024SMika Westerberg ret = __tb_xdomain_response(ctl, res, total_size, 391d1ff7024SMika Westerberg TB_CFG_PKG_XDOMAIN_RESP); 392d1ff7024SMika Westerberg 393d1ff7024SMika Westerberg kfree(res); 394d1ff7024SMika Westerberg return ret; 395d1ff7024SMika Westerberg } 396d1ff7024SMika Westerberg 397d1ff7024SMika Westerberg static int tb_xdp_properties_changed_request(struct tb_ctl *ctl, u64 route, 398d1ff7024SMika Westerberg int retry, const uuid_t *uuid) 399d1ff7024SMika Westerberg { 400d1ff7024SMika Westerberg struct tb_xdp_properties_changed_response res; 401d1ff7024SMika Westerberg struct tb_xdp_properties_changed req; 402d1ff7024SMika Westerberg int ret; 403d1ff7024SMika Westerberg 404d1ff7024SMika Westerberg memset(&req, 0, sizeof(req)); 405d1ff7024SMika Westerberg tb_xdp_fill_header(&req.hdr, route, retry % 4, 406d1ff7024SMika Westerberg PROPERTIES_CHANGED_REQUEST, sizeof(req)); 407d1ff7024SMika Westerberg uuid_copy(&req.src_uuid, uuid); 408d1ff7024SMika Westerberg 409d1ff7024SMika Westerberg memset(&res, 0, sizeof(res)); 410d1ff7024SMika Westerberg ret = __tb_xdomain_request(ctl, &req, sizeof(req), 411d1ff7024SMika Westerberg TB_CFG_PKG_XDOMAIN_REQ, &res, sizeof(res), 412d1ff7024SMika Westerberg TB_CFG_PKG_XDOMAIN_RESP, 413d1ff7024SMika Westerberg XDOMAIN_DEFAULT_TIMEOUT); 414d1ff7024SMika Westerberg if (ret) 415d1ff7024SMika Westerberg return ret; 416d1ff7024SMika Westerberg 417d1ff7024SMika Westerberg return tb_xdp_handle_error(&res.hdr); 418d1ff7024SMika Westerberg } 419d1ff7024SMika Westerberg 420d1ff7024SMika Westerberg static int 421d1ff7024SMika Westerberg tb_xdp_properties_changed_response(struct tb_ctl *ctl, u64 route, u8 sequence) 422d1ff7024SMika Westerberg { 423d1ff7024SMika Westerberg struct tb_xdp_properties_changed_response res; 424d1ff7024SMika Westerberg 425d1ff7024SMika Westerberg memset(&res, 0, sizeof(res)); 426d1ff7024SMika Westerberg tb_xdp_fill_header(&res.hdr, route, sequence, 427d1ff7024SMika Westerberg PROPERTIES_CHANGED_RESPONSE, sizeof(res)); 428d1ff7024SMika Westerberg return __tb_xdomain_response(ctl, &res, sizeof(res), 429d1ff7024SMika Westerberg TB_CFG_PKG_XDOMAIN_RESP); 430d1ff7024SMika Westerberg } 431d1ff7024SMika Westerberg 432d1ff7024SMika Westerberg /** 433d1ff7024SMika Westerberg * tb_register_protocol_handler() - Register protocol handler 434d1ff7024SMika Westerberg * @handler: Handler to register 435d1ff7024SMika Westerberg * 436d1ff7024SMika Westerberg * This allows XDomain service drivers to hook into incoming XDomain 437d1ff7024SMika Westerberg * messages. After this function is called the service driver needs to 438d1ff7024SMika Westerberg * be able to handle calls to callback whenever a package with the 439d1ff7024SMika Westerberg * registered protocol is received. 440d1ff7024SMika Westerberg */ 441d1ff7024SMika Westerberg int tb_register_protocol_handler(struct tb_protocol_handler *handler) 442d1ff7024SMika Westerberg { 443d1ff7024SMika Westerberg if (!handler->uuid || !handler->callback) 444d1ff7024SMika Westerberg return -EINVAL; 445d1ff7024SMika Westerberg if (uuid_equal(handler->uuid, &tb_xdp_uuid)) 446d1ff7024SMika Westerberg return -EINVAL; 447d1ff7024SMika Westerberg 448d1ff7024SMika Westerberg mutex_lock(&xdomain_lock); 449d1ff7024SMika Westerberg list_add_tail(&handler->list, &protocol_handlers); 450d1ff7024SMika Westerberg mutex_unlock(&xdomain_lock); 451d1ff7024SMika Westerberg 452d1ff7024SMika Westerberg return 0; 453d1ff7024SMika Westerberg } 454d1ff7024SMika Westerberg EXPORT_SYMBOL_GPL(tb_register_protocol_handler); 455d1ff7024SMika Westerberg 456d1ff7024SMika Westerberg /** 457d1ff7024SMika Westerberg * tb_unregister_protocol_handler() - Unregister protocol handler 458d1ff7024SMika Westerberg * @handler: Handler to unregister 459d1ff7024SMika Westerberg * 460d1ff7024SMika Westerberg * Removes the previously registered protocol handler. 461d1ff7024SMika Westerberg */ 462d1ff7024SMika Westerberg void tb_unregister_protocol_handler(struct tb_protocol_handler *handler) 463d1ff7024SMika Westerberg { 464d1ff7024SMika Westerberg mutex_lock(&xdomain_lock); 465d1ff7024SMika Westerberg list_del_init(&handler->list); 466d1ff7024SMika Westerberg mutex_unlock(&xdomain_lock); 467d1ff7024SMika Westerberg } 468d1ff7024SMika Westerberg EXPORT_SYMBOL_GPL(tb_unregister_protocol_handler); 469d1ff7024SMika Westerberg 470d1ff7024SMika Westerberg static void tb_xdp_handle_request(struct work_struct *work) 471d1ff7024SMika Westerberg { 472d1ff7024SMika Westerberg struct xdomain_request_work *xw = container_of(work, typeof(*xw), work); 473d1ff7024SMika Westerberg const struct tb_xdp_header *pkg = xw->pkg; 474d1ff7024SMika Westerberg const struct tb_xdomain_header *xhdr = &pkg->xd_hdr; 475d1ff7024SMika Westerberg struct tb *tb = xw->tb; 476d1ff7024SMika Westerberg struct tb_ctl *ctl = tb->ctl; 477d1ff7024SMika Westerberg const uuid_t *uuid; 478d1ff7024SMika Westerberg int ret = 0; 479*9a03c3d3SDan Carpenter u32 sequence; 480d1ff7024SMika Westerberg u64 route; 481d1ff7024SMika Westerberg 482d1ff7024SMika Westerberg route = ((u64)xhdr->route_hi << 32 | xhdr->route_lo) & ~BIT_ULL(63); 483d1ff7024SMika Westerberg sequence = xhdr->length_sn & TB_XDOMAIN_SN_MASK; 484d1ff7024SMika Westerberg sequence >>= TB_XDOMAIN_SN_SHIFT; 485d1ff7024SMika Westerberg 486d1ff7024SMika Westerberg mutex_lock(&tb->lock); 487d1ff7024SMika Westerberg if (tb->root_switch) 488d1ff7024SMika Westerberg uuid = tb->root_switch->uuid; 489d1ff7024SMika Westerberg else 490d1ff7024SMika Westerberg uuid = NULL; 491d1ff7024SMika Westerberg mutex_unlock(&tb->lock); 492d1ff7024SMika Westerberg 493d1ff7024SMika Westerberg if (!uuid) { 494d1ff7024SMika Westerberg tb_xdp_error_response(ctl, route, sequence, ERROR_NOT_READY); 495d1ff7024SMika Westerberg goto out; 496d1ff7024SMika Westerberg } 497d1ff7024SMika Westerberg 498d1ff7024SMika Westerberg switch (pkg->type) { 499d1ff7024SMika Westerberg case PROPERTIES_REQUEST: 500d1ff7024SMika Westerberg ret = tb_xdp_properties_response(tb, ctl, route, sequence, uuid, 501d1ff7024SMika Westerberg (const struct tb_xdp_properties *)pkg); 502d1ff7024SMika Westerberg break; 503d1ff7024SMika Westerberg 504d1ff7024SMika Westerberg case PROPERTIES_CHANGED_REQUEST: { 505d1ff7024SMika Westerberg const struct tb_xdp_properties_changed *xchg = 506d1ff7024SMika Westerberg (const struct tb_xdp_properties_changed *)pkg; 507d1ff7024SMika Westerberg struct tb_xdomain *xd; 508d1ff7024SMika Westerberg 509d1ff7024SMika Westerberg ret = tb_xdp_properties_changed_response(ctl, route, sequence); 510d1ff7024SMika Westerberg 511d1ff7024SMika Westerberg /* 512d1ff7024SMika Westerberg * Since the properties have been changed, let's update 513d1ff7024SMika Westerberg * the xdomain related to this connection as well in 514d1ff7024SMika Westerberg * case there is a change in services it offers. 515d1ff7024SMika Westerberg */ 516d1ff7024SMika Westerberg xd = tb_xdomain_find_by_uuid_locked(tb, &xchg->src_uuid); 517d1ff7024SMika Westerberg if (xd) { 518d1ff7024SMika Westerberg queue_delayed_work(tb->wq, &xd->get_properties_work, 519d1ff7024SMika Westerberg msecs_to_jiffies(50)); 520d1ff7024SMika Westerberg tb_xdomain_put(xd); 521d1ff7024SMika Westerberg } 522d1ff7024SMika Westerberg 523d1ff7024SMika Westerberg break; 524d1ff7024SMika Westerberg } 525d1ff7024SMika Westerberg 526d1ff7024SMika Westerberg default: 527d1ff7024SMika Westerberg break; 528d1ff7024SMika Westerberg } 529d1ff7024SMika Westerberg 530d1ff7024SMika Westerberg if (ret) { 531d1ff7024SMika Westerberg tb_warn(tb, "failed to send XDomain response for %#x\n", 532d1ff7024SMika Westerberg pkg->type); 533d1ff7024SMika Westerberg } 534d1ff7024SMika Westerberg 535d1ff7024SMika Westerberg out: 536d1ff7024SMika Westerberg kfree(xw->pkg); 537d1ff7024SMika Westerberg kfree(xw); 538d1ff7024SMika Westerberg } 539d1ff7024SMika Westerberg 540d1ff7024SMika Westerberg static void 541d1ff7024SMika Westerberg tb_xdp_schedule_request(struct tb *tb, const struct tb_xdp_header *hdr, 542d1ff7024SMika Westerberg size_t size) 543d1ff7024SMika Westerberg { 544d1ff7024SMika Westerberg struct xdomain_request_work *xw; 545d1ff7024SMika Westerberg 546d1ff7024SMika Westerberg xw = kmalloc(sizeof(*xw), GFP_KERNEL); 547d1ff7024SMika Westerberg if (!xw) 548d1ff7024SMika Westerberg return; 549d1ff7024SMika Westerberg 550d1ff7024SMika Westerberg INIT_WORK(&xw->work, tb_xdp_handle_request); 551d1ff7024SMika Westerberg xw->pkg = kmemdup(hdr, size, GFP_KERNEL); 552d1ff7024SMika Westerberg xw->tb = tb; 553d1ff7024SMika Westerberg 554d1ff7024SMika Westerberg queue_work(tb->wq, &xw->work); 555d1ff7024SMika Westerberg } 556d1ff7024SMika Westerberg 557d1ff7024SMika Westerberg /** 558d1ff7024SMika Westerberg * tb_register_service_driver() - Register XDomain service driver 559d1ff7024SMika Westerberg * @drv: Driver to register 560d1ff7024SMika Westerberg * 561d1ff7024SMika Westerberg * Registers new service driver from @drv to the bus. 562d1ff7024SMika Westerberg */ 563d1ff7024SMika Westerberg int tb_register_service_driver(struct tb_service_driver *drv) 564d1ff7024SMika Westerberg { 565d1ff7024SMika Westerberg drv->driver.bus = &tb_bus_type; 566d1ff7024SMika Westerberg return driver_register(&drv->driver); 567d1ff7024SMika Westerberg } 568d1ff7024SMika Westerberg EXPORT_SYMBOL_GPL(tb_register_service_driver); 569d1ff7024SMika Westerberg 570d1ff7024SMika Westerberg /** 571d1ff7024SMika Westerberg * tb_unregister_service_driver() - Unregister XDomain service driver 572d1ff7024SMika Westerberg * @xdrv: Driver to unregister 573d1ff7024SMika Westerberg * 574d1ff7024SMika Westerberg * Unregisters XDomain service driver from the bus. 575d1ff7024SMika Westerberg */ 576d1ff7024SMika Westerberg void tb_unregister_service_driver(struct tb_service_driver *drv) 577d1ff7024SMika Westerberg { 578d1ff7024SMika Westerberg driver_unregister(&drv->driver); 579d1ff7024SMika Westerberg } 580d1ff7024SMika Westerberg EXPORT_SYMBOL_GPL(tb_unregister_service_driver); 581d1ff7024SMika Westerberg 582d1ff7024SMika Westerberg static ssize_t key_show(struct device *dev, struct device_attribute *attr, 583d1ff7024SMika Westerberg char *buf) 584d1ff7024SMika Westerberg { 585d1ff7024SMika Westerberg struct tb_service *svc = container_of(dev, struct tb_service, dev); 586d1ff7024SMika Westerberg 587d1ff7024SMika Westerberg /* 588d1ff7024SMika Westerberg * It should be null terminated but anything else is pretty much 589d1ff7024SMika Westerberg * allowed. 590d1ff7024SMika Westerberg */ 591d1ff7024SMika Westerberg return sprintf(buf, "%*pEp\n", (int)strlen(svc->key), svc->key); 592d1ff7024SMika Westerberg } 593d1ff7024SMika Westerberg static DEVICE_ATTR_RO(key); 594d1ff7024SMika Westerberg 595d1ff7024SMika Westerberg static int get_modalias(struct tb_service *svc, char *buf, size_t size) 596d1ff7024SMika Westerberg { 597d1ff7024SMika Westerberg return snprintf(buf, size, "tbsvc:k%sp%08Xv%08Xr%08X", svc->key, 598d1ff7024SMika Westerberg svc->prtcid, svc->prtcvers, svc->prtcrevs); 599d1ff7024SMika Westerberg } 600d1ff7024SMika Westerberg 601d1ff7024SMika Westerberg static ssize_t modalias_show(struct device *dev, struct device_attribute *attr, 602d1ff7024SMika Westerberg char *buf) 603d1ff7024SMika Westerberg { 604d1ff7024SMika Westerberg struct tb_service *svc = container_of(dev, struct tb_service, dev); 605d1ff7024SMika Westerberg 606d1ff7024SMika Westerberg /* Full buffer size except new line and null termination */ 607d1ff7024SMika Westerberg get_modalias(svc, buf, PAGE_SIZE - 2); 608d1ff7024SMika Westerberg return sprintf(buf, "%s\n", buf); 609d1ff7024SMika Westerberg } 610d1ff7024SMika Westerberg static DEVICE_ATTR_RO(modalias); 611d1ff7024SMika Westerberg 612d1ff7024SMika Westerberg static ssize_t prtcid_show(struct device *dev, struct device_attribute *attr, 613d1ff7024SMika Westerberg char *buf) 614d1ff7024SMika Westerberg { 615d1ff7024SMika Westerberg struct tb_service *svc = container_of(dev, struct tb_service, dev); 616d1ff7024SMika Westerberg 617d1ff7024SMika Westerberg return sprintf(buf, "%u\n", svc->prtcid); 618d1ff7024SMika Westerberg } 619d1ff7024SMika Westerberg static DEVICE_ATTR_RO(prtcid); 620d1ff7024SMika Westerberg 621d1ff7024SMika Westerberg static ssize_t prtcvers_show(struct device *dev, struct device_attribute *attr, 622d1ff7024SMika Westerberg char *buf) 623d1ff7024SMika Westerberg { 624d1ff7024SMika Westerberg struct tb_service *svc = container_of(dev, struct tb_service, dev); 625d1ff7024SMika Westerberg 626d1ff7024SMika Westerberg return sprintf(buf, "%u\n", svc->prtcvers); 627d1ff7024SMika Westerberg } 628d1ff7024SMika Westerberg static DEVICE_ATTR_RO(prtcvers); 629d1ff7024SMika Westerberg 630d1ff7024SMika Westerberg static ssize_t prtcrevs_show(struct device *dev, struct device_attribute *attr, 631d1ff7024SMika Westerberg char *buf) 632d1ff7024SMika Westerberg { 633d1ff7024SMika Westerberg struct tb_service *svc = container_of(dev, struct tb_service, dev); 634d1ff7024SMika Westerberg 635d1ff7024SMika Westerberg return sprintf(buf, "%u\n", svc->prtcrevs); 636d1ff7024SMika Westerberg } 637d1ff7024SMika Westerberg static DEVICE_ATTR_RO(prtcrevs); 638d1ff7024SMika Westerberg 639d1ff7024SMika Westerberg static ssize_t prtcstns_show(struct device *dev, struct device_attribute *attr, 640d1ff7024SMika Westerberg char *buf) 641d1ff7024SMika Westerberg { 642d1ff7024SMika Westerberg struct tb_service *svc = container_of(dev, struct tb_service, dev); 643d1ff7024SMika Westerberg 644d1ff7024SMika Westerberg return sprintf(buf, "0x%08x\n", svc->prtcstns); 645d1ff7024SMika Westerberg } 646d1ff7024SMika Westerberg static DEVICE_ATTR_RO(prtcstns); 647d1ff7024SMika Westerberg 648d1ff7024SMika Westerberg static struct attribute *tb_service_attrs[] = { 649d1ff7024SMika Westerberg &dev_attr_key.attr, 650d1ff7024SMika Westerberg &dev_attr_modalias.attr, 651d1ff7024SMika Westerberg &dev_attr_prtcid.attr, 652d1ff7024SMika Westerberg &dev_attr_prtcvers.attr, 653d1ff7024SMika Westerberg &dev_attr_prtcrevs.attr, 654d1ff7024SMika Westerberg &dev_attr_prtcstns.attr, 655d1ff7024SMika Westerberg NULL, 656d1ff7024SMika Westerberg }; 657d1ff7024SMika Westerberg 658d1ff7024SMika Westerberg static struct attribute_group tb_service_attr_group = { 659d1ff7024SMika Westerberg .attrs = tb_service_attrs, 660d1ff7024SMika Westerberg }; 661d1ff7024SMika Westerberg 662d1ff7024SMika Westerberg static const struct attribute_group *tb_service_attr_groups[] = { 663d1ff7024SMika Westerberg &tb_service_attr_group, 664d1ff7024SMika Westerberg NULL, 665d1ff7024SMika Westerberg }; 666d1ff7024SMika Westerberg 667d1ff7024SMika Westerberg static int tb_service_uevent(struct device *dev, struct kobj_uevent_env *env) 668d1ff7024SMika Westerberg { 669d1ff7024SMika Westerberg struct tb_service *svc = container_of(dev, struct tb_service, dev); 670d1ff7024SMika Westerberg char modalias[64]; 671d1ff7024SMika Westerberg 672d1ff7024SMika Westerberg get_modalias(svc, modalias, sizeof(modalias)); 673d1ff7024SMika Westerberg return add_uevent_var(env, "MODALIAS=%s", modalias); 674d1ff7024SMika Westerberg } 675d1ff7024SMika Westerberg 676d1ff7024SMika Westerberg static void tb_service_release(struct device *dev) 677d1ff7024SMika Westerberg { 678d1ff7024SMika Westerberg struct tb_service *svc = container_of(dev, struct tb_service, dev); 679d1ff7024SMika Westerberg struct tb_xdomain *xd = tb_service_parent(svc); 680d1ff7024SMika Westerberg 681d1ff7024SMika Westerberg ida_simple_remove(&xd->service_ids, svc->id); 682d1ff7024SMika Westerberg kfree(svc->key); 683d1ff7024SMika Westerberg kfree(svc); 684d1ff7024SMika Westerberg } 685d1ff7024SMika Westerberg 686d1ff7024SMika Westerberg struct device_type tb_service_type = { 687d1ff7024SMika Westerberg .name = "thunderbolt_service", 688d1ff7024SMika Westerberg .groups = tb_service_attr_groups, 689d1ff7024SMika Westerberg .uevent = tb_service_uevent, 690d1ff7024SMika Westerberg .release = tb_service_release, 691d1ff7024SMika Westerberg }; 692d1ff7024SMika Westerberg EXPORT_SYMBOL_GPL(tb_service_type); 693d1ff7024SMika Westerberg 694d1ff7024SMika Westerberg static int remove_missing_service(struct device *dev, void *data) 695d1ff7024SMika Westerberg { 696d1ff7024SMika Westerberg struct tb_xdomain *xd = data; 697d1ff7024SMika Westerberg struct tb_service *svc; 698d1ff7024SMika Westerberg 699d1ff7024SMika Westerberg svc = tb_to_service(dev); 700d1ff7024SMika Westerberg if (!svc) 701d1ff7024SMika Westerberg return 0; 702d1ff7024SMika Westerberg 703d1ff7024SMika Westerberg if (!tb_property_find(xd->properties, svc->key, 704d1ff7024SMika Westerberg TB_PROPERTY_TYPE_DIRECTORY)) 705d1ff7024SMika Westerberg device_unregister(dev); 706d1ff7024SMika Westerberg 707d1ff7024SMika Westerberg return 0; 708d1ff7024SMika Westerberg } 709d1ff7024SMika Westerberg 710d1ff7024SMika Westerberg static int find_service(struct device *dev, void *data) 711d1ff7024SMika Westerberg { 712d1ff7024SMika Westerberg const struct tb_property *p = data; 713d1ff7024SMika Westerberg struct tb_service *svc; 714d1ff7024SMika Westerberg 715d1ff7024SMika Westerberg svc = tb_to_service(dev); 716d1ff7024SMika Westerberg if (!svc) 717d1ff7024SMika Westerberg return 0; 718d1ff7024SMika Westerberg 719d1ff7024SMika Westerberg return !strcmp(svc->key, p->key); 720d1ff7024SMika Westerberg } 721d1ff7024SMika Westerberg 722d1ff7024SMika Westerberg static int populate_service(struct tb_service *svc, 723d1ff7024SMika Westerberg struct tb_property *property) 724d1ff7024SMika Westerberg { 725d1ff7024SMika Westerberg struct tb_property_dir *dir = property->value.dir; 726d1ff7024SMika Westerberg struct tb_property *p; 727d1ff7024SMika Westerberg 728d1ff7024SMika Westerberg /* Fill in standard properties */ 729d1ff7024SMika Westerberg p = tb_property_find(dir, "prtcid", TB_PROPERTY_TYPE_VALUE); 730d1ff7024SMika Westerberg if (p) 731d1ff7024SMika Westerberg svc->prtcid = p->value.immediate; 732d1ff7024SMika Westerberg p = tb_property_find(dir, "prtcvers", TB_PROPERTY_TYPE_VALUE); 733d1ff7024SMika Westerberg if (p) 734d1ff7024SMika Westerberg svc->prtcvers = p->value.immediate; 735d1ff7024SMika Westerberg p = tb_property_find(dir, "prtcrevs", TB_PROPERTY_TYPE_VALUE); 736d1ff7024SMika Westerberg if (p) 737d1ff7024SMika Westerberg svc->prtcrevs = p->value.immediate; 738d1ff7024SMika Westerberg p = tb_property_find(dir, "prtcstns", TB_PROPERTY_TYPE_VALUE); 739d1ff7024SMika Westerberg if (p) 740d1ff7024SMika Westerberg svc->prtcstns = p->value.immediate; 741d1ff7024SMika Westerberg 742d1ff7024SMika Westerberg svc->key = kstrdup(property->key, GFP_KERNEL); 743d1ff7024SMika Westerberg if (!svc->key) 744d1ff7024SMika Westerberg return -ENOMEM; 745d1ff7024SMika Westerberg 746d1ff7024SMika Westerberg return 0; 747d1ff7024SMika Westerberg } 748d1ff7024SMika Westerberg 749d1ff7024SMika Westerberg static void enumerate_services(struct tb_xdomain *xd) 750d1ff7024SMika Westerberg { 751d1ff7024SMika Westerberg struct tb_service *svc; 752d1ff7024SMika Westerberg struct tb_property *p; 753d1ff7024SMika Westerberg struct device *dev; 754d1ff7024SMika Westerberg 755d1ff7024SMika Westerberg /* 756d1ff7024SMika Westerberg * First remove all services that are not available anymore in 757d1ff7024SMika Westerberg * the updated property block. 758d1ff7024SMika Westerberg */ 759d1ff7024SMika Westerberg device_for_each_child_reverse(&xd->dev, xd, remove_missing_service); 760d1ff7024SMika Westerberg 761d1ff7024SMika Westerberg /* Then re-enumerate properties creating new services as we go */ 762d1ff7024SMika Westerberg tb_property_for_each(xd->properties, p) { 763d1ff7024SMika Westerberg if (p->type != TB_PROPERTY_TYPE_DIRECTORY) 764d1ff7024SMika Westerberg continue; 765d1ff7024SMika Westerberg 766d1ff7024SMika Westerberg /* If the service exists already we are fine */ 767d1ff7024SMika Westerberg dev = device_find_child(&xd->dev, p, find_service); 768d1ff7024SMika Westerberg if (dev) { 769d1ff7024SMika Westerberg put_device(dev); 770d1ff7024SMika Westerberg continue; 771d1ff7024SMika Westerberg } 772d1ff7024SMika Westerberg 773d1ff7024SMika Westerberg svc = kzalloc(sizeof(*svc), GFP_KERNEL); 774d1ff7024SMika Westerberg if (!svc) 775d1ff7024SMika Westerberg break; 776d1ff7024SMika Westerberg 777d1ff7024SMika Westerberg if (populate_service(svc, p)) { 778d1ff7024SMika Westerberg kfree(svc); 779d1ff7024SMika Westerberg break; 780d1ff7024SMika Westerberg } 781d1ff7024SMika Westerberg 782d1ff7024SMika Westerberg svc->id = ida_simple_get(&xd->service_ids, 0, 0, GFP_KERNEL); 783d1ff7024SMika Westerberg svc->dev.bus = &tb_bus_type; 784d1ff7024SMika Westerberg svc->dev.type = &tb_service_type; 785d1ff7024SMika Westerberg svc->dev.parent = &xd->dev; 786d1ff7024SMika Westerberg dev_set_name(&svc->dev, "%s.%d", dev_name(&xd->dev), svc->id); 787d1ff7024SMika Westerberg 788d1ff7024SMika Westerberg if (device_register(&svc->dev)) { 789d1ff7024SMika Westerberg put_device(&svc->dev); 790d1ff7024SMika Westerberg break; 791d1ff7024SMika Westerberg } 792d1ff7024SMika Westerberg } 793d1ff7024SMika Westerberg } 794d1ff7024SMika Westerberg 795d1ff7024SMika Westerberg static int populate_properties(struct tb_xdomain *xd, 796d1ff7024SMika Westerberg struct tb_property_dir *dir) 797d1ff7024SMika Westerberg { 798d1ff7024SMika Westerberg const struct tb_property *p; 799d1ff7024SMika Westerberg 800d1ff7024SMika Westerberg /* Required properties */ 801d1ff7024SMika Westerberg p = tb_property_find(dir, "deviceid", TB_PROPERTY_TYPE_VALUE); 802d1ff7024SMika Westerberg if (!p) 803d1ff7024SMika Westerberg return -EINVAL; 804d1ff7024SMika Westerberg xd->device = p->value.immediate; 805d1ff7024SMika Westerberg 806d1ff7024SMika Westerberg p = tb_property_find(dir, "vendorid", TB_PROPERTY_TYPE_VALUE); 807d1ff7024SMika Westerberg if (!p) 808d1ff7024SMika Westerberg return -EINVAL; 809d1ff7024SMika Westerberg xd->vendor = p->value.immediate; 810d1ff7024SMika Westerberg 811d1ff7024SMika Westerberg kfree(xd->device_name); 812d1ff7024SMika Westerberg xd->device_name = NULL; 813d1ff7024SMika Westerberg kfree(xd->vendor_name); 814d1ff7024SMika Westerberg xd->vendor_name = NULL; 815d1ff7024SMika Westerberg 816d1ff7024SMika Westerberg /* Optional properties */ 817d1ff7024SMika Westerberg p = tb_property_find(dir, "deviceid", TB_PROPERTY_TYPE_TEXT); 818d1ff7024SMika Westerberg if (p) 819d1ff7024SMika Westerberg xd->device_name = kstrdup(p->value.text, GFP_KERNEL); 820d1ff7024SMika Westerberg p = tb_property_find(dir, "vendorid", TB_PROPERTY_TYPE_TEXT); 821d1ff7024SMika Westerberg if (p) 822d1ff7024SMika Westerberg xd->vendor_name = kstrdup(p->value.text, GFP_KERNEL); 823d1ff7024SMika Westerberg 824d1ff7024SMika Westerberg return 0; 825d1ff7024SMika Westerberg } 826d1ff7024SMika Westerberg 827d1ff7024SMika Westerberg /* Called with @xd->lock held */ 828d1ff7024SMika Westerberg static void tb_xdomain_restore_paths(struct tb_xdomain *xd) 829d1ff7024SMika Westerberg { 830d1ff7024SMika Westerberg if (!xd->resume) 831d1ff7024SMika Westerberg return; 832d1ff7024SMika Westerberg 833d1ff7024SMika Westerberg xd->resume = false; 834d1ff7024SMika Westerberg if (xd->transmit_path) { 835d1ff7024SMika Westerberg dev_dbg(&xd->dev, "re-establishing DMA path\n"); 836d1ff7024SMika Westerberg tb_domain_approve_xdomain_paths(xd->tb, xd); 837d1ff7024SMika Westerberg } 838d1ff7024SMika Westerberg } 839d1ff7024SMika Westerberg 840d1ff7024SMika Westerberg static void tb_xdomain_get_properties(struct work_struct *work) 841d1ff7024SMika Westerberg { 842d1ff7024SMika Westerberg struct tb_xdomain *xd = container_of(work, typeof(*xd), 843d1ff7024SMika Westerberg get_properties_work.work); 844d1ff7024SMika Westerberg struct tb_property_dir *dir; 845d1ff7024SMika Westerberg struct tb *tb = xd->tb; 846d1ff7024SMika Westerberg bool update = false; 847d1ff7024SMika Westerberg u32 *block = NULL; 848d1ff7024SMika Westerberg u32 gen = 0; 849d1ff7024SMika Westerberg int ret; 850d1ff7024SMika Westerberg 851d1ff7024SMika Westerberg ret = tb_xdp_properties_request(tb->ctl, xd->route, xd->local_uuid, 852d1ff7024SMika Westerberg xd->remote_uuid, xd->properties_retries, 853d1ff7024SMika Westerberg &block, &gen); 854d1ff7024SMika Westerberg if (ret < 0) { 855d1ff7024SMika Westerberg if (xd->properties_retries-- > 0) { 856d1ff7024SMika Westerberg queue_delayed_work(xd->tb->wq, &xd->get_properties_work, 857d1ff7024SMika Westerberg msecs_to_jiffies(1000)); 858d1ff7024SMika Westerberg } else { 859d1ff7024SMika Westerberg /* Give up now */ 860d1ff7024SMika Westerberg dev_err(&xd->dev, 861d1ff7024SMika Westerberg "failed read XDomain properties from %pUb\n", 862d1ff7024SMika Westerberg xd->remote_uuid); 863d1ff7024SMika Westerberg } 864d1ff7024SMika Westerberg return; 865d1ff7024SMika Westerberg } 866d1ff7024SMika Westerberg 867d1ff7024SMika Westerberg xd->properties_retries = XDOMAIN_PROPERTIES_RETRIES; 868d1ff7024SMika Westerberg 869d1ff7024SMika Westerberg mutex_lock(&xd->lock); 870d1ff7024SMika Westerberg 871d1ff7024SMika Westerberg /* Only accept newer generation properties */ 872d1ff7024SMika Westerberg if (xd->properties && gen <= xd->property_block_gen) { 873d1ff7024SMika Westerberg /* 874d1ff7024SMika Westerberg * On resume it is likely that the properties block is 875d1ff7024SMika Westerberg * not changed (unless the other end added or removed 876d1ff7024SMika Westerberg * services). However, we need to make sure the existing 877d1ff7024SMika Westerberg * DMA paths are restored properly. 878d1ff7024SMika Westerberg */ 879d1ff7024SMika Westerberg tb_xdomain_restore_paths(xd); 880d1ff7024SMika Westerberg goto err_free_block; 881d1ff7024SMika Westerberg } 882d1ff7024SMika Westerberg 883d1ff7024SMika Westerberg dir = tb_property_parse_dir(block, ret); 884d1ff7024SMika Westerberg if (!dir) { 885d1ff7024SMika Westerberg dev_err(&xd->dev, "failed to parse XDomain properties\n"); 886d1ff7024SMika Westerberg goto err_free_block; 887d1ff7024SMika Westerberg } 888d1ff7024SMika Westerberg 889d1ff7024SMika Westerberg ret = populate_properties(xd, dir); 890d1ff7024SMika Westerberg if (ret) { 891d1ff7024SMika Westerberg dev_err(&xd->dev, "missing XDomain properties in response\n"); 892d1ff7024SMika Westerberg goto err_free_dir; 893d1ff7024SMika Westerberg } 894d1ff7024SMika Westerberg 895d1ff7024SMika Westerberg /* Release the existing one */ 896d1ff7024SMika Westerberg if (xd->properties) { 897d1ff7024SMika Westerberg tb_property_free_dir(xd->properties); 898d1ff7024SMika Westerberg update = true; 899d1ff7024SMika Westerberg } 900d1ff7024SMika Westerberg 901d1ff7024SMika Westerberg xd->properties = dir; 902d1ff7024SMika Westerberg xd->property_block_gen = gen; 903d1ff7024SMika Westerberg 904d1ff7024SMika Westerberg tb_xdomain_restore_paths(xd); 905d1ff7024SMika Westerberg 906d1ff7024SMika Westerberg mutex_unlock(&xd->lock); 907d1ff7024SMika Westerberg 908d1ff7024SMika Westerberg kfree(block); 909d1ff7024SMika Westerberg 910d1ff7024SMika Westerberg /* 911d1ff7024SMika Westerberg * Now the device should be ready enough so we can add it to the 912d1ff7024SMika Westerberg * bus and let userspace know about it. If the device is already 913d1ff7024SMika Westerberg * registered, we notify the userspace that it has changed. 914d1ff7024SMika Westerberg */ 915d1ff7024SMika Westerberg if (!update) { 916d1ff7024SMika Westerberg if (device_add(&xd->dev)) { 917d1ff7024SMika Westerberg dev_err(&xd->dev, "failed to add XDomain device\n"); 918d1ff7024SMika Westerberg return; 919d1ff7024SMika Westerberg } 920d1ff7024SMika Westerberg } else { 921d1ff7024SMika Westerberg kobject_uevent(&xd->dev.kobj, KOBJ_CHANGE); 922d1ff7024SMika Westerberg } 923d1ff7024SMika Westerberg 924d1ff7024SMika Westerberg enumerate_services(xd); 925d1ff7024SMika Westerberg return; 926d1ff7024SMika Westerberg 927d1ff7024SMika Westerberg err_free_dir: 928d1ff7024SMika Westerberg tb_property_free_dir(dir); 929d1ff7024SMika Westerberg err_free_block: 930d1ff7024SMika Westerberg kfree(block); 931d1ff7024SMika Westerberg mutex_unlock(&xd->lock); 932d1ff7024SMika Westerberg } 933d1ff7024SMika Westerberg 934d1ff7024SMika Westerberg static void tb_xdomain_properties_changed(struct work_struct *work) 935d1ff7024SMika Westerberg { 936d1ff7024SMika Westerberg struct tb_xdomain *xd = container_of(work, typeof(*xd), 937d1ff7024SMika Westerberg properties_changed_work.work); 938d1ff7024SMika Westerberg int ret; 939d1ff7024SMika Westerberg 940d1ff7024SMika Westerberg ret = tb_xdp_properties_changed_request(xd->tb->ctl, xd->route, 941d1ff7024SMika Westerberg xd->properties_changed_retries, xd->local_uuid); 942d1ff7024SMika Westerberg if (ret) { 943d1ff7024SMika Westerberg if (xd->properties_changed_retries-- > 0) 944d1ff7024SMika Westerberg queue_delayed_work(xd->tb->wq, 945d1ff7024SMika Westerberg &xd->properties_changed_work, 946d1ff7024SMika Westerberg msecs_to_jiffies(1000)); 947d1ff7024SMika Westerberg return; 948d1ff7024SMika Westerberg } 949d1ff7024SMika Westerberg 950d1ff7024SMika Westerberg xd->properties_changed_retries = XDOMAIN_PROPERTIES_CHANGED_RETRIES; 951d1ff7024SMika Westerberg } 952d1ff7024SMika Westerberg 953d1ff7024SMika Westerberg static ssize_t device_show(struct device *dev, struct device_attribute *attr, 954d1ff7024SMika Westerberg char *buf) 955d1ff7024SMika Westerberg { 956d1ff7024SMika Westerberg struct tb_xdomain *xd = container_of(dev, struct tb_xdomain, dev); 957d1ff7024SMika Westerberg 958d1ff7024SMika Westerberg return sprintf(buf, "%#x\n", xd->device); 959d1ff7024SMika Westerberg } 960d1ff7024SMika Westerberg static DEVICE_ATTR_RO(device); 961d1ff7024SMika Westerberg 962d1ff7024SMika Westerberg static ssize_t 963d1ff7024SMika Westerberg device_name_show(struct device *dev, struct device_attribute *attr, char *buf) 964d1ff7024SMika Westerberg { 965d1ff7024SMika Westerberg struct tb_xdomain *xd = container_of(dev, struct tb_xdomain, dev); 966d1ff7024SMika Westerberg int ret; 967d1ff7024SMika Westerberg 968d1ff7024SMika Westerberg if (mutex_lock_interruptible(&xd->lock)) 969d1ff7024SMika Westerberg return -ERESTARTSYS; 970d1ff7024SMika Westerberg ret = sprintf(buf, "%s\n", xd->device_name ? xd->device_name : ""); 971d1ff7024SMika Westerberg mutex_unlock(&xd->lock); 972d1ff7024SMika Westerberg 973d1ff7024SMika Westerberg return ret; 974d1ff7024SMika Westerberg } 975d1ff7024SMika Westerberg static DEVICE_ATTR_RO(device_name); 976d1ff7024SMika Westerberg 977d1ff7024SMika Westerberg static ssize_t vendor_show(struct device *dev, struct device_attribute *attr, 978d1ff7024SMika Westerberg char *buf) 979d1ff7024SMika Westerberg { 980d1ff7024SMika Westerberg struct tb_xdomain *xd = container_of(dev, struct tb_xdomain, dev); 981d1ff7024SMika Westerberg 982d1ff7024SMika Westerberg return sprintf(buf, "%#x\n", xd->vendor); 983d1ff7024SMika Westerberg } 984d1ff7024SMika Westerberg static DEVICE_ATTR_RO(vendor); 985d1ff7024SMika Westerberg 986d1ff7024SMika Westerberg static ssize_t 987d1ff7024SMika Westerberg vendor_name_show(struct device *dev, struct device_attribute *attr, char *buf) 988d1ff7024SMika Westerberg { 989d1ff7024SMika Westerberg struct tb_xdomain *xd = container_of(dev, struct tb_xdomain, dev); 990d1ff7024SMika Westerberg int ret; 991d1ff7024SMika Westerberg 992d1ff7024SMika Westerberg if (mutex_lock_interruptible(&xd->lock)) 993d1ff7024SMika Westerberg return -ERESTARTSYS; 994d1ff7024SMika Westerberg ret = sprintf(buf, "%s\n", xd->vendor_name ? xd->vendor_name : ""); 995d1ff7024SMika Westerberg mutex_unlock(&xd->lock); 996d1ff7024SMika Westerberg 997d1ff7024SMika Westerberg return ret; 998d1ff7024SMika Westerberg } 999d1ff7024SMika Westerberg static DEVICE_ATTR_RO(vendor_name); 1000d1ff7024SMika Westerberg 1001d1ff7024SMika Westerberg static ssize_t unique_id_show(struct device *dev, struct device_attribute *attr, 1002d1ff7024SMika Westerberg char *buf) 1003d1ff7024SMika Westerberg { 1004d1ff7024SMika Westerberg struct tb_xdomain *xd = container_of(dev, struct tb_xdomain, dev); 1005d1ff7024SMika Westerberg 1006d1ff7024SMika Westerberg return sprintf(buf, "%pUb\n", xd->remote_uuid); 1007d1ff7024SMika Westerberg } 1008d1ff7024SMika Westerberg static DEVICE_ATTR_RO(unique_id); 1009d1ff7024SMika Westerberg 1010d1ff7024SMika Westerberg static struct attribute *xdomain_attrs[] = { 1011d1ff7024SMika Westerberg &dev_attr_device.attr, 1012d1ff7024SMika Westerberg &dev_attr_device_name.attr, 1013d1ff7024SMika Westerberg &dev_attr_unique_id.attr, 1014d1ff7024SMika Westerberg &dev_attr_vendor.attr, 1015d1ff7024SMika Westerberg &dev_attr_vendor_name.attr, 1016d1ff7024SMika Westerberg NULL, 1017d1ff7024SMika Westerberg }; 1018d1ff7024SMika Westerberg 1019d1ff7024SMika Westerberg static struct attribute_group xdomain_attr_group = { 1020d1ff7024SMika Westerberg .attrs = xdomain_attrs, 1021d1ff7024SMika Westerberg }; 1022d1ff7024SMika Westerberg 1023d1ff7024SMika Westerberg static const struct attribute_group *xdomain_attr_groups[] = { 1024d1ff7024SMika Westerberg &xdomain_attr_group, 1025d1ff7024SMika Westerberg NULL, 1026d1ff7024SMika Westerberg }; 1027d1ff7024SMika Westerberg 1028d1ff7024SMika Westerberg static void tb_xdomain_release(struct device *dev) 1029d1ff7024SMika Westerberg { 1030d1ff7024SMika Westerberg struct tb_xdomain *xd = container_of(dev, struct tb_xdomain, dev); 1031d1ff7024SMika Westerberg 1032d1ff7024SMika Westerberg put_device(xd->dev.parent); 1033d1ff7024SMika Westerberg 1034d1ff7024SMika Westerberg tb_property_free_dir(xd->properties); 1035d1ff7024SMika Westerberg ida_destroy(&xd->service_ids); 1036d1ff7024SMika Westerberg 1037d1ff7024SMika Westerberg kfree(xd->local_uuid); 1038d1ff7024SMika Westerberg kfree(xd->remote_uuid); 1039d1ff7024SMika Westerberg kfree(xd->device_name); 1040d1ff7024SMika Westerberg kfree(xd->vendor_name); 1041d1ff7024SMika Westerberg kfree(xd); 1042d1ff7024SMika Westerberg } 1043d1ff7024SMika Westerberg 1044d1ff7024SMika Westerberg static void start_handshake(struct tb_xdomain *xd) 1045d1ff7024SMika Westerberg { 1046d1ff7024SMika Westerberg xd->properties_retries = XDOMAIN_PROPERTIES_RETRIES; 1047d1ff7024SMika Westerberg xd->properties_changed_retries = XDOMAIN_PROPERTIES_CHANGED_RETRIES; 1048d1ff7024SMika Westerberg 1049d1ff7024SMika Westerberg /* Start exchanging properties with the other host */ 1050d1ff7024SMika Westerberg queue_delayed_work(xd->tb->wq, &xd->properties_changed_work, 1051d1ff7024SMika Westerberg msecs_to_jiffies(100)); 1052d1ff7024SMika Westerberg queue_delayed_work(xd->tb->wq, &xd->get_properties_work, 1053d1ff7024SMika Westerberg msecs_to_jiffies(1000)); 1054d1ff7024SMika Westerberg } 1055d1ff7024SMika Westerberg 1056d1ff7024SMika Westerberg static void stop_handshake(struct tb_xdomain *xd) 1057d1ff7024SMika Westerberg { 1058d1ff7024SMika Westerberg xd->properties_retries = 0; 1059d1ff7024SMika Westerberg xd->properties_changed_retries = 0; 1060d1ff7024SMika Westerberg 1061d1ff7024SMika Westerberg cancel_delayed_work_sync(&xd->get_properties_work); 1062d1ff7024SMika Westerberg cancel_delayed_work_sync(&xd->properties_changed_work); 1063d1ff7024SMika Westerberg } 1064d1ff7024SMika Westerberg 1065d1ff7024SMika Westerberg static int __maybe_unused tb_xdomain_suspend(struct device *dev) 1066d1ff7024SMika Westerberg { 1067d1ff7024SMika Westerberg stop_handshake(tb_to_xdomain(dev)); 1068d1ff7024SMika Westerberg return 0; 1069d1ff7024SMika Westerberg } 1070d1ff7024SMika Westerberg 1071d1ff7024SMika Westerberg static int __maybe_unused tb_xdomain_resume(struct device *dev) 1072d1ff7024SMika Westerberg { 1073d1ff7024SMika Westerberg struct tb_xdomain *xd = tb_to_xdomain(dev); 1074d1ff7024SMika Westerberg 1075d1ff7024SMika Westerberg /* 1076d1ff7024SMika Westerberg * Ask tb_xdomain_get_properties() restore any existing DMA 1077d1ff7024SMika Westerberg * paths after properties are re-read. 1078d1ff7024SMika Westerberg */ 1079d1ff7024SMika Westerberg xd->resume = true; 1080d1ff7024SMika Westerberg start_handshake(xd); 1081d1ff7024SMika Westerberg 1082d1ff7024SMika Westerberg return 0; 1083d1ff7024SMika Westerberg } 1084d1ff7024SMika Westerberg 1085d1ff7024SMika Westerberg static const struct dev_pm_ops tb_xdomain_pm_ops = { 1086d1ff7024SMika Westerberg SET_SYSTEM_SLEEP_PM_OPS(tb_xdomain_suspend, tb_xdomain_resume) 1087d1ff7024SMika Westerberg }; 1088d1ff7024SMika Westerberg 1089d1ff7024SMika Westerberg struct device_type tb_xdomain_type = { 1090d1ff7024SMika Westerberg .name = "thunderbolt_xdomain", 1091d1ff7024SMika Westerberg .release = tb_xdomain_release, 1092d1ff7024SMika Westerberg .pm = &tb_xdomain_pm_ops, 1093d1ff7024SMika Westerberg }; 1094d1ff7024SMika Westerberg EXPORT_SYMBOL_GPL(tb_xdomain_type); 1095d1ff7024SMika Westerberg 1096d1ff7024SMika Westerberg /** 1097d1ff7024SMika Westerberg * tb_xdomain_alloc() - Allocate new XDomain object 1098d1ff7024SMika Westerberg * @tb: Domain where the XDomain belongs 1099d1ff7024SMika Westerberg * @parent: Parent device (the switch through the connection to the 1100d1ff7024SMika Westerberg * other domain is reached). 1101d1ff7024SMika Westerberg * @route: Route string used to reach the other domain 1102d1ff7024SMika Westerberg * @local_uuid: Our local domain UUID 1103d1ff7024SMika Westerberg * @remote_uuid: UUID of the other domain 1104d1ff7024SMika Westerberg * 1105d1ff7024SMika Westerberg * Allocates new XDomain structure and returns pointer to that. The 1106d1ff7024SMika Westerberg * object must be released by calling tb_xdomain_put(). 1107d1ff7024SMika Westerberg */ 1108d1ff7024SMika Westerberg struct tb_xdomain *tb_xdomain_alloc(struct tb *tb, struct device *parent, 1109d1ff7024SMika Westerberg u64 route, const uuid_t *local_uuid, 1110d1ff7024SMika Westerberg const uuid_t *remote_uuid) 1111d1ff7024SMika Westerberg { 1112d1ff7024SMika Westerberg struct tb_xdomain *xd; 1113d1ff7024SMika Westerberg 1114d1ff7024SMika Westerberg xd = kzalloc(sizeof(*xd), GFP_KERNEL); 1115d1ff7024SMika Westerberg if (!xd) 1116d1ff7024SMika Westerberg return NULL; 1117d1ff7024SMika Westerberg 1118d1ff7024SMika Westerberg xd->tb = tb; 1119d1ff7024SMika Westerberg xd->route = route; 1120d1ff7024SMika Westerberg ida_init(&xd->service_ids); 1121d1ff7024SMika Westerberg mutex_init(&xd->lock); 1122d1ff7024SMika Westerberg INIT_DELAYED_WORK(&xd->get_properties_work, tb_xdomain_get_properties); 1123d1ff7024SMika Westerberg INIT_DELAYED_WORK(&xd->properties_changed_work, 1124d1ff7024SMika Westerberg tb_xdomain_properties_changed); 1125d1ff7024SMika Westerberg 1126d1ff7024SMika Westerberg xd->local_uuid = kmemdup(local_uuid, sizeof(uuid_t), GFP_KERNEL); 1127d1ff7024SMika Westerberg if (!xd->local_uuid) 1128d1ff7024SMika Westerberg goto err_free; 1129d1ff7024SMika Westerberg 1130d1ff7024SMika Westerberg xd->remote_uuid = kmemdup(remote_uuid, sizeof(uuid_t), GFP_KERNEL); 1131d1ff7024SMika Westerberg if (!xd->remote_uuid) 1132d1ff7024SMika Westerberg goto err_free_local_uuid; 1133d1ff7024SMika Westerberg 1134d1ff7024SMika Westerberg device_initialize(&xd->dev); 1135d1ff7024SMika Westerberg xd->dev.parent = get_device(parent); 1136d1ff7024SMika Westerberg xd->dev.bus = &tb_bus_type; 1137d1ff7024SMika Westerberg xd->dev.type = &tb_xdomain_type; 1138d1ff7024SMika Westerberg xd->dev.groups = xdomain_attr_groups; 1139d1ff7024SMika Westerberg dev_set_name(&xd->dev, "%u-%llx", tb->index, route); 1140d1ff7024SMika Westerberg 1141d1ff7024SMika Westerberg return xd; 1142d1ff7024SMika Westerberg 1143d1ff7024SMika Westerberg err_free_local_uuid: 1144d1ff7024SMika Westerberg kfree(xd->local_uuid); 1145d1ff7024SMika Westerberg err_free: 1146d1ff7024SMika Westerberg kfree(xd); 1147d1ff7024SMika Westerberg 1148d1ff7024SMika Westerberg return NULL; 1149d1ff7024SMika Westerberg } 1150d1ff7024SMika Westerberg 1151d1ff7024SMika Westerberg /** 1152d1ff7024SMika Westerberg * tb_xdomain_add() - Add XDomain to the bus 1153d1ff7024SMika Westerberg * @xd: XDomain to add 1154d1ff7024SMika Westerberg * 1155d1ff7024SMika Westerberg * This function starts XDomain discovery protocol handshake and 1156d1ff7024SMika Westerberg * eventually adds the XDomain to the bus. After calling this function 1157d1ff7024SMika Westerberg * the caller needs to call tb_xdomain_remove() in order to remove and 1158d1ff7024SMika Westerberg * release the object regardless whether the handshake succeeded or not. 1159d1ff7024SMika Westerberg */ 1160d1ff7024SMika Westerberg void tb_xdomain_add(struct tb_xdomain *xd) 1161d1ff7024SMika Westerberg { 1162d1ff7024SMika Westerberg /* Start exchanging properties with the other host */ 1163d1ff7024SMika Westerberg start_handshake(xd); 1164d1ff7024SMika Westerberg } 1165d1ff7024SMika Westerberg 1166d1ff7024SMika Westerberg static int unregister_service(struct device *dev, void *data) 1167d1ff7024SMika Westerberg { 1168d1ff7024SMika Westerberg device_unregister(dev); 1169d1ff7024SMika Westerberg return 0; 1170d1ff7024SMika Westerberg } 1171d1ff7024SMika Westerberg 1172d1ff7024SMika Westerberg /** 1173d1ff7024SMika Westerberg * tb_xdomain_remove() - Remove XDomain from the bus 1174d1ff7024SMika Westerberg * @xd: XDomain to remove 1175d1ff7024SMika Westerberg * 1176d1ff7024SMika Westerberg * This will stop all ongoing configuration work and remove the XDomain 1177d1ff7024SMika Westerberg * along with any services from the bus. When the last reference to @xd 1178d1ff7024SMika Westerberg * is released the object will be released as well. 1179d1ff7024SMika Westerberg */ 1180d1ff7024SMika Westerberg void tb_xdomain_remove(struct tb_xdomain *xd) 1181d1ff7024SMika Westerberg { 1182d1ff7024SMika Westerberg stop_handshake(xd); 1183d1ff7024SMika Westerberg 1184d1ff7024SMika Westerberg device_for_each_child_reverse(&xd->dev, xd, unregister_service); 1185d1ff7024SMika Westerberg 1186d1ff7024SMika Westerberg if (!device_is_registered(&xd->dev)) 1187d1ff7024SMika Westerberg put_device(&xd->dev); 1188d1ff7024SMika Westerberg else 1189d1ff7024SMika Westerberg device_unregister(&xd->dev); 1190d1ff7024SMika Westerberg } 1191d1ff7024SMika Westerberg 1192d1ff7024SMika Westerberg /** 1193d1ff7024SMika Westerberg * tb_xdomain_enable_paths() - Enable DMA paths for XDomain connection 1194d1ff7024SMika Westerberg * @xd: XDomain connection 1195d1ff7024SMika Westerberg * @transmit_path: HopID of the transmit path the other end is using to 1196d1ff7024SMika Westerberg * send packets 1197d1ff7024SMika Westerberg * @transmit_ring: DMA ring used to receive packets from the other end 1198d1ff7024SMika Westerberg * @receive_path: HopID of the receive path the other end is using to 1199d1ff7024SMika Westerberg * receive packets 1200d1ff7024SMika Westerberg * @receive_ring: DMA ring used to send packets to the other end 1201d1ff7024SMika Westerberg * 1202d1ff7024SMika Westerberg * The function enables DMA paths accordingly so that after successful 1203d1ff7024SMika Westerberg * return the caller can send and receive packets using high-speed DMA 1204d1ff7024SMika Westerberg * path. 1205d1ff7024SMika Westerberg * 1206d1ff7024SMika Westerberg * Return: %0 in case of success and negative errno in case of error 1207d1ff7024SMika Westerberg */ 1208d1ff7024SMika Westerberg int tb_xdomain_enable_paths(struct tb_xdomain *xd, u16 transmit_path, 1209d1ff7024SMika Westerberg u16 transmit_ring, u16 receive_path, 1210d1ff7024SMika Westerberg u16 receive_ring) 1211d1ff7024SMika Westerberg { 1212d1ff7024SMika Westerberg int ret; 1213d1ff7024SMika Westerberg 1214d1ff7024SMika Westerberg mutex_lock(&xd->lock); 1215d1ff7024SMika Westerberg 1216d1ff7024SMika Westerberg if (xd->transmit_path) { 1217d1ff7024SMika Westerberg ret = xd->transmit_path == transmit_path ? 0 : -EBUSY; 1218d1ff7024SMika Westerberg goto exit_unlock; 1219d1ff7024SMika Westerberg } 1220d1ff7024SMika Westerberg 1221d1ff7024SMika Westerberg xd->transmit_path = transmit_path; 1222d1ff7024SMika Westerberg xd->transmit_ring = transmit_ring; 1223d1ff7024SMika Westerberg xd->receive_path = receive_path; 1224d1ff7024SMika Westerberg xd->receive_ring = receive_ring; 1225d1ff7024SMika Westerberg 1226d1ff7024SMika Westerberg ret = tb_domain_approve_xdomain_paths(xd->tb, xd); 1227d1ff7024SMika Westerberg 1228d1ff7024SMika Westerberg exit_unlock: 1229d1ff7024SMika Westerberg mutex_unlock(&xd->lock); 1230d1ff7024SMika Westerberg 1231d1ff7024SMika Westerberg return ret; 1232d1ff7024SMika Westerberg } 1233d1ff7024SMika Westerberg EXPORT_SYMBOL_GPL(tb_xdomain_enable_paths); 1234d1ff7024SMika Westerberg 1235d1ff7024SMika Westerberg /** 1236d1ff7024SMika Westerberg * tb_xdomain_disable_paths() - Disable DMA paths for XDomain connection 1237d1ff7024SMika Westerberg * @xd: XDomain connection 1238d1ff7024SMika Westerberg * 1239d1ff7024SMika Westerberg * This does the opposite of tb_xdomain_enable_paths(). After call to 1240d1ff7024SMika Westerberg * this the caller is not expected to use the rings anymore. 1241d1ff7024SMika Westerberg * 1242d1ff7024SMika Westerberg * Return: %0 in case of success and negative errno in case of error 1243d1ff7024SMika Westerberg */ 1244d1ff7024SMika Westerberg int tb_xdomain_disable_paths(struct tb_xdomain *xd) 1245d1ff7024SMika Westerberg { 1246d1ff7024SMika Westerberg int ret = 0; 1247d1ff7024SMika Westerberg 1248d1ff7024SMika Westerberg mutex_lock(&xd->lock); 1249d1ff7024SMika Westerberg if (xd->transmit_path) { 1250d1ff7024SMika Westerberg xd->transmit_path = 0; 1251d1ff7024SMika Westerberg xd->transmit_ring = 0; 1252d1ff7024SMika Westerberg xd->receive_path = 0; 1253d1ff7024SMika Westerberg xd->receive_ring = 0; 1254d1ff7024SMika Westerberg 1255d1ff7024SMika Westerberg ret = tb_domain_disconnect_xdomain_paths(xd->tb, xd); 1256d1ff7024SMika Westerberg } 1257d1ff7024SMika Westerberg mutex_unlock(&xd->lock); 1258d1ff7024SMika Westerberg 1259d1ff7024SMika Westerberg return ret; 1260d1ff7024SMika Westerberg } 1261d1ff7024SMika Westerberg EXPORT_SYMBOL_GPL(tb_xdomain_disable_paths); 1262d1ff7024SMika Westerberg 1263d1ff7024SMika Westerberg struct tb_xdomain_lookup { 1264d1ff7024SMika Westerberg const uuid_t *uuid; 1265d1ff7024SMika Westerberg u8 link; 1266d1ff7024SMika Westerberg u8 depth; 1267d1ff7024SMika Westerberg }; 1268d1ff7024SMika Westerberg 1269d1ff7024SMika Westerberg static struct tb_xdomain *switch_find_xdomain(struct tb_switch *sw, 1270d1ff7024SMika Westerberg const struct tb_xdomain_lookup *lookup) 1271d1ff7024SMika Westerberg { 1272d1ff7024SMika Westerberg int i; 1273d1ff7024SMika Westerberg 1274d1ff7024SMika Westerberg for (i = 1; i <= sw->config.max_port_number; i++) { 1275d1ff7024SMika Westerberg struct tb_port *port = &sw->ports[i]; 1276d1ff7024SMika Westerberg struct tb_xdomain *xd; 1277d1ff7024SMika Westerberg 1278d1ff7024SMika Westerberg if (tb_is_upstream_port(port)) 1279d1ff7024SMika Westerberg continue; 1280d1ff7024SMika Westerberg 1281d1ff7024SMika Westerberg if (port->xdomain) { 1282d1ff7024SMika Westerberg xd = port->xdomain; 1283d1ff7024SMika Westerberg 1284d1ff7024SMika Westerberg if (lookup->uuid) { 1285d1ff7024SMika Westerberg if (uuid_equal(xd->remote_uuid, lookup->uuid)) 1286d1ff7024SMika Westerberg return xd; 1287d1ff7024SMika Westerberg } else if (lookup->link == xd->link && 1288d1ff7024SMika Westerberg lookup->depth == xd->depth) { 1289d1ff7024SMika Westerberg return xd; 1290d1ff7024SMika Westerberg } 1291d1ff7024SMika Westerberg } else if (port->remote) { 1292d1ff7024SMika Westerberg xd = switch_find_xdomain(port->remote->sw, lookup); 1293d1ff7024SMika Westerberg if (xd) 1294d1ff7024SMika Westerberg return xd; 1295d1ff7024SMika Westerberg } 1296d1ff7024SMika Westerberg } 1297d1ff7024SMika Westerberg 1298d1ff7024SMika Westerberg return NULL; 1299d1ff7024SMika Westerberg } 1300d1ff7024SMika Westerberg 1301d1ff7024SMika Westerberg /** 1302d1ff7024SMika Westerberg * tb_xdomain_find_by_uuid() - Find an XDomain by UUID 1303d1ff7024SMika Westerberg * @tb: Domain where the XDomain belongs to 1304d1ff7024SMika Westerberg * @uuid: UUID to look for 1305d1ff7024SMika Westerberg * 1306d1ff7024SMika Westerberg * Finds XDomain by walking through the Thunderbolt topology below @tb. 1307d1ff7024SMika Westerberg * The returned XDomain will have its reference count increased so the 1308d1ff7024SMika Westerberg * caller needs to call tb_xdomain_put() when it is done with the 1309d1ff7024SMika Westerberg * object. 1310d1ff7024SMika Westerberg * 1311d1ff7024SMika Westerberg * This will find all XDomains including the ones that are not yet added 1312d1ff7024SMika Westerberg * to the bus (handshake is still in progress). 1313d1ff7024SMika Westerberg * 1314d1ff7024SMika Westerberg * The caller needs to hold @tb->lock. 1315d1ff7024SMika Westerberg */ 1316d1ff7024SMika Westerberg struct tb_xdomain *tb_xdomain_find_by_uuid(struct tb *tb, const uuid_t *uuid) 1317d1ff7024SMika Westerberg { 1318d1ff7024SMika Westerberg struct tb_xdomain_lookup lookup; 1319d1ff7024SMika Westerberg struct tb_xdomain *xd; 1320d1ff7024SMika Westerberg 1321d1ff7024SMika Westerberg memset(&lookup, 0, sizeof(lookup)); 1322d1ff7024SMika Westerberg lookup.uuid = uuid; 1323d1ff7024SMika Westerberg 1324d1ff7024SMika Westerberg xd = switch_find_xdomain(tb->root_switch, &lookup); 1325d1ff7024SMika Westerberg if (xd) { 1326d1ff7024SMika Westerberg get_device(&xd->dev); 1327d1ff7024SMika Westerberg return xd; 1328d1ff7024SMika Westerberg } 1329d1ff7024SMika Westerberg 1330d1ff7024SMika Westerberg return NULL; 1331d1ff7024SMika Westerberg } 1332d1ff7024SMika Westerberg EXPORT_SYMBOL_GPL(tb_xdomain_find_by_uuid); 1333d1ff7024SMika Westerberg 1334d1ff7024SMika Westerberg /** 1335d1ff7024SMika Westerberg * tb_xdomain_find_by_link_depth() - Find an XDomain by link and depth 1336d1ff7024SMika Westerberg * @tb: Domain where the XDomain belongs to 1337d1ff7024SMika Westerberg * @link: Root switch link number 1338d1ff7024SMika Westerberg * @depth: Depth in the link 1339d1ff7024SMika Westerberg * 1340d1ff7024SMika Westerberg * Finds XDomain by walking through the Thunderbolt topology below @tb. 1341d1ff7024SMika Westerberg * The returned XDomain will have its reference count increased so the 1342d1ff7024SMika Westerberg * caller needs to call tb_xdomain_put() when it is done with the 1343d1ff7024SMika Westerberg * object. 1344d1ff7024SMika Westerberg * 1345d1ff7024SMika Westerberg * This will find all XDomains including the ones that are not yet added 1346d1ff7024SMika Westerberg * to the bus (handshake is still in progress). 1347d1ff7024SMika Westerberg * 1348d1ff7024SMika Westerberg * The caller needs to hold @tb->lock. 1349d1ff7024SMika Westerberg */ 1350d1ff7024SMika Westerberg struct tb_xdomain *tb_xdomain_find_by_link_depth(struct tb *tb, u8 link, 1351d1ff7024SMika Westerberg u8 depth) 1352d1ff7024SMika Westerberg { 1353d1ff7024SMika Westerberg struct tb_xdomain_lookup lookup; 1354d1ff7024SMika Westerberg struct tb_xdomain *xd; 1355d1ff7024SMika Westerberg 1356d1ff7024SMika Westerberg memset(&lookup, 0, sizeof(lookup)); 1357d1ff7024SMika Westerberg lookup.link = link; 1358d1ff7024SMika Westerberg lookup.depth = depth; 1359d1ff7024SMika Westerberg 1360d1ff7024SMika Westerberg xd = switch_find_xdomain(tb->root_switch, &lookup); 1361d1ff7024SMika Westerberg if (xd) { 1362d1ff7024SMika Westerberg get_device(&xd->dev); 1363d1ff7024SMika Westerberg return xd; 1364d1ff7024SMika Westerberg } 1365d1ff7024SMika Westerberg 1366d1ff7024SMika Westerberg return NULL; 1367d1ff7024SMika Westerberg } 1368d1ff7024SMika Westerberg 1369d1ff7024SMika Westerberg bool tb_xdomain_handle_request(struct tb *tb, enum tb_cfg_pkg_type type, 1370d1ff7024SMika Westerberg const void *buf, size_t size) 1371d1ff7024SMika Westerberg { 1372d1ff7024SMika Westerberg const struct tb_protocol_handler *handler, *tmp; 1373d1ff7024SMika Westerberg const struct tb_xdp_header *hdr = buf; 1374d1ff7024SMika Westerberg unsigned int length; 1375d1ff7024SMika Westerberg int ret = 0; 1376d1ff7024SMika Westerberg 1377d1ff7024SMika Westerberg /* We expect the packet is at least size of the header */ 1378d1ff7024SMika Westerberg length = hdr->xd_hdr.length_sn & TB_XDOMAIN_LENGTH_MASK; 1379d1ff7024SMika Westerberg if (length != size / 4 - sizeof(hdr->xd_hdr) / 4) 1380d1ff7024SMika Westerberg return true; 1381d1ff7024SMika Westerberg if (length < sizeof(*hdr) / 4 - sizeof(hdr->xd_hdr) / 4) 1382d1ff7024SMika Westerberg return true; 1383d1ff7024SMika Westerberg 1384d1ff7024SMika Westerberg /* 1385d1ff7024SMika Westerberg * Handle XDomain discovery protocol packets directly here. For 1386d1ff7024SMika Westerberg * other protocols (based on their UUID) we call registered 1387d1ff7024SMika Westerberg * handlers in turn. 1388d1ff7024SMika Westerberg */ 1389d1ff7024SMika Westerberg if (uuid_equal(&hdr->uuid, &tb_xdp_uuid)) { 1390d1ff7024SMika Westerberg if (type == TB_CFG_PKG_XDOMAIN_REQ) { 1391d1ff7024SMika Westerberg tb_xdp_schedule_request(tb, hdr, size); 1392d1ff7024SMika Westerberg return true; 1393d1ff7024SMika Westerberg } 1394d1ff7024SMika Westerberg return false; 1395d1ff7024SMika Westerberg } 1396d1ff7024SMika Westerberg 1397d1ff7024SMika Westerberg mutex_lock(&xdomain_lock); 1398d1ff7024SMika Westerberg list_for_each_entry_safe(handler, tmp, &protocol_handlers, list) { 1399d1ff7024SMika Westerberg if (!uuid_equal(&hdr->uuid, handler->uuid)) 1400d1ff7024SMika Westerberg continue; 1401d1ff7024SMika Westerberg 1402d1ff7024SMika Westerberg mutex_unlock(&xdomain_lock); 1403d1ff7024SMika Westerberg ret = handler->callback(buf, size, handler->data); 1404d1ff7024SMika Westerberg mutex_lock(&xdomain_lock); 1405d1ff7024SMika Westerberg 1406d1ff7024SMika Westerberg if (ret) 1407d1ff7024SMika Westerberg break; 1408d1ff7024SMika Westerberg } 1409d1ff7024SMika Westerberg mutex_unlock(&xdomain_lock); 1410d1ff7024SMika Westerberg 1411d1ff7024SMika Westerberg return ret > 0; 1412d1ff7024SMika Westerberg } 1413d1ff7024SMika Westerberg 1414d1ff7024SMika Westerberg static int rebuild_property_block(void) 1415d1ff7024SMika Westerberg { 1416d1ff7024SMika Westerberg u32 *block, len; 1417d1ff7024SMika Westerberg int ret; 1418d1ff7024SMika Westerberg 1419d1ff7024SMika Westerberg ret = tb_property_format_dir(xdomain_property_dir, NULL, 0); 1420d1ff7024SMika Westerberg if (ret < 0) 1421d1ff7024SMika Westerberg return ret; 1422d1ff7024SMika Westerberg 1423d1ff7024SMika Westerberg len = ret; 1424d1ff7024SMika Westerberg 1425d1ff7024SMika Westerberg block = kcalloc(len, sizeof(u32), GFP_KERNEL); 1426d1ff7024SMika Westerberg if (!block) 1427d1ff7024SMika Westerberg return -ENOMEM; 1428d1ff7024SMika Westerberg 1429d1ff7024SMika Westerberg ret = tb_property_format_dir(xdomain_property_dir, block, len); 1430d1ff7024SMika Westerberg if (ret) { 1431d1ff7024SMika Westerberg kfree(block); 1432d1ff7024SMika Westerberg return ret; 1433d1ff7024SMika Westerberg } 1434d1ff7024SMika Westerberg 1435d1ff7024SMika Westerberg kfree(xdomain_property_block); 1436d1ff7024SMika Westerberg xdomain_property_block = block; 1437d1ff7024SMika Westerberg xdomain_property_block_len = len; 1438d1ff7024SMika Westerberg xdomain_property_block_gen++; 1439d1ff7024SMika Westerberg 1440d1ff7024SMika Westerberg return 0; 1441d1ff7024SMika Westerberg } 1442d1ff7024SMika Westerberg 1443d1ff7024SMika Westerberg static int update_xdomain(struct device *dev, void *data) 1444d1ff7024SMika Westerberg { 1445d1ff7024SMika Westerberg struct tb_xdomain *xd; 1446d1ff7024SMika Westerberg 1447d1ff7024SMika Westerberg xd = tb_to_xdomain(dev); 1448d1ff7024SMika Westerberg if (xd) { 1449d1ff7024SMika Westerberg queue_delayed_work(xd->tb->wq, &xd->properties_changed_work, 1450d1ff7024SMika Westerberg msecs_to_jiffies(50)); 1451d1ff7024SMika Westerberg } 1452d1ff7024SMika Westerberg 1453d1ff7024SMika Westerberg return 0; 1454d1ff7024SMika Westerberg } 1455d1ff7024SMika Westerberg 1456d1ff7024SMika Westerberg static void update_all_xdomains(void) 1457d1ff7024SMika Westerberg { 1458d1ff7024SMika Westerberg bus_for_each_dev(&tb_bus_type, NULL, NULL, update_xdomain); 1459d1ff7024SMika Westerberg } 1460d1ff7024SMika Westerberg 1461d1ff7024SMika Westerberg static bool remove_directory(const char *key, const struct tb_property_dir *dir) 1462d1ff7024SMika Westerberg { 1463d1ff7024SMika Westerberg struct tb_property *p; 1464d1ff7024SMika Westerberg 1465d1ff7024SMika Westerberg p = tb_property_find(xdomain_property_dir, key, 1466d1ff7024SMika Westerberg TB_PROPERTY_TYPE_DIRECTORY); 1467d1ff7024SMika Westerberg if (p && p->value.dir == dir) { 1468d1ff7024SMika Westerberg tb_property_remove(p); 1469d1ff7024SMika Westerberg return true; 1470d1ff7024SMika Westerberg } 1471d1ff7024SMika Westerberg return false; 1472d1ff7024SMika Westerberg } 1473d1ff7024SMika Westerberg 1474d1ff7024SMika Westerberg /** 1475d1ff7024SMika Westerberg * tb_register_property_dir() - Register property directory to the host 1476d1ff7024SMika Westerberg * @key: Key (name) of the directory to add 1477d1ff7024SMika Westerberg * @dir: Directory to add 1478d1ff7024SMika Westerberg * 1479d1ff7024SMika Westerberg * Service drivers can use this function to add new property directory 1480d1ff7024SMika Westerberg * to the host available properties. The other connected hosts are 1481d1ff7024SMika Westerberg * notified so they can re-read properties of this host if they are 1482d1ff7024SMika Westerberg * interested. 1483d1ff7024SMika Westerberg * 1484d1ff7024SMika Westerberg * Return: %0 on success and negative errno on failure 1485d1ff7024SMika Westerberg */ 1486d1ff7024SMika Westerberg int tb_register_property_dir(const char *key, struct tb_property_dir *dir) 1487d1ff7024SMika Westerberg { 1488d1ff7024SMika Westerberg int ret; 1489d1ff7024SMika Westerberg 1490acb40d84SMika Westerberg if (WARN_ON(!xdomain_property_dir)) 1491acb40d84SMika Westerberg return -EAGAIN; 1492acb40d84SMika Westerberg 1493d1ff7024SMika Westerberg if (!key || strlen(key) > 8) 1494d1ff7024SMika Westerberg return -EINVAL; 1495d1ff7024SMika Westerberg 1496d1ff7024SMika Westerberg mutex_lock(&xdomain_lock); 1497d1ff7024SMika Westerberg if (tb_property_find(xdomain_property_dir, key, 1498d1ff7024SMika Westerberg TB_PROPERTY_TYPE_DIRECTORY)) { 1499d1ff7024SMika Westerberg ret = -EEXIST; 1500d1ff7024SMika Westerberg goto err_unlock; 1501d1ff7024SMika Westerberg } 1502d1ff7024SMika Westerberg 1503d1ff7024SMika Westerberg ret = tb_property_add_dir(xdomain_property_dir, key, dir); 1504d1ff7024SMika Westerberg if (ret) 1505d1ff7024SMika Westerberg goto err_unlock; 1506d1ff7024SMika Westerberg 1507d1ff7024SMika Westerberg ret = rebuild_property_block(); 1508d1ff7024SMika Westerberg if (ret) { 1509d1ff7024SMika Westerberg remove_directory(key, dir); 1510d1ff7024SMika Westerberg goto err_unlock; 1511d1ff7024SMika Westerberg } 1512d1ff7024SMika Westerberg 1513d1ff7024SMika Westerberg mutex_unlock(&xdomain_lock); 1514d1ff7024SMika Westerberg update_all_xdomains(); 1515d1ff7024SMika Westerberg return 0; 1516d1ff7024SMika Westerberg 1517d1ff7024SMika Westerberg err_unlock: 1518d1ff7024SMika Westerberg mutex_unlock(&xdomain_lock); 1519d1ff7024SMika Westerberg return ret; 1520d1ff7024SMika Westerberg } 1521d1ff7024SMika Westerberg EXPORT_SYMBOL_GPL(tb_register_property_dir); 1522d1ff7024SMika Westerberg 1523d1ff7024SMika Westerberg /** 1524d1ff7024SMika Westerberg * tb_unregister_property_dir() - Removes property directory from host 1525d1ff7024SMika Westerberg * @key: Key (name) of the directory 1526d1ff7024SMika Westerberg * @dir: Directory to remove 1527d1ff7024SMika Westerberg * 1528d1ff7024SMika Westerberg * This will remove the existing directory from this host and notify the 1529d1ff7024SMika Westerberg * connected hosts about the change. 1530d1ff7024SMika Westerberg */ 1531d1ff7024SMika Westerberg void tb_unregister_property_dir(const char *key, struct tb_property_dir *dir) 1532d1ff7024SMika Westerberg { 1533d1ff7024SMika Westerberg int ret = 0; 1534d1ff7024SMika Westerberg 1535d1ff7024SMika Westerberg mutex_lock(&xdomain_lock); 1536d1ff7024SMika Westerberg if (remove_directory(key, dir)) 1537d1ff7024SMika Westerberg ret = rebuild_property_block(); 1538d1ff7024SMika Westerberg mutex_unlock(&xdomain_lock); 1539d1ff7024SMika Westerberg 1540d1ff7024SMika Westerberg if (!ret) 1541d1ff7024SMika Westerberg update_all_xdomains(); 1542d1ff7024SMika Westerberg } 1543d1ff7024SMika Westerberg EXPORT_SYMBOL_GPL(tb_unregister_property_dir); 1544d1ff7024SMika Westerberg 1545d1ff7024SMika Westerberg int tb_xdomain_init(void) 1546d1ff7024SMika Westerberg { 1547d1ff7024SMika Westerberg int ret; 1548d1ff7024SMika Westerberg 1549d1ff7024SMika Westerberg xdomain_property_dir = tb_property_create_dir(NULL); 1550d1ff7024SMika Westerberg if (!xdomain_property_dir) 1551d1ff7024SMika Westerberg return -ENOMEM; 1552d1ff7024SMika Westerberg 1553d1ff7024SMika Westerberg /* 1554d1ff7024SMika Westerberg * Initialize standard set of properties without any service 1555d1ff7024SMika Westerberg * directories. Those will be added by service drivers 1556d1ff7024SMika Westerberg * themselves when they are loaded. 1557d1ff7024SMika Westerberg */ 1558d1ff7024SMika Westerberg tb_property_add_immediate(xdomain_property_dir, "vendorid", 1559d1ff7024SMika Westerberg PCI_VENDOR_ID_INTEL); 1560d1ff7024SMika Westerberg tb_property_add_text(xdomain_property_dir, "vendorid", "Intel Corp."); 1561d1ff7024SMika Westerberg tb_property_add_immediate(xdomain_property_dir, "deviceid", 0x1); 1562d1ff7024SMika Westerberg tb_property_add_text(xdomain_property_dir, "deviceid", 1563d1ff7024SMika Westerberg utsname()->nodename); 1564d1ff7024SMika Westerberg tb_property_add_immediate(xdomain_property_dir, "devicerv", 0x80000100); 1565d1ff7024SMika Westerberg 1566d1ff7024SMika Westerberg ret = rebuild_property_block(); 1567d1ff7024SMika Westerberg if (ret) { 1568d1ff7024SMika Westerberg tb_property_free_dir(xdomain_property_dir); 1569d1ff7024SMika Westerberg xdomain_property_dir = NULL; 1570d1ff7024SMika Westerberg } 1571d1ff7024SMika Westerberg 1572d1ff7024SMika Westerberg return ret; 1573d1ff7024SMika Westerberg } 1574d1ff7024SMika Westerberg 1575d1ff7024SMika Westerberg void tb_xdomain_exit(void) 1576d1ff7024SMika Westerberg { 1577d1ff7024SMika Westerberg kfree(xdomain_property_block); 1578d1ff7024SMika Westerberg tb_property_free_dir(xdomain_property_dir); 1579d1ff7024SMika Westerberg } 1580