reactos/drivers/bus/acpi/buspdo.c

   1 #include <ntddk.h>
   2
   3 #include <acpi.h>
   4 #include <acpisys.h>
   5 #include <wdmguid.h>
   6 #include <stdio.h>
   7
   8 #include <acpi_bus.h>
   9 #include <acpi_drivers.h>
  10
  11 //#define NDEBUG
  12 #include <debug.h>
  13
  14 #ifdef ALLOC_PRAGMA
  15 #pragma alloc_text (PAGE, Bus_PDO_PnP)
  16 #pragma alloc_text (PAGE, Bus_PDO_QueryDeviceCaps)
  17 #pragma alloc_text (PAGE, Bus_PDO_QueryDeviceId)
  18 #pragma alloc_text (PAGE, Bus_PDO_QueryDeviceText)
  19 #pragma alloc_text (PAGE, Bus_PDO_QueryResources)
  20 #pragma alloc_text (PAGE, Bus_PDO_QueryResourceRequirements)
  21 #pragma alloc_text (PAGE, Bus_PDO_QueryDeviceRelations)
  22 #pragma alloc_text (PAGE, Bus_PDO_QueryBusInformation)
  23 #pragma alloc_text (PAGE, Bus_GetDeviceCapabilities)
  24 #endif
  25
  26 NTSTATUS
  27 Bus_PDO_PnP (
  28      PDEVICE_OBJECT       DeviceObject,
  29      PIRP                 Irp,
  30      PIO_STACK_LOCATION   IrpStack,
  31      PPDO_DEVICE_DATA     DeviceData
  32     )
  33 {
  34     NTSTATUS                status;
  35     POWER_STATE             state;
  36
  37     PAGED_CODE ();
  38
  39     //
  40     // NB: Because we are a bus enumerator, we have no one to whom we could
  41     // defer these irps.  Therefore we do not pass them down but merely
  42     // return them.
  43     //
  44
  45     switch (IrpStack->MinorFunction) {
  46
  47     case IRP_MN_START_DEVICE:
  48
  49         //
  50         // Here we do what ever initialization and ``turning on'' that is
  51         // required to allow others to access this device.
  52         // Power up the device.
  53         //
  54         if (DeviceData->AcpiHandle && acpi_bus_power_manageable(DeviceData->AcpiHandle) &&
  55             !ACPI_SUCCESS(acpi_bus_set_power(DeviceData->AcpiHandle, ACPI_STATE_D0)))
  56         {
  57             DPRINT1("Device %x failed to start!\n", DeviceData->AcpiHandle);
  58             status = STATUS_UNSUCCESSFUL;
  59             break;
  60         }
  61
  62         state.DeviceState = PowerDeviceD0;
  63         PoSetPowerState(DeviceData->Common.Self, DevicePowerState, state);
  64         DeviceData->Common.DevicePowerState = PowerDeviceD0;
  65         SET_NEW_PNP_STATE(DeviceData->Common, Started);
  66         status = STATUS_SUCCESS;
  67         break;
  68
  69     case IRP_MN_STOP_DEVICE:
  70
  71         //
  72         // Here we shut down the device and give up and unmap any resources
  73         // we acquired for the device.
  74         //
  75         if (DeviceData->AcpiHandle && acpi_bus_power_manageable(DeviceData->AcpiHandle) &&
  76             !ACPI_SUCCESS(acpi_bus_set_power(DeviceData->AcpiHandle, ACPI_STATE_D3)))
  77         {
  78             DPRINT1("Device %x failed to stop!\n", DeviceData->AcpiHandle);
  79             status = STATUS_UNSUCCESSFUL;
  80             break;
  81         }
  82
  83         state.DeviceState = PowerDeviceD3;
  84         PoSetPowerState(DeviceData->Common.Self, DevicePowerState, state);
  85         DeviceData->Common.DevicePowerState = PowerDeviceD3;
  86         SET_NEW_PNP_STATE(DeviceData->Common, Stopped);
  87         status = STATUS_SUCCESS;
  88         break;
  89
  90
  91     case IRP_MN_QUERY_STOP_DEVICE:
  92
  93         //
  94         // No reason here why we can't stop the device.
  95         // If there were a reason we should speak now, because answering success
  96         // here may result in a stop device irp.
  97         //
  98
  99         SET_NEW_PNP_STATE(DeviceData->Common, StopPending);
 100         status = STATUS_SUCCESS;
 101         break;
 102
 103     case IRP_MN_CANCEL_STOP_DEVICE:
 104
 105         //
 106         // The stop was canceled.  Whatever state we set, or resources we put
 107         // on hold in anticipation of the forthcoming STOP device IRP should be
 108         // put back to normal.  Someone, in the long list of concerned parties,
 109         // has failed the stop device query.
 110         //
 111
 112         //
 113         // First check to see whether you have received cancel-stop
 114         // without first receiving a query-stop. This could happen if someone
 115         // above us fails a query-stop and passes down the subsequent
 116         // cancel-stop.
 117         //
 118
 119         if (StopPending == DeviceData->Common.DevicePnPState)
 120         {
 121             //
 122             // We did receive a query-stop, so restore.
 123             //
 124             RESTORE_PREVIOUS_PNP_STATE(DeviceData->Common);
 125         }
 126         status = STATUS_SUCCESS;// We must not fail this IRP.
 127         break;
 128     case IRP_MN_QUERY_CAPABILITIES:
 129
 130         //
 131         // Return the capabilities of a device, such as whether the device
 132         // can be locked or ejected..etc
 133         //
 134
 135         status = Bus_PDO_QueryDeviceCaps(DeviceData, Irp);
 136
 137         break;
 138
 139     case IRP_MN_QUERY_ID:
 140
 141         // Query the IDs of the device
 142         status = Bus_PDO_QueryDeviceId(DeviceData, Irp);
 143
 144         break;
 145
 146     case IRP_MN_QUERY_DEVICE_RELATIONS:
 147
 148         DPRINT("\tQueryDeviceRelation Type: %s\n",DbgDeviceRelationString(\
 149                     IrpStack->Parameters.QueryDeviceRelations.Type));
 150
 151         status = Bus_PDO_QueryDeviceRelations(DeviceData, Irp);
 152
 153         break;
 154
 155     case IRP_MN_QUERY_DEVICE_TEXT:
 156
 157         status = Bus_PDO_QueryDeviceText(DeviceData, Irp);
 158
 159         break;
 160
 161     case IRP_MN_QUERY_RESOURCES:
 162
 163         status = Bus_PDO_QueryResources(DeviceData, Irp);
 164
 165         break;
 166
 167     case IRP_MN_QUERY_RESOURCE_REQUIREMENTS:
 168
 169         status = Bus_PDO_QueryResourceRequirements(DeviceData, Irp);
 170
 171         break;
 172
 173     case IRP_MN_QUERY_BUS_INFORMATION:
 174
 175         status = Bus_PDO_QueryBusInformation(DeviceData, Irp);
 176
 177         break;
 178
 179
 180     case IRP_MN_FILTER_RESOURCE_REQUIREMENTS:
 181
 182         //
 183         // OPTIONAL for bus drivers.
 184         // The PnP Manager sends this IRP to a device
 185         // stack so filter and function drivers can adjust the
 186         // resources required by the device, if appropriate.
 187         //
 188
 189         //break;
 190
 191     //case IRP_MN_QUERY_PNP_DEVICE_STATE:
 192
 193         //
 194         // OPTIONAL for bus drivers.
 195         // The PnP Manager sends this IRP after the drivers for
 196         // a device return success from the IRP_MN_START_DEVICE
 197         // request. The PnP Manager also sends this IRP when a
 198         // driver for the device calls IoInvalidateDeviceState.
 199         //
 200
 201         // break;
 202
 203     //case IRP_MN_READ_CONFIG:
 204     //case IRP_MN_WRITE_CONFIG:
 205
 206         //
 207         // Bus drivers for buses with configuration space must handle
 208         // this request for their child devices. Our devices don't
 209         // have a config space.
 210         //
 211
 212         // break;
 213
 214     //case IRP_MN_SET_LOCK:
 215
 216         // break;
 217
 218     default:
 219
 220         //
 221         // For PnP requests to the PDO that we do not understand we should
 222         // return the IRP WITHOUT setting the status or information fields.
 223         // These fields may have already been set by a filter (eg acpi).
 224         status = Irp->IoStatus.Status;
 225
 226         break;
 227     }
 228
 229     Irp->IoStatus.Status = status;
 230     IoCompleteRequest (Irp, IO_NO_INCREMENT);
 231
 232     return status;
 233 }
 234
 235 NTSTATUS
 236 Bus_PDO_QueryDeviceCaps(
 237      PPDO_DEVICE_DATA     DeviceData,
 238       PIRP   Irp )
 239 {
 240
 241     PIO_STACK_LOCATION      stack;
 242     PDEVICE_CAPABILITIES    deviceCapabilities;
 243     struct acpi_device *device = NULL;
 244     ULONG i;
 245
 246     PAGED_CODE ();
 247
 248     if (DeviceData->AcpiHandle)
 249         acpi_bus_get_device(DeviceData->AcpiHandle, &device);
 250
 251     stack = IoGetCurrentIrpStackLocation (Irp);
 252
 253     //
 254     // Get the packet.
 255     //
 256     deviceCapabilities=stack->Parameters.DeviceCapabilities.Capabilities;
 257
 258     //
 259     // Set the capabilities.
 260     //
 261
 262     if (deviceCapabilities->Version != 1 ||
 263             deviceCapabilities->Size < sizeof(DEVICE_CAPABILITIES))
 264     {
 265        return STATUS_UNSUCCESSFUL;
 266     }
 267
 268     deviceCapabilities->D1Latency = 0;
 269     deviceCapabilities->D2Latency = 0;
 270     deviceCapabilities->D3Latency = 0;
 271
 272     deviceCapabilities->DeviceState[PowerSystemWorking] = PowerDeviceD0;
 273     deviceCapabilities->DeviceState[PowerSystemSleeping1] = PowerDeviceD3;
 274     deviceCapabilities->DeviceState[PowerSystemSleeping2] = PowerDeviceD3;
 275     deviceCapabilities->DeviceState[PowerSystemSleeping3] = PowerDeviceD3;
 276
 277     for (i = 0; i < ACPI_D_STATE_COUNT && device; i++)
 278     {
 279         if (!device->power.states[i].flags.valid)
 280             continue;
 281
 282         switch (i)
 283         {
 284            case ACPI_STATE_D0:
 285               deviceCapabilities->DeviceState[PowerSystemWorking] = PowerDeviceD0;
 286               break;
 287
 288            case ACPI_STATE_D1:
 289               deviceCapabilities->DeviceState[PowerSystemSleeping1] = PowerDeviceD1;
 290               deviceCapabilities->D1Latency = device->power.states[i].latency;
 291               break;
 292
 293            case ACPI_STATE_D2:
 294               deviceCapabilities->DeviceState[PowerSystemSleeping2] = PowerDeviceD2;
 295               deviceCapabilities->D2Latency = device->power.states[i].latency;
 296               break;
 297
 298            case ACPI_STATE_D3:
 299               deviceCapabilities->DeviceState[PowerSystemSleeping3] = PowerDeviceD3;
 300               deviceCapabilities->D3Latency = device->power.states[i].latency;
 301               break;
 302         }
 303     }
 304
 305     // We can wake the system from D1
 306     deviceCapabilities->DeviceWake = PowerDeviceD1;
 307
 308
 309     deviceCapabilities->DeviceD1 =
 310         (deviceCapabilities->DeviceState[PowerSystemSleeping1] == PowerDeviceD1) ? TRUE : FALSE;
 311     deviceCapabilities->DeviceD2 =
 312         (deviceCapabilities->DeviceState[PowerSystemSleeping2] == PowerDeviceD2) ? TRUE : FALSE;
 313
 314     deviceCapabilities->WakeFromD0 = FALSE;
 315     deviceCapabilities->WakeFromD1 = TRUE; //Yes we can
 316     deviceCapabilities->WakeFromD2 = FALSE;
 317     deviceCapabilities->WakeFromD3 = FALSE;
 318
 319     if (device)
 320     {
 321        deviceCapabilities->EjectSupported = device->flags.ejectable;
 322        deviceCapabilities->HardwareDisabled = !device->status.enabled;
 323        deviceCapabilities->Removable = device->flags.removable;
 324        deviceCapabilities->SurpriseRemovalOK = device->flags.suprise_removal_ok;
 325        deviceCapabilities->UniqueID = device->flags.unique_id;
 326        deviceCapabilities->NoDisplayInUI = !device->status.show_in_ui;
 327        deviceCapabilities->Address = device->pnp.bus_address;
 328     }
 329     else
 330     {
 331        deviceCapabilities->EjectSupported = FALSE;
 332        deviceCapabilities->HardwareDisabled = FALSE;
 333        deviceCapabilities->Removable = FALSE;
 334        deviceCapabilities->SurpriseRemovalOK = FALSE;
 335        deviceCapabilities->UniqueID = FALSE;
 336        deviceCapabilities->NoDisplayInUI = FALSE;
 337        deviceCapabilities->Address = 0;
 338     }
 339
 340     deviceCapabilities->SilentInstall = FALSE;
 341     deviceCapabilities->UINumber = (ULONG)-1;
 342
 343     return STATUS_SUCCESS;
 344
 345 }
 346
 347 NTSTATUS
 348 Bus_PDO_QueryDeviceId(
 349      PPDO_DEVICE_DATA     DeviceData,
 350       PIRP   Irp )
 351 {
 352     PIO_STACK_LOCATION      stack;
 353     PWCHAR                  buffer;
 354     WCHAR                   temp[256];
 355     ULONG                   length;
 356     NTSTATUS                status = STATUS_SUCCESS;
 357     struct acpi_device *Device;
 358
 359     PAGED_CODE ();
 360
 361     stack = IoGetCurrentIrpStackLocation (Irp);
 362
 363     switch (stack->Parameters.QueryId.IdType) {
 364
 365     case BusQueryDeviceID:
 366         if (DeviceData->AcpiHandle)
 367         {
 368             acpi_bus_get_device(DeviceData->AcpiHandle, &Device);
 369
 370             length = swprintf(temp,
 371                               L"ACPI\\%hs",
 372                               Device->pnp.hardware_id);
 373         }
 374         else
 375         {
 376             /* We know it's a fixed feature button because
 377              * these are direct children of the ACPI root device
 378              * and therefore have no handle
 379              */
 380             length = swprintf(temp,
 381                               L"ACPI\\FixedButton");
 382         }
 383
 384         temp[++length] = UNICODE_NULL;
 385
 386          buffer = ExAllocatePoolWithTag (PagedPool, length * sizeof(WCHAR), 'IPCA');
 387
 388         if (!buffer) {
 389            status = STATUS_INSUFFICIENT_RESOURCES;
 390            break;
 391         }
 392
 393         RtlCopyMemory (buffer, temp, length * sizeof(WCHAR));
 394         Irp->IoStatus.Information = (ULONG_PTR) buffer;
 395         DPRINT("BusQueryDeviceID: %ls\n",buffer);
 396         break;
 397
 398     case BusQueryInstanceID:
 399         /* See comment in BusQueryDeviceID case */
 400         if(DeviceData->AcpiHandle)
 401         {
 402            acpi_bus_get_device(DeviceData->AcpiHandle, &Device);
 403
 404            if (Device->flags.unique_id)
 405               length = swprintf(temp,
 406                                 L"%hs",
 407                                 Device->pnp.unique_id);
 408            else
 409               /* FIXME: Generate unique id! */
 410               length = swprintf(temp, L"%ls", L"0000");
 411         }
 412         else
 413            /* FIXME: Generate unique id! */
 414            length = swprintf(temp, L"%ls", L"0000");
 415
 416         temp[++length] = UNICODE_NULL;
 417
 418         buffer = ExAllocatePoolWithTag (PagedPool, length * sizeof (WCHAR), 'IPCA');
 419         if (!buffer) {
 420            status = STATUS_INSUFFICIENT_RESOURCES;
 421            break;
 422         }
 423
 424         RtlCopyMemory (buffer, temp, length * sizeof (WCHAR));
 425         DPRINT("BusQueryInstanceID: %ls\n",buffer);
 426         Irp->IoStatus.Information = (ULONG_PTR) buffer;
 427         break;
 428
 429     case BusQueryHardwareIDs:
 430         length = 0;
 431
 432         /* See comment in BusQueryDeviceID case */
 433         if (DeviceData->AcpiHandle)
 434         {
 435             acpi_bus_get_device(DeviceData->AcpiHandle, &Device);
 436
 437             length += swprintf(&temp[length],
 438                                L"ACPI\\%hs",
 439                                Device->pnp.hardware_id);
 440             length++;
 441
 442             length += swprintf(&temp[length],
 443                                L"*%hs",
 444                                Device->pnp.hardware_id);
 445             length++;
 446          }
 447          else
 448          {
 449             length += swprintf(&temp[length],
 450                                L"ACPI\\FixedButton");
 451             length++;
 452
 453             length += swprintf(&temp[length],
 454                                L"*FixedButton");
 455             length++;
 456          }
 457
 458          temp[length] = UNICODE_NULL;
 459
 460          length++;
 461
 462          temp[length] = UNICODE_NULL;
 463
 464         buffer = ExAllocatePoolWithTag (PagedPool, length * sizeof(WCHAR), 'IPCA');
 465
 466         if (!buffer) {
 467            status = STATUS_INSUFFICIENT_RESOURCES;
 468            break;
 469         }
 470
 471         RtlCopyMemory (buffer, temp, length * sizeof(WCHAR));
 472         Irp->IoStatus.Information = (ULONG_PTR) buffer;
 473         DPRINT("BusQueryHardwareIDs: %ls\n",buffer);
 474         break;
 475
 476     default:
 477         status = Irp->IoStatus.Status;
 478     }
 479     return status;
 480 }
 481
 482 NTSTATUS
 483 Bus_PDO_QueryDeviceText(
 484      PPDO_DEVICE_DATA     DeviceData,
 485       PIRP   Irp )
 486 {
 487     PWCHAR  Buffer;
 488     PIO_STACK_LOCATION   stack;
 489     NTSTATUS    status;
 490     PAGED_CODE ();
 491
 492     stack = IoGetCurrentIrpStackLocation (Irp);
 493
 494     switch (stack->Parameters.QueryDeviceText.DeviceTextType) {
 495
 496     case DeviceTextDescription:
 497
 498         if (!Irp->IoStatus.Information) {
 499                   if (wcsstr (DeviceData->HardwareIDs, L"PNP000") != 0)
 500                         Buffer = L"Programmable interrupt controller";
 501                   else if (wcsstr(DeviceData->HardwareIDs, L"PNP010") != 0)
 502                         Buffer = L"System timer";
 503                   else if (wcsstr(DeviceData->HardwareIDs, L"PNP020") != 0)
 504                         Buffer = L"DMA controller";
 505                   else if (wcsstr(DeviceData->HardwareIDs, L"PNP03") != 0)
 506                         Buffer = L"Keyboard";
 507                   else if (wcsstr(DeviceData->HardwareIDs, L"PNP040") != 0)
 508                         Buffer = L"Parallel port";
 509                   else if (wcsstr(DeviceData->HardwareIDs, L"PNP05") != 0)
 510                         Buffer = L"Serial port";
 511                   else if (wcsstr(DeviceData->HardwareIDs, L"PNP06") != 0)
 512                         Buffer = L"Disk controller";
 513                   else if (wcsstr(DeviceData->HardwareIDs, L"PNP07") != 0)
 514                         Buffer = L"Disk controller";
 515                   else if (wcsstr(DeviceData->HardwareIDs, L"PNP09") != 0)
 516                         Buffer = L"Display adapter";
 517                   else if (wcsstr(DeviceData->HardwareIDs, L"PNP0A0") != 0)
 518                         Buffer = L"Bus controller";
 519                   else if (wcsstr(DeviceData->HardwareIDs, L"PNP0E0") != 0)
 520                         Buffer = L"PCMCIA controller";
 521                   else if (wcsstr(DeviceData->HardwareIDs, L"PNP0F") != 0)
 522                         Buffer = L"Mouse device";
 523                   else if (wcsstr(DeviceData->HardwareIDs, L"PNP8") != 0)
 524                         Buffer = L"Network adapter";
 525                   else if (wcsstr(DeviceData->HardwareIDs, L"PNPA0") != 0)
 526                         Buffer = L"SCSI controller";
 527                   else if (wcsstr(DeviceData->HardwareIDs, L"PNPB0") != 0)
 528                         Buffer = L"Multimedia device";
 529                   else if (wcsstr(DeviceData->HardwareIDs, L"PNPC00") != 0)
 530                         Buffer = L"Modem";
 531                   else if (wcsstr(DeviceData->HardwareIDs, L"PNP0C0C") != 0)
 532                         Buffer = L"Power Button";
 533                   else if (wcsstr(DeviceData->HardwareIDs, L"PNP0C0E") != 0)
 534                         Buffer = L"Sleep Button";
 535                   else if (wcsstr(DeviceData->HardwareIDs, L"PNP0C0D") != 0)
 536                         Buffer = L"Lid Switch";
 537                   else if (wcsstr(DeviceData->HardwareIDs, L"PNP0C09") != 0)
 538                         Buffer = L"ACPI Embedded Controller";
 539                    else if (wcsstr(DeviceData->HardwareIDs, L"PNP0C0B") != 0)
 540                         Buffer = L"ACPI Fan";
 541                    else if (wcsstr(DeviceData->HardwareIDs, L"PNP0A03") != 0)
 542                         Buffer = L"PCI Root Bridge";
 543                    else if (wcsstr(DeviceData->HardwareIDs, L"PNP0C0A") != 0)
 544                         Buffer = L"ACPI Battery";
 545                    else if (wcsstr(DeviceData->HardwareIDs, L"PNP0C0F") != 0)
 546                         Buffer = L"PCI Interrupt Link";
 547                    else if (wcsstr(DeviceData->HardwareIDs, L"ACPI_PWR") != 0)
 548                         Buffer = L"ACPI Power Resource";
 549                    else if (wcsstr(DeviceData->HardwareIDs, L"Processor") != 0)
 550                         Buffer = L"Processor";
 551                    else if (wcsstr(DeviceData->HardwareIDs, L"ACPI_SYS") != 0)
 552                         Buffer = L"ACPI System";
 553                    else if (wcsstr(DeviceData->HardwareIDs, L"ThermalZone") != 0)
 554                         Buffer = L"ACPI Thermal Zone";
 555                    else if (wcsstr(DeviceData->HardwareIDs, L"ACPI0002") != 0)
 556                         Buffer = L"Smart Battery";
 557                    else if (wcsstr(DeviceData->HardwareIDs, L"ACPI0003") != 0)
 558                         Buffer = L"AC Adapter";
 559                    /* Simply checking if AcpiHandle is NULL eliminates the need to check
 560                     * for the 4 different names that ACPI knows the fixed feature button as internally
 561                     */
 562                    else if (!DeviceData->AcpiHandle)
 563                         Buffer = L"ACPI Fixed Feature Button";
 564                   else
 565                         Buffer = L"Other ACPI device";
 566
 567             DPRINT("\tDeviceTextDescription :%ws\n", Buffer);
 568
 569             Irp->IoStatus.Information = (ULONG_PTR) Buffer;
 570         }
 571             status = STATUS_SUCCESS;
 572         break;
 573
 574     default:
 575         status = Irp->IoStatus.Status;
 576         break;
 577     }
 578
 579     return status;
 580
 581 }
 582
 583 NTSTATUS
 584 Bus_PDO_QueryResources(
 585      PPDO_DEVICE_DATA     DeviceData,
 586       PIRP   Irp )
 587 {
 588         BOOLEAN Done;
 589         ULONG NumberOfResources = 0;
 590         PCM_RESOURCE_LIST ResourceList;
 591         PCM_PARTIAL_RESOURCE_DESCRIPTOR ResourceDescriptor;
 592         ACPI_STATUS AcpiStatus;
 593         ACPI_BUFFER Buffer;
 594         ACPI_RESOURCE* resource;
 595         ULONG ResourceListSize;
 596         ULONG i;
 597
 598
 599     /* Get current resources */
 600     Buffer.Length = 0;
 601     AcpiStatus = AcpiGetCurrentResources(DeviceData->AcpiHandle, &Buffer);
 602     if ((!ACPI_SUCCESS(AcpiStatus) && AcpiStatus != AE_BUFFER_OVERFLOW) ||
 603         Buffer.Length == 0)
 604     {
 605       return Irp->IoStatus.Status;
 606     }
 607
 608     Buffer.Pointer = ExAllocatePool(PagedPool, Buffer.Length);
 609     if (!Buffer.Pointer)
 610       return STATUS_INSUFFICIENT_RESOURCES;
 611
 612     AcpiStatus = AcpiGetCurrentResources(DeviceData->AcpiHandle, &Buffer);
 613     if (!ACPI_SUCCESS(AcpiStatus))
 614     {
 615       DPRINT1("AcpiGetCurrentResources #2 failed (0x%x)\n", AcpiStatus);
 616       ASSERT(FALSE);
 617       return STATUS_UNSUCCESSFUL;
 618     }
 619
 620         resource= Buffer.Pointer;
 621         /* Count number of resources */
 622         Done = FALSE;
 623         while (!Done)
 624         {
 625                 switch (resource->Type)
 626                 {
 627                         case ACPI_RESOURCE_TYPE_IRQ:
 628                         {
 629                                 ACPI_RESOURCE_IRQ *irq_data = (ACPI_RESOURCE_IRQ*) &resource->Data;
 630                                 NumberOfResources += irq_data->InterruptCount;
 631                                 break;
 632                         }
 633                         case ACPI_RESOURCE_TYPE_DMA:
 634                         {
 635                                 ACPI_RESOURCE_DMA *dma_data = (ACPI_RESOURCE_DMA*) &resource->Data;
 636                                 NumberOfResources += dma_data->ChannelCount;
 637                                 break;
 638                         }
 639                         case ACPI_RESOURCE_TYPE_IO:
 640                         {
 641                                 NumberOfResources++;
 642                                 break;
 643                         }
 644                         case ACPI_RESOURCE_TYPE_END_TAG:
 645                         {
 646                                 Done = TRUE;
 647                                 break;
 648                         }
 649                         default:
 650                         {
 651                                 break;
 652                         }
 653                 }
 654                 resource = ACPI_NEXT_RESOURCE(resource);
 655         }
 656
 657         /* Allocate memory */
 658         ResourceListSize = sizeof(CM_RESOURCE_LIST) + sizeof(CM_PARTIAL_RESOURCE_DESCRIPTOR) * (NumberOfResources - 1);
 659         ResourceList = (PCM_RESOURCE_LIST)ExAllocatePool(PagedPool, ResourceListSize);
 660
 661         if (!ResourceList)
 662                 return FALSE;
 663         ResourceList->Count = 1;
 664         ResourceList->List[0].InterfaceType = Internal; /* FIXME */
 665         ResourceList->List[0].BusNumber = 0; /* We're the only ACPI bus device in the system */
 666         ResourceList->List[0].PartialResourceList.Version = 1;
 667         ResourceList->List[0].PartialResourceList.Revision = 1;
 668         ResourceList->List[0].PartialResourceList.Count = NumberOfResources;
 669         ResourceDescriptor = ResourceList->List[0].PartialResourceList.PartialDescriptors;
 670
 671         /* Fill resources list structure */
 672         Done = FALSE;
 673         while (!Done)
 674         {
 675                 switch (resource->Type)
 676                 {
 677                         case ACPI_RESOURCE_TYPE_IRQ:
 678                         {
 679                                 ACPI_RESOURCE_IRQ *irq_data = (ACPI_RESOURCE_IRQ*) &resource->Data;
 680                                 for (i = 0; i < irq_data->InterruptCount; i++)
 681                                 {
 682                                         ResourceDescriptor->Type = CmResourceTypeInterrupt;
 683
 684                                         ResourceDescriptor->ShareDisposition =
 685                                         (irq_data->Sharable == ACPI_SHARED ? CmResourceShareShared : CmResourceShareDeviceExclusive);
 686                                         ResourceDescriptor->Flags =
 687                                         (irq_data->Triggering == ACPI_LEVEL_SENSITIVE ? CM_RESOURCE_INTERRUPT_LEVEL_SENSITIVE : CM_RESOURCE_INTERRUPT_LATCHED);
 688                                         ResourceDescriptor->u.Interrupt.Level = irq_data->Interrupts[i];
 689                                         ResourceDescriptor->u.Interrupt.Vector = 0;
 690                                         ResourceDescriptor->u.Interrupt.Affinity = (KAFFINITY)(-1);
 691
 692                                         ResourceDescriptor++;
 693                                 }
 694                                 break;
 695                         }
 696                         case ACPI_RESOURCE_TYPE_DMA:
 697                         {
 698                                 ACPI_RESOURCE_DMA *dma_data = (ACPI_RESOURCE_DMA*) &resource->Data;
 699                                 for (i = 0; i < dma_data->ChannelCount; i++)
 700                                 {
 701                                         ResourceDescriptor->Type = CmResourceTypeDma;
 702                                         ResourceDescriptor->Flags = 0;
 703                                 switch (dma_data->Type)
 704                                 {
 705                                         case ACPI_TYPE_A: ResourceDescriptor->Flags |= CM_RESOURCE_DMA_TYPE_A; break;
 706                                         case ACPI_TYPE_B: ResourceDescriptor->Flags |= CM_RESOURCE_DMA_TYPE_B; break;
 707                                         case ACPI_TYPE_F: ResourceDescriptor->Flags |= CM_RESOURCE_DMA_TYPE_F; break;
 708                                 }
 709                                 if (dma_data->BusMaster == ACPI_BUS_MASTER)
 710                                         ResourceDescriptor->Flags |= CM_RESOURCE_DMA_BUS_MASTER;
 711                                 switch (dma_data->Transfer)
 712                                 {
 713                                         case ACPI_TRANSFER_8: ResourceDescriptor->Flags |= CM_RESOURCE_DMA_8; break;
 714                                         case ACPI_TRANSFER_16: ResourceDescriptor->Flags |= CM_RESOURCE_DMA_16; break;
 715                                         case ACPI_TRANSFER_8_16: ResourceDescriptor->Flags |= CM_RESOURCE_DMA_8_AND_16; break;
 716                                 }
 717                                 ResourceDescriptor->u.Dma.Channel = dma_data->Channels[i];
 718
 719                                 ResourceDescriptor++;
 720                         }
 721                         break;
 722                         }
 723                         case ACPI_RESOURCE_TYPE_IO:
 724                         {
 725                                 ACPI_RESOURCE_IO *io_data = (ACPI_RESOURCE_IO*) &resource->Data;
 726                                 ResourceDescriptor->Type = CmResourceTypePort;
 727                                 ResourceDescriptor->ShareDisposition = CmResourceShareDriverExclusive;
 728                                 ResourceDescriptor->Flags = CM_RESOURCE_PORT_IO;
 729                                 if (io_data->IoDecode == ACPI_DECODE_16)
 730                                         ResourceDescriptor->Flags |= CM_RESOURCE_PORT_16_BIT_DECODE;
 731                                 else
 732                                         ResourceDescriptor->Flags |= CM_RESOURCE_PORT_10_BIT_DECODE;
 733                                 ResourceDescriptor->u.Port.Start.u.HighPart = 0;
 734                                 ResourceDescriptor->u.Port.Start.u.LowPart = io_data->Minimum;
 735                                 ResourceDescriptor->u.Port.Length = io_data->AddressLength;
 736
 737                                 ResourceDescriptor++;
 738                                 break;
 739                         }
 740                         case ACPI_RESOURCE_TYPE_END_TAG:
 741                         {
 742                                 Done = TRUE;
 743                                 break;
 744                         }
 745                         default:
 746                         {
 747                                 DPRINT1("Unhandled resource type\n");
 748                                 break;
 749                         }
 750                 }
 751                 resource = ACPI_NEXT_RESOURCE(resource);
 752         }
 753
 754     ExFreePool(Buffer.Pointer);
 755         Irp->IoStatus.Information = (ULONG_PTR)ResourceList;
 756         return STATUS_SUCCESS;
 757 }
 758
 759 NTSTATUS
 760 Bus_PDO_QueryResourceRequirements(
 761      PPDO_DEVICE_DATA     DeviceData,
 762       PIRP   Irp )
 763 {
 764         BOOLEAN Done;
 765         ULONG NumberOfResources = 0;
 766         ACPI_STATUS AcpiStatus;
 767         ACPI_BUFFER Buffer;
 768         ACPI_RESOURCE* resource;
 769         ULONG i, RequirementsListSize;
 770         PIO_RESOURCE_REQUIREMENTS_LIST RequirementsList;
 771         PIO_RESOURCE_DESCRIPTOR RequirementDescriptor;
 772
 773     PAGED_CODE ();
 774
 775
 776     /* Get current resources */
 777     Buffer.Length = 0;
 778     AcpiStatus = AcpiGetCurrentResources(DeviceData->AcpiHandle, &Buffer);
 779     if ((!ACPI_SUCCESS(AcpiStatus) && AcpiStatus != AE_BUFFER_OVERFLOW) ||
 780         Buffer.Length == 0)
 781     {
 782       return Irp->IoStatus.Status;
 783     }
 784
 785     Buffer.Pointer = ExAllocatePool(PagedPool, Buffer.Length);
 786     if (!Buffer.Pointer)
 787       return STATUS_INSUFFICIENT_RESOURCES;
 788
 789     AcpiStatus = AcpiGetCurrentResources(DeviceData->AcpiHandle, &Buffer);
 790     if (!ACPI_SUCCESS(AcpiStatus))
 791     {
 792       DPRINT1("AcpiGetCurrentResources #2 failed (0x%x)\n", AcpiStatus);
 793       ASSERT(FALSE);
 794       return STATUS_UNSUCCESSFUL;
 795     }
 796
 797         resource= Buffer.Pointer;
 798         /* Count number of resources */
 799         Done = FALSE;
 800         while (!Done)
 801         {
 802                 switch (resource->Type)
 803                 {
 804                         case ACPI_RESOURCE_TYPE_IRQ:
 805                         {
 806                                 ACPI_RESOURCE_IRQ *irq_data = (ACPI_RESOURCE_IRQ*) &resource->Data;
 807                                 NumberOfResources += irq_data->InterruptCount;
 808                                 break;
 809                         }
 810                         case ACPI_RESOURCE_TYPE_DMA:
 811                         {
 812                                 ACPI_RESOURCE_DMA *dma_data = (ACPI_RESOURCE_DMA*) &resource->Data;
 813                                 NumberOfResources += dma_data->ChannelCount;
 814                                 break;
 815                         }
 816                         case ACPI_RESOURCE_TYPE_IO:
 817                         {
 818                                 NumberOfResources++;
 819                                 break;
 820                         }
 821                         case ACPI_RESOURCE_TYPE_END_TAG:
 822                         {
 823                                 Done = TRUE;
 824                                 break;
 825                         }
 826                         default:
 827                         {
 828                                 break;
 829                         }
 830                 }
 831                 resource = ACPI_NEXT_RESOURCE(resource);
 832         }
 833
 834         RequirementsListSize = sizeof(IO_RESOURCE_REQUIREMENTS_LIST) + sizeof(IO_RESOURCE_DESCRIPTOR) * (NumberOfResources - 1);
 835         RequirementsList = (PIO_RESOURCE_REQUIREMENTS_LIST)ExAllocatePool(PagedPool, RequirementsListSize);
 836
 837         if (!RequirementsList)
 838         {
 839                 ExFreePool(Buffer.Pointer);
 840                 return STATUS_SUCCESS;
 841         }
 842         RequirementsList->ListSize = RequirementsListSize;
 843         RequirementsList->InterfaceType = Internal;
 844         RequirementsList->BusNumber = 0;
 845         RequirementsList->SlotNumber = 0; /* Not used by WDM drivers */
 846         RequirementsList->AlternativeLists = 1;
 847         RequirementsList->List[0].Version = 1;
 848         RequirementsList->List[0].Revision = 1;
 849         RequirementsList->List[0].Count = NumberOfResources;
 850         RequirementDescriptor = RequirementsList->List[0].Descriptors;
 851
 852         /* Fill resources list structure */
 853         Done = FALSE;
 854         while (!Done)
 855         {
 856                 switch (resource->Type)
 857                 {
 858                         case ACPI_RESOURCE_TYPE_IRQ:
 859                         {
 860                                 ACPI_RESOURCE_IRQ *irq_data = (ACPI_RESOURCE_IRQ*) &resource->Data;
 861                                 for (i = 0; i < irq_data->InterruptCount; i++)
 862                                 {
 863                                         RequirementDescriptor->Option = 0; /* Required */
 864                                         RequirementDescriptor->Type = CmResourceTypeInterrupt;
 865                                         RequirementDescriptor->ShareDisposition = (irq_data->Sharable == ACPI_SHARED ? CmResourceShareShared : CmResourceShareDeviceExclusive);
 866                                         RequirementDescriptor->Flags =(irq_data->Triggering == ACPI_LEVEL_SENSITIVE ? CM_RESOURCE_INTERRUPT_LEVEL_SENSITIVE : CM_RESOURCE_INTERRUPT_LATCHED);
 867                                         RequirementDescriptor->u.Interrupt.MinimumVector =  irq_data->Interrupts[i];
 868
 869                                         RequirementDescriptor++;
 870                                 }
 871                                 break;
 872                         }
 873                         case ACPI_RESOURCE_TYPE_DMA:
 874                         {
 875                                 ACPI_RESOURCE_DMA *dma_data = (ACPI_RESOURCE_DMA*) &resource->Data;
 876                                 for (i = 0; i < dma_data->ChannelCount; i++)
 877                                 {
 878                                         RequirementDescriptor->Type = CmResourceTypeDma;
 879                                         RequirementDescriptor->Flags = 0;
 880                                 switch (dma_data->Type)
 881                                 {
 882                                         case ACPI_TYPE_A: RequirementDescriptor->Flags |= CM_RESOURCE_DMA_TYPE_A; break;
 883                                         case ACPI_TYPE_B: RequirementDescriptor->Flags |= CM_RESOURCE_DMA_TYPE_B; break;
 884                                         case ACPI_TYPE_F: RequirementDescriptor->Flags |= CM_RESOURCE_DMA_TYPE_F; break;
 885                                 }
 886                                 if (dma_data->BusMaster == ACPI_BUS_MASTER)
 887                                         RequirementDescriptor->Flags |= CM_RESOURCE_DMA_BUS_MASTER;
 888                                 switch (dma_data->Transfer)
 889                                 {
 890                                         case ACPI_TRANSFER_8: RequirementDescriptor->Flags |= CM_RESOURCE_DMA_8; break;
 891                                         case ACPI_TRANSFER_16: RequirementDescriptor->Flags |= CM_RESOURCE_DMA_16; break;
 892                                         case ACPI_TRANSFER_8_16: RequirementDescriptor->Flags |= CM_RESOURCE_DMA_8_AND_16; break;
 893                                 }
 894
 895                                 RequirementDescriptor->Option = 0; /* Required */
 896                                 RequirementDescriptor->ShareDisposition = CmResourceShareDriverExclusive;
 897                                 RequirementDescriptor->u.Dma.MinimumChannel = dma_data->Channels[i];
 898                                 RequirementDescriptor++;
 899                         }
 900                         break;
 901                         }
 902                         case ACPI_RESOURCE_TYPE_IO:
 903                         {
 904                                 ACPI_RESOURCE_IO *io_data = (ACPI_RESOURCE_IO*) &resource->Data;
 905                                 RequirementDescriptor->Flags = CM_RESOURCE_PORT_IO;
 906                                 if (io_data->IoDecode == ACPI_DECODE_16)
 907                                         RequirementDescriptor->Flags |= CM_RESOURCE_PORT_16_BIT_DECODE;
 908                                 else
 909                                         RequirementDescriptor->Flags |= CM_RESOURCE_PORT_10_BIT_DECODE;
 910
 911                                 RequirementDescriptor->u.Port.Length = io_data->AddressLength;
 912
 913                                 RequirementDescriptor->Option = 0; /* Required */
 914                                 RequirementDescriptor->Type = CmResourceTypePort;
 915                                 RequirementDescriptor->ShareDisposition = CmResourceShareDriverExclusive;
 916                                 RequirementDescriptor->u.Port.Alignment = 1; /* Start address is specified, so it doesn't matter */
 917                                 RequirementDescriptor->u.Port.MinimumAddress.QuadPart = io_data->Minimum;
 918                                 RequirementDescriptor->u.Port.MaximumAddress.QuadPart = io_data->Maximum;
 919
 920                                 RequirementDescriptor++;
 921                                 break;
 922                         }
 923                         case ACPI_RESOURCE_TYPE_END_TAG:
 924                         {
 925                                 Done = TRUE;
 926                                 break;
 927                         }
 928                         default:
 929                         {
 930                                 DPRINT1("Unhandled resource type\n");
 931                                 break;
 932                         }
 933                 }
 934                 resource = ACPI_NEXT_RESOURCE(resource);
 935         }
 936         ExFreePool(Buffer.Pointer);
 937
 938     Irp->IoStatus.Information = (ULONG_PTR)RequirementsList;
 939
 940     return STATUS_SUCCESS;
 941 }
 942
 943 NTSTATUS
 944 Bus_PDO_QueryDeviceRelations(
 945      PPDO_DEVICE_DATA     DeviceData,
 946       PIRP   Irp )
 947 /*++
 948
 949 Routine Description:
 950
 951     The PnP Manager sends this IRP to gather information about
 952     devices with a relationship to the specified device.
 953     Bus drivers must handle this request for TargetDeviceRelation
 954     for their child devices (child PDOs).
 955
 956     If a driver returns relations in response to this IRP,
 957     it allocates a DEVICE_RELATIONS structure from paged
 958     memory containing a count and the appropriate number of
 959     device object pointers. The PnP Manager frees the structure
 960     when it is no longer needed. If a driver replaces a
 961     DEVICE_RELATIONS structure allocated by another driver,
 962     it must free the previous structure.
 963
 964     A driver must reference the PDO of any device that it
 965     reports in this IRP (ObReferenceObject). The PnP Manager
 966     removes the reference when appropriate.
 967
 968 Arguments:
 969
 970     DeviceData - Pointer to the PDO's device extension.
 971     Irp          - Pointer to the irp.
 972
 973 Return Value:
 974
 975     NT STATUS
 976
 977 --*/
 978 {
 979
 980     PIO_STACK_LOCATION   stack;
 981     PDEVICE_RELATIONS deviceRelations;
 982     NTSTATUS status;
 983
 984     PAGED_CODE ();
 985
 986     stack = IoGetCurrentIrpStackLocation (Irp);
 987
 988     switch (stack->Parameters.QueryDeviceRelations.Type) {
 989
 990     case TargetDeviceRelation:
 991
 992         deviceRelations = (PDEVICE_RELATIONS) Irp->IoStatus.Information;
 993         if (deviceRelations) {
 994             //
 995             // Only PDO can handle this request. Somebody above
 996             // is not playing by rule.
 997             //
 998             ASSERTMSG("Someone above is handling TargetDeviceRelation", !deviceRelations);
 999         }
1000
1001         deviceRelations = (PDEVICE_RELATIONS)
1002                 ExAllocatePoolWithTag (PagedPool,
1003                                         sizeof(DEVICE_RELATIONS),
1004                                         'IPCA');
1005         if (!deviceRelations) {
1006                 status = STATUS_INSUFFICIENT_RESOURCES;
1007                 break;
1008         }
1009
1010         //
1011         // There is only one PDO pointer in the structure
1012         // for this relation type. The PnP Manager removes
1013         // the reference to the PDO when the driver or application
1014         // un-registers for notification on the device.
1015         //
1016
1017         deviceRelations->Count = 1;
1018         deviceRelations->Objects[0] = DeviceData->Common.Self;
1019         ObReferenceObject(DeviceData->Common.Self);
1020
1021         status = STATUS_SUCCESS;
1022         Irp->IoStatus.Information = (ULONG_PTR) deviceRelations;
1023         break;
1024
1025     case BusRelations: // Not handled by PDO
1026     case EjectionRelations: // optional for PDO
1027     case RemovalRelations: // // optional for PDO
1028     default:
1029         status = Irp->IoStatus.Status;
1030     }
1031
1032     return status;
1033 }
1034
1035 NTSTATUS
1036 Bus_PDO_QueryBusInformation(
1037      PPDO_DEVICE_DATA     DeviceData,
1038       PIRP   Irp )
1039 /*++
1040
1041 Routine Description:
1042
1043     The PnP Manager uses this IRP to request the type and
1044     instance number of a device's parent bus. Bus drivers
1045     should handle this request for their child devices (PDOs).
1046
1047 Arguments:
1048
1049     DeviceData - Pointer to the PDO's device extension.
1050     Irp          - Pointer to the irp.
1051
1052 Return Value:
1053
1054     NT STATUS
1055
1056 --*/
1057 {
1058
1059     PPNP_BUS_INFORMATION busInfo;
1060
1061     PAGED_CODE ();
1062
1063     busInfo = ExAllocatePoolWithTag (PagedPool, sizeof(PNP_BUS_INFORMATION),
1064                                         'IPCA');
1065
1066     if (busInfo == NULL) {
1067       return STATUS_INSUFFICIENT_RESOURCES;
1068     }
1069
1070     busInfo->BusTypeGuid = GUID_ACPI_INTERFACE_STANDARD;
1071
1072     busInfo->LegacyBusType = InternalPowerBus;
1073
1074     busInfo->BusNumber = 0; //fixme
1075
1076     Irp->IoStatus.Information = (ULONG_PTR)busInfo;
1077
1078     return STATUS_SUCCESS;
1079 }
1080
1081
1082 NTSTATUS
1083 Bus_GetDeviceCapabilities(
1084       PDEVICE_OBJECT          DeviceObject,
1085       PDEVICE_CAPABILITIES    DeviceCapabilities
1086     )
1087 {
1088     IO_STATUS_BLOCK     ioStatus;
1089     KEVENT              pnpEvent;
1090     NTSTATUS            status;
1091     PDEVICE_OBJECT      targetObject;
1092     PIO_STACK_LOCATION  irpStack;
1093     PIRP                pnpIrp;
1094
1095     PAGED_CODE();
1096
1097     //
1098     // Initialize the capabilities that we will send down
1099     //
1100     RtlZeroMemory( DeviceCapabilities, sizeof(DEVICE_CAPABILITIES) );
1101     DeviceCapabilities->Size = sizeof(DEVICE_CAPABILITIES);
1102     DeviceCapabilities->Version = 1;
1103     DeviceCapabilities->Address = -1;
1104     DeviceCapabilities->UINumber = -1;
1105
1106     //
1107     // Initialize the event
1108     //
1109     KeInitializeEvent( &pnpEvent, NotificationEvent, FALSE );
1110
1111     targetObject = IoGetAttachedDeviceReference( DeviceObject );
1112
1113     //
1114     // Build an Irp
1115     //
1116     pnpIrp = IoBuildSynchronousFsdRequest(
1117         IRP_MJ_PNP,
1118         targetObject,
1119         NULL,
1120         0,
1121         NULL,
1122         &pnpEvent,
1123         &ioStatus
1124         );
1125     if (pnpIrp == NULL) {
1126
1127         status = STATUS_INSUFFICIENT_RESOURCES;
1128         goto GetDeviceCapabilitiesExit;
1129
1130     }
1131
1132     //
1133     // Pnp Irps all begin life as STATUS_NOT_SUPPORTED;
1134     //
1135     pnpIrp->IoStatus.Status = STATUS_NOT_SUPPORTED;
1136
1137     //
1138     // Get the top of stack
1139     //
1140     irpStack = IoGetNextIrpStackLocation( pnpIrp );
1141
1142     //
1143     // Set the top of stack
1144     //
1145     RtlZeroMemory( irpStack, sizeof(IO_STACK_LOCATION ) );
1146     irpStack->MajorFunction = IRP_MJ_PNP;
1147     irpStack->MinorFunction = IRP_MN_QUERY_CAPABILITIES;
1148     irpStack->Parameters.DeviceCapabilities.Capabilities = DeviceCapabilities;
1149
1150     //
1151     // Call the driver
1152     //
1153     status = IoCallDriver( targetObject, pnpIrp );
1154     if (status == STATUS_PENDING) {
1155
1156         //
1157         // Block until the irp comes back.
1158         // Important thing to note here is when you allocate
1159         // the memory for an event in the stack you must do a
1160         // KernelMode wait instead of UserMode to prevent
1161         // the stack from getting paged out.
1162         //
1163
1164         KeWaitForSingleObject(
1165             &pnpEvent,
1166             Executive,
1167             KernelMode,
1168             FALSE,
1169             NULL
1170             );
1171         status = ioStatus.Status;
1172
1173     }
1174
1175 GetDeviceCapabilitiesExit:
1176     //
1177     // Done with reference
1178     //
1179     ObDereferenceObject( targetObject );
1180
1181     //
1182     // Done
1183     //
1184     return status;
1185
1186 }
1187
1188