Méthode spécifique à l'appareil du contrôleur GPIO (_DSM)

Pour prendre en charge une variété de communications spécifiques à la classe d’appareil entre la pile de pilotes d’E/S à usage général (GPIO) dans Windows et le microprogramme de 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 part du principe 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 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 d’index de fonction pris en charge et est toujours nécessaire. Pour obtenir 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 le contrôleur 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 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é)

Rendre

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

• Défini comme une interruption ActiveBoth et

• Dont l’état déclaré est pas logique faible (en d’autres termes, est logique élevée).

Par exemple, si une broche ActiveBoth émulée est connectée à un appareil pushbutton, l’épingle entre dans l’état déclaré (niveau d’entrée logique élevé au niveau pin) 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 à nonasseré (niveau d’entrée logique faible).

Exemple de code ASL

L’exemple de code ASL suivant identifie un ensemble de broches GPIO qui ont une polarité initiale d’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})
    }
}