Jump to content

[Mini-Guida] SSDT


ErmaC
 Share

18 posts in this topic

Recommended Posts

Premessa: Non è l'invenzione del secolo

 

1) Domanda: Aumentano le prestazioni del sistema?

1) Risposta: Assolutamente no.

 

2) Domanda: Che vantaggi potrei trarre da queste SSDT?

2) Risposta: Come sopra, nessun vantaggio prestazionale, ma "agevola" la vita agli "smanettoni" di tabelle ACPI e facilita lo scambio nel caso esse siano ad esempio "iniezioni" di dispositivi simili (LAN, schede video, Contoller Audio ecc. ecc.)

 

3) Domanda: Come si usano?

3) Risposta: Le SSDT come il DSDT vengono preparate in "formato" .dsl vanno editate a seconda dei propri usi, verranno compilate allo stesso modo di come viene compilato il DSDT e verranno (se avete più di una tabella SSDT) rinominate in;

SSDT.aml SSDT-1.aml SSDT-2.aml ecc. ecc. fino a SSDT-29.aml

 

4) Domanda: Ho delle tabelle SSDT (GFX/AUDIO/ecc..) posso contribuire?

4) Risposta: Certamente, postale qui in formato .TXT e cercherò di includerle e catalogarle in questo primo post.

 

5) Domanda: Dove vanno messele tabelle SSDT?

5) Risposta: Le tabelle SSDT vanno messe nella stessa posizione ove è situato il DSDT.

 

Requisiti:

- Un bootloader che supporti il caricamento in fase di avvio delle SSDT opzionali.

Esempio Chameleon 2 RC5 ultime revisioni.

Iniziamo.

Ero da tempo alla ricerca della possibilità di poter caricare durante l'avvio tabelle aggiuntive oltre al classico DSDT,

che come conosciamo (e ODIAMO) tutti in molti casi deve essere istruito a dovere per darci le dovute soddisfazioni.

 

Non sarebbe piacevole avere un DSDT minimamente ritoccato (senza iniezioni varie), e poter agire su piccole parti di codice invece di migliaia, per le nostre prove o i vari settaggi?

 

Bene con le SSDT questo si puo' fare.

----------------------------------

RACCOLTA

 

Metodo DTGP (su modulo esterno) *new

 

Metodo DTGP >> DTGP.TXT

 

*Piccola nota se usate questa tabella ed avete ancora dei "richiami" nel DSDT vi basterà aggiungere External (DTGP, MethodObj) in testa al codice del DSDT :censored2:

 

AUDIO

    -----------------------------


  • AD2000B >> AD2000B.TXT*sudo perl -pi -e 's|\x8b\x19\xd4\x11|\x9b\x98\xd4\x11|g' /System/Library/Extensions/AppleHDA.kext/Contents/MacOS/AppleHDA

    -----------------------------


  • AD1988B >> AD1988B.txt

    -----------------------------


  • ALC883 >> ALC883.txt*sudo perl -pi -e 's|\x85\x08\xec\x10|\x83\x08\xec\x10|g' /System/Library/Extensions/AppleHDA.kext/Contents/MacOS/AppleHDA

    -----------------------------


  • ALC888 >> ALC888.txt
  • ALC1200 >> ALC1200.TXT*sudo perl -pi -e 's|\x85\x08\xec\x10|\x88\x08\xec\x10|g' /System/Library/Extensions/AppleHDA.kext/Contents/MacOS/AppleHDA

    -----------------------------


  • ALC889 >> ALC889.txt

    -----------------------------


  • ALC889A >> ALC889A.TXT

    -----------------------------


  • ALC662 >> ALC662.txt*sudo perl -pi -e 's|\x85\x08\xec\x10|\x62\x06\xec\x10|g' /System/Library/Extensions/AppleHDA.kext/Contents/MacOS/AppleHDA

    -----------------------------


  • Via VT1708S (mrmojorisin17) >> VT1708S.txt

    -----------------------------


SATA

SBUS

LPCB

USB

LAN

Shede Grafiche

-----------------------------

-----------------------------

 

----------------------------------

Come funzionano???

 

Il funzionamento è identico sia in struttura che in sintassi al codice del DSDT.

Con la differenza che i Device vengono chiamati e considerati come oggetti esterni allo stesso modulo.

 

External (DTGP, MethodObj)

External (\_SB_.PCI0.XXX, DeviceObj)

Scope (\_SB.PCI0.XXX)

Name (_ADR, 0xXXXXXXXX)

Le XXX avranno valori differenti in ogni caso

 

----------------------------------

Esempio 1: SSDT AUDIO (AD2000b)

[size=1]DefinitionBlock ("SSDT.aml", "SSDT", 1, "APPLE", "HDEF", 0x00001000)
{
   [color="#0000FF"]External (DTGP, MethodObj)[/color]
   [color="#2E8B57"]External (\_SB_.PCI0, DeviceObj)[/color]

   [color="#800080"]Scope (\_SB.PCI0)[/color]
   {
       Device (HDEF)
       {
           [color="#FF0000"]Name (_ADR, 0x001B0000)[/color]
               OperationRegion (HDCS, PCI_Config, 0x54, 0x04)
               Field (HDCS, DWordAcc, NoLock, Preserve)
               {
                       ,   15, 
                   PMES,   1
               }

               Name (_PRW, Package (0x02)
               {
                   0x0D, 
                   0x03
               })
           Method (_DSM, 4, NotSerialized)
           {
               Store (Package (0x10)
                   {
                       "subsystem-id", Buffer (0x04) { 0xA0, 0x00, 0x00, 0x00 },
                       "subsystem-vendor-id", Buffer (0x04) { 0x6B, 0x10, 0x00, 0x00 },
                       "codec-id", Buffer (0x04) { 0x9B, 0x98, 0xD4, 0x11 },
                       "layout-id", Buffer (0x04) { 0x0C, 0x00, 0x00, 0x00 },
                       "device-type", Buffer (0x17) { "Analog Devices AD2000B" },
                       "model", Buffer (0x08) { "AD2000B" },
                       "built-in", Buffer (One) { 0x00 },
                       "PinConfigurations", Buffer (Zero) {}
                   }, Local0)
               DTGP (Arg0, Arg1, Arg2, Arg3, RefOf (Local0))
               Return (Local0)
           }
       }
   }
}[/size]

External (DTGP, MethodObj)

External (\_SB_.PCI0, DeviceObj)

Scope (\_SB.PCI0)

Name (_ADR, 0x0x001B0000)

 

Dall'esempio sopra vediamo che la parte di codice in BLU si riferisce al "richiamo" del già conosciuto e vecchio amico method DTGP, il richiamo al method 'e neccessario, dal momento che dobbiamo iniettare dei dati.

La parte di codice in VERDE si riferisce ad un "oggetto" esterno che viene richiamato nella tabella SSDT e VIOLA si riferisce alla "posizione" logica all'interno del DSDT principale dove il dispositivo che vogliamo montare/iniettare deve essere ubicato.

L'ADDRESS in ROSSO sarà in questo caso necessario in quanto parte che indirizza il dispositivo logico.(La stragrande maggioranza di voi sa che HDEF/AZAL si trova al 0x001B0000).

 

----------------------------------

ESEMPIO 2: SSDT SATA INTERNAL ESB2

[size=1]DefinitionBlock ("SSDT.aml", "SSDT", 1, "SataRe", "SataPri", 0x00001000)
{
   [color="#0000FF"]External (DTGP, MethodObj)[/color]
   [color="#2E8B57"]External (\_SB_.PCI0.SATA, DeviceObj)[/color]

   [color="#800080"]Scope (\_SB.PCI0.SATA)[/color]
   {
       Method (_DSM, 4, NotSerialized)
       {
           Store (Package (0x02)
               {
                   "device-id", 
                   Buffer (0x04)
                   {
                       0x81, 0x26, 0x86, 0x80
                   }
               }, Local0)
           DTGP (Arg0, Arg1, Arg2, Arg3, RefOf (Local0))
           Return (Local0)
       }

       Device (PRT0)
       {
           Name (_ADR, Zero)
           Method (_DSM, 4, NotSerialized)
           {
               Store (Package (0x02)
                   {
                       "io-device-location", 
                       Buffer (0x06)
                       {
                           "Bay 1"
                       }
                   }, Local0)
               DTGP (Arg0, Arg1, Arg2, Arg3, RefOf (Local0))
               Return (Local0)
           }
       }

       Device (PRT1)
       {
           Name (_ADR, One)
           Method (_DSM, 4, NotSerialized)
           {
               Store (Package (0x02)
                   {
                       "io-device-location", 
                       Buffer (0x06)
                       {
                           "Bay 2"
                       }
                   }, Local0)
               DTGP (Arg0, Arg1, Arg2, Arg3, RefOf (Local0))
               Return (Local0)
           }
       }

       Device (PRT2)
       {
           Name (_ADR, 0x02)
           Method (_DSM, 4, NotSerialized)
           {
               Store (Package (0x02)
                   {
                       "io-device-location", 
                       Buffer (0x06)
                       {
                           "Bay 3"
                       }
                   }, Local0)
               DTGP (Arg0, Arg1, Arg2, Arg3, RefOf (Local0))
               Return (Local0)
           }
       }

       Device (PRT3)
       {
           Name (_ADR, 0x03)
           Method (_DSM, 4, NotSerialized)
           {
               Store (Package (0x02)
                   {
                       "io-device-location", 
                       Buffer (0x06)
                       {
                           "Bay 4"
                       }
                   }, Local0)
               DTGP (Arg0, Arg1, Arg2, Arg3, RefOf (Local0))
               Return (Local0)
           }
       }

       Device (PRT4)
       {
           Name (_ADR, 0x04)
           Method (_DSM, 4, NotSerialized)
           {
               Store (Package (0x02)
                   {
                       "io-device-location", 
                       Buffer (0x06)
                       {
                           "Bay 5"
                       }
                   }, Local0)
               DTGP (Arg0, Arg1, Arg2, Arg3, RefOf (Local0))
               Return (Local0)
           }
       }

       Device (PRT5)
       {
           Name (_ADR, 0x05)
           Method (_DSM, 4, NotSerialized)
           {
               Store (Package (0x02)
                   {
                       "io-device-location", 
                       Buffer (0x06)
                       {
                           "Bay 6"
                       }
                   }, Local0)
               DTGP (Arg0, Arg1, Arg2, Arg3, RefOf (Local0))
               Return (Local0)
           }
       }
   }
}
[/size]

All'interno del nostro DSDT nella sua posizione (SATA) avremo semplicemente:

...codice...
		Device (SATA)
		{
			Name (_ADR, 0x001F0002)
		}
...codice...

 

da notare nella SSDT del SATA il codice in colore VERDE questa volta fa riferimento al dispositivo SATA già presente nel DSDT e non "creato" come nel precedente esempio (HDEF).

 

----------------------------------

 

ESEMPIO 3: SSDT USB

Simile come struttura alla SSDT del SATA ESB2.

[size=1]DefinitionBlock ("SSDT.aml", "SSDT", 1, "UHCI", "UHCIPri", 0x00001000)
{
   [color="#0000FF"]External (DTGP, MethodObj)[/color]
[color="#2E8B57"]    External (\_SB_.PCI0.UHC1, DeviceObj)
   External (\_SB_.PCI0.UHC2, DeviceObj)
   External (\_SB_.PCI0.UHC3, DeviceObj)
   External (\_SB_.PCI0.UHC4, DeviceObj)
   External (\_SB_.PCI0.UHC5, DeviceObj)
   External (\_SB_.PCI0.UHC6, DeviceObj)
   External (\_SB_.PCI0.EHC1, DeviceObj)
   External (\_SB_.PCI0.EHC2, DeviceObj[/color])

   [color="#800080"]Scope (\_SB.PCI0.UHC1)[/color]
   {
               OperationRegion (U1CS, PCI_Config, 0xC4, 0x04)
               Field (U1CS, DWordAcc, NoLock, Preserve)
               {
                   U1EN,   2
               }

               Name (_PRW, Package (0x02)
               {
                   0x03, 
                   0x03
               })
               Method (_PSW, 1, NotSerialized)
               {
                   If (Arg0)
                   {
                       Store (0x03, U1EN)
                   }
                   Else
                   {
                       Store (Zero, U1EN)
                   }
               }
               Method (_DSM, 4, NotSerialized)
               {
                   Store (Package (0x02)
                       {
                           "device-id", 
                           Buffer (0x04)
                           {
                               0x34, 0x3A, 0x00, 0x00
                           }
                       }, Local0)
                   DTGP (Arg0, Arg1, Arg2, Arg3, RefOf (Local0))
                   Return (Local0)
               }
   }

   [color="#800080"]Scope (\_SB.PCI0.UHC2)[/color]
   {
               OperationRegion (U2CS, PCI_Config, 0xC4, 0x04)
               Field (U2CS, DWordAcc, NoLock, Preserve)
               {
                   U2EN,   2
               }

               Name (_PRW, Package (0x02)
               {
                   0x04, 
                   0x03
               })
               Method (_PSW, 1, NotSerialized)
               {
                   If (Arg0)
                   {
                       Store (0x03, U2EN)
                   }
                   Else
                   {
                       Store (Zero, U2EN)
                   }
               }   
               Method (_DSM, 4, NotSerialized)
               {
                   Store (Package (0x02)
                       {
                           "device-id", 
                           Buffer (0x04)
                           {
                               0x35, 0x3A, 0x00, 0x00
                           }
                       }, Local0)
                   DTGP (Arg0, Arg1, Arg2, Arg3, RefOf (Local0))
                   Return (Local0)
               }
   }

   [color="#800080"]Scope (\_SB.PCI0.UHC3)[/color]
   {
               OperationRegion (U2CS, PCI_Config, 0xC4, 0x04)
               Field (U2CS, DWordAcc, NoLock, Preserve)
               {
                   U3EN,   2
               }

               Name (_PRW, Package (0x02)
               {
                   0x0C, 
                   0x03
               })
               Method (_PSW, 1, NotSerialized)
               {
                   If (Arg0)
                   {
                       Store (0x03, U3EN)
                   }
                   Else
                   {
                       Store (Zero, U3EN)
                   }
               }
               Method (_DSM, 4, NotSerialized)
               {
                   Store (Package (0x02)
                       {
                           "device-id", 
                           Buffer (0x04)
                           {
                               0x36, 0x3A, 0x00, 0x00
                           }
                       }, Local0)
                   DTGP (Arg0, Arg1, Arg2, Arg3, RefOf (Local0))
                   Return (Local0)
               }
   }

   [color="#800080"]Scope (\_SB.PCI0.UHC4)[/color]
   {
               OperationRegion (U4CS, PCI_Config, 0xC4, 0x04)
               Field (U4CS, DWordAcc, NoLock, Preserve)
               {
                   U4EN,   2
               }

               Name (_PRW, Package (0x02)
               {
                   0x0E, 
                   0x03
               })
               Method (_PSW, 1, NotSerialized)
               {
                   If (Arg0)
                   {
                       Store (0x03, U4EN)
                   }
                   Else
                   {
                       Store (Zero, U4EN)
                   }
               }
               Method (_DSM, 4, NotSerialized)
               {
                   Store (Package (0x02)
                       {
                           "device-id", 
                           Buffer (0x04)
                           {
                               0x37, 0x3A, 0x00, 0x00
                           }
                       }, Local0)
                   DTGP (Arg0, Arg1, Arg2, Arg3, RefOf (Local0))
                   Return (Local0)
               }
   }

   [color="#800080"]Scope (\_SB.PCI0.UHC5)[/color]
   {
               OperationRegion (U5CS, PCI_Config, 0xC4, 0x04)
               Field (U5CS, DWordAcc, NoLock, Preserve)
               {
                   U5EN,   2
               }

               Name (_PRW, Package (0x02)
               {
                   0x05, 
                   0x03
               })
               Method (_PSW, 1, NotSerialized)
               {
                   If (Arg0)
                   {
                       Store (0x03, U5EN)
                   }
                   Else
                   {
                       Store (Zero, U5EN)
                   }
               }
               Method (_DSM, 4, NotSerialized)
               {
                   Store (Package (0x02)
                       {
                           "device-id", 
                           Buffer (0x04)
                           {
                               0x38, 0x3A, 0x00, 0x00
                           }
                       }, Local0)
                   DTGP (Arg0, Arg1, Arg2, Arg3, RefOf (Local0))
                   Return (Local0)
               }
   }

   [color="#800080"]Scope (\_SB.PCI0.UHC6)[/color]
   {
               OperationRegion (U6CS, PCI_Config, 0xC4, 0x04)
               Field (U6CS, DWordAcc, NoLock, Preserve)
               {
                   U6EN,   2
               }

               Name (_PRW, Package (0x02)
               {
                   0x20, 
                   0x03
               })
               Method (_PSW, 1, NotSerialized)
               {
                   If (Arg0)
                   {
                       Store (0x03, U6EN)
                   }
                   Else
                   {
                       Store (Zero, U6EN)
                   }
               }
               Method (_DSM, 4, NotSerialized)
               {
                   Store (Package (0x02)
                       {
                           "device-id", 
                           Buffer (0x04)
                           {
                               0x39, 0x3A, 0x00, 0x00
                           }
                       }, Local0)
                   DTGP (Arg0, Arg1, Arg2, Arg3, RefOf (Local0))
                   Return (Local0)
               }
   }

   [color="#800080"]Scope (\_SB.PCI0.EHC1)[/color]
   {
               OperationRegion (U7CS, PCI_Config, 0x54, 0x02)
               Field (U7CS, WordAcc, NoLock, Preserve)
               {
                       ,   15, 
                   PMES,   1
               }

               Name (_PRW, Package (0x02)
               {
                   0x0D, 
                   0x03
               })
               OperationRegion (USBR, PCI_Config, 0x62, 0x02)
               Field (USBR, AnyAcc, NoLock, Preserve)
               {
                   URE2,   9
               }

               Method (_PSW, 1, NotSerialized)
               {
                   If (LEqual (Arg0, Zero))
                   {
                       Store (Zero, URE2)
                   }

                   If (LEqual (Arg0, One))
                   {
                       Store (0x01FF, URE2)
                   }
               }

               Method (_DSM, 4, NotSerialized)
               {
                   Store (Package (0x0C)
                       {
                           "AAPL,current-available", 
                           0x05DC, 
                           "AAPL,current-extra", 
                           0x04B0, 
                           "AAPL,current-in-sleep", 
                           0x09C4, 
                           "device-id", 
                           Buffer (0x04)
                           {
                               0x3A, 0x3A, 0x00, 0x00
                           }, 

                           "AAPL,clock-id", 
                           Buffer (One)
                           {
                               0x01
                           }, 

                           "device_type", 
                           Buffer (0x05)
                           {
                               "EHCI"
                           }
                       }, Local0)
                   DTGP (Arg0, Arg1, Arg2, Arg3, RefOf (Local0))
                   Return (Local0)
               }
   }

  [color="#800080"] Scope (\_SB.PCI0.EHC2)[/color]
   {
               OperationRegion (U7CS, PCI_Config, 0x54, 0x02)
               Field (U7CS, WordAcc, NoLock, Preserve)
               {
                       ,   15, 
                   PMES,   1
               }

               Name (_PRW, Package (0x02)
               {
                   0x0D, 
                   0x03
               })
               OperationRegion (USBR, PCI_Config, 0x62, 0x02)
               Field (USBR, AnyAcc, NoLock, Preserve)
               {
                   URE2,   9
               }

               Method (_PSW, 1, NotSerialized)
               {
                   If (LEqual (Arg0, Zero))
                   {
                       Store (Zero, URE2)
                   }

                   If (LEqual (Arg0, One))
                   {
                       Store (0x01FF, URE2)
                   }
               }

               Method (_DSM, 4, NotSerialized)
               {
                   Store (Package (0x0C)
                       {
                           "AAPL,current-available", 
                           0x05DC, 
                           "AAPL,current-extra", 
                           0x04B0, 
                           "AAPL,current-in-sleep", 
                           0x09C4, 
                           "device-id", 
                           Buffer (0x04)
                           {
                               0x3C, 0x3A, 0x00, 0x00
                           }, 

                           "AAPL,clock-id", 
                           Buffer (One)
                           {
                               0x02
                           }, 

                           "device_type", 
                           Buffer (0x05)
                           {
                               "EHCI"
                           }
                       }, Local0)
                   DTGP (Arg0, Arg1, Arg2, Arg3, RefOf (Local0))
                   Return (Local0)
               }
   }

}
[/size]

e all'interno del mio DSDT avrò solamente

[size=1]...codice...

           Device (UHC1)
           {
               Name (_ADR, 0x001D0000)
           }

           Device (UHC2)
           {
               Name (_ADR, 0x001D0001)
           }

           Device (UHC3)
           {
               Name (_ADR, 0x001D0002)
           }

           Device (EHC1)
           {
               Name (_ADR, 0x001D0007)
           }

           Device (UHC4)
           {
               Name (_ADR, 0x001A0000)
           }

           Device (UHC5)
           {
               Name (_ADR, 0x001A0001)
           }

           Device (UHC6)
           {
               Name (_ADR, 0x001A0002)
           }

           Device (EHC2)
           {
               Name (_ADR, 0x001A0007)
           }

...codice...[/size]

----------------------------------

ESEMPIO 4: SSDT GFX (QuadroFX5600 su address 0x00030000)

[size=1]DefinitionBlock ("SSDT.aml", "SSDT", 1, "GFX03", "Graphics03", 0x00001000)
{
   [color="#0000FF"]External (DTGP, MethodObj) [/color]
   [color="#2E8B57"]External (\_SB_.PCI0.PEG3.GFX3, DeviceObj)[/color]
   [color="#800080"]Scope (\_SB.PCI0.PEG3.GFX3[/color])
   {
       Method (_DSM, 4, NotSerialized)
           {
               Store (Package (0x1C)
                   {
                   "AAPL,slot-name", Buffer (0x0A) { "PCI-E 16x" },
                   "@0,compatible", Buffer (0x0B) { "NVDA,NVMac" }, 
                   "@0,device_type", Buffer (0x08) { "display" }, 
                   "@0,name", Buffer (0x0F) { "NVDA,Display-A" }, 
                   "@1,compatible", Buffer (0x0B) { "NVDA,NVMac" }, 
                   "@1,device_type", Buffer (0x08) { "display" }, 
                   "@1,name", Buffer (0x0F) { "NVDA,Display-B" }, 
                   "NVCAP", Buffer (0x18) { 0x04, 0x00,[b][i] ...codice... ...codice...[/i][/b], 0x00, 0x00 },
                   "NVPM", Buffer (0x1C) {
                        /* 0000 */    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
                        /* 0008 */    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
                        /* 0010 */    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
                        /* 0018 */    0x00, 0x00, 0x00, 0x00 },
                   "VRAM,totalsize", Buffer (0x04) { 0x00, 0x00, 0x00, 0x60 }, 
                   "device_type", Buffer (0x0C) { "NVDA,Parent" }, 
                   "model", Buffer (0x1C) { "Nvidia Quadro FX 5600 [G80]" }, 
                   "rom-revision", Buffer (0x0F) { "60.80.24.00.00" },
                   "reg",
                   Buffer (0x78) { 0x00, [i][b]...codice... ...codice...[/b][/i], 0x02, 0x00  }
               }, Local0)
           DTGP (Arg0, Arg1, Arg2, Arg3, RefOf (Local0))
           Return (Local0)
       }
   }
}[/size]

e nel DSDT

[size=1]...codice...
           Device (PEG3) [color="#FF0000"]// Questo dispositivo l'ho rinominato in precedenza era P0P3[/color]
           {
               Name (_ADR, 0x00030000)
               Device (GFX3)  [color="#F4A460"]// Questo dispositivo l'ho creato non esisteva prima[/color]
               {
                   Name (_ADR, 0x02000000) [color="#FF0000"]// questo sub address l'ho ricavato con LsPCI ed è della mia motherboard[/color]
               }  [color="#FF0000"]// Fine dispositivo creato[/color]

               Method (_PRW, 0, NotSerialized)
               {
                   Return (GPRW (0x09, 0x04))
               }

               Method (_PRT, 0, NotSerialized)
               {
                   If (PICM)
                   {
                       Return (AR13)
                   }

                   Return (PR13)
               }
           }
...codice...[/size]

----------------------------------

ESEMPIO 5: SSDT SMBUS

[size=1]DefinitionBlock ("SSDT.aml", "SSDT", 1, "APPLE", "SBUS", 0x00001000)
{
   [color="#0000FF"]External (DTGP, MethodObj)[/color]
   [color="#2E8B57"]External (\_SB_.PCI0, DeviceObj)[/color]

   [color="#800080"]Scope (\_SB.PCI0)[/color]
   {
       Device (SBUS)
       {
           [color="#FF0000"]Name (_ADR, 0x001F0003)[/color]
           Device (BUS0)
           {
               Name (_CID, "smbus")
               Name (_ADR, Zero)
               Device (DVL0)
               {
                   Name (_ADR, 0x57)
                   Name (_CID, "diagsvault")
                   Method (_DSM, 4, NotSerialized)
                   {
                       Store (Package (0x03)
                           {
                               "address", 
                               0x57, 
                               Buffer (One)
                               {
                                   0x00
                               }
                           }, Local0)
                       DTGP (Arg0, Arg1, Arg2, Arg3, RefOf (Local0))
                       Return (Local0)
                   }
               }
           }
       }
   }
}[/size]

----------------------------------

continua...

 

Fabio

Link to comment
Share on other sites

Ciao Fabio :)

Ho una domanda ...dopo cancello il post :)

Supponiamo che io lasci inalterato il Device SATA orginale del mio DSDT e che aggiunga una SSDT con il Device SATA patchato, al boot verrà caricato quello presente nel DSDT o nell' SSDT?

 

I dati gli verranno addizionati come fosse una Stringa EFI...

Considera gli effetti collaterali... Se nel DSDT gli inietti una cosa e nella SSDT (sempre stesso Device) altra il tutto va in palla...

 

 

ad ESEMPIO una semplice iniezione senza interferire troppo con il codice del DSDT sarebbe questa

[size=1]DefinitionBlock ("SSDT.aml", "SSDT", 1, "SataRe", "SataPri", 0x00001000)
{
   External (DTGP, MethodObj)
   External (\_SB_.PCI0.SATA, DeviceObj)

   Scope (\_SB.PCI0.SATA)
   {
       Method (_DSM, 4, NotSerialized)
       {
           Store (Package (0x02)
               {
                   "device-id", 
                   Buffer (0x04)
                   {
                       0x81, 0x26, 0x86, 0x80
                   }
               }, Local0)
           DTGP (Arg0, Arg1, Arg2, Arg3, RefOf (Local0))
           Return (Local0)
       }
   }
}[/size]

A differenza dell'esempio in prima pagina qui gli inietti l'ID (ESB2) e nulla di più :unsure:

Il primo esempio invece rinomina i sub-device e aggiunge informazioni "estetiche".

 

 

Fabio

Link to comment
Share on other sites

Io credo che la possibilità di attivare un controllo all'interno del Chameleon che in presenza di SSDT con ripetizioni di medesime tabelle salti quelle del DSDT possa tornare utile.

Immagina un noob che non sa proprio metere le mani nel dsdt, potrebbe semplicemtne aggiungere delle ssdt preconfezionate in Extra senza estrarre nemmeno il dsdt dal bios.

 

Mio parere è quello di aver un minimo di conoscenza su quello che si fa...

Dopotutto questo "metodo" è una alternativa al modding delle ACPI e non è una PRIORITÀ

 

Fabio

Link to comment
Share on other sites

  • 3 weeks later...

E con oggi sono 2...

 

Ho aggiunto una chicca che mi frullava da un paio di settimane nella testa...

 

Ho estratto il metodo DTGP su tabella esterna SSDT ;)

 

Fabio

Link to comment
Share on other sites

  • 2 weeks later...

Ciao iReset volevo chiedere se puoi darmi una mano mi spiego vorrei inserire una SSDT per la video 240 GT quello lo già preparato, nella spiegazione nel dsdt:

 

...codice...
           Device (PEG3) // Questo dispositivo l'ho rinominato in precedenza era P0P3
           {
               Name (_ADR, 0x00030000)
               Device (GFX3)  // Questo dispositivo l'ho creato non esisteva prima
               {
                   Name (_ADR, 0x02000000) // [color="#FF0000"]questo sub address l'ho ricavato con LsPCI ed è della mia motherboard[/color]
               }  // Fine dispositivo creato

               Method (_PRW, 0, NotSerialized)
               {
                   Return (GPRW (0x09, 0x04))
               }

               Method (_PRT, 0, NotSerialized)
               {
                   If (PICM)
                   {
                       Return (AR13)
                   }

                   Return (PR13)
               }
           }

 

La parte che ti ho evidenziato non so crearlo puoi aiutarmi grazie

Link to comment
Share on other sites

Ciao iReset volevo chiedere se puoi darmi una mano mi spiego vorrei inserire una SSDT per la video 240 GT quello lo già preparato, nella spiegazione nel dsdt:

 

...codice...
           Device (PEG3) // Questo dispositivo l'ho rinominato in precedenza era P0P3
           {
               Name (_ADR, 0x00030000)
               Device (GFX3)  // Questo dispositivo l'ho creato non esisteva prima
               {
                   Name (_ADR, 0x02000000) // [color="#FF0000"]questo sub address l'ho ricavato con LsPCI ed è della mia motherboard[/color]
               }  // Fine dispositivo creato

               Method (_PRW, 0, NotSerialized)
               {
                   Return (GPRW (0x09, 0x04))
               }

               Method (_PRT, 0, NotSerialized)
               {
                   If (PICM)
                   {
                       Return (AR13)
                   }

                   Return (PR13)
               }
           }

 

La parte che ti ho evidenziato non so crearlo puoi aiutarmi grazie

 

Ti spiego come farlo... ma non vorrei farlo io.

Ti serve:

1) il tuo IOREG vedi FAQ

2) Informazioni hardware sul tuo sistema (LsPCI) vedi FAQ

 

Dal "dump" LsPCI vedi a che indirizzo sono associati i vari Device e Sub Device, sono 8 caratteri da convertire.

Intanto posta i 2 file richiesti (LsPCI puoi anche metterlo dentro il boxcode del messaggio).

Dall'IOREG vedi dove il sistema vede posizionati i device in base al NOME (Esempio P0P2@ecc.ecc o RP02@ecc.ecc)

 

La combinazione delle due informazioni ti permette di fare "quasi" tutto sul DSDT e/o SSDT.

 

Fabio

Link to comment
Share on other sites

Partiamo dal tuo DSDT:

 

...
           }

           Device (P0P2) //[b] In questo dispositivo si trova la tua scheda grafica[/b]
[size=1]// Queste info sono del tuo dump LsPCI
// [color="#FF0000"]00:01.0[/color] PCI bridge [0604]: Intel Corporation 4 Series Chipset PCI Express Root Port [8086:2e21] (rev 03)
// Notare la corrispondenza in ROSSO di 00:01:00 e 0x00010000 sono due modi "equivalenti"[/size]
           {
               Name (_ADR, [color="#FF0000"]0x00010000[/color]) // dal tuo IOREG vedrai P0P02@1
               Alias (AR01, _PRT)
               Alias (PW94, _PRW)
           }

           Device (P0P3)
...

 

SSDT.jpg

 

ora dal tuo "dump" LsPCI

Slot P0P2 00:01.0 PCI bridge [0604]: Intel Corporation 4 Series Chipset PCI Express Root Port [8086:2e21] (rev 03)

Scheda Video 01:00.0 VGA compatible controller [0300]: nVidia Corporation Unknown device [10de:0ca3] (rev a2)

Audio Scheda Video 01:00.1 Audio device [0403]: nVidia Corporation Unknown device [10de:0be4] (rev a1)

 

Quello che devi aggiungere... creare nel DSDT

...
           }

           Device (P0P2)
           {
               Name (_ADR, 0x00010000)
               Device (GFX0)
               {
                   Name (_ADR, [color="#0000FF"]0x01000000[/color]) [size=1]// [color="#0000FF"]01:00.0[/color] VGA compatible controller [0300]: nVidia Corporation Unknown device [10de:0ca3] (rev a2)[/size]
               }

               Device (HDAU)
               {
                   Name (_ADR, [color="#0000FF"]0x01000001[/color]) [size=1]// [color="#0000FF"]01:00.1 [/color]Audio device [0403]: nVidia Corporation Unknown device [10de:0be4] (rev a1)[/size]
               }

               Alias (AR01, _PRT)
               Alias (PW94, _PRW)
           }

           Device (P0P3)
...

 

quindi la tua tabella SSDT sarà:

DefinitionBlock ("SSDT.aml", "SSDT", 1, "GFX0", "Graphics", 0x00001000)
{
   External (DTGP, MethodObj)
   External (\_SB_.PCI0.P0P2.[color="#0000FF"]HDAU[/color], DeviceObj)
   External (\_SB_.PCI0.P0P2.[color="#0000FF"]GFX0[/color], DeviceObj)

   Scope (\_SB.PCI0.P0P2.[color="#0000FF"]GFX0[/color])
   {
       Method (_DSM, 4, NotSerialized)
       {
           Store (Package (0x1E)
               {
                   "AAPL,slot-name", 
                   Buffer (0x0A)
                   {
                       "PCI-E 16x"
                   }, 

                   "@0,compatible", 
                   Buffer (0x0B)
                   {
                       "NVDA,NVMac"
                   }, 

                   "@0,device_type", 
                   Buffer (0x08)
                   {
                       "display"
                   }, 

                   "@0,name", 
                   Buffer (0x0F)
                   {
                       "NVDA,Display-A"
                   }, 

                   "@1,compatible", 
                   Buffer (0x0B)
                   {
                       "NVDA,NVMac"
                   }, 

                   "@1,device_type", 
                   Buffer (0x08)
                   {
                       "display"
                   }, 

                   "@1,name", 
                   Buffer (0x0F)
                   {
                       "NVDA,Display-B"
                   }, 

                   "NVCAP", 
                   Buffer (0x18)
                   {
                       /* 0000 */    0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x00, 
                       /* 0008 */    0x0C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0A, 
                       /* 0010 */    0x00, 0x00, 0x00, 0x00
                   }, 

                   "NVPM", 
                   Buffer (0x1C)
                   {
                       /* 0000 */    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
                       /* 0008 */    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
                       /* 0010 */    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
                       /* 0018 */    0x00, 0x00, 0x00, 0x00
                   }, 

                   "VRAM,totalsize", 
                   Buffer (0x04)
                   {
                       0x00, 0x00, 0x00, 0x40
                   }, 

                   "device_type", 
                   Buffer (0x0C)
                   {
                       "NVDA,Parent"
                   }, 

                   "model", 
                   Buffer (0x15)
                   {
                       "GeForce GT 240 [G92]"
                   }, 

                   "rom-revision", 
                   Buffer (0x09)
                   {
                       "SSDT ROM"
                   }, 

                   "reg", 
                   Buffer (0x78)
                   {
                       /* 0000 */    0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 
                       /* 0008 */    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
                       /* 0010 */    0x00, 0x00, 0x00, 0x00, 0x10, 0x00, 0x02, 0x02, 
                       /* 0018 */    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
                       /* 0020 */    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 
                       /* 0028 */    0x14, 0x00, 0x02, 0x42, 0x00, 0x00, 0x00, 0x00, 
                       /* 0030 */    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
                       /* 0038 */    0x00, 0x00, 0x00, 0x10, 0x1C, 0x00, 0x02, 0x42, 
                       /* 0040 */    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
                       /* 0048 */    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 
                       /* 0050 */    0x24, 0x00, 0x02, 0x01, 0x00, 0x00, 0x00, 0x00, 
                       /* 0058 */    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
                       /* 0060 */    0x80, 0x00, 0x00, 0x00, 0x30, 0x00, 0x02, 0x02, 
                       /* 0068 */    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
                       /* 0070 */    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x00
                   }, 

                   "hda-gfx", 
                   Buffer (0x0A)
                   {
                       "onboard-1"
                   }
               }, Local0)
           DTGP (Arg0, Arg1, Arg2, Arg3, RefOf (Local0))
           Return (Local0)
       }
   }

   Scope (\_SB.PCI0.P0P2.[color="#0000FF"]HDAU[/color])
   {
       Method (_DSM, 4, NotSerialized)
       {
           Store (Package (0x02)
               {
                   "hda-gfx", 
                   Buffer (0x0A)
                   {
                       "onboard-1"
                   }
               }, Local0)
           DTGP (Arg0, Arg1, Arg2, Arg3, RefOf (Local0))
           Return (Local0)
       }
   }
}

 

Attenzione se usi un metodo iniettore diverso devi cambiarlo in corrispondenza della chiamata nella tabella SSDT.

 

Fabio

Link to comment
Share on other sites

  • 8 months later...

Ciao ermac!

 

Volevo sapere se si può iniettare tramite SSDT il codice della scheda video nVidia GeForce 9600M GT da 1024MB. E soprattutto, che codice ci inserisco? Ho sottomano quello per nVidia GeForce 9300M GT da 256MB, so solamente modificare il nome del dispositivo e la quantità di ram, le altre info tipo NVCAP non so nemmeno cosa sono. Puoi aiutarmi? ;) Grazie! Ciao! :)

Link to comment
Share on other sites

Ciao ermac!

 

Volevo sapere se si può iniettare tramite SSDT il codice della scheda video nVidia GeForce 9600M GT da 1024MB. E soprattutto, che codice ci inserisco? Ho sottomano quello per nVidia GeForce 9300M GT da 256MB, so solamente modificare il nome del dispositivo e la quantità di ram, le altre info tipo NVCAP non so nemmeno cosa sono. Puoi aiutarmi? :) Grazie! Ciao! :)

 

Si certamente si può fare.

Posta il tuo IOREG (guarda le FAQ)

E vediamo di "accompagnarti" nella creazione della tua tabella SSDT.

 

Fabio

Link to comment
Share on other sites

  • 1 month later...

ciao fabio, scusa ma ho bisogno di un aiuto, non riesco avenirne fuori

ho questo problema, ovvero, ho caricato una 6450 512mb sapphire su una scheda con nvidia ion, tutto ok, fatto dsdt funzionante, compilato a pieno, e fixato, il problema è un altro, la 6450 viene riconosciuta come scheda 6xxx generica, il core viene riconosciuto come coicos (giusto) e, da quanto ho visto dall'ioreg, i valori registrati al boot sono errati, ovvero, come si può vedere dalle foto

 

http://imageshack.us/g/208/schermata022455959alle1.png/

 

i valori non sono corretti, e ovrebbero essere rispettivamente

 

devid 6779 (codice della 6450)... qui è 67791

sapphire id-vendor id 1002... qui è 0x02 0x10 0x00 0x00, che a logica sarebbe 2 16 0 0

il subvendor id dovrebbe essere E164... qui è 0x64 0xE1 0x00 0x00 che a logica sarebbe 100 225 0 0

subsystem vendor id dovrebbe essere 174B... qui è 0x4B 0x17 0x00 0x00 che a logica sarebbe 75 23 0 0

 

alla fine i dati sono errati, cioè, ovvio che non mi riconosce la scheda, legge dati errati (p.s. chameleon 2.1 mi riconosce la 6450 al boot, tral'altro sto usando la trunk compilata da te!)

 

la domanda è, compilare un SSDT è facile, mi sono arrangiato e ho capito come fare, il dubbio sta nei dati, che devo mettere in quei valori?

il devid è numero, gli altri son valori data, ho provato mettendo tutti numero, e pure tutti data, risultato, al boot ho forzato il framebuffer (che a stock viene riconosciuto come il framebuffer universale) mettendo burlushes, la scheda mi viene riconosciuta, alla meno, con 5mb di vram, con conseguente impossibilità di utilizzo del sistema (troppo poca vram per caricare le finestre), ho provato ad impostare la vram nel ssdt ma non c'ho tirato fuori un tubo

 

qua non è difficile la compilazione in se dell'ssdt, ma capire che quali valori necessita il sistema, come faccio a fargli riconoscere i dati valore giusto? number 0x6779 o data 0x06 0x07 0x07 0x09 o addirittura data 0x1A 0x7B (che è 6779 in esadecimale)?

 

qua ci vorrebbe una guida per capire quali sono i valori corretti!

 

ti ringrazio, attendo buone nuove!

Link to comment
Share on other sites

...

 

Penso che il problema sia semplicemente che hai una iniezione *SDT (la nvidia) e una iniezione tramite injector di chameleon...

Ora ho controllato gli ID e subID nei sorgenti e sono corretti (tra le altre cose il fatto che l'abbia compilata io no ha nulla a che vedere...)

 

Se puoi... disattiva la nvidia, togli momentaneamente l'iniezione *SDT e vedi con l'injector di Chameleon se i valoi sono leggibili...

Iniettare una ATi via SSDT o DSDT è una operazione molto più lunga e complessa delle nvidia (come ti sarai accorto)...

 

Fabio

  • Like 1
Link to comment
Share on other sites

Ciao, in primis grazie per la risposta.

La ION è disabilitata da bios, non occupa nemmeno porzione della ram di sistema.

La condizione di rilevamento parziale della scheda ce l'ho solo con DSDT estratto e fixato da me, quindi, se uso il sistema di injection di chameleon non mi riconosce la scheda al 100%, o almeno, qe/ci funzionano, l'unico bug, al boot, fra la mela e lo sfondo in caricamento c'è un effetto di luci in stile "pro epilessia", ovvero, la pagina refresha fra bianco e nero (con righe alternate bianche e nere) per un 10 secondi, cosa risolvibile spegnendo il monitor

 

qui ci sono l'ioreg + dsdt

 

dall'ioreg si vede che pci0 è vuoto, ed è il buss occupato dalla ion, mentre il buss pci-e è occupato dalla radeon hd

ho provato a compilare un ssdt a mano, riuscito, col bel risultato di un buco nell'acqua, partizione non più avviabile, modificati permessi dei file di sistema, dovuto formattare exnovo, questo, tentando di cambiare i valori relativi alla scheda, fra cui devid ecc ecc, che, per come li leggo, sembrano errati, cioè, ci credo che la scheda non venga riconosciuta se i valori relativi agli id sono errati..

 

se hai voglia di dare una occhiata all'ioreg e al dsdt, li ho uplodati proforma, non sentirti in obbligo, anzi, non vorrei mai permettermi di chiederti un aiuto diretto, quando, fai già troppo con chameleon :wink2:

 

per ora ti ringrazio, e, beh, buona notte

 

EDIT

 

come non detto, non è colpa del dsdt, e l'injector funziona benissimo.. perchè non si attiva il framebuffer? non lo so, so solo che col tag pciroot 1 ho framebuffer radeonframebuffer (quindi stock) con uscita dvi+hdmi funzionanti all'unisono. Con pciroot0 si spegne la dvi e funziona solo l'hdmi, con il framebuffer bulrushes, quello corretto, e viene riconosciuta la scheda nel modo corretto, quindi, 6450..

 

ora, qua non c'ho capito il perchè ma so che il framebuffer altro non è che una porzione di memoria che si occupa dell'immagazzinamento dei bit a schermo, tale può influire sulle prestazioni fisiche della scheda video?

Cioè, col framebuffer generico potrei avere meno prestazioni alla mano per calcoli opencl/opengl?

 

dico che, qe/ci funzionano, l'accelerazione webgl funziona su safari, accelerazione gpu flash player funziona su tutti (testato su firefox) e i giochi dovrebbero partire, ma non gioco, quindi, dubbio del secolo, che azz cambia avere un framebuffer rispetto all'altro?

cioè, mi conviene tenere lo stock framebuffer e usare 1 porta dvi + 1 hdmi o usare il suo nativo e switchare l'uscita hdmi fra monitor (con cavo adattatore) e tv (questo perchè vorrei prendere una tv per guardarmi i telefilm da pc)

 

so che non centra nulla con l'ssdt, ma son sollevato dal fatto che non è un suo problema, anzi, tutto funziona nel modo corretto, non capisco perchè con pciroot attivo non si configuri tutto correttamente ma, vabbè, almeno non devo compilare un ssdt ex novo

Link to comment
Share on other sites

  • 1 year later...
 Share

×
×
  • Create New...