1087 lines · c
1// SPDX-License-Identifier: GPL-2.02/*3 * Intel(R) Trace Hub driver core4 *5 * Copyright (C) 2014-2015 Intel Corporation.6 */7 8#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt9 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 outputs110 *111 * intel_th_child_remove returns 0 unconditionally, so there is112 * 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 created118 * at hub's probe time by having the hub call119 * 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 the124 * th->thdev[] array to lower positions to maintain125 * 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 else199 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 else258 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 else288 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 else320 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 else381 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 else401 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 subdevices435 */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_MODULES584static 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#else605static 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 to641 * 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 type708 * @th: Intel TH instance709 * @otype: output type710 *711 * Go through the unallocated output devices, find the first one whos type712 * matches @otype and instantiate it. These devices are removed when the hub713 * 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 is747 * 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 them783 * 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 subdevices859 * @dev: parent device860 * @devres: resources indexed by th_mmio_idx861 * @irq: irq number862 */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 device975 * @thdev: output device that requests tracing be enabled976 */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 sequence997 * @thdev: output device that requests tracing switch998 */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 device1018 * @thdev: output device that requests tracing be disabled1019 */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 that1049 * 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>");1087