drivers/hwtracing/intel_th/core.c

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