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