Thinkpad T520 Laptop display doesn't work until "Detect Displays" clicked

coolstarorg · June 13, 2015

I have a Thinkpad T520 with the NVIDIA Quadro NVS 4200M (same chipset as GeForce GT 520M) (Optimus disabled). However, on boot, the laptop display doesn't work. (DVI out works fine though). If I go to Display Preferences, and click "Detect Displays" though, the laptop display starts working with QE/CI and brightness controls (from DSDT editing). Is there a way I can have the laptop display work automatically on boot?

I've fixed the other graphics issues I had before with EDID editing and DSDT editing (color banding and brightness issues fixed). I just need this display detection issue and HDMI Audio fixed and my laptop is good to go with OS X!

This is the relevant snippet from my DSDT:

Device (VID)
                {
                    Name (_ADR, Zero)
                    OperationRegion (VPCG, PCI_Config, Zero, 0x0100)
                    Field (VPCG, DWordAcc, NoLock, Preserve)
                    {
                                Offset (0x2C), 
                        VSID,   32, 
                                Offset (0x70), 
                        VPWR,   8
                    }

                    Name (_S3D, 0x03)
                    Name (DGOS, Zero)
                    Method (_INI, 0, NotSerialized)
                    {
                        VUPS (0x02)
                        Store (VCDL, VQDL)
                        Store (VCDC, VQDC)
                        Store (VCDT, VQD0)
                        Store (VCDD, VQD1)
                        If (ISOP ())
                        {
                            VHYB (0x04, One)
                        }
                    }

                    Method (_PS0, 0, NotSerialized)
                    {
                        If (ISOP ())
                        {
                            If (DGOS)
                            {
                                VHYB (0x02, Zero)
                                Sleep (0x64)
                                VHYB (Zero, One)
                                Sleep (0x0A)
                                Store (One, ^^^LPC.PCRS)
                                Store (One, ^^^LPC.PCRQ)
                                Sleep (0x64)
                                VHYB (0x02, One)
                                Sleep (One)
                                VHYB (0x08, One)
                                Store (0x0A, Local0)
                                Store (0x32, Local1)
                                While (Local1)
                                {
                                    Sleep (Local0)
                                    If (LCHK (One))
                                    {
                                        Break
                                    }

                                    Decrement (Local1)
                                }

                                Store (Zero, ^^^LPC.PCRQ)
                                VHYB (0x04, Zero)
                                SWTT (One)
                                Store (Zero, DGOS)
                            }
                            Else
                            {
                                If (LNotEqual (VSID, 0x21D117AA))
                                {
                                    VHYB (0x04, Zero)
                                }
                            }

                            VHYB (0x09, HDAS)
                        }
                    }

                    Method (_PS1, 0, NotSerialized)
                    {
                        Noop
                    }

                    Method (_PS2, 0, NotSerialized)
                    {
                        Noop
                    }

                    Method (_PS3, 0, NotSerialized)
                    {
                        If (ISOP ())
                        {
                            If (LEqual (OMPR, 0x03))
                            {
                                SWTT (Zero)
                                VHYB (0x08, Zero)
                                Store (0x0A, Local0)
                                Store (0x32, Local1)
                                While (Local1)
                                {
                                    Sleep (Local0)
                                    If (LCHK (Zero))
                                    {
                                        Break
                                    }

                                    Decrement (Local1)
                                }

                                VHYB (0x02, Zero)
                                Sleep (0x64)
                                VHYB (Zero, Zero)
                                Store (One, DGOS)
                                Store (0x02, OMPR)
                            }
                        }
                    }

                    Method (_STA, 0, NotSerialized)
                    {
                        Return (0x0F)
                    }

                    Method (_DSM, 4, NotSerialized)
                    {
                        Store (Package (0x24)
                            {
                                "AAPL,backlight-control", 
                                Buffer (0x04)
                                {
                                    0x01, 0x00, 0x00, 0x00
                                }, 

                                "@0,backlight-control", 
                                Buffer (0x04)
                                {
                                    0x01, 0x00, 0x00, 0x00
                                }, 

                                "AAPL,slot-name", 
                                Buffer (0x09)
                                {
                                    "Build In"
                                }, 

                                "@0,built-in", 
                                Buffer (Zero) {}, 
                                "@0,pwm-info", 
                                Buffer (0x14)
                                {
                                    /* 0000 */    0x01, 0x14, 0x00, 0x64, 0xA8, 0x61, 0x00, 0x00, 
                                    /* 0008 */    0x1C, 0x02, 0x00, 0x00, 0x64, 0x00, 0x00, 0x00, 
                                    /* 0010 */    0x00, 0x04, 0x00, 0x00
                                }, 

                                "@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, 0x01, 0x00, 
                                    /* 0008 */    0x3E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0A, 
                                    /* 0010 */    0x00, 0x00, 0x00, 0x00
                                }, 

                                "NVPM", 
                                Buffer (0x20)
                                {
                                    /* 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 (0x18)
                                {
                                    "Lenovo Quadro NVS 4200M"
                                }, 

                                "rom-revision", 
                                Buffer (0x0F)
                                {
                                    "70.18.87.00.00"
                                }
                            }, Local0)
                        DTGP (Arg0, Arg1, Arg2, Arg3, RefOf (Local0))
                        Return (Local0)
                    }

                    Method (_IRC, 0, NotSerialized)
                    {
                        Return (Zero)
                    }

                    OperationRegion (ATRP, SystemMemory, ATRB, 0x00010000)
                    Field (ATRP, AnyAcc, Lock, Preserve)
                    {
                        IDX0,   262144, 
                        IDX1,   262144
                    }

                    Method (_ROM, 2, Serialized)
                    {
                        If (LGreaterEqual (Arg0, 0x8000))
                        {
                            Return (GETB (Subtract (Arg0, 0x8000), Arg1, IDX1))
                        }

                        If (LGreater (Add (Arg0, Arg1), 0x8000))
                        {
                            Subtract (0x8000, Arg0, Local0)
                            Subtract (Arg1, Local0, Local1)
                            Store (GETB (Arg0, Local0, IDX0), Local3)
                            Store (GETB (Zero, Local1, IDX1), Local4)
                            Concatenate (Local3, Local4, Local5)
                            Return (Local5)
                        }

                        Return (GETB (Arg0, Arg1, IDX0))
                    }

                    Method (GETB, 3, Serialized)
                    {
                        Multiply (Arg0, 0x08, Local0)
                        Multiply (Arg1, 0x08, Local1)
                        CreateField (Arg2, Local0, Local1, TBF3)
                        Return (TBF3)
                    }

                    Method (VSWT, 0, NotSerialized)
                    {
                        If (WVIS)
                        {
                            Store (VEVT (0x07), Local0)
                        }
                        Else
                        {
                            Store (VEVT (0x05), Local0)
                        }

                        And (0xFF, Local0, Local1)
                        If (Local1)
                        {
                            ASWT (Local1, One)
                        }
                    }

                    Method (VLOC, 1, NotSerialized)
                    {
                        If (LEqual (Arg0, ^^^^LID._LID ()))
                        {
                            VSLD (Arg0)
                            Store (Zero, Local0)
                            If (LEqual (And (VPWR, 0x03), Zero))
                            {
                                If (Arg0)
                                {
                                    If (LOr (WIN7, WVIS)) {}
                                    Else
                                    {
                                        Store (VEVT (One), Local0)
                                    }
                                }
                                Else
                                {
                                    If (LOr (WIN7, WVIS)) {}
                                    Else
                                    {
                                        Store (VEVT (0x02), Local0)
                                    }
                                }

                                And (0x0F, Local0, Local1)
                                If (Local1)
                                {
                                    ASWT (Local1, Zero)
                                }
                            }
                        }
                    }

                    Method (_DOS, 1, NotSerialized)
                    {
                        If (LEqual (Arg0, 0x02))
                        {
                            Store (0x14, Local0)
                            While (Local0)
                            {
                                Decrement (Local0)
                                Acquire (MDGS, 0xFFFF)
                                If (LEqual (Zero, MSWT))
                                {
                                    Store (One, MSWT)
                                    Store (Zero, Local0)
                                    Store (Arg0, VDEE)
                                }

                                Release (MDGS)
                                Sleep (0xC8)
                            }
                        }
                        Else
                        {
                            Acquire (MDGS, 0xFFFF)
                            If (LEqual (VDEE, 0x02))
                            {
                                Store (Zero, MSWT)
                            }

                            If (LGreater (Arg0, 0x02))
                            {
                                Store (One, VDEE)
                            }
                            Else
                            {
                                Store (Arg0, VDEE)
                            }

                            Release (MDGS)
                        }
                    }

                    Method (_DOD, 0, NotSerialized)
                    {
                        Return (Package (0x08)
                        {
                            0x0100, 
                            0x0114, 
                            0x0111, 
                            0x0115, 
                            0x0112, 
                            0x0116, 
                            0x0113, 
                            0x0110
                        })
                    }

                    Method (ASWT, 2, NotSerialized)
                    {
                        If (LEqual (One, VDEE))
                        {
                            And (One, Arg1, Local1)
                            VSDS (Arg0, Local1)
                        }
                        Else
                        {
                            Store (0x14, Local0)
                            While (Local0)
                            {
                                Decrement (Local0)
                                Acquire (MDGS, 0xFFFF)
                                If (LEqual (Zero, MSWT))
                                {
                                    Store (Zero, Local0)
                                    If (And (One, Arg1))
                                    {
                                        Store (One, VUPC)
                                    }
                                    Else
                                    {
                                        Store (Zero, VUPC)
                                    }

                                    If (And (One, Arg0))
                                    {
                                        Store (One, VQDL)
                                    }
                                    Else
                                    {
                                        Store (Zero, VQDL)
                                    }

                                    If (And (0x02, Arg0))
                                    {
                                        Store (One, VQDC)
                                    }
                                    Else
                                    {
                                        Store (Zero, VQDC)
                                    }

                                    If (And (0x04, Arg0))
                                    {
                                        Store (One, VQD0)
                                    }
                                    Else
                                    {
                                        Store (Zero, VQD0)
                                    }

                                    If (And (0x08, Arg0))
                                    {
                                        Store (One, VQD1)
                                    }
                                    Else
                                    {
                                        Store (Zero, VQD1)
                                    }

                                    If (And (0x10, Arg0))
                                    {
                                        Store (One, VQD2)
                                    }
                                    Else
                                    {
                                        Store (Zero, VQD2)
                                    }

                                    If (And (0x20, Arg0))
                                    {
                                        Store (One, VQD3)
                                    }
                                    Else
                                    {
                                        Store (Zero, VQD3)
                                    }

                                    If (And (0x40, Arg0))
                                    {
                                        Store (One, VQD4)
                                    }
                                    Else
                                    {
                                        Store (Zero, VQD4)
                                    }

                                    If (And (0x80, Arg0))
                                    {
                                        Store (One, VQD5)
                                    }
                                    Else
                                    {
                                        Store (Zero, VQD5)
                                    }
                                }

                                Release (MDGS)
                                Sleep (0xC8)
                            }

                            If (And (0x02, Arg1))
                            {
                                Notify (VID, 0x81)
                            }
                            Else
                            {
                                Notify (VID, 0x80)
                            }
                        }
                    }

                    Method (VDSW, 1, NotSerialized)
                    {
                        If (LEqual (VPWR, Zero))
                        {
                            If (Arg0)
                            {
                                Store (VEVT (0x03), Local0)
                            }
                            Else
                            {
                                Store (VEVT (0x04), Local0)
                            }

                            And (0x0F, Local0, Local1)
                            If (Local1)
                            {
                                ASWT (Local1, Zero)
                            }
                        }
                    }

                    Device (LCD0)
                    {
                        Method (_ADR, 0, NotSerialized)
                        {
                            Return (0x0110)
                        }

                        Method (_DCS, 0, NotSerialized)
                        {
                            VUPS (Zero)
                            If (VCDL)
                            {
                                Return (0x1F)
                            }
                            Else
                            {
                                Return (0x1D)
                            }
                        }

                        Method (_DGS, 0, NotSerialized)
                        {
                            Return (VQDL)
                        }

                        Method (_DSS, 1, NotSerialized)
                        {
                            And (Arg0, One, VSDL)
                            If (And (Arg0, 0x80000000))
                            {
                                If (And (Arg0, 0x40000000))
                                {
                                    DSWT (0x02)
                                }
                                Else
                                {
                                    DSWT (One)
                                }
                            }
                        }

                        Method (_DDC, 1, NotSerialized)
                        {
                            If (ISOP ())
                            {
                                Return (Zero)
                            }

                            If (LEqual (Arg0, One))
                            {
                                Return (VEDI)
                            }
                            Else
                            {
                                If (LEqual (Arg0, 0x02))
                                {
                                    Return (VEDI)
                                }
                            }

                            Return (Zero)
                        }
                    }

                    Device (CRT0)
                    {
                        Method (_ADR, 0, NotSerialized)
                        {
                            Return (0x0100)
                        }

                        Method (_DCS, 0, NotSerialized)
                        {
                            VUPS (One)
                            If (VCSS)
                            {
                                If (VCDC)
                                {
                                    Return (0x1F)
                                }
                                Else
                                {
                                    Return (0x1D)
                                }
                            }
                            Else
                            {
                                If (VCDC)
                                {
                                    Return (0x0F)
                                }
                                Else
                                {
                                    Return (0x0D)
                                }
                            }
                        }

                        Method (_DGS, 0, NotSerialized)
                        {
                            Return (VQDC)
                        }

                        Method (_DSS, 1, NotSerialized)
                        {
                            And (Arg0, One, VSDC)
                            If (And (Arg0, 0x80000000))
                            {
                                If (And (Arg0, 0x40000000))
                                {
                                    DSWT (0x02)
                                }
                                Else
                                {
                                    DSWT (One)
                                }
                            }
                        }
                    }

                    Device (DVI0)
                    {
                        Method (_ADR, 0, NotSerialized)
                        {
                            Return (0x0111)
                        }

                        Method (_DCS, 0, NotSerialized)
                        {
                            VUPS (Zero)
                            If (VCDD)
                            {
                                Return (0x1F)
                            }
                            Else
                            {
                                Return (0x1D)
                            }
                        }

                        Method (_DGS, 0, NotSerialized)
                        {
                            Return (VQD1)
                        }

                        Method (_DSS, 1, NotSerialized)
                        {
                            And (Arg0, One, VSD1)
                            If (And (Arg0, 0x80000000))
                            {
                                If (And (Arg0, 0x40000000))
                                {
                                    DSWT (0x02)
                                }
                                Else
                                {
                                    DSWT (One)
                                }
                            }
                        }
                    }

                    Device (DP0)
                    {
                        Method (_ADR, 0, NotSerialized)
                        {
                            Return (0x0114)
                        }

                        Method (_DCS, 0, NotSerialized)
                        {
                            VUPS (Zero)
                            If (VCDT)
                            {
                                Return (0x1F)
                            }
                            Else
                            {
                                Return (0x1D)
                            }
                        }

                        Method (_DGS, 0, NotSerialized)
                        {
                            Return (VQD0)
                        }

                        Method (_DSS, 1, NotSerialized)
                        {
                            And (Arg0, One, VSD0)
                            If (And (Arg0, 0x80000000))
                            {
                                If (And (Arg0, 0x40000000))
                                {
                                    DSWT (0x02)
                                }
                                Else
                                {
                                    DSWT (One)
                                }
                            }
                        }
                    }

                    Device (DVI1)
                    {
                        Method (_ADR, 0, NotSerialized)
                        {
                            Return (0x0112)
                        }

                        Method (_DCS, 0, NotSerialized)
                        {
                            VUPS (Zero)
                            If (VCDD)
                            {
                                Return (0x1F)
                            }
                            Else
                            {
                                Return (0x1D)
                            }
                        }

                        Method (_DGS, 0, NotSerialized)
                        {
                            Return (VQD3)
                        }

                        Method (_DSS, 1, NotSerialized)
                        {
                            And (Arg0, One, VSD3)
                            If (And (Arg0, 0x80000000))
                            {
                                If (And (Arg0, 0x40000000))
                                {
                                    DSWT (0x02)
                                }
                                Else
                                {
                                    DSWT (One)
                                }
                            }
                        }
                    }

                    Device (DP1)
                    {
                        Method (_ADR, 0, NotSerialized)
                        {
                            Return (0x0115)
                        }

                        Method (_DCS, 0, NotSerialized)
                        {
                            VUPS (Zero)
                            If (VCDT)
                            {
                                Return (0x1F)
                            }
                            Else
                            {
                                Return (0x1D)
                            }
                        }

                        Method (_DGS, 0, NotSerialized)
                        {
                            Return (VQD2)
                        }

                        Method (_DSS, 1, NotSerialized)
                        {
                            And (Arg0, One, VSD2)
                            If (And (Arg0, 0x80000000))
                            {
                                If (And (Arg0, 0x40000000))
                                {
                                    DSWT (0x02)
                                }
                                Else
                                {
                                    DSWT (One)
                                }
                            }
                        }
                    }

                    Device (DVI2)
                    {
                        Method (_ADR, 0, NotSerialized)
                        {
                            Return (0x0113)
                        }

                        Method (_DCS, 0, NotSerialized)
                        {
                            VUPS (Zero)
                            If (VCDD)
                            {
                                Return (0x1F)
                            }
                            Else
                            {
                                Return (0x1D)
                            }
                        }

                        Method (_DGS, 0, NotSerialized)
                        {
                            Return (VQD5)
                        }

                        Method (_DSS, 1, NotSerialized)
                        {
                            And (Arg0, One, VSD5)
                            If (And (Arg0, 0x80000000))
                            {
                                If (And (Arg0, 0x40000000))
                                {
                                    DSWT (0x02)
                                }
                                Else
                                {
                                    DSWT (One)
                                }
                            }
                        }
                    }

                    Device (DP2)
                    {
                        Method (_ADR, 0, NotSerialized)
                        {
                            Return (0x0116)
                        }

                        Method (_DCS, 0, NotSerialized)
                        {
                            VUPS (Zero)
                            If (VCDT)
                            {
                                Return (0x1F)
                            }
                            Else
                            {
                                Return (0x1D)
                            }
                        }

                        Method (_DGS, 0, NotSerialized)
                        {
                            Return (VQD4)
                        }

                        Method (_DSS, 1, NotSerialized)
                        {
                            And (Arg0, One, VSD4)
                            If (And (Arg0, 0x80000000))
                            {
                                If (And (Arg0, 0x40000000))
                                {
                                    DSWT (0x02)
                                }
                                Else
                                {
                                    DSWT (One)
                                }
                            }
                        }
                    }

                    Method (DSWT, 1, NotSerialized)
                    {
                        If (VSDL)
                        {
                            Store (One, Local0)
                        }
                        Else
                        {
                            Store (Zero, Local0)
                        }

                        If (VSDC)
                        {
                            Or (0x02, Local0, Local0)
                        }

                        If (VSD0)
                        {
                            Or (0x08, Local0, Local0)
                        }

                        If (Local0)
                        {
                            If (VUPC)
                            {
                                VSDS (Local0, Arg0)
                            }
                        }
                        Else
                        {
                            Noop
                        }
                    }

                    Name (_SUN, One)
                }

                OperationRegion (PEGC, PCI_Config, Zero, 0x0100)
                Field (PEGC, DWordAcc, NoLock, Preserve)
                {
                            Offset (0xEC), 
                    GMGP,   1, 
                    HPGP,   1, 
                    PMGP,   1
                }

                Device (HDAU)
                {
                    Name (_ADR, One)
                    Method (_DSM, 4, NotSerialized)
                    {
                        Store (Package (0x06)
                            {
                                "hda-gfx", 
                                Buffer (0x0A)
                                {
                                    "onboard-1"
                                }, 

                                "layout-id", 
                                Buffer (0x04)
                                {
                                    0x01, 0x00, 0x00, 0x00
                                }, 

                                "PinConfigurations", 
                                Buffer (0x04)
                                {
                                    0xE0, 0x00, 0x56, 0x28
                                }
                            }, Local0)
                        DTGP (Arg0, Arg1, Arg2, Arg3, RefOf (Local0))
                        Return (Local0)
                    }
                }

angelol · June 13, 2015

Try adding

"hda-gfx", 
                                Buffer (0x0A)
                                {
                                    "onboard-1"
                                },

in your GFX DSM method. Also I don't know if layout-id and PinConfigurations are necessary in HDAU. I have working HDMI sound with only hda-gfx in HDAU's DSM.

For the display try adding:

"@1,AAPL,boot-display", 
                            Buffer (0x04)
                            {
                                0x01, 0x00, 0x00, 0x00
                            },

and try different ports ie: @0,@1 etc. Use it to make your main boot display and maybe it'll fix your problem.

Edited June 13, 2015 by angelol

coolstarorg · June 13, 2015

I applied those DSDT edits but my laptop's built-in display is still off at boot. Also, one thing I noticed is if I do not inject the card at all in clover or in the DSDT (stock DSM method) then both displays work, but the laptop LCD is detected as external and brightness controls do not work.

I have noticed that if I revert all my edits to _DSM and use the original DSM method with no graphics injection from Clover, the laptop display works but it's detected as external. Also, there's no brightness controls with the original _DSM method. This is the _DSM method from the original DSDT:

 Method (_DSM, 4, NotSerialized)  // _DSM: Device-Specific Method
                    {
                        If (\CMPB (Arg0, Buffer (0x10)
                                {
                                    /* 0000 */   0xF8, 0xD8, 0x86, 0xA4, 0xDA, 0x0B, 0x1B, 0x47,
                                    /* 0008 */   0xA7, 0x2B, 0x60, 0x42, 0xA6, 0xB5, 0xBE, 0xE0
                                }))
                        {
                            Return (NVOP (Arg0, Arg1, Arg2, Arg3))
                        }
                    }

coolstarorg · June 13, 2015

Below are the IORegistry information for my Graphics card when I'm not injecting in DSDT or with Clover (where display works properly on boot but no brightness controls).

angelol · June 15, 2015

Can you send me ur DSDT so I can have a better look? Btw, is your HDMI fixed?

Try replacing the contents of your DSM with this:

"@0,AAPL,boot-display", 
                            Buffer (0x04)
                            {
                                0x01, 0x00, 0x00, 0x00
                            }, 

                            "@0,backlight-control", 
                            Buffer (0x04)
                            {
                                0x01, 0x00, 0x00, 0x00
                            }, 

                            "@0,built-in", 
                            Buffer (One)
                            {
                                0x00
                            }, 

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

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

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

                            "@0,NVMT", 
                            Buffer (0x60)
                            {
                                /* 0000 */    0x0B, 0x03, 0xFF, 0x20, 0x06, 0xAF, 0x3E, 0x31, 
                                /* 0008 */    0x00, 0x05, 0x20, 0x03, 0x8F, 0x05, 0x30, 0x05, 
                                /* 0010 */    0x50, 0x05, 0x00, 0x00, 0x4E, 0x03, 0x23, 0x03, 
                                /* 0018 */    0x29, 0x03, 0x00, 0x00, 0x20, 0x43, 0x52, 0x04, 
                                /* 0020 */    0x00, 0x00, 0x01, 0x01, 0xE0, 0x00, 0x00, 0x00, 
                                /* 0028 */    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
                                /* 0030 */    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
                                /* 0038 */    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
                                /* 0040 */    0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0x00, 0x00, 
                                /* 0048 */    0x00, 0x00, 0x00, 0x00, 0x40, 0xFF, 0x10, 0x05, 
                                /* 0050 */    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
                                /* 0058 */    0x00, 0x08, 0x00, 0x00, 0x30, 0x01, 0x09, 0x09
                            }, 

                            "@0,pwm-info", 
                            Buffer (0x18)
                            {
                                /* 0000 */    0x02, 0x18, 0x00, 0x64, 0x90, 0x59, 0x02, 0x00, 
                                /* 0008 */    0x08, 0x52, 0x00, 0x00, 0xA5, 0x1C, 0x00, 0x00, 
                                /* 0010 */    0x00, 0x04, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00
                            }, 

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

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

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

                            "@1,connector-type", 
                            Buffer (0x04)
                            {
                                0x00, 0x08, 0x00, 0x00
                            }, 

                            "NVCAP", 
                            Buffer (0x14)
                            {
                                /* 0000 */    0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 
                                /* 0008 */    0x56, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0A, 
                                /* 0010 */    0x00, 0x00, 0x00, 0x00
                            }, 

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

                            "model", 
                            Buffer (0x18)
                            {
                                "NVIDIA Quadro NVS 4200M"
                            }, 

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

                            "hda-gfx", 
                            Buffer (0x0A)
                            {
                                "onboard-1"
                            }

coolstarorg · June 15, 2015

I have attached both the original DSDT (no GPU injection; laptop display works but recognized as external and no brightness controls) and my current DSDT (GPU injected; laptop display only works after clicking "Detect Displays" and then recognized as internal with working brightness after clicking the button).

I haven't tried HDMI audio just yet (rarely use it; would be nice if it works, but having a working laptop display is more important ATM)

I have tried replacing the DSM method with the one you gave (changed 0x20 to 0x40 since I have a 1 GB video card). It fixed my laptop display but broke DVI out

DSDTs.zip

angelol · June 15, 2015

Try this (fingers crossed ) :

"@0,AAPL,boot-display", 
                            Buffer (0x04)
                            {
                                0x01, 0x00, 0x00, 0x00
                            }, 

                            "@0,backlight-control", 
                            Buffer (0x04)
                            {
                                0x01, 0x00, 0x00, 0x00
                            }, 

                            "@0,built-in", 
                            Buffer (One)
                            {
                                0x00
                            }, 

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

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

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

                            "@0,NVMT", 
                            Buffer (0x60)
                            {
                                /* 0000 */    0x0B, 0x03, 0xFF, 0x20, 0x06, 0xAF, 0x3E, 0x31, 
                                /* 0008 */    0x00, 0x05, 0x20, 0x03, 0x8F, 0x05, 0x30, 0x05, 
                                /* 0010 */    0x50, 0x05, 0x00, 0x00, 0x4E, 0x03, 0x23, 0x03, 
                                /* 0018 */    0x29, 0x03, 0x00, 0x00, 0x20, 0x43, 0x52, 0x04, 
                                /* 0020 */    0x00, 0x00, 0x01, 0x01, 0xE0, 0x00, 0x00, 0x00, 
                                /* 0028 */    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
                                /* 0030 */    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
                                /* 0038 */    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
                                /* 0040 */    0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0x00, 0x00, 
                                /* 0048 */    0x00, 0x00, 0x00, 0x00, 0x40, 0xFF, 0x10, 0x05, 
                                /* 0050 */    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
                                /* 0058 */    0x00, 0x08, 0x00, 0x00, 0x30, 0x01, 0x09, 0x09
                            }, 

                            "@0,pwm-info", 
                            Buffer (0x18)
                            {
                                /* 0000 */    0x02, 0x18, 0x00, 0x64, 0x90, 0x59, 0x02, 0x00, 
                                /* 0008 */    0x08, 0x52, 0x00, 0x00, 0xA5, 0x1C, 0x00, 0x00, 
                                /* 0010 */    0x00, 0x04, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00
                            }, 

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

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

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

                            "@1,connector-type", 
                            Buffer (0x04)
                            {
                                0x00, 0x08, 0x00, 0x00
                            }, 

                            "NVCAP", 
                            Buffer (0x14)
                            {
                                /* 0000 */    0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 
                                /* 0008 */    0x3E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0A, 
                                /* 0010 */    0x00, 0x00, 0x00, 0x00
                            }, 

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

                            "model", 
                            Buffer (0x18)
                            {
                                "NVIDIA Quadro NVS 4200M"
                            }, 

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

                            "hda-gfx", 
                            Buffer (0x0A)
                            {
                                "onboard-1"
                            }

coolstarorg · June 15, 2015

Update: Changed 0x56 in the NVCAP back to 0x3E and DVI1 started working again.

DVI2 is still dead but at least DVI1 is usable and the laptop display starts on boot with working brightness

angelol · June 15, 2015

Try adding this:

 

                            "NVPM", 
                            Buffer (0x20)
                            {
                                /* 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
                            },

First try replacing "@0,pwm-info" with this:

"@0,pwm-info", 
                                Buffer (0x14)
                                {
                                    /* 0000 */    0x01, 0x14, 0x00, 0x64, 0xA8, 0x61, 0x00, 0x00, 
                                    /* 0008 */    0x1C, 0x02, 0x00, 0x00, 0x64, 0x00, 0x00, 0x00, 
                                    /* 0010 */    0x00, 0x04, 0x00, 0x00
                                },

and if it doesn't work, try with this:

"@0,pwm-info", 
                                Buffer (0x14)
                                {
                                    /* 0000 */    0x01, 0x14, 0x00, 0x64, 0xA8, 0x61, 0x00, 0x00, 
                                    /* 0008 */    0x08, 0x52, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 
                                    /* 0010 */    0x00, 0x04, 0x00, 0x00
                                },

angelol · June 15, 2015

Try these 2:

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

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

angelol · June 15, 2015

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

"NVCAP", 
                            Buffer (0x14)
                            {
                                /* 0000 */    0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x00, 
                                /* 0008 */    0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 
                                /* 0010 */    0x00, 0x00, 0x00, 0x00
                            },

coolstarorg · June 15, 2015

Here's a copy of my video BIOS: https://mega.co.nz/#!bVAnXIpY!lOWPGojZVKVpbpepoR0H3fYxItU9rQVWUSoYbRTe47I

dumped from Linux with

mint@mint ~ $ sudo su
mint mint # echo 1 > /sys/devices/pci0000\:00/0000\:00\:01.0/0000\:01\:00.0/rom mint mint # exit
exit
mint@mint ~ $ sudo cat /sys/devices/pci0000\:00/0000\:00\:01.0/0000\:01\:00.0/rom > /home/mint/Desktop/GF119.rom
mint@mint ~ $ sudo su
mint mint # echo 0 > /sys/devices/pci0000\:00/0000\:00\:01.0/0000\:01\:00.0/rom  
mint mint # exit
exit

angelol · June 15, 2015

This should probably work:

"NVCAP", 
Buffer (0x14)
{
/* 0000 */ 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 
/* 0008 */ 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 
/* 0010 */ 0x00, 0x00, 0x00, 0x00
},

Use this kext along with the working DVI + LVDS NVCAP

NVS4200M.kext.zip

coolstarorg · June 15, 2015

This is my current DSDT & clover settings as of now. HDMI works now but no audio. Might be related but onboard audio works intermittently across reboots.

AppleHDA is patched on the fly with Clover EFI and an "injector kext" with the layout XML's.

Also, just tried injecting audio via DSDT layout-id 0xC in HDEF instead of clover EFI injection and it's still intermittent.

DSDT-nvidia.zip

AppleHDA_20672.kext.zip

angelol · June 15, 2015

I removed the intel codec from AppleHDA and fixed HDMI's _DSM.
I think all should be working now

Archive.zip

angelol · June 16, 2015

Try using this SSDT.

SSDT-1.aml.zip

Thinkpad T520 Laptop display doesn't work until "Detect Displays" clicked

Recommended Posts

Link to comment

Share on other sites

Link to comment

Share on other sites

Link to comment

Share on other sites

Link to comment

Share on other sites

Link to comment

Share on other sites

Link to comment

Share on other sites

Link to comment

Share on other sites

Link to comment

Share on other sites

Link to comment

Share on other sites

Link to comment

Share on other sites

Link to comment

Share on other sites

Link to comment

Share on other sites

Link to comment

Share on other sites

Link to comment

Share on other sites

Link to comment

Share on other sites

Link to comment

Share on other sites