sys/arm64/arm64/gic_v3_acpi.c

   1 /*-
   2  * Copyright (c) 2016 The FreeBSD Foundation
   3  * All rights reserved.
   4  *
   5  * This software was developed by Andrew Turner under
   6  * the sponsorship of the FreeBSD Foundation.
   7  *
   8  * Redistribution and use in source and binary forms, with or without
   9  * modification, are permitted provided that the following conditions
  10  * are met:
  11  * 1. Redistributions of source code must retain the above copyright
  12  *    notice, this list of conditions and the following disclaimer.
  13  * 2. Redistributions in binary form must reproduce the above copyright
  14  *    notice, this list of conditions and the following disclaimer in the
  15  *    documentation and/or other materials provided with the distribution.
  16  *
  17  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  18  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  19  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  20  * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  21  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  22  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  23  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  24  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  25  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  26  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  27  * SUCH DAMAGE.
  28  */
  29
  30 #include "opt_acpi.h"
  31
  32 #include <sys/cdefs.h>
  33 __FBSDID("$FreeBSD$");
  34
  35 #include <sys/types.h>
  36 #include <sys/systm.h>
  37 #include <sys/bus.h>
  38 #include <sys/kernel.h>
  39 #include <sys/malloc.h>
  40 #include <sys/module.h>
  41 #include <sys/rman.h>
  42
  43 #include <machine/intr.h>
  44 #include <machine/resource.h>
  45
  46 #include <contrib/dev/acpica/include/acpi.h>
  47 #include <dev/acpica/acpivar.h>
  48
  49 #include "gic_v3_reg.h"
  50 #include "gic_v3_var.h"
  51
  52 struct gic_v3_acpi_devinfo {
  53         struct gic_v3_devinfo   di_gic_dinfo;
  54         struct resource_list    di_rl;
  55 };
  56
  57 static device_identify_t gic_v3_acpi_identify;
  58 static device_probe_t gic_v3_acpi_probe;
  59 static device_attach_t gic_v3_acpi_attach;
  60 static bus_alloc_resource_t gic_v3_acpi_bus_alloc_res;
  61
  62 static void gic_v3_acpi_bus_attach(device_t);
  63
  64 static device_method_t gic_v3_acpi_methods[] = {
  65         /* Device interface */
  66         DEVMETHOD(device_identify,              gic_v3_acpi_identify),
  67         DEVMETHOD(device_probe,                 gic_v3_acpi_probe),
  68         DEVMETHOD(device_attach,                gic_v3_acpi_attach),
  69
  70         /* Bus interface */
  71         DEVMETHOD(bus_alloc_resource,           gic_v3_acpi_bus_alloc_res),
  72         DEVMETHOD(bus_activate_resource,        bus_generic_activate_resource),
  73
  74         /* End */
  75         DEVMETHOD_END
  76 };
  77
  78 DEFINE_CLASS_1(gic, gic_v3_acpi_driver, gic_v3_acpi_methods,
  79     sizeof(struct gic_v3_softc), gic_v3_driver);
  80
  81 static devclass_t gic_v3_acpi_devclass;
  82
  83 EARLY_DRIVER_MODULE(gic_v3, acpi, gic_v3_acpi_driver, gic_v3_acpi_devclass,
  84     0, 0, BUS_PASS_INTERRUPT + BUS_PASS_ORDER_MIDDLE);
  85
  86 struct madt_table_data {
  87         device_t parent;
  88         device_t dev;
  89         ACPI_MADT_GENERIC_DISTRIBUTOR *dist;
  90         int count;
  91 };
  92
  93 static void
  94 madt_handler(ACPI_SUBTABLE_HEADER *entry, void *arg)
  95 {
  96         struct madt_table_data *madt_data;
  97
  98         madt_data = (struct madt_table_data *)arg;
  99
 100         switch(entry->Type) {
 101         case ACPI_MADT_TYPE_GENERIC_DISTRIBUTOR:
 102                 if (madt_data->dist != NULL) {
 103                         if (bootverbose)
 104                                 device_printf(madt_data->parent,
 105                                     "gic: Already have a distributor table");
 106                         break;
 107                 }
 108                 madt_data->dist = (ACPI_MADT_GENERIC_DISTRIBUTOR *)entry;
 109                 break;
 110
 111         case ACPI_MADT_TYPE_GENERIC_REDISTRIBUTOR:
 112                 break;
 113
 114         default:
 115                 break;
 116         }
 117 }
 118
 119 static void
 120 rdist_map(ACPI_SUBTABLE_HEADER *entry, void *arg)
 121 {
 122         ACPI_MADT_GENERIC_REDISTRIBUTOR *redist;
 123         struct madt_table_data *madt_data;
 124
 125         madt_data = (struct madt_table_data *)arg;
 126
 127         switch(entry->Type) {
 128         case ACPI_MADT_TYPE_GENERIC_REDISTRIBUTOR:
 129                 redist = (ACPI_MADT_GENERIC_REDISTRIBUTOR *)entry;
 130
 131                 madt_data->count++;
 132                 BUS_SET_RESOURCE(madt_data->parent, madt_data->dev,
 133                     SYS_RES_MEMORY, madt_data->count, redist->BaseAddress,
 134                     redist->Length);
 135                 break;
 136
 137         default:
 138                 break;
 139         }
 140 }
 141
 142 static void
 143 gic_v3_acpi_identify(driver_t *driver, device_t parent)
 144 {
 145         struct madt_table_data madt_data;
 146         ACPI_TABLE_MADT *madt;
 147         vm_paddr_t physaddr;
 148         device_t dev;
 149
 150         physaddr = acpi_find_table(ACPI_SIG_MADT);
 151         if (physaddr == 0)
 152                 return;
 153
 154         madt = acpi_map_table(physaddr, ACPI_SIG_MADT);
 155         if (madt == NULL) {
 156                 device_printf(parent, "gic: Unable to map the MADT\n");
 157                 return;
 158         }
 159
 160         madt_data.parent = parent;
 161         madt_data.dist = NULL;
 162         madt_data.count = 0;
 163
 164         acpi_walk_subtables(madt + 1, (char *)madt + madt->Header.Length,
 165             madt_handler, &madt_data);
 166         if (madt_data.dist == NULL) {
 167                 device_printf(parent,
 168                     "No gic interrupt or distributor table\n");
 169                 goto out;
 170         }
 171         /* This is for the wrong GIC version */
 172         if (madt_data.dist->Version != ACPI_MADT_GIC_VERSION_V3)
 173                 goto out;
 174
 175         dev = BUS_ADD_CHILD(parent, BUS_PASS_INTERRUPT + BUS_PASS_ORDER_MIDDLE,
 176             "gic", -1);
 177         if (dev == NULL) {
 178                 device_printf(parent, "add gic child failed\n");
 179                 goto out;
 180         }
 181
 182         /* Add the MADT data */
 183         BUS_SET_RESOURCE(parent, dev, SYS_RES_MEMORY, 0,
 184             madt_data.dist->BaseAddress, 128 * 1024);
 185
 186         madt_data.dev = dev;
 187         acpi_walk_subtables(madt + 1, (char *)madt + madt->Header.Length,
 188             rdist_map, &madt_data);
 189
 190         acpi_set_private(dev, (void *)(uintptr_t)madt_data.dist->Version);
 191
 192 out:
 193         acpi_unmap_table(madt);
 194 }
 195
 196 static int
 197 gic_v3_acpi_probe(device_t dev)
 198 {
 199
 200         switch((uintptr_t)acpi_get_private(dev)) {
 201         case ACPI_MADT_GIC_VERSION_V3:
 202                 break;
 203         default:
 204                 return (ENXIO);
 205         }
 206
 207         device_set_desc(dev, GIC_V3_DEVSTR);
 208         return (BUS_PROBE_NOWILDCARD);
 209 }
 210
 211 static void
 212 madt_count_redistrib(ACPI_SUBTABLE_HEADER *entry, void *arg)
 213 {
 214         struct gic_v3_softc *sc = arg;
 215
 216         if (entry->Type == ACPI_MADT_TYPE_GENERIC_REDISTRIBUTOR)
 217                 sc->gic_redists.nregions++;
 218 }
 219
 220 static int
 221 gic_v3_acpi_count_regions(device_t dev)
 222 {
 223         struct gic_v3_softc *sc;
 224         ACPI_TABLE_MADT *madt;
 225         vm_paddr_t physaddr;
 226
 227         sc = device_get_softc(dev);
 228
 229         physaddr = acpi_find_table(ACPI_SIG_MADT);
 230         if (physaddr == 0)
 231                 return (ENXIO);
 232
 233         madt = acpi_map_table(physaddr, ACPI_SIG_MADT);
 234         if (madt == NULL) {
 235                 device_printf(dev, "Unable to map the MADT\n");
 236                 return (ENXIO);
 237         }
 238
 239         acpi_walk_subtables(madt + 1, (char *)madt + madt->Header.Length,
 240             madt_count_redistrib, sc);
 241         acpi_unmap_table(madt);
 242
 243         return (sc->gic_redists.nregions > 0 ? 0 : ENXIO);
 244 }
 245
 246 static int
 247 gic_v3_acpi_attach(device_t dev)
 248 {
 249         struct gic_v3_softc *sc;
 250         int err;
 251
 252         sc = device_get_softc(dev);
 253         sc->dev = dev;
 254         sc->gic_bus = GIC_BUS_ACPI;
 255
 256         err = gic_v3_acpi_count_regions(dev);
 257         if (err != 0)
 258                 goto error;
 259
 260         err = gic_v3_attach(dev);
 261         if (err != 0)
 262                 goto error;
 263
 264         sc->gic_pic = intr_pic_register(dev, ACPI_INTR_XREF);
 265         if (sc->gic_pic == NULL) {
 266                 device_printf(dev, "could not register PIC\n");
 267                 err = ENXIO;
 268                 goto error;
 269         }
 270
 271         if (intr_pic_claim_root(dev, ACPI_INTR_XREF, arm_gic_v3_intr, sc,
 272             GIC_LAST_SGI - GIC_FIRST_SGI + 1) != 0) {
 273                 err = ENXIO;
 274                 goto error;
 275         }
 276
 277         /*
 278          * Try to register the ITS driver to this GIC. The GIC will act as
 279          * a bus in that case. Failure here will not affect the main GIC
 280          * functionality.
 281          */
 282         gic_v3_acpi_bus_attach(dev);
 283
 284         if (device_get_children(dev, &sc->gic_children, &sc->gic_nchildren) !=0)
 285                 sc->gic_nchildren = 0;
 286
 287         return (0);
 288
 289 error:
 290         if (bootverbose) {
 291                 device_printf(dev,
 292                     "Failed to attach. Error %d\n", err);
 293         }
 294         /* Failure so free resources */
 295         gic_v3_detach(dev);
 296
 297         return (err);
 298 }
 299
 300 static void
 301 gic_v3_add_children(ACPI_SUBTABLE_HEADER *entry, void *arg)
 302 {
 303         ACPI_MADT_GENERIC_TRANSLATOR *gict;
 304         struct gic_v3_acpi_devinfo *di;
 305         struct gic_v3_softc *sc;
 306         device_t child, dev;
 307         u_int xref;
 308         int err, pxm;
 309
 310         if (entry->Type == ACPI_MADT_TYPE_GENERIC_TRANSLATOR) {
 311                 /* We have an ITS, add it as a child */
 312                 gict = (ACPI_MADT_GENERIC_TRANSLATOR *)entry;
 313                 dev = arg;
 314                 sc = device_get_softc(dev);
 315
 316                 child = device_add_child(dev, "its", -1);
 317                 if (child == NULL)
 318                         return;
 319
 320                 di = malloc(sizeof(*di), M_GIC_V3, M_WAITOK | M_ZERO);
 321                 resource_list_init(&di->di_rl);
 322                 resource_list_add(&di->di_rl, SYS_RES_MEMORY, 0,
 323                     gict->BaseAddress, gict->BaseAddress + 128 * 1024 - 1,
 324                     128 * 1024);
 325                 err = acpi_iort_its_lookup(gict->TranslationId, &xref, &pxm);
 326                 if (err == 0) {
 327                         di->di_gic_dinfo.gic_domain = pxm;
 328                         di->di_gic_dinfo.msi_xref = xref;
 329                 } else {
 330                         di->di_gic_dinfo.gic_domain = -1;
 331                         di->di_gic_dinfo.msi_xref = ACPI_MSI_XREF;
 332                 }
 333                 sc->gic_nchildren++;
 334                 device_set_ivars(child, di);
 335         }
 336 }
 337
 338 static void
 339 gic_v3_acpi_bus_attach(device_t dev)
 340 {
 341         ACPI_TABLE_MADT *madt;
 342         vm_paddr_t physaddr;
 343
 344         physaddr = acpi_find_table(ACPI_SIG_MADT);
 345         if (physaddr == 0)
 346                 return;
 347
 348         madt = acpi_map_table(physaddr, ACPI_SIG_MADT);
 349         if (madt == NULL) {
 350                 device_printf(dev, "Unable to map the MADT to add children\n");
 351                 return;
 352         }
 353
 354         acpi_walk_subtables(madt + 1, (char *)madt + madt->Header.Length,
 355             gic_v3_add_children, dev);
 356
 357         acpi_unmap_table(madt);
 358
 359         bus_generic_attach(dev);
 360 }
 361
 362 static struct resource *
 363 gic_v3_acpi_bus_alloc_res(device_t bus, device_t child, int type, int *rid,
 364     rman_res_t start, rman_res_t end, rman_res_t count, u_int flags)
 365 {
 366         struct gic_v3_acpi_devinfo *di;
 367         struct resource_list_entry *rle;
 368
 369         /* We only allocate memory */
 370         if (type != SYS_RES_MEMORY)
 371                 return (NULL);
 372
 373         if (RMAN_IS_DEFAULT_RANGE(start, end)) {
 374                 if ((di = device_get_ivars(child)) == NULL)
 375                         return (NULL);
 376
 377                 /* Find defaults for this rid */
 378                 rle = resource_list_find(&di->di_rl, type, *rid);
 379                 if (rle == NULL)
 380                         return (NULL);
 381
 382                 start = rle->start;
 383                 end = rle->end;
 384                 count = rle->count;
 385         }
 386
 387         return (bus_generic_alloc_resource(bus, child, type, rid, start, end,
 388             count, flags));
 389 }