1/* $NetBSD: acpi_mcfg.c,v 1.4 2016/07/12 09:45:34 hannken Exp $ */
2
3/*-
4 * Copyright (C) 2015 NONAKA Kimihiro <nonaka@NetBSD.org>
5 * All rights reserved.
6 *
7 * Redistribution and use in source and binary forms, with or without
8 * modification, are permitted provided that the following conditions
9 * are met:
10 * 1. Redistributions of source code must retain the above copyright
11 * notice, this list of conditions and the following disclaimer.
12 * 2. Redistributions in binary form must reproduce the above copyright
13 * notice, this list of conditions and the following disclaimer in the
14 * documentation and/or other materials provided with the distribution.
15 *
16 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
17 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
18 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
19 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
20 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
21 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
22 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
23 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
24 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
25 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
26 */
27
28#include <sys/cdefs.h>
29__KERNEL_RCSID(0, "$NetBSD: acpi_mcfg.c,v 1.4 2016/07/12 09:45:34 hannken Exp $");
30
31#include <sys/param.h>
32#include <sys/device.h>
33#include <sys/kmem.h>
34#include <sys/systm.h>
35
36#include <dev/pci/pcireg.h>
37#include <dev/pci/pcivar.h>
38#include <dev/pci/pcidevs.h>
39
40#include <dev/acpi/acpireg.h>
41#include <dev/acpi/acpivar.h>
42#include <dev/acpi/acpi_mcfg.h>
43
44#include "locators.h"
45
46#define _COMPONENT ACPI_RESOURCE_COMPONENT
47ACPI_MODULE_NAME ("acpi_mcfg")
48
49#define EXTCONF_OFFSET(d, f, r) ((((d) * 8 + (f)) * PCI_EXTCONF_SIZE) + (r))
50
51#define EXTCONF_SET_VALID(mb, d, f) ((mb)->valid_devs[(d)] |= __BIT((f)))
52#define EXTCONF_SET_INVALID(mb, d, f) ((mb)->valid_devs[(d)] &= ~__BIT((f)))
53#define EXTCONF_IS_VALID(mb, d, f) ((mb)->valid_devs[(d)] & __BIT((f)))
54
55struct mcfg_segment {
56 uint64_t ms_address; /* Base address */
57 int ms_segment; /* Segment # */
58 int ms_bus_start; /* Start bus # */
59 int ms_bus_end; /* End bus # */
60 bus_space_tag_t ms_bst;
61 struct mcfg_bus {
62 bus_space_handle_t bsh[32][8];
63 uint8_t valid_devs[32];
64 int valid_ndevs;
65 pcitag_t last_probed;
66 } *ms_bus;
67};
68
69static struct mcfg_segment *mcfg_segs;
70static int mcfg_nsegs;
71static ACPI_TABLE_MCFG *mcfg;
72static int mcfg_inited;
73static struct acpi_softc *acpi_sc;
74
75static const struct acpimcfg_ops mcfg_default_ops = {
76 .ao_validate = acpimcfg_default_validate,
77
78 .ao_read = acpimcfg_default_read,
79 .ao_write = acpimcfg_default_write,
80};
81static const struct acpimcfg_ops *mcfg_ops = &mcfg_default_ops;
82
83/*
84 * default operations.
85 */
86bool
87acpimcfg_default_validate(uint64_t address, int bus_start, int *bus_end)
88{
89
90 /* Always Ok */
91 return true;
92}
93
94uint32_t
95acpimcfg_default_read(bus_space_tag_t bst, bus_space_handle_t bsh,
96 bus_addr_t addr)
97{
98
99 return bus_space_read_4(bst, bsh, addr);
100}
101
102void
103acpimcfg_default_write(bus_space_tag_t bst, bus_space_handle_t bsh,
104 bus_addr_t addr, uint32_t data)
105{
106
107 bus_space_write_4(bst, bsh, addr, data);
108}
109
110
111/*
112 * Check MCFG memory region at system resource
113 */
114struct acpimcfg_memrange {
115 const char *hid;
116 uint64_t address;
117 int bus_start;
118 int bus_end;
119 bool found;
120};
121
122static ACPI_STATUS
123acpimcfg_parse_callback(ACPI_RESOURCE *res, void *ctx)
124{
125 struct acpimcfg_memrange *mr = ctx;
126 const char *type;
127 uint64_t size, mapaddr, mapsize;
128 int n;
129
130 switch (res->Type) {
131 case ACPI_RESOURCE_TYPE_FIXED_MEMORY32:
132 type = "FIXED_MEMORY32";
133 mapaddr = res->Data.FixedMemory32.Address;
134 mapsize = res->Data.FixedMemory32.AddressLength;
135 break;
136
137 case ACPI_RESOURCE_TYPE_ADDRESS32:
138 /* XXX Only fixed size supported for now */
139 if (res->Data.Address32.Address.AddressLength == 0 ||
140 res->Data.Address32.ProducerConsumer != ACPI_CONSUMER)
141 goto out;
142
143 if (res->Data.Address32.ResourceType != ACPI_MEMORY_RANGE)
144 goto out;
145
146 if (res->Data.Address32.MinAddressFixed != ACPI_ADDRESS_FIXED ||
147 res->Data.Address32.MaxAddressFixed != ACPI_ADDRESS_FIXED)
148 goto out;
149
150 type = "ADDRESS32";
151 mapaddr = res->Data.Address32.Address.Minimum;
152 mapsize = res->Data.Address32.Address.AddressLength;
153 break;
154
155#ifdef _LP64
156 case ACPI_RESOURCE_TYPE_ADDRESS64:
157 /* XXX Only fixed size supported for now */
158 if (res->Data.Address64.Address.AddressLength == 0 ||
159 res->Data.Address64.ProducerConsumer != ACPI_CONSUMER)
160 goto out;
161
162 if (res->Data.Address64.ResourceType != ACPI_MEMORY_RANGE)
163 goto out;
164
165 if (res->Data.Address64.MinAddressFixed != ACPI_ADDRESS_FIXED ||
166 res->Data.Address64.MaxAddressFixed != ACPI_ADDRESS_FIXED)
167 goto out;
168
169 type = "ADDRESS64";
170 mapaddr = res->Data.Address64.Address.Minimum;
171 mapsize = res->Data.Address64.Address.AddressLength;
172 break;
173#endif
174
175 default:
176 out:
177 aprint_debug_dev(acpi_sc->sc_dev, "MCFG: %s: Type=%d\n",
178 mr->hid, res->Type);
179 return_ACPI_STATUS(AE_OK);
180 }
181
182 aprint_debug_dev(acpi_sc->sc_dev, "MCFG: %s: Type=%d(%s), "
183 "Address=0x%016" PRIx64 ", Length=0x%016" PRIx64 "\n",
184 mr->hid, res->Type, type, mapaddr, mapsize);
185
186 if (mr->address < mapaddr || mr->address >= mapaddr + mapsize)
187 return_ACPI_STATUS(AE_OK);
188
189 size = (mr->bus_end - mr->bus_start + 1) * ACPIMCFG_SIZE_PER_BUS;
190
191 /* full map */
192 if (mr->address + size <= mapaddr + mapsize) {
193 mr->found = true;
194 return_ACPI_STATUS(AE_CTRL_TERMINATE);
195 }
196
197 /* partial map */
198 n = (mapsize - (mr->address - mapaddr)) / ACPIMCFG_SIZE_PER_BUS;
199 /* bus_start == bus_end is not allowed. */
200 if (n > 1) {
201 mr->bus_end = mr->bus_start + n - 1;
202 mr->found = true;
203 return_ACPI_STATUS(AE_CTRL_TERMINATE);
204 }
205
206 aprint_debug_dev(acpi_sc->sc_dev, "MCFG: bus %d-%d, "
207 "address 0x%016" PRIx64 ": invalid size: request 0x%016" PRIx64
208 ", actual 0x%016" PRIx64 "\n",
209 mr->bus_start, mr->bus_end, mr->address, size, mapsize);
210
211 return_ACPI_STATUS(AE_OK);
212}
213
214static ACPI_STATUS
215acpimcfg_check_system_resource(ACPI_HANDLE handle, UINT32 level, void *ctx,
216 void **retval)
217{
218 struct acpimcfg_memrange *mr = ctx;
219 ACPI_STATUS status;
220
221 status = AcpiWalkResources(handle, "_CRS", acpimcfg_parse_callback, mr);
222 if (ACPI_FAILURE(status))
223 return_ACPI_STATUS(status);
224
225 if (mr->found)
226 return_ACPI_STATUS(AE_CTRL_TERMINATE);
227
228 aprint_debug_dev(acpi_sc->sc_dev, "MCFG: %s: bus %d-%d, "
229 "address 0x%016" PRIx64 ": no valid region\n", mr->hid,
230 mr->bus_start, mr->bus_end, mr->address);
231
232 return_ACPI_STATUS(AE_OK);
233}
234
235static bool
236acpimcfg_find_system_resource(uint64_t address, int bus_start, int *bus_end)
237{
238 static const char *system_resource_hid[] = {
239 "PNP0C01", /* System Board */
240 "PNP0C02" /* General ID for reserving resources */
241 };
242 struct acpimcfg_memrange mr;
243 ACPI_STATUS status;
244 int i;
245
246 mr.address = address;
247 mr.bus_start = bus_start;
248 mr.bus_end = *bus_end;
249 mr.found = false;
250
251 for (i = 0; i < __arraycount(system_resource_hid); i++) {
252 mr.hid = system_resource_hid[i];
253 status = AcpiGetDevices(__UNCONST(system_resource_hid[i]),
254 acpimcfg_check_system_resource, &mr, NULL);
255 if (ACPI_FAILURE(status))
256 continue;
257 if (mr.found) {
258 *bus_end = mr.bus_end;
259 return true;
260 }
261 }
262 return false;
263}
264
265
266/*
267 * ACPI MCFG
268 */
269void
270acpimcfg_probe(struct acpi_softc *sc)
271{
272 ACPI_MCFG_ALLOCATION *ama;
273 ACPI_STATUS status;
274 uint32_t offset;
275 int i, nsegs;
276
277 if (acpi_sc != NULL)
278 panic("acpi_sc != NULL");
279 acpi_sc = sc;
280
281 status = AcpiGetTable(ACPI_SIG_MCFG, 0, (ACPI_TABLE_HEADER **)&mcfg);
282 if (ACPI_FAILURE(status)) {
283 mcfg = NULL;
284 return;
285 }
286
287 nsegs = 0;
288 offset = sizeof(ACPI_TABLE_MCFG);
289 ama = ACPI_ADD_PTR(ACPI_MCFG_ALLOCATION, mcfg, offset);
290 for (i = 0; offset < mcfg->Header.Length; i++) {
291 aprint_debug_dev(sc->sc_dev,
292 "MCFG: segment %d, bus %d-%d, address 0x%016" PRIx64 "\n",
293 ama->PciSegment, ama->StartBusNumber, ama->EndBusNumber,
294 ama->Address);
295 nsegs++;
296 offset += sizeof(ACPI_MCFG_ALLOCATION);
297 ama = ACPI_ADD_PTR(ACPI_MCFG_ALLOCATION, ama, offset);
298 }
299 if (nsegs == 0) {
300 mcfg = NULL;
301 return;
302 }
303
304 mcfg_segs = kmem_zalloc(sizeof(*mcfg_segs) * nsegs, KM_SLEEP);
305 mcfg_nsegs = nsegs;
306}
307
308int
309acpimcfg_init(bus_space_tag_t memt, const struct acpimcfg_ops *ops)
310{
311 ACPI_MCFG_ALLOCATION *ama;
312 struct mcfg_segment *seg;
313 uint32_t offset;
314 int i, n, nsegs, bus_end;
315
316 if (mcfg == NULL)
317 return ENXIO;
318
319 if (mcfg_inited)
320 return 0;
321
322 if (ops != NULL)
323 mcfg_ops = ops;
324
325 nsegs = 0;
326 offset = sizeof(ACPI_TABLE_MCFG);
327 ama = ACPI_ADD_PTR(ACPI_MCFG_ALLOCATION, mcfg, offset);
328 for (i = 0; offset < mcfg->Header.Length; i++) {
329#ifndef _LP64
330 if (ama->Address >= 0x100000000ULL) {
331 aprint_debug_dev(acpi_sc->sc_dev,
332 "MCFG: segment %d, bus %d-%d, address 0x%016" PRIx64
333 ": ignore (64bit address)\n", ama->PciSegment,
334 ama->StartBusNumber, ama->EndBusNumber,
335 ama->Address);
336 goto next;
337 }
338#endif
339 /*
340 * Some (broken?) BIOSen have an MCFG table for an empty
341 * bus range. Ignore those tables.
342 */
343 if (ama->StartBusNumber == ama->EndBusNumber) {
344 aprint_debug_dev(acpi_sc->sc_dev,
345 "MCFG: segment %d, bus %d-%d, address 0x%016" PRIx64
346 ": ignore (bus %d == %d)\n", ama->PciSegment,
347 ama->StartBusNumber, ama->EndBusNumber,
348 ama->Address, ama->StartBusNumber,
349 ama->EndBusNumber);
350 goto next;
351 }
352 if (ama->StartBusNumber > ama->EndBusNumber) {
353 aprint_debug_dev(acpi_sc->sc_dev,
354 "MCFG: segment %d, bus %d-%d, address 0x%016" PRIx64
355 ": ignore (bus %d > %d)\n", ama->PciSegment,
356 ama->StartBusNumber, ama->EndBusNumber,
357 ama->Address, ama->StartBusNumber,
358 ama->EndBusNumber);
359 goto next;
360 }
361
362 /* Validate MCFG memory range */
363 bus_end = ama->EndBusNumber;
364 if (mcfg_ops->ao_validate != NULL &&
365 !mcfg_ops->ao_validate(ama->Address, ama->StartBusNumber,
366 &bus_end)) {
367 if (!acpimcfg_find_system_resource( ama->Address,
368 ama->StartBusNumber, &bus_end)) {
369 aprint_debug_dev(acpi_sc->sc_dev,
370 "MCFG: segment %d, bus %d-%d, "
371 "address 0x%016" PRIx64
372 ": ignore (invalid address)\n",
373 ama->PciSegment,
374 ama->StartBusNumber, ama->EndBusNumber,
375 ama->Address);
376 goto next;
377 }
378 }
379 if (ama->EndBusNumber != bus_end) {
380 aprint_debug_dev(acpi_sc->sc_dev,
381 "MCFG: segment %d, bus %d-%d, address 0x%016" PRIx64
382 " -> bus %d-%d\n", ama->PciSegment,
383 ama->StartBusNumber, ama->EndBusNumber,
384 ama->Address, ama->StartBusNumber, bus_end);
385 }
386
387 if (ama->PciSegment != 0) {
388 aprint_debug_dev(acpi_sc->sc_dev,
389 "MCFG: segment %d, bus %d-%d, address 0x%016" PRIx64
390 ": ignore (non PCI segment 0)\n", ama->PciSegment,
391 ama->StartBusNumber, bus_end, ama->Address);
392 goto next;
393 }
394
395 seg = &mcfg_segs[nsegs++];
396 seg->ms_address = ama->Address;
397 seg->ms_segment = ama->PciSegment;
398 seg->ms_bus_start = ama->StartBusNumber;
399 seg->ms_bus_end = bus_end;
400 seg->ms_bst = memt;
401 n = seg->ms_bus_end - seg->ms_bus_start + 1;
402 seg->ms_bus = kmem_zalloc(sizeof(*seg->ms_bus) * n, KM_SLEEP);
403
404 next:
405 offset += sizeof(ACPI_MCFG_ALLOCATION);
406 ama = ACPI_ADD_PTR(ACPI_MCFG_ALLOCATION, ama, offset);
407 }
408 if (nsegs == 0)
409 return ENOENT;
410
411 for (i = 0; i < nsegs; i++) {
412 seg = &mcfg_segs[i];
413 aprint_verbose_dev(acpi_sc->sc_dev,
414 "MCFG: segment %d, bus %d-%d, address 0x%016" PRIx64 "\n",
415 seg->ms_segment, seg->ms_bus_start, seg->ms_bus_end,
416 seg->ms_address);
417 }
418
419 /* Update # of segment */
420 mcfg_nsegs = nsegs;
421 mcfg_inited = true;
422
423 return 0;
424}
425
426static int
427acpimcfg_ext_conf_is_aliased(pci_chipset_tag_t pc, pcitag_t tag)
428{
429 pcireg_t id;
430 int i;
431
432 id = pci_conf_read(pc, tag, PCI_ID_REG);
433 for (i = PCI_CONF_SIZE; i < PCI_EXTCONF_SIZE; i += PCI_CONF_SIZE) {
434 if (pci_conf_read(pc, tag, i) != id)
435 return false;
436 }
437 return true;
438}
439
440static struct mcfg_segment *
441acpimcfg_get_segment(int bus)
442{
443 struct mcfg_segment *seg;
444 int i;
445
446 for (i = 0; i < mcfg_nsegs; i++) {
447 seg = &mcfg_segs[i];
448 if (bus >= seg->ms_bus_start && bus <= seg->ms_bus_end)
449 return seg;
450 }
451 return NULL;
452}
453
454static int
455acpimcfg_device_probe(const struct pci_attach_args *pa)
456{
457 pci_chipset_tag_t pc = pa->pa_pc;
458 struct mcfg_segment *seg;
459 struct mcfg_bus *mb;
460 pcitag_t tag;
461 pcireg_t reg;
462 int bus = pa->pa_bus;
463 int dev = pa->pa_device;
464 int func = pa->pa_function;
465 int last_dev, last_func, end_func;
466 int alias = 0;
467 int i, j;
468
469 seg = acpimcfg_get_segment(bus);
470 if (seg == NULL)
471 return 0;
472
473 mb = &seg->ms_bus[bus - seg->ms_bus_start];
474 tag = pci_make_tag(pc, bus, dev, func);
475
476 /* Mark invalid between last probed device to probed device. */
477 pci_decompose_tag(pc, mb->last_probed, NULL, &last_dev, &last_func);
478 if (dev != 0 || func != 0) {
479 for (i = last_dev; i <= dev; i++) {
480 end_func = (i == dev) ? func : 8;
481 for (j = last_func; j < end_func; j++) {
482 if (i == last_dev && j == last_func)
483 continue;
484 EXTCONF_SET_INVALID(mb, i, j);
485 }
486 last_func = 0;
487 }
488 }
489 mb->last_probed = tag;
490
491 /* Probe extended configuration space. */
492 if (((reg = pci_conf_read(pc, tag, PCI_CONF_SIZE)) == (pcireg_t)-1) ||
493 (reg == 0) || (alias = acpimcfg_ext_conf_is_aliased(pc, tag))) {
494 aprint_debug_dev(acpi_sc->sc_dev,
495 "MCFG: %03d:%02d:%d: invalid config space "
496 "(cfg[0x%03x]=0x%08x, alias=%s)\n", bus, dev, func,
497 PCI_CONF_SIZE, reg, alias ? "true" : "false");
498 EXTCONF_SET_INVALID(mb, dev, func);
499 } else {
500 aprint_debug_dev(acpi_sc->sc_dev,
501 "MCFG: %03d:%02d:%d: Ok (cfg[0x%03x]=0x%08x)\n",
502 bus, dev, func, PCI_CONF_SIZE, reg);
503 mb->valid_ndevs++;
504 }
505
506 return 0;
507}
508
509static void
510acpimcfg_scan_bus(struct pci_softc *sc, pci_chipset_tag_t pc, int bus)
511{
512 static const int wildcard[PCICF_NLOCS] = {
513 PCICF_DEV_DEFAULT, PCICF_FUNCTION_DEFAULT
514 };
515
516 sc->sc_bus = bus; /* XXX */
517
518 pci_enumerate_bus(sc, wildcard, acpimcfg_device_probe, NULL);
519}
520
521int
522acpimcfg_map_bus(device_t self, pci_chipset_tag_t pc, int bus)
523{
524 struct pci_softc *sc = device_private(self);
525 struct mcfg_segment *seg = NULL;
526 struct mcfg_bus *mb;
527 bus_space_handle_t bsh;
528 bus_addr_t baddr;
529 pcitag_t tag;
530 pcireg_t reg;
531 bool is_e7520_mch;
532 int boff;
533 int last_dev, last_func;
534 int i, j;
535 int error;
536
537 if (!mcfg_inited)
538 return ENXIO;
539
540 seg = acpimcfg_get_segment(bus);
541 if (seg == NULL)
542 return ENOENT;
543
544 boff = bus - seg->ms_bus_start;
545 if (seg->ms_bus[boff].valid_ndevs > 0)
546 return 0;
547
548 mb = &seg->ms_bus[boff];
549 baddr = seg->ms_address + (boff * ACPIMCFG_SIZE_PER_BUS);
550
551 /* Map extended configration space of all dev/func. */
552 error = bus_space_map(seg->ms_bst, baddr, ACPIMCFG_SIZE_PER_BUS, 0,
553 &bsh);
554 if (error != 0)
555 return error;
556 for (i = 0; i < 32; i++) {
557 for (j = 0; j < 8; j++) {
558 error = bus_space_subregion(seg->ms_bst, bsh,
559 EXTCONF_OFFSET(i, j, 0), PCI_EXTCONF_SIZE,
560 &mb->bsh[i][j]);
561 if (error != 0)
562 break;
563 }
564 }
565 if (error != 0)
566 return error;
567
568 aprint_debug("\n");
569
570 /* Probe extended configuration space of all devices. */
571 memset(mb->valid_devs, 0xff, sizeof(mb->valid_devs));
572 mb->valid_ndevs = 0;
573 mb->last_probed = pci_make_tag(pc, bus, 0, 0);
574
575 /*
576 * On an Intel E7520 we have to temporarily disable
577 * Enhanced Config Access error detection and reporting
578 * by setting the appropriate error mask in HI_ERRMASK register.
579 *
580 * See "Intel E7520 Memory Controller Hub (MCH) Datasheet",
581 * Document 303006-002, pg. 82
582 */
583 tag = pci_make_tag(pc, 0, 0, 1);
584 reg = pci_conf_read(pc, tag, PCI_ID_REG);
585 is_e7520_mch = (reg ==
586 PCI_ID_CODE(PCI_VENDOR_INTEL, PCI_PRODUCT_INTEL_E7525_MCHER));
587 if (is_e7520_mch) {
588 reg = pci_conf_read(pc, tag, 0x54);
589 pci_conf_write(pc, tag, 0x54, reg | 0x20);
590 }
591
592 acpimcfg_scan_bus(sc, pc, bus);
593
594 if (is_e7520_mch) {
595 pci_conf_write(pc, tag, 0x54, reg);
596 }
597
598 /* Unmap extended configration space of all dev/func. */
599 bus_space_unmap(seg->ms_bst, bsh, ACPIMCFG_SIZE_PER_BUS);
600 memset(mb->bsh, 0, sizeof(mb->bsh));
601
602 if (mb->valid_ndevs == 0) {
603 aprint_debug_dev(acpi_sc->sc_dev,
604 "MCFG: bus %d: no valid devices.\n", bus);
605 memset(mb->valid_devs, 0, sizeof(mb->valid_devs));
606 goto out;
607 }
608
609 /* Mark invalid on remaining all devices. */
610 pci_decompose_tag(pc, mb->last_probed, NULL, &last_dev, &last_func);
611 for (i = last_dev; i < 32; i++) {
612 for (j = last_func; j < 8; j++) {
613 if (i == last_dev && j == last_func) {
614 /* Don't mark invalid to last probed device. */
615 continue;
616 }
617 EXTCONF_SET_INVALID(mb, i, j);
618 }
619 last_func = 0;
620 }
621
622 /* Map extended configuration space per dev/func. */
623 for (i = 0; i < 32; i++) {
624 for (j = 0; j < 8; j++) {
625 if (!EXTCONF_IS_VALID(mb, i, j))
626 continue;
627 error = bus_space_map(seg->ms_bst,
628 baddr + EXTCONF_OFFSET(i, j, 0), PCI_EXTCONF_SIZE,
629 0, &mb->bsh[i][j]);
630 if (error != 0) {
631 /* Unmap all handles when map failed. */
632 do {
633 while (--j >= 0) {
634 if (!EXTCONF_IS_VALID(mb, i, j))
635 continue;
636 bus_space_unmap(seg->ms_bst,
637 mb->bsh[i][j],
638 PCI_EXTCONF_SIZE);
639 }
640 j = 8;
641 } while (--i >= 0);
642 memset(mb->valid_devs, 0,
643 sizeof(mb->valid_devs));
644 goto out;
645 }
646 }
647 }
648
649 aprint_debug_dev(acpi_sc->sc_dev, "MCFG: bus %d: valid devices\n", bus);
650 for (i = 0; i < 32; i++) {
651 for (j = 0; j < 8; j++) {
652 if (EXTCONF_IS_VALID(mb, i, j)) {
653 aprint_debug_dev(acpi_sc->sc_dev,
654 "MCFG: %03d:%02d:%d\n", bus, i, j);
655 }
656 }
657 }
658
659 error = 0;
660out:
661 aprint_debug_dev(acpi_sc->sc_dev, "%s done", __func__);
662
663 return error;
664}
665
666int
667acpimcfg_conf_read(pci_chipset_tag_t pc, pcitag_t tag, int reg, pcireg_t *data)
668{
669 struct mcfg_segment *seg = NULL;
670 struct mcfg_bus *mb;
671 int bus, dev, func;
672
673 KASSERT(reg < PCI_EXTCONF_SIZE);
674 KASSERT((reg & 3) == 0);
675
676 if (!mcfg_inited) {
677 *data = -1;
678 return ENXIO;
679 }
680
681 pci_decompose_tag(pc, tag, &bus, &dev, &func);
682
683 seg = acpimcfg_get_segment(bus);
684 if (seg == NULL) {
685 *data = -1;
686 return ERANGE;
687 }
688
689 mb = &seg->ms_bus[bus - seg->ms_bus_start];
690 if (!EXTCONF_IS_VALID(mb, dev, func)) {
691 *data = -1;
692 return EINVAL;
693 }
694
695 *data = mcfg_ops->ao_read(seg->ms_bst, mb->bsh[dev][func], reg);
696 return 0;
697}
698
699int
700acpimcfg_conf_write(pci_chipset_tag_t pc, pcitag_t tag, int reg, pcireg_t data)
701{
702 struct mcfg_segment *seg = NULL;
703 struct mcfg_bus *mb;
704 int bus, dev, func;
705
706 KASSERT(reg < PCI_EXTCONF_SIZE);
707 KASSERT((reg & 3) == 0);
708
709 if (!mcfg_inited)
710 return ENXIO;
711
712 pci_decompose_tag(pc, tag, &bus, &dev, &func);
713
714 seg = acpimcfg_get_segment(bus);
715 if (seg == NULL)
716 return ERANGE;
717
718 mb = &seg->ms_bus[bus - seg->ms_bus_start];
719 if (!EXTCONF_IS_VALID(mb, dev, func))
720 return EINVAL;
721
722 mcfg_ops->ao_write(seg->ms_bst, mb->bsh[dev][func], reg, data);
723 return 0;
724}
725