GpIO controller Device-Specific Method (_DSM)

Article
06/15/2023

Pour prendre en charge diverses communications spécifiques à la classe des appareils entre la pile de pilotes d’E/S à usage général (GPIO) dans Windows et le microprogramme de la plateforme, Microsoft définit une méthode Device-Specific (_DSM) qui peut être incluse sous un contrôleur GPIO dans l’espace de noms ACPI.

Actuellement, cette méthode définit deux fonctions :

Index de fonction 0 : fonction de requête standard que toutes les méthodes _DSM doivent fournir.
Index de fonction 1 : fonction de polarité ActiveBoth, qui informe la pile GPIO de toutes les broches ActiveBoth sur le contrôleur qui ne sont pas déclarées logiquement faibles. La pile GPIO suppose que les broches ActiveBoth sont déclarées logiquement faibles. Cette fonction permet donc à la plateforme de remplacer cette valeur par défaut pour des broches spécifiques.

Définition de GUID

Le GUID du contrôleur GPIO _DSM méthode est défini comme suit :

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

Fonction 0

La fonction 0 de chaque _DSM est une fonction de requête qui retourne l’ensemble des index de fonction pris en charge et est toujours nécessaire. Pour la définition de la fonction 0, consultez la section 9.14.1, « _DSM (méthode spécifique à l’appareil) », dans la spécification ACPI 5.0.

Fonction 1

Les paramètres de la fonction 1 du contrôleur GPIO _DSM méthode sont définis comme suit :

Arguments

Arg0 : UUID pour les _DSM de contrôleur GPIO

// 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 révision

#define GPIO_CONTROLLER _DSM_REVISION_ID 0
Arg2 : Index de fonction pour la polarité déclarée ActiveBoth :

#define GPIO_CONTROLLER_DSM_ACTIVE_BOTH_POLARITY_FUNCTION_INDEX 1
Arg3 : Package vide (non utilisé)

Renvoie

Package d’entiers, chacun d’eux étant le numéro de broche relatif au contrôleur d’une broche sur le contrôleur GPIO qui est :

Défini comme une interruption ActiveBoth, et
Dont l’état déclaré n’est pas logiquement bas (en d’autres termes, est logiquement élevé).

Par exemple, si une broche ActiveBoth émulée est connectée à un appareil à bouton-poussoir, l’épingle passe à l’état déclaré (niveau d’entrée logique élevé au niveau de l’épingle) lorsque l’utilisateur appuie sur le bouton et reste dans l’état déclaré pendant que l’utilisateur maintient le bouton enfoncé. Lorsque l’utilisateur relâche le bouton, l’état de l’épingle passe à unasserted (niveau d’entrée faible logique).

Exemple de code ASL

L’exemple de code ASL suivant identifie un ensemble de broches GPIO dont la polarité initiale est 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})
    }
}

Partager via