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