lib/ecam.c

   1 /*
   2  *      The PCI Library -- Direct Configuration access via PCIe ECAM
   3  *
   4  *      Copyright (c) 2023 Pali Rohár <pali@kernel.org>
   5  *
   6  *      Can be freely distributed and used under the terms of the GNU GPL v2+.
   7  *
   8  *      SPDX-License-Identifier: GPL-2.0-or-later
   9  */
  10
  11 #include "internal.h"
  12 #include "physmem.h"
  13 #include "physmem-access.h"
  14
  15 #include <ctype.h>
  16 #include <errno.h>
  17 #include <stdio.h>
  18 #include <stdlib.h>
  19 #include <string.h>
  20 #include <limits.h>
  21
  22 #include <glob.h>
  23 #include <unistd.h>
  24
  25 #if defined (__FreeBSD__) || defined (__DragonFly__) || defined(__NetBSD__)
  26 #include <sys/sysctl.h>
  27 #endif
  28
  29 #if defined (__FreeBSD__) || defined (__DragonFly__)
  30 #include <kenv.h>
  31 #endif
  32
  33 struct acpi_rsdp {
  34   char signature[8];
  35   u8 checksum;
  36   char oem_id[6];
  37   u8 revision;
  38   u32 rsdt_address;
  39   struct {
  40     u32 length;
  41     u64 xsdt_address;
  42     u8 ext_checksum;
  43     u8 reserved[3];
  44   } rsdp20[0];
  45 } PCI_PACKED;
  46
  47 struct acpi_sdt {
  48   char signature[4];
  49   u32 length;
  50   u8 revision;
  51   u8 checksum;
  52   char oem_id[6];
  53   char oem_table_id[8];
  54   u32 oem_revision;
  55   char asl_compiler_id[4];
  56   u32 asl_compiler_revision;
  57 } PCI_PACKED;
  58
  59 struct acpi_rsdt {
  60   struct acpi_sdt sdt;
  61   u32 sdt_addresses[0];
  62 } PCI_PACKED;
  63
  64 struct acpi_xsdt {
  65   struct acpi_sdt sdt;
  66   u64 sdt_addresses[0];
  67 } PCI_PACKED;
  68
  69 struct acpi_mcfg {
  70   struct acpi_sdt sdt;
  71   u64 reserved;
  72   struct {
  73     u64 address;
  74     u16 pci_segment;
  75     u8 start_bus_number;
  76     u8 end_bus_number;
  77     u32 reserved;
  78   } allocations[0];
  79 } PCI_PACKED;
  80
  81 struct mmap_cache {
  82   void *map;
  83   u64 addr;
  84   u32 length;
  85   int domain;
  86   u8 bus;
  87   int w;
  88 };
  89
  90 // Back-end data linked to struct pci_access
  91 struct ecam_access {
  92   struct acpi_mcfg *mcfg;
  93   struct mmap_cache *cache;
  94   struct physmem *physmem;
  95   long pagesize;
  96 };
  97
  98 static unsigned int
  99 get_rsdt_addresses_count(struct acpi_rsdt *rsdt)
 100 {
 101   return (rsdt->sdt.length - ((unsigned char*)&rsdt->sdt_addresses - (unsigned char *)rsdt)) / sizeof(rsdt->sdt_addresses[0]);
 102 }
 103
 104 static unsigned int
 105 get_xsdt_addresses_count(struct acpi_xsdt *xsdt)
 106 {
 107   return (xsdt->sdt.length - ((unsigned char*)&xsdt->sdt_addresses - (unsigned char *)xsdt)) / sizeof(xsdt->sdt_addresses[0]);
 108 }
 109
 110 static unsigned int
 111 get_mcfg_allocations_count(struct acpi_mcfg *mcfg)
 112 {
 113   return (mcfg->sdt.length - ((unsigned char *)&mcfg->allocations - (unsigned char *)mcfg)) / sizeof(mcfg->allocations[0]);
 114 }
 115
 116 static u8
 117 calculate_checksum(const u8 *bytes, int len)
 118 {
 119   u8 checksum = 0;
 120
 121   while (len-- > 0)
 122     checksum -= *(bytes++);
 123   return checksum;
 124 }
 125
 126 static struct acpi_sdt *
 127 check_and_map_sdt(struct physmem *physmem, long pagesize, u64 addr, const char *signature, void **map_addr, u32 *map_length)
 128 {
 129   struct acpi_sdt *sdt;
 130   char sdt_signature[sizeof(sdt->signature)];
 131   u32 length;
 132   void *map;
 133
 134   if (addr + sizeof(*sdt) < addr)
 135     return NULL;
 136
 137   map = physmem_map(physmem, addr & ~(pagesize-1), sizeof(*sdt) + (addr & (pagesize-1)), 0);
 138   if (map == (void *)-1)
 139     return NULL;
 140
 141   sdt = (struct acpi_sdt *)((unsigned char *)map + (addr & (pagesize-1)));
 142   length = sdt->length;
 143   memcpy(sdt_signature, sdt->signature, sizeof(sdt->signature));
 144
 145   physmem_unmap(physmem, map, sizeof(*sdt) + (addr & (pagesize-1)));
 146
 147   if (memcmp(sdt_signature, signature, sizeof(sdt_signature)) != 0)
 148     return NULL;
 149   if (length < sizeof(*sdt))
 150     return NULL;
 151
 152   map = physmem_map(physmem, addr & ~(pagesize-1), length + (addr & (pagesize-1)), 0);
 153   if (map == (void *)-1)
 154     return NULL;
 155
 156   sdt = (struct acpi_sdt *)((unsigned char *)map + (addr & (pagesize-1)));
 157
 158   if (calculate_checksum((u8 *)sdt, sdt->length) != 0)
 159     {
 160       physmem_unmap(physmem, map, length + (addr & (pagesize-1)));
 161       return NULL;
 162     }
 163
 164   *map_addr = map;
 165   *map_length = length + (addr & (pagesize-1));
 166   return sdt;
 167 }
 168
 169 static int
 170 check_rsdp(struct acpi_rsdp *rsdp)
 171 {
 172   if (memcmp(rsdp->signature, "RSD PTR ", sizeof(rsdp->signature)) != 0)
 173     return 0;
 174   if (calculate_checksum((u8 *)rsdp, sizeof(*rsdp)) != 0)
 175     return 0;
 176   return 1;
 177 }
 178
 179 static int
 180 check_and_parse_rsdp(struct physmem *physmem, long pagesize, u64 addr, u32 *rsdt_address, u64 *xsdt_address)
 181 {
 182   struct acpi_rsdp *rsdp;
 183   unsigned char buf[sizeof(*rsdp) + sizeof(*rsdp->rsdp20)];
 184   void *map;
 185
 186   map = physmem_map(physmem, addr & ~(pagesize-1), sizeof(buf) + (addr & (pagesize-1)), 0);
 187   if (map == (void *)-1)
 188     return 0;
 189
 190   rsdp = (struct acpi_rsdp *)buf;
 191   memcpy(rsdp, (unsigned char *)map + (addr & (pagesize-1)), sizeof(buf));
 192
 193   physmem_unmap(physmem, map, sizeof(buf));
 194
 195   if (!check_rsdp(rsdp))
 196     return 0;
 197
 198   *rsdt_address = rsdp->rsdt_address;
 199
 200   if (rsdp->revision != 0 &&
 201       (*rsdp->rsdp20).length == sizeof(*rsdp) + sizeof(*rsdp->rsdp20) &&
 202       calculate_checksum((u8 *)rsdp, (*rsdp->rsdp20).length) == 0)
 203     *xsdt_address = (*rsdp->rsdp20).xsdt_address;
 204   else
 205     *xsdt_address = 0;
 206
 207   return 1;
 208 }
 209
 210 static u64
 211 find_rsdp_address(struct pci_access *a, const char *efisystab, int use_bsd UNUSED, int use_x86bios UNUSED)
 212 {
 213   u64 ullnum;
 214 #if defined (__FreeBSD__) || defined (__DragonFly__) || defined(__NetBSD__)
 215   unsigned long ulnum;
 216 #endif
 217   char buf[1024];
 218   char *endptr;
 219   u64 acpi20;
 220   u64 acpi;
 221 #if defined(__amd64__) || defined(__i386__)
 222   struct ecam_access *eacc = a->backend_data;
 223   struct physmem *physmem = eacc->physmem;
 224   u64 rsdp_addr;
 225   u64 addr;
 226   void *map;
 227 #endif
 228   size_t len;
 229   FILE *f;
 230
 231   if (efisystab[0])
 232     {
 233       acpi = 0;
 234       acpi20 = 0;
 235       a->debug("reading EFI system table: %s...", efisystab);
 236       f = fopen(efisystab, "r");
 237       if (f)
 238         {
 239           while (fgets(buf, sizeof(buf), f))
 240             {
 241               len = strlen(buf);
 242               while (len > 0 && buf[len-1] == '\n')
 243                 buf[--len] = '\0';
 244               if (strncmp(buf, "ACPI20=", 7) == 0 && isxdigit(buf[7]))
 245                 {
 246                   errno = 0;
 247                   ullnum = strtoull(buf+7, &endptr, 16);
 248                   if (!errno && !*endptr)
 249                     acpi20 = ullnum;
 250                 }
 251               else if (strncmp(buf, "ACPI=", 5) == 0 && isxdigit(buf[5]))
 252                 {
 253                   errno = 0;
 254                   ullnum = strtoull(buf+5, &endptr, 16);
 255                   if (!errno && !*endptr)
 256                     acpi = ullnum;
 257                 }
 258             }
 259           fclose(f);
 260         }
 261       else
 262         a->debug("opening failed: %s...", strerror(errno));
 263
 264       if (acpi20)
 265         return acpi20;
 266       else if (acpi)
 267         return acpi;
 268     }
 269
 270 #if defined (__FreeBSD__) || defined (__DragonFly__)
 271   if (use_bsd)
 272     {
 273       /* First try FreeBSD kenv hint.acpi.0.rsdp */
 274       a->debug("calling kenv hint.acpi.0.rsdp...");
 275       if (kenv(KENV_GET, "hint.acpi.0.rsdp", buf, sizeof(buf)) > 0)
 276         {
 277           errno = 0;
 278           ullnum = strtoull(buf, &endptr, 16);
 279           if (!errno && !*endptr)
 280             return ullnum;
 281         }
 282
 283       /* Then try FreeBSD sysctl machdep.acpi_root */
 284       a->debug("calling sysctl machdep.acpi_root...");
 285       len = sizeof(ulnum);
 286       if (sysctlbyname("machdep.acpi_root", &ulnum, &len, NULL, 0) == 0)
 287         return ulnum;
 288     }
 289 #endif
 290
 291 #if defined(__NetBSD__)
 292   if (use_bsd)
 293     {
 294       /* Try NetBSD sysctl hw.acpi.root */
 295       a->debug("calling sysctl hw.acpi.root...");
 296       len = sizeof(ulnum);
 297       if (sysctlbyname("hw.acpi.root", &ulnum, &len, NULL, 0) == 0)
 298         return ulnum;
 299     }
 300 #endif
 301
 302 #if defined(__amd64__) || defined(__i386__)
 303   if (use_x86bios)
 304     {
 305       rsdp_addr = 0;
 306
 307       /* Scan first kB of Extended BIOS Data Area */
 308       a->debug("scanning first kB of EBDA...");
 309       map = physmem_map(physmem, 0, 0x40E + 1024, 0);
 310       if (map != (void *)-1)
 311         {
 312           for (addr = 0x40E; addr < 0x40E + 1024; addr += 16)
 313             {
 314               if (check_rsdp((struct acpi_rsdp *)((unsigned char *)map + addr)))
 315                 {
 316                   rsdp_addr = addr;
 317                   break;
 318                 }
 319             }
 320           if (physmem_unmap(physmem, map, 0x40E + 1024) != 0)
 321             a->debug("unmapping of EBDA failed: %s...", strerror(errno));
 322         }
 323       else
 324         a->debug("mapping of EBDA failed: %s...", strerror(errno));
 325
 326       if (rsdp_addr)
 327         return rsdp_addr;
 328
 329       /* Scan the main BIOS area below 1 MB */
 330       a->debug("scanning BIOS below 1 MB...");
 331       map = physmem_map(physmem, 0xE0000, 0x20000, 0);
 332       if (map != (void *)-1)
 333         {
 334           for (addr = 0x0; addr < 0x20000; addr += 16)
 335             {
 336               if (check_rsdp((struct acpi_rsdp *)((unsigned char *)map + addr)))
 337                 {
 338                   rsdp_addr = 0xE0000 + addr;
 339                   break;
 340                 }
 341             }
 342           if (physmem_unmap(physmem, map, 0x20000) != 0)
 343             a->debug("unmapping of BIOS failed: %s...", strerror(errno));
 344         }
 345       else
 346         a->debug("mapping of BIOS failed: %s...", strerror(errno));
 347
 348       if (rsdp_addr)
 349         return rsdp_addr;
 350     }
 351 #endif
 352
 353   return 0;
 354 }
 355
 356 static struct acpi_mcfg *
 357 find_mcfg(struct pci_access *a, const char *acpimcfg, const char *efisystab, int use_bsd, int use_x86bios)
 358 {
 359   struct ecam_access *eacc = a->backend_data;
 360   struct physmem *physmem = eacc->physmem;
 361   long pagesize = eacc->pagesize;
 362   struct acpi_xsdt *xsdt;
 363   struct acpi_rsdt *rsdt;
 364   struct acpi_mcfg *mcfg;
 365   struct acpi_sdt *sdt;
 366   unsigned int i, count;
 367   u64 rsdp_address;
 368   u64 xsdt_address;
 369   u32 rsdt_address;
 370   void *map_addr;
 371   u32 map_length;
 372   void *map2_addr;
 373   u32 map2_length;
 374   long length;
 375   FILE *mcfg_file;
 376   const char *path;
 377   glob_t mcfg_glob;
 378   int ret;
 379
 380   if (acpimcfg[0])
 381     {
 382       ret = glob(acpimcfg, GLOB_NOCHECK, NULL, &mcfg_glob);
 383       if (ret == 0)
 384         {
 385           path = mcfg_glob.gl_pathv[0];
 386           a->debug("reading acpi mcfg file: %s...", path);
 387           mcfg_file = fopen(path, "rb");
 388           globfree(&mcfg_glob);
 389           if (mcfg_file)
 390             {
 391               if (fseek(mcfg_file, 0, SEEK_END) == 0)
 392                 length = ftell(mcfg_file);
 393               else
 394                 length = -1;
 395               if (length > 0 && (size_t)length > sizeof(*mcfg))
 396                 {
 397                   rewind(mcfg_file);
 398                   mcfg = pci_malloc(a, length);
 399                   if (fread(mcfg, 1, length, mcfg_file) == (size_t)length &&
 400                       memcmp(mcfg->sdt.signature, "MCFG", 4) == 0 &&
 401                       mcfg->sdt.length <= (size_t)length &&
 402                       calculate_checksum((u8 *)mcfg, mcfg->sdt.length) == 0)
 403                     {
 404                       fclose(mcfg_file);
 405                       return mcfg;
 406                     }
 407                 }
 408               fclose(mcfg_file);
 409             }
 410           a->debug("failed...");
 411         }
 412       else
 413         a->debug("glob(%s) failed: %d...", acpimcfg, ret);
 414     }
 415
 416   a->debug("searching for ACPI RSDP...");
 417   rsdp_address = find_rsdp_address(a, efisystab, use_bsd, use_x86bios);
 418   if (!rsdp_address)
 419     {
 420       a->debug("not found...");
 421       return NULL;
 422     }
 423   a->debug("found at 0x%" PCI_U64_FMT_X "...", rsdp_address);
 424
 425   if (!check_and_parse_rsdp(physmem, pagesize, rsdp_address, &rsdt_address, &xsdt_address))
 426     {
 427       a->debug("invalid...");
 428       return NULL;
 429     }
 430
 431   mcfg = NULL;
 432   a->debug("searching for ACPI MCFG (XSDT=0x%" PCI_U64_FMT_X ", RSDT=0x%lx)...", xsdt_address, (unsigned long)rsdt_address);
 433
 434   xsdt = xsdt_address ? (struct acpi_xsdt *)check_and_map_sdt(physmem, pagesize, xsdt_address, "XSDT", &map_addr, &map_length) : NULL;
 435   if (xsdt)
 436     {
 437       a->debug("via XSDT...");
 438       count = get_xsdt_addresses_count(xsdt);
 439       for (i = 0; i < count; i++)
 440         {
 441           sdt = check_and_map_sdt(physmem, pagesize, xsdt->sdt_addresses[i], "MCFG", &map2_addr, &map2_length);
 442           if (sdt)
 443             {
 444               mcfg = pci_malloc(a, sdt->length);
 445               memcpy(mcfg, sdt, sdt->length);
 446               physmem_unmap(physmem, map2_addr, map2_length);
 447               break;
 448             }
 449         }
 450       physmem_unmap(physmem, map_addr, map_length);
 451       if (mcfg)
 452         {
 453           a->debug("found...");
 454           return mcfg;
 455         }
 456     }
 457
 458   rsdt = (struct acpi_rsdt *)check_and_map_sdt(physmem, pagesize, rsdt_address, "RSDT", &map_addr, &map_length);
 459   if (rsdt)
 460     {
 461       a->debug("via RSDT...");
 462       count = get_rsdt_addresses_count(rsdt);
 463       for (i = 0; i < count; i++)
 464         {
 465           sdt = check_and_map_sdt(physmem, pagesize, rsdt->sdt_addresses[i], "MCFG", &map2_addr, &map2_length);
 466           if (sdt)
 467             {
 468               mcfg = pci_malloc(a, sdt->length);
 469               memcpy(mcfg, sdt, sdt->length);
 470               physmem_unmap(physmem, map2_addr, map2_length);
 471               break;
 472             }
 473         }
 474       physmem_unmap(physmem, map_addr, map_length);
 475       if (mcfg)
 476         {
 477           a->debug("found...");
 478           return mcfg;
 479         }
 480     }
 481
 482   a->debug("not found...");
 483   return NULL;
 484 }
 485
 486 static void
 487 get_mcfg_allocation(struct acpi_mcfg *mcfg, unsigned int i, int *domain, u8 *start_bus, u8 *end_bus, u64 *addr, u32 *length)
 488 {
 489   int buses = (int)mcfg->allocations[i].end_bus_number - (int)mcfg->allocations[i].start_bus_number + 1;
 490
 491   if (domain)
 492     *domain = mcfg->allocations[i].pci_segment;
 493   if (start_bus)
 494     *start_bus = mcfg->allocations[i].start_bus_number;
 495   if (end_bus)
 496     *end_bus = mcfg->allocations[i].end_bus_number;
 497   if (addr)
 498     *addr = mcfg->allocations[i].address;
 499   if (length)
 500     *length = (buses > 0) ? (buses * 32 * 8 * 4096) : 0;
 501 }
 502
 503 static int
 504 parse_next_addrs(const char *addrs, const char **next, int *domain, u8 *start_bus, u8 *end_bus, u64 *addr, u32 *length)
 505 {
 506   u64 ullnum;
 507   const char *sep1, *sep2;
 508   int addr_len;
 509   char *endptr;
 510   long num;
 511   int buses;
 512   u64 start_addr;
 513
 514   if (!*addrs)
 515     {
 516       if (next)
 517         *next = NULL;
 518       return 0;
 519     }
 520
 521   endptr = strchr(addrs, ',');
 522   if (endptr)
 523     addr_len = endptr - addrs;
 524   else
 525     addr_len = strlen(addrs);
 526
 527   if (next)
 528     *next = endptr ? (endptr+1) : NULL;
 529
 530   sep1 = memchr(addrs, ':', addr_len);
 531   if (!sep1)
 532     return 0;
 533
 534   sep2 = memchr(sep1+1, ':', addr_len - (sep1+1 - addrs));
 535   if (!sep2)
 536     {
 537       sep2 = sep1;
 538       sep1 = NULL;
 539     }
 540
 541   if (!sep1)
 542     {
 543       if (domain)
 544         *domain = 0;
 545     }
 546   else
 547     {
 548       if (!isxdigit(*addrs))
 549         return 0;
 550       errno = 0;
 551       num = strtol(addrs, &endptr, 16);
 552       if (errno || endptr != sep1 || num < 0 || num > INT_MAX)
 553         return 0;
 554       if (domain)
 555         *domain = num;
 556     }
 557
 558   errno = 0;
 559   num = strtol(sep1 ? (sep1+1) : addrs, &endptr, 16);
 560   if (errno || num < 0 || num > 0xff)
 561     return 0;
 562   if (start_bus)
 563     *start_bus = num;
 564
 565   buses = -num;
 566
 567   if (endptr != sep2)
 568     {
 569       if (*endptr != '-')
 570         return 0;
 571       errno = 0;
 572       num = strtol(endptr+1, &endptr, 16);
 573       if (errno || endptr != sep2 || num < 0 || num > 0xff)
 574         return 0;
 575       buses = num - -buses + 1;
 576       if (buses <= 0)
 577         return 0;
 578       if (end_bus)
 579         *end_bus = num;
 580     }
 581
 582   if (!isxdigit(*(sep2+1)))
 583     return 0;
 584
 585   errno = 0;
 586   ullnum = strtoull(sep2+1, &endptr, 16);
 587   if (errno || (ullnum & 3))
 588     return 0;
 589   if (addr)
 590     *addr = ullnum;
 591   start_addr = ullnum;
 592
 593   if (endptr == addrs + addr_len)
 594     {
 595       if (buses <= 0)
 596         {
 597           buses = 0xff - -buses + 1;
 598           if (end_bus)
 599             *end_bus = 0xff;
 600         }
 601       if (start_addr + (unsigned)buses * 32 * 8 * 4096 < start_addr)
 602         return 0;
 603       if (length)
 604         *length = buses * 32 * 8 * 4096;
 605     }
 606   else
 607     {
 608       if (*endptr != '+' || !isxdigit(*(endptr+1)))
 609         return 0;
 610       errno = 0;
 611       ullnum = strtoull(endptr+1, &endptr, 16);
 612       if (errno || endptr != addrs + addr_len || (ullnum & 3) || ullnum > 256 * 32 * 8 * 4096)
 613         return 0;
 614       if (start_addr + ullnum < start_addr)
 615         return 0;
 616       if (buses > 0 && ullnum > (unsigned)buses * 32 * 8 * 4096)
 617         return 0;
 618       if (buses <= 0 && ullnum > (0xff - (unsigned)-buses + 1) * 32 * 8 * 4096)
 619         return 0;
 620       if (length)
 621         *length = ullnum;
 622       if (buses <= 0 && end_bus)
 623         *end_bus = -buses + (ullnum + 32 * 8 * 4096 - 1) / (32 * 8 * 4096);
 624     }
 625
 626   return 1;
 627 }
 628
 629 static int
 630 validate_addrs(const char *addrs)
 631 {
 632   if (!*addrs)
 633     return 1;
 634
 635   while (addrs)
 636     if (!parse_next_addrs(addrs, &addrs, NULL, NULL, NULL, NULL, NULL))
 637       return 0;
 638
 639   return 1;
 640 }
 641
 642 static int
 643 calculate_bus_addr(u8 start_bus, u64 start_addr, u32 total_length, u8 bus, u64 *addr, u32 *length)
 644 {
 645   u32 offset;
 646
 647   offset = 32*8*4096 * (bus - start_bus);
 648   if (offset >= total_length)
 649     return 0;
 650
 651   *addr = start_addr + offset;
 652   *length = total_length - offset;
 653
 654   if (*length > 32*8*4096)
 655     *length = 32*8*4096;
 656
 657   return 1;
 658 }
 659
 660 static int
 661 get_bus_addr(struct acpi_mcfg *mcfg, const char *addrs, int domain, u8 bus, u64 *addr, u32 *length)
 662 {
 663   int cur_domain;
 664   u8 start_bus;
 665   u8 end_bus;
 666   u64 start_addr;
 667   u32 total_length;
 668   int i, count;
 669
 670   if (mcfg)
 671     {
 672       count = get_mcfg_allocations_count(mcfg);
 673       for (i = 0; i < count; i++)
 674         {
 675           get_mcfg_allocation(mcfg, i, &cur_domain, &start_bus, &end_bus, &start_addr, &total_length);
 676           if (domain == cur_domain && bus >= start_bus && bus <= end_bus)
 677             return calculate_bus_addr(start_bus, start_addr, total_length, bus, addr, length);
 678         }
 679       return 0;
 680     }
 681   else
 682     {
 683       while (addrs)
 684         {
 685           if (!parse_next_addrs(addrs, &addrs, &cur_domain, &start_bus, &end_bus, &start_addr, &total_length))
 686             return 0;
 687           if (domain == cur_domain && bus >= start_bus && bus <= end_bus)
 688             return calculate_bus_addr(start_bus, start_addr, total_length, bus, addr, length);
 689         }
 690       return 0;
 691     }
 692 }
 693
 694 static void
 695 munmap_reg(struct pci_access *a)
 696 {
 697   struct ecam_access *eacc = a->backend_data;
 698   struct mmap_cache *cache = eacc->cache;
 699   struct physmem *physmem = eacc->physmem;
 700   long pagesize = eacc->pagesize;
 701
 702   if (!cache)
 703     return;
 704
 705   physmem_unmap(physmem, cache->map, cache->length + (cache->addr & (pagesize-1)));
 706   pci_mfree(cache);
 707   eacc->cache = NULL;
 708 }
 709
 710 static int
 711 mmap_reg(struct pci_access *a, int w, int domain, u8 bus, u8 dev, u8 func, int pos, volatile void **reg)
 712 {
 713   struct ecam_access *eacc = a->backend_data;
 714   struct mmap_cache *cache = eacc->cache;
 715   struct physmem *physmem = eacc->physmem;
 716   long pagesize = eacc->pagesize;
 717   const char *addrs;
 718   void *map;
 719   u64 addr;
 720   u32 length;
 721   u32 offset;
 722
 723   if (cache && cache->domain == domain && cache->bus == bus && !!cache->w == !!w)
 724     {
 725       map = cache->map;
 726       addr = cache->addr;
 727       length = cache->length;
 728     }
 729   else
 730     {
 731       addrs = pci_get_param(a, "ecam.addrs");
 732       if (!get_bus_addr(eacc->mcfg, addrs, domain, bus, &addr, &length))
 733         return 0;
 734
 735       map = physmem_map(physmem, addr & ~(pagesize-1), length + (addr & (pagesize-1)), w);
 736       if (map == (void *)-1)
 737         return 0;
 738
 739       if (cache)
 740         physmem_unmap(physmem, cache->map, cache->length + (cache->addr & (pagesize-1)));
 741       else
 742         cache = eacc->cache = pci_malloc(a, sizeof(*cache));
 743
 744       cache->map = map;
 745       cache->addr = addr;
 746       cache->length = length;
 747       cache->domain = domain;
 748       cache->bus = bus;
 749       cache->w = w;
 750     }
 751
 752   /*
 753    * Enhanced Configuration Access Mechanism (ECAM) offset according to:
 754    * PCI Express Base Specification, Revision 5.0, Version 1.0, Section 7.2.2, Table 7-1, p. 677
 755    */
 756   offset = ((dev & 0x1f) << 15) | ((func & 0x7) << 12) | (pos & 0xfff);
 757
 758   if (offset + 4 > length)
 759     return 0;
 760
 761   *reg = (unsigned char *)map + (addr & (pagesize-1)) + offset;
 762   return 1;
 763 }
 764
 765 static void
 766 ecam_config(struct pci_access *a)
 767 {
 768   physmem_init_config(a);
 769   pci_define_param(a, "ecam.acpimcfg", PCI_PATH_ACPI_MCFG, "Path to the ACPI MCFG table");
 770   pci_define_param(a, "ecam.efisystab", PCI_PATH_EFI_SYSTAB, "Path to the EFI system table");
 771 #if defined (__FreeBSD__) || defined (__DragonFly__) || defined(__NetBSD__)
 772   pci_define_param(a, "ecam.bsd", "1", "Use BSD kenv or sysctl to find ACPI MCFG table");
 773 #endif
 774 #if defined(__amd64__) || defined(__i386__)
 775   pci_define_param(a, "ecam.x86bios", "1", "Scan x86 BIOS memory for ACPI MCFG table");
 776 #endif
 777   pci_define_param(a, "ecam.addrs", "", "Physical addresses of memory mapped PCIe ECAM interface"); /* format: [domain:]start_bus[-end_bus]:start_addr[+length],... */
 778 }
 779
 780 static int
 781 ecam_detect(struct pci_access *a)
 782 {
 783   int use_addrs = 1, use_acpimcfg = 1, use_efisystab = 1, use_bsd = 1, use_x86bios = 1;
 784   const char *acpimcfg = pci_get_param(a, "ecam.acpimcfg");
 785   const char *efisystab = pci_get_param(a, "ecam.efisystab");
 786 #if defined (__FreeBSD__) || defined (__DragonFly__) || defined(__NetBSD__)
 787   const char *bsd = pci_get_param(a, "ecam.bsd");
 788 #endif
 789 #if defined(__amd64__) || defined(__i386__)
 790   const char *x86bios = pci_get_param(a, "ecam.x86bios");
 791 #endif
 792   const char *addrs = pci_get_param(a, "ecam.addrs");
 793   glob_t mcfg_glob;
 794   int ret;
 795
 796   if (!*addrs)
 797     {
 798       a->debug("ecam.addrs was not specified...");
 799       use_addrs = 0;
 800     }
 801
 802   if (acpimcfg[0])
 803     {
 804       ret = glob(acpimcfg, GLOB_NOCHECK, NULL, &mcfg_glob);
 805       if (ret == 0)
 806         {
 807           if (access(mcfg_glob.gl_pathv[0], R_OK))
 808             {
 809               a->debug("cannot access acpimcfg: %s: %s...", mcfg_glob.gl_pathv[0], strerror(errno));
 810               use_acpimcfg = 0;
 811             }
 812           globfree(&mcfg_glob);
 813         }
 814       else
 815         {
 816           a->debug("glob(%s) failed: %d...", acpimcfg, ret);
 817           use_acpimcfg = 0;
 818         }
 819     }
 820   else
 821     use_acpimcfg = 0;
 822
 823   if (!efisystab[0] || access(efisystab, R_OK))
 824     {
 825       if (efisystab[0])
 826         a->debug("cannot access efisystab: %s: %s...", efisystab, strerror(errno));
 827       use_efisystab = 0;
 828     }
 829
 830 #if defined (__FreeBSD__) || defined (__DragonFly__) || defined(__NetBSD__)
 831   if (strcmp(bsd, "0") == 0)
 832     {
 833       a->debug("not using BSD kenv/sysctl...");
 834       use_bsd = 0;
 835     }
 836 #else
 837   use_bsd = 0;
 838 #endif
 839
 840 #if defined(__amd64__) || defined(__i386__)
 841   if (strcmp(x86bios, "0") == 0)
 842     {
 843       a->debug("not using x86 BIOS...");
 844       use_x86bios = 0;
 845     }
 846 #else
 847   use_x86bios = 0;
 848 #endif
 849
 850   if (!use_addrs && !use_acpimcfg && !use_efisystab && !use_bsd && !use_x86bios)
 851     {
 852       a->debug("no ecam source provided");
 853       return 0;
 854     }
 855
 856   if (!validate_addrs(addrs))
 857     {
 858       a->debug("ecam.addrs has invalid format %s", addrs);
 859       return 0;
 860     }
 861
 862   if (physmem_access(a, 0))
 863     {
 864       a->debug("cannot access physical memory: %s", strerror(errno));
 865       return 0;
 866     }
 867
 868   if (use_addrs)
 869     a->debug("using with ecam addresses %s", addrs);
 870   else
 871     a->debug("using with%s%s%s%s%s%s", use_acpimcfg ? " acpimcfg=" : "", use_acpimcfg ? acpimcfg : "", use_efisystab ? " efisystab=" : "", use_efisystab ? efisystab : "", use_bsd ? " bsd" : "", use_x86bios ? " x86bios" : "");
 872
 873   return 1;
 874 }
 875
 876 static void
 877 ecam_init(struct pci_access *a)
 878 {
 879   const char *acpimcfg = pci_get_param(a, "ecam.acpimcfg");
 880   const char *efisystab = pci_get_param(a, "ecam.efisystab");
 881 #if defined (__FreeBSD__) || defined (__DragonFly__) || defined(__NetBSD__)
 882   const char *bsd = pci_get_param(a, "ecam.bsd");
 883 #endif
 884 #if defined(__amd64__) || defined(__i386__)
 885   const char *x86bios = pci_get_param(a, "ecam.x86bios");
 886 #endif
 887   const char *addrs = pci_get_param(a, "ecam.addrs");
 888   struct physmem *physmem = NULL;
 889   struct ecam_access *eacc = NULL;
 890   long pagesize = 0;
 891   int use_bsd = 0;
 892   int use_x86bios = 0;
 893   int test_domain = 0;
 894   u8 test_bus = 0;
 895   volatile void *test_reg;
 896
 897   if (!validate_addrs(addrs))
 898     a->error("Option ecam.addrs has invalid address format \"%s\".", addrs);
 899
 900   physmem = physmem_open(a, a->writeable);
 901   if (!physmem)
 902     a->error("Cannot open physcal memory: %s.", strerror(errno));
 903
 904   pagesize = physmem_get_pagesize(physmem);
 905   if (pagesize <= 0)
 906     a->error("Cannot get page size: %s.", strerror(errno));
 907
 908   eacc = pci_malloc(a, sizeof(*eacc));
 909   eacc->mcfg = NULL;
 910   eacc->cache = NULL;
 911   eacc->physmem = physmem;
 912   eacc->pagesize = pagesize;
 913   a->backend_data = eacc;
 914
 915   if (!*addrs)
 916     {
 917 #if defined (__FreeBSD__) || defined (__DragonFly__)
 918       if (strcmp(bsd, "0") != 0)
 919         use_bsd = 1;
 920 #endif
 921 #if defined(__amd64__) || defined(__i386__)
 922       if (strcmp(x86bios, "0") != 0)
 923         use_x86bios = 1;
 924 #endif
 925       eacc->mcfg = find_mcfg(a, acpimcfg, efisystab, use_bsd, use_x86bios);
 926       if (!eacc->mcfg)
 927         a->error("Option ecam.addrs was not specified and ACPI MCFG table cannot be found.");
 928     }
 929
 930   if (eacc->mcfg)
 931     get_mcfg_allocation(eacc->mcfg, 0, &test_domain, &test_bus, NULL, NULL, NULL);
 932   else
 933     parse_next_addrs(addrs, NULL, &test_domain, &test_bus, NULL, NULL, NULL);
 934
 935   errno = 0;
 936   if (!mmap_reg(a, 0, test_domain, test_bus, 0, 0, 0, &test_reg))
 937     a->error("Cannot map ecam region: %s.", errno ? strerror(errno) : "Unknown error");
 938 }
 939
 940 static void
 941 ecam_cleanup(struct pci_access *a)
 942 {
 943   struct ecam_access *eacc = a->backend_data;
 944
 945   munmap_reg(a);
 946   physmem_close(eacc->physmem);
 947   pci_mfree(eacc->mcfg);
 948   pci_mfree(eacc);
 949   a->backend_data = NULL;
 950 }
 951
 952 static void
 953 ecam_scan(struct pci_access *a)
 954 {
 955   const char *addrs = pci_get_param(a, "ecam.addrs");
 956   struct ecam_access *eacc = a->backend_data;
 957   u32 *segments;
 958   int i, j, count;
 959   int domain;
 960
 961   segments = pci_malloc(a, 0xFFFF/8);
 962   memset(segments, 0, 0xFFFF/8);
 963
 964   if (eacc->mcfg)
 965     {
 966       count = get_mcfg_allocations_count(eacc->mcfg);
 967       for (i = 0; i < count; i++)
 968         segments[eacc->mcfg->allocations[i].pci_segment / 32] |= 1 << (eacc->mcfg->allocations[i].pci_segment % 32);
 969     }
 970   else
 971     {
 972       while (addrs)
 973         {
 974           if (parse_next_addrs(addrs, &addrs, &domain, NULL, NULL, NULL, NULL))
 975             segments[domain / 32] |= 1 << (domain % 32);
 976         }
 977     }
 978
 979   for (i = 0; i < 0xFFFF/32; i++)
 980     {
 981       if (!segments[i])
 982         continue;
 983       for (j = 0; j < 32; j++)
 984         if (segments[i] & (1 << j))
 985           pci_generic_scan_domain(a, 32*i + j);
 986     }
 987
 988   pci_mfree(segments);
 989 }
 990
 991 static int
 992 ecam_read(struct pci_dev *d, int pos, byte *buf, int len)
 993 {
 994   volatile void *reg;
 995
 996   if (pos >= 4096)
 997     return 0;
 998
 999   if (len != 1 && len != 2 && len != 4)
1000     return pci_generic_block_read(d, pos, buf, len);
1001
1002   if (!mmap_reg(d->access, 0, d->domain, d->bus, d->dev, d->func, pos, &reg))
1003     return 0;
1004
1005   switch (len)
1006     {
1007     case 1:
1008       buf[0] = physmem_readb(reg);
1009       break;
1010     case 2:
1011       ((u16 *) buf)[0] = physmem_readw(reg);
1012       break;
1013     case 4:
1014       ((u32 *) buf)[0] = physmem_readl(reg);
1015       break;
1016     }
1017
1018   return 1;
1019 }
1020
1021 static int
1022 ecam_write(struct pci_dev *d, int pos, byte *buf, int len)
1023 {
1024   volatile void *reg;
1025
1026   if (pos >= 4096)
1027     return 0;
1028
1029   if (len != 1 && len != 2 && len != 4)
1030     return pci_generic_block_read(d, pos, buf, len);
1031
1032   if (!mmap_reg(d->access, 1, d->domain, d->bus, d->dev, d->func, pos, &reg))
1033     return 0;
1034
1035   switch (len)
1036     {
1037     case 1:
1038       physmem_writeb(buf[0], reg);
1039       break;
1040     case 2:
1041       physmem_writew(((u16 *) buf)[0], reg);
1042       break;
1043     case 4:
1044       physmem_writel(((u32 *) buf)[0], reg);
1045       break;
1046     }
1047
1048   return 1;
1049 }
1050
1051 struct pci_methods pm_ecam = {
1052   "ecam",
1053   "Raw memory mapped access using PCIe ECAM interface",
1054   ecam_config,
1055   ecam_detect,
1056   ecam_init,
1057   ecam_cleanup,
1058   ecam_scan,
1059   pci_generic_fill_info,
1060   ecam_read,
1061   ecam_write,
1062   NULL,                                 /* read_vpd */
1063   NULL,                                 /* init_dev */
1064   NULL                                  /* cleanup_dev */
1065 };