/*      $NetBSD: acpi_verbose.c,v 1.22 2022/06/02 00:12:20 rin Exp $ */

/*-
* Copyright (c) 2003, 2007, 2010 The NetBSD Foundation, Inc.
* All rights reserved.
*
* This code is derived from software contributed to The NetBSD Foundation
* by Charles M. Hannum of By Noon Software, Inc, and Jukka Ruohonen.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
*    notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
*    notice, this list of conditions and the following disclaimer in the
*    documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
* ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
* TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
* PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
* BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*/

/*
* Copyright 2001, 2003 Wasabi Systems, Inc.
* All rights reserved.
*
* Written by Jason R. Thorpe for Wasabi Systems, Inc.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
*    notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
*    notice, this list of conditions and the following disclaimer in the
*    documentation and/or other materials provided with the distribution.
* 3. All advertising materials mentioning features or use of this software
*    must display the following acknowledgement:
*      This product includes software developed for the NetBSD Project by
*      Wasabi Systems, Inc.
* 4. The name of Wasabi Systems, Inc. may not be used to endorse
*    or promote products derived from this software without specific prior
*    written permission.
*
* THIS SOFTWARE IS PROVIDED BY WASABI SYSTEMS, INC. ``AS IS'' AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
* TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
* PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL WASABI SYSTEMS, INC
* BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*/

#include <sys/cdefs.h>
__KERNEL_RCSID(0, "$NetBSD: acpi_verbose.c,v 1.22 2022/06/02 00:12:20 rin Exp $");

#include "pci.h"

#include <sys/param.h>
#include <sys/device.h>
#include <sys/kernel.h>
#include <sys/systm.h>
#include <sys/module.h>

#include <dev/acpi/acpireg.h>
#include <dev/acpi/acpivar.h>
#include <dev/acpi/acpidevs_data.h>
#include <dev/acpi/acpi_pci.h>

#include <prop/proplib.h>

#define _COMPONENT ACPI_UTILITIES
ACPI_MODULE_NAME   ("acpi_verbose")

static bool        acpiverbose_modcmd_prop(prop_dictionary_t);

void               acpi_print_verbose_real(struct acpi_softc *);
void               acpi_print_dev_real(const char *);
static void        acpi_print_madt(struct acpi_softc *);
static ACPI_STATUS acpi_print_madt_callback(ACPI_SUBTABLE_HEADER *, void *);
static void        acpi_print_fadt(struct acpi_softc *);
static void        acpi_print_devnodes(struct acpi_softc *);
static void        acpi_print_tree(struct acpi_devnode *, uint32_t);

extern ACPI_TABLE_HEADER *madt_header;

MODULE(MODULE_CLASS_MISC, acpiverbose, NULL);

static int
acpiverbose_modcmd(modcmd_t cmd, void *arg)
{
       static void (*saved_print_verbose)(struct acpi_softc *);
       static void (*saved_print_dev)(const char *);
       bool dump;

       dump = false;

       switch (cmd) {

       case MODULE_CMD_INIT:
               saved_print_verbose = acpi_print_verbose;
               saved_print_dev = acpi_print_dev;
               acpi_print_verbose = acpi_print_verbose_real;
               acpi_print_dev = acpi_print_dev_real;
               acpi_verbose_loaded = 1;

               if (arg != NULL)
                       dump = acpiverbose_modcmd_prop(arg);

               if (dump != false)
                       acpi_print_verbose_real(acpi_softc);

               return 0;

       case MODULE_CMD_FINI:
               acpi_print_verbose = saved_print_verbose;
               acpi_print_dev = saved_print_dev;
               acpi_verbose_loaded = 0;
               return 0;

       default:
               return ENOTTY;
       }
}

static bool
acpiverbose_modcmd_prop(prop_dictionary_t dict)
{
       prop_object_t obj;

       obj = prop_dictionary_get(dict, "dump");

       if (obj == NULL || prop_object_type(obj) != PROP_TYPE_BOOL)
               return false;

       return prop_bool_true(obj);
}

void
acpi_print_verbose_real(struct acpi_softc *sc)
{

       acpi_print_madt(sc);
       acpi_print_fadt(sc);
       acpi_print_devnodes(sc);
       acpi_print_tree(sc->sc_root, 0);
}

void
acpi_print_dev_real(const char *pnpstr)
{
       int i;

       for (i = 0; i < __arraycount(acpi_knowndevs); i++) {

               if (strcmp(acpi_knowndevs[i].pnp, pnpstr) == 0)
                       aprint_normal("[%s] ", acpi_knowndevs[i].str);
       }
}

static void
acpi_print_madt(struct acpi_softc *sc)
{
       ACPI_STATUS rv;

       rv = acpi_madt_map();

       if (ACPI_FAILURE(rv) && rv != AE_ALREADY_EXISTS)
               return;

       if (madt_header == NULL)
               return;

       acpi_madt_walk(acpi_print_madt_callback, sc);
}

static ACPI_STATUS
acpi_print_madt_callback(ACPI_SUBTABLE_HEADER *hdr, void *aux)
{
       struct acpi_softc *sc = aux;
       device_t self = sc->sc_dev;

       /*
        * See ACPI 4.0, section 5.2.12.
        */
       switch (hdr->Type) {

       case ACPI_MADT_TYPE_LOCAL_APIC:

               aprint_normal_dev(self, "[MADT] %-15s: "
                   "CPU ID %u, LAPIC ID %u, FLAGS 0x%02X", "LAPIC",
                   ((ACPI_MADT_LOCAL_APIC *)hdr)->ProcessorId,
                   ((ACPI_MADT_LOCAL_APIC *)hdr)->Id,
                   ((ACPI_MADT_LOCAL_APIC *)hdr)->LapicFlags);

               break;

       case ACPI_MADT_TYPE_IO_APIC:

               aprint_normal_dev(self, "[MADT] %-15s: "
                   "ID %u, GSI %u, ADDR 0x%04X", "I/O APIC",
                   ((ACPI_MADT_IO_APIC *)hdr)->Id,
                   ((ACPI_MADT_IO_APIC *)hdr)->GlobalIrqBase,
                   ((ACPI_MADT_IO_APIC *)hdr)->Address);

               break;

       case ACPI_MADT_TYPE_INTERRUPT_OVERRIDE:

               aprint_normal_dev(self, "[MADT] %-15s: "
                   "BUS %u, IRQ %u, GSI %u, FLAGS 0x%02X", "INTR OVERRIDE",
                   ((ACPI_MADT_INTERRUPT_OVERRIDE *)hdr)->Bus,
                   ((ACPI_MADT_INTERRUPT_OVERRIDE *)hdr)->SourceIrq,
                   ((ACPI_MADT_INTERRUPT_OVERRIDE *)hdr)->GlobalIrq,
                   ((ACPI_MADT_INTERRUPT_OVERRIDE *)hdr)->IntiFlags);

               break;

       case ACPI_MADT_TYPE_NMI_SOURCE:

               aprint_normal_dev(self, "[MADT] %-15s: "
                   "GSI %u, FLAGS 0x%02X", "NMI SOURCE",
                   ((ACPI_MADT_NMI_SOURCE *)hdr)->GlobalIrq,
                   ((ACPI_MADT_NMI_SOURCE *)hdr)->IntiFlags);

               break;

       case ACPI_MADT_TYPE_LOCAL_APIC_NMI:

               aprint_normal_dev(self, "[MADT] %-15s: "
                   "CPU ID %u, LINT %u, FLAGS 0x%02X", "LAPIC NMI",
                   ((ACPI_MADT_LOCAL_APIC_NMI *)hdr)->ProcessorId,
                   ((ACPI_MADT_LOCAL_APIC_NMI *)hdr)->Lint,
                   ((ACPI_MADT_LOCAL_APIC_NMI *)hdr)->IntiFlags);

               break;

       case ACPI_MADT_TYPE_LOCAL_APIC_OVERRIDE:

               aprint_normal_dev(self, "[MADT] %-15s: "
                   "ADDR 0x%016" PRIX64"", "APIC OVERRIDE",
                   ((ACPI_MADT_LOCAL_APIC_OVERRIDE *)hdr)->Address);

               break;

       case ACPI_MADT_TYPE_IO_SAPIC:

               aprint_normal_dev(self, "[MADT] %-15s: "
                   "ID %u, GSI %u, ADDR 0x%016" PRIX64"", "I/O SAPIC",
                   ((ACPI_MADT_IO_SAPIC *)hdr)->Id,
                   ((ACPI_MADT_IO_SAPIC *)hdr)->GlobalIrqBase,
                   ((ACPI_MADT_IO_SAPIC *)hdr)->Address);

               break;

       case ACPI_MADT_TYPE_LOCAL_SAPIC:

               aprint_normal_dev(self, "[MADT] %-15s: "
                   "CPU ID %u, ID %u, EID %u, UID %u, FLAGS 0x%02X", "LSAPIC",
                   ((ACPI_MADT_LOCAL_SAPIC*)hdr)->ProcessorId,
                   ((ACPI_MADT_LOCAL_SAPIC*)hdr)->Id,
                   ((ACPI_MADT_LOCAL_SAPIC*)hdr)->Eid,
                   ((ACPI_MADT_LOCAL_SAPIC*)hdr)->Uid,
                   ((ACPI_MADT_LOCAL_SAPIC*)hdr)->LapicFlags);

               break;

       case ACPI_MADT_TYPE_INTERRUPT_SOURCE:

               aprint_normal_dev(self, "[MADT] %-15s: ID %u, EID %u, "
                   "TYPE %u, PMI %u, GSI %u, FLAGS 0x%02X", "INTR SOURCE",
                   ((ACPI_MADT_INTERRUPT_SOURCE *)hdr)->Id,
                   ((ACPI_MADT_INTERRUPT_SOURCE *)hdr)->Eid,
                   ((ACPI_MADT_INTERRUPT_SOURCE *)hdr)->Type,
                   ((ACPI_MADT_INTERRUPT_SOURCE *)hdr)->IoSapicVector,
                   ((ACPI_MADT_INTERRUPT_SOURCE *)hdr)->GlobalIrq,
                   ((ACPI_MADT_INTERRUPT_SOURCE *)hdr)->Flags);

               break;

       case ACPI_MADT_TYPE_LOCAL_X2APIC:

               aprint_normal_dev(self, "[MADT] %-15s: "
                   "ID %u, UID %u, FLAGS 0x%02X", "X2APIC",
                   ((ACPI_MADT_LOCAL_X2APIC *)hdr)->LocalApicId,
                   ((ACPI_MADT_LOCAL_X2APIC *)hdr)->Uid,
                   ((ACPI_MADT_LOCAL_X2APIC *)hdr)->LapicFlags);

               break;

       case ACPI_MADT_TYPE_LOCAL_X2APIC_NMI:

               aprint_normal_dev(self, "[MADT] %-15s: "
                   "UID %u, LINT %u, FLAGS 0x%02X", "X2APIC NMI",
                   ((ACPI_MADT_LOCAL_X2APIC_NMI *)hdr)->Uid,
                   ((ACPI_MADT_LOCAL_X2APIC_NMI *)hdr)->Lint,
                   ((ACPI_MADT_LOCAL_X2APIC_NMI *)hdr)->IntiFlags);

               break;

       default:
               aprint_normal_dev(self, "[MADT] %-15s", "UNKNOWN");
               break;
       }

       aprint_normal("\n");

       return AE_OK;
}

static void
acpi_print_fadt(struct acpi_softc *sc)
{
       uint32_t i;

       /*
        * See ACPI 4.0, section 5.2.9.
        */
       struct acpi_fadt {
               uint32_t         fadt_offset;
               const char      *fadt_name;
               uint64_t         fadt_value;
       };

       struct acpi_fadt_genaddr {
               uint32_t                 fadt_offset;
               const char              *fadt_name;
               ACPI_GENERIC_ADDRESS     fadt_value;
       };

       const struct acpi_fadt acpi_fadt_table[] = {

               { 36,   "FACS",          AcpiGbl_FADT.Facs              },
               { 40,   "DSDT",          AcpiGbl_FADT.Dsdt              },
               { 44,   "INT_MODEL",     AcpiGbl_FADT.Model             },
               { 45,   "PM_PROFILE",    AcpiGbl_FADT.PreferredProfile  },
               { 46,   "SCI_INT",       AcpiGbl_FADT.SciInterrupt      },
               { 48,   "SMI_CMD",       AcpiGbl_FADT.SmiCommand        },
               { 52,   "ACPI_ENABLE",   AcpiGbl_FADT.AcpiEnable        },
               { 53,   "ACPI_DISABLE",  AcpiGbl_FADT.AcpiDisable       },
               { 54,   "S4BIOS_REQ",    AcpiGbl_FADT.S4BiosRequest     },
               { 55,   "PSTATE_CNT",    AcpiGbl_FADT.PstateControl     },
               { 56,   "PM1a_EVT_BLK",  AcpiGbl_FADT.Pm1aEventBlock    },
               { 60,   "PM1b_EVT_BLK",  AcpiGbl_FADT.Pm1bEventBlock    },
               { 64,   "PM1a_CNT_BLK",  AcpiGbl_FADT.Pm1aControlBlock  },
               { 68,   "PM1b_CNT_BLK",  AcpiGbl_FADT.Pm1bControlBlock  },
               { 72,   "PM2_CNT_BLK",   AcpiGbl_FADT.Pm2ControlBlock   },
               { 76,   "PM_TMR_BLK",    AcpiGbl_FADT.PmTimerBlock      },
               { 80,   "GPE0_BLK",      AcpiGbl_FADT.Gpe0Block         },
               { 84,   "GPE1_BLK",      AcpiGbl_FADT.Gpe1Block         },
               { 88,   "PM1_EVT_LEN",   AcpiGbl_FADT.Pm1EventLength    },
               { 89,   "PM1_CNT_LEN",   AcpiGbl_FADT.Pm1ControlLength  },
               { 90,   "PM2_CNT_LEN",   AcpiGbl_FADT.Pm2ControlLength  },
               { 91,   "PM_TMR_LEN",    AcpiGbl_FADT.PmTimerLength     },
               { 92,   "GPE0_BLK_LEN",  AcpiGbl_FADT.Gpe0BlockLength   },
               { 93,   "GPE1_BLK_LEN",  AcpiGbl_FADT.Gpe1BlockLength   },
               { 94,   "GPE1_BASE",     AcpiGbl_FADT.Gpe1Base          },
               { 95,   "CST_CNT",       AcpiGbl_FADT.CstControl        },
               { 96,   "P_LVL2_LAT",    AcpiGbl_FADT.C2Latency         },
               { 98,   "P_LVL3_LAT",    AcpiGbl_FADT.C3Latency         },
               { 100,  "FLUSH_SIZE",    AcpiGbl_FADT.FlushSize         },
               { 102,  "FLUSH_STRIDE",  AcpiGbl_FADT.FlushStride       },
               { 104,  "DUTY_OFFSET",   AcpiGbl_FADT.DutyOffset        },
               { 105,  "DUTY_WIDTH",    AcpiGbl_FADT.DutyWidth         },
               { 106,  "DAY_ALRM",      AcpiGbl_FADT.DayAlarm          },
               { 107,  "MON_ALRM",      AcpiGbl_FADT.MonthAlarm        },
               { 108,  "CENTURY",       AcpiGbl_FADT.Century           },
               { 109,  "IAPC_BOOT_ARCH",AcpiGbl_FADT.BootFlags         },
               { 128,  "RESET_VALUE",   AcpiGbl_FADT.ResetValue        },
               { 129,  "ARM_BOOT_ARCH", AcpiGbl_FADT.ArmBootFlags      },
               { 132,  "X_FACS",        AcpiGbl_FADT.XFacs             },
               { 140,  "X_DSDT",        AcpiGbl_FADT.XDsdt             },
       };

       const struct acpi_fadt_genaddr acpi_fadt_genaddr_table[] = {

               { 116,  "RESET_REG",     AcpiGbl_FADT.ResetRegister     },
               { 148,  "X_PM1a_EVT_BLK",AcpiGbl_FADT.XPm1aEventBlock   },
               { 160,  "X_PM1b_EVT_BLK",AcpiGbl_FADT.XPm1bEventBlock   },
               { 172,  "X_PM1a_CNT_BLK",AcpiGbl_FADT.XPm1aControlBlock },
               { 184,  "X_PM1b_CNT_BLK",AcpiGbl_FADT.XPm1bControlBlock },
               { 196,  "X_PM2_CNT_BLK", AcpiGbl_FADT.XPm2ControlBlock  },
               { 208,  "X_PM_TMR_BLK",  AcpiGbl_FADT.XPmTimerBlock     },
               { 220,  "X_GPE0_BLK",    AcpiGbl_FADT.XGpe0Block        },
               { 232,  "X_GPE1_BLK",    AcpiGbl_FADT.XGpe1Block        },
               { 244,  "SLEEP_CTRL_REG",AcpiGbl_FADT.SleepControl      },
               { 256,  "SLEEP_STAT_REG",AcpiGbl_FADT.SleepStatus       },
       };

       const struct acpi_fadt acpi_fadt_flags[] = {

               { 0,    "WBINVD",       ACPI_FADT_WBINVD                },
               { 1,    "WBINVD_FLUSH", ACPI_FADT_WBINVD_FLUSH          },
               { 2,    "PROC_C1",      ACPI_FADT_C1_SUPPORTED          },
               { 3,    "P_LVL2_UP",    ACPI_FADT_C2_MP_SUPPORTED       },
               { 4,    "PWR_BUTTON",   ACPI_FADT_POWER_BUTTON          },
               { 5,    "SLP_BUTTON",   ACPI_FADT_SLEEP_BUTTON          },
               { 6,    "FIX_RTC",      ACPI_FADT_FIXED_RTC             },
               { 7,    "RTC_S4",       ACPI_FADT_S4_RTC_WAKE           },
               { 8,    "TMR_VAL_EXT",  ACPI_FADT_32BIT_TIMER           },
               { 9,    "DCK_CAP",      ACPI_FADT_DOCKING_SUPPORTED     },
               { 10,   "RESET_REG_SUP",ACPI_FADT_RESET_REGISTER        },
               { 11,   "SEALED_CASE",  ACPI_FADT_SEALED_CASE           },
               { 12,   "HEADLESS",     ACPI_FADT_HEADLESS              },
               { 13,   "CPU_SW_SLP",   ACPI_FADT_SLEEP_TYPE            },
               { 14,   "PCI_EXP_WAK",  ACPI_FADT_PCI_EXPRESS_WAKE      },
               { 15,   "PLATFORM_CLK", ACPI_FADT_PLATFORM_CLOCK        },
               { 16,   "S4_RTC_STS",   ACPI_FADT_S4_RTC_VALID          },
               { 17,   "REMOTE_POWER", ACPI_FADT_REMOTE_POWER_ON       },
               { 18,   "APIC_CLUSTER", ACPI_FADT_APIC_CLUSTER          },
               { 19,   "APIC_PHYSICAL",ACPI_FADT_APIC_PHYSICAL         },
               { 20,   "HW_REDUCED",   ACPI_FADT_HW_REDUCED            },
               { 21,   "LOW_POWER_S0", ACPI_FADT_LOW_POWER_S0          },
       };

       for (i = 0; i < __arraycount(acpi_fadt_table); i++) {

               aprint_normal_dev(sc->sc_dev,
                   "[FADT] %-15s: 0x%016" PRIX64"\n",
                   acpi_fadt_table[i].fadt_name,
                   acpi_fadt_table[i].fadt_value);
       }

       for (i = 0; i < __arraycount(acpi_fadt_genaddr_table); i++) {

               aprint_normal_dev(sc->sc_dev,
                   "[FADT] %-15s: 0x%016" PRIX64", "
                   "SPACE ID %u, BIT WIDTH %u, BIT OFFSET %u, "
                   "ACCESS WIDTH %u\n",
                   acpi_fadt_genaddr_table[i].fadt_name,
                   acpi_fadt_genaddr_table[i].fadt_value.Address,
                   acpi_fadt_genaddr_table[i].fadt_value.SpaceId,
                   acpi_fadt_genaddr_table[i].fadt_value.BitWidth,
                   acpi_fadt_genaddr_table[i].fadt_value.BitOffset,
                   acpi_fadt_genaddr_table[i].fadt_value.AccessWidth);
       }

       for (i = 0; i < __arraycount(acpi_fadt_flags); i++) {

               aprint_normal_dev(sc->sc_dev,
                   "[FADT] %-15s: 0x%016" PRIX64"\n",
                   acpi_fadt_flags[i].fadt_name, AcpiGbl_FADT.Flags &
                   acpi_fadt_flags[i].fadt_value);

               KASSERT(i ==  acpi_fadt_flags[i].fadt_offset);
               KASSERT(__BIT(acpi_fadt_flags[i].fadt_offset) ==
                             acpi_fadt_flags[i].fadt_value);
       }
}

static void
acpi_print_devnodes(struct acpi_softc *sc)
{
       struct acpi_devnode *ad;
       ACPI_DEVICE_INFO *di;

       SIMPLEQ_FOREACH(ad, &sc->sc_head, ad_list) {

               di = ad->ad_devinfo;
               aprint_normal_dev(sc->sc_dev, "[%-4s] ", ad->ad_name);

               aprint_normal("HID %-10s ",
                   ((di->Valid & ACPI_VALID_HID) != 0) ?
                   di->HardwareId.String: "-");

               aprint_normal("UID %-4s ",
                   ((di->Valid & ACPI_VALID_UID) != 0) ?
                   di->UniqueId.String : "-");

               if ((di->Valid & ACPI_VALID_ADR) != 0)
                       aprint_normal("ADR 0x%016" PRIX64"", di->Address);
               else
                       aprint_normal("ADR -");

               aprint_normal("\n");
       }
       aprint_normal("\n");
}

static void
acpi_print_tree(struct acpi_devnode *ad, uint32_t level)
{
       struct acpi_devnode *child;
       char buf[5];
       uint32_t i;

       for (i = 0; i < level; i++)
               aprint_normal("    ");

       buf[0] = '\0';

       if ((ad->ad_flags & ACPI_DEVICE_POWER) != 0)
               (void)strlcat(buf, "P", sizeof(buf));

       if ((ad->ad_flags & ACPI_DEVICE_WAKEUP) != 0)
               (void)strlcat(buf, "W", sizeof(buf));

       if ((ad->ad_flags & ACPI_DEVICE_EJECT) != 0)
               (void)strlcat(buf, "E", sizeof(buf));

       aprint_normal("%-5s [%02u] [%s]", ad->ad_name, ad->ad_type, buf);

       if (ad->ad_device != NULL)
               aprint_normal(" <%s>", device_xname(ad->ad_device));

#if NPCI > 0
       if (ad->ad_pciinfo != NULL) {

               aprint_normal(" (PCI)");

               if ((ad->ad_pciinfo->ap_flags & ACPI_PCI_INFO_DEVICE) != 0)
                       aprint_normal(" @ 0x%02X:0x%02X:0x%02X:0x%02X",
                           ad->ad_pciinfo->ap_segment,
                           ad->ad_pciinfo->ap_bus,
                           ad->ad_pciinfo->ap_device,
                           ad->ad_pciinfo->ap_function);

               if ((ad->ad_devinfo->Flags & ACPI_PCI_ROOT_BRIDGE) != 0)
                       aprint_normal(" [R]");

               if ((ad->ad_pciinfo->ap_flags & ACPI_PCI_INFO_BRIDGE) != 0)
                       aprint_normal(" [B] -> 0x%02X:0x%02X",
                           ad->ad_pciinfo->ap_segment,
                           ad->ad_pciinfo->ap_downbus);

               device_t dev = acpi_pcidev_find_dev(ad);

               if (dev != NULL)
                       aprint_normal(" <%s>", device_xname(dev));
       }
#endif

       aprint_normal("\n");

       SIMPLEQ_FOREACH(child, &ad->ad_child_head, ad_child_list)
           acpi_print_tree(child, level + 1);
}

You are viewing proxied material from ftp.icm.edu.pl. The copyright of proxied material belongs to its original authors. Any comments or complaints in relation to proxied material should be directed to the original authors of the content concerned. Please see the disclaimer for more details.