Hackintosh Laptop Cihazlarda Pil Göstergesi için DSDT Yamalamak

montezuma

MASTER YODA
Yönetici
19 Eki 2016
17,005
4,081
4,351
OS X kullandığımız laptoplarda pil durumunu çalıştırmak icin ACPI kullanıyoruz. Ancak ne yazık ki PC’lerin pil donanımları Apple’ın SMbus donanımı ile uyumlu degil. Bu gibi problemlerde, genel olarak ‘ACPIBatteryManager.kext’ kullanmanızı öneriyoruz. Kext’i aşağıdaki linkten bulabilirsiniz.

RehabMan/OS-X-ACPI-Battery-Driver · GitHub

AppleACPIPlatform’un
son sürümü, ne yazık ki EC (Embedded Controller) içindeki alanlara doğru erişim sağlayamıyor. Doğru erişim sağlayamayan ACPI metotlarıda ( _BIF, _STA, _BST vb.) ACPIBatteryMenager’da sorunlara yol açar. Her ne kadar AppleACPIPlatform (Snow Leopard’dan) kullanmak mümkünse de, Ivy Bridge CPU’lara sahip sistemlerde doğal güç yönetimi sağlamasına imkan verdiğinden, AppleACPIPlatform son sürümü tercih edilmelidir. Ancak Apple’ın AppleACPIPlatfom.kext’inin son sürümünü kullanmak için DSDT’nin ACPI için uygun olarak düzenlenmesi gerekmektedir.

Özellikle EC içindeki 8.bit den daha büyük alanların, aynı anda 8 Bit'lik alanlara erişebilen hale getirmek gerekiyor. Bunlar, 16, 32, 64 ve daha büyük alanlardır.

Mevcut Yamalar

Herşeyden önce laptop’unuza uygun yama hali hazırda mevcut olabilir. Bu yüzden ilk olarak aşağıdaki linkten sisteminize uygun yamanın olup olmadığını kontrol edebilirsiniz.

https://github.com/RehabMan/Laptop-DSDT-Patch

Bu yamaları MaciASL deposuna yüklemek için;
Öncelikle DSDT’yi bir yama ile düzenlerken, yamanın nasıl yapıldığını bilmeniz gerekiyor. Böylece kendiniz, var olan yamalar ile kendi DSDT’nizi düzenleyebilirsiniz.
Not: MaciASLdışında farklı bir DSDT programı kullanmayın. Hazırladığımız yamaları MaciASL dışında, herhangi bir başka DSDT programı ile test etmedik.

Diğer ilgili DSDT Yamaları

EC alanlarına ek olarak, Batarya durumuna etki eden bir kaç DSDT problemi daha vardır. Bunlar bataryaya özel sorunlar degildir ancak sıklıkla, batarya için yama uygulanırken farkedilir.
Batarya kodu Windows işletim sisteminin versiyonuna bağlıdır. Bunu düzeltmek için, DSDT yama bölümünden OS X Check Fix uygulayın. Bu, DSDT’nin Windows 2006 çalıştığında yapılan eylemleri yapmasına olanak sağlar. Farklı bolümlere etki etmesi için yama değiştirebilirsiniz-(Ornegin Windows 2012)
Bir diğer benzer problem ise, OS X’in ACPI’sini non-Zero SyncLevel ile işaretleyen Mutex Objects uygulama zorluğu. (Daha fazla bilgi için ACPI okuyun.) Bu sorunu cozmek icin yine DSDT-Laptop yama deposundan “ Fix Mutex with non-zero SyncLevel” uygulanır.

DSDT Düzenlemek İçin Bilinmesi Gerekenler
  • DSDT bir programdır. Bu yüzden DSDT düzenlerken az bile olsa programlama ve Bilgisayar modifiyesi hakkında bilgi sahibi olmanız gerekiyor.
  • Ayrıca, her DSDT yamasının kendine özgü dilleri vardır.( Ayrıntılı bakmak için MaciASL)
  • Son olarak, yamalar temelde kapsamlı ara ve degistir search / replace düzenli ifadeleridir(Regex). Bu yüzden Regex’i anlamak size, DSDT düzenlerken çok yardımcı olacaktır.
"Regular expression (Düzenli İfadeler) bir metni düzenlemek yada metin içerisinden belli kurallara uyan alt metinler elde etmek için kullandığımız bir dildir. Bir regular expression, string tipindeki karakter topluluğuna uygulanır. Sonuç olarak substringler oluşur yada orjinal metnin bir kısmını içeren değiştirilmiş yeni metinler elde edilir.” (Düzenli İfadeler(Regular Expressions) Nedir?
  • DSDT dosyası düzenlerken,ortaya çıkabilecek derleme hatalarının ne olduğunu bilmek problemleri anlamanıza yardımcı olur. Welcome to The ACPI Component Architecture Project | The ACPI Component Architecture Project The ACPI Component Architecture Project
  • Ayrıca ACPI hakkında biraz fikir olmanız gerekiyor. Bunun için gerekenleride asağıdaki adresten indirebilirsiniz.
  • Bu rehber size temel ACPI , Programcılık , Düzenli ifadeler (regex ) öğretmek amacı ile hazırlanmamıştır.

Yama İşlemi

Batarya durumu için DSDT yamalarken, işlem boyunca basit bir yöntem kullandık. OS X içinde saldırgan olan bölümleri dönüştürdük. Hangi kod bölümlerinin hangi işlemleri yaptığını anlamak için çok zaman harcamadık. Sadece ne gördüysek onu dönüştürdük.
Bu işlemler boyunca, rehberde paylaştığımız örnek DSDT dosyasını kullanacağız. Dolayısıyla sizde rehberdeki işlemlere başlamadan önce, DSDT dosyasını indirin. Bu örnek DSDT dosyası özellikle HP Envy 14 için. Bunun bitmiş halini ‘HP Envy 14’ olarak yama deposunda bulabilirsiniz.
İlk olarak DSDT içinde değişiklik yapılması gereken yerleri tespit edeceğiz. DSDT dosyanızı MacıASL ile açın ve arama bölümüne “EmbeddedControl” yazın. Tek bir DSDT içinde her biri “EmbeddedControl”ile ilişkili bir kaç tane alan olabilir.
Bu yüzden bu ilişkili alanları bulmak ve düzenlemek için ilk olarak “embeddedcontrol” içinde arama yapıyoruz.

Örnek DSDT içinde EC alanı bulun:
Kod:
OperationRegion (ECF2, EmbeddedControl, Zero, 0xFF)
Yukarıdaki kod, 255 bitlik bir EC bölge tanımlıyor. Ve bunun ECF2 olarak çağrıldığını görüyoruz.
Şimdi biz ‘ECF2 ‘olarak tanımlanmış alanı arayacağız. Örnek DSDT dosyamızda arama yaptığımızda göreceğiniz üzere, bu bölgeye atıfta bulunulan sadece bir alan var. ( Farklı DSDT dosyalarında bu alandan birden fazla olabilir.)
Alan tanımı bize yukarıdaki 255 bitlik EC bölgenin bir açıklamasını verir. Sonuç olarak diyebiliriz ki, ECF2 bu alan ile ilişkilendirilir. Bunu EC içindeki bir yapı olarak düşünün.

Sonraki adım ise alan tanımı içindeki öğeleri inceleyerek, 8 bit'den daha büyük alanları bulmak.
Örnek olarak, ilk alanın açıklaması BDN0,56:
Kod:
 Field (ECF2, ByteAcc, Lock, Preserve)
   {
       Offset (0x10),
       BDN0,   56,
…
Bu, 56 bit'lik bir alan. Eğer 8 bit'den daha büyük bir alan DSDT içine erişiyorsa, bu kodun
alanı tanımlayacak şekilde düzenlenmeye ihtiyacı vardır. Eğer örnek DSDT dosyamızda BDN0 için yaptığınız arama sonuçlarına bakarsanız, aşağıdaki gibi bir tanım göreceksiniz:
Kod:
Store (BDN0, BDN)
Bu “Store”,BDN içine, BDN0 (EC içinde )değerini saklamak icin tasarlanmıştır. Erişilen alanlar 32 bit'den daha büyük ise, bunlara tampon-arabellek(Buffer Type) olarak erişilir. 32 bit yada altındaki alanlara ise, tamsayılar (integar) olarak erişilir. Bunları anlamak, bu kodu değiştirirken çok önemlidir. Arabellek olarak erişimleri düzenlemek biraz daha uğraş gerektirir, bunu belirtelim. Ayrıca şu hatırlatmayı yapmak gerekir. bu kod EC’den okunuyor. Bu yüzden ‘read’ ve ‘write’ farklı olarak ele alınmalıdır.
Buradaki amaç, bu kodun bulunduğu 56 bit (7 bayt) olarak okunan satirin, ayni anda 8 bitlik arabellekleri okuyabilmesini sağlamak. Bu sayede elde edilen arabellek BND içinde depolanabilir / saklanabilir. Bunu nasıl yapacağımıza daha sonra tekrar döneceğiz. Şimdilik geri kalan EC alanlarını ,incelemeye devam edelim.
Şimdi 8 bitden daha büyük alanları görmek için EC’nin geri kalanına bakın.Ve eğer bu alanların erişimleri varsa bunları görmek için ,herbirini DSDT’nin geri kalanında arayın.

Bazı bunlara benzer alanlar erişilebilir değildir. Bunlar icin bir şey yapamayız. Şimdi bir sonraki alanımız olan BMN0 bakalım
Kod:
BMN0,   32,
Eğer DSDT içinde ‘BMN0’ için arama yaparsanız, sadece bu ifadeyi buluruz.Ki buda erişilebilir değildir.Buna dikket etmeye gerek yok. Aynı durum BMN4 içinde geçerlidir. Diğer yandan BCT0 ise BDN0 gibi 128 bitliktir ve erişilebilirdir.
Kod:
Store (BCT0, CTN)
Kapsamlı bir aramada aşağıdaki listeyi göreceksiniz:

Kod:
         BDN0,   56,
                        BCT0,   128,
                        BDN1,   56,
                        BCT1,   128,
...
                        BDC0,   16,
                        BDC1,   16,
                        BFC0,   16,
                        BFC1,   16,
...
                        BDV0,   16,
                        BDV1,   16,
...
                        BPR0,   16,
                        BPR1,   16,

                        BRC0,   16,
                        BRC1,   16,
                        BCC0,   16,
                        BCC1,   16,
                        CV01,   16,
                        CV02,   16,
                        CV03,   16,
                        CV04,   16,
                        CV11,   16,
                        CV12,   16,
                        CV13,   16,
                        CV14,   16,
...
                        BMD0,   16,
                        BMD1,   16,
                        BPV0,   16,
                        BPV1,   16,
                        BSN0,   16,
                        BSN1,   16,
                        BCV0,   16,
                        BCV1,   16,
                        CRG0,   16,
                        CRG1,   16,
                        BTY0,   32,
                        BTY1,   32,
...
                        CBT0,   16,
                        CBT1,   16,
Yukarıdaki listede baktığınızda DSDT içinde düzenlenmesi gereken 16, 32, 56, ve 128 bitlik bir çok farklı boyutta alan olduğunu farkedeceksiniz.

16 ve 32 Bitik Alanlar

16 ve 32 bitlik alanlar daha kolay düzenlenirler. Bu yüzden bizde düzenlemeye bu alanlar ile başlayalım. Üstteki listeden ‘BDC0’ örnek olarak alalım. Simdi amacımız neydi tekrar hatırlayalım: Bu alanı değiştirip iki parçalı hale getirmek( düşük bayt, büyük bayt). Bunu yapmak için, DSDT içinde başka isimler ile çakışmayacak şekilde, parçaların önüne 4’lü karakterler kullanacağız.Bunu yapmanın en kolay yolu, ‘BDC0’ daki ilk harfi kaldırmak ve kalan diğer 3 karakteri kullanmak. Aşağıdaki örneğe bakın:
Kod:
// was: BDC0, 16
   DC00, 8,
   DC01, 8,
Bir yama şöyle görünecek:
Kod:
into device label H_EC code_regex BDC0,\s+16, replace_matched begin DC00,8,DC01,8, end;
Burada yama şunu söylüyor: “H_EC etiketli aygıt içindeki koda bak, "BDC0,<spaces>16," için arama yap ve yerine "DC00,8,DC01,8," koy. Bu şekilde alanımız iki parçaya bölünmüş oluyor. Ancak bu yamayı bu haliyle derleyip DSDT içine modifiye etmeye kalkarsanız, hata alırsınız. Zira bu kod hala BCD0 içine erişir halde. Fakat bu hatalar hangi kodun değiştirilmesi gerektiğini belirlememize de yardımcı olur.
Kod:
Store (BDC0, Index (DerefOf (Index (Local0, 0x02)), Zero))
   Store (ShiftRight (BDC0, 0x08), Index (DerefOf (Index (Local0, 0x02)), One))
Görüldüğü üzere kod iki parçalı ve , BCD0 ‘dan okunuyor. Kolay bir şekilde yama yapılandırması için B1B2 metodu kullanıp bunu DSDT içine yama ile yerleştireceğiz.
Kod:
into method label B1B2 remove_entry;
into definitionblock code_regex . insert
begin
Method (B1B2, 2, NotSerialized) { Return(Or(Arg0, ShiftLeft(Arg1, 8))) }\n
end;
Bu metod iki argümanı alır ( düşük bayt-yüksek bayt) ve 8 bitlik iki degeri 16 bitlik bir değere döndürür.
Şimdi yukarıdaki kod için bunu aşağıdakine çevirmek istiyoruz:
Kod:
Store (B1B2(DC00,DC01), Index (DerefOf (Index (Local0, 0x02)), Zero))
   Store (ShiftRight (B1B2(DC00,DC01), 0x08), Index (DerefOf (Index (Local0, 0x02)), One))
Ayrıca bir yama bu işlemleri otomatik olarak yapmak icin yapılandırabilir.Aşağıdaki göreceğiniz gibi diğer 16 bitlik alan yamaları da aynı modeli takip ederler.
Kod:
into method label GBTI code_regex \(BDC0, replaceall_matched begin (B1B2(DC00,DC01), end;
Dikkatli bir şekilde konuyu takip ederseniz aşağıdaki kodların optimize edilebilir olduklarını farkedeceksiniz:
Kod:
Store (DC00, Index (DerefOf (Index (Local0, 0x02)), Zero))
   Store (DC01, Index (DerefOf (Index (Local0, 0x02)), One))
Burada her kod için beyin jimnastiği yapmak, açıkcası size bir fayda sağlamayacaktır. Burada asıl önemli olan, otomatik düzeltme yöntemini kullanarak, kodları hatasız bir şekilde optimize etmektir. Zira kodları otomatik optimize etmek yerine manuel olarak düzeltmeye çalışırsanız hata yapma olasılığınız çok fazla olacaktır ve yamalarınız hata verecektir. Ayrıca bu kodlar çok nadir kodlardır.

16 bitlik kayıtlar ile nasıl çalışacağımızı anladıysak, hepsini dönüştürmek artık daha kolay olacaktır.
Aşağıda 16 bit EC alanları için kapsamlı yama:
Kod:
# 16-bit registers
into device label H_EC code_regex BDC0,\s+16 replace_matched
begin DC00,8,DC01,8 end;
into device label H_EC code_regex BDC1,\s+16 replace_matched
begin DC10,8,DC11,8 end;
into device label H_EC code_regex BFC0,\s+16 replace_matched
begin FC00,8,FC01,8 end;
into device label H_EC code_regex BFC1,\s+16 replace_matched
begin FC10,8,FC11,8 end;
into device label H_EC code_regex BDV0,\s+16 replace_matched
begin DV00,8,DV01,8 end;
into device label H_EC code_regex BDV1,\s+16 replace_matched
begin DV10,8,DV11,8 end;
into device label H_EC code_regex BPR0,\s+16 replace_matched
begin PR00,8,PR01,8 end;
into device label H_EC code_regex BPR1,\s+16 replace_matched
begin PR10,8,PR11,8 end;
into device label H_EC code_regex BRC0,\s+16 replace_matched
begin RC00,8,RC01,8 end;
into device label H_EC code_regex BRC1,\s+16 replace_matched
begin RC10,8,RC11,8 end;
into device label H_EC code_regex BCC0,\s+16 replace_matched
begin CC00,8,CC01,8 end;
into device label H_EC code_regex BCC1,\s+16 replace_matched
begin CC10,8,CC11,8 end;
into device label H_EC code_regex CV01,\s+16 replace_matched
begin CV10,8,CV11,8 end;
into device label H_EC code_regex CV02,\s+16 replace_matched
begin CV20,8,CV21,8 end;
into device label H_EC code_regex CV03,\s+16 replace_matched
begin CV30,8,CV31,8 end;
into device label H_EC code_regex CV04,\s+16 replace_matched
begin CV40,8,CV41,8 end;
into device label H_EC code_regex CV11,\s+16 replace_matched
begin CV50,8,CV51,8 end;
into device label H_EC code_regex CV12,\s+16 replace_matched
begin CV60,8,CV61,8 end;
into device label H_EC code_regex CV13,\s+16 replace_matched
begin CV70,8,CV71,8 end;
into device label H_EC code_regex CV14,\s+16 replace_matched
begin CV80,8,CV81,8 end;
into device label H_EC code_regex HPBA,\s+16 replace_matched
begin PBA0,8,PBA1,8 end;
into device label H_EC code_regex HPBB,\s+16 replace_matched
begin PBB0,8,PBB1,8 end;
into device label H_EC code_regex BMD0,\s+16 replace_matched
begin MD00,8,MD01,8 end;
into device label H_EC code_regex BMD1,\s+16 replace_matched
begin MD10,8,MD11,8 end;
into device label H_EC code_regex BPV0,\s+16 replace_matched
begin PV00,8,PV01,8 end;
into device label H_EC code_regex BPV1,\s+16 replace_matched
begin PV10,8,PV11,8 end;
into device label H_EC code_regex BSN0,\s+16 replace_matched
begin SN00,8,SN01,8 end;
into device label H_EC code_regex BSN1,\s+16 replace_matched
begin SN10,8,SN11,8 end;
into device label H_EC code_regex BCV0,\s+16 replace_matched
begin BV00,8,BV01,8 end;
into device label H_EC code_regex BCV1,\s+16 replace_matched
begin BV10,8,BV11,8 end;
into device label H_EC code_regex CRG0,\s+16 replace_matched
begin RG00,8,RG01,8 end;
into device label H_EC code_regex CRG1,\s+16 replace_matched
begin RG10,8,RG11,8 end;
into device label H_EC code_regex CBT0,\s+16 replace_matched
begin BT00,8,BT01,8 end;
into device label H_EC code_regex CBT1,\s+16 replace_matched
begin BT10,8,BT11,8 end;
Bu kayıtlara erişen,düzeltilmesi gereken bütün kodlar:
Kod:
# fix 16-bit methods
into method label GBTI code_regex \(BDC0, replaceall_matched
begin (B1B2(DC00,DC01), end;
into method label GBTI code_regex \(BDC1, replaceall_matched
begin (B1B2(DC10,DC11), end;
into method label GBTI code_regex \(BFC0, replaceall_matched
begin (B1B2(FC00,FC01), end;
into method label GBTI code_regex \(BFC1, replaceall_matched
begin (B1B2(FC10,FC11), end;
into method label BTIF code_regex \(BFC0, replaceall_matched
begin (B1B2(FC00,FC01), end;
into method label BTIF code_regex \(BFC1, replaceall_matched
begin (B1B2(FC10,FC11), end;
into method label ITLB code_regex \(BFC1, replaceall_matched
begin (B1B2(FC10,FC11), end;
into method label ITLB code_regex \sBFC0, replaceall_matched
begin B1B2(FC00,FC01), end;
into method label _Q09 code_regex \(BRC0, replaceall_matched
begin (B1B2(RC00,RC01), end;
into method label _Q09 code_regex \sBFC0\) replaceall_matched
begin B1B2(FC00,FC01)) end;
into method label GBTI code_regex \(BDV0, replaceall_matched
begin (B1B2(DV00,DV01), end;
into method label GBTI code_regex \(BDV1, replaceall_matched
begin (B1B2(DV10,DV11), end;
into method label BTIF code_regex \(BDV0, replaceall_matched
begin (B1B2(DV00,DV01), end;
into method label BTIF code_regex \(BDV1, replaceall_matched
begin (B1B2(DV10,DV11), end;
into method label GBTI code_regex \(BPR0, replaceall_matched
begin (B1B2(PR00,PR01), end;
into method label GBTI code_regex \(BPR1, replaceall_matched
begin (B1B2(PR10,PR11), end;
into method label BTST code_regex \sBPR0, replaceall_matched
begin B1B2(PR00,PR01), end;
into method label BTST code_regex \sBPR1, replaceall_matched
begin B1B2(PR10,PR11), end;
into method label BTST code_regex \(BPR0, replaceall_matched
begin (B1B2(PR00,PR01), end;
into method label BTST code_regex \(BPR1, replaceall_matched
begin (B1B2(PR10,PR11), end;
into method label BTST code_regex \(BRC0, replaceall_matched
begin (B1B2(RC00,RC01), end;
into method label BTST code_regex \(BRC1, replaceall_matched
begin (B1B2(RC10,RC11), end;
into method label GBTI code_regex \(BRC0, replaceall_matched
begin (B1B2(RC00,RC01), end;
into method label GBTI code_regex \(BRC1, replaceall_matched
begin (B1B2(RC10,RC11), end;
into method label _Q09 code_regex \(BRC0, replaceall_matched
begin (B1B2(RC00,RC01), end;
into method label GBTI code_regex \(BCC0, replaceall_matched
begin (B1B2(CC00,CC01), end;
into method label GBTI code_regex \(BCC1, replaceall_matched
begin (B1B2(CC10,CC11), end;
into method label GBTI code_regex \(CV01, replaceall_matched
begin (B1B2(CV10,CV11), end;
into method label GBTI code_regex \(CV02, replaceall_matched
begin (B1B2(CV20,CV21), end;
into method label GBTI code_regex \(CV03, replaceall_matched
begin (B1B2(CV30,CV31), end;
into method label GBTI code_regex \(CV04, replaceall_matched
begin (B1B2(CV40,CV41), end;
into method label GBTI code_regex \(CV11, replaceall_matched
begin (B1B2(CV50,CV51), end;
into method label GBTI code_regex \(CV12, replaceall_matched
begin (B1B2(CV60,CV61), end;
into method label GBTI code_regex \(CV13, replaceall_matched
begin (B1B2(CV70,CV71), end;
into method label GBTI code_regex \(CV14, replaceall_matched
begin (B1B2(CV80,CV81), end;
into method label BTIF code_regex \(BMD0, replaceall_matched
begin (B1B2(MD00,MD01), end;
into method label BTIF code_regex \(BMD1, replaceall_matched
begin (B1B2(MD10,MD11), end;
into method label GBTI code_regex \sBMD0\) replaceall_matched
begin B1B2(MD00,MD01)) end;
into method label GBTI code_regex \(BMD0, replaceall_matched
begin (B1B2(MD00,MD01), end;
into method label GBTI code_regex \sBMD1\) replaceall_matched
begin B1B2(MD10,MD11)) end;
into method label GBTI code_regex \(BMD1, replaceall_matched
begin (B1B2(MD10,MD11), end;
into method label BTST code_regex \(BPV0, replaceall_matched
begin (B1B2(PV00,PV01), end;
into method label BTST code_regex \(BPV1, replaceall_matched
begin (B1B2(PV10,PV11), end;
into method label GBTI code_regex \(BPV0, replaceall_matched
begin (B1B2(PV00,PV01), end;
into method label GBTI code_regex \(BPV1, replaceall_matched
begin (B1B2(PV10,PV11), end;
into method label BTIF code_regex \(BSN0, replaceall_matched
begin (B1B2(SN00,SN01), end;
into method label BTIF code_regex \(BSN1, replaceall_matched
begin (B1B2(SN10,SN11), end;
into method label GBTI code_regex \(BSN0, replaceall_matched
begin (B1B2(SN00,SN01), end;
into method label GBTI code_regex \(BSN1, replaceall_matched
begin (B1B2(SN10,SN11), end;
into method label GBTI code_regex \(BCV0, replaceall_matched
begin (B1B2(BV00,BV01), end;
into method label GBTI code_regex \(BCV1, replaceall_matched
begin (B1B2(BV10,BV11), end;
into method label GBTI code_regex \(CRG0, replaceall_matched
begin (B1B2(RG00,RG01), end;
into method label GBTI code_regex \(CRG1, replaceall_matched
begin (B1B2(RG10,RG11), end;
into method label GBTI code_regex \(CBT0, replaceall_matched
begin (B1B2(BT00,BT01), end;
into method label GBTI code_regex \(CBT1, replaceall_matched
begin (B1B2(BT10,BT11), end;
Peki 32 bit kayıtlı kodların, BTY0 ve BTY1’in düzenlemesi? Bunlarda 16 bit ile benzer işlenir. Ancak burada sedece farklı olarak 4 tane 8 bitlik değer ile tek bir 32 bitlik değer yapılandırmak için ‘B1B4’ metodunu kullanacağız.
Kod:
into method label B1B4 remove_entry;
into definitionblock code_regex . insert
begin
Method (B1B4, 4, NotSerialized)\n
{\n
    Store(Arg3, Local0)\n
    Or(Arg2, ShiftLeft(Local0, 8), Local0)\n
    Or(Arg1, ShiftLeft(Local0, 8), Local0)\n
    Or(Arg0, ShiftLeft(Local0, 8), Local0)\n
    Return(Local0)\n
}\n
end;
Şimdi BTY0 ve BTY1’i 4 adet 8-bitlik kayıtlara koymak icin dönüştürmemiz lazım.
Kod:
# 32-bit registers
into device label H_EC code_regex BTY0,\s+32 replace_matched begin TY00,8,TY01,8,TY02,8,TY03,8 end;
into device label H_EC code_regex BTY1,\s+32 replace_matched begin TY10,8,TY11,8,TY12,8,TY13,8 end;
ve GPTI içindeki kodunda düzeltilmesi gerekiyor:

Kod:
   Store (BTY0, BTY)
...
   Store (BTY1, BTYB)
16 bitde yaptığımız gibi yamalıyoruz ancak, 16 bit-de kullandığımız B1B2 yerine B1B4 kullanıyoruz:
Kod:
# fix 32-bit methods
into method label GBTI code_regex \(BTY0, replaceall_matched begin (B1B4(TY00,TY01,TY02,TY03), end;
into method label GBTI code_regex \(BTY1, replaceall_matched begin (B1B4(TY10,TY11,TY12,TY13), end;
Yukarıdaki kodu aşağıdaki gibi degistirir.
Kod:
  Store (B1B4(TY00,TY01,TY02,TY03), BTY)
...
   Store (B1B4(TY10,TY11,TY12,TY13), BTYB)
Arabellek Alanları 32 bit’den büyük alanlar

İlk yaptığımız aramaya dönün ve 8 bit’den büyük alanları bulun. Elimizdeki 32 bit’den büyük alanlar şunlardı:
Kod:
 BCT0,   128,
   BDN1,   56,
   BCT1,   128,
8 Bit’lik bu alanlara ayni anda erişim sıkıntı yaratabilir. Bu yüzden biz bunlara ofsetden erişeceğiz. (Bknz Ofset nedir? ) Varolan kodların bunlara direk erişmediklerinden emin olmak için bunları yeniden isimlendirelim:
Kod:
into device label H_EC code_regex (BDN0,)\s+(56) replace_matched begin BDNX,%2,//%1%2 end;
into device label H_EC code_regex (BDN1,)\s+(56) replace_matched begin BDNY,%2,//%1%2 end;
into device label H_EC code_regex (BCT0,)\s+(128) replace_matched begin BCTX,%2,//%1%2 end;
into device label H_EC code_regex (BCT1,)\s+(128) replace_matched begin BCTY,%2,//%1%2 end;
Şimdi EC icindeki alanlara ofsetlerin yerleştirildiğini belirlemek gerekiyor. Unutmayın, boyutlar bit içinde ancak baytlar ofset içinde. Aşağıdaki yorumda ofsetler 16’lik içinde. Görebileceğiniz üzere hepsi aynı numaralarla geliyorlar.

Kod:
  Field (ECF2, ByteAcc, Lock, Preserve)
   {
            Offset (0x10),
       BDN0,   56,     //!!0x10
            Offset (0x18),
       BME0,   8,
            Offset (0x20),
       BMN0,   32,     //0x20
       BMN2,   8,     //0x24
       BMN4,   88,    //0x25
       BCT0,   128,     //!! 0x30
       BDN1,   56,     //!! 0x40
            Offset (0x48),
       BME1,   8,
            Offset (0x50),
       BMN1,   32,     //0x50
       BMN3,   8,     //0x54
       BMN5,   88,     //0x55
       BCT1,   128,     //!!0x60
Bir kere yamayı çalıştırıp yeniden isimlendirip derledikten sonra, derleyici size, hangi koda dikkat etmeniz gerektiğini söyleyecektir. Bizim durumda bizim kodumuzu şu hatalar ile görüyoruz:
Kod:
...
   Store (BCT0, CTN)
...
   Store (BDN0, BDN)
...
   Store (BCT1, CTNB)
...
   Store (BDN1, BDNB)
…
Bunlarda hatalar var çünkü biz bunları sırasıyla BCT0, BDN0, BCT1, BDN1’ dan BCTX, BDNX, BCTY, BDNY şeklinde yeniden isimlendirdik.

Sizinde gorebileceginiz üzere, bu kod bunları EC ara bellek alanlaıindan okuyor ve bunları
herhangi bir yerde depoluyor. Bu öğeleri aynı anda 8 bit okuması için düzenleme içinde şu yöntemi kullanmalıyız.
Kod:
# utility methods to read/write buffers from/to EC
into method label RE1B parent_label H_EC remove_entry;
into method label RECB parent_label H_EC remove_entry;
into device label H_EC insert
begin
Method (RE1B, 1, NotSerialized)\n
{\n
    OperationRegion(ERAM, EmbeddedControl, Arg0, 1)\n
    Field(ERAM, ByteAcc, NoLock, Preserve) { BYTE, 8 }\n
    Return(BYTE)\n
}\n
Method (RECB, 2, Serialized)\n
// Arg0 - offset in bytes from zero-based EC\n
// Arg1 - size of buffer in bits\n
{\n
    ShiftRight(Arg1, 3, Arg1)\n
    Name(TEMP, Buffer(Arg1) { })\n
    Add(Arg0, Arg1, Arg1)\n
    Store(0, Local0)\n
    While (LLess(Arg0, Arg1))\n
    {\n
        Store(RE1B(Arg0), Index(TEMP, Local0))\n
        Increment(Arg0)\n
        Increment(Local0)\n
    }\n
    Return(TEMP)\n
}\n
end;
RECB “EC Ara bellek oku” anlamına geliyor. Ofsetin alan bit büyüklüğünü okuyabilmesi için iki parametre alması gerekiyor. Bit boyutu ise mutlaka 8’in çarpanları olmalıdır. Zira kod bunu kontrol etmez.
Yardımcı metodların mutlaka EC aygıtı içinde tanınmış olması gerekir. Bu DSDT’de H_EC olarak isimlendirilmiş:

Kod:
Device (H_EC)
                {
                    Name (_HID, EisaId (“PNP0C09"))
Eğer sizdeki EC’nin ismi farklı ise, RECB/RE1B oluşturmak için yamaları değiştirmeniz gerekiyor. Geçerli isimler EC, EC0. Ve bu örnekteki H_EC gibi.
BCT0’nin ilk sorunda bununla basa çıkması için bunu eşdeğer yapmak istiyoruz:
Kod:
Store(RECB(0x30,128), CTN)
0x30 BTC0 alanindaki offset(artik BCTX olarak adlandiriliyor), ve 128 ise bit sayisi oluyor.
Bu düzenlemeler şu yamalar ile başarılı olabilir:
Kod:
into method label GBTI code_regex \(BCT0, replaceall_matched begin (RECB(0x30,128), end;
into method label GBTI code_regex \(BCT1, replaceall_matched begin (RECB(0x60,128), end;
into method label GBTI code_regex \(BDN0, replaceall_matched begin (RECB(0x10,56), end;
into method label GBTI code_regex \(BDN1, replaceall_matched begin (RECB(0x40,56), end;
DSDT artık EC Arabellek’e herhangi bir şey yazmayacaktır. Ancak eğer yazarsa aşağıdaki metod işinize yarayacaktır:
Kod:
into method label WE1B parent_label H_EC remove_entry;
into method label WECB parent_label H_EC remove_entry;
into device label H_EC insert
begin
Method (WE1B, 2, NotSerialized)\n
{\n
    OperationRegion(ERAM, EmbeddedControl, Arg0, 1)\n
    Field(ERAM, ByteAcc, NoLock, Preserve) { BYTE, 8 }\n
    Store(Arg1, BYTE)\n
}\n
Method (WECB, 3, Serialized)\n
// Arg0 - offset in bytes from zero-based EC\n
// Arg1 - size of buffer in bits\n
// Arg2 - value to write\n
{\n
    ShiftRight(Arg1, 3, Arg1)\n
    Name(TEMP, Buffer(Arg1) { })\n
    Store(Arg2, TEMP)\n
    Add(Arg0, Arg1, Arg1)\n
    Store(0, Local0)\n
    While (LLess(Arg0, Arg1))\n
    {\n
        WE1B(Arg0, DerefOf(Index(TEMP, Local0)))\n
        Increment(Arg0)\n
        Increment(Local0)\n
    }\n
}\n
end;
BCT0’a yazılan varsayımsal bir kod satırı düşünün:

Kod:
Store(Local0, BCT0)
Buradaki durumda BCT0 erişimi RECB çağrılarak değiştirilemez. Yazılabilir ancak okunamaz. Bu durumda bunun yerine WECB kullanılmalıdır.
Kod:
WECB(0x30,128, Local0)
WECB içindeki ilk iki parametre, RECB içindekilerle aynıdır.(ofset ve EC alani boyutu) Üçüncü parametrede (Arg2), değeridir ve EC alanına yazılmalıdır. Bizim örnekteki deponun orijinal kaynağı ( depodaki ilk parametre).. Local0
Store, tek ‘AML opcode’ yazabilen değildir. Ayrıca Store tek ‘AMP opcode’ okuyabilen de değildir.
Şöyle bir örneklendirme yapalım:
Kod:
Add(X, Y, Z)
Yukarıda ki örnekte, X’den okur, Y’den okur ekleme işlemini yapar. Ve sonucu Z’ye yazar.

AML işlem kodunun tam olarak ne yaptığından emin değilseniz ACPI tanımlarını okuyun.
www.acpica.org: The ACPI Component Architecture Project
Burada ayrıntılı dokümanları bulabilirsiniz. Ancak bu, bu yazının kapsamında değildir.
Mevcut diz üstü repoları alıştırma ve bilgi edinmek icin en iyi kaynaklardır. Laptop repolarda bir çok WECB/RECB alıştırması ve mevcut yamalar bulabilirsiniz.
example-dst.aml.zip

*Bu rehber ilk olarak tarafımca hazırlanmış olup Technopat üzerinden yayınlanmıştır.
**Rehber Kaynak: Rehabman www.tonymacx86.com: [Guide] How to patch DSDT for working battery status
 
Son düzenleme:
  • Like
Tepkiler: S10soz_21 ve Ediko

Benzer konular

AD Engelleyici Tespit Edildi

Anlıyoruz, reklamlar can sıkıcı!

Elbette, reklam engelleme yazılımı reklamları engelleme konusunda harika bir iş çıkarsa da, web sitemizin faydalı özelliklerini de engeller. En iyi site deneyimi ve bize destek olmak için lütfen AdBlocker’ınızı devre dışı bırakın.

AD Reklam Engelleyiciyi Devre Dışı Bıraktım
Hayır teşekkürler