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