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