drivers/hwtracing/coresight/coresight-platform.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  * Copyright (c) 2012, The Linux Foundation. All rights reserved.
   4  */
   5
   6 #include <linux/acpi.h>
   7 #include <linux/types.h>
   8 #include <linux/err.h>
   9 #include <linux/slab.h>
  10 #include <linux/clk.h>
  11 #include <linux/of.h>
  12 #include <linux/of_address.h>
  13 #include <linux/of_graph.h>
  14 #include <linux/of_platform.h>
  15 #include <linux/platform_device.h>
  16 #include <linux/amba/bus.h>
  17 #include <linux/coresight.h>
  18 #include <linux/cpumask.h>
  19 #include <asm/smp_plat.h>
  20
  21 #include "coresight-priv.h"
  22 /*
  23  * coresight_alloc_conns: Allocate connections record for each output
  24  * port from the device.
  25  */
  26 static int coresight_alloc_conns(struct device *dev,
  27                                  struct coresight_platform_data *pdata)
  28 {
  29         if (pdata->nr_outport) {
  30                 pdata->conns = devm_kcalloc(dev, pdata->nr_outport,
  31                                             sizeof(*pdata->conns), GFP_KERNEL);
  32                 if (!pdata->conns)
  33                         return -ENOMEM;
  34         }
  35
  36         return 0;
  37 }
  38
  39 static struct device *
  40 coresight_find_device_by_fwnode(struct fwnode_handle *fwnode)
  41 {
  42         struct device *dev = NULL;
  43
  44         /*
  45          * If we have a non-configurable replicator, it will be found on the
  46          * platform bus.
  47          */
  48         dev = bus_find_device_by_fwnode(&platform_bus_type, fwnode);
  49         if (dev)
  50                 return dev;
  51
  52         /*
  53          * We have a configurable component - circle through the AMBA bus
  54          * looking for the device that matches the endpoint node.
  55          */
  56         return bus_find_device_by_fwnode(&amba_bustype, fwnode);
  57 }
  58
  59 /*
  60  * Find a registered coresight device from a device fwnode.
  61  * The node info is associated with the AMBA parent, but the
  62  * csdev keeps a copy so iterate round the coresight bus to
  63  * find the device.
  64  */
  65 struct coresight_device *
  66 coresight_find_csdev_by_fwnode(struct fwnode_handle *r_fwnode)
  67 {
  68         struct device *dev;
  69         struct coresight_device *csdev = NULL;
  70
  71         dev = bus_find_device_by_fwnode(&coresight_bustype, r_fwnode);
  72         if (dev) {
  73                 csdev = to_coresight_device(dev);
  74                 put_device(dev);
  75         }
  76         return csdev;
  77 }
  78 EXPORT_SYMBOL_GPL(coresight_find_csdev_by_fwnode);
  79
  80 #ifdef CONFIG_OF
  81 static inline bool of_coresight_legacy_ep_is_input(struct device_node *ep)
  82 {
  83         return of_property_read_bool(ep, "slave-mode");
  84 }
  85
  86 static void of_coresight_get_ports_legacy(const struct device_node *node,
  87                                           int *nr_inport, int *nr_outport)
  88 {
  89         struct device_node *ep = NULL;
  90         struct of_endpoint endpoint;
  91         int in = 0, out = 0;
  92
  93         /*
  94          * Avoid warnings in of_graph_get_next_endpoint()
  95          * if the device doesn't have any graph connections
  96          */
  97         if (!of_graph_is_present(node))
  98                 return;
  99         do {
 100                 ep = of_graph_get_next_endpoint(node, ep);
 101                 if (!ep)
 102                         break;
 103
 104                 if (of_graph_parse_endpoint(ep, &endpoint))
 105                         continue;
 106
 107                 if (of_coresight_legacy_ep_is_input(ep)) {
 108                         in = (endpoint.port + 1 > in) ?
 109                                 endpoint.port + 1 : in;
 110                 } else {
 111                         out = (endpoint.port + 1) > out ?
 112                                 endpoint.port + 1 : out;
 113                 }
 114
 115         } while (ep);
 116
 117         *nr_inport = in;
 118         *nr_outport = out;
 119 }
 120
 121 static struct device_node *of_coresight_get_port_parent(struct device_node *ep)
 122 {
 123         struct device_node *parent = of_graph_get_port_parent(ep);
 124
 125         /*
 126          * Skip one-level up to the real device node, if we
 127          * are using the new bindings.
 128          */
 129         if (of_node_name_eq(parent, "in-ports") ||
 130             of_node_name_eq(parent, "out-ports"))
 131                 parent = of_get_next_parent(parent);
 132
 133         return parent;
 134 }
 135
 136 static inline struct device_node *
 137 of_coresight_get_input_ports_node(const struct device_node *node)
 138 {
 139         return of_get_child_by_name(node, "in-ports");
 140 }
 141
 142 static inline struct device_node *
 143 of_coresight_get_output_ports_node(const struct device_node *node)
 144 {
 145         return of_get_child_by_name(node, "out-ports");
 146 }
 147
 148 static inline int
 149 of_coresight_count_ports(struct device_node *port_parent)
 150 {
 151         int i = 0;
 152         struct device_node *ep = NULL;
 153         struct of_endpoint endpoint;
 154
 155         while ((ep = of_graph_get_next_endpoint(port_parent, ep))) {
 156                 /* Defer error handling to parsing */
 157                 if (of_graph_parse_endpoint(ep, &endpoint))
 158                         continue;
 159                 if (endpoint.port + 1 > i)
 160                         i = endpoint.port + 1;
 161         }
 162
 163         return i;
 164 }
 165
 166 static void of_coresight_get_ports(const struct device_node *node,
 167                                    int *nr_inport, int *nr_outport)
 168 {
 169         struct device_node *input_ports = NULL, *output_ports = NULL;
 170
 171         input_ports = of_coresight_get_input_ports_node(node);
 172         output_ports = of_coresight_get_output_ports_node(node);
 173
 174         if (input_ports || output_ports) {
 175                 if (input_ports) {
 176                         *nr_inport = of_coresight_count_ports(input_ports);
 177                         of_node_put(input_ports);
 178                 }
 179                 if (output_ports) {
 180                         *nr_outport = of_coresight_count_ports(output_ports);
 181                         of_node_put(output_ports);
 182                 }
 183         } else {
 184                 /* Fall back to legacy DT bindings parsing */
 185                 of_coresight_get_ports_legacy(node, nr_inport, nr_outport);
 186         }
 187 }
 188
 189 static int of_coresight_get_cpu(struct device *dev)
 190 {
 191         int cpu;
 192         struct device_node *dn;
 193
 194         if (!dev->of_node)
 195                 return -ENODEV;
 196
 197         dn = of_parse_phandle(dev->of_node, "cpu", 0);
 198         if (!dn)
 199                 return -ENODEV;
 200
 201         cpu = of_cpu_node_to_id(dn);
 202         of_node_put(dn);
 203
 204         return cpu;
 205 }
 206
 207 /*
 208  * of_coresight_parse_endpoint : Parse the given output endpoint @ep
 209  * and fill the connection information in @conn
 210  *
 211  * Parses the local port, remote device name and the remote port.
 212  *
 213  * Returns :
 214  *       0      - If the parsing completed without any fatal errors.
 215  *      -Errno  - Fatal error, abort the scanning.
 216  */
 217 static int of_coresight_parse_endpoint(struct device *dev,
 218                                        struct device_node *ep,
 219                                        struct coresight_platform_data *pdata)
 220 {
 221         int ret = 0;
 222         struct of_endpoint endpoint, rendpoint;
 223         struct device_node *rparent = NULL;
 224         struct device_node *rep = NULL;
 225         struct device *rdev = NULL;
 226         struct fwnode_handle *rdev_fwnode;
 227         struct coresight_connection *conn;
 228
 229         do {
 230                 /* Parse the local port details */
 231                 if (of_graph_parse_endpoint(ep, &endpoint))
 232                         break;
 233                 /*
 234                  * Get a handle on the remote endpoint and the device it is
 235                  * attached to.
 236                  */
 237                 rep = of_graph_get_remote_endpoint(ep);
 238                 if (!rep)
 239                         break;
 240                 rparent = of_coresight_get_port_parent(rep);
 241                 if (!rparent)
 242                         break;
 243                 if (of_graph_parse_endpoint(rep, &rendpoint))
 244                         break;
 245
 246                 rdev_fwnode = of_fwnode_handle(rparent);
 247                 /* If the remote device is not available, defer probing */
 248                 rdev = coresight_find_device_by_fwnode(rdev_fwnode);
 249                 if (!rdev) {
 250                         ret = -EPROBE_DEFER;
 251                         break;
 252                 }
 253
 254                 conn = &pdata->conns[endpoint.port];
 255                 if (conn->child_fwnode) {
 256                         dev_warn(dev, "Duplicate output port %d\n",
 257                                  endpoint.port);
 258                         ret = -EINVAL;
 259                         break;
 260                 }
 261                 conn->outport = endpoint.port;
 262                 /*
 263                  * Hold the refcount to the target device. This could be
 264                  * released via:
 265                  * 1) coresight_release_platform_data() if the probe fails or
 266                  *    this device is unregistered.
 267                  * 2) While removing the target device via
 268                  *    coresight_remove_match()
 269                  */
 270                 conn->child_fwnode = fwnode_handle_get(rdev_fwnode);
 271                 conn->child_port = rendpoint.port;
 272                 /* Connection record updated */
 273         } while (0);
 274
 275         of_node_put(rparent);
 276         of_node_put(rep);
 277         put_device(rdev);
 278
 279         return ret;
 280 }
 281
 282 static int of_get_coresight_platform_data(struct device *dev,
 283                                           struct coresight_platform_data *pdata)
 284 {
 285         int ret = 0;
 286         struct device_node *ep = NULL;
 287         const struct device_node *parent = NULL;
 288         bool legacy_binding = false;
 289         struct device_node *node = dev->of_node;
 290
 291         /* Get the number of input and output port for this component */
 292         of_coresight_get_ports(node, &pdata->nr_inport, &pdata->nr_outport);
 293
 294         /* If there are no output connections, we are done */
 295         if (!pdata->nr_outport)
 296                 return 0;
 297
 298         ret = coresight_alloc_conns(dev, pdata);
 299         if (ret)
 300                 return ret;
 301
 302         parent = of_coresight_get_output_ports_node(node);
 303         /*
 304          * If the DT uses obsoleted bindings, the ports are listed
 305          * under the device and we need to filter out the input
 306          * ports.
 307          */
 308         if (!parent) {
 309                 legacy_binding = true;
 310                 parent = node;
 311                 dev_warn_once(dev, "Uses obsolete Coresight DT bindings\n");
 312         }
 313
 314         /* Iterate through each output port to discover topology */
 315         while ((ep = of_graph_get_next_endpoint(parent, ep))) {
 316                 /*
 317                  * Legacy binding mixes input/output ports under the
 318                  * same parent. So, skip the input ports if we are dealing
 319                  * with legacy binding, as they processed with their
 320                  * connected output ports.
 321                  */
 322                 if (legacy_binding && of_coresight_legacy_ep_is_input(ep))
 323                         continue;
 324
 325                 ret = of_coresight_parse_endpoint(dev, ep, pdata);
 326                 if (ret)
 327                         return ret;
 328         }
 329
 330         return 0;
 331 }
 332 #else
 333 static inline int
 334 of_get_coresight_platform_data(struct device *dev,
 335                                struct coresight_platform_data *pdata)
 336 {
 337         return -ENOENT;
 338 }
 339
 340 static inline int of_coresight_get_cpu(struct device *dev)
 341 {
 342         return -ENODEV;
 343 }
 344 #endif
 345
 346 #ifdef CONFIG_ACPI
 347
 348 #include <acpi/actypes.h>
 349 #include <acpi/processor.h>
 350
 351 /* ACPI Graph _DSD UUID : "ab02a46b-74c7-45a2-bd68-f7d344ef2153" */
 352 static const guid_t acpi_graph_uuid = GUID_INIT(0xab02a46b, 0x74c7, 0x45a2,
 353                                                 0xbd, 0x68, 0xf7, 0xd3,
 354                                                 0x44, 0xef, 0x21, 0x53);
 355 /* Coresight ACPI Graph UUID : "3ecbc8b6-1d0e-4fb3-8107-e627f805c6cd" */
 356 static const guid_t coresight_graph_uuid = GUID_INIT(0x3ecbc8b6, 0x1d0e, 0x4fb3,
 357                                                      0x81, 0x07, 0xe6, 0x27,
 358                                                      0xf8, 0x05, 0xc6, 0xcd);
 359 #define ACPI_CORESIGHT_LINK_SLAVE       0
 360 #define ACPI_CORESIGHT_LINK_MASTER      1
 361
 362 static inline bool is_acpi_guid(const union acpi_object *obj)
 363 {
 364         return (obj->type == ACPI_TYPE_BUFFER) && (obj->buffer.length == 16);
 365 }
 366
 367 /*
 368  * acpi_guid_matches    - Checks if the given object is a GUID object and
 369  * that it matches the supplied the GUID.
 370  */
 371 static inline bool acpi_guid_matches(const union acpi_object *obj,
 372                                    const guid_t *guid)
 373 {
 374         return is_acpi_guid(obj) &&
 375                guid_equal((guid_t *)obj->buffer.pointer, guid);
 376 }
 377
 378 static inline bool is_acpi_dsd_graph_guid(const union acpi_object *obj)
 379 {
 380         return acpi_guid_matches(obj, &acpi_graph_uuid);
 381 }
 382
 383 static inline bool is_acpi_coresight_graph_guid(const union acpi_object *obj)
 384 {
 385         return acpi_guid_matches(obj, &coresight_graph_uuid);
 386 }
 387
 388 static inline bool is_acpi_coresight_graph(const union acpi_object *obj)
 389 {
 390         const union acpi_object *graphid, *guid, *links;
 391
 392         if (obj->type != ACPI_TYPE_PACKAGE ||
 393             obj->package.count < 3)
 394                 return false;
 395
 396         graphid = &obj->package.elements[0];
 397         guid = &obj->package.elements[1];
 398         links = &obj->package.elements[2];
 399
 400         if (graphid->type != ACPI_TYPE_INTEGER ||
 401             links->type != ACPI_TYPE_INTEGER)
 402                 return false;
 403
 404         return is_acpi_coresight_graph_guid(guid);
 405 }
 406
 407 /*
 408  * acpi_validate_dsd_graph      - Make sure the given _DSD graph conforms
 409  * to the ACPI _DSD Graph specification.
 410  *
 411  * ACPI Devices Graph property has the following format:
 412  *  {
 413  *      Revision        - Integer, must be 0
 414  *      NumberOfGraphs  - Integer, N indicating the following list.
 415  *      Graph[1],
 416  *       ...
 417  *      Graph[N]
 418  *  }
 419  *
 420  * And each Graph entry has the following format:
 421  *  {
 422  *      GraphID         - Integer, identifying a graph the device belongs to.
 423  *      UUID            - UUID identifying the specification that governs
 424  *                        this graph. (e.g, see is_acpi_coresight_graph())
 425  *      NumberOfLinks   - Number "N" of connections on this node of the graph.
 426  *      Links[1]
 427  *      ...
 428  *      Links[N]
 429  *  }
 430  *
 431  * Where each "Links" entry has the following format:
 432  *
 433  * {
 434  *      SourcePortAddress       - Integer
 435  *      DestinationPortAddress  - Integer
 436  *      DestinationDeviceName   - Reference to another device
 437  *      ( --- CoreSight specific extensions below ---)
 438  *      DirectionOfFlow         - Integer 1 for output(master)
 439  *                                0 for input(slave)
 440  * }
 441  *
 442  * e.g:
 443  * For a Funnel device
 444  *
 445  * Device(MFUN) {
 446  *   ...
 447  *
 448  *   Name (_DSD, Package() {
 449  *      // DSD Package contains tuples of {  Proeprty_Type_UUID, Package() }
 450  *      ToUUID("daffd814-6eba-4d8c-8a91-bc9bbf4aa301"), //Std. Property UUID
 451  *      Package() {
 452  *              Package(2) { "property-name", <property-value> }
 453  *      },
 454  *
 455  *      ToUUID("ab02a46b-74c7-45a2-bd68-f7d344ef2153"), // ACPI Graph UUID
 456  *      Package() {
 457  *        0,            // Revision
 458  *        1,            // NumberOfGraphs.
 459  *        Package() {   // Graph[0] Package
 460  *           1,         // GraphID
 461  *           // Coresight Graph UUID
 462  *           ToUUID("3ecbc8b6-1d0e-4fb3-8107-e627f805c6cd"),
 463  *           3,         // NumberOfLinks aka ports
 464  *           // Link[0]: Output_0 -> Replicator:Input_0
 465  *           Package () { 0, 0, \_SB_.RPL0, 1 },
 466  *           // Link[1]: Input_0 <- Cluster0_Funnel0:Output_0
 467  *           Package () { 0, 0, \_SB_.CLU0.FUN0, 0 },
 468  *           // Link[2]: Input_1 <- Cluster1_Funnel0:Output_0
 469  *            Package () { 1, 0, \_SB_.CLU1.FUN0, 0 },
 470  *        }     // End of Graph[0] Package
 471  *
 472  *      }, // End of ACPI Graph Property
 473  *  })
 474  */
 475 static inline bool acpi_validate_dsd_graph(const union acpi_object *graph)
 476 {
 477         int i, n;
 478         const union acpi_object *rev, *nr_graphs;
 479
 480         /* The graph must contain at least the Revision and Number of Graphs */
 481         if (graph->package.count < 2)
 482                 return false;
 483
 484         rev = &graph->package.elements[0];
 485         nr_graphs = &graph->package.elements[1];
 486
 487         if (rev->type != ACPI_TYPE_INTEGER ||
 488             nr_graphs->type != ACPI_TYPE_INTEGER)
 489                 return false;
 490
 491         /* We only support revision 0 */
 492         if (rev->integer.value != 0)
 493                 return false;
 494
 495         n = nr_graphs->integer.value;
 496         /* CoreSight devices are only part of a single Graph */
 497         if (n != 1)
 498                 return false;
 499
 500         /* Make sure the ACPI graph package has right number of elements */
 501         if (graph->package.count != (n + 2))
 502                 return false;
 503
 504         /*
 505          * Each entry must be a graph package with at least 3 members :
 506          * { GraphID, UUID, NumberOfLinks(n), Links[.],... }
 507          */
 508         for (i = 2; i < n + 2; i++) {
 509                 const union acpi_object *obj = &graph->package.elements[i];
 510
 511                 if (obj->type != ACPI_TYPE_PACKAGE ||
 512                     obj->package.count < 3)
 513                         return false;
 514         }
 515
 516         return true;
 517 }
 518
 519 /* acpi_get_dsd_graph   - Find the _DSD Graph property for the given device. */
 520 static const union acpi_object *
 521 acpi_get_dsd_graph(struct acpi_device *adev)
 522 {
 523         int i;
 524         struct acpi_buffer buf = { ACPI_ALLOCATE_BUFFER };
 525         acpi_status status;
 526         const union acpi_object *dsd;
 527
 528         status = acpi_evaluate_object_typed(adev->handle, "_DSD", NULL,
 529                                             &buf, ACPI_TYPE_PACKAGE);
 530         if (ACPI_FAILURE(status))
 531                 return NULL;
 532
 533         dsd = buf.pointer;
 534
 535         /*
 536          * _DSD property consists tuples { Prop_UUID, Package() }
 537          * Iterate through all the packages and find the Graph.
 538          */
 539         for (i = 0; i + 1 < dsd->package.count; i += 2) {
 540                 const union acpi_object *guid, *package;
 541
 542                 guid = &dsd->package.elements[i];
 543                 package = &dsd->package.elements[i + 1];
 544
 545                 /* All _DSD elements must have a UUID and a Package */
 546                 if (!is_acpi_guid(guid) || package->type != ACPI_TYPE_PACKAGE)
 547                         break;
 548                 /* Skip the non-Graph _DSD packages */
 549                 if (!is_acpi_dsd_graph_guid(guid))
 550                         continue;
 551                 if (acpi_validate_dsd_graph(package))
 552                         return package;
 553                 /* Invalid graph format, continue */
 554                 dev_warn(&adev->dev, "Invalid Graph _DSD property\n");
 555         }
 556
 557         return NULL;
 558 }
 559
 560 static inline bool
 561 acpi_validate_coresight_graph(const union acpi_object *cs_graph)
 562 {
 563         int nlinks;
 564
 565         nlinks = cs_graph->package.elements[2].integer.value;
 566         /*
 567          * Graph must have the following fields :
 568          * { GraphID, GraphUUID, NumberOfLinks, Links... }
 569          */
 570         if (cs_graph->package.count != (nlinks + 3))
 571                 return false;
 572         /* The links are validated in acpi_coresight_parse_link() */
 573         return true;
 574 }
 575
 576 /*
 577  * acpi_get_coresight_graph     - Parse the device _DSD tables and find
 578  * the Graph property matching the CoreSight Graphs.
 579  *
 580  * Returns the pointer to the CoreSight Graph Package when found. Otherwise
 581  * returns NULL.
 582  */
 583 static const union acpi_object *
 584 acpi_get_coresight_graph(struct acpi_device *adev)
 585 {
 586         const union acpi_object *graph_list, *graph;
 587         int i, nr_graphs;
 588
 589         graph_list = acpi_get_dsd_graph(adev);
 590         if (!graph_list)
 591                 return graph_list;
 592
 593         nr_graphs = graph_list->package.elements[1].integer.value;
 594
 595         for (i = 2; i < nr_graphs + 2; i++) {
 596                 graph = &graph_list->package.elements[i];
 597                 if (!is_acpi_coresight_graph(graph))
 598                         continue;
 599                 if (acpi_validate_coresight_graph(graph))
 600                         return graph;
 601                 /* Invalid graph format */
 602                 break;
 603         }
 604
 605         return NULL;
 606 }
 607
 608 /*
 609  * acpi_coresight_parse_link    - Parse the given Graph connection
 610  * of the device and populate the coresight_connection for an output
 611  * connection.
 612  *
 613  * CoreSight Graph specification mandates that the direction of the data
 614  * flow must be specified in the link. i.e,
 615  *
 616  *      SourcePortAddress,      // Integer
 617  *      DestinationPortAddress, // Integer
 618  *      DestinationDeviceName,  // Reference to another device
 619  *      DirectionOfFlow,        // 1 for output(master), 0 for input(slave)
 620  *
 621  * Returns the direction of the data flow [ Input(slave) or Output(master) ]
 622  * upon success.
 623  * Returns an negative error number otherwise.
 624  */
 625 static int acpi_coresight_parse_link(struct acpi_device *adev,
 626                                      const union acpi_object *link,
 627                                      struct coresight_connection *conn)
 628 {
 629         int dir;
 630         const union acpi_object *fields;
 631         struct acpi_device *r_adev;
 632         struct device *rdev;
 633
 634         if (link->type != ACPI_TYPE_PACKAGE ||
 635             link->package.count != 4)
 636                 return -EINVAL;
 637
 638         fields = link->package.elements;
 639
 640         if (fields[0].type != ACPI_TYPE_INTEGER ||
 641             fields[1].type != ACPI_TYPE_INTEGER ||
 642             fields[2].type != ACPI_TYPE_LOCAL_REFERENCE ||
 643             fields[3].type != ACPI_TYPE_INTEGER)
 644                 return -EINVAL;
 645
 646         r_adev = acpi_fetch_acpi_dev(fields[2].reference.handle);
 647         if (!r_adev)
 648                 return -ENODEV;
 649
 650         dir = fields[3].integer.value;
 651         if (dir == ACPI_CORESIGHT_LINK_MASTER) {
 652                 conn->outport = fields[0].integer.value;
 653                 conn->child_port = fields[1].integer.value;
 654                 rdev = coresight_find_device_by_fwnode(&r_adev->fwnode);
 655                 if (!rdev)
 656                         return -EPROBE_DEFER;
 657                 /*
 658                  * Hold the refcount to the target device. This could be
 659                  * released via:
 660                  * 1) coresight_release_platform_data() if the probe fails or
 661                  *    this device is unregistered.
 662                  * 2) While removing the target device via
 663                  *    coresight_remove_match().
 664                  */
 665                 conn->child_fwnode = fwnode_handle_get(&r_adev->fwnode);
 666         } else if (dir == ACPI_CORESIGHT_LINK_SLAVE) {
 667                 /*
 668                  * We are only interested in the port number
 669                  * for the input ports at this component.
 670                  * Store the port number in child_port.
 671                  */
 672                 conn->child_port = fields[0].integer.value;
 673         } else {
 674                 /* Invalid direction */
 675                 return -EINVAL;
 676         }
 677
 678         return dir;
 679 }
 680
 681 /*
 682  * acpi_coresight_parse_graph   - Parse the _DSD CoreSight graph
 683  * connection information and populate the supplied coresight_platform_data
 684  * instance.
 685  */
 686 static int acpi_coresight_parse_graph(struct acpi_device *adev,
 687                                       struct coresight_platform_data *pdata)
 688 {
 689         int rc, i, nlinks;
 690         const union acpi_object *graph;
 691         struct coresight_connection *conns, *ptr;
 692
 693         pdata->nr_inport = pdata->nr_outport = 0;
 694         graph = acpi_get_coresight_graph(adev);
 695         if (!graph)
 696                 return -ENOENT;
 697
 698         nlinks = graph->package.elements[2].integer.value;
 699         if (!nlinks)
 700                 return 0;
 701
 702         /*
 703          * To avoid scanning the table twice (once for finding the number of
 704          * output links and then later for parsing the output links),
 705          * cache the links information in one go and then later copy
 706          * it to the pdata.
 707          */
 708         conns = devm_kcalloc(&adev->dev, nlinks, sizeof(*conns), GFP_KERNEL);
 709         if (!conns)
 710                 return -ENOMEM;
 711         ptr = conns;
 712         for (i = 0; i < nlinks; i++) {
 713                 const union acpi_object *link = &graph->package.elements[3 + i];
 714                 int dir;
 715
 716                 dir = acpi_coresight_parse_link(adev, link, ptr);
 717                 if (dir < 0)
 718                         return dir;
 719
 720                 if (dir == ACPI_CORESIGHT_LINK_MASTER) {
 721                         if (ptr->outport >= pdata->nr_outport)
 722                                 pdata->nr_outport = ptr->outport + 1;
 723                         ptr++;
 724                 } else {
 725                         WARN_ON(pdata->nr_inport == ptr->child_port + 1);
 726                         /*
 727                          * We do not track input port connections for a device.
 728                          * However we need the highest port number described,
 729                          * which can be recorded now and reuse this connection
 730                          * record for an output connection. Hence, do not move
 731                          * the ptr for input connections
 732                          */
 733                         if (ptr->child_port >= pdata->nr_inport)
 734                                 pdata->nr_inport = ptr->child_port + 1;
 735                 }
 736         }
 737
 738         rc = coresight_alloc_conns(&adev->dev, pdata);
 739         if (rc)
 740                 return rc;
 741
 742         /* Copy the connection information to the final location */
 743         for (i = 0; conns + i < ptr; i++) {
 744                 int port = conns[i].outport;
 745
 746                 /* Duplicate output port */
 747                 WARN_ON(pdata->conns[port].child_fwnode);
 748                 pdata->conns[port] = conns[i];
 749         }
 750
 751         devm_kfree(&adev->dev, conns);
 752         return 0;
 753 }
 754
 755 /*
 756  * acpi_handle_to_logical_cpuid - Map a given acpi_handle to the
 757  * logical CPU id of the corresponding CPU device.
 758  *
 759  * Returns the logical CPU id when found. Otherwise returns >= nr_cpus_id.
 760  */
 761 static int
 762 acpi_handle_to_logical_cpuid(acpi_handle handle)
 763 {
 764         int i;
 765         struct acpi_processor *pr;
 766
 767         for_each_possible_cpu(i) {
 768                 pr = per_cpu(processors, i);
 769                 if (pr && pr->handle == handle)
 770                         break;
 771         }
 772
 773         return i;
 774 }
 775
 776 /*
 777  * acpi_coresigh_get_cpu - Find the logical CPU id of the CPU associated
 778  * with this coresight device. With ACPI bindings, the CoreSight components
 779  * are listed as child device of the associated CPU.
 780  *
 781  * Returns the logical CPU id when found. Otherwise returns 0.
 782  */
 783 static int acpi_coresight_get_cpu(struct device *dev)
 784 {
 785         int cpu;
 786         acpi_handle cpu_handle;
 787         acpi_status status;
 788         struct acpi_device *adev = ACPI_COMPANION(dev);
 789
 790         if (!adev)
 791                 return -ENODEV;
 792         status = acpi_get_parent(adev->handle, &cpu_handle);
 793         if (ACPI_FAILURE(status))
 794                 return -ENODEV;
 795
 796         cpu = acpi_handle_to_logical_cpuid(cpu_handle);
 797         if (cpu >= nr_cpu_ids)
 798                 return -ENODEV;
 799         return cpu;
 800 }
 801
 802 static int
 803 acpi_get_coresight_platform_data(struct device *dev,
 804                                  struct coresight_platform_data *pdata)
 805 {
 806         struct acpi_device *adev;
 807
 808         adev = ACPI_COMPANION(dev);
 809         if (!adev)
 810                 return -EINVAL;
 811
 812         return acpi_coresight_parse_graph(adev, pdata);
 813 }
 814
 815 #else
 816
 817 static inline int
 818 acpi_get_coresight_platform_data(struct device *dev,
 819                                  struct coresight_platform_data *pdata)
 820 {
 821         return -ENOENT;
 822 }
 823
 824 static inline int acpi_coresight_get_cpu(struct device *dev)
 825 {
 826         return -ENODEV;
 827 }
 828 #endif
 829
 830 int coresight_get_cpu(struct device *dev)
 831 {
 832         if (is_of_node(dev->fwnode))
 833                 return of_coresight_get_cpu(dev);
 834         else if (is_acpi_device_node(dev->fwnode))
 835                 return acpi_coresight_get_cpu(dev);
 836         return 0;
 837 }
 838 EXPORT_SYMBOL_GPL(coresight_get_cpu);
 839
 840 struct coresight_platform_data *
 841 coresight_get_platform_data(struct device *dev)
 842 {
 843         int ret = -ENOENT;
 844         struct coresight_platform_data *pdata = NULL;
 845         struct fwnode_handle *fwnode = dev_fwnode(dev);
 846
 847         if (IS_ERR_OR_NULL(fwnode))
 848                 goto error;
 849
 850         pdata = devm_kzalloc(dev, sizeof(*pdata), GFP_KERNEL);
 851         if (!pdata) {
 852                 ret = -ENOMEM;
 853                 goto error;
 854         }
 855
 856         if (is_of_node(fwnode))
 857                 ret = of_get_coresight_platform_data(dev, pdata);
 858         else if (is_acpi_device_node(fwnode))
 859                 ret = acpi_get_coresight_platform_data(dev, pdata);
 860
 861         if (!ret)
 862                 return pdata;
 863 error:
 864         if (!IS_ERR_OR_NULL(pdata))
 865                 /* Cleanup the connection information */
 866                 coresight_release_platform_data(NULL, pdata);
 867         return ERR_PTR(ret);
 868 }
 869 EXPORT_SYMBOL_GPL(coresight_get_platform_data);