Jump to content

Creando SSDT's Personalizados Para OpenCore

XAVIDENIA

By XAVIDENIA,
in DSDT y SSDTs

 Share
10 posts in this topic

Recommended Posts

XAVIDENIA
XAVIDENIA
Posted
Posted (edited)

Hola estoy tratando de crear un EFI de OpenCore para Haswell en mi caso ya tengo todo o casi todo echo a excepción de los SSDT's  que los  quiero hacer personalizados , así que aquí explicare un poco lo que yo entiendo de la Guia de instalación de OpenCore de  Dortania y expondre también mis dudas por si alguien es capaz de ayudar , generalmente todas mis dudas estan basadas y fundamentadas en la creación de los SSDT's

 

Partimos de la base de que nuestro Pc es un Haswell:

Haswell y Broadwell.png

 

en esta sección nos dice que la versión de OpenCore soportada para nuestro hardware es la 0.6.5 o sea , si no me equivoco la ultima...

 

 Ahora necesitaríamos saber que SSDt's como mínimo necesitamos para que OpenCore pueda trabajar y/o almenos pueda arrancar OS X con unos mínimos o como lo hace Clover, para eso vamos a buscar la tabla en la Guia de instalación de OpenCore de Dortania, que es esta: 

 

Tabla DESKTOP.png

 

Como vemos en la tabla para un hardware Haswell de escritorio Normal, no Haswell de gama alta, ni portátil , necesitamos 2 SSDT's.... el SSDT-PLUG y el SSDT-EC

Estos SSDT's no los vamos ha encontrar en ningún dump que la hagamos al ACPI, tenemos que descargarnos las plantillas y apartir de ahí usarlos directamente o personalizarlos verificando datos y en nuestra DSDT propia y borrando lo que no sea de nuestro hardware, pues estos SSDT's Preconfigurados de cada plataforma Generados por el Equipo de OpenCore, por lo general estos SSDT's vienen configurados para distintos procesadores de cada Familia.... y por plataformas Desktop, Desktop gama alta y Portátiles....

Pero que son estos SSDT's ?? Cual es su funcionalidad???

Segun Los de OpenCore esta es la funcionalidad de estos dos SSDT's:

 

SSDT'S necesarios.png

 

Personalizar SSDT-PLUG

 

SSDT-PLUG: Nos vamos a la sección comenzando con ACPI ---> que SSDT   necesita cada plataforma  que es donde se encuentran la tablas como la que yo he puesto aqui....

 

en mi caso es un desktop , el procesador es un Haswell y dentro de los Haswell hay varios modelos el mío es un I4770k...

al estar el SSDT-PLUG configurado para distintos modelos de Haswell, esto penaliza en tiempo de arranque , con lo que lo mejor es personalizarlo a cada modelo de procesador....

 

así que vamos alla:

Montamos la partición EFI  de nuestro HDD Os X  accedemos a ella y nos vamos a EFI--->Clover--->ACPI y copiamos la carpeta Origin al escritorio por si algo sale mal continuar teniendo los aml originales del dump.....


una vez en el escritorio descompilamos el DSDT.aml a DSDT.dsl,hay muchos tutoriales de como hacerlo en esta sección de insanelymac,por ejemplo este: https://www.insanelymac.com/forum/topic/312072-ya-tengo-mi-dsdt-original-¿ahora-qué/

o bien tambien podemos descompilarlo con Maciasl....

 

una vez tenemos el DSDT.dsl obtenido  lo abrimos con Maciasl.

 

ahora descargamos el SSDT-PLUG que corresponde a nuestra plataforma y tambien lo pasamos a dsl

 

y lo abrimos en una nueva instancia  de Maciasl

como vemos el SSDT-PLUG no tiene muchas lineas  y si nos fijamos en el Principio(en los externas) veremos  que hay unas lineas que son casi iguales y que solo Cambia el _PR_ por _SB_  y los nombres de Dispositivos CP00,CPU0,MPM,P000,PR00,SCK0.CP00,SCK0.PR00

 

Quote

    External (_PR_.C000, ProcessorObj)
    External (_PR_.CPU0, ProcessorObj)
    External (_PR_.P000, ProcessorObj)
    External (_PR_.PR00, ProcessorObj)
    External (_SB_.CPU0, ProcessorObj)
    External (_SB_.PR00, ProcessorObj)
    External (_SB_.SCK0.CP00, ProcessorObj)
    External (_SB_.SCK0.PR00, ProcessorObj)

 

pues bien debemos de saber cual de todos es nuestro procesador y eliminar los demás, según tengo entendido tras seguir la Guia de DORTANIA, para eso abrimos nuestro DSDT del dump  que hemos pasado anteriormente a dsl en una nueva instancia de Maciasl, si no le habíamos abierto antes... y buscamos dentro del DSDT la palabra Processor

 

y esto es lo que me aparece en mi DSDT....

Quote

Scope (_PR)
    {
        Processor (CPU0, 0x01, 0x00001810, 0x06) {}
        Processor (CPU1, 0x02, 0x00001810, 0x06) {}
        Processor (CPU2, 0x03, 0x00001810, 0x06) {}
        Processor (CPU3, 0x04, 0x00001810, 0x06) {}
        Processor (CPU4, 0x05, 0x00001810, 0x06) {}
        Processor (CPU5, 0x06, 0x00001810, 0x06) {}
        Processor (CPU6, 0x07, 0x00001810, 0x06) {}
        Processor (CPU7, 0x08, 0x00001810, 0x06) {}
    }
Como vemos el Scope de nuestro Procesador es (_PR) y nuestros núcleos de llaman CPU+el numero de la CPU

 así que vamos a borrar el resto de las CPU que no concuerdan con nuestro Harware y sus Scripts de mas abajo de forma que solo quede los relacionados con nuestra CPU con lo cual OpenCore al inyectar el SSDT será mas rápido al no tener que ir probando Scopes y nombres de CPU.....

 

con esto hecho solo nos debe de quedar una entrada se nos quedaría asi....

Quote

External (_PR_.CPU0, DeviceObj)// (from opcode)

 procedemos a eliminar script de las demás Cpu que no concuerdan con las nuestras... los Scripts estan debajo de los external y debemos quitarlos todos menos el que corresponde a nuestra CPU y el que pone PMPM que es un método.

 

Ojo al borrar los Scripts que no pertenezcan a nuestro hardware pues van encerrados dentro del método PMPM, que quiero decir con esto: pues que al final de todo hay un corchete o llave que perntenece a la función PMPM y si lo borramos nos dará error al compilarlo.... yo aconsejo hacerlo con VsCode que tiene una extension llamada ACPI solo hay que instalarla y al abrir el dsl  con VsCode nos marcara todas y cada una de la llaves de apertura y cierre, emparejándolas , por tabulado..... 

 

una vez hecho si lo hacemos en VsCode solo hay que guardar cambios y abrirlo con Maciasl para compilarlo, ver si hay algún error y de no haberlo guardarlo como aml(ACPI Machine Language Binary)

 

Nota: aconsejable usar la ultima versión de Maciasl, que si no me equivoco es la 1.5.9

 

nuestro SSDT queda así:

Quote

 External (_PR_.CPU0, DeviceObj)    // (from opcode)
    Method (PMPM, 4, NotSerialized)
    {
        If ((Arg2 == Zero))
        {
            Return (Buffer (One)
            {
                 0x03                                           
            })
        }

        Return (Package (0x02)
        {
            "plugin-type", 
            One
        })
    }
    If (CondRefOf (\_PR.CPU0))
    {
        If ((ObjectType (\_PR.CPU0) == 0x0C))
        {
            Scope (\_PR.CPU0)
            {
                Method (_DSM, 4, NotSerialized)  // _DSM: Device-Specific Method
                {
                    Return (PMPM (Arg0, Arg1, Arg2, Arg3))
                }
            }
        }
    }
}

 

Nota: aconsejable usar la ultima versión de Maciasl,

 

compilamos el SSDT-PLUG-DRTNIA ,  nos vamos a safe as , elegimos formato aml(ACPI Machine Language Binary) cambiando el nombre para no confundirnos luego... Yo le he renombrado SSDT-PLUG-i4770k(SSDT-PLUG-modelo procesador) y listo ya tenemos compilado el SSDT-PLUG.aml para nuestro equipo...

 

Si me equivoco en algo o por mi nivel de ingles me equivoco o mal entiendo algo , agradecería me corrigieran......

 

 

 

Edited by XAVIDENIA
Link to comment
Share on other sites
XAVIDENIA
XAVIDENIA
Posted
  • Author
Posted (edited)
17 hours ago, Allan said:

Hello @XAVIDENIA.

 

Please don't post the same topic twice. The other one is going to be deleted.

 

Thanks

No he publicado el mismo tema 2 veces..... el primero preguntaba sobre como editar unos SSDT's para Clover y me aconsejaron que usara OpenCore y me explicaron un poco como iba la configuración y tal y despeje mis dudas.... y configure el Plist

 

y en este ya tengo el Plist configurado y estoy explicando a la par que preguntando mis dudas sobre como hacer los SSDT's de Opencore personalizados a mi PC

 

I have not published the same topic 2 times ..... the first one asked about how to edit some SSDT's for Clover and they advised me to use OpenCore and they explained to me a bit how the configuration was going and such and clear my doubts .... and configure the Plist and in this I already have the Plist configured and I am explaining at the same time asking my doubts about how to make the Opencore SSDT's customized to my PC

Edited by XAVIDENIA
Link to comment
Share on other sites
XAVIDENIA
XAVIDENIA
Posted
  • Author
Posted (edited)

Bueno en esta ocasión, ya que tenemos al SSDT-PLUG personalizado para nuestro hardware , vamos a intentar personalizar el segundo SSDT necesario para que OpenCore Arranque  en nuestro Hardware Haswell con unos mínimos estamos hablando del SSDT-EC......

Pero para que sirve este SSDT?? Que función tiene??

lo que hace.png

Como vais a ver la lista de externals en este SSDT es mas extensa.....

Quote

    External (_SB_.PC00.LPC0, DeviceObj)
    External (_SB_.PC00.LPC0.EC0_, DeviceObj)
    External (_SB_.PC00.LPC0.EC__, DeviceObj)
    External (_SB_.PC00.LPC0.ECDV, DeviceObj)
    External (_SB_.PC00.LPC0.H_EC, DeviceObj)
    External (_SB_.PC00.LPC0.PGEC, DeviceObj)
    External (_SB_.PCI0.LPC0, DeviceObj)
    External (_SB_.PCI0.LPC0.EC0_, DeviceObj)
    External (_SB_.PCI0.LPC0.EC__, DeviceObj)
    External (_SB_.PCI0.LPC0.ECDV, DeviceObj)
    External (_SB_.PCI0.LPC0.H_EC, DeviceObj)
    External (_SB_.PCI0.LPC0.PGEC, DeviceObj)
    External (_SB_.PCI0.LPC_, DeviceObj)
    External (_SB_.PCI0.LPC_.EC0_, DeviceObj)
    External (_SB_.PCI0.LPC_.EC__, DeviceObj)
    External (_SB_.PCI0.LPC_.ECDV, DeviceObj)
    External (_SB_.PCI0.LPC_.H_EC, DeviceObj)
    External (_SB_.PCI0.LPC_.PGEC, DeviceObj)
    External (_SB_.PCI0.LPCB, DeviceObj)
    External (_SB_.PCI0.LPCB.EC0_, DeviceObj)
    External (_SB_.PCI0.LPCB.EC__, DeviceObj)
    External (_SB_.PCI0.LPCB.ECDV, DeviceObj)
    External (_SB_.PCI0.LPCB.H_EC, DeviceObj)
    External (_SB_.PCI0.LPCB.PGEC, DeviceObj)
    External (_SB_.PCI0.PX40, DeviceObj)
    External (_SB_.PCI0.PX40.EC0_, DeviceObj)
    External (_SB_.PCI0.PX40.EC__, DeviceObj)
    External (_SB_.PCI0.PX40.ECDV, DeviceObj)
    External (_SB_.PCI0.PX40.H_EC, DeviceObj)
    External (_SB_.PCI0.PX40.PGEC, DeviceObj)
    External (_SB_.PCI0.SBRG, DeviceObj)
    External (_SB_.PCI0.SBRG.EC0_, DeviceObj)
    External (_SB_.PCI0.SBRG.EC__, DeviceObj)
    External (_SB_.PCI0.SBRG.ECDV, DeviceObj)
    External (_SB_.PCI0.SBRG.H_EC, DeviceObj)
    External (_SB_.PCI0.SBRG.PGEC, DeviceObj)

 

Para personalizar este SSDT , vamos a empezar por abrir el DSDT.dsl que usamos con el anterior SSDT(SSDT-PLUG) el DSDT original del dump de Clover....

y vamos a buscar dentro del DSDT PNP0C09

 

Esto nos va ha arrojar 2 datos:

Quote

Scope (_SB.PCI0.LPCB)<--- ruta del controlador integrado
    {
        Device (H_EC). <--- nombre del dispositivo o del controlador integrado
        {
            Name (_HID, EisaId ("PNP0C09"))  // _HID: Hardware ID
            Name (_UID, One)  // _UID: Unique ID
            Method (_STA, 0, NotSerialized)  // _STA: Status
            {
                ^^^GFX0.CLID = 0x03
                Return (Zero)
            }

 

así queda mi SSDT-EC-DESKTOP tras eliminar todo lo que no tenia que ver con mi controlador integrado

 

Quote

DefinitionBlock ("", "SSDT", 2, "DRTNIA", "SsdtEC", 0x00001000)
{
    
    External (_SB_.PCI0.LPCB.H_EC, DeviceObj)
    
    If (CondRefOf (\_SB.PCI0.LPCB.H_EC))
    {
        If ((((CondRefOf (\_SB.PCI0.LPCB.H_EC._HID) && CondRefOf (\_SB.PCI0.LPCB.H_EC._CRS)) && CondRefOf (\_SB.PCI0.LPCB.H_EC._GPE
            )) && !CondRefOf (\_SB.PCI0.LPCB.H_EC._STA)))
        {
            Scope (\_SB.PCI0.LPCB.H_EC)
            {
                Method (_STA, 0, NotSerialized)  // _STA: Status
                {
                    If (_OSI ("Darwin"))
                    {
                        Return (Zero)
                    }
                    Else
                    {
                        Return (0x0F)
                    }
                }
            }
        }
    }

    Scope (\_SB)
    {
        Device (EC)
        {
            Name (_HID, "ACID0001")  // _HID: Hardware ID
            Method (_STA, 0, NotSerialized)  // _STA: Status
            {
                If (_OSI ("Darwin"))
                {
                    Return (0x0F)
                }
                Else
                {
                    Return (Zero)
                }
            }
        }
    }
}

 

Aqui la primera duda, según esta Pagina debo de renombrar:

 

edciones 1.png

 

ediciones 2.png

Asi:

Quote

_SB_.PCI0.LPCB  a  _SB_.PC00.LPC0

 

 con lo cual quedaria si:

Quote

DefinitionBlock ("", "SSDT", 2, "DRTNIA", "SsdtEC", 0x00001000)
{
    
    External (_SB_.PC00.LPC0.H_EC, DeviceObj)
    
    If (CondRefOf (\_SB.PC00.LPC0.H_EC))
    {
        If ((((CondRefOf (\_SB.PC00.LPC0.H_EC._HID) && CondRefOf (\_SB.PC00.LPC0.H_EC._CRS)) && CondRefOf (\_SB.PC00.LPC0.H_EC._GPE
            )) && !CondRefOf (\_SB.PCI0.LPCB.H_EC._STA)))
        {
            Scope (\_SB.PC00.LPC0.H_EC)
            {
                Method (_STA, 0, NotSerialized)  // _STA: Status
                {
                    If (_OSI ("Darwin"))
                    {
                        Return (Zero)
                    }
                    Else
                    {
                        Return (0x0F)
                    }
                }
            }
        }
    }

    Scope (\_SB) <---    Incompleto???
    {
        Device (EC)
        {
            Name (_HID, "ACID0001")  // _HID: Hardware ID
            Method (_STA, 0, NotSerialized)  // _STA: Status
            {
                If (_OSI ("Darwin"))
                {
                    Return (0x0F)
                }
                Else
                {
                    Return (Zero)
                }
            }
        }
    }
}

 aqui mi duda pues en la guía se basa en otro tipo de SSDT para otro tipo de Hardware que no es Haswell....  aparte de que el Scope final , parece incompleto, debo de poner mis datos ahi????

Pues se usa el SSDT-EC-USBX

SNAG-21012819334200.png

 

SNAG-21012819342900.png

 

y la unica referencia que hay hacia el SSDT-EC para Haswell esta aqui y no aclara nada al respecto de los cambios ha hacer .....

alguien puede iluminar un poco????

 

Gracias y saludos

 

Edited by XAVIDENIA
  • Thanks 1
Link to comment
Share on other sites
  • 4 weeks later...
uzmi
uzmi
Posted
Posted (edited)

hola:

¿Como lo llevas? ¿lo solucionaste?

Desde mi ignorancia aporto un granito de arena:

https://dortania.github.io/Getting-Started-With-ACPI/#a-quick-explainer-on-acpi

 

Controladores integrados (EC)

  • Todas las máquinas Intel semi-modernas tienen un EC (generalmente llamado H_EC, ECDV, EC0, etc.) expuesto en su DSDT, y muchos sistemas AMD también lo tienen expuesto. Estos controladores generalmente no son compatibles con macOS y pueden causar pánico, por lo que deben ocultarse de macOS. Sin ECembargo, macOS Catalina requiere que esté presente un dispositivo con nombre , por lo que se crea un EC ficticio.
  • Con las computadoras portátiles, el controlador integrado real aún debe estar habilitado para que la batería y las teclas de acceso rápido funcionen, y cambiar el nombre del EC también puede causar problemas con Windows, por lo que es preferible crear un EC falso sin deshabilitar el controlador integrado real.

 

 

 

Mas tierra, digo arena:

Nombro a Maldon en quien me baso y apoyo para hacer funcionar mi Big Sur, y él tiene preparado una imagen para instalar con un ssdt generico donde crea un device EC(unico) para   que la instalación funcione:

Device (_SB.EC)

Edited by uzmi
  • Thanks 1
Link to comment
Share on other sites
surfcaster
surfcaster
Posted
Posted

Hola Guzman, Maldon es un caso aparte, no es de este mundo, yo estoy funcionando con Mojave, Catalina y BS con únicamente DSDT hecho por Maldon, absolutamente todo funcionando como era de esperar habiéndolo hecho el, si lo necesitaras para verlo que se que te gusta trastear te lo envio y te adelanto que todo lo necesario en las tablas SSDT esta metido en mi DSDT

  • Thanks 1
Link to comment
Share on other sites
  • 4 weeks later...
miliuco
miliuco
Posted
Posted (edited)

@XAVIDENIA

Yo creo que no debes complicarte con SSDT-EC, el genérico que se descarga de varios sitios (incluso viene en la carpeta Docs > AcpiSamples de las versiones recientes de OpenCore) por lo genera funciona bien en todos los sistemas. Sólo has de usar el tuyo si lo generas tú mismo con seguridad.

Conoces SSDTTIME? es un script de corpnewt que en mi opinión es la forma más sencilla de generar tanto SSDT-PLUG como SSDT-EC para tu sistema. Antes de generarlos has de obtener el DSDT de tu sistema, en las opciones de SSDTTIME es la que dice Dump DSDT. Después a partir de ese DSDT es cuando generas los SSDT. Aquí tienes unas instrucciones.

Edited by miliuco
  • Thanks 1
Link to comment
Share on other sites
 Share
Go to topic listing
×
×
  • Create New...