150352fa7SAlexander Shishkin // SPDX-License-Identifier: GPL-2.0
239f40346SAlexander Shishkin /*
339f40346SAlexander Shishkin * Intel(R) Trace Hub driver core
439f40346SAlexander Shishkin *
539f40346SAlexander Shishkin * Copyright (C) 2014-2015 Intel Corporation.
639f40346SAlexander Shishkin */
739f40346SAlexander Shishkin
839f40346SAlexander Shishkin #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
939f40346SAlexander Shishkin
1039f40346SAlexander Shishkin #include <linux/types.h>
1139f40346SAlexander Shishkin #include <linux/module.h>
1239f40346SAlexander Shishkin #include <linux/device.h>
1339f40346SAlexander Shishkin #include <linux/sysfs.h>
1439f40346SAlexander Shishkin #include <linux/kdev_t.h>
1539f40346SAlexander Shishkin #include <linux/debugfs.h>
1639f40346SAlexander Shishkin #include <linux/idr.h>
1739f40346SAlexander Shishkin #include <linux/pci.h>
18142dfeb2SAlexander Shishkin #include <linux/pm_runtime.h>
1939f40346SAlexander Shishkin #include <linux/dma-mapping.h>
2039f40346SAlexander Shishkin
2139f40346SAlexander Shishkin #include "intel_th.h"
2239f40346SAlexander Shishkin #include "debug.h"
2339f40346SAlexander Shishkin
24c49a7591SAlexander Shishkin static bool host_mode __read_mostly;
25c49a7591SAlexander Shishkin module_param(host_mode, bool, 0444);
26c49a7591SAlexander Shishkin
2739f40346SAlexander Shishkin static DEFINE_IDA(intel_th_ida);
2839f40346SAlexander Shishkin
intel_th_match(struct device * dev,const struct device_driver * driver)29*d69d8048SGreg Kroah-Hartman static int intel_th_match(struct device *dev, const struct device_driver *driver)
3039f40346SAlexander Shishkin {
31*d69d8048SGreg Kroah-Hartman const struct intel_th_driver *thdrv = to_intel_th_driver(driver);
3239f40346SAlexander Shishkin struct intel_th_device *thdev = to_intel_th_device(dev);
3339f40346SAlexander Shishkin
3439f40346SAlexander Shishkin if (thdev->type == INTEL_TH_SWITCH &&
3539f40346SAlexander Shishkin (!thdrv->enable || !thdrv->disable))
3639f40346SAlexander Shishkin return 0;
3739f40346SAlexander Shishkin
3839f40346SAlexander Shishkin return !strcmp(thdev->name, driver->name);
3939f40346SAlexander Shishkin }
4039f40346SAlexander Shishkin
intel_th_child_remove(struct device * dev,void * data)4139f40346SAlexander Shishkin static int intel_th_child_remove(struct device *dev, void *data)
4239f40346SAlexander Shishkin {
4339f40346SAlexander Shishkin device_release_driver(dev);
4439f40346SAlexander Shishkin
4539f40346SAlexander Shishkin return 0;
4639f40346SAlexander Shishkin }
4739f40346SAlexander Shishkin
intel_th_probe(struct device * dev)4839f40346SAlexander Shishkin static int intel_th_probe(struct device *dev)
4939f40346SAlexander Shishkin {
5039f40346SAlexander Shishkin struct intel_th_driver *thdrv = to_intel_th_driver(dev->driver);
5139f40346SAlexander Shishkin struct intel_th_device *thdev = to_intel_th_device(dev);
5239f40346SAlexander Shishkin struct intel_th_driver *hubdrv;
5339f40346SAlexander Shishkin struct intel_th_device *hub = NULL;
5439f40346SAlexander Shishkin int ret;
5539f40346SAlexander Shishkin
5639f40346SAlexander Shishkin if (thdev->type == INTEL_TH_SWITCH)
5739f40346SAlexander Shishkin hub = thdev;
5839f40346SAlexander Shishkin else if (dev->parent)
5939f40346SAlexander Shishkin hub = to_intel_th_device(dev->parent);
6039f40346SAlexander Shishkin
6139f40346SAlexander Shishkin if (!hub || !hub->dev.driver)
6239f40346SAlexander Shishkin return -EPROBE_DEFER;
6339f40346SAlexander Shishkin
6439f40346SAlexander Shishkin hubdrv = to_intel_th_driver(hub->dev.driver);
6539f40346SAlexander Shishkin
66142dfeb2SAlexander Shishkin pm_runtime_set_active(dev);
67142dfeb2SAlexander Shishkin pm_runtime_no_callbacks(dev);
68142dfeb2SAlexander Shishkin pm_runtime_enable(dev);
69142dfeb2SAlexander Shishkin
7039f40346SAlexander Shishkin ret = thdrv->probe(to_intel_th_device(dev));
7139f40346SAlexander Shishkin if (ret)
72142dfeb2SAlexander Shishkin goto out_pm;
7339f40346SAlexander Shishkin
74b5edbf1eSAlexander Shishkin if (thdrv->attr_group) {
75b5edbf1eSAlexander Shishkin ret = sysfs_create_group(&thdev->dev.kobj, thdrv->attr_group);
76142dfeb2SAlexander Shishkin if (ret)
77142dfeb2SAlexander Shishkin goto out;
78b5edbf1eSAlexander Shishkin }
79b5edbf1eSAlexander Shishkin
8039f40346SAlexander Shishkin if (thdev->type == INTEL_TH_OUTPUT &&
8139f40346SAlexander Shishkin !intel_th_output_assigned(thdev))
82142dfeb2SAlexander Shishkin /* does not talk to hardware */
8339f40346SAlexander Shishkin ret = hubdrv->assign(hub, thdev);
8439f40346SAlexander Shishkin
85142dfeb2SAlexander Shishkin out:
86142dfeb2SAlexander Shishkin if (ret)
87142dfeb2SAlexander Shishkin thdrv->remove(thdev);
88142dfeb2SAlexander Shishkin
89142dfeb2SAlexander Shishkin out_pm:
90142dfeb2SAlexander Shishkin if (ret)
91142dfeb2SAlexander Shishkin pm_runtime_disable(dev);
92142dfeb2SAlexander Shishkin
9339f40346SAlexander Shishkin return ret;
9439f40346SAlexander Shishkin }
9539f40346SAlexander Shishkin
96a753bfcfSAlexander Shishkin static void intel_th_device_remove(struct intel_th_device *thdev);
97a753bfcfSAlexander Shishkin
intel_th_remove(struct device * dev)98fc7a6209SUwe Kleine-König static void intel_th_remove(struct device *dev)
9939f40346SAlexander Shishkin {
10039f40346SAlexander Shishkin struct intel_th_driver *thdrv = to_intel_th_driver(dev->driver);
10139f40346SAlexander Shishkin struct intel_th_device *thdev = to_intel_th_device(dev);
102a753bfcfSAlexander Shishkin struct intel_th_device *hub = to_intel_th_hub(thdev);
10339f40346SAlexander Shishkin
10439f40346SAlexander Shishkin if (thdev->type == INTEL_TH_SWITCH) {
105a753bfcfSAlexander Shishkin struct intel_th *th = to_intel_th(hub);
106a753bfcfSAlexander Shishkin int i, lowest;
107a753bfcfSAlexander Shishkin
108ae128916SUwe Kleine-König /*
109ae128916SUwe Kleine-König * disconnect outputs
110ae128916SUwe Kleine-König *
111ae128916SUwe Kleine-König * intel_th_child_remove returns 0 unconditionally, so there is
112ae128916SUwe Kleine-König * no need to check the return value of device_for_each_child.
113ae128916SUwe Kleine-König */
114ae128916SUwe Kleine-König device_for_each_child(dev, thdev, intel_th_child_remove);
115a753bfcfSAlexander Shishkin
116a753bfcfSAlexander Shishkin /*
117a753bfcfSAlexander Shishkin * Remove outputs, that is, hub's children: they are created
118a753bfcfSAlexander Shishkin * at hub's probe time by having the hub call
119a753bfcfSAlexander Shishkin * intel_th_output_enable() for each of them.
120a753bfcfSAlexander Shishkin */
121a753bfcfSAlexander Shishkin for (i = 0, lowest = -1; i < th->num_thdevs; i++) {
122a753bfcfSAlexander Shishkin /*
123a753bfcfSAlexander Shishkin * Move the non-output devices from higher up the
124a753bfcfSAlexander Shishkin * th->thdev[] array to lower positions to maintain
125a753bfcfSAlexander Shishkin * a contiguous array.
126a753bfcfSAlexander Shishkin */
127a753bfcfSAlexander Shishkin if (th->thdev[i]->type != INTEL_TH_OUTPUT) {
128a753bfcfSAlexander Shishkin if (lowest >= 0) {
129a753bfcfSAlexander Shishkin th->thdev[lowest] = th->thdev[i];
130a753bfcfSAlexander Shishkin th->thdev[i] = NULL;
131a753bfcfSAlexander Shishkin ++lowest;
132a753bfcfSAlexander Shishkin }
133a753bfcfSAlexander Shishkin
134a753bfcfSAlexander Shishkin continue;
135a753bfcfSAlexander Shishkin }
136a753bfcfSAlexander Shishkin
137a753bfcfSAlexander Shishkin if (lowest == -1)
138a753bfcfSAlexander Shishkin lowest = i;
139a753bfcfSAlexander Shishkin
140a753bfcfSAlexander Shishkin intel_th_device_remove(th->thdev[i]);
141a753bfcfSAlexander Shishkin th->thdev[i] = NULL;
142a753bfcfSAlexander Shishkin }
143a753bfcfSAlexander Shishkin
1448801922cSAlexander Shishkin if (lowest >= 0)
145a753bfcfSAlexander Shishkin th->num_thdevs = lowest;
14639f40346SAlexander Shishkin }
14739f40346SAlexander Shishkin
148b5edbf1eSAlexander Shishkin if (thdrv->attr_group)
149b5edbf1eSAlexander Shishkin sysfs_remove_group(&thdev->dev.kobj, thdrv->attr_group);
150b5edbf1eSAlexander Shishkin
151142dfeb2SAlexander Shishkin pm_runtime_get_sync(dev);
152142dfeb2SAlexander Shishkin
15339f40346SAlexander Shishkin thdrv->remove(thdev);
15439f40346SAlexander Shishkin
15539f40346SAlexander Shishkin if (intel_th_output_assigned(thdev)) {
15639f40346SAlexander Shishkin struct intel_th_driver *hubdrv =
15739f40346SAlexander Shishkin to_intel_th_driver(dev->parent->driver);
15839f40346SAlexander Shishkin
15939f40346SAlexander Shishkin if (hub->dev.driver)
160142dfeb2SAlexander Shishkin /* does not talk to hardware */
16139f40346SAlexander Shishkin hubdrv->unassign(hub, thdev);
16239f40346SAlexander Shishkin }
16339f40346SAlexander Shishkin
164142dfeb2SAlexander Shishkin pm_runtime_disable(dev);
165142dfeb2SAlexander Shishkin pm_runtime_set_active(dev);
166142dfeb2SAlexander Shishkin pm_runtime_enable(dev);
16739f40346SAlexander Shishkin }
16839f40346SAlexander Shishkin
16939f40346SAlexander Shishkin static struct bus_type intel_th_bus = {
17039f40346SAlexander Shishkin .name = "intel_th",
17139f40346SAlexander Shishkin .match = intel_th_match,
17239f40346SAlexander Shishkin .probe = intel_th_probe,
17339f40346SAlexander Shishkin .remove = intel_th_remove,
17439f40346SAlexander Shishkin };
17539f40346SAlexander Shishkin
17639f40346SAlexander Shishkin static void intel_th_device_free(struct intel_th_device *thdev);
17739f40346SAlexander Shishkin
intel_th_device_release(struct device * dev)17839f40346SAlexander Shishkin static void intel_th_device_release(struct device *dev)
17939f40346SAlexander Shishkin {
18039f40346SAlexander Shishkin intel_th_device_free(to_intel_th_device(dev));
18139f40346SAlexander Shishkin }
18239f40346SAlexander Shishkin
1838dc0b2d3SRicardo B. Marliere static const struct device_type intel_th_source_device_type = {
18439f40346SAlexander Shishkin .name = "intel_th_source_device",
18539f40346SAlexander Shishkin .release = intel_th_device_release,
18639f40346SAlexander Shishkin };
18739f40346SAlexander Shishkin
intel_th_output_devnode(const struct device * dev,umode_t * mode,kuid_t * uid,kgid_t * gid)188a9b12f8bSGreg Kroah-Hartman static char *intel_th_output_devnode(const struct device *dev, umode_t *mode,
18939f40346SAlexander Shishkin kuid_t *uid, kgid_t *gid)
19039f40346SAlexander Shishkin {
191a9b12f8bSGreg Kroah-Hartman const struct intel_th_device *thdev = to_intel_th_device(dev);
192a9b12f8bSGreg Kroah-Hartman const struct intel_th *th = to_intel_th(thdev);
19339f40346SAlexander Shishkin char *node;
19439f40346SAlexander Shishkin
19539f40346SAlexander Shishkin if (thdev->id >= 0)
19614136e36SAlexander Shishkin node = kasprintf(GFP_KERNEL, "intel_th%d/%s%d", th->id,
19714136e36SAlexander Shishkin thdev->name, thdev->id);
19839f40346SAlexander Shishkin else
19914136e36SAlexander Shishkin node = kasprintf(GFP_KERNEL, "intel_th%d/%s", th->id,
20014136e36SAlexander Shishkin thdev->name);
20139f40346SAlexander Shishkin
20239f40346SAlexander Shishkin return node;
20339f40346SAlexander Shishkin }
20439f40346SAlexander Shishkin
port_show(struct device * dev,struct device_attribute * attr,char * buf)20539f40346SAlexander Shishkin static ssize_t port_show(struct device *dev, struct device_attribute *attr,
20639f40346SAlexander Shishkin char *buf)
20739f40346SAlexander Shishkin {
20839f40346SAlexander Shishkin struct intel_th_device *thdev = to_intel_th_device(dev);
20939f40346SAlexander Shishkin
21039f40346SAlexander Shishkin if (thdev->output.port >= 0)
21139f40346SAlexander Shishkin return scnprintf(buf, PAGE_SIZE, "%u\n", thdev->output.port);
21239f40346SAlexander Shishkin
21339f40346SAlexander Shishkin return scnprintf(buf, PAGE_SIZE, "unassigned\n");
21439f40346SAlexander Shishkin }
21539f40346SAlexander Shishkin
21639f40346SAlexander Shishkin static DEVICE_ATTR_RO(port);
21739f40346SAlexander Shishkin
intel_th_trace_prepare(struct intel_th_device * thdev)218ab1afed7SAlexander Shishkin static void intel_th_trace_prepare(struct intel_th_device *thdev)
219ab1afed7SAlexander Shishkin {
220ab1afed7SAlexander Shishkin struct intel_th_device *hub = to_intel_th_hub(thdev);
221ab1afed7SAlexander Shishkin struct intel_th_driver *hubdrv = to_intel_th_driver(hub->dev.driver);
222ab1afed7SAlexander Shishkin
223ab1afed7SAlexander Shishkin if (hub->type != INTEL_TH_SWITCH)
224ab1afed7SAlexander Shishkin return;
225ab1afed7SAlexander Shishkin
226ab1afed7SAlexander Shishkin if (thdev->type != INTEL_TH_OUTPUT)
227ab1afed7SAlexander Shishkin return;
228ab1afed7SAlexander Shishkin
229ab1afed7SAlexander Shishkin pm_runtime_get_sync(&thdev->dev);
230ab1afed7SAlexander Shishkin hubdrv->prepare(hub, &thdev->output);
231ab1afed7SAlexander Shishkin pm_runtime_put(&thdev->dev);
232ab1afed7SAlexander Shishkin }
233ab1afed7SAlexander Shishkin
intel_th_output_activate(struct intel_th_device * thdev)23439f40346SAlexander Shishkin static int intel_th_output_activate(struct intel_th_device *thdev)
23539f40346SAlexander Shishkin {
236f18a9531SAlexander Shishkin struct intel_th_driver *thdrv =
237f18a9531SAlexander Shishkin to_intel_th_driver_or_null(thdev->dev.driver);
23829e15e83SAlexander Shishkin struct intel_th *th = to_intel_th(thdev);
239142dfeb2SAlexander Shishkin int ret = 0;
240f18a9531SAlexander Shishkin
241f18a9531SAlexander Shishkin if (!thdrv)
242f18a9531SAlexander Shishkin return -ENODEV;
24339f40346SAlexander Shishkin
244e2ea295bSAlexander Shishkin if (!try_module_get(thdrv->driver.owner))
245e2ea295bSAlexander Shishkin return -ENODEV;
246e2ea295bSAlexander Shishkin
247142dfeb2SAlexander Shishkin pm_runtime_get_sync(&thdev->dev);
24839f40346SAlexander Shishkin
24929e15e83SAlexander Shishkin if (th->activate)
25029e15e83SAlexander Shishkin ret = th->activate(th);
25129e15e83SAlexander Shishkin if (ret)
25229e15e83SAlexander Shishkin goto fail_put;
25329e15e83SAlexander Shishkin
254ab1afed7SAlexander Shishkin intel_th_trace_prepare(thdev);
255142dfeb2SAlexander Shishkin if (thdrv->activate)
256142dfeb2SAlexander Shishkin ret = thdrv->activate(thdev);
257142dfeb2SAlexander Shishkin else
25839f40346SAlexander Shishkin intel_th_trace_enable(thdev);
25939f40346SAlexander Shishkin
26029e15e83SAlexander Shishkin if (ret)
26129e15e83SAlexander Shishkin goto fail_deactivate;
26229e15e83SAlexander Shishkin
26329e15e83SAlexander Shishkin return 0;
26429e15e83SAlexander Shishkin
26529e15e83SAlexander Shishkin fail_deactivate:
26629e15e83SAlexander Shishkin if (th->deactivate)
26729e15e83SAlexander Shishkin th->deactivate(th);
26829e15e83SAlexander Shishkin
26929e15e83SAlexander Shishkin fail_put:
270142dfeb2SAlexander Shishkin pm_runtime_put(&thdev->dev);
271e609ccefSAlexander Shishkin module_put(thdrv->driver.owner);
272142dfeb2SAlexander Shishkin
273142dfeb2SAlexander Shishkin return ret;
27439f40346SAlexander Shishkin }
27539f40346SAlexander Shishkin
intel_th_output_deactivate(struct intel_th_device * thdev)27639f40346SAlexander Shishkin static void intel_th_output_deactivate(struct intel_th_device *thdev)
27739f40346SAlexander Shishkin {
278f18a9531SAlexander Shishkin struct intel_th_driver *thdrv =
279f18a9531SAlexander Shishkin to_intel_th_driver_or_null(thdev->dev.driver);
28029e15e83SAlexander Shishkin struct intel_th *th = to_intel_th(thdev);
281f18a9531SAlexander Shishkin
282f18a9531SAlexander Shishkin if (!thdrv)
283f18a9531SAlexander Shishkin return;
28439f40346SAlexander Shishkin
28539f40346SAlexander Shishkin if (thdrv->deactivate)
28639f40346SAlexander Shishkin thdrv->deactivate(thdev);
28739f40346SAlexander Shishkin else
28839f40346SAlexander Shishkin intel_th_trace_disable(thdev);
289e2ea295bSAlexander Shishkin
29029e15e83SAlexander Shishkin if (th->deactivate)
29129e15e83SAlexander Shishkin th->deactivate(th);
29229e15e83SAlexander Shishkin
293142dfeb2SAlexander Shishkin pm_runtime_put(&thdev->dev);
294e2ea295bSAlexander Shishkin module_put(thdrv->driver.owner);
29539f40346SAlexander Shishkin }
29639f40346SAlexander Shishkin
active_show(struct device * dev,struct device_attribute * attr,char * buf)29739f40346SAlexander Shishkin static ssize_t active_show(struct device *dev, struct device_attribute *attr,
29839f40346SAlexander Shishkin char *buf)
29939f40346SAlexander Shishkin {
30039f40346SAlexander Shishkin struct intel_th_device *thdev = to_intel_th_device(dev);
30139f40346SAlexander Shishkin
30239f40346SAlexander Shishkin return scnprintf(buf, PAGE_SIZE, "%d\n", thdev->output.active);
30339f40346SAlexander Shishkin }
30439f40346SAlexander Shishkin
active_store(struct device * dev,struct device_attribute * attr,const char * buf,size_t size)30539f40346SAlexander Shishkin static ssize_t active_store(struct device *dev, struct device_attribute *attr,
30639f40346SAlexander Shishkin const char *buf, size_t size)
30739f40346SAlexander Shishkin {
30839f40346SAlexander Shishkin struct intel_th_device *thdev = to_intel_th_device(dev);
30939f40346SAlexander Shishkin unsigned long val;
31039f40346SAlexander Shishkin int ret;
31139f40346SAlexander Shishkin
31239f40346SAlexander Shishkin ret = kstrtoul(buf, 10, &val);
31339f40346SAlexander Shishkin if (ret)
31439f40346SAlexander Shishkin return ret;
31539f40346SAlexander Shishkin
31639f40346SAlexander Shishkin if (!!val != thdev->output.active) {
31739f40346SAlexander Shishkin if (val)
31839f40346SAlexander Shishkin ret = intel_th_output_activate(thdev);
31939f40346SAlexander Shishkin else
32039f40346SAlexander Shishkin intel_th_output_deactivate(thdev);
32139f40346SAlexander Shishkin }
32239f40346SAlexander Shishkin
32339f40346SAlexander Shishkin return ret ? ret : size;
32439f40346SAlexander Shishkin }
32539f40346SAlexander Shishkin
32639f40346SAlexander Shishkin static DEVICE_ATTR_RW(active);
32739f40346SAlexander Shishkin
32839f40346SAlexander Shishkin static struct attribute *intel_th_output_attrs[] = {
32939f40346SAlexander Shishkin &dev_attr_port.attr,
33039f40346SAlexander Shishkin &dev_attr_active.attr,
33139f40346SAlexander Shishkin NULL,
33239f40346SAlexander Shishkin };
33339f40346SAlexander Shishkin
33439f40346SAlexander Shishkin ATTRIBUTE_GROUPS(intel_th_output);
33539f40346SAlexander Shishkin
3368dc0b2d3SRicardo B. Marliere static const struct device_type intel_th_output_device_type = {
33739f40346SAlexander Shishkin .name = "intel_th_output_device",
33839f40346SAlexander Shishkin .groups = intel_th_output_groups,
33939f40346SAlexander Shishkin .release = intel_th_device_release,
34039f40346SAlexander Shishkin .devnode = intel_th_output_devnode,
34139f40346SAlexander Shishkin };
34239f40346SAlexander Shishkin
3438dc0b2d3SRicardo B. Marliere static const struct device_type intel_th_switch_device_type = {
34439f40346SAlexander Shishkin .name = "intel_th_switch_device",
34539f40346SAlexander Shishkin .release = intel_th_device_release,
34639f40346SAlexander Shishkin };
34739f40346SAlexander Shishkin
3488dc0b2d3SRicardo B. Marliere static const struct device_type *intel_th_device_type[] = {
34939f40346SAlexander Shishkin [INTEL_TH_SOURCE] = &intel_th_source_device_type,
35039f40346SAlexander Shishkin [INTEL_TH_OUTPUT] = &intel_th_output_device_type,
35139f40346SAlexander Shishkin [INTEL_TH_SWITCH] = &intel_th_switch_device_type,
35239f40346SAlexander Shishkin };
35339f40346SAlexander Shishkin
intel_th_driver_register(struct intel_th_driver * thdrv)35439f40346SAlexander Shishkin int intel_th_driver_register(struct intel_th_driver *thdrv)
35539f40346SAlexander Shishkin {
35639f40346SAlexander Shishkin if (!thdrv->probe || !thdrv->remove)
35739f40346SAlexander Shishkin return -EINVAL;
35839f40346SAlexander Shishkin
35939f40346SAlexander Shishkin thdrv->driver.bus = &intel_th_bus;
36039f40346SAlexander Shishkin
36139f40346SAlexander Shishkin return driver_register(&thdrv->driver);
36239f40346SAlexander Shishkin }
36339f40346SAlexander Shishkin EXPORT_SYMBOL_GPL(intel_th_driver_register);
36439f40346SAlexander Shishkin
intel_th_driver_unregister(struct intel_th_driver * thdrv)36539f40346SAlexander Shishkin void intel_th_driver_unregister(struct intel_th_driver *thdrv)
36639f40346SAlexander Shishkin {
36739f40346SAlexander Shishkin driver_unregister(&thdrv->driver);
36839f40346SAlexander Shishkin }
36939f40346SAlexander Shishkin EXPORT_SYMBOL_GPL(intel_th_driver_unregister);
37039f40346SAlexander Shishkin
37139f40346SAlexander Shishkin static struct intel_th_device *
intel_th_device_alloc(struct intel_th * th,unsigned int type,const char * name,int id)37239f40346SAlexander Shishkin intel_th_device_alloc(struct intel_th *th, unsigned int type, const char *name,
37339f40346SAlexander Shishkin int id)
37439f40346SAlexander Shishkin {
37539f40346SAlexander Shishkin struct device *parent;
37639f40346SAlexander Shishkin struct intel_th_device *thdev;
37739f40346SAlexander Shishkin
3788edc514bSAlexander Shishkin if (type == INTEL_TH_OUTPUT)
37939f40346SAlexander Shishkin parent = &th->hub->dev;
3808edc514bSAlexander Shishkin else
3818edc514bSAlexander Shishkin parent = th->dev;
38239f40346SAlexander Shishkin
38339f40346SAlexander Shishkin thdev = kzalloc(sizeof(*thdev) + strlen(name) + 1, GFP_KERNEL);
38439f40346SAlexander Shishkin if (!thdev)
38539f40346SAlexander Shishkin return NULL;
38639f40346SAlexander Shishkin
38739f40346SAlexander Shishkin thdev->id = id;
38839f40346SAlexander Shishkin thdev->type = type;
38939f40346SAlexander Shishkin
39039f40346SAlexander Shishkin strcpy(thdev->name, name);
39139f40346SAlexander Shishkin device_initialize(&thdev->dev);
39239f40346SAlexander Shishkin thdev->dev.bus = &intel_th_bus;
39339f40346SAlexander Shishkin thdev->dev.type = intel_th_device_type[type];
39439f40346SAlexander Shishkin thdev->dev.parent = parent;
39539f40346SAlexander Shishkin thdev->dev.dma_mask = parent->dma_mask;
39639f40346SAlexander Shishkin thdev->dev.dma_parms = parent->dma_parms;
39739f40346SAlexander Shishkin dma_set_coherent_mask(&thdev->dev, parent->coherent_dma_mask);
39839f40346SAlexander Shishkin if (id >= 0)
39939f40346SAlexander Shishkin dev_set_name(&thdev->dev, "%d-%s%d", th->id, name, id);
40039f40346SAlexander Shishkin else
40139f40346SAlexander Shishkin dev_set_name(&thdev->dev, "%d-%s", th->id, name);
40239f40346SAlexander Shishkin
40339f40346SAlexander Shishkin return thdev;
40439f40346SAlexander Shishkin }
40539f40346SAlexander Shishkin
intel_th_device_add_resources(struct intel_th_device * thdev,struct resource * res,int nres)40639f40346SAlexander Shishkin static int intel_th_device_add_resources(struct intel_th_device *thdev,
40739f40346SAlexander Shishkin struct resource *res, int nres)
40839f40346SAlexander Shishkin {
40939f40346SAlexander Shishkin struct resource *r;
41039f40346SAlexander Shishkin
41139f40346SAlexander Shishkin r = kmemdup(res, sizeof(*res) * nres, GFP_KERNEL);
41239f40346SAlexander Shishkin if (!r)
41339f40346SAlexander Shishkin return -ENOMEM;
41439f40346SAlexander Shishkin
41539f40346SAlexander Shishkin thdev->resource = r;
41639f40346SAlexander Shishkin thdev->num_resources = nres;
41739f40346SAlexander Shishkin
41839f40346SAlexander Shishkin return 0;
41939f40346SAlexander Shishkin }
42039f40346SAlexander Shishkin
intel_th_device_remove(struct intel_th_device * thdev)42139f40346SAlexander Shishkin static void intel_th_device_remove(struct intel_th_device *thdev)
42239f40346SAlexander Shishkin {
42339f40346SAlexander Shishkin device_del(&thdev->dev);
42439f40346SAlexander Shishkin put_device(&thdev->dev);
42539f40346SAlexander Shishkin }
42639f40346SAlexander Shishkin
intel_th_device_free(struct intel_th_device * thdev)42739f40346SAlexander Shishkin static void intel_th_device_free(struct intel_th_device *thdev)
42839f40346SAlexander Shishkin {
42939f40346SAlexander Shishkin kfree(thdev->resource);
43039f40346SAlexander Shishkin kfree(thdev);
43139f40346SAlexander Shishkin }
43239f40346SAlexander Shishkin
43339f40346SAlexander Shishkin /*
43439f40346SAlexander Shishkin * Intel(R) Trace Hub subdevices
43539f40346SAlexander Shishkin */
43677c98b28SAlexander Shishkin static const struct intel_th_subdevice {
43739f40346SAlexander Shishkin const char *name;
43839f40346SAlexander Shishkin struct resource res[3];
43939f40346SAlexander Shishkin unsigned nres;
44039f40346SAlexander Shishkin unsigned type;
44139f40346SAlexander Shishkin unsigned otype;
442ba828cc9SAlexander Shishkin bool mknode;
4434d02ceffSAlexander Shishkin unsigned scrpd;
44439f40346SAlexander Shishkin int id;
445a753bfcfSAlexander Shishkin } intel_th_subdevices[] = {
44639f40346SAlexander Shishkin {
44739f40346SAlexander Shishkin .nres = 1,
44839f40346SAlexander Shishkin .res = {
44939f40346SAlexander Shishkin {
4508116db57SAlexander Shishkin /* Handle TSCU and CTS from GTH driver */
45139f40346SAlexander Shishkin .start = REG_GTH_OFFSET,
4528116db57SAlexander Shishkin .end = REG_CTS_OFFSET + REG_CTS_LENGTH - 1,
45339f40346SAlexander Shishkin .flags = IORESOURCE_MEM,
45439f40346SAlexander Shishkin },
45539f40346SAlexander Shishkin },
45639f40346SAlexander Shishkin .name = "gth",
45739f40346SAlexander Shishkin .type = INTEL_TH_SWITCH,
45839f40346SAlexander Shishkin .id = -1,
45939f40346SAlexander Shishkin },
46039f40346SAlexander Shishkin {
46139f40346SAlexander Shishkin .nres = 2,
46239f40346SAlexander Shishkin .res = {
46339f40346SAlexander Shishkin {
46439f40346SAlexander Shishkin .start = REG_MSU_OFFSET,
46539f40346SAlexander Shishkin .end = REG_MSU_OFFSET + REG_MSU_LENGTH - 1,
46639f40346SAlexander Shishkin .flags = IORESOURCE_MEM,
46739f40346SAlexander Shishkin },
46839f40346SAlexander Shishkin {
46939f40346SAlexander Shishkin .start = BUF_MSU_OFFSET,
47039f40346SAlexander Shishkin .end = BUF_MSU_OFFSET + BUF_MSU_LENGTH - 1,
47139f40346SAlexander Shishkin .flags = IORESOURCE_MEM,
47239f40346SAlexander Shishkin },
47339f40346SAlexander Shishkin },
47439f40346SAlexander Shishkin .name = "msc",
47539f40346SAlexander Shishkin .id = 0,
47639f40346SAlexander Shishkin .type = INTEL_TH_OUTPUT,
477ba828cc9SAlexander Shishkin .mknode = true,
47839f40346SAlexander Shishkin .otype = GTH_MSU,
4794d02ceffSAlexander Shishkin .scrpd = SCRPD_MEM_IS_PRIM_DEST | SCRPD_MSC0_IS_ENABLED,
48039f40346SAlexander Shishkin },
48139f40346SAlexander Shishkin {
48239f40346SAlexander Shishkin .nres = 2,
48339f40346SAlexander Shishkin .res = {
48439f40346SAlexander Shishkin {
48539f40346SAlexander Shishkin .start = REG_MSU_OFFSET,
48639f40346SAlexander Shishkin .end = REG_MSU_OFFSET + REG_MSU_LENGTH - 1,
48739f40346SAlexander Shishkin .flags = IORESOURCE_MEM,
48839f40346SAlexander Shishkin },
48939f40346SAlexander Shishkin {
49039f40346SAlexander Shishkin .start = BUF_MSU_OFFSET,
49139f40346SAlexander Shishkin .end = BUF_MSU_OFFSET + BUF_MSU_LENGTH - 1,
49239f40346SAlexander Shishkin .flags = IORESOURCE_MEM,
49339f40346SAlexander Shishkin },
49439f40346SAlexander Shishkin },
49539f40346SAlexander Shishkin .name = "msc",
49639f40346SAlexander Shishkin .id = 1,
49739f40346SAlexander Shishkin .type = INTEL_TH_OUTPUT,
498ba828cc9SAlexander Shishkin .mknode = true,
49939f40346SAlexander Shishkin .otype = GTH_MSU,
5004d02ceffSAlexander Shishkin .scrpd = SCRPD_MEM_IS_PRIM_DEST | SCRPD_MSC1_IS_ENABLED,
50139f40346SAlexander Shishkin },
50239f40346SAlexander Shishkin {
50339f40346SAlexander Shishkin .nres = 2,
50439f40346SAlexander Shishkin .res = {
50539f40346SAlexander Shishkin {
50639f40346SAlexander Shishkin .start = REG_STH_OFFSET,
50739f40346SAlexander Shishkin .end = REG_STH_OFFSET + REG_STH_LENGTH - 1,
50839f40346SAlexander Shishkin .flags = IORESOURCE_MEM,
50939f40346SAlexander Shishkin },
51039f40346SAlexander Shishkin {
511db73a059SAlexander Shishkin .start = TH_MMIO_SW,
51239f40346SAlexander Shishkin .end = 0,
51339f40346SAlexander Shishkin .flags = IORESOURCE_MEM,
51439f40346SAlexander Shishkin },
51539f40346SAlexander Shishkin },
51639f40346SAlexander Shishkin .id = -1,
51739f40346SAlexander Shishkin .name = "sth",
51839f40346SAlexander Shishkin .type = INTEL_TH_SOURCE,
51939f40346SAlexander Shishkin },
52039f40346SAlexander Shishkin {
521fc027f4cSAlexander Shishkin .nres = 2,
522fc027f4cSAlexander Shishkin .res = {
523fc027f4cSAlexander Shishkin {
524fc027f4cSAlexander Shishkin .start = REG_STH_OFFSET,
525fc027f4cSAlexander Shishkin .end = REG_STH_OFFSET + REG_STH_LENGTH - 1,
526fc027f4cSAlexander Shishkin .flags = IORESOURCE_MEM,
527fc027f4cSAlexander Shishkin },
528fc027f4cSAlexander Shishkin {
529fc027f4cSAlexander Shishkin .start = TH_MMIO_RTIT,
530fc027f4cSAlexander Shishkin .end = 0,
531fc027f4cSAlexander Shishkin .flags = IORESOURCE_MEM,
532fc027f4cSAlexander Shishkin },
533fc027f4cSAlexander Shishkin },
534fc027f4cSAlexander Shishkin .id = -1,
535fc027f4cSAlexander Shishkin .name = "rtit",
536fc027f4cSAlexander Shishkin .type = INTEL_TH_SOURCE,
537fc027f4cSAlexander Shishkin },
538fc027f4cSAlexander Shishkin {
53939f40346SAlexander Shishkin .nres = 1,
54039f40346SAlexander Shishkin .res = {
54139f40346SAlexander Shishkin {
54239f40346SAlexander Shishkin .start = REG_PTI_OFFSET,
54339f40346SAlexander Shishkin .end = REG_PTI_OFFSET + REG_PTI_LENGTH - 1,
54439f40346SAlexander Shishkin .flags = IORESOURCE_MEM,
54539f40346SAlexander Shishkin },
54639f40346SAlexander Shishkin },
54739f40346SAlexander Shishkin .id = -1,
54839f40346SAlexander Shishkin .name = "pti",
54939f40346SAlexander Shishkin .type = INTEL_TH_OUTPUT,
55039f40346SAlexander Shishkin .otype = GTH_PTI,
5514d02ceffSAlexander Shishkin .scrpd = SCRPD_PTI_IS_PRIM_DEST,
55239f40346SAlexander Shishkin },
55339f40346SAlexander Shishkin {
55439f40346SAlexander Shishkin .nres = 1,
55539f40346SAlexander Shishkin .res = {
55639f40346SAlexander Shishkin {
55792758af3SAlexander Shishkin .start = REG_PTI_OFFSET,
55892758af3SAlexander Shishkin .end = REG_PTI_OFFSET + REG_PTI_LENGTH - 1,
55992758af3SAlexander Shishkin .flags = IORESOURCE_MEM,
56092758af3SAlexander Shishkin },
56192758af3SAlexander Shishkin },
56292758af3SAlexander Shishkin .id = -1,
56392758af3SAlexander Shishkin .name = "lpp",
56492758af3SAlexander Shishkin .type = INTEL_TH_OUTPUT,
56592758af3SAlexander Shishkin .otype = GTH_LPP,
56692758af3SAlexander Shishkin .scrpd = SCRPD_PTI_IS_PRIM_DEST,
56792758af3SAlexander Shishkin },
56892758af3SAlexander Shishkin {
56992758af3SAlexander Shishkin .nres = 1,
57092758af3SAlexander Shishkin .res = {
57192758af3SAlexander Shishkin {
57239f40346SAlexander Shishkin .start = REG_DCIH_OFFSET,
57339f40346SAlexander Shishkin .end = REG_DCIH_OFFSET + REG_DCIH_LENGTH - 1,
57439f40346SAlexander Shishkin .flags = IORESOURCE_MEM,
57539f40346SAlexander Shishkin },
57639f40346SAlexander Shishkin },
57739f40346SAlexander Shishkin .id = -1,
57839f40346SAlexander Shishkin .name = "dcih",
57939f40346SAlexander Shishkin .type = INTEL_TH_OUTPUT,
58039f40346SAlexander Shishkin },
58139f40346SAlexander Shishkin };
58239f40346SAlexander Shishkin
583a36aa80fSAlexander Shishkin #ifdef CONFIG_MODULES
__intel_th_request_hub_module(struct work_struct * work)584a36aa80fSAlexander Shishkin static void __intel_th_request_hub_module(struct work_struct *work)
585a36aa80fSAlexander Shishkin {
586a36aa80fSAlexander Shishkin struct intel_th *th = container_of(work, struct intel_th,
587a36aa80fSAlexander Shishkin request_module_work);
588a36aa80fSAlexander Shishkin
589a36aa80fSAlexander Shishkin request_module("intel_th_%s", th->hub->name);
590a36aa80fSAlexander Shishkin }
591a36aa80fSAlexander Shishkin
intel_th_request_hub_module(struct intel_th * th)592a36aa80fSAlexander Shishkin static int intel_th_request_hub_module(struct intel_th *th)
593a36aa80fSAlexander Shishkin {
594a36aa80fSAlexander Shishkin INIT_WORK(&th->request_module_work, __intel_th_request_hub_module);
595a36aa80fSAlexander Shishkin schedule_work(&th->request_module_work);
596a36aa80fSAlexander Shishkin
597a36aa80fSAlexander Shishkin return 0;
598a36aa80fSAlexander Shishkin }
599a36aa80fSAlexander Shishkin
intel_th_request_hub_module_flush(struct intel_th * th)600a36aa80fSAlexander Shishkin static void intel_th_request_hub_module_flush(struct intel_th *th)
601a36aa80fSAlexander Shishkin {
602a36aa80fSAlexander Shishkin flush_work(&th->request_module_work);
603a36aa80fSAlexander Shishkin }
604a36aa80fSAlexander Shishkin #else
intel_th_request_hub_module(struct intel_th * th)605a36aa80fSAlexander Shishkin static inline int intel_th_request_hub_module(struct intel_th *th)
606a36aa80fSAlexander Shishkin {
607a36aa80fSAlexander Shishkin return -EINVAL;
608a36aa80fSAlexander Shishkin }
609a36aa80fSAlexander Shishkin
intel_th_request_hub_module_flush(struct intel_th * th)610a36aa80fSAlexander Shishkin static inline void intel_th_request_hub_module_flush(struct intel_th *th)
611a36aa80fSAlexander Shishkin {
612a36aa80fSAlexander Shishkin }
613a36aa80fSAlexander Shishkin #endif /* CONFIG_MODULES */
614a36aa80fSAlexander Shishkin
615a753bfcfSAlexander Shishkin static struct intel_th_device *
intel_th_subdevice_alloc(struct intel_th * th,const struct intel_th_subdevice * subdev)616a753bfcfSAlexander Shishkin intel_th_subdevice_alloc(struct intel_th *th,
617a753bfcfSAlexander Shishkin const struct intel_th_subdevice *subdev)
61839f40346SAlexander Shishkin {
619a753bfcfSAlexander Shishkin struct intel_th_device *thdev;
62039f40346SAlexander Shishkin struct resource res[3];
62139f40346SAlexander Shishkin unsigned int req = 0;
622a753bfcfSAlexander Shishkin int r, err;
623c49a7591SAlexander Shishkin
62439f40346SAlexander Shishkin thdev = intel_th_device_alloc(th, subdev->type, subdev->name,
62539f40346SAlexander Shishkin subdev->id);
626a753bfcfSAlexander Shishkin if (!thdev)
627a753bfcfSAlexander Shishkin return ERR_PTR(-ENOMEM);
628a753bfcfSAlexander Shishkin
6293321371bSAlexander Shishkin thdev->drvdata = th->drvdata;
63039f40346SAlexander Shishkin
63139f40346SAlexander Shishkin memcpy(res, subdev->res,
63239f40346SAlexander Shishkin sizeof(struct resource) * subdev->nres);
63339f40346SAlexander Shishkin
63439f40346SAlexander Shishkin for (r = 0; r < subdev->nres; r++) {
635a753bfcfSAlexander Shishkin struct resource *devres = th->resource;
636db73a059SAlexander Shishkin int bar = TH_MMIO_CONFIG;
63739f40346SAlexander Shishkin
63839f40346SAlexander Shishkin /*
63939f40346SAlexander Shishkin * Take .end == 0 to mean 'take the whole bar',
64039f40346SAlexander Shishkin * .start then tells us which bar it is. Default to
64139f40346SAlexander Shishkin * TH_MMIO_CONFIG.
64239f40346SAlexander Shishkin */
64339f40346SAlexander Shishkin if (!res[r].end && res[r].flags == IORESOURCE_MEM) {
64439f40346SAlexander Shishkin bar = res[r].start;
64523f66749SAlexander Shishkin err = -ENODEV;
64623f66749SAlexander Shishkin if (bar >= th->num_resources)
64723f66749SAlexander Shishkin goto fail_put_device;
64839f40346SAlexander Shishkin res[r].start = 0;
64939f40346SAlexander Shishkin res[r].end = resource_size(&devres[bar]) - 1;
65039f40346SAlexander Shishkin }
65139f40346SAlexander Shishkin
65239f40346SAlexander Shishkin if (res[r].flags & IORESOURCE_MEM) {
65339f40346SAlexander Shishkin res[r].start += devres[bar].start;
65439f40346SAlexander Shishkin res[r].end += devres[bar].start;
65539f40346SAlexander Shishkin
65639f40346SAlexander Shishkin dev_dbg(th->dev, "%s:%d @ %pR\n",
65739f40346SAlexander Shishkin subdev->name, r, &res[r]);
65839f40346SAlexander Shishkin } else if (res[r].flags & IORESOURCE_IRQ) {
6594c5bb6ebSAlexander Shishkin /*
6604c5bb6ebSAlexander Shishkin * Only pass on the IRQ if we have useful interrupts:
6614c5bb6ebSAlexander Shishkin * the ones that can be configured via MINTCTL.
6624c5bb6ebSAlexander Shishkin */
6634c5bb6ebSAlexander Shishkin if (INTEL_TH_CAP(th, has_mintctl) && th->irq != -1)
664a753bfcfSAlexander Shishkin res[r].start = th->irq;
66539f40346SAlexander Shishkin }
66639f40346SAlexander Shishkin }
66739f40346SAlexander Shishkin
66839f40346SAlexander Shishkin err = intel_th_device_add_resources(thdev, res, subdev->nres);
66951259277SAlexander Shishkin if (err)
670a753bfcfSAlexander Shishkin goto fail_put_device;
67139f40346SAlexander Shishkin
67239f40346SAlexander Shishkin if (subdev->type == INTEL_TH_OUTPUT) {
673ba828cc9SAlexander Shishkin if (subdev->mknode)
674a753bfcfSAlexander Shishkin thdev->dev.devt = MKDEV(th->major, th->num_thdevs);
67539f40346SAlexander Shishkin thdev->output.type = subdev->otype;
67639f40346SAlexander Shishkin thdev->output.port = -1;
6774d02ceffSAlexander Shishkin thdev->output.scratchpad = subdev->scrpd;
678c49a7591SAlexander Shishkin } else if (subdev->type == INTEL_TH_SWITCH) {
679282ffec5SAlexander Shishkin thdev->host_mode =
680282ffec5SAlexander Shishkin INTEL_TH_CAP(th, host_mode_only) ? true : host_mode;
681a753bfcfSAlexander Shishkin th->hub = thdev;
68239f40346SAlexander Shishkin }
68339f40346SAlexander Shishkin
68439f40346SAlexander Shishkin err = device_add(&thdev->dev);
68551259277SAlexander Shishkin if (err)
686a753bfcfSAlexander Shishkin goto fail_free_res;
68739f40346SAlexander Shishkin
68839f40346SAlexander Shishkin /* need switch driver to be loaded to enumerate the rest */
68939f40346SAlexander Shishkin if (subdev->type == INTEL_TH_SWITCH && !req) {
690a36aa80fSAlexander Shishkin err = intel_th_request_hub_module(th);
69139f40346SAlexander Shishkin if (!err)
69239f40346SAlexander Shishkin req++;
69339f40346SAlexander Shishkin }
69439f40346SAlexander Shishkin
695a753bfcfSAlexander Shishkin return thdev;
696a753bfcfSAlexander Shishkin
697a753bfcfSAlexander Shishkin fail_free_res:
698a753bfcfSAlexander Shishkin kfree(thdev->resource);
699a753bfcfSAlexander Shishkin
700a753bfcfSAlexander Shishkin fail_put_device:
701a753bfcfSAlexander Shishkin put_device(&thdev->dev);
702a753bfcfSAlexander Shishkin
703a753bfcfSAlexander Shishkin return ERR_PTR(err);
704a753bfcfSAlexander Shishkin }
705a753bfcfSAlexander Shishkin
706a753bfcfSAlexander Shishkin /**
707a753bfcfSAlexander Shishkin * intel_th_output_enable() - find and enable a device for a given output type
708a753bfcfSAlexander Shishkin * @th: Intel TH instance
709a753bfcfSAlexander Shishkin * @otype: output type
710a753bfcfSAlexander Shishkin *
711a753bfcfSAlexander Shishkin * Go through the unallocated output devices, find the first one whos type
712a753bfcfSAlexander Shishkin * matches @otype and instantiate it. These devices are removed when the hub
713a753bfcfSAlexander Shishkin * device is removed, see intel_th_remove().
714a753bfcfSAlexander Shishkin */
intel_th_output_enable(struct intel_th * th,unsigned int otype)715a753bfcfSAlexander Shishkin int intel_th_output_enable(struct intel_th *th, unsigned int otype)
716a753bfcfSAlexander Shishkin {
717a753bfcfSAlexander Shishkin struct intel_th_device *thdev;
718a753bfcfSAlexander Shishkin int src = 0, dst = 0;
719a753bfcfSAlexander Shishkin
720a753bfcfSAlexander Shishkin for (src = 0, dst = 0; dst <= th->num_thdevs; src++, dst++) {
721a753bfcfSAlexander Shishkin for (; src < ARRAY_SIZE(intel_th_subdevices); src++) {
722a753bfcfSAlexander Shishkin if (intel_th_subdevices[src].type != INTEL_TH_OUTPUT)
723a753bfcfSAlexander Shishkin continue;
724a753bfcfSAlexander Shishkin
725a753bfcfSAlexander Shishkin if (intel_th_subdevices[src].otype != otype)
726a753bfcfSAlexander Shishkin continue;
727a753bfcfSAlexander Shishkin
728a753bfcfSAlexander Shishkin break;
729a753bfcfSAlexander Shishkin }
730a753bfcfSAlexander Shishkin
731a753bfcfSAlexander Shishkin /* no unallocated matching subdevices */
732a753bfcfSAlexander Shishkin if (src == ARRAY_SIZE(intel_th_subdevices))
733a753bfcfSAlexander Shishkin return -ENODEV;
734a753bfcfSAlexander Shishkin
735a753bfcfSAlexander Shishkin for (; dst < th->num_thdevs; dst++) {
736a753bfcfSAlexander Shishkin if (th->thdev[dst]->type != INTEL_TH_OUTPUT)
737a753bfcfSAlexander Shishkin continue;
738a753bfcfSAlexander Shishkin
739a753bfcfSAlexander Shishkin if (th->thdev[dst]->output.type != otype)
740a753bfcfSAlexander Shishkin continue;
741a753bfcfSAlexander Shishkin
742a753bfcfSAlexander Shishkin break;
743a753bfcfSAlexander Shishkin }
744a753bfcfSAlexander Shishkin
745a753bfcfSAlexander Shishkin /*
746a753bfcfSAlexander Shishkin * intel_th_subdevices[src] matches our requirements and is
747a753bfcfSAlexander Shishkin * not matched in th::thdev[]
748a753bfcfSAlexander Shishkin */
749a753bfcfSAlexander Shishkin if (dst == th->num_thdevs)
750a753bfcfSAlexander Shishkin goto found;
751a753bfcfSAlexander Shishkin }
752a753bfcfSAlexander Shishkin
753a753bfcfSAlexander Shishkin return -ENODEV;
754a753bfcfSAlexander Shishkin
755a753bfcfSAlexander Shishkin found:
756a753bfcfSAlexander Shishkin thdev = intel_th_subdevice_alloc(th, &intel_th_subdevices[src]);
757a753bfcfSAlexander Shishkin if (IS_ERR(thdev))
758a753bfcfSAlexander Shishkin return PTR_ERR(thdev);
759a753bfcfSAlexander Shishkin
760a753bfcfSAlexander Shishkin th->thdev[th->num_thdevs++] = thdev;
761a753bfcfSAlexander Shishkin
762a753bfcfSAlexander Shishkin return 0;
763a753bfcfSAlexander Shishkin }
764a753bfcfSAlexander Shishkin EXPORT_SYMBOL_GPL(intel_th_output_enable);
765a753bfcfSAlexander Shishkin
intel_th_populate(struct intel_th * th)766a753bfcfSAlexander Shishkin static int intel_th_populate(struct intel_th *th)
767a753bfcfSAlexander Shishkin {
768a753bfcfSAlexander Shishkin int src;
769a753bfcfSAlexander Shishkin
770a753bfcfSAlexander Shishkin /* create devices for each intel_th_subdevice */
771a753bfcfSAlexander Shishkin for (src = 0; src < ARRAY_SIZE(intel_th_subdevices); src++) {
772a753bfcfSAlexander Shishkin const struct intel_th_subdevice *subdev =
773a753bfcfSAlexander Shishkin &intel_th_subdevices[src];
774a753bfcfSAlexander Shishkin struct intel_th_device *thdev;
775a753bfcfSAlexander Shishkin
776a753bfcfSAlexander Shishkin /* only allow SOURCE and SWITCH devices in host mode */
777282ffec5SAlexander Shishkin if ((INTEL_TH_CAP(th, host_mode_only) || host_mode) &&
778282ffec5SAlexander Shishkin subdev->type == INTEL_TH_OUTPUT)
779a753bfcfSAlexander Shishkin continue;
780a753bfcfSAlexander Shishkin
781a753bfcfSAlexander Shishkin /*
782a753bfcfSAlexander Shishkin * don't enable port OUTPUTs in this path; SWITCH enables them
783a753bfcfSAlexander Shishkin * via intel_th_output_enable()
784a753bfcfSAlexander Shishkin */
785a753bfcfSAlexander Shishkin if (subdev->type == INTEL_TH_OUTPUT &&
786a753bfcfSAlexander Shishkin subdev->otype != GTH_NONE)
787a753bfcfSAlexander Shishkin continue;
788a753bfcfSAlexander Shishkin
789a753bfcfSAlexander Shishkin thdev = intel_th_subdevice_alloc(th, subdev);
790a753bfcfSAlexander Shishkin /* note: caller should free subdevices from th::thdev[] */
79123f66749SAlexander Shishkin if (IS_ERR(thdev)) {
79223f66749SAlexander Shishkin /* ENODEV for individual subdevices is allowed */
79323f66749SAlexander Shishkin if (PTR_ERR(thdev) == -ENODEV)
79423f66749SAlexander Shishkin continue;
79523f66749SAlexander Shishkin
796a753bfcfSAlexander Shishkin return PTR_ERR(thdev);
79723f66749SAlexander Shishkin }
798a753bfcfSAlexander Shishkin
799a753bfcfSAlexander Shishkin th->thdev[th->num_thdevs++] = thdev;
80039f40346SAlexander Shishkin }
80139f40346SAlexander Shishkin
80239f40346SAlexander Shishkin return 0;
80339f40346SAlexander Shishkin }
80439f40346SAlexander Shishkin
intel_th_output_open(struct inode * inode,struct file * file)80539f40346SAlexander Shishkin static int intel_th_output_open(struct inode *inode, struct file *file)
80639f40346SAlexander Shishkin {
80739f40346SAlexander Shishkin const struct file_operations *fops;
80839f40346SAlexander Shishkin struct intel_th_driver *thdrv;
80939f40346SAlexander Shishkin struct device *dev;
81039f40346SAlexander Shishkin int err;
81139f40346SAlexander Shishkin
8124495dfddSSuzuki K Poulose dev = bus_find_device_by_devt(&intel_th_bus, inode->i_rdev);
81339f40346SAlexander Shishkin if (!dev || !dev->driver)
81439f40346SAlexander Shishkin return -ENODEV;
81539f40346SAlexander Shishkin
81639f40346SAlexander Shishkin thdrv = to_intel_th_driver(dev->driver);
81739f40346SAlexander Shishkin fops = fops_get(thdrv->fops);
81839f40346SAlexander Shishkin if (!fops)
81939f40346SAlexander Shishkin return -ENODEV;
82039f40346SAlexander Shishkin
82139f40346SAlexander Shishkin replace_fops(file, fops);
82239f40346SAlexander Shishkin
82339f40346SAlexander Shishkin file->private_data = to_intel_th_device(dev);
82439f40346SAlexander Shishkin
82539f40346SAlexander Shishkin if (file->f_op->open) {
82639f40346SAlexander Shishkin err = file->f_op->open(inode, file);
82739f40346SAlexander Shishkin return err;
82839f40346SAlexander Shishkin }
82939f40346SAlexander Shishkin
83039f40346SAlexander Shishkin return 0;
83139f40346SAlexander Shishkin }
83239f40346SAlexander Shishkin
83339f40346SAlexander Shishkin static const struct file_operations intel_th_output_fops = {
83439f40346SAlexander Shishkin .open = intel_th_output_open,
83539f40346SAlexander Shishkin .llseek = noop_llseek,
83639f40346SAlexander Shishkin };
83739f40346SAlexander Shishkin
intel_th_irq(int irq,void * data)838aac8da65SAlexander Shishkin static irqreturn_t intel_th_irq(int irq, void *data)
839aac8da65SAlexander Shishkin {
840aac8da65SAlexander Shishkin struct intel_th *th = data;
841aac8da65SAlexander Shishkin irqreturn_t ret = IRQ_NONE;
842aac8da65SAlexander Shishkin struct intel_th_driver *d;
843aac8da65SAlexander Shishkin int i;
844aac8da65SAlexander Shishkin
845aac8da65SAlexander Shishkin for (i = 0; i < th->num_thdevs; i++) {
846aac8da65SAlexander Shishkin if (th->thdev[i]->type != INTEL_TH_OUTPUT)
847aac8da65SAlexander Shishkin continue;
848aac8da65SAlexander Shishkin
849aac8da65SAlexander Shishkin d = to_intel_th_driver(th->thdev[i]->dev.driver);
850aac8da65SAlexander Shishkin if (d && d->irq)
851aac8da65SAlexander Shishkin ret |= d->irq(th->thdev[i]);
852aac8da65SAlexander Shishkin }
853aac8da65SAlexander Shishkin
854aac8da65SAlexander Shishkin return ret;
855aac8da65SAlexander Shishkin }
856aac8da65SAlexander Shishkin
85739f40346SAlexander Shishkin /**
85839f40346SAlexander Shishkin * intel_th_alloc() - allocate a new Intel TH device and its subdevices
85939f40346SAlexander Shishkin * @dev: parent device
860db73a059SAlexander Shishkin * @devres: resources indexed by th_mmio_idx
86139f40346SAlexander Shishkin * @irq: irq number
86239f40346SAlexander Shishkin */
86339f40346SAlexander Shishkin struct intel_th *
intel_th_alloc(struct device * dev,const struct intel_th_drvdata * drvdata,struct resource * devres,unsigned int ndevres)864a525ed17SAlexander Shishkin intel_th_alloc(struct device *dev, const struct intel_th_drvdata *drvdata,
86562a59302SAlexander Shishkin struct resource *devres, unsigned int ndevres)
86639f40346SAlexander Shishkin {
86762a59302SAlexander Shishkin int err, r, nr_mmios = 0;
86839f40346SAlexander Shishkin struct intel_th *th;
869661b0df8SAlexander Shishkin
87039f40346SAlexander Shishkin th = kzalloc(sizeof(*th), GFP_KERNEL);
87139f40346SAlexander Shishkin if (!th)
87239f40346SAlexander Shishkin return ERR_PTR(-ENOMEM);
87339f40346SAlexander Shishkin
8740f373e6dSChristophe JAILLET th->id = ida_alloc(&intel_th_ida, GFP_KERNEL);
87539f40346SAlexander Shishkin if (th->id < 0) {
87639f40346SAlexander Shishkin err = th->id;
87739f40346SAlexander Shishkin goto err_alloc;
87839f40346SAlexander Shishkin }
87939f40346SAlexander Shishkin
88039f40346SAlexander Shishkin th->major = __register_chrdev(0, 0, TH_POSSIBLE_OUTPUTS,
88139f40346SAlexander Shishkin "intel_th/output", &intel_th_output_fops);
88239f40346SAlexander Shishkin if (th->major < 0) {
88339f40346SAlexander Shishkin err = th->major;
88439f40346SAlexander Shishkin goto err_ida;
88539f40346SAlexander Shishkin }
88662a59302SAlexander Shishkin th->irq = -1;
88739f40346SAlexander Shishkin th->dev = dev;
8883321371bSAlexander Shishkin th->drvdata = drvdata;
88939f40346SAlexander Shishkin
890db73a059SAlexander Shishkin for (r = 0; r < ndevres; r++)
89162a59302SAlexander Shishkin switch (devres[r].flags & IORESOURCE_TYPE_BITS) {
89262a59302SAlexander Shishkin case IORESOURCE_MEM:
89362a59302SAlexander Shishkin th->resource[nr_mmios++] = devres[r];
89462a59302SAlexander Shishkin break;
89562a59302SAlexander Shishkin case IORESOURCE_IRQ:
896aac8da65SAlexander Shishkin err = devm_request_irq(dev, devres[r].start,
897aac8da65SAlexander Shishkin intel_th_irq, IRQF_SHARED,
898aac8da65SAlexander Shishkin dev_name(dev), th);
899aac8da65SAlexander Shishkin if (err)
900aac8da65SAlexander Shishkin goto err_chrdev;
901aac8da65SAlexander Shishkin
90262a59302SAlexander Shishkin if (th->irq == -1)
90362a59302SAlexander Shishkin th->irq = devres[r].start;
904ab832e38SAlexander Shishkin th->num_irqs++;
90562a59302SAlexander Shishkin break;
90662a59302SAlexander Shishkin default:
90762a59302SAlexander Shishkin dev_warn(dev, "Unknown resource type %lx\n",
90862a59302SAlexander Shishkin devres[r].flags);
90962a59302SAlexander Shishkin break;
91062a59302SAlexander Shishkin }
91162a59302SAlexander Shishkin
91262a59302SAlexander Shishkin th->num_resources = nr_mmios;
913a753bfcfSAlexander Shishkin
914d7b17871SAlexander Shishkin dev_set_drvdata(dev, th);
915d7b17871SAlexander Shishkin
916142dfeb2SAlexander Shishkin pm_runtime_no_callbacks(dev);
917142dfeb2SAlexander Shishkin pm_runtime_put(dev);
918142dfeb2SAlexander Shishkin pm_runtime_allow(dev);
919142dfeb2SAlexander Shishkin
920a753bfcfSAlexander Shishkin err = intel_th_populate(th);
921a753bfcfSAlexander Shishkin if (err) {
922a753bfcfSAlexander Shishkin /* free the subdevices and undo everything */
923a753bfcfSAlexander Shishkin intel_th_free(th);
924a753bfcfSAlexander Shishkin return ERR_PTR(err);
925a753bfcfSAlexander Shishkin }
92639f40346SAlexander Shishkin
92739f40346SAlexander Shishkin return th;
92839f40346SAlexander Shishkin
929aac8da65SAlexander Shishkin err_chrdev:
930aac8da65SAlexander Shishkin __unregister_chrdev(th->major, 0, TH_POSSIBLE_OUTPUTS,
931aac8da65SAlexander Shishkin "intel_th/output");
932aac8da65SAlexander Shishkin
93339f40346SAlexander Shishkin err_ida:
9340f373e6dSChristophe JAILLET ida_free(&intel_th_ida, th->id);
93539f40346SAlexander Shishkin
93639f40346SAlexander Shishkin err_alloc:
93739f40346SAlexander Shishkin kfree(th);
93839f40346SAlexander Shishkin
93939f40346SAlexander Shishkin return ERR_PTR(err);
94039f40346SAlexander Shishkin }
94139f40346SAlexander Shishkin EXPORT_SYMBOL_GPL(intel_th_alloc);
94239f40346SAlexander Shishkin
intel_th_free(struct intel_th * th)94339f40346SAlexander Shishkin void intel_th_free(struct intel_th *th)
94439f40346SAlexander Shishkin {
94539f40346SAlexander Shishkin int i;
94639f40346SAlexander Shishkin
947a36aa80fSAlexander Shishkin intel_th_request_hub_module_flush(th);
94839f40346SAlexander Shishkin
94939f40346SAlexander Shishkin intel_th_device_remove(th->hub);
950a753bfcfSAlexander Shishkin for (i = 0; i < th->num_thdevs; i++) {
951a753bfcfSAlexander Shishkin if (th->thdev[i] != th->hub)
952a753bfcfSAlexander Shishkin intel_th_device_remove(th->thdev[i]);
953a753bfcfSAlexander Shishkin th->thdev[i] = NULL;
954a753bfcfSAlexander Shishkin }
955a753bfcfSAlexander Shishkin
956a753bfcfSAlexander Shishkin th->num_thdevs = 0;
95739f40346SAlexander Shishkin
958ab832e38SAlexander Shishkin for (i = 0; i < th->num_irqs; i++)
959ab832e38SAlexander Shishkin devm_free_irq(th->dev, th->irq + i, th);
960ab832e38SAlexander Shishkin
961142dfeb2SAlexander Shishkin pm_runtime_get_sync(th->dev);
962142dfeb2SAlexander Shishkin pm_runtime_forbid(th->dev);
963142dfeb2SAlexander Shishkin
96439f40346SAlexander Shishkin __unregister_chrdev(th->major, 0, TH_POSSIBLE_OUTPUTS,
96539f40346SAlexander Shishkin "intel_th/output");
96639f40346SAlexander Shishkin
9670f373e6dSChristophe JAILLET ida_free(&intel_th_ida, th->id);
96839f40346SAlexander Shishkin
96939f40346SAlexander Shishkin kfree(th);
97039f40346SAlexander Shishkin }
97139f40346SAlexander Shishkin EXPORT_SYMBOL_GPL(intel_th_free);
97239f40346SAlexander Shishkin
97339f40346SAlexander Shishkin /**
97439f40346SAlexander Shishkin * intel_th_trace_enable() - enable tracing for an output device
97539f40346SAlexander Shishkin * @thdev: output device that requests tracing be enabled
97639f40346SAlexander Shishkin */
intel_th_trace_enable(struct intel_th_device * thdev)97739f40346SAlexander Shishkin int intel_th_trace_enable(struct intel_th_device *thdev)
97839f40346SAlexander Shishkin {
97939f40346SAlexander Shishkin struct intel_th_device *hub = to_intel_th_device(thdev->dev.parent);
98039f40346SAlexander Shishkin struct intel_th_driver *hubdrv = to_intel_th_driver(hub->dev.driver);
98139f40346SAlexander Shishkin
98239f40346SAlexander Shishkin if (WARN_ON_ONCE(hub->type != INTEL_TH_SWITCH))
98339f40346SAlexander Shishkin return -EINVAL;
98439f40346SAlexander Shishkin
98539f40346SAlexander Shishkin if (WARN_ON_ONCE(thdev->type != INTEL_TH_OUTPUT))
98639f40346SAlexander Shishkin return -EINVAL;
98739f40346SAlexander Shishkin
988142dfeb2SAlexander Shishkin pm_runtime_get_sync(&thdev->dev);
98939f40346SAlexander Shishkin hubdrv->enable(hub, &thdev->output);
99039f40346SAlexander Shishkin
99139f40346SAlexander Shishkin return 0;
99239f40346SAlexander Shishkin }
99339f40346SAlexander Shishkin EXPORT_SYMBOL_GPL(intel_th_trace_enable);
99439f40346SAlexander Shishkin
99539f40346SAlexander Shishkin /**
9968116db57SAlexander Shishkin * intel_th_trace_switch() - execute a switch sequence
9978116db57SAlexander Shishkin * @thdev: output device that requests tracing switch
9988116db57SAlexander Shishkin */
intel_th_trace_switch(struct intel_th_device * thdev)9998116db57SAlexander Shishkin int intel_th_trace_switch(struct intel_th_device *thdev)
10008116db57SAlexander Shishkin {
10018116db57SAlexander Shishkin struct intel_th_device *hub = to_intel_th_device(thdev->dev.parent);
10028116db57SAlexander Shishkin struct intel_th_driver *hubdrv = to_intel_th_driver(hub->dev.driver);
10038116db57SAlexander Shishkin
10048116db57SAlexander Shishkin if (WARN_ON_ONCE(hub->type != INTEL_TH_SWITCH))
10058116db57SAlexander Shishkin return -EINVAL;
10068116db57SAlexander Shishkin
10078116db57SAlexander Shishkin if (WARN_ON_ONCE(thdev->type != INTEL_TH_OUTPUT))
10088116db57SAlexander Shishkin return -EINVAL;
10098116db57SAlexander Shishkin
10108116db57SAlexander Shishkin hubdrv->trig_switch(hub, &thdev->output);
10118116db57SAlexander Shishkin
10128116db57SAlexander Shishkin return 0;
10138116db57SAlexander Shishkin }
10148116db57SAlexander Shishkin EXPORT_SYMBOL_GPL(intel_th_trace_switch);
10158116db57SAlexander Shishkin
10168116db57SAlexander Shishkin /**
101739f40346SAlexander Shishkin * intel_th_trace_disable() - disable tracing for an output device
101839f40346SAlexander Shishkin * @thdev: output device that requests tracing be disabled
101939f40346SAlexander Shishkin */
intel_th_trace_disable(struct intel_th_device * thdev)102039f40346SAlexander Shishkin int intel_th_trace_disable(struct intel_th_device *thdev)
102139f40346SAlexander Shishkin {
102239f40346SAlexander Shishkin struct intel_th_device *hub = to_intel_th_device(thdev->dev.parent);
102339f40346SAlexander Shishkin struct intel_th_driver *hubdrv = to_intel_th_driver(hub->dev.driver);
102439f40346SAlexander Shishkin
102539f40346SAlexander Shishkin WARN_ON_ONCE(hub->type != INTEL_TH_SWITCH);
102639f40346SAlexander Shishkin if (WARN_ON_ONCE(thdev->type != INTEL_TH_OUTPUT))
102739f40346SAlexander Shishkin return -EINVAL;
102839f40346SAlexander Shishkin
102939f40346SAlexander Shishkin hubdrv->disable(hub, &thdev->output);
1030142dfeb2SAlexander Shishkin pm_runtime_put(&thdev->dev);
103139f40346SAlexander Shishkin
103239f40346SAlexander Shishkin return 0;
103339f40346SAlexander Shishkin }
103439f40346SAlexander Shishkin EXPORT_SYMBOL_GPL(intel_th_trace_disable);
103539f40346SAlexander Shishkin
intel_th_set_output(struct intel_th_device * thdev,unsigned int master)103639f40346SAlexander Shishkin int intel_th_set_output(struct intel_th_device *thdev,
103739f40346SAlexander Shishkin unsigned int master)
103839f40346SAlexander Shishkin {
10399ad57708SAlexander Shishkin struct intel_th_device *hub = to_intel_th_hub(thdev);
104039f40346SAlexander Shishkin struct intel_th_driver *hubdrv = to_intel_th_driver(hub->dev.driver);
1041e78e1fdbSAlexander Shishkin int ret;
104239f40346SAlexander Shishkin
1043c2d2c7deSAlexander Shishkin /* In host mode, this is up to the external debugger, do nothing. */
1044c2d2c7deSAlexander Shishkin if (hub->host_mode)
1045c2d2c7deSAlexander Shishkin return 0;
1046c2d2c7deSAlexander Shishkin
1047e78e1fdbSAlexander Shishkin /*
1048e78e1fdbSAlexander Shishkin * hub is instantiated together with the source device that
1049e78e1fdbSAlexander Shishkin * calls here, so guaranteed to be present.
1050e78e1fdbSAlexander Shishkin */
1051e78e1fdbSAlexander Shishkin hubdrv = to_intel_th_driver(hub->dev.driver);
1052e78e1fdbSAlexander Shishkin if (!hubdrv || !try_module_get(hubdrv->driver.owner))
1053e78e1fdbSAlexander Shishkin return -EINVAL;
105439f40346SAlexander Shishkin
1055e78e1fdbSAlexander Shishkin if (!hubdrv->set_output) {
1056e78e1fdbSAlexander Shishkin ret = -ENOTSUPP;
1057e78e1fdbSAlexander Shishkin goto out;
1058e78e1fdbSAlexander Shishkin }
1059e78e1fdbSAlexander Shishkin
1060e78e1fdbSAlexander Shishkin ret = hubdrv->set_output(hub, master);
1061e78e1fdbSAlexander Shishkin
1062e78e1fdbSAlexander Shishkin out:
1063e78e1fdbSAlexander Shishkin module_put(hubdrv->driver.owner);
1064e78e1fdbSAlexander Shishkin return ret;
106539f40346SAlexander Shishkin }
106639f40346SAlexander Shishkin EXPORT_SYMBOL_GPL(intel_th_set_output);
106739f40346SAlexander Shishkin
intel_th_init(void)106839f40346SAlexander Shishkin static int __init intel_th_init(void)
106939f40346SAlexander Shishkin {
107039f40346SAlexander Shishkin intel_th_debug_init();
107139f40346SAlexander Shishkin
107239f40346SAlexander Shishkin return bus_register(&intel_th_bus);
107339f40346SAlexander Shishkin }
107439f40346SAlexander Shishkin subsys_initcall(intel_th_init);
107539f40346SAlexander Shishkin
intel_th_exit(void)107639f40346SAlexander Shishkin static void __exit intel_th_exit(void)
107739f40346SAlexander Shishkin {
107839f40346SAlexander Shishkin intel_th_debug_done();
107939f40346SAlexander Shishkin
108039f40346SAlexander Shishkin bus_unregister(&intel_th_bus);
108139f40346SAlexander Shishkin }
108239f40346SAlexander Shishkin module_exit(intel_th_exit);
108339f40346SAlexander Shishkin
108439f40346SAlexander Shishkin MODULE_LICENSE("GPL v2");
108539f40346SAlexander Shishkin MODULE_DESCRIPTION("Intel(R) Trace Hub controller driver");
108639f40346SAlexander Shishkin MODULE_AUTHOR("Alexander Shishkin <alexander.shishkin@linux.intel.com>");
1087