drivers/bus/acpi/ospm/acpienum.c

   1 /* $Id$
   2  *
   3  * PROJECT:         ReactOS ACPI bus driver
   4  * FILE:            acpi/ospm/acpienum.c
   5  * PURPOSE:         ACPI namespace enumerator
   6  * PROGRAMMERS:     Casper S. Hornstrup (chorns@users.sourceforge.net)
   7  * UPDATE HISTORY:
   8  *      01-05-2001  CSH  Created
   9  */
  10 #include <acpisys.h>
  11 #include <bm.h>
  12
  13 #define NDEBUG
  14 #include <debug.h>
  15
  16
  17 void
  18 bm_print1 (
  19         BM_NODE                 *node,
  20         u32                     flags)
  21 {
  22         ACPI_BUFFER             buffer;
  23         BM_DEVICE               *device = NULL;
  24         char                    *type_string = NULL;
  25
  26         if (!node) {
  27                 return;
  28         }
  29
  30         device = &(node->device);
  31
  32         if (flags & BM_PRINT_PRESENT) {
  33                 if (!BM_DEVICE_PRESENT(device)) {
  34                         return;
  35                 }
  36         }
  37
  38         buffer.length = 256;
  39         buffer.pointer = acpi_os_callocate(buffer.length);
  40         if (!buffer.pointer) {
  41                 return;
  42         }
  43
  44         acpi_get_name(device->acpi_handle, ACPI_FULL_PATHNAME, &buffer);
  45
  46         switch(device->id.type) {
  47         case BM_TYPE_SYSTEM:
  48                 type_string = "System";
  49                 break;
  50         case BM_TYPE_SCOPE:
  51                 type_string = "Scope";
  52                 break;
  53         case BM_TYPE_PROCESSOR:
  54                 type_string = "Processor";
  55                 break;
  56         case BM_TYPE_THERMAL_ZONE:
  57                 type_string = "ThermalZone";
  58                 break;
  59         case BM_TYPE_POWER_RESOURCE:
  60                 type_string = "PowerResource";
  61                 break;
  62         case BM_TYPE_FIXED_BUTTON:
  63                 type_string = "Button";
  64                 break;
  65         case BM_TYPE_DEVICE:
  66                 type_string = "Device";
  67                 break;
  68         default:
  69                 type_string = "Unknown";
  70                 break;
  71         }
  72
  73         if (!(flags & BM_PRINT_GROUP)) {
  74                 DbgPrint("+------------------------------------------------------------\n");
  75         }
  76
  77                 DbgPrint("%s[0x%02x] hid[%s] %s\n", type_string, device->handle, device->id.hid, buffer.pointer);
  78                 DbgPrint("  acpi_handle[0x%08x] flags[0x%02x] status[0x%02x]\n", device->acpi_handle, device->flags, device->status);
  79
  80         if (flags & BM_PRINT_IDENTIFICATION) {
  81                 DbgPrint("  identification: uid[%s] adr[0x%08x]\n", device->id.uid, device->id.adr);
  82         }
  83
  84         if (flags & BM_PRINT_LINKAGE) {
  85                 DbgPrint("  linkage: this[%p] parent[%p] next[%p]\n", node, node->parent, node->next);
  86                 DbgPrint("    scope.head[%p] scope.tail[%p]\n", node->scope.head, node->scope.tail);
  87         }
  88
  89         if (flags & BM_PRINT_POWER) {
  90                 DbgPrint("  power: state[D%d] flags[0x%08X]\n", device->power.state, device->power.flags);
  91                 DbgPrint("    S0[0x%02x] S1[0x%02x] S2[0x%02x]\n", device->power.dx_supported[0], device->power.dx_supported[1], device->power.dx_supported[2]);
  92                 DbgPrint("    S3[0x%02x] S4[0x%02x] S5[0x%02x]\n", device->power.dx_supported[3], device->power.dx_supported[4], device->power.dx_supported[5]);
  93         }
  94
  95         if (!(flags & BM_PRINT_GROUP)) {
  96                 DbgPrint("+------------------------------------------------------------\n");
  97         }
  98
  99         acpi_os_free(buffer.pointer);
 100
 101         return;
 102 }
 103
 104
 105 NTSTATUS
 106 ACPIEnumerateRootBusses(
 107   PFDO_DEVICE_EXTENSION DeviceExtension)
 108 {
 109   BM_HANDLE_LIST HandleList;
 110   PACPI_DEVICE AcpiDevice;
 111   ACPI_STATUS AcpiStatus;
 112   BM_HANDLE DeviceHandle;
 113         BM_DEVICE_ID Criteria;
 114   KIRQL OldIrql;
 115   ULONG i;
 116
 117   BM_NODE *Node;
 118   ULONG j;
 119
 120   DPRINT("Called\n");
 121
 122   RtlZeroMemory(&Criteria, sizeof(BM_DEVICE_ID));
 123   RtlMoveMemory(&Criteria.hid, PCI_ROOT_HID_STRING, sizeof(PCI_ROOT_HID_STRING));
 124
 125   AcpiStatus = bm_search(BM_HANDLE_ROOT, &Criteria, &HandleList);
 126
 127   if (ACPI_SUCCESS(AcpiStatus)) {
 128     DPRINT("Got %d devices\n", HandleList.count);
 129
 130     for (i = 0; i < HandleList.count; i++) {
 131       AcpiStatus = bm_get_node(HandleList.handles[i], 0, &Node);
 132       if (ACPI_SUCCESS(AcpiStatus)) {
 133         DPRINT("Got BM node information: (Node 0x%X)\n", Node);
 134         bm_print1(Node, BM_PRINT_ALL - BM_PRINT_PRESENT);
 135 #if 1
 136         for (j=0; j < 4*1000;j++)
 137           KeStallExecutionProcessor(1000);
 138 #endif
 139       } else {
 140         DPRINT("Could not get BM node\n");
 141       }
 142
 143       AcpiDevice = (PACPI_DEVICE)ExAllocatePool(
 144           NonPagedPool, sizeof(ACPI_DEVICE));
 145       if (!AcpiDevice) {
 146         return STATUS_INSUFFICIENT_RESOURCES;
 147       }
 148
 149       RtlZeroMemory(AcpiDevice, sizeof(ACPI_DEVICE));
 150
 151       AcpiDevice->Pdo = NULL;
 152       AcpiDevice->BmHandle = HandleList.handles[i];
 153
 154       KeAcquireSpinLock(&DeviceExtension->DeviceListLock, &OldIrql);
 155       InsertHeadList(&DeviceExtension->DeviceListHead,
 156         &AcpiDevice->DeviceListEntry);
 157       DeviceExtension->DeviceListCount++;
 158       KeReleaseSpinLock(&DeviceExtension->DeviceListLock, OldIrql);
 159     }
 160   } else {
 161     DPRINT("Got no devices (Status 0x%X)\n", AcpiStatus);
 162   }
 163         for (j=0; j < 4*10*1000;j++)
 164           KeStallExecutionProcessor(1000);
 165
 166   return STATUS_SUCCESS;
 167 }
 168
 169
 170 NTSTATUS
 171 ACPIEnumerateNamespace(
 172   PFDO_DEVICE_EXTENSION DeviceExtension)
 173 {
 174   BM_HANDLE_LIST HandleList;
 175   PACPI_DEVICE AcpiDevice;
 176   ACPI_STATUS AcpiStatus;
 177   BM_HANDLE DeviceHandle;
 178         BM_DEVICE_ID Criteria;
 179   BM_NODE *Node;
 180   KIRQL OldIrql;
 181   ULONG i;
 182
 183   DPRINT("Called\n");
 184
 185         RtlZeroMemory(&Criteria, sizeof(BM_DEVICE_ID));
 186
 187   DbgPrint("Listing ACPI namespace\n");
 188   Criteria.type = BM_TYPE_ALL;
 189
 190   AcpiStatus = bm_search(BM_HANDLE_ROOT, &Criteria, &HandleList);
 191   if (ACPI_SUCCESS(AcpiStatus)) {
 192     DPRINT("Got %d devices\n", HandleList.count);
 193
 194     for (i = 0; i < HandleList.count; i++) {
 195       AcpiStatus = bm_get_node(HandleList.handles[i], 0, &Node);
 196       if (ACPI_SUCCESS(AcpiStatus)) {
 197         DPRINT("Got BM node information: (Node 0x%X)\n", Node);
 198 #if 0
 199         {
 200           ULONG j;
 201
 202           bm_print1(Node, BM_PRINT_ALL - BM_PRINT_PRESENT);
 203           for (j=0; j < 4*1000;j++)
 204             KeStallExecutionProcessor(1000);
 205         }
 206 #endif
 207       } else {
 208         DPRINT("Could not get BM node\n");
 209       }
 210
 211       AcpiDevice = (PACPI_DEVICE)ExAllocatePool(
 212           NonPagedPool, sizeof(ACPI_DEVICE));
 213       if (!AcpiDevice) {
 214         return STATUS_INSUFFICIENT_RESOURCES;
 215       }
 216
 217       RtlZeroMemory(AcpiDevice, sizeof(ACPI_DEVICE));
 218
 219       AcpiDevice->Pdo = NULL;
 220       AcpiDevice->BmHandle = HandleList.handles[i];
 221
 222       KeAcquireSpinLock(&DeviceExtension->DeviceListLock, &OldIrql);
 223       InsertHeadList(&DeviceExtension->DeviceListHead,
 224         &AcpiDevice->DeviceListEntry);
 225       DeviceExtension->DeviceListCount++;
 226       KeReleaseSpinLock(&DeviceExtension->DeviceListLock, OldIrql);
 227     }
 228   } else {
 229     DPRINT("Got no devices (Status 0x%X)\n", AcpiStatus);
 230   }
 231
 232   return STATUS_SUCCESS;
 233 }
 234
 235 /* EOF */