Loading...
1// SPDX-License-Identifier: GPL-2.0
2/*
3 * Intel(R) Trace Hub driver core
4 *
5 * Copyright (C) 2014-2015 Intel Corporation.
6 */
7
8#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
9
10#include <linux/types.h>
11#include <linux/module.h>
12#include <linux/device.h>
13#include <linux/sysfs.h>
14#include <linux/kdev_t.h>
15#include <linux/debugfs.h>
16#include <linux/idr.h>
17#include <linux/pci.h>
18#include <linux/pm_runtime.h>
19#include <linux/dma-mapping.h>
20
21#include "intel_th.h"
22#include "debug.h"
23
24static bool host_mode __read_mostly;
25module_param(host_mode, bool, 0444);
26
27static DEFINE_IDA(intel_th_ida);
28
29static int intel_th_match(struct device *dev, struct device_driver *driver)
30{
31 struct intel_th_driver *thdrv = to_intel_th_driver(driver);
32 struct intel_th_device *thdev = to_intel_th_device(dev);
33
34 if (thdev->type == INTEL_TH_SWITCH &&
35 (!thdrv->enable || !thdrv->disable))
36 return 0;
37
38 return !strcmp(thdev->name, driver->name);
39}
40
41static int intel_th_child_remove(struct device *dev, void *data)
42{
43 device_release_driver(dev);
44
45 return 0;
46}
47
48static int intel_th_probe(struct device *dev)
49{
50 struct intel_th_driver *thdrv = to_intel_th_driver(dev->driver);
51 struct intel_th_device *thdev = to_intel_th_device(dev);
52 struct intel_th_driver *hubdrv;
53 struct intel_th_device *hub = NULL;
54 int ret;
55
56 if (thdev->type == INTEL_TH_SWITCH)
57 hub = thdev;
58 else if (dev->parent)
59 hub = to_intel_th_device(dev->parent);
60
61 if (!hub || !hub->dev.driver)
62 return -EPROBE_DEFER;
63
64 hubdrv = to_intel_th_driver(hub->dev.driver);
65
66 pm_runtime_set_active(dev);
67 pm_runtime_no_callbacks(dev);
68 pm_runtime_enable(dev);
69
70 ret = thdrv->probe(to_intel_th_device(dev));
71 if (ret)
72 goto out_pm;
73
74 if (thdrv->attr_group) {
75 ret = sysfs_create_group(&thdev->dev.kobj, thdrv->attr_group);
76 if (ret)
77 goto out;
78 }
79
80 if (thdev->type == INTEL_TH_OUTPUT &&
81 !intel_th_output_assigned(thdev))
82 /* does not talk to hardware */
83 ret = hubdrv->assign(hub, thdev);
84
85out:
86 if (ret)
87 thdrv->remove(thdev);
88
89out_pm:
90 if (ret)
91 pm_runtime_disable(dev);
92
93 return ret;
94}
95
96static void intel_th_device_remove(struct intel_th_device *thdev);
97
98static int intel_th_remove(struct device *dev)
99{
100 struct intel_th_driver *thdrv = to_intel_th_driver(dev->driver);
101 struct intel_th_device *thdev = to_intel_th_device(dev);
102 struct intel_th_device *hub = to_intel_th_hub(thdev);
103 int err;
104
105 if (thdev->type == INTEL_TH_SWITCH) {
106 struct intel_th *th = to_intel_th(hub);
107 int i, lowest;
108
109 /* disconnect outputs */
110 err = device_for_each_child(dev, thdev, intel_th_child_remove);
111 if (err)
112 return err;
113
114 /*
115 * Remove outputs, that is, hub's children: they are created
116 * at hub's probe time by having the hub call
117 * intel_th_output_enable() for each of them.
118 */
119 for (i = 0, lowest = -1; i < th->num_thdevs; i++) {
120 /*
121 * Move the non-output devices from higher up the
122 * th->thdev[] array to lower positions to maintain
123 * a contiguous array.
124 */
125 if (th->thdev[i]->type != INTEL_TH_OUTPUT) {
126 if (lowest >= 0) {
127 th->thdev[lowest] = th->thdev[i];
128 th->thdev[i] = NULL;
129 ++lowest;
130 }
131
132 continue;
133 }
134
135 if (lowest == -1)
136 lowest = i;
137
138 intel_th_device_remove(th->thdev[i]);
139 th->thdev[i] = NULL;
140 }
141
142 if (lowest >= 0)
143 th->num_thdevs = lowest;
144 }
145
146 if (thdrv->attr_group)
147 sysfs_remove_group(&thdev->dev.kobj, thdrv->attr_group);
148
149 pm_runtime_get_sync(dev);
150
151 thdrv->remove(thdev);
152
153 if (intel_th_output_assigned(thdev)) {
154 struct intel_th_driver *hubdrv =
155 to_intel_th_driver(dev->parent->driver);
156
157 if (hub->dev.driver)
158 /* does not talk to hardware */
159 hubdrv->unassign(hub, thdev);
160 }
161
162 pm_runtime_disable(dev);
163 pm_runtime_set_active(dev);
164 pm_runtime_enable(dev);
165
166 return 0;
167}
168
169static struct bus_type intel_th_bus = {
170 .name = "intel_th",
171 .match = intel_th_match,
172 .probe = intel_th_probe,
173 .remove = intel_th_remove,
174};
175
176static void intel_th_device_free(struct intel_th_device *thdev);
177
178static void intel_th_device_release(struct device *dev)
179{
180 intel_th_device_free(to_intel_th_device(dev));
181}
182
183static struct device_type intel_th_source_device_type = {
184 .name = "intel_th_source_device",
185 .release = intel_th_device_release,
186};
187
188static char *intel_th_output_devnode(struct device *dev, umode_t *mode,
189 kuid_t *uid, kgid_t *gid)
190{
191 struct intel_th_device *thdev = to_intel_th_device(dev);
192 struct intel_th *th = to_intel_th(thdev);
193 char *node;
194
195 if (thdev->id >= 0)
196 node = kasprintf(GFP_KERNEL, "intel_th%d/%s%d", th->id,
197 thdev->name, thdev->id);
198 else
199 node = kasprintf(GFP_KERNEL, "intel_th%d/%s", th->id,
200 thdev->name);
201
202 return node;
203}
204
205static ssize_t port_show(struct device *dev, struct device_attribute *attr,
206 char *buf)
207{
208 struct intel_th_device *thdev = to_intel_th_device(dev);
209
210 if (thdev->output.port >= 0)
211 return scnprintf(buf, PAGE_SIZE, "%u\n", thdev->output.port);
212
213 return scnprintf(buf, PAGE_SIZE, "unassigned\n");
214}
215
216static DEVICE_ATTR_RO(port);
217
218static int intel_th_output_activate(struct intel_th_device *thdev)
219{
220 struct intel_th_driver *thdrv =
221 to_intel_th_driver_or_null(thdev->dev.driver);
222 struct intel_th *th = to_intel_th(thdev);
223 int ret = 0;
224
225 if (!thdrv)
226 return -ENODEV;
227
228 if (!try_module_get(thdrv->driver.owner))
229 return -ENODEV;
230
231 pm_runtime_get_sync(&thdev->dev);
232
233 if (th->activate)
234 ret = th->activate(th);
235 if (ret)
236 goto fail_put;
237
238 if (thdrv->activate)
239 ret = thdrv->activate(thdev);
240 else
241 intel_th_trace_enable(thdev);
242
243 if (ret)
244 goto fail_deactivate;
245
246 return 0;
247
248fail_deactivate:
249 if (th->deactivate)
250 th->deactivate(th);
251
252fail_put:
253 pm_runtime_put(&thdev->dev);
254 module_put(thdrv->driver.owner);
255
256 return ret;
257}
258
259static void intel_th_output_deactivate(struct intel_th_device *thdev)
260{
261 struct intel_th_driver *thdrv =
262 to_intel_th_driver_or_null(thdev->dev.driver);
263 struct intel_th *th = to_intel_th(thdev);
264
265 if (!thdrv)
266 return;
267
268 if (thdrv->deactivate)
269 thdrv->deactivate(thdev);
270 else
271 intel_th_trace_disable(thdev);
272
273 if (th->deactivate)
274 th->deactivate(th);
275
276 pm_runtime_put(&thdev->dev);
277 module_put(thdrv->driver.owner);
278}
279
280static ssize_t active_show(struct device *dev, struct device_attribute *attr,
281 char *buf)
282{
283 struct intel_th_device *thdev = to_intel_th_device(dev);
284
285 return scnprintf(buf, PAGE_SIZE, "%d\n", thdev->output.active);
286}
287
288static ssize_t active_store(struct device *dev, struct device_attribute *attr,
289 const char *buf, size_t size)
290{
291 struct intel_th_device *thdev = to_intel_th_device(dev);
292 unsigned long val;
293 int ret;
294
295 ret = kstrtoul(buf, 10, &val);
296 if (ret)
297 return ret;
298
299 if (!!val != thdev->output.active) {
300 if (val)
301 ret = intel_th_output_activate(thdev);
302 else
303 intel_th_output_deactivate(thdev);
304 }
305
306 return ret ? ret : size;
307}
308
309static DEVICE_ATTR_RW(active);
310
311static struct attribute *intel_th_output_attrs[] = {
312 &dev_attr_port.attr,
313 &dev_attr_active.attr,
314 NULL,
315};
316
317ATTRIBUTE_GROUPS(intel_th_output);
318
319static struct device_type intel_th_output_device_type = {
320 .name = "intel_th_output_device",
321 .groups = intel_th_output_groups,
322 .release = intel_th_device_release,
323 .devnode = intel_th_output_devnode,
324};
325
326static struct device_type intel_th_switch_device_type = {
327 .name = "intel_th_switch_device",
328 .release = intel_th_device_release,
329};
330
331static struct device_type *intel_th_device_type[] = {
332 [INTEL_TH_SOURCE] = &intel_th_source_device_type,
333 [INTEL_TH_OUTPUT] = &intel_th_output_device_type,
334 [INTEL_TH_SWITCH] = &intel_th_switch_device_type,
335};
336
337int intel_th_driver_register(struct intel_th_driver *thdrv)
338{
339 if (!thdrv->probe || !thdrv->remove)
340 return -EINVAL;
341
342 thdrv->driver.bus = &intel_th_bus;
343
344 return driver_register(&thdrv->driver);
345}
346EXPORT_SYMBOL_GPL(intel_th_driver_register);
347
348void intel_th_driver_unregister(struct intel_th_driver *thdrv)
349{
350 driver_unregister(&thdrv->driver);
351}
352EXPORT_SYMBOL_GPL(intel_th_driver_unregister);
353
354static struct intel_th_device *
355intel_th_device_alloc(struct intel_th *th, unsigned int type, const char *name,
356 int id)
357{
358 struct device *parent;
359 struct intel_th_device *thdev;
360
361 if (type == INTEL_TH_OUTPUT)
362 parent = &th->hub->dev;
363 else
364 parent = th->dev;
365
366 thdev = kzalloc(sizeof(*thdev) + strlen(name) + 1, GFP_KERNEL);
367 if (!thdev)
368 return NULL;
369
370 thdev->id = id;
371 thdev->type = type;
372
373 strcpy(thdev->name, name);
374 device_initialize(&thdev->dev);
375 thdev->dev.bus = &intel_th_bus;
376 thdev->dev.type = intel_th_device_type[type];
377 thdev->dev.parent = parent;
378 thdev->dev.dma_mask = parent->dma_mask;
379 thdev->dev.dma_parms = parent->dma_parms;
380 dma_set_coherent_mask(&thdev->dev, parent->coherent_dma_mask);
381 if (id >= 0)
382 dev_set_name(&thdev->dev, "%d-%s%d", th->id, name, id);
383 else
384 dev_set_name(&thdev->dev, "%d-%s", th->id, name);
385
386 return thdev;
387}
388
389static int intel_th_device_add_resources(struct intel_th_device *thdev,
390 struct resource *res, int nres)
391{
392 struct resource *r;
393
394 r = kmemdup(res, sizeof(*res) * nres, GFP_KERNEL);
395 if (!r)
396 return -ENOMEM;
397
398 thdev->resource = r;
399 thdev->num_resources = nres;
400
401 return 0;
402}
403
404static void intel_th_device_remove(struct intel_th_device *thdev)
405{
406 device_del(&thdev->dev);
407 put_device(&thdev->dev);
408}
409
410static void intel_th_device_free(struct intel_th_device *thdev)
411{
412 kfree(thdev->resource);
413 kfree(thdev);
414}
415
416/*
417 * Intel(R) Trace Hub subdevices
418 */
419static const struct intel_th_subdevice {
420 const char *name;
421 struct resource res[3];
422 unsigned nres;
423 unsigned type;
424 unsigned otype;
425 bool mknode;
426 unsigned scrpd;
427 int id;
428} intel_th_subdevices[] = {
429 {
430 .nres = 1,
431 .res = {
432 {
433 /* Handle TSCU and CTS from GTH driver */
434 .start = REG_GTH_OFFSET,
435 .end = REG_CTS_OFFSET + REG_CTS_LENGTH - 1,
436 .flags = IORESOURCE_MEM,
437 },
438 },
439 .name = "gth",
440 .type = INTEL_TH_SWITCH,
441 .id = -1,
442 },
443 {
444 .nres = 2,
445 .res = {
446 {
447 .start = REG_MSU_OFFSET,
448 .end = REG_MSU_OFFSET + REG_MSU_LENGTH - 1,
449 .flags = IORESOURCE_MEM,
450 },
451 {
452 .start = BUF_MSU_OFFSET,
453 .end = BUF_MSU_OFFSET + BUF_MSU_LENGTH - 1,
454 .flags = IORESOURCE_MEM,
455 },
456 },
457 .name = "msc",
458 .id = 0,
459 .type = INTEL_TH_OUTPUT,
460 .mknode = true,
461 .otype = GTH_MSU,
462 .scrpd = SCRPD_MEM_IS_PRIM_DEST | SCRPD_MSC0_IS_ENABLED,
463 },
464 {
465 .nres = 2,
466 .res = {
467 {
468 .start = REG_MSU_OFFSET,
469 .end = REG_MSU_OFFSET + REG_MSU_LENGTH - 1,
470 .flags = IORESOURCE_MEM,
471 },
472 {
473 .start = BUF_MSU_OFFSET,
474 .end = BUF_MSU_OFFSET + BUF_MSU_LENGTH - 1,
475 .flags = IORESOURCE_MEM,
476 },
477 },
478 .name = "msc",
479 .id = 1,
480 .type = INTEL_TH_OUTPUT,
481 .mknode = true,
482 .otype = GTH_MSU,
483 .scrpd = SCRPD_MEM_IS_PRIM_DEST | SCRPD_MSC1_IS_ENABLED,
484 },
485 {
486 .nres = 2,
487 .res = {
488 {
489 .start = REG_STH_OFFSET,
490 .end = REG_STH_OFFSET + REG_STH_LENGTH - 1,
491 .flags = IORESOURCE_MEM,
492 },
493 {
494 .start = TH_MMIO_SW,
495 .end = 0,
496 .flags = IORESOURCE_MEM,
497 },
498 },
499 .id = -1,
500 .name = "sth",
501 .type = INTEL_TH_SOURCE,
502 },
503 {
504 .nres = 2,
505 .res = {
506 {
507 .start = REG_STH_OFFSET,
508 .end = REG_STH_OFFSET + REG_STH_LENGTH - 1,
509 .flags = IORESOURCE_MEM,
510 },
511 {
512 .start = TH_MMIO_RTIT,
513 .end = 0,
514 .flags = IORESOURCE_MEM,
515 },
516 },
517 .id = -1,
518 .name = "rtit",
519 .type = INTEL_TH_SOURCE,
520 },
521 {
522 .nres = 1,
523 .res = {
524 {
525 .start = REG_PTI_OFFSET,
526 .end = REG_PTI_OFFSET + REG_PTI_LENGTH - 1,
527 .flags = IORESOURCE_MEM,
528 },
529 },
530 .id = -1,
531 .name = "pti",
532 .type = INTEL_TH_OUTPUT,
533 .otype = GTH_PTI,
534 .scrpd = SCRPD_PTI_IS_PRIM_DEST,
535 },
536 {
537 .nres = 1,
538 .res = {
539 {
540 .start = REG_PTI_OFFSET,
541 .end = REG_PTI_OFFSET + REG_PTI_LENGTH - 1,
542 .flags = IORESOURCE_MEM,
543 },
544 },
545 .id = -1,
546 .name = "lpp",
547 .type = INTEL_TH_OUTPUT,
548 .otype = GTH_LPP,
549 .scrpd = SCRPD_PTI_IS_PRIM_DEST,
550 },
551 {
552 .nres = 1,
553 .res = {
554 {
555 .start = REG_DCIH_OFFSET,
556 .end = REG_DCIH_OFFSET + REG_DCIH_LENGTH - 1,
557 .flags = IORESOURCE_MEM,
558 },
559 },
560 .id = -1,
561 .name = "dcih",
562 .type = INTEL_TH_OUTPUT,
563 },
564};
565
566#ifdef CONFIG_MODULES
567static void __intel_th_request_hub_module(struct work_struct *work)
568{
569 struct intel_th *th = container_of(work, struct intel_th,
570 request_module_work);
571
572 request_module("intel_th_%s", th->hub->name);
573}
574
575static int intel_th_request_hub_module(struct intel_th *th)
576{
577 INIT_WORK(&th->request_module_work, __intel_th_request_hub_module);
578 schedule_work(&th->request_module_work);
579
580 return 0;
581}
582
583static void intel_th_request_hub_module_flush(struct intel_th *th)
584{
585 flush_work(&th->request_module_work);
586}
587#else
588static inline int intel_th_request_hub_module(struct intel_th *th)
589{
590 return -EINVAL;
591}
592
593static inline void intel_th_request_hub_module_flush(struct intel_th *th)
594{
595}
596#endif /* CONFIG_MODULES */
597
598static struct intel_th_device *
599intel_th_subdevice_alloc(struct intel_th *th,
600 const struct intel_th_subdevice *subdev)
601{
602 struct intel_th_device *thdev;
603 struct resource res[3];
604 unsigned int req = 0;
605 int r, err;
606
607 thdev = intel_th_device_alloc(th, subdev->type, subdev->name,
608 subdev->id);
609 if (!thdev)
610 return ERR_PTR(-ENOMEM);
611
612 thdev->drvdata = th->drvdata;
613
614 memcpy(res, subdev->res,
615 sizeof(struct resource) * subdev->nres);
616
617 for (r = 0; r < subdev->nres; r++) {
618 struct resource *devres = th->resource;
619 int bar = TH_MMIO_CONFIG;
620
621 /*
622 * Take .end == 0 to mean 'take the whole bar',
623 * .start then tells us which bar it is. Default to
624 * TH_MMIO_CONFIG.
625 */
626 if (!res[r].end && res[r].flags == IORESOURCE_MEM) {
627 bar = res[r].start;
628 err = -ENODEV;
629 if (bar >= th->num_resources)
630 goto fail_put_device;
631 res[r].start = 0;
632 res[r].end = resource_size(&devres[bar]) - 1;
633 }
634
635 if (res[r].flags & IORESOURCE_MEM) {
636 res[r].start += devres[bar].start;
637 res[r].end += devres[bar].start;
638
639 dev_dbg(th->dev, "%s:%d @ %pR\n",
640 subdev->name, r, &res[r]);
641 } else if (res[r].flags & IORESOURCE_IRQ) {
642 /*
643 * Only pass on the IRQ if we have useful interrupts:
644 * the ones that can be configured via MINTCTL.
645 */
646 if (INTEL_TH_CAP(th, has_mintctl) && th->irq != -1)
647 res[r].start = th->irq;
648 }
649 }
650
651 err = intel_th_device_add_resources(thdev, res, subdev->nres);
652 if (err)
653 goto fail_put_device;
654
655 if (subdev->type == INTEL_TH_OUTPUT) {
656 if (subdev->mknode)
657 thdev->dev.devt = MKDEV(th->major, th->num_thdevs);
658 thdev->output.type = subdev->otype;
659 thdev->output.port = -1;
660 thdev->output.scratchpad = subdev->scrpd;
661 } else if (subdev->type == INTEL_TH_SWITCH) {
662 thdev->host_mode =
663 INTEL_TH_CAP(th, host_mode_only) ? true : host_mode;
664 th->hub = thdev;
665 }
666
667 err = device_add(&thdev->dev);
668 if (err)
669 goto fail_free_res;
670
671 /* need switch driver to be loaded to enumerate the rest */
672 if (subdev->type == INTEL_TH_SWITCH && !req) {
673 err = intel_th_request_hub_module(th);
674 if (!err)
675 req++;
676 }
677
678 return thdev;
679
680fail_free_res:
681 kfree(thdev->resource);
682
683fail_put_device:
684 put_device(&thdev->dev);
685
686 return ERR_PTR(err);
687}
688
689/**
690 * intel_th_output_enable() - find and enable a device for a given output type
691 * @th: Intel TH instance
692 * @otype: output type
693 *
694 * Go through the unallocated output devices, find the first one whos type
695 * matches @otype and instantiate it. These devices are removed when the hub
696 * device is removed, see intel_th_remove().
697 */
698int intel_th_output_enable(struct intel_th *th, unsigned int otype)
699{
700 struct intel_th_device *thdev;
701 int src = 0, dst = 0;
702
703 for (src = 0, dst = 0; dst <= th->num_thdevs; src++, dst++) {
704 for (; src < ARRAY_SIZE(intel_th_subdevices); src++) {
705 if (intel_th_subdevices[src].type != INTEL_TH_OUTPUT)
706 continue;
707
708 if (intel_th_subdevices[src].otype != otype)
709 continue;
710
711 break;
712 }
713
714 /* no unallocated matching subdevices */
715 if (src == ARRAY_SIZE(intel_th_subdevices))
716 return -ENODEV;
717
718 for (; dst < th->num_thdevs; dst++) {
719 if (th->thdev[dst]->type != INTEL_TH_OUTPUT)
720 continue;
721
722 if (th->thdev[dst]->output.type != otype)
723 continue;
724
725 break;
726 }
727
728 /*
729 * intel_th_subdevices[src] matches our requirements and is
730 * not matched in th::thdev[]
731 */
732 if (dst == th->num_thdevs)
733 goto found;
734 }
735
736 return -ENODEV;
737
738found:
739 thdev = intel_th_subdevice_alloc(th, &intel_th_subdevices[src]);
740 if (IS_ERR(thdev))
741 return PTR_ERR(thdev);
742
743 th->thdev[th->num_thdevs++] = thdev;
744
745 return 0;
746}
747EXPORT_SYMBOL_GPL(intel_th_output_enable);
748
749static int intel_th_populate(struct intel_th *th)
750{
751 int src;
752
753 /* create devices for each intel_th_subdevice */
754 for (src = 0; src < ARRAY_SIZE(intel_th_subdevices); src++) {
755 const struct intel_th_subdevice *subdev =
756 &intel_th_subdevices[src];
757 struct intel_th_device *thdev;
758
759 /* only allow SOURCE and SWITCH devices in host mode */
760 if ((INTEL_TH_CAP(th, host_mode_only) || host_mode) &&
761 subdev->type == INTEL_TH_OUTPUT)
762 continue;
763
764 /*
765 * don't enable port OUTPUTs in this path; SWITCH enables them
766 * via intel_th_output_enable()
767 */
768 if (subdev->type == INTEL_TH_OUTPUT &&
769 subdev->otype != GTH_NONE)
770 continue;
771
772 thdev = intel_th_subdevice_alloc(th, subdev);
773 /* note: caller should free subdevices from th::thdev[] */
774 if (IS_ERR(thdev)) {
775 /* ENODEV for individual subdevices is allowed */
776 if (PTR_ERR(thdev) == -ENODEV)
777 continue;
778
779 return PTR_ERR(thdev);
780 }
781
782 th->thdev[th->num_thdevs++] = thdev;
783 }
784
785 return 0;
786}
787
788static int intel_th_output_open(struct inode *inode, struct file *file)
789{
790 const struct file_operations *fops;
791 struct intel_th_driver *thdrv;
792 struct device *dev;
793 int err;
794
795 dev = bus_find_device_by_devt(&intel_th_bus, inode->i_rdev);
796 if (!dev || !dev->driver)
797 return -ENODEV;
798
799 thdrv = to_intel_th_driver(dev->driver);
800 fops = fops_get(thdrv->fops);
801 if (!fops)
802 return -ENODEV;
803
804 replace_fops(file, fops);
805
806 file->private_data = to_intel_th_device(dev);
807
808 if (file->f_op->open) {
809 err = file->f_op->open(inode, file);
810 return err;
811 }
812
813 return 0;
814}
815
816static const struct file_operations intel_th_output_fops = {
817 .open = intel_th_output_open,
818 .llseek = noop_llseek,
819};
820
821static irqreturn_t intel_th_irq(int irq, void *data)
822{
823 struct intel_th *th = data;
824 irqreturn_t ret = IRQ_NONE;
825 struct intel_th_driver *d;
826 int i;
827
828 for (i = 0; i < th->num_thdevs; i++) {
829 if (th->thdev[i]->type != INTEL_TH_OUTPUT)
830 continue;
831
832 d = to_intel_th_driver(th->thdev[i]->dev.driver);
833 if (d && d->irq)
834 ret |= d->irq(th->thdev[i]);
835 }
836
837 return ret;
838}
839
840/**
841 * intel_th_alloc() - allocate a new Intel TH device and its subdevices
842 * @dev: parent device
843 * @devres: resources indexed by th_mmio_idx
844 * @irq: irq number
845 */
846struct intel_th *
847intel_th_alloc(struct device *dev, struct intel_th_drvdata *drvdata,
848 struct resource *devres, unsigned int ndevres)
849{
850 int err, r, nr_mmios = 0;
851 struct intel_th *th;
852
853 th = kzalloc(sizeof(*th), GFP_KERNEL);
854 if (!th)
855 return ERR_PTR(-ENOMEM);
856
857 th->id = ida_simple_get(&intel_th_ida, 0, 0, GFP_KERNEL);
858 if (th->id < 0) {
859 err = th->id;
860 goto err_alloc;
861 }
862
863 th->major = __register_chrdev(0, 0, TH_POSSIBLE_OUTPUTS,
864 "intel_th/output", &intel_th_output_fops);
865 if (th->major < 0) {
866 err = th->major;
867 goto err_ida;
868 }
869 th->irq = -1;
870 th->dev = dev;
871 th->drvdata = drvdata;
872
873 for (r = 0; r < ndevres; r++)
874 switch (devres[r].flags & IORESOURCE_TYPE_BITS) {
875 case IORESOURCE_MEM:
876 th->resource[nr_mmios++] = devres[r];
877 break;
878 case IORESOURCE_IRQ:
879 err = devm_request_irq(dev, devres[r].start,
880 intel_th_irq, IRQF_SHARED,
881 dev_name(dev), th);
882 if (err)
883 goto err_chrdev;
884
885 if (th->irq == -1)
886 th->irq = devres[r].start;
887 th->num_irqs++;
888 break;
889 default:
890 dev_warn(dev, "Unknown resource type %lx\n",
891 devres[r].flags);
892 break;
893 }
894
895 th->num_resources = nr_mmios;
896
897 dev_set_drvdata(dev, th);
898
899 pm_runtime_no_callbacks(dev);
900 pm_runtime_put(dev);
901 pm_runtime_allow(dev);
902
903 err = intel_th_populate(th);
904 if (err) {
905 /* free the subdevices and undo everything */
906 intel_th_free(th);
907 return ERR_PTR(err);
908 }
909
910 return th;
911
912err_chrdev:
913 __unregister_chrdev(th->major, 0, TH_POSSIBLE_OUTPUTS,
914 "intel_th/output");
915
916err_ida:
917 ida_simple_remove(&intel_th_ida, th->id);
918
919err_alloc:
920 kfree(th);
921
922 return ERR_PTR(err);
923}
924EXPORT_SYMBOL_GPL(intel_th_alloc);
925
926void intel_th_free(struct intel_th *th)
927{
928 int i;
929
930 intel_th_request_hub_module_flush(th);
931
932 intel_th_device_remove(th->hub);
933 for (i = 0; i < th->num_thdevs; i++) {
934 if (th->thdev[i] != th->hub)
935 intel_th_device_remove(th->thdev[i]);
936 th->thdev[i] = NULL;
937 }
938
939 th->num_thdevs = 0;
940
941 for (i = 0; i < th->num_irqs; i++)
942 devm_free_irq(th->dev, th->irq + i, th);
943
944 pm_runtime_get_sync(th->dev);
945 pm_runtime_forbid(th->dev);
946
947 __unregister_chrdev(th->major, 0, TH_POSSIBLE_OUTPUTS,
948 "intel_th/output");
949
950 ida_simple_remove(&intel_th_ida, th->id);
951
952 kfree(th);
953}
954EXPORT_SYMBOL_GPL(intel_th_free);
955
956/**
957 * intel_th_trace_enable() - enable tracing for an output device
958 * @thdev: output device that requests tracing be enabled
959 */
960int intel_th_trace_enable(struct intel_th_device *thdev)
961{
962 struct intel_th_device *hub = to_intel_th_device(thdev->dev.parent);
963 struct intel_th_driver *hubdrv = to_intel_th_driver(hub->dev.driver);
964
965 if (WARN_ON_ONCE(hub->type != INTEL_TH_SWITCH))
966 return -EINVAL;
967
968 if (WARN_ON_ONCE(thdev->type != INTEL_TH_OUTPUT))
969 return -EINVAL;
970
971 pm_runtime_get_sync(&thdev->dev);
972 hubdrv->enable(hub, &thdev->output);
973
974 return 0;
975}
976EXPORT_SYMBOL_GPL(intel_th_trace_enable);
977
978/**
979 * intel_th_trace_switch() - execute a switch sequence
980 * @thdev: output device that requests tracing switch
981 */
982int intel_th_trace_switch(struct intel_th_device *thdev)
983{
984 struct intel_th_device *hub = to_intel_th_device(thdev->dev.parent);
985 struct intel_th_driver *hubdrv = to_intel_th_driver(hub->dev.driver);
986
987 if (WARN_ON_ONCE(hub->type != INTEL_TH_SWITCH))
988 return -EINVAL;
989
990 if (WARN_ON_ONCE(thdev->type != INTEL_TH_OUTPUT))
991 return -EINVAL;
992
993 hubdrv->trig_switch(hub, &thdev->output);
994
995 return 0;
996}
997EXPORT_SYMBOL_GPL(intel_th_trace_switch);
998
999/**
1000 * intel_th_trace_disable() - disable tracing for an output device
1001 * @thdev: output device that requests tracing be disabled
1002 */
1003int intel_th_trace_disable(struct intel_th_device *thdev)
1004{
1005 struct intel_th_device *hub = to_intel_th_device(thdev->dev.parent);
1006 struct intel_th_driver *hubdrv = to_intel_th_driver(hub->dev.driver);
1007
1008 WARN_ON_ONCE(hub->type != INTEL_TH_SWITCH);
1009 if (WARN_ON_ONCE(thdev->type != INTEL_TH_OUTPUT))
1010 return -EINVAL;
1011
1012 hubdrv->disable(hub, &thdev->output);
1013 pm_runtime_put(&thdev->dev);
1014
1015 return 0;
1016}
1017EXPORT_SYMBOL_GPL(intel_th_trace_disable);
1018
1019int intel_th_set_output(struct intel_th_device *thdev,
1020 unsigned int master)
1021{
1022 struct intel_th_device *hub = to_intel_th_hub(thdev);
1023 struct intel_th_driver *hubdrv = to_intel_th_driver(hub->dev.driver);
1024 int ret;
1025
1026 /* In host mode, this is up to the external debugger, do nothing. */
1027 if (hub->host_mode)
1028 return 0;
1029
1030 /*
1031 * hub is instantiated together with the source device that
1032 * calls here, so guaranteed to be present.
1033 */
1034 hubdrv = to_intel_th_driver(hub->dev.driver);
1035 if (!hubdrv || !try_module_get(hubdrv->driver.owner))
1036 return -EINVAL;
1037
1038 if (!hubdrv->set_output) {
1039 ret = -ENOTSUPP;
1040 goto out;
1041 }
1042
1043 ret = hubdrv->set_output(hub, master);
1044
1045out:
1046 module_put(hubdrv->driver.owner);
1047 return ret;
1048}
1049EXPORT_SYMBOL_GPL(intel_th_set_output);
1050
1051static int __init intel_th_init(void)
1052{
1053 intel_th_debug_init();
1054
1055 return bus_register(&intel_th_bus);
1056}
1057subsys_initcall(intel_th_init);
1058
1059static void __exit intel_th_exit(void)
1060{
1061 intel_th_debug_done();
1062
1063 bus_unregister(&intel_th_bus);
1064}
1065module_exit(intel_th_exit);
1066
1067MODULE_LICENSE("GPL v2");
1068MODULE_DESCRIPTION("Intel(R) Trace Hub controller driver");
1069MODULE_AUTHOR("Alexander Shishkin <alexander.shishkin@linux.intel.com>");
1// SPDX-License-Identifier: GPL-2.0
2/*
3 * Intel(R) Trace Hub driver core
4 *
5 * Copyright (C) 2014-2015 Intel Corporation.
6 */
7
8#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
9
10#include <linux/types.h>
11#include <linux/module.h>
12#include <linux/device.h>
13#include <linux/sysfs.h>
14#include <linux/kdev_t.h>
15#include <linux/debugfs.h>
16#include <linux/idr.h>
17#include <linux/pci.h>
18#include <linux/pm_runtime.h>
19#include <linux/dma-mapping.h>
20
21#include "intel_th.h"
22#include "debug.h"
23
24static bool host_mode __read_mostly;
25module_param(host_mode, bool, 0444);
26
27static DEFINE_IDA(intel_th_ida);
28
29static int intel_th_match(struct device *dev, struct device_driver *driver)
30{
31 struct intel_th_driver *thdrv = to_intel_th_driver(driver);
32 struct intel_th_device *thdev = to_intel_th_device(dev);
33
34 if (thdev->type == INTEL_TH_SWITCH &&
35 (!thdrv->enable || !thdrv->disable))
36 return 0;
37
38 return !strcmp(thdev->name, driver->name);
39}
40
41static int intel_th_child_remove(struct device *dev, void *data)
42{
43 device_release_driver(dev);
44
45 return 0;
46}
47
48static int intel_th_probe(struct device *dev)
49{
50 struct intel_th_driver *thdrv = to_intel_th_driver(dev->driver);
51 struct intel_th_device *thdev = to_intel_th_device(dev);
52 struct intel_th_driver *hubdrv;
53 struct intel_th_device *hub = NULL;
54 int ret;
55
56 if (thdev->type == INTEL_TH_SWITCH)
57 hub = thdev;
58 else if (dev->parent)
59 hub = to_intel_th_device(dev->parent);
60
61 if (!hub || !hub->dev.driver)
62 return -EPROBE_DEFER;
63
64 hubdrv = to_intel_th_driver(hub->dev.driver);
65
66 pm_runtime_set_active(dev);
67 pm_runtime_no_callbacks(dev);
68 pm_runtime_enable(dev);
69
70 ret = thdrv->probe(to_intel_th_device(dev));
71 if (ret)
72 goto out_pm;
73
74 if (thdrv->attr_group) {
75 ret = sysfs_create_group(&thdev->dev.kobj, thdrv->attr_group);
76 if (ret)
77 goto out;
78 }
79
80 if (thdev->type == INTEL_TH_OUTPUT &&
81 !intel_th_output_assigned(thdev))
82 /* does not talk to hardware */
83 ret = hubdrv->assign(hub, thdev);
84
85out:
86 if (ret)
87 thdrv->remove(thdev);
88
89out_pm:
90 if (ret)
91 pm_runtime_disable(dev);
92
93 return ret;
94}
95
96static void intel_th_device_remove(struct intel_th_device *thdev);
97
98static int intel_th_remove(struct device *dev)
99{
100 struct intel_th_driver *thdrv = to_intel_th_driver(dev->driver);
101 struct intel_th_device *thdev = to_intel_th_device(dev);
102 struct intel_th_device *hub = to_intel_th_hub(thdev);
103
104 if (thdev->type == INTEL_TH_SWITCH) {
105 struct intel_th *th = to_intel_th(hub);
106 int i, lowest;
107
108 /*
109 * disconnect outputs
110 *
111 * intel_th_child_remove returns 0 unconditionally, so there is
112 * no need to check the return value of device_for_each_child.
113 */
114 device_for_each_child(dev, thdev, intel_th_child_remove);
115
116 /*
117 * Remove outputs, that is, hub's children: they are created
118 * at hub's probe time by having the hub call
119 * intel_th_output_enable() for each of them.
120 */
121 for (i = 0, lowest = -1; i < th->num_thdevs; i++) {
122 /*
123 * Move the non-output devices from higher up the
124 * th->thdev[] array to lower positions to maintain
125 * a contiguous array.
126 */
127 if (th->thdev[i]->type != INTEL_TH_OUTPUT) {
128 if (lowest >= 0) {
129 th->thdev[lowest] = th->thdev[i];
130 th->thdev[i] = NULL;
131 ++lowest;
132 }
133
134 continue;
135 }
136
137 if (lowest == -1)
138 lowest = i;
139
140 intel_th_device_remove(th->thdev[i]);
141 th->thdev[i] = NULL;
142 }
143
144 if (lowest >= 0)
145 th->num_thdevs = lowest;
146 }
147
148 if (thdrv->attr_group)
149 sysfs_remove_group(&thdev->dev.kobj, thdrv->attr_group);
150
151 pm_runtime_get_sync(dev);
152
153 thdrv->remove(thdev);
154
155 if (intel_th_output_assigned(thdev)) {
156 struct intel_th_driver *hubdrv =
157 to_intel_th_driver(dev->parent->driver);
158
159 if (hub->dev.driver)
160 /* does not talk to hardware */
161 hubdrv->unassign(hub, thdev);
162 }
163
164 pm_runtime_disable(dev);
165 pm_runtime_set_active(dev);
166 pm_runtime_enable(dev);
167
168 return 0;
169}
170
171static struct bus_type intel_th_bus = {
172 .name = "intel_th",
173 .match = intel_th_match,
174 .probe = intel_th_probe,
175 .remove = intel_th_remove,
176};
177
178static void intel_th_device_free(struct intel_th_device *thdev);
179
180static void intel_th_device_release(struct device *dev)
181{
182 intel_th_device_free(to_intel_th_device(dev));
183}
184
185static struct device_type intel_th_source_device_type = {
186 .name = "intel_th_source_device",
187 .release = intel_th_device_release,
188};
189
190static char *intel_th_output_devnode(struct device *dev, umode_t *mode,
191 kuid_t *uid, kgid_t *gid)
192{
193 struct intel_th_device *thdev = to_intel_th_device(dev);
194 struct intel_th *th = to_intel_th(thdev);
195 char *node;
196
197 if (thdev->id >= 0)
198 node = kasprintf(GFP_KERNEL, "intel_th%d/%s%d", th->id,
199 thdev->name, thdev->id);
200 else
201 node = kasprintf(GFP_KERNEL, "intel_th%d/%s", th->id,
202 thdev->name);
203
204 return node;
205}
206
207static ssize_t port_show(struct device *dev, struct device_attribute *attr,
208 char *buf)
209{
210 struct intel_th_device *thdev = to_intel_th_device(dev);
211
212 if (thdev->output.port >= 0)
213 return scnprintf(buf, PAGE_SIZE, "%u\n", thdev->output.port);
214
215 return scnprintf(buf, PAGE_SIZE, "unassigned\n");
216}
217
218static DEVICE_ATTR_RO(port);
219
220static void intel_th_trace_prepare(struct intel_th_device *thdev)
221{
222 struct intel_th_device *hub = to_intel_th_hub(thdev);
223 struct intel_th_driver *hubdrv = to_intel_th_driver(hub->dev.driver);
224
225 if (hub->type != INTEL_TH_SWITCH)
226 return;
227
228 if (thdev->type != INTEL_TH_OUTPUT)
229 return;
230
231 pm_runtime_get_sync(&thdev->dev);
232 hubdrv->prepare(hub, &thdev->output);
233 pm_runtime_put(&thdev->dev);
234}
235
236static int intel_th_output_activate(struct intel_th_device *thdev)
237{
238 struct intel_th_driver *thdrv =
239 to_intel_th_driver_or_null(thdev->dev.driver);
240 struct intel_th *th = to_intel_th(thdev);
241 int ret = 0;
242
243 if (!thdrv)
244 return -ENODEV;
245
246 if (!try_module_get(thdrv->driver.owner))
247 return -ENODEV;
248
249 pm_runtime_get_sync(&thdev->dev);
250
251 if (th->activate)
252 ret = th->activate(th);
253 if (ret)
254 goto fail_put;
255
256 intel_th_trace_prepare(thdev);
257 if (thdrv->activate)
258 ret = thdrv->activate(thdev);
259 else
260 intel_th_trace_enable(thdev);
261
262 if (ret)
263 goto fail_deactivate;
264
265 return 0;
266
267fail_deactivate:
268 if (th->deactivate)
269 th->deactivate(th);
270
271fail_put:
272 pm_runtime_put(&thdev->dev);
273 module_put(thdrv->driver.owner);
274
275 return ret;
276}
277
278static void intel_th_output_deactivate(struct intel_th_device *thdev)
279{
280 struct intel_th_driver *thdrv =
281 to_intel_th_driver_or_null(thdev->dev.driver);
282 struct intel_th *th = to_intel_th(thdev);
283
284 if (!thdrv)
285 return;
286
287 if (thdrv->deactivate)
288 thdrv->deactivate(thdev);
289 else
290 intel_th_trace_disable(thdev);
291
292 if (th->deactivate)
293 th->deactivate(th);
294
295 pm_runtime_put(&thdev->dev);
296 module_put(thdrv->driver.owner);
297}
298
299static ssize_t active_show(struct device *dev, struct device_attribute *attr,
300 char *buf)
301{
302 struct intel_th_device *thdev = to_intel_th_device(dev);
303
304 return scnprintf(buf, PAGE_SIZE, "%d\n", thdev->output.active);
305}
306
307static ssize_t active_store(struct device *dev, struct device_attribute *attr,
308 const char *buf, size_t size)
309{
310 struct intel_th_device *thdev = to_intel_th_device(dev);
311 unsigned long val;
312 int ret;
313
314 ret = kstrtoul(buf, 10, &val);
315 if (ret)
316 return ret;
317
318 if (!!val != thdev->output.active) {
319 if (val)
320 ret = intel_th_output_activate(thdev);
321 else
322 intel_th_output_deactivate(thdev);
323 }
324
325 return ret ? ret : size;
326}
327
328static DEVICE_ATTR_RW(active);
329
330static struct attribute *intel_th_output_attrs[] = {
331 &dev_attr_port.attr,
332 &dev_attr_active.attr,
333 NULL,
334};
335
336ATTRIBUTE_GROUPS(intel_th_output);
337
338static struct device_type intel_th_output_device_type = {
339 .name = "intel_th_output_device",
340 .groups = intel_th_output_groups,
341 .release = intel_th_device_release,
342 .devnode = intel_th_output_devnode,
343};
344
345static struct device_type intel_th_switch_device_type = {
346 .name = "intel_th_switch_device",
347 .release = intel_th_device_release,
348};
349
350static struct device_type *intel_th_device_type[] = {
351 [INTEL_TH_SOURCE] = &intel_th_source_device_type,
352 [INTEL_TH_OUTPUT] = &intel_th_output_device_type,
353 [INTEL_TH_SWITCH] = &intel_th_switch_device_type,
354};
355
356int intel_th_driver_register(struct intel_th_driver *thdrv)
357{
358 if (!thdrv->probe || !thdrv->remove)
359 return -EINVAL;
360
361 thdrv->driver.bus = &intel_th_bus;
362
363 return driver_register(&thdrv->driver);
364}
365EXPORT_SYMBOL_GPL(intel_th_driver_register);
366
367void intel_th_driver_unregister(struct intel_th_driver *thdrv)
368{
369 driver_unregister(&thdrv->driver);
370}
371EXPORT_SYMBOL_GPL(intel_th_driver_unregister);
372
373static struct intel_th_device *
374intel_th_device_alloc(struct intel_th *th, unsigned int type, const char *name,
375 int id)
376{
377 struct device *parent;
378 struct intel_th_device *thdev;
379
380 if (type == INTEL_TH_OUTPUT)
381 parent = &th->hub->dev;
382 else
383 parent = th->dev;
384
385 thdev = kzalloc(sizeof(*thdev) + strlen(name) + 1, GFP_KERNEL);
386 if (!thdev)
387 return NULL;
388
389 thdev->id = id;
390 thdev->type = type;
391
392 strcpy(thdev->name, name);
393 device_initialize(&thdev->dev);
394 thdev->dev.bus = &intel_th_bus;
395 thdev->dev.type = intel_th_device_type[type];
396 thdev->dev.parent = parent;
397 thdev->dev.dma_mask = parent->dma_mask;
398 thdev->dev.dma_parms = parent->dma_parms;
399 dma_set_coherent_mask(&thdev->dev, parent->coherent_dma_mask);
400 if (id >= 0)
401 dev_set_name(&thdev->dev, "%d-%s%d", th->id, name, id);
402 else
403 dev_set_name(&thdev->dev, "%d-%s", th->id, name);
404
405 return thdev;
406}
407
408static int intel_th_device_add_resources(struct intel_th_device *thdev,
409 struct resource *res, int nres)
410{
411 struct resource *r;
412
413 r = kmemdup(res, sizeof(*res) * nres, GFP_KERNEL);
414 if (!r)
415 return -ENOMEM;
416
417 thdev->resource = r;
418 thdev->num_resources = nres;
419
420 return 0;
421}
422
423static void intel_th_device_remove(struct intel_th_device *thdev)
424{
425 device_del(&thdev->dev);
426 put_device(&thdev->dev);
427}
428
429static void intel_th_device_free(struct intel_th_device *thdev)
430{
431 kfree(thdev->resource);
432 kfree(thdev);
433}
434
435/*
436 * Intel(R) Trace Hub subdevices
437 */
438static const struct intel_th_subdevice {
439 const char *name;
440 struct resource res[3];
441 unsigned nres;
442 unsigned type;
443 unsigned otype;
444 bool mknode;
445 unsigned scrpd;
446 int id;
447} intel_th_subdevices[] = {
448 {
449 .nres = 1,
450 .res = {
451 {
452 /* Handle TSCU and CTS from GTH driver */
453 .start = REG_GTH_OFFSET,
454 .end = REG_CTS_OFFSET + REG_CTS_LENGTH - 1,
455 .flags = IORESOURCE_MEM,
456 },
457 },
458 .name = "gth",
459 .type = INTEL_TH_SWITCH,
460 .id = -1,
461 },
462 {
463 .nres = 2,
464 .res = {
465 {
466 .start = REG_MSU_OFFSET,
467 .end = REG_MSU_OFFSET + REG_MSU_LENGTH - 1,
468 .flags = IORESOURCE_MEM,
469 },
470 {
471 .start = BUF_MSU_OFFSET,
472 .end = BUF_MSU_OFFSET + BUF_MSU_LENGTH - 1,
473 .flags = IORESOURCE_MEM,
474 },
475 },
476 .name = "msc",
477 .id = 0,
478 .type = INTEL_TH_OUTPUT,
479 .mknode = true,
480 .otype = GTH_MSU,
481 .scrpd = SCRPD_MEM_IS_PRIM_DEST | SCRPD_MSC0_IS_ENABLED,
482 },
483 {
484 .nres = 2,
485 .res = {
486 {
487 .start = REG_MSU_OFFSET,
488 .end = REG_MSU_OFFSET + REG_MSU_LENGTH - 1,
489 .flags = IORESOURCE_MEM,
490 },
491 {
492 .start = BUF_MSU_OFFSET,
493 .end = BUF_MSU_OFFSET + BUF_MSU_LENGTH - 1,
494 .flags = IORESOURCE_MEM,
495 },
496 },
497 .name = "msc",
498 .id = 1,
499 .type = INTEL_TH_OUTPUT,
500 .mknode = true,
501 .otype = GTH_MSU,
502 .scrpd = SCRPD_MEM_IS_PRIM_DEST | SCRPD_MSC1_IS_ENABLED,
503 },
504 {
505 .nres = 2,
506 .res = {
507 {
508 .start = REG_STH_OFFSET,
509 .end = REG_STH_OFFSET + REG_STH_LENGTH - 1,
510 .flags = IORESOURCE_MEM,
511 },
512 {
513 .start = TH_MMIO_SW,
514 .end = 0,
515 .flags = IORESOURCE_MEM,
516 },
517 },
518 .id = -1,
519 .name = "sth",
520 .type = INTEL_TH_SOURCE,
521 },
522 {
523 .nres = 2,
524 .res = {
525 {
526 .start = REG_STH_OFFSET,
527 .end = REG_STH_OFFSET + REG_STH_LENGTH - 1,
528 .flags = IORESOURCE_MEM,
529 },
530 {
531 .start = TH_MMIO_RTIT,
532 .end = 0,
533 .flags = IORESOURCE_MEM,
534 },
535 },
536 .id = -1,
537 .name = "rtit",
538 .type = INTEL_TH_SOURCE,
539 },
540 {
541 .nres = 1,
542 .res = {
543 {
544 .start = REG_PTI_OFFSET,
545 .end = REG_PTI_OFFSET + REG_PTI_LENGTH - 1,
546 .flags = IORESOURCE_MEM,
547 },
548 },
549 .id = -1,
550 .name = "pti",
551 .type = INTEL_TH_OUTPUT,
552 .otype = GTH_PTI,
553 .scrpd = SCRPD_PTI_IS_PRIM_DEST,
554 },
555 {
556 .nres = 1,
557 .res = {
558 {
559 .start = REG_PTI_OFFSET,
560 .end = REG_PTI_OFFSET + REG_PTI_LENGTH - 1,
561 .flags = IORESOURCE_MEM,
562 },
563 },
564 .id = -1,
565 .name = "lpp",
566 .type = INTEL_TH_OUTPUT,
567 .otype = GTH_LPP,
568 .scrpd = SCRPD_PTI_IS_PRIM_DEST,
569 },
570 {
571 .nres = 1,
572 .res = {
573 {
574 .start = REG_DCIH_OFFSET,
575 .end = REG_DCIH_OFFSET + REG_DCIH_LENGTH - 1,
576 .flags = IORESOURCE_MEM,
577 },
578 },
579 .id = -1,
580 .name = "dcih",
581 .type = INTEL_TH_OUTPUT,
582 },
583};
584
585#ifdef CONFIG_MODULES
586static void __intel_th_request_hub_module(struct work_struct *work)
587{
588 struct intel_th *th = container_of(work, struct intel_th,
589 request_module_work);
590
591 request_module("intel_th_%s", th->hub->name);
592}
593
594static int intel_th_request_hub_module(struct intel_th *th)
595{
596 INIT_WORK(&th->request_module_work, __intel_th_request_hub_module);
597 schedule_work(&th->request_module_work);
598
599 return 0;
600}
601
602static void intel_th_request_hub_module_flush(struct intel_th *th)
603{
604 flush_work(&th->request_module_work);
605}
606#else
607static inline int intel_th_request_hub_module(struct intel_th *th)
608{
609 return -EINVAL;
610}
611
612static inline void intel_th_request_hub_module_flush(struct intel_th *th)
613{
614}
615#endif /* CONFIG_MODULES */
616
617static struct intel_th_device *
618intel_th_subdevice_alloc(struct intel_th *th,
619 const struct intel_th_subdevice *subdev)
620{
621 struct intel_th_device *thdev;
622 struct resource res[3];
623 unsigned int req = 0;
624 int r, err;
625
626 thdev = intel_th_device_alloc(th, subdev->type, subdev->name,
627 subdev->id);
628 if (!thdev)
629 return ERR_PTR(-ENOMEM);
630
631 thdev->drvdata = th->drvdata;
632
633 memcpy(res, subdev->res,
634 sizeof(struct resource) * subdev->nres);
635
636 for (r = 0; r < subdev->nres; r++) {
637 struct resource *devres = th->resource;
638 int bar = TH_MMIO_CONFIG;
639
640 /*
641 * Take .end == 0 to mean 'take the whole bar',
642 * .start then tells us which bar it is. Default to
643 * TH_MMIO_CONFIG.
644 */
645 if (!res[r].end && res[r].flags == IORESOURCE_MEM) {
646 bar = res[r].start;
647 err = -ENODEV;
648 if (bar >= th->num_resources)
649 goto fail_put_device;
650 res[r].start = 0;
651 res[r].end = resource_size(&devres[bar]) - 1;
652 }
653
654 if (res[r].flags & IORESOURCE_MEM) {
655 res[r].start += devres[bar].start;
656 res[r].end += devres[bar].start;
657
658 dev_dbg(th->dev, "%s:%d @ %pR\n",
659 subdev->name, r, &res[r]);
660 } else if (res[r].flags & IORESOURCE_IRQ) {
661 /*
662 * Only pass on the IRQ if we have useful interrupts:
663 * the ones that can be configured via MINTCTL.
664 */
665 if (INTEL_TH_CAP(th, has_mintctl) && th->irq != -1)
666 res[r].start = th->irq;
667 }
668 }
669
670 err = intel_th_device_add_resources(thdev, res, subdev->nres);
671 if (err)
672 goto fail_put_device;
673
674 if (subdev->type == INTEL_TH_OUTPUT) {
675 if (subdev->mknode)
676 thdev->dev.devt = MKDEV(th->major, th->num_thdevs);
677 thdev->output.type = subdev->otype;
678 thdev->output.port = -1;
679 thdev->output.scratchpad = subdev->scrpd;
680 } else if (subdev->type == INTEL_TH_SWITCH) {
681 thdev->host_mode =
682 INTEL_TH_CAP(th, host_mode_only) ? true : host_mode;
683 th->hub = thdev;
684 }
685
686 err = device_add(&thdev->dev);
687 if (err)
688 goto fail_free_res;
689
690 /* need switch driver to be loaded to enumerate the rest */
691 if (subdev->type == INTEL_TH_SWITCH && !req) {
692 err = intel_th_request_hub_module(th);
693 if (!err)
694 req++;
695 }
696
697 return thdev;
698
699fail_free_res:
700 kfree(thdev->resource);
701
702fail_put_device:
703 put_device(&thdev->dev);
704
705 return ERR_PTR(err);
706}
707
708/**
709 * intel_th_output_enable() - find and enable a device for a given output type
710 * @th: Intel TH instance
711 * @otype: output type
712 *
713 * Go through the unallocated output devices, find the first one whos type
714 * matches @otype and instantiate it. These devices are removed when the hub
715 * device is removed, see intel_th_remove().
716 */
717int intel_th_output_enable(struct intel_th *th, unsigned int otype)
718{
719 struct intel_th_device *thdev;
720 int src = 0, dst = 0;
721
722 for (src = 0, dst = 0; dst <= th->num_thdevs; src++, dst++) {
723 for (; src < ARRAY_SIZE(intel_th_subdevices); src++) {
724 if (intel_th_subdevices[src].type != INTEL_TH_OUTPUT)
725 continue;
726
727 if (intel_th_subdevices[src].otype != otype)
728 continue;
729
730 break;
731 }
732
733 /* no unallocated matching subdevices */
734 if (src == ARRAY_SIZE(intel_th_subdevices))
735 return -ENODEV;
736
737 for (; dst < th->num_thdevs; dst++) {
738 if (th->thdev[dst]->type != INTEL_TH_OUTPUT)
739 continue;
740
741 if (th->thdev[dst]->output.type != otype)
742 continue;
743
744 break;
745 }
746
747 /*
748 * intel_th_subdevices[src] matches our requirements and is
749 * not matched in th::thdev[]
750 */
751 if (dst == th->num_thdevs)
752 goto found;
753 }
754
755 return -ENODEV;
756
757found:
758 thdev = intel_th_subdevice_alloc(th, &intel_th_subdevices[src]);
759 if (IS_ERR(thdev))
760 return PTR_ERR(thdev);
761
762 th->thdev[th->num_thdevs++] = thdev;
763
764 return 0;
765}
766EXPORT_SYMBOL_GPL(intel_th_output_enable);
767
768static int intel_th_populate(struct intel_th *th)
769{
770 int src;
771
772 /* create devices for each intel_th_subdevice */
773 for (src = 0; src < ARRAY_SIZE(intel_th_subdevices); src++) {
774 const struct intel_th_subdevice *subdev =
775 &intel_th_subdevices[src];
776 struct intel_th_device *thdev;
777
778 /* only allow SOURCE and SWITCH devices in host mode */
779 if ((INTEL_TH_CAP(th, host_mode_only) || host_mode) &&
780 subdev->type == INTEL_TH_OUTPUT)
781 continue;
782
783 /*
784 * don't enable port OUTPUTs in this path; SWITCH enables them
785 * via intel_th_output_enable()
786 */
787 if (subdev->type == INTEL_TH_OUTPUT &&
788 subdev->otype != GTH_NONE)
789 continue;
790
791 thdev = intel_th_subdevice_alloc(th, subdev);
792 /* note: caller should free subdevices from th::thdev[] */
793 if (IS_ERR(thdev)) {
794 /* ENODEV for individual subdevices is allowed */
795 if (PTR_ERR(thdev) == -ENODEV)
796 continue;
797
798 return PTR_ERR(thdev);
799 }
800
801 th->thdev[th->num_thdevs++] = thdev;
802 }
803
804 return 0;
805}
806
807static int intel_th_output_open(struct inode *inode, struct file *file)
808{
809 const struct file_operations *fops;
810 struct intel_th_driver *thdrv;
811 struct device *dev;
812 int err;
813
814 dev = bus_find_device_by_devt(&intel_th_bus, inode->i_rdev);
815 if (!dev || !dev->driver)
816 return -ENODEV;
817
818 thdrv = to_intel_th_driver(dev->driver);
819 fops = fops_get(thdrv->fops);
820 if (!fops)
821 return -ENODEV;
822
823 replace_fops(file, fops);
824
825 file->private_data = to_intel_th_device(dev);
826
827 if (file->f_op->open) {
828 err = file->f_op->open(inode, file);
829 return err;
830 }
831
832 return 0;
833}
834
835static const struct file_operations intel_th_output_fops = {
836 .open = intel_th_output_open,
837 .llseek = noop_llseek,
838};
839
840static irqreturn_t intel_th_irq(int irq, void *data)
841{
842 struct intel_th *th = data;
843 irqreturn_t ret = IRQ_NONE;
844 struct intel_th_driver *d;
845 int i;
846
847 for (i = 0; i < th->num_thdevs; i++) {
848 if (th->thdev[i]->type != INTEL_TH_OUTPUT)
849 continue;
850
851 d = to_intel_th_driver(th->thdev[i]->dev.driver);
852 if (d && d->irq)
853 ret |= d->irq(th->thdev[i]);
854 }
855
856 return ret;
857}
858
859/**
860 * intel_th_alloc() - allocate a new Intel TH device and its subdevices
861 * @dev: parent device
862 * @devres: resources indexed by th_mmio_idx
863 * @irq: irq number
864 */
865struct intel_th *
866intel_th_alloc(struct device *dev, const struct intel_th_drvdata *drvdata,
867 struct resource *devres, unsigned int ndevres)
868{
869 int err, r, nr_mmios = 0;
870 struct intel_th *th;
871
872 th = kzalloc(sizeof(*th), GFP_KERNEL);
873 if (!th)
874 return ERR_PTR(-ENOMEM);
875
876 th->id = ida_simple_get(&intel_th_ida, 0, 0, GFP_KERNEL);
877 if (th->id < 0) {
878 err = th->id;
879 goto err_alloc;
880 }
881
882 th->major = __register_chrdev(0, 0, TH_POSSIBLE_OUTPUTS,
883 "intel_th/output", &intel_th_output_fops);
884 if (th->major < 0) {
885 err = th->major;
886 goto err_ida;
887 }
888 th->irq = -1;
889 th->dev = dev;
890 th->drvdata = drvdata;
891
892 for (r = 0; r < ndevres; r++)
893 switch (devres[r].flags & IORESOURCE_TYPE_BITS) {
894 case IORESOURCE_MEM:
895 th->resource[nr_mmios++] = devres[r];
896 break;
897 case IORESOURCE_IRQ:
898 err = devm_request_irq(dev, devres[r].start,
899 intel_th_irq, IRQF_SHARED,
900 dev_name(dev), th);
901 if (err)
902 goto err_chrdev;
903
904 if (th->irq == -1)
905 th->irq = devres[r].start;
906 th->num_irqs++;
907 break;
908 default:
909 dev_warn(dev, "Unknown resource type %lx\n",
910 devres[r].flags);
911 break;
912 }
913
914 th->num_resources = nr_mmios;
915
916 dev_set_drvdata(dev, th);
917
918 pm_runtime_no_callbacks(dev);
919 pm_runtime_put(dev);
920 pm_runtime_allow(dev);
921
922 err = intel_th_populate(th);
923 if (err) {
924 /* free the subdevices and undo everything */
925 intel_th_free(th);
926 return ERR_PTR(err);
927 }
928
929 return th;
930
931err_chrdev:
932 __unregister_chrdev(th->major, 0, TH_POSSIBLE_OUTPUTS,
933 "intel_th/output");
934
935err_ida:
936 ida_simple_remove(&intel_th_ida, th->id);
937
938err_alloc:
939 kfree(th);
940
941 return ERR_PTR(err);
942}
943EXPORT_SYMBOL_GPL(intel_th_alloc);
944
945void intel_th_free(struct intel_th *th)
946{
947 int i;
948
949 intel_th_request_hub_module_flush(th);
950
951 intel_th_device_remove(th->hub);
952 for (i = 0; i < th->num_thdevs; i++) {
953 if (th->thdev[i] != th->hub)
954 intel_th_device_remove(th->thdev[i]);
955 th->thdev[i] = NULL;
956 }
957
958 th->num_thdevs = 0;
959
960 for (i = 0; i < th->num_irqs; i++)
961 devm_free_irq(th->dev, th->irq + i, th);
962
963 pm_runtime_get_sync(th->dev);
964 pm_runtime_forbid(th->dev);
965
966 __unregister_chrdev(th->major, 0, TH_POSSIBLE_OUTPUTS,
967 "intel_th/output");
968
969 ida_simple_remove(&intel_th_ida, th->id);
970
971 kfree(th);
972}
973EXPORT_SYMBOL_GPL(intel_th_free);
974
975/**
976 * intel_th_trace_enable() - enable tracing for an output device
977 * @thdev: output device that requests tracing be enabled
978 */
979int intel_th_trace_enable(struct intel_th_device *thdev)
980{
981 struct intel_th_device *hub = to_intel_th_device(thdev->dev.parent);
982 struct intel_th_driver *hubdrv = to_intel_th_driver(hub->dev.driver);
983
984 if (WARN_ON_ONCE(hub->type != INTEL_TH_SWITCH))
985 return -EINVAL;
986
987 if (WARN_ON_ONCE(thdev->type != INTEL_TH_OUTPUT))
988 return -EINVAL;
989
990 pm_runtime_get_sync(&thdev->dev);
991 hubdrv->enable(hub, &thdev->output);
992
993 return 0;
994}
995EXPORT_SYMBOL_GPL(intel_th_trace_enable);
996
997/**
998 * intel_th_trace_switch() - execute a switch sequence
999 * @thdev: output device that requests tracing switch
1000 */
1001int intel_th_trace_switch(struct intel_th_device *thdev)
1002{
1003 struct intel_th_device *hub = to_intel_th_device(thdev->dev.parent);
1004 struct intel_th_driver *hubdrv = to_intel_th_driver(hub->dev.driver);
1005
1006 if (WARN_ON_ONCE(hub->type != INTEL_TH_SWITCH))
1007 return -EINVAL;
1008
1009 if (WARN_ON_ONCE(thdev->type != INTEL_TH_OUTPUT))
1010 return -EINVAL;
1011
1012 hubdrv->trig_switch(hub, &thdev->output);
1013
1014 return 0;
1015}
1016EXPORT_SYMBOL_GPL(intel_th_trace_switch);
1017
1018/**
1019 * intel_th_trace_disable() - disable tracing for an output device
1020 * @thdev: output device that requests tracing be disabled
1021 */
1022int intel_th_trace_disable(struct intel_th_device *thdev)
1023{
1024 struct intel_th_device *hub = to_intel_th_device(thdev->dev.parent);
1025 struct intel_th_driver *hubdrv = to_intel_th_driver(hub->dev.driver);
1026
1027 WARN_ON_ONCE(hub->type != INTEL_TH_SWITCH);
1028 if (WARN_ON_ONCE(thdev->type != INTEL_TH_OUTPUT))
1029 return -EINVAL;
1030
1031 hubdrv->disable(hub, &thdev->output);
1032 pm_runtime_put(&thdev->dev);
1033
1034 return 0;
1035}
1036EXPORT_SYMBOL_GPL(intel_th_trace_disable);
1037
1038int intel_th_set_output(struct intel_th_device *thdev,
1039 unsigned int master)
1040{
1041 struct intel_th_device *hub = to_intel_th_hub(thdev);
1042 struct intel_th_driver *hubdrv = to_intel_th_driver(hub->dev.driver);
1043 int ret;
1044
1045 /* In host mode, this is up to the external debugger, do nothing. */
1046 if (hub->host_mode)
1047 return 0;
1048
1049 /*
1050 * hub is instantiated together with the source device that
1051 * calls here, so guaranteed to be present.
1052 */
1053 hubdrv = to_intel_th_driver(hub->dev.driver);
1054 if (!hubdrv || !try_module_get(hubdrv->driver.owner))
1055 return -EINVAL;
1056
1057 if (!hubdrv->set_output) {
1058 ret = -ENOTSUPP;
1059 goto out;
1060 }
1061
1062 ret = hubdrv->set_output(hub, master);
1063
1064out:
1065 module_put(hubdrv->driver.owner);
1066 return ret;
1067}
1068EXPORT_SYMBOL_GPL(intel_th_set_output);
1069
1070static int __init intel_th_init(void)
1071{
1072 intel_th_debug_init();
1073
1074 return bus_register(&intel_th_bus);
1075}
1076subsys_initcall(intel_th_init);
1077
1078static void __exit intel_th_exit(void)
1079{
1080 intel_th_debug_done();
1081
1082 bus_unregister(&intel_th_bus);
1083}
1084module_exit(intel_th_exit);
1085
1086MODULE_LICENSE("GPL v2");
1087MODULE_DESCRIPTION("Intel(R) Trace Hub controller driver");
1088MODULE_AUTHOR("Alexander Shishkin <alexander.shishkin@linux.intel.com>");