16 replies to this topic

[ErmaC]

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.

• Chameleon bootloader with SSDT and DSDT override, I written a patch for Chameleon which overrides default SSDT and DSDT
  
• Chameleon RC5 mode with mem detection enabled and automatic P-States & C-States generation for native power managment
  
• AnVAL (ACPI Loader)
  
• Chameleon RC5 Meklort's Branch

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   944bytes   106 downloads

*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

AUDIO

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

• AD2000B >>  AD2000B.TXT   1.42K   54 downloads*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   1.74K   22 downloads

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

• ALC883 >>  ALC883.txt   1.43K   23 downloads*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   1.43K   51 downloads
  
• ALC1200 >>  ALC1200.TXT   1.8K   47 downloads*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   1.93K   42 downloads

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

• ALC889A >>  ALC889A.TXT   1.93K   26 downloads

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

• ALC662 >>  ALC662.txt   1.93K   21 downloads*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   1.86K   31 downloads

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

SATA

• ESB2 Full >>  ESB2f.TXT   3.51K   39 downloads
  
• ESB2 Mini >>  ESB2m.TXT   573bytes   33 downloads
  
• *ICH10 Full >>  ICH10.TXT   3.51K   78 downloads*Un modo elegante per risolvere le Icone arancioni è usare IOAHCIBlockstorageInjector e LegayAppleAHCIPort in Extra/Extensions.
  Oppure usare i miei plist editati da sostituire direttamente negli kext in System/Library/Extensions.
  AppleAHCIPort >> /System/Library/Extensions/AppleAHCIPort.kext/Contents/Info.plist
  IOAHCIBlockStorage >> /System/Library/Extensions/IOAHCIFamily.kext/Contents/PlugIns/IOAHCIBlockStorage.kext/Contents/Info.plist
  

SBUS

• SBUS >>  SBUS.TXT   1.28K   73 downloads

LPCB

• Intel pci8086,3a18 >>  pci8086_3a18.TXT   588bytes   39 downloads
  
• Intel pci8086,3b02 >>  pci8086_3b02.TXT   588bytes   17 downloads

USB

• UHCI e EHCI (ICH10) >>  UHCI_EHCI.TXT   8.79K   56 downloads
  
• UHCI (ICH10) >>  UHCI.txt   5.56K   10 downloads
  
• EHCI (ICH10) >>  EHCI.txt   3.33K   23 downloads

LAN

• Ethernet 0&1 Marvell 88E8086 >>  ETH0_1.TXT   4.08K   24 downloads
  
• Ethernet 0 Marvell 88E8086 >>  ETH0.TXT   2.09K   14 downloads
  
• Ethernet 0 Atheros L1E (mrmojorisin17) >>  ETH0_AtherosL1E.TXT   2.09K   35 downloads
  
• Ethernet 1 Marvell 88E8086 >>  ETH1.TXT   2.09K   9 downloads

Shede Grafiche

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

• nVidia Quadro FX 5600 (0x10de 0x019d) >>  QuadroFX5600.TXT   4.26K   20 downloads
  
• nVidia GeForce GTX 285 (0x10de 0x05e3) >>  GTX_285.TXT   4.23K   50 downloads
  
• nVidia GeForce GTX 275 (0x10de 0x05e6) >>  GTX_275.TXT   4.23K   12 downloads
  
• nVidia GeForce GTX 260 (0x10de 0x05e2) >>  GTX_260.TXT   4.23K   32 downloads
  
• nVidia GeForce 8800 GT (0x10de 0x0611) >>  GF_8800_GT.TXT   4.35K   39 downloads
  
• nVidia GeForce 9800 GTX+ (0x10de 0x0612) >>  GTX_9800.TXT   2.91K   28 downloads
  
• nVidia GeForce GT 240 (0x10DE 0x0CA3) >>  GT_240_1GB.TXT   4.84K   37 downloads
  
• nVidia GeForce GT 430 (0x10DE 0x0DE1) >>  GT_430.TXT   3.45K   21 downloads
  
• nVidia GeForce GTX 470 (0x10DE 0x06CD) >>  GTX_470.TXT   3.47K   54 downloads
  
• nVidia GeForce GTX 480 (0x10DE 0x06C0) >>  GTX_480.TXT   3.45K   50 downloads

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

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

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

[ErmaC]

buoo, on Feb 9 2011, 09:54 AM, said:

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ù
Il primo esempio invece rinomina i sub-device e aggiunge informazioni "estetiche".


Fabio

[ErmaC]

buoo, on Feb 9 2011, 01:40 PM, said:

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

[Astaga]

Secondo me sarebbe opportuno fare spostare questa guida nella sezione: Guide E Trucchi per PC Desktop

Complimenti per il thread!!!

[ErmaC]

Aggiunte le SSDT delle schede grafice:

- GTX+ 9800
- GT 430
- GTX 470
- GTX 480

Buon divertimento

Fabio

[ErmaC]

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

[Fabio71]

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

[ErmaC]

iFabios71, on Mar 19 2011, 06:03 PM, said:

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

[Fabio71]

Intanto grazie della risposta
Allora ho dato un occhiata al mio IOREG i device con il nome  P0P2@1 indica :
Display@0
NVDA Display-A@0
NVDA Display-B@1
Penso che sia quello che mi interessa giusto

intanto ti posto LsPCI e IOREG

Attached Files

•  iFabios71.zip   402.16K   11 downloads

[ErmaC]

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   255.74K   63 downloads

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

[Fabio71]

Ti ringrazio molto e sopratutto della spiegazione.
Posso disturbarti in PM grazie

[Marchrius]

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!

[ErmaC]

Marchrius, on 30 November 2011 - 06:35 PM, said:

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

[iba21]

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...55959alle1.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!

[ErmaC]

iba21, on 01 February 2012 - 03:22 PM, said:

...

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

[iba21]

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

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

[lidiano]

Ciao hai nessuna su cosa editare per una GTX 660 TI