GpioClx client driver: Device fails to start (yellow bang) when GPIO_CLX_ProcessAddDevicePostDeviceCreate fails due to missing ASL/ACPI entry — need driver to function for IOCTL-only operations without ACPI resources

VijayaGopika E 1 Reputation point
2026-03-05T07:21:53.29+00:00

We have developed a GPIO controller client driver using the GpioClx (GPIO Class Extension) framework. Our driver serves dual purposes:

  1. GPIO functionality — Pin read/write, interrupt management, wake support (requires ACPI/ASL resource descriptors)
  2. IOCTL functionality — Register read/write, EEPROM operations, OTP operations (does not require ACPI/ASL resources)

When the ASL/ACPI table does not include an entry for our device, GPIO_CLX_ProcessAddDevicePostDeviceCreate returns a failure status during EvtDeviceAdd. This prevents the device from starting successfully, resulting in a yellow bang (Code 10 / device cannot start) in Device Manager.

Tried the below for resolving

  1. We bypassed the failure from GPIO_CLX_ProcessAddDevicePostDeviceCreate by returning STATUS_SUCCESS from EvtDeviceAdd despite the error.
  2. However, even after bypassing, GpioClx does not invoke CLIENT_QueryControllerBasicInformation or CLIENT_StartController callbacks. The device still fails to start with a yellow bang because GpioClx's internal PnP/power state machine is not fully initialized.

Our requirement is
When ASL is present: Full GPIO + IOCTL functionality (GpioClx manages GPIO, IOCTLs work via CLIENT_ControllerSpecificFunction.

When ASL is absent: IOCTL-only functionality via CLIENT_ControllerSpecificFunction. The device should start successfully without GPIO capabilities, allowing user-mode applications to communicate with the driver via a device interface (DeviceIoControl) for register access operations.

Is there a supported mechanism within the GpioClx framework to allow a client driver's device to start successfully even when GPIO_CLX_ProcessAddDevicePostDeviceCreate fails due to missing ACPI resources? Specifically:

Can GpioClx be configured to allow partial initialization where GPIO functionality is disabled but the device node still starts successfully?

Are there any known patterns or best practices for GpioClx client drivers that need to support IOCTL operations independently of ACPI-described GPIO resources?

Windows for home | Other | Devices and drivers
0 comments

1 answer

Sort by: Most helpful
Most helpful Newest Oldest

  1. AI answer

    2026-03-05T07:22:18.15+00:00

    Within the documented GpioClx model, there is no supported mechanism to partially initialize GpioClx and still have a fully started device node when the GpioClx initialization path fails due to missing ACPI/ASL resources.

    Key points from the GpioClx design:

    1. GpioClx is tightly coupled to ACPI-enumerated GPIO controllers and resources
      • GPIO controllers and the peripherals that connect to them are enumerated by ACPI, and the relationship between controllers and peripherals is described using GPIO Connection Resource Descriptors in the firmware namespace (_CRS, GpioInt/GpioIo, etc.).
      • The GPIO controller device’s ACPI namespace (_HID, _CRS, optional _UID) defines the controller’s resources and the bank/interrupt mapping. GpioClx relies on this ACPI description to know what hardware resources exist and how to manage them.
      • The GpioClx DDI is defined for a GPIO controller driver that cooperates with GpioClx to handle I/O and interrupts for GPIO pins that are configured as data inputs/outputs or interrupt inputs. This model assumes a properly described ACPI controller device.
    2. Device object initialization with GpioClx is all-or-nothing
      • The documented initialization sequence requires the GPIO controller driver to call:
        • GPIO_CLX_ProcessAddDevicePreDeviceCreate before WdfDeviceCreate, and
        • GPIO_CLX_ProcessAddDevicePostDeviceCreate after WdfDeviceCreate.
      • These calls are part of bringing the controller under GpioClx management. If GPIO_CLX_ProcessAddDevicePostDeviceCreate fails (for example, because required ACPI resources are not present), the GpioClx state machine is not initialized, and GpioClx will not call the client callbacks such as CLIENT_QueryControllerBasicInformation or CLIENT_StartController.
      • Bypassing the failure in EvtDeviceAdd does not change this: the GpioClx extension has already failed its own initialization and will not operate in a “partial” mode.
    3. GpioClx is not designed as a generic IOCTL transport independent of ACPI GPIO resources
      • The documented purpose of GpioClx is to manage GPIO pins and interrupts for ACPI-described GPIO controllers and to provide a uniform GPIO I/O interface to peripheral drivers.
      • The framework does not expose a supported mode where the controller driver can use GpioClx only for CLIENT_ControllerSpecificFunction/IOCTL handling while ignoring missing ACPI GPIO resources. The controller-specific IOCTL path is an extension on top of a fully initialized GpioClx controller, not an independent mode.
    4. Implication for the described requirement
      Based on the documented model:
      • If ACPI/ASL for the GPIO controller is present and correct: use GpioClx normally for GPIO + interrupts + wake, and expose controller-specific IOCTLs via CLIENT_ControllerSpecificFunction.
      • If ACPI/ASL for the controller is absent or incomplete: GpioClx initialization is not supported to succeed in a “GPIO-disabled but IOCTL-only” mode. The framework expects a valid ACPI-described controller; otherwise, the GpioClx-based device will not fully start.
      To support IOCTL-only functionality when ACPI resources are missing, the supported pattern is to implement a separate KMDF/WDM driver path that does not use GpioClx for that scenario (for example, a different device/stack or a different driver that exposes a device interface and handles IOCTLs directly). The GpioClx-based controller driver is intended only for the ACPI-enumerated GPIO controller case.

    There are no documented patterns or best practices in the provided material that describe a partial or degraded GpioClx initialization mode where the device node starts successfully without ACPI-described GPIO resources while still using GpioClx for IOCTL-only operations.

    References:

    AI-generated content may be incorrect. Read our transparency notes for more information.

    Was this answer helpful?

Your answer

Answers can be marked as 'Accepted' by the question author and 'Recommended' by moderators, which helps users know the answer solved the author's problem.