]> mj.ucw.cz Git - pciutils.git/blob - lib/ecam.c
libpci: Move physical memory mapping mmap() code from ecam/mmio-ports to physmem...
[pciutils.git] / 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 };