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