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