Método Device-Specific del controlador GPIO (_DSM)

Para admitir una variedad de comunicaciones específicas de clase de dispositivo entre la pila de controladores de E/S de uso general (GPIO) en Windows y el firmware de la plataforma, Microsoft define un método Device-Specific (_DSM) que se puede incluir en un controlador GPIO en el espacio de nombres ACPI.

Actualmente, este método define dos funciones:

• Índice de función 0: función de consulta estándar que se requieren todos los métodos _DSM para proporcionar.

• Índice de función 1: la función De polaridad ActiveBoth, que informa a la pila GPIO de cualquier patilla ActiveBoth en el controlador que no sean lógica asercionada baja. La pila DE GPIO supone que los patillas ActiveBoth son lógica asercionadas de baja, por lo que esta función permite que la plataforma invalide ese valor predeterminado para patillas específicas.

Definición de GUID

El GUID del controlador GPIO _DSM método se define como:

{4F248F40-D5E2-499F-834C-27758EA1CD3F}

Función 0

La función 0 de cada _DSM es una función de consulta que devuelve el conjunto de índices de función admitidos y siempre es necesaria. Para obtener la definición de function 0, vea la sección 9.14.1, "_DSM (método específico del dispositivo)", en la especificación ACPI 5.0 .

Función 1

Los parámetros de la función 1 del método de _DSM controlador GPIO se definen de la siguiente manera:

Argumentos

• Arg0: UUID para el controlador GPIO _DSM

  // GUID: {4F248F40-D5E2-499F-834C-27758EA1CD3F}

  DEFINE_GUID (GPIO_CONTROLLER _DSM_GUID,

  0x4f248f40, 0xd5e2, 0x499f, 0x83, 0x4c, 0x27, 0x75, 0x8e, 0xa1, 0xcd. 0x3f);

• Arg1: id. de revisión de

  #define GPIO_CONTROLLER _DSM_REVISION_ID 0

• Arg2: Índice de función para la polaridad aserida de ActiveBoth:

  #define GPIO_CONTROLLER_DSM_ACTIVE_BOTH_POLARITY_FUNCTION_INDEX 1

• Arg3: Paquete vacío (no usado)

Devolución

Un paquete de enteros, cada uno de los cuales es el número de patilla relativa al controlador de un pin en el controlador GPIO que es:

• Se define como una interrupción de ActiveBoth y

• Cuyo estado aserdo es no lógica baja (es decir, es lógica alta).

Por ejemplo, si un pin ActiveBoth emulado está conectado a un dispositivo pushbutton, el pin entra en el estado asertivo (nivel de entrada alto de lógica en el pin) cuando el usuario presiona el botón y permanece en estado asertivo mientras el usuario mantiene presionado el botón. Cuando el usuario suelta el botón, el estado de anclaje cambia a no asertado (nivel de entrada lógicamente bajo).

Ejemplo de código ASL

En el siguiente ejemplo de código ASL se identifica un conjunto de patillas GPIO que tienen polaridad inicial de ActiveHigh.

//
// _DSM - Device-Specific Method
//
// Arg0:    UUID       Unique function identifier
// Arg1:    Integer    Revision Level
// Arg2:    Integer    Function Index (0 = Return Supported Functions)
// Arg3:    Package    Parameters
//

Function(_DSM,{BuffObj, PkgObj, IntObj},{BuffObj, IntObj, IntObj, PkgObj})
{

    //
    // Switch based on which unique function identifier was passed in
    //

    //
    // GPIO CLX UUID
    //

    If(LEqual(Arg0,ToUUID("4F248F40-D5E2-499F-834C-27758EA1CD3F")))
    {
        switch(Arg2)
        {

            //
            // Function 0: Return supported functions, based on 
            //    revision
            //

            case(0)
            {
                // Revision 0+: Functions 0 & 1 are supported
                return (Buffer() {0x3})
            }

            //
            // Function 1: For emulated ActiveBoth controllers, 
            //    returns a package of controller-relative pin
            //    numbers. Each corresponding pin will have an
            //    initial polarity of ActiveHigh.
            //
            //    A pin number of 0xffff is ignored.
            //

            case(1)
            {     
                // Marks pins 0x28, 0x29 and 0x44 to be ActiveHigh.
                Return (Package() {0x28, 0x29, 0x44})
            }

            //
            // Unrecognized function for this revision
            //

            default
            {
                BreakPoint
            }
        }
    }
    else
    {
        //
        // If this is not one of the UUIDs we recognize, then return
        // a buffer with bit 0 set to 0 to indicate that no functions
        // are supported for this UUID.
        //

        return (Buffer() {0})
    }
}