drivers/hwtracing/coresight/coresight.c

   1 /* Copyright (c) 2012, The Linux Foundation. All rights reserved.
   2  *
   3  * This program is free software; you can redistribute it and/or modify
   4  * it under the terms of the GNU General Public License version 2 and
   5  * only version 2 as published by the Free Software Foundation.
   6  *
   7  * This program is distributed in the hope that it will be useful,
   8  * but WITHOUT ANY WARRANTY; without even the implied warranty of
   9  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  10  * GNU General Public License for more details.
  11  */
  12
  13 #include <linux/kernel.h>
  14 #include <linux/module.h>
  15 #include <linux/init.h>
  16 #include <linux/types.h>
  17 #include <linux/device.h>
  18 #include <linux/io.h>
  19 #include <linux/err.h>
  20 #include <linux/export.h>
  21 #include <linux/slab.h>
  22 #include <linux/mutex.h>
  23 #include <linux/clk.h>
  24 #include <linux/coresight.h>
  25 #include <linux/of_platform.h>
  26 #include <linux/delay.h>
  27
  28 #include "coresight-priv.h"
  29
  30 static DEFINE_MUTEX(coresight_mutex);
  31
  32 /**
  33  * struct coresight_node - elements of a path, from source to sink
  34  * @csdev:      Address of an element.
  35  * @link:       hook to the list.
  36  */
  37 struct coresight_node {
  38         struct coresight_device *csdev;
  39         struct list_head link;
  40 };
  41
  42 /*
  43  * When operating Coresight drivers from the sysFS interface, only a single
  44  * path can exist from a tracer (associated to a CPU) to a sink.
  45  */
  46 static DEFINE_PER_CPU(struct list_head *, sysfs_path);
  47
  48 static int coresight_id_match(struct device *dev, void *data)
  49 {
  50         int trace_id, i_trace_id;
  51         struct coresight_device *csdev, *i_csdev;
  52
  53         csdev = data;
  54         i_csdev = to_coresight_device(dev);
  55
  56         /*
  57          * No need to care about oneself and components that are not
  58          * sources or not enabled
  59          */
  60         if (i_csdev == csdev || !i_csdev->enable ||
  61             i_csdev->type != CORESIGHT_DEV_TYPE_SOURCE)
  62                 return 0;
  63
  64         /* Get the source ID for both compoment */
  65         trace_id = source_ops(csdev)->trace_id(csdev);
  66         i_trace_id = source_ops(i_csdev)->trace_id(i_csdev);
  67
  68         /* All you need is one */
  69         if (trace_id == i_trace_id)
  70                 return 1;
  71
  72         return 0;
  73 }
  74
  75 static int coresight_source_is_unique(struct coresight_device *csdev)
  76 {
  77         int trace_id = source_ops(csdev)->trace_id(csdev);
  78
  79         /* this shouldn't happen */
  80         if (trace_id < 0)
  81                 return 0;
  82
  83         return !bus_for_each_dev(&coresight_bustype, NULL,
  84                                  csdev, coresight_id_match);
  85 }
  86
  87 static int coresight_find_link_inport(struct coresight_device *csdev,
  88                                       struct coresight_device *parent)
  89 {
  90         int i;
  91         struct coresight_connection *conn;
  92
  93         for (i = 0; i < parent->nr_outport; i++) {
  94                 conn = &parent->conns[i];
  95                 if (conn->child_dev == csdev)
  96                         return conn->child_port;
  97         }
  98
  99         dev_err(&csdev->dev, "couldn't find inport, parent: %s, child: %s\n",
 100                 dev_name(&parent->dev), dev_name(&csdev->dev));
 101
 102         return 0;
 103 }
 104
 105 static int coresight_find_link_outport(struct coresight_device *csdev,
 106                                        struct coresight_device *child)
 107 {
 108         int i;
 109         struct coresight_connection *conn;
 110
 111         for (i = 0; i < csdev->nr_outport; i++) {
 112                 conn = &csdev->conns[i];
 113                 if (conn->child_dev == child)
 114                         return conn->outport;
 115         }
 116
 117         dev_err(&csdev->dev, "couldn't find outport, parent: %s, child: %s\n",
 118                 dev_name(&csdev->dev), dev_name(&child->dev));
 119
 120         return 0;
 121 }
 122
 123 static int coresight_enable_sink(struct coresight_device *csdev)
 124 {
 125         int ret;
 126
 127         if (!csdev->enable) {
 128                 if (sink_ops(csdev)->enable) {
 129                         ret = sink_ops(csdev)->enable(csdev);
 130                         if (ret)
 131                                 return ret;
 132                 }
 133                 csdev->enable = true;
 134         }
 135
 136         atomic_inc(csdev->refcnt);
 137
 138         return 0;
 139 }
 140
 141 static void coresight_disable_sink(struct coresight_device *csdev)
 142 {
 143         if (atomic_dec_return(csdev->refcnt) == 0) {
 144                 if (sink_ops(csdev)->disable) {
 145                         sink_ops(csdev)->disable(csdev);
 146                         csdev->enable = false;
 147                 }
 148         }
 149 }
 150
 151 static int coresight_enable_link(struct coresight_device *csdev,
 152                                  struct coresight_device *parent,
 153                                  struct coresight_device *child)
 154 {
 155         int ret;
 156         int link_subtype;
 157         int refport, inport, outport;
 158
 159         if (!parent || !child)
 160                 return -EINVAL;
 161
 162         inport = coresight_find_link_inport(csdev, parent);
 163         outport = coresight_find_link_outport(csdev, child);
 164         link_subtype = csdev->subtype.link_subtype;
 165
 166         if (link_subtype == CORESIGHT_DEV_SUBTYPE_LINK_MERG)
 167                 refport = inport;
 168         else if (link_subtype == CORESIGHT_DEV_SUBTYPE_LINK_SPLIT)
 169                 refport = outport;
 170         else
 171                 refport = 0;
 172
 173         if (atomic_inc_return(&csdev->refcnt[refport]) == 1) {
 174                 if (link_ops(csdev)->enable) {
 175                         ret = link_ops(csdev)->enable(csdev, inport, outport);
 176                         if (ret)
 177                                 return ret;
 178                 }
 179         }
 180
 181         csdev->enable = true;
 182
 183         return 0;
 184 }
 185
 186 static void coresight_disable_link(struct coresight_device *csdev,
 187                                    struct coresight_device *parent,
 188                                    struct coresight_device *child)
 189 {
 190         int i, nr_conns;
 191         int link_subtype;
 192         int refport, inport, outport;
 193
 194         if (!parent || !child)
 195                 return;
 196
 197         inport = coresight_find_link_inport(csdev, parent);
 198         outport = coresight_find_link_outport(csdev, child);
 199         link_subtype = csdev->subtype.link_subtype;
 200
 201         if (link_subtype == CORESIGHT_DEV_SUBTYPE_LINK_MERG) {
 202                 refport = inport;
 203                 nr_conns = csdev->nr_inport;
 204         } else if (link_subtype == CORESIGHT_DEV_SUBTYPE_LINK_SPLIT) {
 205                 refport = outport;
 206                 nr_conns = csdev->nr_outport;
 207         } else {
 208                 refport = 0;
 209                 nr_conns = 1;
 210         }
 211
 212         if (atomic_dec_return(&csdev->refcnt[refport]) == 0) {
 213                 if (link_ops(csdev)->disable)
 214                         link_ops(csdev)->disable(csdev, inport, outport);
 215         }
 216
 217         for (i = 0; i < nr_conns; i++)
 218                 if (atomic_read(&csdev->refcnt[i]) != 0)
 219                         return;
 220
 221         csdev->enable = false;
 222 }
 223
 224 static int coresight_enable_source(struct coresight_device *csdev)
 225 {
 226         int ret;
 227
 228         if (!coresight_source_is_unique(csdev)) {
 229                 dev_warn(&csdev->dev, "traceID %d not unique\n",
 230                          source_ops(csdev)->trace_id(csdev));
 231                 return -EINVAL;
 232         }
 233
 234         if (!csdev->enable) {
 235                 if (source_ops(csdev)->enable) {
 236                         ret = source_ops(csdev)->enable(csdev);
 237                         if (ret)
 238                                 return ret;
 239                 }
 240                 csdev->enable = true;
 241         }
 242
 243         atomic_inc(csdev->refcnt);
 244
 245         return 0;
 246 }
 247
 248 static void coresight_disable_source(struct coresight_device *csdev)
 249 {
 250         if (atomic_dec_return(csdev->refcnt) == 0) {
 251                 if (source_ops(csdev)->disable) {
 252                         source_ops(csdev)->disable(csdev);
 253                         csdev->enable = false;
 254                 }
 255         }
 256 }
 257
 258 void coresight_disable_path(struct list_head *path)
 259 {
 260         struct coresight_node *nd;
 261         struct coresight_device *csdev, *parent, *child;
 262
 263         list_for_each_entry(nd, path, link) {
 264                 csdev = nd->csdev;
 265
 266                 switch (csdev->type) {
 267                 case CORESIGHT_DEV_TYPE_SINK:
 268                 case CORESIGHT_DEV_TYPE_LINKSINK:
 269                         coresight_disable_sink(csdev);
 270                         break;
 271                 case CORESIGHT_DEV_TYPE_SOURCE:
 272                         /* sources are disabled from either sysFS or Perf */
 273                         break;
 274                 case CORESIGHT_DEV_TYPE_LINK:
 275                         parent = list_prev_entry(nd, link)->csdev;
 276                         child = list_next_entry(nd, link)->csdev;
 277                         coresight_disable_link(csdev, parent, child);
 278                         break;
 279                 default:
 280                         break;
 281                 }
 282         }
 283 }
 284
 285 int coresight_enable_path(struct list_head *path)
 286 {
 287
 288         int ret = 0;
 289         struct coresight_node *nd;
 290         struct coresight_device *csdev, *parent, *child;
 291
 292         list_for_each_entry_reverse(nd, path, link) {
 293                 csdev = nd->csdev;
 294
 295                 switch (csdev->type) {
 296                 case CORESIGHT_DEV_TYPE_SINK:
 297                 case CORESIGHT_DEV_TYPE_LINKSINK:
 298                         ret = coresight_enable_sink(csdev);
 299                         if (ret)
 300                                 goto err;
 301                         break;
 302                 case CORESIGHT_DEV_TYPE_SOURCE:
 303                         /* sources are enabled from either sysFS or Perf */
 304                         break;
 305                 case CORESIGHT_DEV_TYPE_LINK:
 306                         parent = list_prev_entry(nd, link)->csdev;
 307                         child = list_next_entry(nd, link)->csdev;
 308                         ret = coresight_enable_link(csdev, parent, child);
 309                         if (ret)
 310                                 goto err;
 311                         break;
 312                 default:
 313                         goto err;
 314                 }
 315         }
 316
 317 out:
 318         return ret;
 319 err:
 320         coresight_disable_path(path);
 321         goto out;
 322 }
 323
 324 /**
 325  * _coresight_build_path - recursively build a path from a @csdev to a sink.
 326  * @csdev:      The device to start from.
 327  * @path:       The list to add devices to.
 328  *
 329  * The tree of Coresight device is traversed until an activated sink is
 330  * found.  From there the sink is added to the list along with all the
 331  * devices that led to that point - the end result is a list from source
 332  * to sink. In that list the source is the first device and the sink the
 333  * last one.
 334  */
 335 static int _coresight_build_path(struct coresight_device *csdev,
 336                                  struct list_head *path)
 337 {
 338         int i;
 339         bool found = false;
 340         struct coresight_node *node;
 341         struct coresight_connection *conn;
 342
 343         /* An activated sink has been found.  Enqueue the element */
 344         if ((csdev->type == CORESIGHT_DEV_TYPE_SINK ||
 345              csdev->type == CORESIGHT_DEV_TYPE_LINKSINK) && csdev->activated)
 346                 goto out;
 347
 348         /* Not a sink - recursively explore each port found on this element */
 349         for (i = 0; i < csdev->nr_outport; i++) {
 350                 conn = &csdev->conns[i];
 351                 if (_coresight_build_path(conn->child_dev, path) == 0) {
 352                         found = true;
 353                         break;
 354                 }
 355         }
 356
 357         if (!found)
 358                 return -ENODEV;
 359
 360 out:
 361         /*
 362          * A path from this element to a sink has been found.  The elements
 363          * leading to the sink are already enqueued, all that is left to do
 364          * is add a node for this element.
 365          */
 366         node = kzalloc(sizeof(struct coresight_node), GFP_KERNEL);
 367         if (!node)
 368                 return -ENOMEM;
 369
 370         node->csdev = csdev;
 371         list_add(&node->link, path);
 372
 373         return 0;
 374 }
 375
 376 struct list_head *coresight_build_path(struct coresight_device *csdev)
 377 {
 378         struct list_head *path;
 379
 380         path = kzalloc(sizeof(struct list_head), GFP_KERNEL);
 381         if (!path)
 382                 return NULL;
 383
 384         INIT_LIST_HEAD(path);
 385
 386         if (_coresight_build_path(csdev, path)) {
 387                 kfree(path);
 388                 path = NULL;
 389         }
 390
 391         return path;
 392 }
 393
 394 /**
 395  * coresight_release_path - release a previously built path.
 396  * @path:       the path to release.
 397  *
 398  * Go through all the elements of a path and 1) removed it from the list and
 399  * 2) free the memory allocated for each node.
 400  */
 401 void coresight_release_path(struct list_head *path)
 402 {
 403         struct coresight_node *nd, *next;
 404
 405         list_for_each_entry_safe(nd, next, path, link) {
 406                 list_del(&nd->link);
 407                 kfree(nd);
 408         }
 409
 410         kfree(path);
 411         path = NULL;
 412 }
 413
 414 int coresight_enable(struct coresight_device *csdev)
 415 {
 416         int ret = 0;
 417         int cpu;
 418         struct list_head *path;
 419
 420         mutex_lock(&coresight_mutex);
 421         if (csdev->type != CORESIGHT_DEV_TYPE_SOURCE) {
 422                 ret = -EINVAL;
 423                 dev_err(&csdev->dev, "wrong device type in %s\n", __func__);
 424                 goto out;
 425         }
 426         if (csdev->enable)
 427                 goto out;
 428
 429         path = coresight_build_path(csdev);
 430         if (!path) {
 431                 pr_err("building path(s) failed\n");
 432                 goto out;
 433         }
 434
 435         ret = coresight_enable_path(path);
 436         if (ret)
 437                 goto err_path;
 438
 439         ret = coresight_enable_source(csdev);
 440         if (ret)
 441                 goto err_source;
 442
 443         /*
 444          * When working from sysFS it is important to keep track
 445          * of the paths that were created so that they can be
 446          * undone in 'coresight_disable()'.  Since there can only
 447          * be a single session per tracer (when working from sysFS)
 448          * a per-cpu variable will do just fine.
 449          */
 450         cpu = source_ops(csdev)->cpu_id(csdev);
 451         per_cpu(sysfs_path, cpu) = path;
 452
 453 out:
 454         mutex_unlock(&coresight_mutex);
 455         return ret;
 456
 457 err_source:
 458         coresight_disable_path(path);
 459
 460 err_path:
 461         coresight_release_path(path);
 462         goto out;
 463 }
 464 EXPORT_SYMBOL_GPL(coresight_enable);
 465
 466 void coresight_disable(struct coresight_device *csdev)
 467 {
 468         int cpu;
 469         struct list_head *path;
 470
 471         mutex_lock(&coresight_mutex);
 472         if (csdev->type != CORESIGHT_DEV_TYPE_SOURCE) {
 473                 dev_err(&csdev->dev, "wrong device type in %s\n", __func__);
 474                 goto out;
 475         }
 476         if (!csdev->enable)
 477                 goto out;
 478
 479         cpu = source_ops(csdev)->cpu_id(csdev);
 480         path = per_cpu(sysfs_path, cpu);
 481         coresight_disable_source(csdev);
 482         coresight_disable_path(path);
 483         coresight_release_path(path);
 484         per_cpu(sysfs_path, cpu) = NULL;
 485
 486 out:
 487         mutex_unlock(&coresight_mutex);
 488 }
 489 EXPORT_SYMBOL_GPL(coresight_disable);
 490
 491 static ssize_t enable_sink_show(struct device *dev,
 492                                 struct device_attribute *attr, char *buf)
 493 {
 494         struct coresight_device *csdev = to_coresight_device(dev);
 495
 496         return scnprintf(buf, PAGE_SIZE, "%u\n", (unsigned)csdev->activated);
 497 }
 498
 499 static ssize_t enable_sink_store(struct device *dev,
 500                                  struct device_attribute *attr,
 501                                  const char *buf, size_t size)
 502 {
 503         int ret;
 504         unsigned long val;
 505         struct coresight_device *csdev = to_coresight_device(dev);
 506
 507         ret = kstrtoul(buf, 10, &val);
 508         if (ret)
 509                 return ret;
 510
 511         if (val)
 512                 csdev->activated = true;
 513         else
 514                 csdev->activated = false;
 515
 516         return size;
 517
 518 }
 519 static DEVICE_ATTR_RW(enable_sink);
 520
 521 static ssize_t enable_source_show(struct device *dev,
 522                                   struct device_attribute *attr, char *buf)
 523 {
 524         struct coresight_device *csdev = to_coresight_device(dev);
 525
 526         return scnprintf(buf, PAGE_SIZE, "%u\n", (unsigned)csdev->enable);
 527 }
 528
 529 static ssize_t enable_source_store(struct device *dev,
 530                                    struct device_attribute *attr,
 531                                    const char *buf, size_t size)
 532 {
 533         int ret = 0;
 534         unsigned long val;
 535         struct coresight_device *csdev = to_coresight_device(dev);
 536
 537         ret = kstrtoul(buf, 10, &val);
 538         if (ret)
 539                 return ret;
 540
 541         if (val) {
 542                 ret = coresight_enable(csdev);
 543                 if (ret)
 544                         return ret;
 545         } else {
 546                 coresight_disable(csdev);
 547         }
 548
 549         return size;
 550 }
 551 static DEVICE_ATTR_RW(enable_source);
 552
 553 static struct attribute *coresight_sink_attrs[] = {
 554         &dev_attr_enable_sink.attr,
 555         NULL,
 556 };
 557 ATTRIBUTE_GROUPS(coresight_sink);
 558
 559 static struct attribute *coresight_source_attrs[] = {
 560         &dev_attr_enable_source.attr,
 561         NULL,
 562 };
 563 ATTRIBUTE_GROUPS(coresight_source);
 564
 565 static struct device_type coresight_dev_type[] = {
 566         {
 567                 .name = "none",
 568         },
 569         {
 570                 .name = "sink",
 571                 .groups = coresight_sink_groups,
 572         },
 573         {
 574                 .name = "link",
 575         },
 576         {
 577                 .name = "linksink",
 578                 .groups = coresight_sink_groups,
 579         },
 580         {
 581                 .name = "source",
 582                 .groups = coresight_source_groups,
 583         },
 584 };
 585
 586 static void coresight_device_release(struct device *dev)
 587 {
 588         struct coresight_device *csdev = to_coresight_device(dev);
 589
 590         kfree(csdev->conns);
 591         kfree(csdev->refcnt);
 592         kfree(csdev);
 593 }
 594
 595 static int coresight_orphan_match(struct device *dev, void *data)
 596 {
 597         int i;
 598         bool still_orphan = false;
 599         struct coresight_device *csdev, *i_csdev;
 600         struct coresight_connection *conn;
 601
 602         csdev = data;
 603         i_csdev = to_coresight_device(dev);
 604
 605         /* No need to check oneself */
 606         if (csdev == i_csdev)
 607                 return 0;
 608
 609         /* Move on to another component if no connection is orphan */
 610         if (!i_csdev->orphan)
 611                 return 0;
 612         /*
 613          * Circle throuch all the connection of that component.  If we find
 614          * an orphan connection whose name matches @csdev, link it.
 615          */
 616         for (i = 0; i < i_csdev->nr_outport; i++) {
 617                 conn = &i_csdev->conns[i];
 618
 619                 /* We have found at least one orphan connection */
 620                 if (conn->child_dev == NULL) {
 621                         /* Does it match this newly added device? */
 622                         if (!strcmp(dev_name(&csdev->dev), conn->child_name)) {
 623                                 conn->child_dev = csdev;
 624                         } else {
 625                                 /* This component still has an orphan */
 626                                 still_orphan = true;
 627                         }
 628                 }
 629         }
 630
 631         i_csdev->orphan = still_orphan;
 632
 633         /*
 634          * Returning '0' ensures that all known component on the
 635          * bus will be checked.
 636          */
 637         return 0;
 638 }
 639
 640 static void coresight_fixup_orphan_conns(struct coresight_device *csdev)
 641 {
 642         /*
 643          * No need to check for a return value as orphan connection(s)
 644          * are hooked-up with each newly added component.
 645          */
 646         bus_for_each_dev(&coresight_bustype, NULL,
 647                          csdev, coresight_orphan_match);
 648 }
 649
 650
 651 static int coresight_name_match(struct device *dev, void *data)
 652 {
 653         char *to_match;
 654         struct coresight_device *i_csdev;
 655
 656         to_match = data;
 657         i_csdev = to_coresight_device(dev);
 658
 659         if (to_match && !strcmp(to_match, dev_name(&i_csdev->dev)))
 660                 return 1;
 661
 662         return 0;
 663 }
 664
 665 static void coresight_fixup_device_conns(struct coresight_device *csdev)
 666 {
 667         int i;
 668         struct device *dev = NULL;
 669         struct coresight_connection *conn;
 670
 671         for (i = 0; i < csdev->nr_outport; i++) {
 672                 conn = &csdev->conns[i];
 673                 dev = bus_find_device(&coresight_bustype, NULL,
 674                                       (void *)conn->child_name,
 675                                       coresight_name_match);
 676
 677                 if (dev) {
 678                         conn->child_dev = to_coresight_device(dev);
 679                         /* and put reference from 'bus_find_device()' */
 680                         put_device(dev);
 681                 } else {
 682                         csdev->orphan = true;
 683                         conn->child_dev = NULL;
 684                 }
 685         }
 686 }
 687
 688 static int coresight_remove_match(struct device *dev, void *data)
 689 {
 690         int i;
 691         struct coresight_device *csdev, *iterator;
 692         struct coresight_connection *conn;
 693
 694         csdev = data;
 695         iterator = to_coresight_device(dev);
 696
 697         /* No need to check oneself */
 698         if (csdev == iterator)
 699                 return 0;
 700
 701         /*
 702          * Circle throuch all the connection of that component.  If we find
 703          * a connection whose name matches @csdev, remove it.
 704          */
 705         for (i = 0; i < iterator->nr_outport; i++) {
 706                 conn = &iterator->conns[i];
 707
 708                 if (conn->child_dev == NULL)
 709                         continue;
 710
 711                 if (!strcmp(dev_name(&csdev->dev), conn->child_name)) {
 712                         iterator->orphan = true;
 713                         conn->child_dev = NULL;
 714                         /* No need to continue */
 715                         break;
 716                 }
 717         }
 718
 719         /*
 720          * Returning '0' ensures that all known component on the
 721          * bus will be checked.
 722          */
 723         return 0;
 724 }
 725
 726 static void coresight_remove_conns(struct coresight_device *csdev)
 727 {
 728         bus_for_each_dev(&coresight_bustype, NULL,
 729                          csdev, coresight_remove_match);
 730 }
 731
 732 /**
 733  * coresight_timeout - loop until a bit has changed to a specific state.
 734  * @addr: base address of the area of interest.
 735  * @offset: address of a register, starting from @addr.
 736  * @position: the position of the bit of interest.
 737  * @value: the value the bit should have.
 738  *
 739  * Return: 0 as soon as the bit has taken the desired state or -EAGAIN if
 740  * TIMEOUT_US has elapsed, which ever happens first.
 741  */
 742
 743 int coresight_timeout(void __iomem *addr, u32 offset, int position, int value)
 744 {
 745         int i;
 746         u32 val;
 747
 748         for (i = TIMEOUT_US; i > 0; i--) {
 749                 val = __raw_readl(addr + offset);
 750                 /* waiting on the bit to go from 0 to 1 */
 751                 if (value) {
 752                         if (val & BIT(position))
 753                                 return 0;
 754                 /* waiting on the bit to go from 1 to 0 */
 755                 } else {
 756                         if (!(val & BIT(position)))
 757                                 return 0;
 758                 }
 759
 760                 /*
 761                  * Delay is arbitrary - the specification doesn't say how long
 762                  * we are expected to wait.  Extra check required to make sure
 763                  * we don't wait needlessly on the last iteration.
 764                  */
 765                 if (i - 1)
 766                         udelay(1);
 767         }
 768
 769         return -EAGAIN;
 770 }
 771
 772 struct bus_type coresight_bustype = {
 773         .name   = "coresight",
 774 };
 775
 776 static int __init coresight_init(void)
 777 {
 778         return bus_register(&coresight_bustype);
 779 }
 780 postcore_initcall(coresight_init);
 781
 782 struct coresight_device *coresight_register(struct coresight_desc *desc)
 783 {
 784         int i;
 785         int ret;
 786         int link_subtype;
 787         int nr_refcnts = 1;
 788         atomic_t *refcnts = NULL;
 789         struct coresight_device *csdev;
 790         struct coresight_connection *conns;
 791
 792         csdev = kzalloc(sizeof(*csdev), GFP_KERNEL);
 793         if (!csdev) {
 794                 ret = -ENOMEM;
 795                 goto err_kzalloc_csdev;
 796         }
 797
 798         if (desc->type == CORESIGHT_DEV_TYPE_LINK ||
 799             desc->type == CORESIGHT_DEV_TYPE_LINKSINK) {
 800                 link_subtype = desc->subtype.link_subtype;
 801
 802                 if (link_subtype == CORESIGHT_DEV_SUBTYPE_LINK_MERG)
 803                         nr_refcnts = desc->pdata->nr_inport;
 804                 else if (link_subtype == CORESIGHT_DEV_SUBTYPE_LINK_SPLIT)
 805                         nr_refcnts = desc->pdata->nr_outport;
 806         }
 807
 808         refcnts = kcalloc(nr_refcnts, sizeof(*refcnts), GFP_KERNEL);
 809         if (!refcnts) {
 810                 ret = -ENOMEM;
 811                 goto err_kzalloc_refcnts;
 812         }
 813
 814         csdev->refcnt = refcnts;
 815
 816         csdev->nr_inport = desc->pdata->nr_inport;
 817         csdev->nr_outport = desc->pdata->nr_outport;
 818         conns = kcalloc(csdev->nr_outport, sizeof(*conns), GFP_KERNEL);
 819         if (!conns) {
 820                 ret = -ENOMEM;
 821                 goto err_kzalloc_conns;
 822         }
 823
 824         for (i = 0; i < csdev->nr_outport; i++) {
 825                 conns[i].outport = desc->pdata->outports[i];
 826                 conns[i].child_name = desc->pdata->child_names[i];
 827                 conns[i].child_port = desc->pdata->child_ports[i];
 828         }
 829
 830         csdev->conns = conns;
 831
 832         csdev->type = desc->type;
 833         csdev->subtype = desc->subtype;
 834         csdev->ops = desc->ops;
 835         csdev->orphan = false;
 836
 837         csdev->dev.type = &coresight_dev_type[desc->type];
 838         csdev->dev.groups = desc->groups;
 839         csdev->dev.parent = desc->dev;
 840         csdev->dev.release = coresight_device_release;
 841         csdev->dev.bus = &coresight_bustype;
 842         dev_set_name(&csdev->dev, "%s", desc->pdata->name);
 843
 844         ret = device_register(&csdev->dev);
 845         if (ret)
 846                 goto err_device_register;
 847
 848         mutex_lock(&coresight_mutex);
 849
 850         coresight_fixup_device_conns(csdev);
 851         coresight_fixup_orphan_conns(csdev);
 852
 853         mutex_unlock(&coresight_mutex);
 854
 855         return csdev;
 856
 857 err_device_register:
 858         kfree(conns);
 859 err_kzalloc_conns:
 860         kfree(refcnts);
 861 err_kzalloc_refcnts:
 862         kfree(csdev);
 863 err_kzalloc_csdev:
 864         return ERR_PTR(ret);
 865 }
 866 EXPORT_SYMBOL_GPL(coresight_register);
 867
 868 void coresight_unregister(struct coresight_device *csdev)
 869 {
 870         /* Remove references of that device in the topology */
 871         coresight_remove_conns(csdev);
 872         device_unregister(&csdev->dev);
 873 }
 874 EXPORT_SYMBOL_GPL(coresight_unregister);
 875
 876 MODULE_LICENSE("GPL v2");