sys/arm64/coresight/coresight.c

   1 /*-
   2  * Copyright (c) 2018 Ruslan Bukin <br@bsdpad.com>
   3  * All rights reserved.
   4  *
   5  * This software was developed by SRI International and the University of
   6  * Cambridge Computer Laboratory under DARPA/AFRL contract FA8750-10-C-0237
   7  * ("CTSRD"), as part of the DARPA CRASH research programme.
   8  *
   9  * Redistribution and use in source and binary forms, with or without
  10  * modification, are permitted provided that the following conditions
  11  * are met:
  12  * 1. Redistributions of source code must retain the above copyright
  13  *    notice, this list of conditions and the following disclaimer.
  14  * 2. Redistributions in binary form must reproduce the above copyright
  15  *    notice, this list of conditions and the following disclaimer in the
  16  *    documentation and/or other materials provided with the distribution.
  17  *
  18  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  19  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  20  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  21  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  22  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  23  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  24  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  25  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  26  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  27  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  28  * SUCH DAMAGE.
  29  */
  30
  31 #include <sys/cdefs.h>
  32 __FBSDID("$FreeBSD$");
  33
  34 #include <sys/param.h>
  35 #include <sys/systm.h>
  36 #include <sys/bus.h>
  37 #include <sys/rman.h>
  38 #include <sys/kernel.h>
  39 #include <sys/lock.h>
  40 #include <sys/module.h>
  41 #include <sys/mutex.h>
  42 #include <machine/bus.h>
  43
  44 #include <dev/ofw/ofw_bus.h>
  45 #include <dev/ofw/ofw_bus_subr.h>
  46
  47 #include <arm64/coresight/coresight.h>
  48
  49 MALLOC_DEFINE(M_CORESIGHT, "coresight", "ARM Coresight");
  50 static struct mtx cs_mtx;
  51
  52 struct coresight_device_list cs_devs;
  53
  54 static int
  55 coresight_get_ports(phandle_t dev_node,
  56     struct coresight_platform_data *pdata)
  57 {
  58         phandle_t node, child;
  59         pcell_t port_reg;
  60         phandle_t xref;
  61         char *name;
  62         int ret;
  63         phandle_t endpoint_child;
  64         struct endpoint *endp;
  65
  66         child = ofw_bus_find_child(dev_node, "ports");
  67         if (child)
  68                 node = child;
  69         else
  70                 node = dev_node;
  71
  72         for (child = OF_child(node); child != 0; child = OF_peer(child)) {
  73                 ret = OF_getprop_alloc(child, "name", (void **)&name);
  74                 if (ret == -1)
  75                         continue;
  76
  77                 if (strcasecmp(name, "port") ||
  78                     strncasecmp(name, "port@", 6)) {
  79
  80                         port_reg = -1;
  81                         OF_getencprop(child, "reg", (void *)&port_reg, sizeof(port_reg));
  82
  83                         endpoint_child = ofw_bus_find_child(child, "endpoint");
  84                         if (endpoint_child) {
  85                                 if (OF_getencprop(endpoint_child, "remote-endpoint", &xref,
  86                                     sizeof(xref)) == -1) {
  87                                         printf("failed\n");
  88                                         continue;
  89                                 }
  90                                 endp = malloc(sizeof(struct endpoint), M_CORESIGHT,
  91                                     M_WAITOK | M_ZERO);
  92                                 endp->my_node = endpoint_child;
  93                                 endp->their_node = OF_node_from_xref(xref);
  94                                 endp->dev_node = dev_node;
  95                                 endp->reg = port_reg;
  96                                 if (OF_getproplen(endpoint_child, "slave-mode") >= 0) {
  97                                         pdata->in_ports++;
  98                                         endp->slave = 1;
  99                                 } else {
 100                                         pdata->out_ports++;
 101                                 }
 102
 103                                 mtx_lock(&pdata->mtx_lock);
 104                                 TAILQ_INSERT_TAIL(&pdata->endpoints, endp, link);
 105                                 mtx_unlock(&pdata->mtx_lock);
 106                         }
 107                 }
 108         }
 109
 110         return (0);
 111 }
 112
 113 int
 114 coresight_register(struct coresight_desc *desc)
 115 {
 116         struct coresight_device *cs_dev;
 117
 118         cs_dev = malloc(sizeof(struct coresight_device),
 119             M_CORESIGHT, M_WAITOK | M_ZERO);
 120         cs_dev->dev = desc->dev;
 121         cs_dev->node = ofw_bus_get_node(desc->dev);
 122         cs_dev->pdata = desc->pdata;
 123         cs_dev->dev_type = desc->dev_type;
 124
 125         mtx_lock(&cs_mtx);
 126         TAILQ_INSERT_TAIL(&cs_devs, cs_dev, link);
 127         mtx_unlock(&cs_mtx);
 128
 129         return (0);
 130 }
 131
 132 struct endpoint *
 133 coresight_get_output_endpoint(struct coresight_platform_data *pdata)
 134 {
 135         struct endpoint *endp;
 136
 137         if (pdata->out_ports != 1)
 138                 return (NULL);
 139
 140         TAILQ_FOREACH(endp, &pdata->endpoints, link) {
 141                 if (endp->slave == 0)
 142                         return (endp);
 143         }
 144
 145         return (NULL);
 146 }
 147
 148 struct coresight_device *
 149 coresight_get_output_device(struct endpoint *endp, struct endpoint **out_endp)
 150 {
 151         struct coresight_device *cs_dev;
 152         struct endpoint *endp2;
 153
 154         TAILQ_FOREACH(cs_dev, &cs_devs, link) {
 155                 TAILQ_FOREACH(endp2, &cs_dev->pdata->endpoints, link) {
 156                         if (endp->their_node == endp2->my_node) {
 157                                 *out_endp = endp2;
 158                                 return (cs_dev);
 159                         }
 160                 }
 161         }
 162
 163         return (NULL);
 164 }
 165
 166 static int
 167 coresight_get_cpu(phandle_t node,
 168     struct coresight_platform_data *pdata)
 169 {
 170         phandle_t cpu_node;
 171         pcell_t xref;
 172         pcell_t cpu_reg;
 173
 174         if (OF_getencprop(node, "cpu", &xref, sizeof(xref)) != -1) {
 175                 cpu_node = OF_node_from_xref(xref);
 176                 if (OF_getencprop(cpu_node, "reg", (void *)&cpu_reg,
 177                         sizeof(cpu_reg)) > 0) {
 178                         pdata->cpu = cpu_reg;
 179                         return (0);
 180                 }
 181         }
 182
 183         return (-1);
 184 }
 185
 186 struct coresight_platform_data *
 187 coresight_get_platform_data(device_t dev)
 188 {
 189         struct coresight_platform_data *pdata;
 190         phandle_t node;
 191
 192         node = ofw_bus_get_node(dev);
 193
 194         pdata = malloc(sizeof(struct coresight_platform_data),
 195             M_CORESIGHT, M_WAITOK | M_ZERO);
 196         mtx_init(&pdata->mtx_lock, "Coresight Platform Data", NULL, MTX_DEF);
 197         TAILQ_INIT(&pdata->endpoints);
 198
 199         coresight_get_cpu(node, pdata);
 200         coresight_get_ports(node, pdata);
 201
 202         if (bootverbose)
 203                 printf("Total ports: in %d out %d\n",
 204                     pdata->in_ports, pdata->out_ports);
 205
 206         return (pdata);
 207 }
 208
 209 static void
 210 coresight_init(void)
 211 {
 212
 213         mtx_init(&cs_mtx, "ARM Coresight", NULL, MTX_DEF);
 214         TAILQ_INIT(&cs_devs);
 215 }
 216
 217 SYSINIT(coresight, SI_SUB_DRIVERS, SI_ORDER_FIRST, coresight_init, NULL);