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/init.h>
  15 #include <linux/types.h>
  16 #include <linux/device.h>
  17 #include <linux/io.h>
  18 #include <linux/err.h>
  19 #include <linux/export.h>
  20 #include <linux/slab.h>
  21 #include <linux/mutex.h>
  22 #include <linux/clk.h>
  23 #include <linux/coresight.h>
  24 #include <linux/of_platform.h>
  25 #include <linux/delay.h>
  26 #include <linux/pm_runtime.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, u32 mode)
 124 {
 125         int ret;
 126
 127         if (!csdev->enable) {
 128                 if (sink_ops(csdev)->enable) {
 129                         ret = sink_ops(csdev)->enable(csdev, mode);
 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, u32 mode)
 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, NULL, mode);
 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, u32 mode)
 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, mode);
 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 struct coresight_device *coresight_get_sink(struct list_head *path)
 325 {
 326         struct coresight_device *csdev;
 327
 328         if (!path)
 329                 return NULL;
 330
 331         csdev = list_last_entry(path, struct coresight_node, link)->csdev;
 332         if (csdev->type != CORESIGHT_DEV_TYPE_SINK &&
 333             csdev->type != CORESIGHT_DEV_TYPE_LINKSINK)
 334                 return NULL;
 335
 336         return csdev;
 337 }
 338
 339 /**
 340  * _coresight_build_path - recursively build a path from a @csdev to a sink.
 341  * @csdev:      The device to start from.
 342  * @path:       The list to add devices to.
 343  *
 344  * The tree of Coresight device is traversed until an activated sink is
 345  * found.  From there the sink is added to the list along with all the
 346  * devices that led to that point - the end result is a list from source
 347  * to sink. In that list the source is the first device and the sink the
 348  * last one.
 349  */
 350 static int _coresight_build_path(struct coresight_device *csdev,
 351                                  struct list_head *path)
 352 {
 353         int i;
 354         bool found = false;
 355         struct coresight_node *node;
 356         struct coresight_connection *conn;
 357
 358         /* An activated sink has been found.  Enqueue the element */
 359         if ((csdev->type == CORESIGHT_DEV_TYPE_SINK ||
 360              csdev->type == CORESIGHT_DEV_TYPE_LINKSINK) && csdev->activated)
 361                 goto out;
 362
 363         /* Not a sink - recursively explore each port found on this element */
 364         for (i = 0; i < csdev->nr_outport; i++) {
 365                 conn = &csdev->conns[i];
 366                 if (_coresight_build_path(conn->child_dev, path) == 0) {
 367                         found = true;
 368                         break;
 369                 }
 370         }
 371
 372         if (!found)
 373                 return -ENODEV;
 374
 375 out:
 376         /*
 377          * A path from this element to a sink has been found.  The elements
 378          * leading to the sink are already enqueued, all that is left to do
 379          * is tell the PM runtime core we need this element and add a node
 380          * for it.
 381          */
 382         node = kzalloc(sizeof(struct coresight_node), GFP_KERNEL);
 383         if (!node)
 384                 return -ENOMEM;
 385
 386         node->csdev = csdev;
 387         list_add(&node->link, path);
 388         pm_runtime_get_sync(csdev->dev.parent);
 389
 390         return 0;
 391 }
 392
 393 struct list_head *coresight_build_path(struct coresight_device *csdev)
 394 {
 395         struct list_head *path;
 396
 397         path = kzalloc(sizeof(struct list_head), GFP_KERNEL);
 398         if (!path)
 399                 return NULL;
 400
 401         INIT_LIST_HEAD(path);
 402
 403         if (_coresight_build_path(csdev, path)) {
 404                 kfree(path);
 405                 path = NULL;
 406         }
 407
 408         return path;
 409 }
 410
 411 /**
 412  * coresight_release_path - release a previously built path.
 413  * @path:       the path to release.
 414  *
 415  * Go through all the elements of a path and 1) removed it from the list and
 416  * 2) free the memory allocated for each node.
 417  */
 418 void coresight_release_path(struct list_head *path)
 419 {
 420         struct coresight_device *csdev;
 421         struct coresight_node *nd, *next;
 422
 423         list_for_each_entry_safe(nd, next, path, link) {
 424                 csdev = nd->csdev;
 425
 426                 pm_runtime_put_sync(csdev->dev.parent);
 427                 list_del(&nd->link);
 428                 kfree(nd);
 429         }
 430
 431         kfree(path);
 432         path = NULL;
 433 }
 434
 435 int coresight_enable(struct coresight_device *csdev)
 436 {
 437         int ret = 0;
 438         int cpu;
 439         struct list_head *path;
 440
 441         mutex_lock(&coresight_mutex);
 442         if (csdev->type != CORESIGHT_DEV_TYPE_SOURCE) {
 443                 ret = -EINVAL;
 444                 dev_err(&csdev->dev, "wrong device type in %s\n", __func__);
 445                 goto out;
 446         }
 447         if (csdev->enable)
 448                 goto out;
 449
 450         path = coresight_build_path(csdev);
 451         if (!path) {
 452                 pr_err("building path(s) failed\n");
 453                 goto out;
 454         }
 455
 456         ret = coresight_enable_path(path, CS_MODE_SYSFS);
 457         if (ret)
 458                 goto err_path;
 459
 460         ret = coresight_enable_source(csdev, CS_MODE_SYSFS);
 461         if (ret)
 462                 goto err_source;
 463
 464         /*
 465          * When working from sysFS it is important to keep track
 466          * of the paths that were created so that they can be
 467          * undone in 'coresight_disable()'.  Since there can only
 468          * be a single session per tracer (when working from sysFS)
 469          * a per-cpu variable will do just fine.
 470          */
 471         cpu = source_ops(csdev)->cpu_id(csdev);
 472         per_cpu(sysfs_path, cpu) = path;
 473
 474 out:
 475         mutex_unlock(&coresight_mutex);
 476         return ret;
 477
 478 err_source:
 479         coresight_disable_path(path);
 480
 481 err_path:
 482         coresight_release_path(path);
 483         goto out;
 484 }
 485 EXPORT_SYMBOL_GPL(coresight_enable);
 486
 487 void coresight_disable(struct coresight_device *csdev)
 488 {
 489         int cpu;
 490         struct list_head *path;
 491
 492         mutex_lock(&coresight_mutex);
 493         if (csdev->type != CORESIGHT_DEV_TYPE_SOURCE) {
 494                 dev_err(&csdev->dev, "wrong device type in %s\n", __func__);
 495                 goto out;
 496         }
 497         if (!csdev->enable)
 498                 goto out;
 499
 500         cpu = source_ops(csdev)->cpu_id(csdev);
 501         path = per_cpu(sysfs_path, cpu);
 502         coresight_disable_source(csdev);
 503         coresight_disable_path(path);
 504         coresight_release_path(path);
 505         per_cpu(sysfs_path, cpu) = NULL;
 506
 507 out:
 508         mutex_unlock(&coresight_mutex);
 509 }
 510 EXPORT_SYMBOL_GPL(coresight_disable);
 511
 512 static ssize_t enable_sink_show(struct device *dev,
 513                                 struct device_attribute *attr, char *buf)
 514 {
 515         struct coresight_device *csdev = to_coresight_device(dev);
 516
 517         return scnprintf(buf, PAGE_SIZE, "%u\n", (unsigned)csdev->activated);
 518 }
 519
 520 static ssize_t enable_sink_store(struct device *dev,
 521                                  struct device_attribute *attr,
 522                                  const char *buf, size_t size)
 523 {
 524         int ret;
 525         unsigned long val;
 526         struct coresight_device *csdev = to_coresight_device(dev);
 527
 528         ret = kstrtoul(buf, 10, &val);
 529         if (ret)
 530                 return ret;
 531
 532         if (val)
 533                 csdev->activated = true;
 534         else
 535                 csdev->activated = false;
 536
 537         return size;
 538
 539 }
 540 static DEVICE_ATTR_RW(enable_sink);
 541
 542 static ssize_t enable_source_show(struct device *dev,
 543                                   struct device_attribute *attr, char *buf)
 544 {
 545         struct coresight_device *csdev = to_coresight_device(dev);
 546
 547         return scnprintf(buf, PAGE_SIZE, "%u\n", (unsigned)csdev->enable);
 548 }
 549
 550 static ssize_t enable_source_store(struct device *dev,
 551                                    struct device_attribute *attr,
 552                                    const char *buf, size_t size)
 553 {
 554         int ret = 0;
 555         unsigned long val;
 556         struct coresight_device *csdev = to_coresight_device(dev);
 557
 558         ret = kstrtoul(buf, 10, &val);
 559         if (ret)
 560                 return ret;
 561
 562         if (val) {
 563                 ret = coresight_enable(csdev);
 564                 if (ret)
 565                         return ret;
 566         } else {
 567                 coresight_disable(csdev);
 568         }
 569
 570         return size;
 571 }
 572 static DEVICE_ATTR_RW(enable_source);
 573
 574 static struct attribute *coresight_sink_attrs[] = {
 575         &dev_attr_enable_sink.attr,
 576         NULL,
 577 };
 578 ATTRIBUTE_GROUPS(coresight_sink);
 579
 580 static struct attribute *coresight_source_attrs[] = {
 581         &dev_attr_enable_source.attr,
 582         NULL,
 583 };
 584 ATTRIBUTE_GROUPS(coresight_source);
 585
 586 static struct device_type coresight_dev_type[] = {
 587         {
 588                 .name = "none",
 589         },
 590         {
 591                 .name = "sink",
 592                 .groups = coresight_sink_groups,
 593         },
 594         {
 595                 .name = "link",
 596         },
 597         {
 598                 .name = "linksink",
 599                 .groups = coresight_sink_groups,
 600         },
 601         {
 602                 .name = "source",
 603                 .groups = coresight_source_groups,
 604         },
 605 };
 606
 607 static void coresight_device_release(struct device *dev)
 608 {
 609         struct coresight_device *csdev = to_coresight_device(dev);
 610
 611         kfree(csdev->conns);
 612         kfree(csdev->refcnt);
 613         kfree(csdev);
 614 }
 615
 616 static int coresight_orphan_match(struct device *dev, void *data)
 617 {
 618         int i;
 619         bool still_orphan = false;
 620         struct coresight_device *csdev, *i_csdev;
 621         struct coresight_connection *conn;
 622
 623         csdev = data;
 624         i_csdev = to_coresight_device(dev);
 625
 626         /* No need to check oneself */
 627         if (csdev == i_csdev)
 628                 return 0;
 629
 630         /* Move on to another component if no connection is orphan */
 631         if (!i_csdev->orphan)
 632                 return 0;
 633         /*
 634          * Circle throuch all the connection of that component.  If we find
 635          * an orphan connection whose name matches @csdev, link it.
 636          */
 637         for (i = 0; i < i_csdev->nr_outport; i++) {
 638                 conn = &i_csdev->conns[i];
 639
 640                 /* We have found at least one orphan connection */
 641                 if (conn->child_dev == NULL) {
 642                         /* Does it match this newly added device? */
 643                         if (!strcmp(dev_name(&csdev->dev), conn->child_name)) {
 644                                 conn->child_dev = csdev;
 645                         } else {
 646                                 /* This component still has an orphan */
 647                                 still_orphan = true;
 648                         }
 649                 }
 650         }
 651
 652         i_csdev->orphan = still_orphan;
 653
 654         /*
 655          * Returning '0' ensures that all known component on the
 656          * bus will be checked.
 657          */
 658         return 0;
 659 }
 660
 661 static void coresight_fixup_orphan_conns(struct coresight_device *csdev)
 662 {
 663         /*
 664          * No need to check for a return value as orphan connection(s)
 665          * are hooked-up with each newly added component.
 666          */
 667         bus_for_each_dev(&coresight_bustype, NULL,
 668                          csdev, coresight_orphan_match);
 669 }
 670
 671
 672 static int coresight_name_match(struct device *dev, void *data)
 673 {
 674         char *to_match;
 675         struct coresight_device *i_csdev;
 676
 677         to_match = data;
 678         i_csdev = to_coresight_device(dev);
 679
 680         if (to_match && !strcmp(to_match, dev_name(&i_csdev->dev)))
 681                 return 1;
 682
 683         return 0;
 684 }
 685
 686 static void coresight_fixup_device_conns(struct coresight_device *csdev)
 687 {
 688         int i;
 689         struct device *dev = NULL;
 690         struct coresight_connection *conn;
 691
 692         for (i = 0; i < csdev->nr_outport; i++) {
 693                 conn = &csdev->conns[i];
 694                 dev = bus_find_device(&coresight_bustype, NULL,
 695                                       (void *)conn->child_name,
 696                                       coresight_name_match);
 697
 698                 if (dev) {
 699                         conn->child_dev = to_coresight_device(dev);
 700                         /* and put reference from 'bus_find_device()' */
 701                         put_device(dev);
 702                 } else {
 703                         csdev->orphan = true;
 704                         conn->child_dev = NULL;
 705                 }
 706         }
 707 }
 708
 709 static int coresight_remove_match(struct device *dev, void *data)
 710 {
 711         int i;
 712         struct coresight_device *csdev, *iterator;
 713         struct coresight_connection *conn;
 714
 715         csdev = data;
 716         iterator = to_coresight_device(dev);
 717
 718         /* No need to check oneself */
 719         if (csdev == iterator)
 720                 return 0;
 721
 722         /*
 723          * Circle throuch all the connection of that component.  If we find
 724          * a connection whose name matches @csdev, remove it.
 725          */
 726         for (i = 0; i < iterator->nr_outport; i++) {
 727                 conn = &iterator->conns[i];
 728
 729                 if (conn->child_dev == NULL)
 730                         continue;
 731
 732                 if (!strcmp(dev_name(&csdev->dev), conn->child_name)) {
 733                         iterator->orphan = true;
 734                         conn->child_dev = NULL;
 735                         /* No need to continue */
 736                         break;
 737                 }
 738         }
 739
 740         /*
 741          * Returning '0' ensures that all known component on the
 742          * bus will be checked.
 743          */
 744         return 0;
 745 }
 746
 747 static void coresight_remove_conns(struct coresight_device *csdev)
 748 {
 749         bus_for_each_dev(&coresight_bustype, NULL,
 750                          csdev, coresight_remove_match);
 751 }
 752
 753 /**
 754  * coresight_timeout - loop until a bit has changed to a specific state.
 755  * @addr: base address of the area of interest.
 756  * @offset: address of a register, starting from @addr.
 757  * @position: the position of the bit of interest.
 758  * @value: the value the bit should have.
 759  *
 760  * Return: 0 as soon as the bit has taken the desired state or -EAGAIN if
 761  * TIMEOUT_US has elapsed, which ever happens first.
 762  */
 763
 764 int coresight_timeout(void __iomem *addr, u32 offset, int position, int value)
 765 {
 766         int i;
 767         u32 val;
 768
 769         for (i = TIMEOUT_US; i > 0; i--) {
 770                 val = __raw_readl(addr + offset);
 771                 /* waiting on the bit to go from 0 to 1 */
 772                 if (value) {
 773                         if (val & BIT(position))
 774                                 return 0;
 775                 /* waiting on the bit to go from 1 to 0 */
 776                 } else {
 777                         if (!(val & BIT(position)))
 778                                 return 0;
 779                 }
 780
 781                 /*
 782                  * Delay is arbitrary - the specification doesn't say how long
 783                  * we are expected to wait.  Extra check required to make sure
 784                  * we don't wait needlessly on the last iteration.
 785                  */
 786                 if (i - 1)
 787                         udelay(1);
 788         }
 789
 790         return -EAGAIN;
 791 }
 792
 793 struct bus_type coresight_bustype = {
 794         .name   = "coresight",
 795 };
 796
 797 static int __init coresight_init(void)
 798 {
 799         return bus_register(&coresight_bustype);
 800 }
 801 postcore_initcall(coresight_init);
 802
 803 struct coresight_device *coresight_register(struct coresight_desc *desc)
 804 {
 805         int i;
 806         int ret;
 807         int link_subtype;
 808         int nr_refcnts = 1;
 809         atomic_t *refcnts = NULL;
 810         struct coresight_device *csdev;
 811         struct coresight_connection *conns;
 812
 813         csdev = kzalloc(sizeof(*csdev), GFP_KERNEL);
 814         if (!csdev) {
 815                 ret = -ENOMEM;
 816                 goto err_kzalloc_csdev;
 817         }
 818
 819         if (desc->type == CORESIGHT_DEV_TYPE_LINK ||
 820             desc->type == CORESIGHT_DEV_TYPE_LINKSINK) {
 821                 link_subtype = desc->subtype.link_subtype;
 822
 823                 if (link_subtype == CORESIGHT_DEV_SUBTYPE_LINK_MERG)
 824                         nr_refcnts = desc->pdata->nr_inport;
 825                 else if (link_subtype == CORESIGHT_DEV_SUBTYPE_LINK_SPLIT)
 826                         nr_refcnts = desc->pdata->nr_outport;
 827         }
 828
 829         refcnts = kcalloc(nr_refcnts, sizeof(*refcnts), GFP_KERNEL);
 830         if (!refcnts) {
 831                 ret = -ENOMEM;
 832                 goto err_kzalloc_refcnts;
 833         }
 834
 835         csdev->refcnt = refcnts;
 836
 837         csdev->nr_inport = desc->pdata->nr_inport;
 838         csdev->nr_outport = desc->pdata->nr_outport;
 839         conns = kcalloc(csdev->nr_outport, sizeof(*conns), GFP_KERNEL);
 840         if (!conns) {
 841                 ret = -ENOMEM;
 842                 goto err_kzalloc_conns;
 843         }
 844
 845         for (i = 0; i < csdev->nr_outport; i++) {
 846                 conns[i].outport = desc->pdata->outports[i];
 847                 conns[i].child_name = desc->pdata->child_names[i];
 848                 conns[i].child_port = desc->pdata->child_ports[i];
 849         }
 850
 851         csdev->conns = conns;
 852
 853         csdev->type = desc->type;
 854         csdev->subtype = desc->subtype;
 855         csdev->ops = desc->ops;
 856         csdev->orphan = false;
 857
 858         csdev->dev.type = &coresight_dev_type[desc->type];
 859         csdev->dev.groups = desc->groups;
 860         csdev->dev.parent = desc->dev;
 861         csdev->dev.release = coresight_device_release;
 862         csdev->dev.bus = &coresight_bustype;
 863         dev_set_name(&csdev->dev, "%s", desc->pdata->name);
 864
 865         ret = device_register(&csdev->dev);
 866         if (ret)
 867                 goto err_device_register;
 868
 869         mutex_lock(&coresight_mutex);
 870
 871         coresight_fixup_device_conns(csdev);
 872         coresight_fixup_orphan_conns(csdev);
 873
 874         mutex_unlock(&coresight_mutex);
 875
 876         return csdev;
 877
 878 err_device_register:
 879         kfree(conns);
 880 err_kzalloc_conns:
 881         kfree(refcnts);
 882 err_kzalloc_refcnts:
 883         kfree(csdev);
 884 err_kzalloc_csdev:
 885         return ERR_PTR(ret);
 886 }
 887 EXPORT_SYMBOL_GPL(coresight_register);
 888
 889 void coresight_unregister(struct coresight_device *csdev)
 890 {
 891         /* Remove references of that device in the topology */
 892         coresight_remove_conns(csdev);
 893         device_unregister(&csdev->dev);
 894 }
 895 EXPORT_SYMBOL_GPL(coresight_unregister);