Chameleon Commit Details - 1804 - Chameleon open source boot loader project.

Date:

2012-01-17 23:32:17 (12 years 3 months ago)

Author:

armel cadet-petit

Commit:

1804

Parents:

1803

Message:

Please, see change log

Changes:

A	/branches/cparm/i386/libsa/udivdi3.c
A	/branches/cparm/i386/libsa/qdivrem.c
A	/branches/cparm/i386/libsa/moddi3.c
A	/branches/cparm/i386/libsaio/arc4random.c
A	/branches/cparm/i386/libsa/bzero.s
A	/branches/cparm/i386/libsa/umoddi3.c
A	/branches/cparm/i386/libsa/divdi3.c
A	/branches/cparm/i386/libsaio/cpu_intel_amd.c
A	/branches/cparm/i386/libsa/bcopy.s
A	/branches/cparm/i386/libsaio/stack_protector.c
A	/branches/cparm/i386/libsa/quad.h
M	/branches/cparm/i386/libsa/string.c
M	/branches/cparm/i386/libsaio/stringTable.c
M	/branches/cparm/i386/boot2/modules.h
M	/branches/cparm/i386/util/Symbols.c
M	/branches/cparm/Chameleon.xcodeproj/project.pbxproj
M	/branches/cparm/i386/modules/SMBiosPatcher/Makefile
M	/branches/cparm/i386/modules/CPUfreq/Makefile
M	/branches/cparm/i386/util/Makefile
M	/branches/cparm/i386/libsaio/disk.c
M	/branches/cparm/i386/modules/Memory/Makefile
M	/branches/cparm/i386/libsaio/Makefile
M	/branches/cparm/i386/libsaio/saio_internal.h
M	/branches/cparm/i386/boot2/options.c
M	/branches/cparm/i386/modules/NetbookInstaller/Makefile
M	/branches/cparm/i386/libsaio/console.c
M	/branches/cparm/i386/boot2/graphics.c
M	/branches/cparm/i386/modules/RamDiskLoader/Makefile
M	/branches/cparm/i386/modules/YellowIconFixer/Makefile
M	/branches/cparm/i386/modules/KextPatcher/Makefile
M	/branches/cparm/i386/libsa/Makefile
M	/branches/cparm/i386/modules/ACPIPatcher/Makefile
M	/branches/cparm/i386/modules/Networking/Makefile
M	/branches/cparm/i386/modules/ACPICodec/acpi_codec.c
M	/branches/cparm/i386/modules/GraphicsEnabler/Makefile
M	/branches/cparm/CHANGES
M	/branches/cparm/i386/libsaio/sys.c
M	/branches/cparm/i386/modules/Keymapper/Makefile
M	/branches/cparm/i386/boot2/drivers.c
M	/branches/cparm/i386/modules/USBFix/Makefile
M	/branches/cparm/i386/modules/HPET/Makefile
M	/branches/cparm/i386/libsaio/saio_types.h
M	/branches/cparm/i386/modules/Resolution/Makefile
M	/branches/cparm/i386/libsaio/fake_efi.c
M	/branches/cparm/i386/modules/KextPatcher/kext_patcher.c
M	/branches/cparm/i386/libsa/setjmp.s
M	/branches/cparm/i386/libsaio/misc.c
M	/branches/cparm/i386/libsa/zalloc.c
M	/branches/cparm/i386/modules/ACPICodec/Makefile
M	/branches/cparm/i386/modules/HelloWorld/Makefile
M	/branches/cparm/i386/modules/GUI/gui.c
M	/branches/cparm/i386/libsa/strtol.c
M	/branches/cparm/i386/boot2/Makefile
M	/branches/cparm/i386/libsa/prf.c
M	/branches/cparm/i386/boot2/boot.c
M	/branches/cparm/i386/modules/GUI/Makefile
M	/branches/cparm/i386/libsa/libsa.h
M	/branches/cparm/i386/libsaio/internal_modules.h
M	/branches/cparm/i386/modules/KernelPatcher/Makefile
M	/branches/cparm/i386/boot2/modules.c
M	/branches/cparm/i386/libsaio/pci.c
M	/branches/cparm/i386/modules/HibernateEnabler/Makefile
M	/branches/cparm/i386/modules/SMBiosGetters/Makefile

File differences

-
2
3
4
5
6
1 7
2 8
3 9
+- Added cpu_intel_amd.c (not by default, you need to edit the makefile in the libsaio directory to compile it)␊
- Implemented a stack_protector (seems to work)␊
- Sync'd libsa with Xnu␊
- Removed lcc_kext dependency from the make file␊
- Fixed some bugs␊
␊
- Updated the default theme to v 1.1 (credit to blackosx)␊
- Updated LogintoLion with he haiku device logo (credit to blackosx)␊
- Updated for the gui ␊
+- Added cpu_intel_amd.c (not by default, you need to edit the makefile in the libsaio directory to compile it)␊
+- Implemented a stack_protector (seems to work)␊
+- Sync'd libsa with Xnu␊
+- Removed lcc_kext dependency from the make file␊
+- Fixed some bugs␊
+␊
 - Updated the default theme to v 1.1 (credit to blackosx)␊
 - Updated LogintoLion with he haiku device logo (credit to blackosx)␊
 - Updated for the gui ␊

-11
12 12
13 13
14 
14
15 15
16 16
17 17
18 
18
19 19
20 20
21 21
... ...
33 33
34 34
35 35
36 
36
37 37
38 38
39 39
+OPTIM = -Os -Oz␊
DEBUG = -DNOTHING␊
#DEBUG = -DDEBUG_CPU=1 -DDEBUG_MEM=1 -DDEBUG_SPD=1 -DDEBUG_PCI=1 -DDEBUG_SMBIOS=1␊
CFLAGS␉= $(RC_CFLAGS) $(OPTIM) $(MORECPP) -arch i386 -g -Wmost \␊
CFLAGS␉= $(RC_CFLAGS) $(OPTIM) $(MORECPP) -arch i386 -g -Wmost -fstack-protector-all \␊
    -D__ARCHITECTURE__=\"i386\" -DSAIO_INTERNAL_USER \␊
    -DRCZ_COMPRESSED_FILE_SUPPORT $(DEBUG) \␊
    -fno-builtin -static $(OMIT_FRAME_POINTER_CFLAG) \␊
    -mpreferred-stack-boundary=2 -fno-align-functions -fno-stack-protector \␊
    -mpreferred-stack-boundary=2 -fno-align-functions \␊
    -march=pentium4 -msse2 -mfpmath=sse -msoft-float  ␊
␊
DEFINES=␊

␊
VPATH = $(OBJROOT):$(SYMROOT)␊
␊
SAIO_OBJS = table.o asm.o bios.o biosfn.o \␊
SAIO_OBJS = table.o asm.o bios.o biosfn.o arc4random.o stack_protector.o \␊
        disk.o sys.o cache.o bootstruct.o \␊
        stringTable.o load.o pci.o allocate.o misc.o \␊
␉␉vbe.o hfs.o hfs_compare.o \␊
 ...
 OPTIM = -Os -Oz␊
 DEBUG = -DNOTHING␊
 #DEBUG = -DDEBUG_CPU=1 -DDEBUG_MEM=1 -DDEBUG_SPD=1 -DDEBUG_PCI=1 -DDEBUG_SMBIOS=1␊
-CFLAGS␉= $(RC_CFLAGS) $(OPTIM) $(MORECPP) -arch i386 -g -Wmost \␊
+CFLAGS␉= $(RC_CFLAGS) $(OPTIM) $(MORECPP) -arch i386 -g -Wmost -fstack-protector-all \␊
     -D__ARCHITECTURE__=\"i386\" -DSAIO_INTERNAL_USER \␊
     -DRCZ_COMPRESSED_FILE_SUPPORT $(DEBUG) \␊
     -fno-builtin -static $(OMIT_FRAME_POINTER_CFLAG) \␊
-    -mpreferred-stack-boundary=2 -fno-align-functions -fno-stack-protector \␊
+    -mpreferred-stack-boundary=2 -fno-align-functions \␊
     -march=pentium4 -msse2 -mfpmath=sse -msoft-float  ␊
 ␊
 DEFINES=␊
 ␊
 VPATH = $(OBJROOT):$(SYMROOT)␊
 ␊
-SAIO_OBJS = table.o asm.o bios.o biosfn.o \␊
+SAIO_OBJS = table.o asm.o bios.o biosfn.o arc4random.o stack_protector.o \␊
         disk.o sys.o cache.o bootstruct.o \␊
         stringTable.o load.o pci.o allocate.o misc.o \␊
 ␉␉vbe.o hfs.o hfs_compare.o \␊

-26
27 27
28 28
29 
30 29
31 30
32 31
+␊
   // Done !!!␊
    ␊
   // ps: i swear the next version will be more simple ␊
}␊
␊
#endif /* __INTERNAL_MODULES_H */
 ␊
    // Done !!!␊
     ␊
-   // ps: i swear the next version will be more simple ␊
 }␊
 ␊
 #endif /* __INTERNAL_MODULES_H */

-196
197 197
198 198
199
199 200
200 201
201 202
... ...
333 334
334 335
335 336
336 
337 
337
338
338 339
339 340
340 341
... ...
375 376
376 377
377 378
378 
379 
379
380
380 381
381 382
382 383
... ...
417 418
418 419
419 420
420 
421
421 422
422 423
423 424
... ...
1049 1050
1050 1051
1051 1052
1052 
1053 
1054 
1055 
1056 
1053
1054
1055
1056
1057
1057 1058
1058 
1059
1059 1060
1060 1061
1061 
1062 
1062
1063
1064
1065
1063 1066
1064 1067
1065 1068
... ...
1519 1522
1520 1523
1521 1524
1525
1526
1527
1528
1529
1530
1531
1532
1533
1534
1535
1536
1537
1538
1539
1540
1541
1542
1543
1544
1545
1546
1547
1548
1549
1522 1550
1523 1551
1524 1552
1525 1553
1526 1554
1527 
1528 1555
1529 1556
1530 1557
... ...
1543 1570
1544 1571
1545 1572
1546 
1573
1574
1547 1575
1548 
1549 
1550 
1551 
1552 
1553 
1554 
1576
1577
1578
1579
1580
1581
1582
1583
1584
1585
1586
1587
1588
1589
1590
1591
1592
1593
1594
1595
1596
1597
1598
1555 1599
1556 1600
1557 1601
... ...
2127 2171
2128 2172
2129 2173
2130 
2174
2131 2175
2132 2176
2133 2177
... ...
2143 2187
2144 2188
2145 2189
2146 
2147 
2190
2191
2148 2192
2149 2193
2150 2194
... ...
2168 2212
2169 2213
2170 2214
2171 
2215
2172 2216
2173 2217
2174 2218
... ...
2183 2227
2184 2228
2185 2229
2186 
2187 
2230
2231
2188 2232
2189 2233
2190 2234
+#ifdef APPLE_PARTITION_MAP_SUPPORT␊
static BVRef diskScanAPMBootVolumes( int biosdev, int * countPtr );␊
#endif␊
static TagPtr XMLGetElementWithID( TagPtr dict, const char* id );␊
static bool getOSVersion(BVRef bvr, char *str);␊
␊
//==========================================================================␊

                rc = 0;␊
                break;␊
            }␊
            error("  EBIOS read error: %s\n", bios_error(rc), rc);␊
            error("    Block 0x%x Sectors %d\n", secno, xnsecs);␊
            printf("  EBIOS read error: %s\n", bios_error(rc), rc);␊
            printf("    Block 0x%x Sectors %d\n", secno, xnsecs);␊
            sleep(1);␊
        }␊
    }␊

                rc = 0;␊
                break;␊
            }␊
            error("  BIOS read error: %s\n", bios_error(rc), rc);␊
            error("    Block %d, Cyl %d Head %d Sector %d\n",␊
            printf("  BIOS read error: %s\n", bios_error(rc), rc);␊
            printf("    Block %d, Cyl %d Head %d Sector %d\n",␊
                  secno, cyl, head, sec);␊
            sleep(1);␊
        }␊

␉if(biosdev >= 0x100 && (execute_hook("isRamDiskRegistred", NULL, NULL, NULL, NULL, NULL, NULL) == EFI_SUCCESS)){␊
␉␊
␉␉int ret = -1;␊
␉␉execute_hook("p_ramdiskReadBytes", &biosdev, &blkno, &byteoff, &byteCount, buffer, &ret);␊
␉␉execute_hook("p_ramdiskReadBytes", &biosdev,  (void*)(unsigned long)&blkno,  &byteoff,  &byteCount, buffer, &ret);␊
␉␉return ret;␊
␉}␊
#endif␉␉␉␊

␉␉␊
␉␉/* Let's try assuming we are on a hybrid HFS/ISO9660 CD. */␊
␉␉bvr = newFDiskBVRef(␊
␉␉␉␉␉␉␉biosdev, 0,␊
␉␉␉␉␉␉␉0,␊
␉␉␉␉␉␉␉&cdpart,␊
␉␉␉␉␉␉␉HFSInitPartition,␊
␉␉␉␉␉␉␉HFSLoadFile,␊
                            biosdev, 0,␊
                            0,␊
                            &cdpart,␊
                            HFSInitPartition,␊
                            HFSLoadFile,␊
                            HFSReadFile,␊
␉␉␉␉␉␉␉HFSGetDirEntry,␊
                            HFSGetDirEntry,␊
                            HFSGetFileBlock,␊
                            HFSGetUUID,␊
␉␉␉␉␉␉␉0,␊
␉␉␉␉␉␉␉kBIOSDevTypeHardDrive);␊
                            HFSGetDescription,␊
                            HFSFree,␊
                            0,␊
                            kBIOSDevTypeHardDrive, 0);␊
␉␉bvr->next = map->bvr;␊
␉␉map->bvr = bvr;␊
␉␉map->bvrcnt++;␊

    }␊
}␊
␊
static TagPtr XMLGetElementWithID( TagPtr dict, const char* id )␊
{␊
␉if(dict->type != kTagTypeArray) return 0;␊
␉␊
␉int element = 0;␊
␉TagPtr tmp = dict->tag;␊
␉int entry_count = XMLTagCount(dict);␊
␉␊
␉while(element < entry_count)␊
␉{␊
␉␉char *Identifier = NULL;␊
␉␉Identifier   = XMLCastString(XMLGetProperty(tmp, (const char*)"Identifier"));␊
␉␉␊
␉␉if (Identifier && (strcmp(Identifier, id) == 0))␊
␉␉{␉␉␉␊
␉␉␉return tmp;␊
␉␉}␊
␉␉␊
␉␉element++;␊
␉␉tmp = tmp->tagNext;␊
␉}␊
␉␊
␉return tmp;␊
}␊
␊
static bool getOSVersion(BVRef bvr, char *str)␊
{␊
␉bool valid = false;␉␊
␉config_file_t systemVersion;␊
␉char  dirSpec[512];␉␊
␉long  flags, time;␊
␉␊
␉sprintf(dirSpec, "hd(%d,%d)/System/Library/CoreServices/SystemVersion.plist", BIOS_DEV_UNIT(bvr), bvr->part_no);␊
␉␊

␉␉}␊
␉␉else ␊
␉␉{␊
␉␉␉sprintf(dirSpec, "hd(%d,%d)/", BIOS_DEV_UNIT(bvr), bvr->part_no);␊
␉␉␉/* Much clean */␊
␉␉␉sprintf(dirSpec, "hd(%d,%d)/Mac OS X Install Data/index.sproduct", BIOS_DEV_UNIT(bvr), bvr->part_no);␊
␉␉␉␊
␉␉␉if (GetFileInfo(dirSpec, "Mac OS X Install Data", &flags, &time) == 0)␊
␉␉␉{␉␊
␉␉␉␉/*** DIRTY HACK (would be better to have a plist) ***/␊
␉␉␉␉*str = '\0';␊
␉␉␉␉strncat(str, "10.7", 4);␊
␉␉␉␉return true;␊
␉␉␉}␊
␉␉␉if (!loadConfigFile(dirSpec, &systemVersion))␊
␉␉␉{␊
␉␉␉␉TagPtr pkg_p = XMLCastArray(XMLGetProperty(systemVersion.dictionary, (const char*)"Packages"));␊
␉␉␉␉␊
␉␉␉␉if (pkg_p)␊
␉␉␉␉{␊
␉␉␉␉␉␊
␉␉␉␉␉char *version = NULL;␊
␉␉␉␉␉␊
␉␉␉␉␉version = XMLCastString(XMLGetProperty(␊
␉␉␉␉␉␉␉␉␉␉␉␉␉␉   XMLGetElementWithID(pkg_p, ␊
␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉   "com.apple.mpkg.OSInstall"), ␊
␉␉␉␉␉␉␉␉␉␉␉␉␉␉   (const char*)"Version"));␊
␉␉␉␉␉␊
␉␉␉␉␉if (version && strlen(version) >= 4) ␊
␉␉␉␉␉{␊
␉␉␉␉␉␉*str = '\0';␊
␉␉␉␉␉␉strncat(str, version, 4);␊
␉␉␉␉␉␉return true;␊
␉␉␉␉␉␉␊
␉␉␉␉␉}␉␉␉␉␉␉␊
␉␉␉␉}␉␉␉␉␉␊
␉␉␉}␉␊
␉␉}␊
␉}␊
␉␊

    int rc;␊
␉␊
    if ((len & (BPS-1)) != 0) {␊
        error("raw disk read not sector aligned");␊
        printf("raw disk read not sector aligned");␊
        return -1;␊
    }␊
    secno += bvr->part_boff;␊

        if ((rc = ebiosread(bvr->biosdev, secno, secs)) != 0) {␊
            /* Ignore corrected ECC errors */␊
            if (rc != ECC_CORRECTED_ERR) {␊
                error("  EBIOS read error: %s\n", bios_error(rc), rc);␊
                error("    Block %d Sectors %d\n", secno, secs);␊
                printf("  EBIOS read error: %s\n", bios_error(rc), rc);␊
                printf("    Block %d Sectors %d\n", secno, secs);␊
                return rc;␊
            }␊
        }␊

    int rc;␊
␉␊
    if ((len & (BPS-1)) != 0) {␊
        error("raw disk write not sector aligned");␊
        printf("raw disk write not sector aligned");␊
        return -1;␊
    }␊
    secno += bvr->part_boff;␊

        bcopy( cbuf, trackbuf, copy_len );␊
        //printf("rdr: ebioswrite(%d, %d, %d)\n", bvr->biosdev, secno, secs);␊
        if ((rc = ebioswrite(bvr->biosdev, secno, secs)) != 0) {␊
            error("  EBIOS write error: %s\n", bios_error(rc), rc);␊
            error("    Block %d Sectors %d\n", secno, secs);␊
            printf("  EBIOS write error: %s\n", bios_error(rc), rc);␊
            printf("    Block %d Sectors %d\n", secno, secs);␊
            return rc;␊
        }␊
        len -= copy_len;␊
 ...
 ...
 ...
 ...
 ...
 ...
 ...
 ...
 ...
 ...
 #ifdef APPLE_PARTITION_MAP_SUPPORT␊
 static BVRef diskScanAPMBootVolumes( int biosdev, int * countPtr );␊
 #endif␊
+static TagPtr XMLGetElementWithID( TagPtr dict, const char* id );␊
 static bool getOSVersion(BVRef bvr, char *str);␊
 ␊
 //==========================================================================␊
                 rc = 0;␊
                 break;␊
             }␊
-            error("  EBIOS read error: %s\n", bios_error(rc), rc);␊
-            error("    Block 0x%x Sectors %d\n", secno, xnsecs);␊
+            printf("  EBIOS read error: %s\n", bios_error(rc), rc);␊
+            printf("    Block 0x%x Sectors %d\n", secno, xnsecs);␊
             sleep(1);␊
         }␊
     }␊
                 rc = 0;␊
                 break;␊
             }␊
-            error("  BIOS read error: %s\n", bios_error(rc), rc);␊
-            error("    Block %d, Cyl %d Head %d Sector %d\n",␊
+            printf("  BIOS read error: %s\n", bios_error(rc), rc);␊
+            printf("    Block %d, Cyl %d Head %d Sector %d\n",␊
                   secno, cyl, head, sec);␊
             sleep(1);␊
         }␊
 ␉if(biosdev >= 0x100 && (execute_hook("isRamDiskRegistred", NULL, NULL, NULL, NULL, NULL, NULL) == EFI_SUCCESS)){␊
 ␉␊
 ␉␉int ret = -1;␊
-␉␉execute_hook("p_ramdiskReadBytes", &biosdev, &blkno, &byteoff, &byteCount, buffer, &ret);␊
+␉␉execute_hook("p_ramdiskReadBytes", &biosdev,  (void*)(unsigned long)&blkno,  &byteoff,  &byteCount, buffer, &ret);␊
 ␉␉return ret;␊
 ␉}␊
 #endif␉␉␉␊
 ␉␉␊
 ␉␉/* Let's try assuming we are on a hybrid HFS/ISO9660 CD. */␊
 ␉␉bvr = newFDiskBVRef(␊
-␉␉␉␉␉␉␉biosdev, 0,␊
-␉␉␉␉␉␉␉0,␊
-␉␉␉␉␉␉␉&cdpart,␊
-␉␉␉␉␉␉␉HFSInitPartition,␊
-␉␉␉␉␉␉␉HFSLoadFile,␊
+                            biosdev, 0,␊
+,␊
+                            &cdpart,␊
+                            HFSInitPartition,␊
+                            HFSLoadFile,␊
                             HFSReadFile,␊
-␉␉␉␉␉␉␉HFSGetDirEntry,␊
+                            HFSGetDirEntry,␊
                             HFSGetFileBlock,␊
                             HFSGetUUID,␊
-␉␉␉␉␉␉␉0,␊
-␉␉␉␉␉␉␉kBIOSDevTypeHardDrive);␊
+                            HFSGetDescription,␊
+                            HFSFree,␊
+,␊
+                            kBIOSDevTypeHardDrive, 0);␊
 ␉␉bvr->next = map->bvr;␊
 ␉␉map->bvr = bvr;␊
 ␉␉map->bvrcnt++;␊
     }␊
 }␊
 ␊
+static TagPtr XMLGetElementWithID( TagPtr dict, const char* id )␊
+{␊
+␉if(dict->type != kTagTypeArray) return 0;␊
+␉␊
+␉int element = 0;␊
+␉TagPtr tmp = dict->tag;␊
+␉int entry_count = XMLTagCount(dict);␊
+␉␊
+␉while(element < entry_count)␊
+␉{␊
+␉␉char *Identifier = NULL;␊
+␉␉Identifier   = XMLCastString(XMLGetProperty(tmp, (const char*)"Identifier"));␊
+␉␉␊
+␉␉if (Identifier && (strcmp(Identifier, id) == 0))␊
+␉␉{␉␉␉␊
+␉␉␉return tmp;␊
+␉␉}␊
+␉␉␊
+␉␉element++;␊
+␉␉tmp = tmp->tagNext;␊
+␉}␊
+␉␊
+␉return tmp;␊
+}␊
+␊
 static bool getOSVersion(BVRef bvr, char *str)␊
 {␊
 ␉bool valid = false;␉␊
 ␉config_file_t systemVersion;␊
 ␉char  dirSpec[512];␉␊
-␉long  flags, time;␊
 ␉␊
 ␉sprintf(dirSpec, "hd(%d,%d)/System/Library/CoreServices/SystemVersion.plist", BIOS_DEV_UNIT(bvr), bvr->part_no);␊
 ␉␊
 ␉␉}␊
 ␉␉else ␊
 ␉␉{␊
-␉␉␉sprintf(dirSpec, "hd(%d,%d)/", BIOS_DEV_UNIT(bvr), bvr->part_no);␊
+␉␉␉/* Much clean */␊
+␉␉␉sprintf(dirSpec, "hd(%d,%d)/Mac OS X Install Data/index.sproduct", BIOS_DEV_UNIT(bvr), bvr->part_no);␊
 ␉␉␉␊
-␉␉␉if (GetFileInfo(dirSpec, "Mac OS X Install Data", &flags, &time) == 0)␊
-␉␉␉{␉␊
-␉␉␉␉/*** DIRTY HACK (would be better to have a plist) ***/␊
-␉␉␉␉*str = '\0';␊
-␉␉␉␉strncat(str, "10.7", 4);␊
-␉␉␉␉return true;␊
-␉␉␉}␊
+␉␉␉if (!loadConfigFile(dirSpec, &systemVersion))␊
+␉␉␉{␊
+␉␉␉␉TagPtr pkg_p = XMLCastArray(XMLGetProperty(systemVersion.dictionary, (const char*)"Packages"));␊
+␉␉␉␉␊
+␉␉␉␉if (pkg_p)␊
+␉␉␉␉{␊
+␉␉␉␉␉␊
+␉␉␉␉␉char *version = NULL;␊
+␉␉␉␉␉␊
+␉␉␉␉␉version = XMLCastString(XMLGetProperty(␊
+␉␉␉␉␉␉␉␉␉␉␉␉␉␉   XMLGetElementWithID(pkg_p, ␊
+␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉   "com.apple.mpkg.OSInstall"), ␊
+␉␉␉␉␉␉␉␉␉␉␉␉␉␉   (const char*)"Version"));␊
+␉␉␉␉␉␊
+␉␉␉␉␉if (version && strlen(version) >= 4) ␊
+␉␉␉␉␉{␊
+␉␉␉␉␉␉*str = '\0';␊
+␉␉␉␉␉␉strncat(str, version, 4);␊
+␉␉␉␉␉␉return true;␊
+␉␉␉␉␉␉␊
+␉␉␉␉␉}␉␉␉␉␉␉␊
+␉␉␉␉}␉␉␉␉␉␊
+␉␉␉}␉␊
 ␉␉}␊
 ␉}␊
 ␉␊
     int rc;␊
 ␉␊
     if ((len & (BPS-1)) != 0) {␊
-        error("raw disk read not sector aligned");␊
+        printf("raw disk read not sector aligned");␊
         return -1;␊
     }␊
     secno += bvr->part_boff;␊
         if ((rc = ebiosread(bvr->biosdev, secno, secs)) != 0) {␊
             /* Ignore corrected ECC errors */␊
             if (rc != ECC_CORRECTED_ERR) {␊
-                error("  EBIOS read error: %s\n", bios_error(rc), rc);␊
-                error("    Block %d Sectors %d\n", secno, secs);␊
+                printf("  EBIOS read error: %s\n", bios_error(rc), rc);␊
+                printf("    Block %d Sectors %d\n", secno, secs);␊
                 return rc;␊
             }␊
         }␊
     int rc;␊
 ␉␊
     if ((len & (BPS-1)) != 0) {␊
-        error("raw disk write not sector aligned");␊
+        printf("raw disk write not sector aligned");␊
         return -1;␊
     }␊
     secno += bvr->part_boff;␊
         bcopy( cbuf, trackbuf, copy_len );␊
         //printf("rdr: ebioswrite(%d, %d, %d)\n", bvr->biosdev, secno, secs);␊
         if ((rc = ebioswrite(bvr->biosdev, secno, secs)) != 0) {␊
-            error("  EBIOS write error: %s\n", bios_error(rc), rc);␊
-            error("    Block %d Sectors %d\n", secno, secs);␊
+            printf("  EBIOS write error: %s\n", bios_error(rc), rc);␊
+            printf("    Block %d Sectors %d\n", secno, secs);␊
             return rc;␊
         }␊
         len -= copy_len;␊

-159
160 160
161 161
162 
162
163 163
164 164
165 165
... ...
195 195
196 196
197 197
198 
198
199 199
200 200
201 201
+char *get_pci_dev_path(pci_dt_t *pci_dt)␊
{␊
␉char* buffer = malloc(sizeof(char) * 256);␊
␊
␉␊
␉pci_dt_t␉*current;␊
␉pci_dt_t␉*end;␊
␉char␉␉tmp[64];␊

␉␊
␉while (current)␊
␉{␉␉␊
␉␉execute_hook("PCIDevice", current, NULL/* &ret*/, NULL, NULL, NULL, NULL);␊
␉␉execute_hook("PCIDevice", (void*)current, NULL, NULL, NULL, NULL, NULL);␊
␉␉␊
␉␉setup_pci_devs(current->children);␊
␉␉current = current->next;␊
 ...
 char *get_pci_dev_path(pci_dt_t *pci_dt)␊
 {␊
 ␉char* buffer = malloc(sizeof(char) * 256);␊
-␊
+␉␊
 ␉pci_dt_t␉*current;␊
 ␉pci_dt_t␉*end;␊
 ␉char␉␉tmp[64];␊
 ␉␊
 ␉while (current)␊
 ␉{␉␉␊
-␉␉execute_hook("PCIDevice", current, NULL/* &ret*/, NULL, NULL, NULL, NULL);␊
+␉␉execute_hook("PCIDevice", (void*)current, NULL, NULL, NULL, NULL, NULL);␊
 ␉␉␊
 ␉␉setup_pci_devs(current->children);␊
 ␉␉current = current->next;␊

-45
46 46
47 47
48 
48
49 49
50 50
51 51
+/*␊
 * Max size fo config data array, in bytes.␊
 */␊
#define IO_CONFIG_DATA_SIZE␉␉4096 // was 163840␊
#define IO_CONFIG_DATA_SIZE␉␉40960 // was 4096 // was 163840␊
␊
#define rand_tab_len 100␊
␊
 /*␊
  * Max size fo config data array, in bytes.␊
  */␊
-#define IO_CONFIG_DATA_SIZE␉␉4096 // was 163840␊
+#define IO_CONFIG_DATA_SIZE␉␉40960 // was 4096 // was 163840␊
 ␊
 #define rand_tab_len 100␊
 ␊

-186
187 187
188 188
189 
189
190 190
191 191
192 192
... ...
253 253
254 254
255 255
256 
256
257 257
258 258
259 259
... ...
286 286
287 287
288 288
289 
289
290 290
291 291
292 292
... ...
308 308
309 309
310 310
311 
312 
313 
314 
315 
316 
317 
318 
319 
320 
321 
322 
323 
324 
325 
326 
327 
328 
329 
330 
331 
332 
333 
334 
335 
336 
337 
338 
339 
340 
341 
342 
343 
344 
345 
346 
347 
348 
349 
350 
351 
352 
353 
354 
355 
356 
357 
358 
359 
360 
361 
362 
363 
364 
365 
366 
367 
368 
369 
370 
371 
372 
373 
374 
375 
376 
377 
378 
379 
380 
381 
382 
383 
384 
385 
386 
387 
388 
389 
390 
391 
392 
393 
394 
395 
396 
397 
398 
399 
400 
401 
402 
403 
404 
405 
406 
407 
408 
409 
410 
411 
412 
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413 413
414 414
415 415
... ...
713 713
714 714
715 715
716 
717 
718 
719 
720 
721 
716
717
718
719
720
721
722 722
723 
724 
725 
726 
727 
728 
723
724
725
726
727
728
729 729
730 730
731 731
732 732
733 
733
734 734
735 735
736 736
737 737
738 738
739 
739
740 740
741 741
742 742
... ...
788 788
789 789
790 790
791 
791
792 792
793 
793
794 794
795 795
796 796
... ...
844 844
845 845
846 846
847 
847
848 848
849 849
850 850
851 851
852 852
853 
853
854 854
855 855
856 856
... ...
869 869
870 870
871 871
872 
872
873 873
874 874
875 875
... ...
907 907
908 908
909 909
910 
910
911 911
912 912
913 913
... ...
933 933
934 934
935 935
936 
936
937 937
938 938
939 939
... ...
954 954
955 955
956 956
957 
957
958 958
959 959
960 960
... ...
968 968
969 969
970 970
971 
971
972 972
973 973
974 974
... ...
993 993
994 994
995 995
996 
996
997 997
998 998
999 999
+        gEfiConfigurationTable64[i].VendorTable = (EFI_PTR32)table;␊
␉␉gNumTables64++ ;␊
␉}    ␊
        ␊
␉␊
    Node *tableNode = DT__AddChild(gEfiConfigurationTableNode, mallocStringForGuid(pGuid));␊
    ␊
    // Use the pointer to the GUID we just stuffed into the system table␊

␉␉num = (EFI_UINTN)gST64->NumberOfTableEntries;        ␊
        ␊
␉}␊
     msglog("EFI Configuration table :\n");␊
␉msglog("EFI Configuration table :\n");␊
    for (i=0; i<num; i++)␊
␉{␊
        if (archCpuType == CPU_TYPE_I386)␊

␉␉{␊
            sprintf(id, "%s", "_MP_");␊
        } ␊
       ␊
␉␉␊
        msglog("table [%d]:%s , 32Bit addr : 0x%x\n",i,id,table);␊
        ␊
    }␊

␊
#define setupEfiTables(mode)                           \␊
{ \␊
␉struct fake_efi_pages \␊
␉{\␊
␉␉/* We use the fake_efi_pages struct so that we only need to do one kernel␊
␉␉ * memory allocation for all needed EFI data.  Otherwise, small allocations␊
␉␉ * like the FIRMWARE_VENDOR string would take up an entire page.␊
␉␉ * NOTE WELL: Do NOT assume this struct has any particular layout within itself.␊
␉␉ * It is absolutely not intended to be publicly exposed anywhere␊
␉␉ * We say pages (plural) although right now we are well within the 1 page size␊
␉␉ * and probably will stay that way.␊
␉␉ */\␊
␉␉EFI_SYSTEM_TABLE_##mode efiSystemTable;\␊
␉␉EFI_RUNTIME_SERVICES_##mode efiRuntimeServices;\␊
␉␉EFI_CONFIGURATION_TABLE_##mode efiConfigurationTable[MAX_CONFIGURATION_TABLE_ENTRIES];\␊
␉␉EFI_CHAR16 firmwareVendor[sizeof(FIRMWARE_VENDOR)/sizeof(EFI_CHAR16)];\␊
␉␉uint8_t voidret_instructions[sizeof(VOIDRET_INSTRUCTIONS)/sizeof(uint8_t)];\␊
␉␉uint8_t unsupportedret_instructions[sizeof(UNSUPPORTEDRET_INSTRUCTIONS)/sizeof(uint8_t)];\␊
␉};\␊
␉struct fake_efi_pages *fakeEfiPages = (struct fake_efi_pages*)AllocateKernelMemory(sizeof(struct fake_efi_pages));\␊
␉/* Zero out all the tables in case fields are added later*/\␊
␉bzero(fakeEfiPages, sizeof(struct fake_efi_pages));\␊
␉/*--------------------------------------------------------------------␊
␉ * Initialize some machine code that will return EFI_UNSUPPORTED for␊
     * functions returning int and simply return for void functions.*/\␊
␉memcpy(fakeEfiPages->voidret_instructions, VOIDRET_INSTRUCTIONS, sizeof(VOIDRET_INSTRUCTIONS));\␊
␉memcpy(fakeEfiPages->unsupportedret_instructions, UNSUPPORTEDRET_INSTRUCTIONS, sizeof(UNSUPPORTEDRET_INSTRUCTIONS));\␊
␉/*--------------------------------------------------------------------␊
␉ * System table*/\␊
␉EFI_SYSTEM_TABLE_##mode *efiSystemTable = gST##mode = &fakeEfiPages->efiSystemTable;\␊
␉efiSystemTable->Hdr.Signature = EFI_SYSTEM_TABLE_SIGNATURE;\␊
␉efiSystemTable->Hdr.Revision = EFI_SYSTEM_TABLE_REVISION;\␊
␉efiSystemTable->Hdr.HeaderSize = sizeof(EFI_SYSTEM_TABLE_##mode);\␊
␉efiSystemTable->Hdr.CRC32 = 0;/*Initialize to zero and then do CRC32*/ \␊
␉efiSystemTable->Hdr.Reserved = 0;\␊
␉efiSystemTable->FirmwareVendor = pto(mode, &fakeEfiPages->firmwareVendor);\␊
␉memcpy(fakeEfiPages->firmwareVendor, FIRMWARE_VENDOR, sizeof(FIRMWARE_VENDOR));\␊
␉efiSystemTable->FirmwareRevision = FIRMWARE_REVISION;\␊
␉/* XXX: We may need to have basic implementations of ConIn/ConOut/StdErr␊
␉ * The EFI spec states that all handles are invalid after boot services have been␊
␉ * exited so we can probably get by with leaving the handles as zero.␊
␉ */\␊
␉efiSystemTable->ConsoleInHandle = 0;\␊
␉efiSystemTable->ConIn = 0;\␊
␉efiSystemTable->ConsoleOutHandle = 0;\␊
␉efiSystemTable->ConOut = 0;\␊
␉efiSystemTable->StandardErrorHandle = 0;\␊
␉efiSystemTable->StdErr = 0;\␊
␉efiSystemTable->RuntimeServices = pto(mode,&fakeEfiPages->efiRuntimeServices) ;\␊
␉/* According to the EFI spec, BootServices aren't valid after the␊
␉ * boot process is exited so we can probably do without it.␊
␉ * Apple didn't provide a definition for it in pexpert/i386/efi.h␊
␉ * so I'm guessing they don't use it.␊
␉ */\␊
␉efiSystemTable->BootServices = 0;\␊
␉efiSystemTable->NumberOfTableEntries = 0;\␊
␉efiSystemTable->ConfigurationTable = pto(mode,fakeEfiPages->efiConfigurationTable);\␊
␉/* We're done. Now CRC32 the thing so the kernel will accept it.␊
␉ * Must be initialized to zero before CRC32, done above.␊
     */\␊
␉gST##mode->Hdr.CRC32 = crc32(0L, gST##mode, gST##mode->Hdr.HeaderSize);\␊
␉/*--------------------------------------------------------------------␊
␉ * Runtime services*/\␊
␉EFI_RUNTIME_SERVICES_##mode *efiRuntimeServices = &fakeEfiPages->efiRuntimeServices;\␊
␉efiRuntimeServices->Hdr.Signature = EFI_RUNTIME_SERVICES_SIGNATURE;\␊
␉efiRuntimeServices->Hdr.Revision = EFI_RUNTIME_SERVICES_REVISION;\␊
␉efiRuntimeServices->Hdr.HeaderSize = sizeof(EFI_RUNTIME_SERVICES_##mode);\␊
␉efiRuntimeServices->Hdr.CRC32 = 0;\␊
␉efiRuntimeServices->Hdr.Reserved = 0;\␊
␉/* There are a number of function pointers in the efiRuntimeServices table.␊
␉ * These are the Foundation (e.g. core) services and are expected to be present on␊
␉ * all EFI-compliant machines.␉Some kernel extensions (notably AppleEFIRuntime)␊
␉ * will call these without checking to see if they are null.␊
␉ *␊
␉ * We don't really feel like doing an EFI implementation in the bootloader␊
␉ * but it is nice if we can at least prevent a complete crash by␊
␉ * at least providing some sort of implementation until one can be provided␊
␉ * nicely in a kext.␊
␉ */\␊
␉void (*voidret_fp)() = (void*)fakeEfiPages->voidret_instructions;\␊
␉void (*unsupportedret_fp)() = (void*)fakeEfiPages->unsupportedret_instructions;\␊
␉efiRuntimeServices->GetTime = pto(mode,unsupportedret_fp);\␊
␉efiRuntimeServices->SetTime = pto(mode,unsupportedret_fp);\␊
␉efiRuntimeServices->GetWakeupTime = pto(mode,unsupportedret_fp);\␊
␉efiRuntimeServices->SetWakeupTime = pto(mode,unsupportedret_fp);\␊
␉efiRuntimeServices->SetVirtualAddressMap = pto(mode,unsupportedret_fp);\␊
␉efiRuntimeServices->ConvertPointer = pto(mode,unsupportedret_fp);\␊
␉efiRuntimeServices->GetVariable = pto(mode,unsupportedret_fp);\␊
␉efiRuntimeServices->GetNextVariableName = pto(mode,unsupportedret_fp);\␊
␉efiRuntimeServices->SetVariable = pto(mode,unsupportedret_fp);\␊
␉efiRuntimeServices->GetNextHighMonotonicCount = pto(mode,unsupportedret_fp);\␊
␉efiRuntimeServices->ResetSystem = pto(mode,voidret_fp);\␊
␉/*We're done.␉Now CRC32 the thing so the kernel will accept it*/\␊
␉efiRuntimeServices->Hdr.CRC32 = crc32(0L, efiRuntimeServices, efiRuntimeServices->Hdr.HeaderSize);\␊
␉/*--------------------------------------------------------------------␊
␉ * Finish filling in the rest of the boot args that we need.*/\␊
␉bootArgs->efiSystemTable = (uint32_t)efiSystemTable;\␊
␉bootArgs->efiMode = kBootArgsEfiMode##mode;\␊
␉/* The bootArgs structure as a whole is bzero'd so we don't need to fill in␊
␉ * things like efiRuntimeServices* and what not.␊
␉ *␊
␉ * In fact, the only code that seems to use that is the hibernate code so it␊
␉ * knows not to save the pages.␉ It even checks to make sure its nonzero.␊
␉*/\␊
struct fake_efi_pages \␊
{\␊
/* We use the fake_efi_pages struct so that we only need to do one kernel␊
* memory allocation for all needed EFI data.  Otherwise, small allocations␊
* like the FIRMWARE_VENDOR string would take up an entire page.␊
* NOTE WELL: Do NOT assume this struct has any particular layout within itself.␊
* It is absolutely not intended to be publicly exposed anywhere␊
* We say pages (plural) although right now we are well within the 1 page size␊
* and probably will stay that way.␊
*/\␊
EFI_SYSTEM_TABLE_##mode efiSystemTable;\␊
EFI_RUNTIME_SERVICES_##mode efiRuntimeServices;\␊
EFI_CONFIGURATION_TABLE_##mode efiConfigurationTable[MAX_CONFIGURATION_TABLE_ENTRIES];\␊
EFI_CHAR16 firmwareVendor[sizeof(FIRMWARE_VENDOR)/sizeof(EFI_CHAR16)];\␊
uint8_t voidret_instructions[sizeof(VOIDRET_INSTRUCTIONS)/sizeof(uint8_t)];\␊
uint8_t unsupportedret_instructions[sizeof(UNSUPPORTEDRET_INSTRUCTIONS)/sizeof(uint8_t)];\␊
};\␊
struct fake_efi_pages *fakeEfiPages = (struct fake_efi_pages*)AllocateKernelMemory(sizeof(struct fake_efi_pages));\␊
/* Zero out all the tables in case fields are added later*/\␊
bzero(fakeEfiPages, sizeof(struct fake_efi_pages));\␊
/*--------------------------------------------------------------------␊
* Initialize some machine code that will return EFI_UNSUPPORTED for␊
* functions returning int and simply return for void functions.*/\␊
memcpy(fakeEfiPages->voidret_instructions, VOIDRET_INSTRUCTIONS, sizeof(VOIDRET_INSTRUCTIONS));\␊
memcpy(fakeEfiPages->unsupportedret_instructions, UNSUPPORTEDRET_INSTRUCTIONS, sizeof(UNSUPPORTEDRET_INSTRUCTIONS));\␊
/*--------------------------------------------------------------------␊
* System table*/\␊
EFI_SYSTEM_TABLE_##mode *efiSystemTable = gST##mode = &fakeEfiPages->efiSystemTable;\␊
efiSystemTable->Hdr.Signature = EFI_SYSTEM_TABLE_SIGNATURE;\␊
efiSystemTable->Hdr.Revision = EFI_SYSTEM_TABLE_REVISION;\␊
efiSystemTable->Hdr.HeaderSize = sizeof(EFI_SYSTEM_TABLE_##mode);\␊
efiSystemTable->Hdr.CRC32 = 0;/*Initialize to zero and then do CRC32*/ \␊
efiSystemTable->Hdr.Reserved = 0;\␊
efiSystemTable->FirmwareVendor = pto(mode, &fakeEfiPages->firmwareVendor);\␊
memcpy(fakeEfiPages->firmwareVendor, FIRMWARE_VENDOR, sizeof(FIRMWARE_VENDOR));\␊
efiSystemTable->FirmwareRevision = FIRMWARE_REVISION;\␊
/* XXX: We may need to have basic implementations of ConIn/ConOut/StdErr␊
* The EFI spec states that all handles are invalid after boot services have been␊
* exited so we can probably get by with leaving the handles as zero.␊
*/\␊
efiSystemTable->ConsoleInHandle = 0;\␊
efiSystemTable->ConIn = 0;\␊
efiSystemTable->ConsoleOutHandle = 0;\␊
efiSystemTable->ConOut = 0;\␊
efiSystemTable->StandardErrorHandle = 0;\␊
efiSystemTable->StdErr = 0;\␊
efiSystemTable->RuntimeServices = pto(mode,&fakeEfiPages->efiRuntimeServices) ;\␊
/* According to the EFI spec, BootServices aren't valid after the␊
* boot process is exited so we can probably do without it.␊
* Apple didn't provide a definition for it in pexpert/i386/efi.h␊
* so I'm guessing they don't use it.␊
*/\␊
efiSystemTable->BootServices = 0;\␊
efiSystemTable->NumberOfTableEntries = 0;\␊
efiSystemTable->ConfigurationTable = pto(mode,fakeEfiPages->efiConfigurationTable);\␊
/* We're done. Now CRC32 the thing so the kernel will accept it.␊
* Must be initialized to zero before CRC32, done above.␊
*/\␊
gST##mode->Hdr.CRC32 = crc32(0L, gST##mode, gST##mode->Hdr.HeaderSize);\␊
/*--------------------------------------------------------------------␊
* Runtime services*/\␊
EFI_RUNTIME_SERVICES_##mode *efiRuntimeServices = &fakeEfiPages->efiRuntimeServices;\␊
efiRuntimeServices->Hdr.Signature = EFI_RUNTIME_SERVICES_SIGNATURE;\␊
efiRuntimeServices->Hdr.Revision = EFI_RUNTIME_SERVICES_REVISION;\␊
efiRuntimeServices->Hdr.HeaderSize = sizeof(EFI_RUNTIME_SERVICES_##mode);\␊
efiRuntimeServices->Hdr.CRC32 = 0;\␊
efiRuntimeServices->Hdr.Reserved = 0;\␊
/* There are a number of function pointers in the efiRuntimeServices table.␊
* These are the Foundation (e.g. core) services and are expected to be present on␊
* all EFI-compliant machines.␉Some kernel extensions (notably AppleEFIRuntime)␊
* will call these without checking to see if they are null.␊
*␊
* We don't really feel like doing an EFI implementation in the bootloader␊
* but it is nice if we can at least prevent a complete crash by␊
* at least providing some sort of implementation until one can be provided␊
* nicely in a kext.␊
*/\␊
void (*voidret_fp)() = (void*)fakeEfiPages->voidret_instructions;\␊
void (*unsupportedret_fp)() = (void*)fakeEfiPages->unsupportedret_instructions;\␊
efiRuntimeServices->GetTime = pto(mode,unsupportedret_fp);\␊
efiRuntimeServices->SetTime = pto(mode,unsupportedret_fp);\␊
efiRuntimeServices->GetWakeupTime = pto(mode,unsupportedret_fp);\␊
efiRuntimeServices->SetWakeupTime = pto(mode,unsupportedret_fp);\␊
efiRuntimeServices->SetVirtualAddressMap = pto(mode,unsupportedret_fp);\␊
efiRuntimeServices->ConvertPointer = pto(mode,unsupportedret_fp);\␊
efiRuntimeServices->GetVariable = pto(mode,unsupportedret_fp);\␊
efiRuntimeServices->GetNextVariableName = pto(mode,unsupportedret_fp);\␊
efiRuntimeServices->SetVariable = pto(mode,unsupportedret_fp);\␊
efiRuntimeServices->GetNextHighMonotonicCount = pto(mode,unsupportedret_fp);\␊
efiRuntimeServices->ResetSystem = pto(mode,voidret_fp);\␊
/*We're done.␉Now CRC32 the thing so the kernel will accept it*/\␊
efiRuntimeServices->Hdr.CRC32 = crc32(0L, efiRuntimeServices, efiRuntimeServices->Hdr.HeaderSize);\␊
/*--------------------------------------------------------------------␊
* Finish filling in the rest of the boot args that we need.*/\␊
bootArgs->efiSystemTable = (uint32_t)efiSystemTable;\␊
bootArgs->efiMode = kBootArgsEfiMode##mode;\␊
/* The bootArgs structure as a whole is bzero'd so we don't need to fill in␊
* things like efiRuntimeServices* and what not.␊
*␊
* In fact, the only code that seems to use that is the hibernate code so it␊
* knows not to save the pages.␉ It even checks to make sure its nonzero.␊
*/\␊
}␊
␊
/*␊

␉␉␉␉DT__AddProperty(chosenNode, kBootUUIDKey, strlen(bootInfo->uuidStr)+1, bootInfo->uuidStr);␊
#if 0␊
␉␉␉if (gRootPath[0])␊
␉␉␉ {␊
␉␉␉ ␊
␉␉␉ DT__AddProperty(chosenNode, "rootpath" or try "root-matching", strlen(gRootPath)+1, gRootPath);␉␉␉␊
␉␉␉ ␊
␉␉␉ } ␊
␉␉␉ else ␊
␉␉␉{␊
␉␉␉␉␊
␉␉␉␉DT__AddProperty(chosenNode, "rootpath" or try "root-matching", strlen(gRootPath)+1, gRootPath);␉␉␉␊
␉␉␉␉␊
␉␉␉} ␊
␉␉␉else ␊
#endif␊
␉␉␉␉ if (gRootDevice)␊
␉␉␉ {␊
␉␉␉␉ ␊
␉␉␉␉ DT__AddProperty(chosenNode, "boot-device-path", strlen(gRootDevice)+1, gRootDevice);␉␉␉␊
␉␉␉␉ ␊
␉␉␉ }␉␉␉␊
␉␉␉␉if (gRootDevice)␊
␉␉␉␉{␊
␉␉␉␉␉␊
␉␉␉␉␉DT__AddProperty(chosenNode, "boot-device-path", strlen(gRootDevice)+1, gRootDevice);␉␉␉␊
␉␉␉␉␉␊
␉␉␉␉}␉␉␉␊
␉␉␉␊
␉␉␉// "boot-file" is not used by kextcache if there is no "boot-device-path" or if there is a valid "rootpath" ,␊
␉␉␉// but i let it by default since it may be used by another service␊
␉␉␉DT__AddProperty(chosenNode, "boot-file", strlen(bootInfo->bootFile)+1, (EFI_CHAR16*)bootInfo->bootFile);␊
␉␉␉␉␉␉␊
␉␉␉␊
␉␉␉if (bootInfo->adler32) ␊
␉␉␉␉DT__AddProperty(chosenNode, "boot-kernelcache-adler32", sizeof(unsigned long), &bootInfo->adler32);␊
␉␉␉␊
␉␉}␊
␉}␉␊
␊
␉␊
␉// We could also just do DT__FindNode("/efi/platform", true)␊
␉// But I think eventually we want to fill stuff in the efi node␊
␉// too so we might as well create it so we have a pointer for it too.␊

␉␉{␊
␉␉␉DT__AddProperty(efiNode, MOTHERBOARD_NAME_PROP, strlen(DefaultPlatform)+1, DefaultPlatform);␊
␉␉}␊
␊
␉␉␊
␉}␊
␊
␉␊
␉// Set up the /efi/configuration-table node which will eventually have several child nodes for␊
␉// all of the configuration tables needed by various kernel extensions.␊
␉gEfiConfigurationTableNode = DT__AddChild(efiNode, "configuration-table");␊

void setupSmbiosConfigFile(const char *filename)␊
{␉␊
␉static bool readSmbConfigFile = true;␊
␊
␉␊
␉if (readSmbConfigFile == true)␊
␉{␊
␉␉char␉␉dirSpecSMBIOS[128] = "";␊
␉␉const char *override_pathname = NULL;␊
␉␉int␉␉␉len = 0, err = 0;␊
␉␊
␉␉␊
␉␉// Take in account user overriding␊
␉␉if (getValueForKey("SMBIOS", &override_pathname, &len, &bootInfo->bootConfig) && len > 0)␊
␉␉{␊

␉␉␉␉err = loadConfigFile(dirSpecSMBIOS, &bootInfo->smbiosConfig);␊
␉␉␉}␊
␉␉}␊
␊
␉␉␊
␉␉if (err)␊
␉␉{␊
␉␉␉verbose("No SMBIOS config file found.\n");␊

␉␉␉␉}␊
␉␉␉␉␊
␉␉␉␉ACPI_TABLE_FACS *FacsPointer = (acpi_tables.FacsPointer64 != (void*)0ul) ? (ACPI_TABLE_FACS *)acpi_tables.FacsPointer64:(ACPI_TABLE_FACS *)acpi_tables.FacsPointer;␊
␉␉␉␉␉␉␉␉␊
␉␉␉␉␊
␉␉␉␉Platform->hardware_signature = FacsPointer->HardwareSignature;␊
␉␉␉␉␊
␉␉␉} while (0);            ␉␊

{␊
    if (smbios_p)␊
        addConfigurationTable(&gEfiSmbiosTableGuid, &smbios_p, NULL);␊
␉␉␊
␉␊
␉if (Platform->CPU.Vendor == 0x756E6547 /* Intel */)␊
␉{␊
␉␉int num_cpus;␊

        }        ␊
#endif               ␊
␉}␉␊
␉␉␊
␉␊
␉// PM_Model␊
␉if (Platform->CPU.isServer == true)␊
    {␊

␉{␊
␉␉Platform->Type = Desktop;␊
␉}␊
␊
␉␊
␉// Invalidate the platform hardware signature (this needs to be verified with acpica, but i guess that 0xFFFFFFFF is an invalid signature)  ␉␊
␉Platform->hardware_signature = 0xFFFFFFFF; ␊
␉␊

{␊
␉// Collect PCI info &| Generate device prop string␊
␉setup_pci_devs(root_pci_dev);␊
␊
␉␊
␉// load smbios.plist file if any␊
␉setupSmbiosConfigFile("SMBIOS.plist");␊
␉setup_Smbios();␊
 ...
 ...
 ...
 ...
 ...
 ...
 ...
 ...
 ...
 ...
 ...
 ...
         gEfiConfigurationTable64[i].VendorTable = (EFI_PTR32)table;␊
 ␉␉gNumTables64++ ;␊
 ␉}    ␊
-        ␊
+␉␊
     Node *tableNode = DT__AddChild(gEfiConfigurationTableNode, mallocStringForGuid(pGuid));␊
     ␊
     // Use the pointer to the GUID we just stuffed into the system table␊
 ␉␉num = (EFI_UINTN)gST64->NumberOfTableEntries;        ␊
         ␊
 ␉}␊
-     msglog("EFI Configuration table :\n");␊
+␉msglog("EFI Configuration table :\n");␊
     for (i=0; i<num; i++)␊
 ␉{␊
         if (archCpuType == CPU_TYPE_I386)␊
 ␉␉{␊
             sprintf(id, "%s", "_MP_");␊
         } ␊
-       ␊
+␉␉␊
         msglog("table [%d]:%s , 32Bit addr : 0x%x\n",i,id,table);␊
         ␊
     }␊
 ␊
 #define setupEfiTables(mode)                           \␊
 { \␊
-␉struct fake_efi_pages \␊
-␉{\␊
-␉␉/* We use the fake_efi_pages struct so that we only need to do one kernel␊
-␉␉ * memory allocation for all needed EFI data.  Otherwise, small allocations␊
-␉␉ * like the FIRMWARE_VENDOR string would take up an entire page.␊
-␉␉ * NOTE WELL: Do NOT assume this struct has any particular layout within itself.␊
-␉␉ * It is absolutely not intended to be publicly exposed anywhere␊
-␉␉ * We say pages (plural) although right now we are well within the 1 page size␊
-␉␉ * and probably will stay that way.␊
-␉␉ */\␊
-␉␉EFI_SYSTEM_TABLE_##mode efiSystemTable;\␊
-␉␉EFI_RUNTIME_SERVICES_##mode efiRuntimeServices;\␊
-␉␉EFI_CONFIGURATION_TABLE_##mode efiConfigurationTable[MAX_CONFIGURATION_TABLE_ENTRIES];\␊
-␉␉EFI_CHAR16 firmwareVendor[sizeof(FIRMWARE_VENDOR)/sizeof(EFI_CHAR16)];\␊
-␉␉uint8_t voidret_instructions[sizeof(VOIDRET_INSTRUCTIONS)/sizeof(uint8_t)];\␊
-␉␉uint8_t unsupportedret_instructions[sizeof(UNSUPPORTEDRET_INSTRUCTIONS)/sizeof(uint8_t)];\␊
-␉};\␊
-␉struct fake_efi_pages *fakeEfiPages = (struct fake_efi_pages*)AllocateKernelMemory(sizeof(struct fake_efi_pages));\␊
-␉/* Zero out all the tables in case fields are added later*/\␊
-␉bzero(fakeEfiPages, sizeof(struct fake_efi_pages));\␊
-␉/*--------------------------------------------------------------------␊
-␉ * Initialize some machine code that will return EFI_UNSUPPORTED for␊
-     * functions returning int and simply return for void functions.*/\␊
-␉memcpy(fakeEfiPages->voidret_instructions, VOIDRET_INSTRUCTIONS, sizeof(VOIDRET_INSTRUCTIONS));\␊
-␉memcpy(fakeEfiPages->unsupportedret_instructions, UNSUPPORTEDRET_INSTRUCTIONS, sizeof(UNSUPPORTEDRET_INSTRUCTIONS));\␊
-␉/*--------------------------------------------------------------------␊
-␉ * System table*/\␊
-␉EFI_SYSTEM_TABLE_##mode *efiSystemTable = gST##mode = &fakeEfiPages->efiSystemTable;\␊
-␉efiSystemTable->Hdr.Signature = EFI_SYSTEM_TABLE_SIGNATURE;\␊
-␉efiSystemTable->Hdr.Revision = EFI_SYSTEM_TABLE_REVISION;\␊
-␉efiSystemTable->Hdr.HeaderSize = sizeof(EFI_SYSTEM_TABLE_##mode);\␊
-␉efiSystemTable->Hdr.CRC32 = 0;/*Initialize to zero and then do CRC32*/ \␊
-␉efiSystemTable->Hdr.Reserved = 0;\␊
-␉efiSystemTable->FirmwareVendor = pto(mode, &fakeEfiPages->firmwareVendor);\␊
-␉memcpy(fakeEfiPages->firmwareVendor, FIRMWARE_VENDOR, sizeof(FIRMWARE_VENDOR));\␊
-␉efiSystemTable->FirmwareRevision = FIRMWARE_REVISION;\␊
-␉/* XXX: We may need to have basic implementations of ConIn/ConOut/StdErr␊
-␉ * The EFI spec states that all handles are invalid after boot services have been␊
-␉ * exited so we can probably get by with leaving the handles as zero.␊
-␉ */\␊
-␉efiSystemTable->ConsoleInHandle = 0;\␊
-␉efiSystemTable->ConIn = 0;\␊
-␉efiSystemTable->ConsoleOutHandle = 0;\␊
-␉efiSystemTable->ConOut = 0;\␊
-␉efiSystemTable->StandardErrorHandle = 0;\␊
-␉efiSystemTable->StdErr = 0;\␊
-␉efiSystemTable->RuntimeServices = pto(mode,&fakeEfiPages->efiRuntimeServices) ;\␊
-␉/* According to the EFI spec, BootServices aren't valid after the␊
-␉ * boot process is exited so we can probably do without it.␊
-␉ * Apple didn't provide a definition for it in pexpert/i386/efi.h␊
-␉ * so I'm guessing they don't use it.␊
-␉ */\␊
-␉efiSystemTable->BootServices = 0;\␊
-␉efiSystemTable->NumberOfTableEntries = 0;\␊
-␉efiSystemTable->ConfigurationTable = pto(mode,fakeEfiPages->efiConfigurationTable);\␊
-␉/* We're done. Now CRC32 the thing so the kernel will accept it.␊
-␉ * Must be initialized to zero before CRC32, done above.␊
-     */\␊
-␉gST##mode->Hdr.CRC32 = crc32(0L, gST##mode, gST##mode->Hdr.HeaderSize);\␊
-␉/*--------------------------------------------------------------------␊
-␉ * Runtime services*/\␊
-␉EFI_RUNTIME_SERVICES_##mode *efiRuntimeServices = &fakeEfiPages->efiRuntimeServices;\␊
-␉efiRuntimeServices->Hdr.Signature = EFI_RUNTIME_SERVICES_SIGNATURE;\␊
-␉efiRuntimeServices->Hdr.Revision = EFI_RUNTIME_SERVICES_REVISION;\␊
-␉efiRuntimeServices->Hdr.HeaderSize = sizeof(EFI_RUNTIME_SERVICES_##mode);\␊
-␉efiRuntimeServices->Hdr.CRC32 = 0;\␊
-␉efiRuntimeServices->Hdr.Reserved = 0;\␊
-␉/* There are a number of function pointers in the efiRuntimeServices table.␊
-␉ * These are the Foundation (e.g. core) services and are expected to be present on␊
-␉ * all EFI-compliant machines.␉Some kernel extensions (notably AppleEFIRuntime)␊
-␉ * will call these without checking to see if they are null.␊
-␉ *␊
-␉ * We don't really feel like doing an EFI implementation in the bootloader␊
-␉ * but it is nice if we can at least prevent a complete crash by␊
-␉ * at least providing some sort of implementation until one can be provided␊
-␉ * nicely in a kext.␊
-␉ */\␊
-␉void (*voidret_fp)() = (void*)fakeEfiPages->voidret_instructions;\␊
-␉void (*unsupportedret_fp)() = (void*)fakeEfiPages->unsupportedret_instructions;\␊
-␉efiRuntimeServices->GetTime = pto(mode,unsupportedret_fp);\␊
-␉efiRuntimeServices->SetTime = pto(mode,unsupportedret_fp);\␊
-␉efiRuntimeServices->GetWakeupTime = pto(mode,unsupportedret_fp);\␊
-␉efiRuntimeServices->SetWakeupTime = pto(mode,unsupportedret_fp);\␊
-␉efiRuntimeServices->SetVirtualAddressMap = pto(mode,unsupportedret_fp);\␊
-␉efiRuntimeServices->ConvertPointer = pto(mode,unsupportedret_fp);\␊
-␉efiRuntimeServices->GetVariable = pto(mode,unsupportedret_fp);\␊
-␉efiRuntimeServices->GetNextVariableName = pto(mode,unsupportedret_fp);\␊
-␉efiRuntimeServices->SetVariable = pto(mode,unsupportedret_fp);\␊
-␉efiRuntimeServices->GetNextHighMonotonicCount = pto(mode,unsupportedret_fp);\␊
-␉efiRuntimeServices->ResetSystem = pto(mode,voidret_fp);\␊
-␉/*We're done.␉Now CRC32 the thing so the kernel will accept it*/\␊
-␉efiRuntimeServices->Hdr.CRC32 = crc32(0L, efiRuntimeServices, efiRuntimeServices->Hdr.HeaderSize);\␊
-␉/*--------------------------------------------------------------------␊
-␉ * Finish filling in the rest of the boot args that we need.*/\␊
-␉bootArgs->efiSystemTable = (uint32_t)efiSystemTable;\␊
-␉bootArgs->efiMode = kBootArgsEfiMode##mode;\␊
-␉/* The bootArgs structure as a whole is bzero'd so we don't need to fill in␊
-␉ * things like efiRuntimeServices* and what not.␊
-␉ *␊
-␉ * In fact, the only code that seems to use that is the hibernate code so it␊
-␉ * knows not to save the pages.␉ It even checks to make sure its nonzero.␊
-␉*/\␊
+struct fake_efi_pages \␊
+{\␊
+/* We use the fake_efi_pages struct so that we only need to do one kernel␊
+* memory allocation for all needed EFI data.  Otherwise, small allocations␊
+* like the FIRMWARE_VENDOR string would take up an entire page.␊
+* NOTE WELL: Do NOT assume this struct has any particular layout within itself.␊
+* It is absolutely not intended to be publicly exposed anywhere␊
+* We say pages (plural) although right now we are well within the 1 page size␊
+* and probably will stay that way.␊
+*/\␊
+EFI_SYSTEM_TABLE_##mode efiSystemTable;\␊
+EFI_RUNTIME_SERVICES_##mode efiRuntimeServices;\␊
+EFI_CONFIGURATION_TABLE_##mode efiConfigurationTable[MAX_CONFIGURATION_TABLE_ENTRIES];\␊
+EFI_CHAR16 firmwareVendor[sizeof(FIRMWARE_VENDOR)/sizeof(EFI_CHAR16)];\␊
+uint8_t voidret_instructions[sizeof(VOIDRET_INSTRUCTIONS)/sizeof(uint8_t)];\␊
+uint8_t unsupportedret_instructions[sizeof(UNSUPPORTEDRET_INSTRUCTIONS)/sizeof(uint8_t)];\␊
+};\␊
+struct fake_efi_pages *fakeEfiPages = (struct fake_efi_pages*)AllocateKernelMemory(sizeof(struct fake_efi_pages));\␊
+/* Zero out all the tables in case fields are added later*/\␊
+bzero(fakeEfiPages, sizeof(struct fake_efi_pages));\␊
+/*--------------------------------------------------------------------␊
+* Initialize some machine code that will return EFI_UNSUPPORTED for␊
+* functions returning int and simply return for void functions.*/\␊
+memcpy(fakeEfiPages->voidret_instructions, VOIDRET_INSTRUCTIONS, sizeof(VOIDRET_INSTRUCTIONS));\␊
+memcpy(fakeEfiPages->unsupportedret_instructions, UNSUPPORTEDRET_INSTRUCTIONS, sizeof(UNSUPPORTEDRET_INSTRUCTIONS));\␊
+/*--------------------------------------------------------------------␊
+* System table*/\␊
+EFI_SYSTEM_TABLE_##mode *efiSystemTable = gST##mode = &fakeEfiPages->efiSystemTable;\␊
+efiSystemTable->Hdr.Signature = EFI_SYSTEM_TABLE_SIGNATURE;\␊
+efiSystemTable->Hdr.Revision = EFI_SYSTEM_TABLE_REVISION;\␊
+efiSystemTable->Hdr.HeaderSize = sizeof(EFI_SYSTEM_TABLE_##mode);\␊
+efiSystemTable->Hdr.CRC32 = 0;/*Initialize to zero and then do CRC32*/ \␊
+efiSystemTable->Hdr.Reserved = 0;\␊
+efiSystemTable->FirmwareVendor = pto(mode, &fakeEfiPages->firmwareVendor);\␊
+memcpy(fakeEfiPages->firmwareVendor, FIRMWARE_VENDOR, sizeof(FIRMWARE_VENDOR));\␊
+efiSystemTable->FirmwareRevision = FIRMWARE_REVISION;\␊
+/* XXX: We may need to have basic implementations of ConIn/ConOut/StdErr␊
+* The EFI spec states that all handles are invalid after boot services have been␊
+* exited so we can probably get by with leaving the handles as zero.␊
+*/\␊
+efiSystemTable->ConsoleInHandle = 0;\␊
+efiSystemTable->ConIn = 0;\␊
+efiSystemTable->ConsoleOutHandle = 0;\␊
+efiSystemTable->ConOut = 0;\␊
+efiSystemTable->StandardErrorHandle = 0;\␊
+efiSystemTable->StdErr = 0;\␊
+efiSystemTable->RuntimeServices = pto(mode,&fakeEfiPages->efiRuntimeServices) ;\␊
+/* According to the EFI spec, BootServices aren't valid after the␊
+* boot process is exited so we can probably do without it.␊
+* Apple didn't provide a definition for it in pexpert/i386/efi.h␊
+* so I'm guessing they don't use it.␊
+*/\␊
+efiSystemTable->BootServices = 0;\␊
+efiSystemTable->NumberOfTableEntries = 0;\␊
+efiSystemTable->ConfigurationTable = pto(mode,fakeEfiPages->efiConfigurationTable);\␊
+/* We're done. Now CRC32 the thing so the kernel will accept it.␊
+* Must be initialized to zero before CRC32, done above.␊
+*/\␊
+gST##mode->Hdr.CRC32 = crc32(0L, gST##mode, gST##mode->Hdr.HeaderSize);\␊
+/*--------------------------------------------------------------------␊
+* Runtime services*/\␊
+EFI_RUNTIME_SERVICES_##mode *efiRuntimeServices = &fakeEfiPages->efiRuntimeServices;\␊
+efiRuntimeServices->Hdr.Signature = EFI_RUNTIME_SERVICES_SIGNATURE;\␊
+efiRuntimeServices->Hdr.Revision = EFI_RUNTIME_SERVICES_REVISION;\␊
+efiRuntimeServices->Hdr.HeaderSize = sizeof(EFI_RUNTIME_SERVICES_##mode);\␊
+efiRuntimeServices->Hdr.CRC32 = 0;\␊
+efiRuntimeServices->Hdr.Reserved = 0;\␊
+/* There are a number of function pointers in the efiRuntimeServices table.␊
+* These are the Foundation (e.g. core) services and are expected to be present on␊
+* all EFI-compliant machines.␉Some kernel extensions (notably AppleEFIRuntime)␊
+* will call these without checking to see if they are null.␊
+*␊
+* We don't really feel like doing an EFI implementation in the bootloader␊
+* but it is nice if we can at least prevent a complete crash by␊
+* at least providing some sort of implementation until one can be provided␊
+* nicely in a kext.␊
+*/\␊
+void (*voidret_fp)() = (void*)fakeEfiPages->voidret_instructions;\␊
+void (*unsupportedret_fp)() = (void*)fakeEfiPages->unsupportedret_instructions;\␊
+efiRuntimeServices->GetTime = pto(mode,unsupportedret_fp);\␊
+efiRuntimeServices->SetTime = pto(mode,unsupportedret_fp);\␊
+efiRuntimeServices->GetWakeupTime = pto(mode,unsupportedret_fp);\␊
+efiRuntimeServices->SetWakeupTime = pto(mode,unsupportedret_fp);\␊
+efiRuntimeServices->SetVirtualAddressMap = pto(mode,unsupportedret_fp);\␊
+efiRuntimeServices->ConvertPointer = pto(mode,unsupportedret_fp);\␊
+efiRuntimeServices->GetVariable = pto(mode,unsupportedret_fp);\␊
+efiRuntimeServices->GetNextVariableName = pto(mode,unsupportedret_fp);\␊
+efiRuntimeServices->SetVariable = pto(mode,unsupportedret_fp);\␊
+efiRuntimeServices->GetNextHighMonotonicCount = pto(mode,unsupportedret_fp);\␊
+efiRuntimeServices->ResetSystem = pto(mode,voidret_fp);\␊
+/*We're done.␉Now CRC32 the thing so the kernel will accept it*/\␊
+efiRuntimeServices->Hdr.CRC32 = crc32(0L, efiRuntimeServices, efiRuntimeServices->Hdr.HeaderSize);\␊
+/*--------------------------------------------------------------------␊
+* Finish filling in the rest of the boot args that we need.*/\␊
+bootArgs->efiSystemTable = (uint32_t)efiSystemTable;\␊
+bootArgs->efiMode = kBootArgsEfiMode##mode;\␊
+/* The bootArgs structure as a whole is bzero'd so we don't need to fill in␊
+* things like efiRuntimeServices* and what not.␊
+*␊
+* In fact, the only code that seems to use that is the hibernate code so it␊
+* knows not to save the pages.␉ It even checks to make sure its nonzero.␊
+*/\␊
 }␊
 ␊
 /*␊
 ␉␉␉␉DT__AddProperty(chosenNode, kBootUUIDKey, strlen(bootInfo->uuidStr)+1, bootInfo->uuidStr);␊
 #if 0␊
 ␉␉␉if (gRootPath[0])␊
-␉␉␉ {␊
-␉␉␉ ␊
-␉␉␉ DT__AddProperty(chosenNode, "rootpath" or try "root-matching", strlen(gRootPath)+1, gRootPath);␉␉␉␊
-␉␉␉ ␊
-␉␉␉ } ␊
-␉␉␉ else ␊
+␉␉␉{␊
+␉␉␉␉␊
+␉␉␉␉DT__AddProperty(chosenNode, "rootpath" or try "root-matching", strlen(gRootPath)+1, gRootPath);␉␉␉␊
+␉␉␉␉␊
+␉␉␉} ␊
+␉␉␉else ␊
 #endif␊
-␉␉␉␉ if (gRootDevice)␊
-␉␉␉ {␊
-␉␉␉␉ ␊
-␉␉␉␉ DT__AddProperty(chosenNode, "boot-device-path", strlen(gRootDevice)+1, gRootDevice);␉␉␉␊
-␉␉␉␉ ␊
-␉␉␉ }␉␉␉␊
+␉␉␉␉if (gRootDevice)␊
+␉␉␉␉{␊
+␉␉␉␉␉␊
+␉␉␉␉␉DT__AddProperty(chosenNode, "boot-device-path", strlen(gRootDevice)+1, gRootDevice);␉␉␉␊
+␉␉␉␉␉␊
+␉␉␉␉}␉␉␉␊
 ␉␉␉␊
 ␉␉␉// "boot-file" is not used by kextcache if there is no "boot-device-path" or if there is a valid "rootpath" ,␊
 ␉␉␉// but i let it by default since it may be used by another service␊
 ␉␉␉DT__AddProperty(chosenNode, "boot-file", strlen(bootInfo->bootFile)+1, (EFI_CHAR16*)bootInfo->bootFile);␊
-␉␉␉␉␉␉␊
+␉␉␉␊
 ␉␉␉if (bootInfo->adler32) ␊
 ␉␉␉␉DT__AddProperty(chosenNode, "boot-kernelcache-adler32", sizeof(unsigned long), &bootInfo->adler32);␊
 ␉␉␉␊
 ␉␉}␊
 ␉}␉␊
-␊
+␉␊
 ␉// We could also just do DT__FindNode("/efi/platform", true)␊
 ␉// But I think eventually we want to fill stuff in the efi node␊
 ␉// too so we might as well create it so we have a pointer for it too.␊
 ␉␉{␊
 ␉␉␉DT__AddProperty(efiNode, MOTHERBOARD_NAME_PROP, strlen(DefaultPlatform)+1, DefaultPlatform);␊
 ␉␉}␊
-␊
+␉␉␊
 ␉}␊
-␊
+␉␊
 ␉// Set up the /efi/configuration-table node which will eventually have several child nodes for␊
 ␉// all of the configuration tables needed by various kernel extensions.␊
 ␉gEfiConfigurationTableNode = DT__AddChild(efiNode, "configuration-table");␊
 void setupSmbiosConfigFile(const char *filename)␊
 {␉␊
 ␉static bool readSmbConfigFile = true;␊
-␊
+␉␊
 ␉if (readSmbConfigFile == true)␊
 ␉{␊
 ␉␉char␉␉dirSpecSMBIOS[128] = "";␊
 ␉␉const char *override_pathname = NULL;␊
 ␉␉int␉␉␉len = 0, err = 0;␊
-␉␊
+␉␉␊
 ␉␉// Take in account user overriding␊
 ␉␉if (getValueForKey("SMBIOS", &override_pathname, &len, &bootInfo->bootConfig) && len > 0)␊
 ␉␉{␊
 ␉␉␉␉err = loadConfigFile(dirSpecSMBIOS, &bootInfo->smbiosConfig);␊
 ␉␉␉}␊
 ␉␉}␊
-␊
+␉␉␊
 ␉␉if (err)␊
 ␉␉{␊
 ␉␉␉verbose("No SMBIOS config file found.\n");␊
 ␉␉␉␉}␊
 ␉␉␉␉␊
 ␉␉␉␉ACPI_TABLE_FACS *FacsPointer = (acpi_tables.FacsPointer64 != (void*)0ul) ? (ACPI_TABLE_FACS *)acpi_tables.FacsPointer64:(ACPI_TABLE_FACS *)acpi_tables.FacsPointer;␊
-␉␉␉␉␉␉␉␉␊
+␉␉␉␉␊
 ␉␉␉␉Platform->hardware_signature = FacsPointer->HardwareSignature;␊
 ␉␉␉␉␊
 ␉␉␉} while (0);            ␉␊
 {␊
     if (smbios_p)␊
         addConfigurationTable(&gEfiSmbiosTableGuid, &smbios_p, NULL);␊
-␉␉␊
+␉␊
 ␉if (Platform->CPU.Vendor == 0x756E6547 /* Intel */)␊
 ␉{␊
 ␉␉int num_cpus;␊
         }        ␊
 #endif               ␊
 ␉}␉␊
-␉␉␊
+␉␊
 ␉// PM_Model␊
 ␉if (Platform->CPU.isServer == true)␊
     {␊
 ␉{␊
 ␉␉Platform->Type = Desktop;␊
 ␉}␊
-␊
+␉␊
 ␉// Invalidate the platform hardware signature (this needs to be verified with acpica, but i guess that 0xFFFFFFFF is an invalid signature)  ␉␊
 ␉Platform->hardware_signature = 0xFFFFFFFF; ␊
 ␉␊
 {␊
 ␉// Collect PCI info &| Generate device prop string␊
 ␉setup_pci_devs(root_pci_dev);␊
-␊
+␉␊
 ␉// load smbios.plist file if any␊
 ␉setupSmbiosConfigFile("SMBIOS.plist");␊
 ␉setup_Smbios();␊

-178
179 179
180 180
181 
182 
183 
184 
181
185 182
186 183
187 184
+␊
int random (struct ran_obj* self)␊
{␊
␉␊
␉//struct ran_opt * ret = (struct ran_opt * )malloc(sizeof(struct ran_opt));␊
␉//ret = rt ;␊
␉␊
␉␉␊
    struct ran_obj * ret = self ;␊
    ␊
␉static int wheel = 0;␊
 ␊
 int random (struct ran_obj* self)␊
 {␊
-␉␊
-␉//struct ran_opt * ret = (struct ran_opt * )malloc(sizeof(struct ran_opt));␊
-␉//ret = rt ;␊
-␉␊
+␉␉␊
     struct ran_obj * ret = self ;␊
     ␊
 ␉static int wheel = 0;␊

-27
28 28
29 29
30
31
32
33
30 34
31 35
32 36
... ...
101 105
102 106
103 107
108
104 109
105 110
106 111
... ...
122 127
123 128
124 129
125 
130
126 131
127 
132
128 133
129 
134
130 135
131 136
132 137
... ...
184 189
185 190
186 191
192
193
194
187 195
188 196
189 197
+␊
#include "saio_types.h"␊
␊
/* arc4random.c */␊
extern void   arc4rand(void *ptr, u_int len, int reseed);␊
extern uint32_t  arc4random(void);␊
␊
/* asm.s */␊
extern void   real_to_prot(void);␊
extern void   prot_to_real(void);␊

extern int    error(const char *format, ...);␊
extern int    verbose(const char *format, ...);␊
extern void   stop(const char *format, ...);␊
extern char * newStringWithFormat(const char * fmt, ...);␊
␊
/* disk.c */␊
extern void rescanBIOSDevice(int biosdev);␊

␊
/* hfs_compare.c */␊
extern int32_t FastUnicodeCompare(u_int16_t *uniStr1, u_int32_t len1,␊
␉␉␉␉␉␉␉   u_int16_t *uniStr2, u_int32_t len2, int byte_order);␊
␉␉␉␉␉␉␉␉  u_int16_t *uniStr2, u_int32_t len2, int byte_order);␊
extern void utf_encodestr( const u_int16_t * ucsp, int ucslen,␊
                u_int8_t * utf8p, u_int32_t bufsize, int byte_order );␊
␉␉␉␉␉␉  u_int8_t * utf8p, u_int32_t bufsize, int byte_order );␊
extern void utf_decodestr(const u_int8_t *utf8p, u_int16_t *ucsp,␊
                u_int16_t *ucslen, u_int32_t bufsize, int byte_order );␊
␉␉␉␉␉␉  u_int16_t *ucslen, u_int32_t bufsize, int byte_order );␊
␊
/* load.c */␊
extern bool   gHaveKernelCache;␊

#endif␊
extern int    loadOverrideConfig(config_file_t *configBuff);␊
extern char * newString(const char *oldString);␊
extern char * newEmptyStringWithLength(int len);␊
extern char * newStringWithLength(const char * oldString, int len);␊
␊
extern char * getNextArg(char ** ptr, char * val);␊
extern int␉  ParseXMLFile( char * buffer, TagPtr * dict );␊
␊
 ...
 ...
 ...
 ␊
 #include "saio_types.h"␊
 ␊
+/* arc4random.c */␊
+extern void   arc4rand(void *ptr, u_int len, int reseed);␊
+extern uint32_t  arc4random(void);␊
+␊
 /* asm.s */␊
 extern void   real_to_prot(void);␊
 extern void   prot_to_real(void);␊
 extern int    error(const char *format, ...);␊
 extern int    verbose(const char *format, ...);␊
 extern void   stop(const char *format, ...);␊
+extern char * newStringWithFormat(const char * fmt, ...);␊
 ␊
 /* disk.c */␊
 extern void rescanBIOSDevice(int biosdev);␊
 ␊
 /* hfs_compare.c */␊
 extern int32_t FastUnicodeCompare(u_int16_t *uniStr1, u_int32_t len1,␊
-␉␉␉␉␉␉␉   u_int16_t *uniStr2, u_int32_t len2, int byte_order);␊
+␉␉␉␉␉␉␉␉  u_int16_t *uniStr2, u_int32_t len2, int byte_order);␊
 extern void utf_encodestr( const u_int16_t * ucsp, int ucslen,␊
-                u_int8_t * utf8p, u_int32_t bufsize, int byte_order );␊
+␉␉␉␉␉␉  u_int8_t * utf8p, u_int32_t bufsize, int byte_order );␊
 extern void utf_decodestr(const u_int8_t *utf8p, u_int16_t *ucsp,␊
-                u_int16_t *ucslen, u_int32_t bufsize, int byte_order );␊
+␉␉␉␉␉␉  u_int16_t *ucslen, u_int32_t bufsize, int byte_order );␊
 ␊
 /* load.c */␊
 extern bool   gHaveKernelCache;␊
 #endif␊
 extern int    loadOverrideConfig(config_file_t *configBuff);␊
 extern char * newString(const char *oldString);␊
+extern char * newEmptyStringWithLength(int len);␊
+extern char * newStringWithLength(const char * oldString, int len);␊
+␊
 extern char * getNextArg(char ** ptr, char * val);␊
 extern int␉  ParseXMLFile( char * buffer, TagPtr * dict );␊
 ␊

-142
143 143
144 144
145 
145
146 146
147 147
148 148
... ...
168 168
169 169
170 170
171 
171
172 172
173 173
174 174
... ...
241 241
242 242
243 243
244 
244
245 245
246 246
247 247
... ...
263 263
264 264
265 265
266 
266
267 267
268 268
269 269
... ...
615 615
616 616
617 617
618 
618
619 619
620 620
621 621
... ...
669 669
670 670
671 671
672 
672
673 673
674 674
675 675
676 
676
677 677
678 678
679 679
+␉␊
    //bzero( outModeInfo, sizeof(*outModeInfo) );␊
␉bzero( outModeInfo, sizeof(VBEModeInfoBlock) );␊
␊
␉␊
    // Get VBE controller info containing the list of supported modes.␊
␉␊
    //bzero( &vbeInfo, sizeof(vbeInfo) );␊

␉␉␊
        //bzero( &modeInfo, sizeof(modeInfo) );␊
        bzero( &modeInfo, sizeof(VBEModeInfoBlock) );␊
␊
␉␉␊
        err = getVBEModeInfo( *modePtr, &modeInfo );␊
        if ( err != errSuccess )␊
        {␊

            matchedMode = *modePtr;␊
            //bcopy( &modeInfo, outModeInfo, sizeof(modeInfo) );            ␊
            bcopy( &modeInfo, outModeInfo, sizeof(VBEModeInfoBlock) );␊
␊
␉␉␉␊
            break;␊
        }␊
␉␉␊

        matchedMode = *modePtr;␊
        //bcopy( &modeInfo, outModeInfo, sizeof(modeInfo) );␊
        bcopy( &modeInfo, outModeInfo, sizeof(VBEModeInfoBlock) );␊
␊
␉␉␊
    }␊
␉␊
    return matchedMode;␊

    unsigned long params[4];␊
    int           count;␊
    int           err = errSuccess;␊
␊
␉␊
    if ( mode == GRAPHICS_MODE )␊
    {␊
  ␉␉if ( (err=initGraphicsMode ()) == errSuccess ) {␊

spinActivityIndicator(int sectors)␊
{␊
    static unsigned long lastTickTime = 0, currentTickTime;␊
␊
␉␊
␉bool doreturn = false;␊
␉execute_hook("spinActivity_hook", &sectors, &doreturn, NULL, NULL, NULL, NULL);␊
␉if (doreturn == true) return;␊
␊
␉␊
␉currentTickTime = time18(); // late binding␊
␉if (currentTickTime < lastTickTime + MIN_TICKS)␊
␉{␊
 ...
 ...
 ...
 ...
 ...
 ␉␊
     //bzero( outModeInfo, sizeof(*outModeInfo) );␊
 ␉bzero( outModeInfo, sizeof(VBEModeInfoBlock) );␊
-␊
+␉␊
     // Get VBE controller info containing the list of supported modes.␊
 ␉␊
     //bzero( &vbeInfo, sizeof(vbeInfo) );␊
 ␉␉␊
         //bzero( &modeInfo, sizeof(modeInfo) );␊
         bzero( &modeInfo, sizeof(VBEModeInfoBlock) );␊
-␊
+␉␉␊
         err = getVBEModeInfo( *modePtr, &modeInfo );␊
         if ( err != errSuccess )␊
         {␊
             matchedMode = *modePtr;␊
             //bcopy( &modeInfo, outModeInfo, sizeof(modeInfo) );            ␊
             bcopy( &modeInfo, outModeInfo, sizeof(VBEModeInfoBlock) );␊
-␊
+␉␉␉␊
             break;␊
         }␊
 ␉␉␊
         matchedMode = *modePtr;␊
         //bcopy( &modeInfo, outModeInfo, sizeof(modeInfo) );␊
         bcopy( &modeInfo, outModeInfo, sizeof(VBEModeInfoBlock) );␊
-␊
+␉␉␊
     }␊
 ␉␊
     return matchedMode;␊
     unsigned long params[4];␊
     int           count;␊
     int           err = errSuccess;␊
-␊
+␉␊
     if ( mode == GRAPHICS_MODE )␊
     {␊
   ␉␉if ( (err=initGraphicsMode ()) == errSuccess ) {␊
 spinActivityIndicator(int sectors)␊
 {␊
     static unsigned long lastTickTime = 0, currentTickTime;␊
-␊
+␉␊
 ␉bool doreturn = false;␊
 ␉execute_hook("spinActivity_hook", &sectors, &doreturn, NULL, NULL, NULL, NULL);␊
 ␉if (doreturn == true) return;␊
-␊
+␉␊
 ␉currentTickTime = time18(); // late binding␊
 ␉if (currentTickTime < lastTickTime + MIN_TICKS)␊
 ␉{␊

-1030
1031 1031
1032 1032
1033 
1033
1034
1034 1035
1035 1036
1036 1037
1037 1038
1038 1039
1039 
1040
1041
1040 1042
1041 1043
1042 1044
... ...
1055 1057
1056 1058
1057 1059
1060
1061
1062
1063
1058 1064
1059 1065
1060 1066
+␉␉␉␉{␊
␉␉␉␉␉if (strcmp(name, name_compare) == 0)␊
␉␉␉␉␉{␊
␉␉␉␉␉␉DBG("found : %s\n", name);␉␊
␉␉␉␉␉␉DBG("found : %s\n", name);␊
␉␉␉␉␉␉closedir(moduleDir);␊
␉␉␉␉␉␉return true;␊
␉␉␉␉␉}␊
␉␉␉␉}␊
␉␉␉␉else␊
␉␉␉␉{␊
␉␉␉␉␉DBG("found : %s\n", name);␉␊
␉␉␉␉␉DBG("found : %s\n", name);␊
␉␉␉␉␉closedir(moduleDir);␊
␉␉␉␉␉return true;␊
␉␉␉␉}␉␉␉␊
␉␉␉}␊

#endif␉␉␊
␉}␊
␉␊
␉if (moduleDir) {␊
␉␉closedir(moduleDir);␊
␉␉␊
␉}␊
␉return false;␊
}␊
␊
 ...
 ␉␉␉␉{␊
 ␉␉␉␉␉if (strcmp(name, name_compare) == 0)␊
 ␉␉␉␉␉{␊
-␉␉␉␉␉␉DBG("found : %s\n", name);␉␊
+␉␉␉␉␉␉DBG("found : %s\n", name);␊
+␉␉␉␉␉␉closedir(moduleDir);␊
 ␉␉␉␉␉␉return true;␊
 ␉␉␉␉␉}␊
 ␉␉␉␉}␊
 ␉␉␉␉else␊
 ␉␉␉␉{␊
-␉␉␉␉␉DBG("found : %s\n", name);␉␊
+␉␉␉␉␉DBG("found : %s\n", name);␊
+␉␉␉␉␉closedir(moduleDir);␊
 ␉␉␉␉␉return true;␊
 ␉␉␉␉}␉␉␉␊
 ␉␉␉}␊
 #endif␉␉␊
 ␉}␊
 ␉␊
+␉if (moduleDir) {␊
+␉␉closedir(moduleDir);␊
+␉␉␊
+␉}␊
 ␉return false;␊
 }␊
 ␊

-91
92 92
93 93
94 
94
95 95
96 96
97 97
98 98
99 
99
100 100
101 101
+␉␉␉␉␉␉␉ struct symtab_command* symtabCommand,␊
␉␉␉␉␉␉␉ long long(*symbol_handler)(char*, long long, char),␊
␉␉␉␉␉␉␉ char is64);␊
␉␉␉␉␉␉␉ ␊
␊
unsigned int lookup_all_symbols(const char* name);␊
␊
EFI_STATUS replace_function(const char* symbol, void* newAddress);␊
␊
extern unsigned int (*lookup_symbol)(const char*);␊
extern unsigned int (*lookup_symbol)(const char*, int(*strcmp_callback)(const char*, const char*));␊
␊
#endif /* __BOOT_MODULES_H */
 ␉␉␉␉␉␉␉ struct symtab_command* symtabCommand,␊
 ␉␉␉␉␉␉␉ long long(*symbol_handler)(char*, long long, char),␊
 ␉␉␉␉␉␉␉ char is64);␊
-␉␉␉␉␉␉␉ ␊
+␊
 unsigned int lookup_all_symbols(const char* name);␊
 ␊
 EFI_STATUS replace_function(const char* symbol, void* newAddress);␊
 ␊
-extern unsigned int (*lookup_symbol)(const char*);␊
+extern unsigned int (*lookup_symbol)(const char*, int(*strcmp_callback)(const char*, const char*));␊
 ␊
 #endif /* __BOOT_MODULES_H */

-98
99 99
100 100
101 
101
102 102
103 103
104 104
... ...
121 121
122 122
123 123
124 
124
125 125
126 126
127 127
... ...
341 341
342 342
343 343
344 
344
345 345
346 346
347 347
... ...
723 723
724 724
725 725
726 
726
727 727
728 728
729 729
... ...
733 733
734 734
735 735
736 
736
737 737
738 738
739 739
... ...
743 743
744 744
745 745
746 
747 746
748 747
749 
748
749
750
751
752
750 753
751 754
752 755
+        return 0;␊
␉␊
␉␊
␊
␉␊
    // Load extra drivers if a hook has been installed.␊
    ␊
␉int step = 0;␊

␉␉␉␊
␉␉␉step = 1;␊
␉␉␉execute_hook("ramDiskLoadDrivers", &step, NULL, NULL, NULL, NULL, NULL);␊
␊
␉␉␉␊
#endif␊
␉␉␉␊
␉␉␉// First try a specfic OS version folder ie 10.5␊

    if (!length || (unsigned)length < sizeof (DriversPackage)) return -1;␊
␉␊
␉// call hook to notify modules that the mkext has been loaded␊
␉execute_hook("LoadDriverMKext", (void*)fileSpec, (void*)package, (void*) length, NULL, NULL, NULL);␊
␉execute_hook("LoadDriverMKext", (void*)fileSpec, (void*)package, &length, NULL, NULL, NULL);␊
␉␊
␉␊
    // Verify the MKext.␊

{␊
    long ret;␊
    compressed_kernel_header * kernel_header = (compressed_kernel_header *) binary;␊
    ␉␉␊
␉␊
#if 0␊
    printf("kernel header:\n");␊
    printf("signature: 0x%x\n", kernel_header->signature);␊

    printf("compressed_size: 0x%x\n", kernel_header->compressed_size);␊
    getc();␊
#endif␊
␉␉␊
␉␊
    if (kernel_header->signature == OSSwapBigToHostConstInt32('comp'))␊
␉{␊
        if (kernel_header->compress_type != OSSwapBigToHostConstInt32('lzss'))␊

        }␊
␉␉␊
␉␉u_int32_t uncompressed_size, size;␊
␉␉void *buffer;␊
␉␉␊
        uncompressed_size = OSSwapBigToHostInt32(kernel_header->uncompressed_size);␊
        binary = buffer = malloc(uncompressed_size);␊
        binary = malloc(uncompressed_size);␊
␉␉if (!binary) {␊
␉␉␉printf("Unable to allocate memory for uncompressed kernel\n");␊
            return -1;␊
␉␉}␊
␉␉␊
        size = decompress_lzss((u_int8_t *) binary, &kernel_header->data[0],␊
                               OSSwapBigToHostInt32(kernel_header->compressed_size));␊
 ...
 ...
 ...
 ...
 ...
         return 0;␊
 ␉␊
 ␉␊
-␊
+␉␊
     // Load extra drivers if a hook has been installed.␊
     ␊
 ␉int step = 0;␊
 ␉␉␉␊
 ␉␉␉step = 1;␊
 ␉␉␉execute_hook("ramDiskLoadDrivers", &step, NULL, NULL, NULL, NULL, NULL);␊
-␊
+␉␉␉␊
 #endif␊
 ␉␉␉␊
 ␉␉␉// First try a specfic OS version folder ie 10.5␊
     if (!length || (unsigned)length < sizeof (DriversPackage)) return -1;␊
 ␉␊
 ␉// call hook to notify modules that the mkext has been loaded␊
-␉execute_hook("LoadDriverMKext", (void*)fileSpec, (void*)package, (void*) length, NULL, NULL, NULL);␊
+␉execute_hook("LoadDriverMKext", (void*)fileSpec, (void*)package, &length, NULL, NULL, NULL);␊
 ␉␊
 ␉␊
     // Verify the MKext.␊
 {␊
     long ret;␊
     compressed_kernel_header * kernel_header = (compressed_kernel_header *) binary;␊
-    ␉␉␊
+␉␊
 #if 0␊
     printf("kernel header:\n");␊
     printf("signature: 0x%x\n", kernel_header->signature);␊
     printf("compressed_size: 0x%x\n", kernel_header->compressed_size);␊
     getc();␊
 #endif␊
-␉␉␊
+␉␊
     if (kernel_header->signature == OSSwapBigToHostConstInt32('comp'))␊
 ␉{␊
         if (kernel_header->compress_type != OSSwapBigToHostConstInt32('lzss'))␊
         }␊
 ␉␉␊
 ␉␉u_int32_t uncompressed_size, size;␊
-␉␉void *buffer;␊
 ␉␉␊
         uncompressed_size = OSSwapBigToHostInt32(kernel_header->uncompressed_size);␊
-        binary = buffer = malloc(uncompressed_size);␊
+        binary = malloc(uncompressed_size);␊
+␉␉if (!binary) {␊
+␉␉␉printf("Unable to allocate memory for uncompressed kernel\n");␊
+            return -1;␊
+␉␉}␊
 ␉␉␊
         size = decompress_lzss((u_int8_t *) binary, &kernel_header->data[0],␊
                                OSSwapBigToHostInt32(kernel_header->compressed_size));␊

-111
112 112
113 113
114 
114
115 115
116 116
117 117
... ...
142 142
143 143
144 144
145 
146 
147 
148 
149 
145
146
147
148
149
150 150
151 151
152 152
... ...
237 237
238 238
239 239
240 
240
241 241
242 
243 
244 
245 
246 
247 
242
243
244
245
246
247
248 248
249 
250 
249
250
251 251
252 252
253 253
... ...
564 564
565 565
566 566
567 
568 
569 
570 
571 
572 
573 
574 
575 
576 
577 
578 
579 
580 
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
581 582
582 
583 583
584 584
585 585
... ...
773 773
774 774
775 775
776 
777 
778 
779 
780 
781 
782 
783 
784 
785 
786 
787 
788 
789 
790 
791 
792 
793 
794 
795 
776
796 777
797 
798 
778
799 779
800 
801 
802 
803 
804 
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805 805
806 806
807 807
... ...
900 900
901 901
902 902
903 
903
904 904
905 905
906 906
... ...
983 983
984 984
985 985
986 
987 
986
988 987
989 
990 
991 
992 
993 
994 
995 
988
989
990
991
992
993
994
995
996
997
998
999
1000
996 1001
997 
1002
1003
1004
1005
1006
1007
1008
1009
1010
1011
1012
1013
1014
1015
998 1016
999 
1000 
1001 
1002 
1003 
1004 
1005 
1006 
1007 
1008 
1009 1017
1010 1018
1011 
1019
1012 1020
1013 1021
1014 1022
... ...
1032 1040
1033 1041
1034 1042
1035 
1043
1044
1045
1046
1036 1047
1037 1048
1038 1049
... ...
1114 1125
1115 1126
1116 1127
1117 
1118 
1128
1129
1130
1131
1132
1133
1119 1134
1120 1135
1121 
1122 
1123 
1124 
1125 
1126 
1127 
1128 
1136
1137
1138
1129 1139
1140
1130 1141
1131 1142
1132 1143
... ...
1138 1149
1139 1150
1140 1151
1141 
1152
1142 1153
1143 1154
1144 1155
+␉␊
␉moveCursor( 0, row );␊
␉printf(msg);␊
␉␉␊
␉␊
    for ( time = time18(), timeout++; timeout > 0; )␊
    {␊
␉␉if ((ch = readKeyboardStatus()))␊

␊
//==========================================================================␊
␊
 char   gBootArgs[BOOT_STRING_LEN];␊
 char * gBootArgsPtr = gBootArgs;␊
 char * gBootArgsEnd = gBootArgs + BOOT_STRING_LEN - 1;␊
 char   booterCommand[BOOT_STRING_LEN];␊
 char   booterParam[BOOT_STRING_LEN];␊
char   gBootArgs[BOOT_STRING_LEN];␊
char * gBootArgsPtr = gBootArgs;␊
char * gBootArgsEnd = gBootArgs + BOOT_STRING_LEN - 1;␊
char   booterCommand[BOOT_STRING_LEN];␊
char   booterParam[BOOT_STRING_LEN];␊
␊
void clearBootArgs(void)␊
{␊

␊
//==========================================================================␊
␊
 const MenuItem * gMenuItems = NULL;␊
const MenuItem * gMenuItems = NULL;␊
␊
 int   gMenuItemCount;␊
 int   gMenuRow;␊
 int   gMenuHeight;␊
 int   gMenuTop;␊
 int   gMenuBottom;␊
 int   gMenuSelection;␊
int   gMenuItemCount;␊
int   gMenuRow;␊
int   gMenuHeight;␊
int   gMenuTop;␊
int   gMenuBottom;␊
int   gMenuSelection;␊
␊
 int␉ gMenuStart;␊
 int␉ gMenuEnd;␊
int␉ gMenuStart;␊
int␉ gMenuEnd;␊
␊
void printMenuItem( const MenuItem * item, int highlight )␊
{␊

␉␉timeout = multiboot_timeout;␊
␉} else ␊
#endif␊
␉if (!getIntForKey(kTimeoutKey, &timeout, &bootInfo->bootConfig)) {␊
␉␉/*  If there is no timeout key in the file use the default timeout␊
␉␉ which is different for CDs vs. hard disks.  However, if not booting␊
␉␉ a CD and no config file could be loaded set the timeout␊
␉␉ to zero which causes the menu to display immediately.␊
␉␉ This way, if no partitions can be found, that is the disk is unpartitioned␊
␉␉ or simply cannot be read) then an empty menu is displayed.␊
␉␉ If some partitions are found, for example a Windows partition, then␊
␉␉ these will be displayed in the menu as foreign partitions.␊
␉␉ */␊
␉␉if (isCDROM) {␊
␉␉␉timeout = kCDBootTimeout;␊
␉␉} else {␊
␉␉␉timeout = sysConfigValid ? kBootTimeout : 0;␊
␉␉if (!getIntForKey(kTimeoutKey, &timeout, &bootInfo->bootConfig)) {␊
␉␉␉/*  If there is no timeout key in the file use the default timeout␊
␉␉␉ which is different for CDs vs. hard disks.  However, if not booting␊
␉␉␉ a CD and no config file could be loaded set the timeout␊
␉␉␉ to zero which causes the menu to display immediately.␊
␉␉␉ This way, if no partitions can be found, that is the disk is unpartitioned␊
␉␉␉ or simply cannot be read) then an empty menu is displayed.␊
␉␉␉ If some partitions are found, for example a Windows partition, then␊
␉␉␉ these will be displayed in the menu as foreign partitions.␊
␉␉␉ */␊
␉␉␉if (isCDROM) {␊
␉␉␉␉timeout = kCDBootTimeout;␊
␉␉␉} else {␊
␉␉␉␉timeout = sysConfigValid ? kBootTimeout : 0;␊
␉␉␉}␊
␉␉}␊
␉}␊
␉␊
␉if (timeout < 0) {␊
␉␉gBootMode |= kBootModeQuiet;␊

␉␉␉␉␉}␊
␉␉␉␉␉else␊
#endif␊
␉␉␉␉␉if ( strcmp( booterCommand, "memory" ) == 0) ␊
␉␉␉␉␉{␊
␉␉␉␉␉␉printMemoryInfo();␊
␉␉␉␉␉}␊
␉␉␉␉␉else if (strcmp(booterCommand, "lspci") == 0) ␊
␉␉␉␉␉{␊
␉␉␉␉␉␉lspci();␊
␉␉␉␉␉} ␊
␉␉␉␉␉else if (strcmp(booterCommand, "more") == 0) ␊
␉␉␉␉␉{␊
␉␉␉␉␉␉showTextFile(booterParam);␊
␉␉␉␉␉}␊
␉␉␉␉␉else if (strcmp(booterCommand, "rd") == 0) ␊
␉␉␉␉␉{␊
␉␉␉␉␉␉if (execute_hook("processRAMDiskCommand", (void*)argPtr, &booterParam, NULL, NULL, NULL, NULL) != EFI_SUCCESS)␊
␉␉␉␉␉␉showMessage("ramdisk module not found, please install RamdiskLoader.dylib in /Extra/modules/");␊
␉␉␉␉␉} ␊
␉␉␉␉␉else if (strcmp(booterCommand, "norescan") == 0)␊
␉␉␉␉␉{␊
␉␉␉␉␉␉if (gEnableCDROMRescan)␊
␉␉␉␉␉␉if ( strcmp( booterCommand, "memory" ) == 0) ␊
␉␉␉␉␉␉{␊
␉␉␉␉␉␉␉gEnableCDROMRescan = false;␊
␉␉␉␉␉␉␉break;␊
␉␉␉␉␉␉␉printMemoryInfo();␊
␉␉␉␉␉␉}␊
␉␉␉␉␉}␊
␉␉␉␉␉else␊
␉␉␉␉␉{␊
␉␉␉␉␉␉showHelp();␊
␉␉␉␉␉}␊
␉␉␉␉␉␉else if (strcmp(booterCommand, "lspci") == 0) ␊
␉␉␉␉␉␉{␊
␉␉␉␉␉␉␉lspci();␊
␉␉␉␉␉␉} ␊
␉␉␉␉␉␉else if (strcmp(booterCommand, "more") == 0) ␊
␉␉␉␉␉␉{␊
␉␉␉␉␉␉␉showTextFile(booterParam);␊
␉␉␉␉␉␉}␊
␉␉␉␉␉␉else if (strcmp(booterCommand, "rd") == 0) ␊
␉␉␉␉␉␉{␊
␉␉␉␉␉␉␉if (execute_hook("processRAMDiskCommand", (void*)argPtr, &booterParam, NULL, NULL, NULL, NULL) != EFI_SUCCESS)␊
␉␉␉␉␉␉␉␉showMessage("ramdisk module not found, please install RamdiskLoader.dylib in /Extra/modules/");␊
␉␉␉␉␉␉} ␊
␉␉␉␉␉␉else if (strcmp(booterCommand, "norescan") == 0)␊
␉␉␉␉␉␉{␊
␉␉␉␉␉␉␉if (gEnableCDROMRescan)␊
␉␉␉␉␉␉␉{␊
␉␉␉␉␉␉␉␉gEnableCDROMRescan = false;␊
␉␉␉␉␉␉␉␉break;␊
␉␉␉␉␉␉␉}␊
␉␉␉␉␉␉}␊
␉␉␉␉␉␉else␊
␉␉␉␉␉␉{␊
␉␉␉␉␉␉␉showHelp();␊
␉␉␉␉␉␉}␊
#endif␊
␉␉␉␉␉key = 0;␊
␉␉␉␉␉showBootPrompt(nextRow, showPrompt);␊

    int␉␉     userCnt;␊
    char *           argP;␊
    char *           configKernelFlags;␊
        ␊
␉␊
    skipblanks( &cp );␊
␉␊
    // Update the unit and partition number.␊

        cnt = 0;␊
    }␊
␉␊
    configKernelFlags = malloc(cnt + 1);␊
    strlcpy(configKernelFlags, val, cnt + 1);␊
    configKernelFlags = newString(val);␊
␉␊
    ␉␊
    if (!getValueForBootKey(cp, kSafeModeFlag, &val, &cnt) &&␊
        !getValueForBootKey(configKernelFlags, kSafeModeFlag, &val, &cnt)) {␊
        if (gBootMode & kBootModeSafe) {␊
            copyArgument(0, kSafeModeFlag, strlen(kSafeModeFlag), &argP, &ArgCntRemaining);␊
        }␊
    }␊
␉{␊
␉␉bool isSafeMode = false;␊
␉␉if (configKernelFlags) {␊
␉␉␉isSafeMode = getValueForBootKey(configKernelFlags, kSafeModeFlag, &val, &cnt);␊
␉␉}␊
␉␉␊
␉␉if (!getValueForBootKey(cp, kSafeModeFlag, &val, &cnt) &&␊
␉␉␉(isSafeMode == false)) {␊
␉␉␉if (gBootMode & kBootModeSafe) {␊
␉␉␉␉copyArgument(0, kSafeModeFlag, strlen(kSafeModeFlag), &argP, &ArgCntRemaining);␊
␉␉␉}␊
␉␉}␊
␉}␊
␉␊
    // Store the merged kernel flags and boot args.␊
␉if (configKernelFlags) {␊
␉␉// Store the merged kernel flags and boot args.␊
␉␉␊
␉␉cnt = strlen(configKernelFlags);␊
␉␉if (cnt) {␊
␉␉␉if (cnt > ArgCntRemaining) {␊
␉␉␉␉printf("Warning: boot arguments too long, truncating\n");␊
␉␉␉␉cnt = ArgCntRemaining;␊
␉␉␉}␊
␉␉␉strncpy(argP, configKernelFlags, cnt);␊
␉␉␉argP[cnt++] = ' ';␊
␉␉␉ArgCntRemaining -= cnt;␊
␉␉}␊
␉}␉␊
␉␊
    cnt = strlen(configKernelFlags);␊
    if (cnt) {␊
        if (cnt > ArgCntRemaining) {␊
            error("Warning: boot arguments too long, truncating\n");␊
            cnt = ArgCntRemaining;␊
        }␊
        strncpy(argP, configKernelFlags, cnt);␊
        argP[cnt++] = ' ';␊
        ArgCntRemaining -= cnt;␊
    }␊
    userCnt = strlen(cp);␊
    if (userCnt > ArgCntRemaining) {␊
␉␉error("Warning: boot arguments too long, truncating\n");␊
␉␉printf("Warning: boot arguments too long, truncating\n");␊
␉␉userCnt = ArgCntRemaining;␊
    }␊
    strncpy(&argP[cnt], cp, userCnt);␊

␉␉strlcpy(gMKextName, val, cnt + 1);␊
␉}␊
␉␊
    free(configKernelFlags);␊
␉if (configKernelFlags) ␊
␉{␊
␉␉free(configKernelFlags);␊
␉}␊
␉␊
    return 0;␊
}␊

␉char filename[512];␊
␉sprintf(filename, "BootHelp.txt");␊
␉␊
␉␉// Check Extra on booting partition␊
␉␉sprintf(dirspec,"/Extra/%s",filename);␊
␉// Check Extra on booting partition␊
␉sprintf(dirspec,"/Extra/%s",filename);␊
␉fd=open (dirspec);␊
␉if (fd<0)␊
␉{␉// Fall back to booter partition␊
␉␉sprintf(dirspec,"bt(0,0)/Extra/%s",filename);␊
␉␉fd=open (dirspec);␊
␉␉if (fd<0)␊
␉␉{␉// Fall back to booter partition␊
␉␉␉sprintf(dirspec,"bt(0,0)/Extra/%s",filename);␊
␉␉␉fd=open (dirspec);␊
␉␉␉if (fd<0)␊
␉␉␉{␊
␉␉␉␉printf("BootHelp not found: %s\n", filename);␊
␉␉␉␉return;␊
␉␉␉}␊
␉␉{␊
␉␉␉printf("BootHelp not found: %s\n", filename);␊
␉␉␉return;␊
␉␉}␊
␉}␊
␉int BootHelp_txt_len = file_size (fd);␊
␉void *BootHelp_txt=malloc(BootHelp_txt_len);␊
␉if (BootHelp_txt)␊

␉␉␉close (fd);␊
␉␉␉return;␊
␉␉}␊
␉␉␉␉␊
␉␉␊
␉␉close (fd);␉␉␊
␉}␊
#endif␊
 ...
 ...
 ...
 ...
 ...
 ...
 ...
 ...
 ...
 ␉␊
 ␉moveCursor( 0, row );␊
 ␉printf(msg);␊
-␉␉␊
+␉␊
     for ( time = time18(), timeout++; timeout > 0; )␊
     {␊
 ␉␉if ((ch = readKeyboardStatus()))␊
 ␊
 //==========================================================================␊
 ␊
- char   gBootArgs[BOOT_STRING_LEN];␊
- char * gBootArgsPtr = gBootArgs;␊
- char * gBootArgsEnd = gBootArgs + BOOT_STRING_LEN - 1;␊
- char   booterCommand[BOOT_STRING_LEN];␊
- char   booterParam[BOOT_STRING_LEN];␊
+char   gBootArgs[BOOT_STRING_LEN];␊
+char * gBootArgsPtr = gBootArgs;␊
+char * gBootArgsEnd = gBootArgs + BOOT_STRING_LEN - 1;␊
+char   booterCommand[BOOT_STRING_LEN];␊
+char   booterParam[BOOT_STRING_LEN];␊
 ␊
 void clearBootArgs(void)␊
 {␊
 ␊
 //==========================================================================␊
 ␊
- const MenuItem * gMenuItems = NULL;␊
+const MenuItem * gMenuItems = NULL;␊
 ␊
- int   gMenuItemCount;␊
- int   gMenuRow;␊
- int   gMenuHeight;␊
- int   gMenuTop;␊
- int   gMenuBottom;␊
- int   gMenuSelection;␊
+int   gMenuItemCount;␊
+int   gMenuRow;␊
+int   gMenuHeight;␊
+int   gMenuTop;␊
+int   gMenuBottom;␊
+int   gMenuSelection;␊
 ␊
- int␉ gMenuStart;␊
- int␉ gMenuEnd;␊
+int␉ gMenuStart;␊
+int␉ gMenuEnd;␊
 ␊
 void printMenuItem( const MenuItem * item, int highlight )␊
 {␊
 ␉␉timeout = multiboot_timeout;␊
 ␉} else ␊
 #endif␊
-␉if (!getIntForKey(kTimeoutKey, &timeout, &bootInfo->bootConfig)) {␊
-␉␉/*  If there is no timeout key in the file use the default timeout␊
-␉␉ which is different for CDs vs. hard disks.  However, if not booting␊
-␉␉ a CD and no config file could be loaded set the timeout␊
-␉␉ to zero which causes the menu to display immediately.␊
-␉␉ This way, if no partitions can be found, that is the disk is unpartitioned␊
-␉␉ or simply cannot be read) then an empty menu is displayed.␊
-␉␉ If some partitions are found, for example a Windows partition, then␊
-␉␉ these will be displayed in the menu as foreign partitions.␊
-␉␉ */␊
-␉␉if (isCDROM) {␊
-␉␉␉timeout = kCDBootTimeout;␊
-␉␉} else {␊
-␉␉␉timeout = sysConfigValid ? kBootTimeout : 0;␊
+␉␉if (!getIntForKey(kTimeoutKey, &timeout, &bootInfo->bootConfig)) {␊
+␉␉␉/*  If there is no timeout key in the file use the default timeout␊
+␉␉␉ which is different for CDs vs. hard disks.  However, if not booting␊
+␉␉␉ a CD and no config file could be loaded set the timeout␊
+␉␉␉ to zero which causes the menu to display immediately.␊
+␉␉␉ This way, if no partitions can be found, that is the disk is unpartitioned␊
+␉␉␉ or simply cannot be read) then an empty menu is displayed.␊
+␉␉␉ If some partitions are found, for example a Windows partition, then␊
+␉␉␉ these will be displayed in the menu as foreign partitions.␊
+␉␉␉ */␊
+␉␉␉if (isCDROM) {␊
+␉␉␉␉timeout = kCDBootTimeout;␊
+␉␉␉} else {␊
+␉␉␉␉timeout = sysConfigValid ? kBootTimeout : 0;␊
+␉␉␉}␊
 ␉␉}␊
-␉}␊
 ␉␊
 ␉if (timeout < 0) {␊
 ␉␉gBootMode |= kBootModeQuiet;␊
 ␉␉␉␉␉}␊
 ␉␉␉␉␉else␊
 #endif␊
-␉␉␉␉␉if ( strcmp( booterCommand, "memory" ) == 0) ␊
-␉␉␉␉␉{␊
-␉␉␉␉␉␉printMemoryInfo();␊
-␉␉␉␉␉}␊
-␉␉␉␉␉else if (strcmp(booterCommand, "lspci") == 0) ␊
-␉␉␉␉␉{␊
-␉␉␉␉␉␉lspci();␊
-␉␉␉␉␉} ␊
-␉␉␉␉␉else if (strcmp(booterCommand, "more") == 0) ␊
-␉␉␉␉␉{␊
-␉␉␉␉␉␉showTextFile(booterParam);␊
-␉␉␉␉␉}␊
-␉␉␉␉␉else if (strcmp(booterCommand, "rd") == 0) ␊
-␉␉␉␉␉{␊
-␉␉␉␉␉␉if (execute_hook("processRAMDiskCommand", (void*)argPtr, &booterParam, NULL, NULL, NULL, NULL) != EFI_SUCCESS)␊
-␉␉␉␉␉␉showMessage("ramdisk module not found, please install RamdiskLoader.dylib in /Extra/modules/");␊
-␉␉␉␉␉} ␊
-␉␉␉␉␉else if (strcmp(booterCommand, "norescan") == 0)␊
-␉␉␉␉␉{␊
-␉␉␉␉␉␉if (gEnableCDROMRescan)␊
+␉␉␉␉␉␉if ( strcmp( booterCommand, "memory" ) == 0) ␊
 ␉␉␉␉␉␉{␊
-␉␉␉␉␉␉␉gEnableCDROMRescan = false;␊
-␉␉␉␉␉␉␉break;␊
+␉␉␉␉␉␉␉printMemoryInfo();␊
 ␉␉␉␉␉␉}␊
-␉␉␉␉␉}␊
-␉␉␉␉␉else␊
-␉␉␉␉␉{␊
-␉␉␉␉␉␉showHelp();␊
-␉␉␉␉␉}␊
+␉␉␉␉␉␉else if (strcmp(booterCommand, "lspci") == 0) ␊
+␉␉␉␉␉␉{␊
+␉␉␉␉␉␉␉lspci();␊
+␉␉␉␉␉␉} ␊
+␉␉␉␉␉␉else if (strcmp(booterCommand, "more") == 0) ␊
+␉␉␉␉␉␉{␊
+␉␉␉␉␉␉␉showTextFile(booterParam);␊
+␉␉␉␉␉␉}␊
+␉␉␉␉␉␉else if (strcmp(booterCommand, "rd") == 0) ␊
+␉␉␉␉␉␉{␊
+␉␉␉␉␉␉␉if (execute_hook("processRAMDiskCommand", (void*)argPtr, &booterParam, NULL, NULL, NULL, NULL) != EFI_SUCCESS)␊
+␉␉␉␉␉␉␉␉showMessage("ramdisk module not found, please install RamdiskLoader.dylib in /Extra/modules/");␊
+␉␉␉␉␉␉} ␊
+␉␉␉␉␉␉else if (strcmp(booterCommand, "norescan") == 0)␊
+␉␉␉␉␉␉{␊
+␉␉␉␉␉␉␉if (gEnableCDROMRescan)␊
+␉␉␉␉␉␉␉{␊
+␉␉␉␉␉␉␉␉gEnableCDROMRescan = false;␊
+␉␉␉␉␉␉␉␉break;␊
+␉␉␉␉␉␉␉}␊
+␉␉␉␉␉␉}␊
+␉␉␉␉␉␉else␊
+␉␉␉␉␉␉{␊
+␉␉␉␉␉␉␉showHelp();␊
+␉␉␉␉␉␉}␊
 #endif␊
 ␉␉␉␉␉key = 0;␊
 ␉␉␉␉␉showBootPrompt(nextRow, showPrompt);␊
     int␉␉     userCnt;␊
     char *           argP;␊
     char *           configKernelFlags;␊
-        ␊
+␉␊
     skipblanks( &cp );␊
 ␉␊
     // Update the unit and partition number.␊
         cnt = 0;␊
     }␊
 ␉␊
-    configKernelFlags = malloc(cnt + 1);␊
-    strlcpy(configKernelFlags, val, cnt + 1);␊
+    configKernelFlags = newString(val);␊
 ␉␊
-    ␉␊
-    if (!getValueForBootKey(cp, kSafeModeFlag, &val, &cnt) &&␊
-        !getValueForBootKey(configKernelFlags, kSafeModeFlag, &val, &cnt)) {␊
-        if (gBootMode & kBootModeSafe) {␊
-            copyArgument(0, kSafeModeFlag, strlen(kSafeModeFlag), &argP, &ArgCntRemaining);␊
-        }␊
-    }␊
+␉{␊
+␉␉bool isSafeMode = false;␊
+␉␉if (configKernelFlags) {␊
+␉␉␉isSafeMode = getValueForBootKey(configKernelFlags, kSafeModeFlag, &val, &cnt);␊
+␉␉}␊
+␉␉␊
+␉␉if (!getValueForBootKey(cp, kSafeModeFlag, &val, &cnt) &&␊
+␉␉␉(isSafeMode == false)) {␊
+␉␉␉if (gBootMode & kBootModeSafe) {␊
+␉␉␉␉copyArgument(0, kSafeModeFlag, strlen(kSafeModeFlag), &argP, &ArgCntRemaining);␊
+␉␉␉}␊
+␉␉}␊
+␉}␊
 ␉␊
-    // Store the merged kernel flags and boot args.␊
+␉if (configKernelFlags) {␊
+␉␉// Store the merged kernel flags and boot args.␊
+␉␉␊
+␉␉cnt = strlen(configKernelFlags);␊
+␉␉if (cnt) {␊
+␉␉␉if (cnt > ArgCntRemaining) {␊
+␉␉␉␉printf("Warning: boot arguments too long, truncating\n");␊
+␉␉␉␉cnt = ArgCntRemaining;␊
+␉␉␉}␊
+␉␉␉strncpy(argP, configKernelFlags, cnt);␊
+␉␉␉argP[cnt++] = ' ';␊
+␉␉␉ArgCntRemaining -= cnt;␊
+␉␉}␊
+␉}␉␊
 ␉␊
-    cnt = strlen(configKernelFlags);␊
-    if (cnt) {␊
-        if (cnt > ArgCntRemaining) {␊
-            error("Warning: boot arguments too long, truncating\n");␊
-            cnt = ArgCntRemaining;␊
-        }␊
-        strncpy(argP, configKernelFlags, cnt);␊
-        argP[cnt++] = ' ';␊
-        ArgCntRemaining -= cnt;␊
-    }␊
     userCnt = strlen(cp);␊
     if (userCnt > ArgCntRemaining) {␊
-␉␉error("Warning: boot arguments too long, truncating\n");␊
+␉␉printf("Warning: boot arguments too long, truncating\n");␊
 ␉␉userCnt = ArgCntRemaining;␊
     }␊
     strncpy(&argP[cnt], cp, userCnt);␊
 ␉␉strlcpy(gMKextName, val, cnt + 1);␊
 ␉}␊
 ␉␊
-    free(configKernelFlags);␊
+␉if (configKernelFlags) ␊
+␉{␊
+␉␉free(configKernelFlags);␊
+␉}␊
 ␉␊
     return 0;␊
 }␊
 ␉char filename[512];␊
 ␉sprintf(filename, "BootHelp.txt");␊
 ␉␊
-␉␉// Check Extra on booting partition␊
-␉␉sprintf(dirspec,"/Extra/%s",filename);␊
+␉// Check Extra on booting partition␊
+␉sprintf(dirspec,"/Extra/%s",filename);␊
+␉fd=open (dirspec);␊
+␉if (fd<0)␊
+␉{␉// Fall back to booter partition␊
+␉␉sprintf(dirspec,"bt(0,0)/Extra/%s",filename);␊
 ␉␉fd=open (dirspec);␊
 ␉␉if (fd<0)␊
-␉␉{␉// Fall back to booter partition␊
-␉␉␉sprintf(dirspec,"bt(0,0)/Extra/%s",filename);␊
-␉␉␉fd=open (dirspec);␊
-␉␉␉if (fd<0)␊
-␉␉␉{␊
-␉␉␉␉printf("BootHelp not found: %s\n", filename);␊
-␉␉␉␉return;␊
-␉␉␉}␊
+␉␉{␊
+␉␉␉printf("BootHelp not found: %s\n", filename);␊
+␉␉␉return;␊
 ␉␉}␊
+␉}␊
 ␉int BootHelp_txt_len = file_size (fd);␊
 ␉void *BootHelp_txt=malloc(BootHelp_txt_len);␊
 ␉if (BootHelp_txt)␊
 ␉␉␉close (fd);␊
 ␉␉␉return;␊
 ␉␉}␊
-␉␉␉␉␊
+␉␉␊
 ␉␉close (fd);␉␉␊
 ␉}␊
 #endif␊

-9
10 10
11 11
12 
12
13 13
14 
14
15 15
16 16
17 17
... ...
77 77
78 78
79 79
80 
80
81 81
82 82
83 83
+include ../MakePaths.dir␊
␊
OPTIM = -Os -Oz␊
CFLAGS␉= $(RC_CFLAGS) $(OPTIM) $(MORECPP) -arch i386 -g -Wmost -Werror \␊
CFLAGS␉= $(RC_CFLAGS) $(OPTIM) $(MORECPP) -arch i386 -g -Wmost -Werror -fstack-protector-all \␊
␉␉-fno-builtin -DSAIO_INTERNAL_USER -static $(OMIT_FRAME_POINTER_CFLAG) \␊
␉␉-mpreferred-stack-boundary=2 -fno-align-functions -fno-stack-protector \␊
␉␉-mpreferred-stack-boundary=2 -fno-align-functions \␊
␉␉-march=pentium4 -msse2 -mfpmath=sse -msoft-float  ␊
␊
DEFINES=␊

␉@echo "\t[LD] boot.sys"␊
␉@$(LD)   -static -Wl,-preload -Wl,-segaddr,__INIT,$(BOOT2ADDR) \␊
␉        -nostdlib -arch i386 -Wl,-segalign,20 \␊
␉␉-o $(SYMROOT)/boot.sys $(filter %.o,$^) $(LIBS) -lcc_kext ␉␉␊
␉␉-o $(SYMROOT)/boot.sys $(filter %.o,$^) $(LIBS) ␉␉␊
␉@echo "\t[MACHOCONV] boot"␊
␉@$(SYMROOT)/machOconv $(SYMROOT)/boot.sys $(SYMROOT)/boot &> /dev/null␊
␉␊
 ...
 include ../MakePaths.dir␊
 ␊
 OPTIM = -Os -Oz␊
-CFLAGS␉= $(RC_CFLAGS) $(OPTIM) $(MORECPP) -arch i386 -g -Wmost -Werror \␊
+CFLAGS␉= $(RC_CFLAGS) $(OPTIM) $(MORECPP) -arch i386 -g -Wmost -Werror -fstack-protector-all \␊
 ␉␉-fno-builtin -DSAIO_INTERNAL_USER -static $(OMIT_FRAME_POINTER_CFLAG) \␊
-␉␉-mpreferred-stack-boundary=2 -fno-align-functions -fno-stack-protector \␊
+␉␉-mpreferred-stack-boundary=2 -fno-align-functions \␊
 ␉␉-march=pentium4 -msse2 -mfpmath=sse -msoft-float  ␊
 ␊
 DEFINES=␊
 ␉@echo "\t[LD] boot.sys"␊
 ␉@$(LD)   -static -Wl,-preload -Wl,-segaddr,__INIT,$(BOOT2ADDR) \␊
 ␉        -nostdlib -arch i386 -Wl,-segalign,20 \␊
-␉␉-o $(SYMROOT)/boot.sys $(filter %.o,$^) $(LIBS) -lcc_kext ␉␉␊
+␉␉-o $(SYMROOT)/boot.sys $(filter %.o,$^) $(LIBS) ␉␉␊
 ␉@echo "\t[MACHOCONV] boot"␊
 ␉@$(SYMROOT)/machOconv $(SYMROOT)/boot.sys $(SYMROOT)/boot &> /dev/null␊
 ␉␊

-23
24 24
25 25
26 
26
27 27
28 28
29 29
30 
30
31 31
32 32
33 33
+␊
OPTIM = -Os -Oz␊
DEBUG = -DNOTHING␊
CFLAGS␉= $(RC_CFLAGS) $(OPTIM) $(MORECPP) -arch i386 -g -Wmost \␊
CFLAGS␉= $(RC_CFLAGS) $(OPTIM) $(MORECPP) -arch i386 -g -Wmost -fstack-protector-all \␊
    -D__ARCHITECTURE__=\"i386\" -DSAIO_INTERNAL_USER \␊
    -DRCZ_COMPRESSED_FILE_SUPPORT $(DEBUG) \␊
    -fno-builtin $(OMIT_FRAME_POINTER_CFLAG) \␊
    -mpreferred-stack-boundary=2 -fno-align-functions -fno-stack-protector \␊
    -mpreferred-stack-boundary=2 -fno-align-functions \␊
    -march=pentium4 -msse2 -mfpmath=sse -msoft-float -fno-common␊
␊
DEFINES=␊
 ␊
 OPTIM = -Os -Oz␊
 DEBUG = -DNOTHING␊
-CFLAGS␉= $(RC_CFLAGS) $(OPTIM) $(MORECPP) -arch i386 -g -Wmost \␊
+CFLAGS␉= $(RC_CFLAGS) $(OPTIM) $(MORECPP) -arch i386 -g -Wmost -fstack-protector-all \␊
     -D__ARCHITECTURE__=\"i386\" -DSAIO_INTERNAL_USER \␊
     -DRCZ_COMPRESSED_FILE_SUPPORT $(DEBUG) \␊
     -fno-builtin $(OMIT_FRAME_POINTER_CFLAG) \␊
-    -mpreferred-stack-boundary=2 -fno-align-functions -fno-stack-protector \␊
+    -mpreferred-stack-boundary=2 -fno-align-functions \␊
     -march=pentium4 -msse2 -mfpmath=sse -msoft-float -fno-common␊
 ␊
 DEFINES=␊

-23
24 24
25 25
26 
26
27 27
28 28
29 29
30 
30
31 31
32 32
33 33
+␊
OPTIM = -Os -Oz␊
DEBUG = -DNOTHING␊
CFLAGS␉= $(RC_CFLAGS) $(OPTIM) $(MORECPP) -arch i386 -g -Wmost \␊
CFLAGS␉= $(RC_CFLAGS) $(OPTIM) $(MORECPP) -arch i386 -g -Wmost -fstack-protector-all \␊
    -D__ARCHITECTURE__=\"i386\" -DSAIO_INTERNAL_USER \␊
    -DRCZ_COMPRESSED_FILE_SUPPORT $(DEBUG) \␊
    -fno-builtin $(OMIT_FRAME_POINTER_CFLAG) \␊
    -mpreferred-stack-boundary=2 -fno-align-functions -fno-stack-protector \␊
    -mpreferred-stack-boundary=2 -fno-align-functions \␊
    -march=pentium4 -msse2 -mfpmath=sse -msoft-float -fno-common ␊
␊
DEFINES=␊
 ␊
 OPTIM = -Os -Oz␊
 DEBUG = -DNOTHING␊
-CFLAGS␉= $(RC_CFLAGS) $(OPTIM) $(MORECPP) -arch i386 -g -Wmost \␊
+CFLAGS␉= $(RC_CFLAGS) $(OPTIM) $(MORECPP) -arch i386 -g -Wmost -fstack-protector-all \␊
     -D__ARCHITECTURE__=\"i386\" -DSAIO_INTERNAL_USER \␊
     -DRCZ_COMPRESSED_FILE_SUPPORT $(DEBUG) \␊
     -fno-builtin $(OMIT_FRAME_POINTER_CFLAG) \␊
-    -mpreferred-stack-boundary=2 -fno-align-functions -fno-stack-protector \␊
+    -mpreferred-stack-boundary=2 -fno-align-functions \␊
     -march=pentium4 -msse2 -mfpmath=sse -msoft-float -fno-common ␊
 ␊
 DEFINES=␊

-23
24 24
25 25
26 
26
27 27
28 28
29 29
30 
30
31 31
32 32
33 33
+␊
OPTIM = -Os -Oz␊
DEBUG = -DNOTHING␊
CFLAGS␉= $(RC_CFLAGS) $(OPTIM) $(MORECPP) -arch i386 -g -Wmost \␊
CFLAGS␉= $(RC_CFLAGS) $(OPTIM) $(MORECPP) -arch i386 -g -Wmost -fstack-protector-all \␊
    -D__ARCHITECTURE__=\"i386\" -DSAIO_INTERNAL_USER \␊
    -DRCZ_COMPRESSED_FILE_SUPPORT $(DEBUG) \␊
    -fno-builtin $(OMIT_FRAME_POINTER_CFLAG) \␊
    -mpreferred-stack-boundary=2 -fno-align-functions -fno-stack-protector \␊
    -mpreferred-stack-boundary=2 -fno-align-functions \␊
    -march=pentium4 -msse2 -mfpmath=sse -msoft-float -fno-common  ␊
␊
DEFINES=␊
 ␊
 OPTIM = -Os -Oz␊
 DEBUG = -DNOTHING␊
-CFLAGS␉= $(RC_CFLAGS) $(OPTIM) $(MORECPP) -arch i386 -g -Wmost \␊
+CFLAGS␉= $(RC_CFLAGS) $(OPTIM) $(MORECPP) -arch i386 -g -Wmost -fstack-protector-all \␊
     -D__ARCHITECTURE__=\"i386\" -DSAIO_INTERNAL_USER \␊
     -DRCZ_COMPRESSED_FILE_SUPPORT $(DEBUG) \␊
     -fno-builtin $(OMIT_FRAME_POINTER_CFLAG) \␊
-    -mpreferred-stack-boundary=2 -fno-align-functions -fno-stack-protector \␊
+    -mpreferred-stack-boundary=2 -fno-align-functions \␊
     -march=pentium4 -msse2 -mfpmath=sse -msoft-float -fno-common  ␊
 ␊
 DEFINES=␊

-130
131 131
132 132
133 
133
134 134
135 135
136 136
+void KextPatcher_start()␊
{␉␉␊
␉// Hooks into the following:␊
␉//␉execute_hook("LoadDriverMKext", (void*)package, (void*) length, NULL, NULL, NULL, NULL);␊
␉//␉execute_hook("LoadDriverMKext", (void*)package, &length, NULL, NULL, NULL, NULL);␊
␉//  execute_hook("LoadMatchedModules", module, &length, executableAddr, NULL, NULL, NULL);␊
#if UNUSED␊
␉register_hook_callback("PCIDevice", &KextPatcher_hook);␊
 void KextPatcher_start()␊
 {␉␉␊
 ␉// Hooks into the following:␊
-␉//␉execute_hook("LoadDriverMKext", (void*)package, (void*) length, NULL, NULL, NULL, NULL);␊
+␉//␉execute_hook("LoadDriverMKext", (void*)package, &length, NULL, NULL, NULL, NULL);␊
 ␉//  execute_hook("LoadMatchedModules", module, &length, executableAddr, NULL, NULL, NULL);␊
 #if UNUSED␊
 ␉register_hook_callback("PCIDevice", &KextPatcher_hook);␊

-23
24 24
25 25
26 
26
27 27
28 28
29 29
30 
30
31 31
32 32
33 33
+␊
OPTIM = -Os -Oz␊
DEBUG = -DNOTHING␊
CFLAGS␉= $(RC_CFLAGS) $(OPTIM) $(MORECPP) -arch i386 -g -Wmost \␊
CFLAGS␉= $(RC_CFLAGS) $(OPTIM) $(MORECPP) -arch i386 -g -Wmost -fstack-protector-all \␊
    -D__ARCHITECTURE__=\"i386\" -DSAIO_INTERNAL_USER \␊
    -DRCZ_COMPRESSED_FILE_SUPPORT $(DEBUG) \␊
    -fno-builtin $(OMIT_FRAME_POINTER_CFLAG) \␊
    -mpreferred-stack-boundary=2 -fno-align-functions -fno-stack-protector \␊
    -mpreferred-stack-boundary=2 -fno-align-functions \␊
    -march=pentium4 -msse2 -mfpmath=sse -msoft-float -fno-common␊
␊
DEFINES=␊
 ␊
 OPTIM = -Os -Oz␊
 DEBUG = -DNOTHING␊
-CFLAGS␉= $(RC_CFLAGS) $(OPTIM) $(MORECPP) -arch i386 -g -Wmost \␊
+CFLAGS␉= $(RC_CFLAGS) $(OPTIM) $(MORECPP) -arch i386 -g -Wmost -fstack-protector-all \␊
     -D__ARCHITECTURE__=\"i386\" -DSAIO_INTERNAL_USER \␊
     -DRCZ_COMPRESSED_FILE_SUPPORT $(DEBUG) \␊
     -fno-builtin $(OMIT_FRAME_POINTER_CFLAG) \␊
-    -mpreferred-stack-boundary=2 -fno-align-functions -fno-stack-protector \␊
+    -mpreferred-stack-boundary=2 -fno-align-functions \␊
     -march=pentium4 -msse2 -mfpmath=sse -msoft-float -fno-common␊
 ␊
 DEFINES=␊

-23
24 24
25 25
26 
26
27 27
28 28
29 29
30 
30
31 31
32 32
33 33
+␊
OPTIM = -Os -Oz␊
DEBUG = -DNOTHING␊
CFLAGS␉= $(RC_CFLAGS) $(OPTIM) $(MORECPP) -arch i386 -g -Wmost \␊
CFLAGS␉= $(RC_CFLAGS) $(OPTIM) $(MORECPP) -arch i386 -g -Wmost -fstack-protector-all \␊
    -D__ARCHITECTURE__=\"i386\" -DSAIO_INTERNAL_USER \␊
    -DRCZ_COMPRESSED_FILE_SUPPORT $(DEBUG) \␊
    -fno-builtin $(OMIT_FRAME_POINTER_CFLAG) \␊
    -mpreferred-stack-boundary=2 -fno-align-functions -fno-stack-protector \␊
    -mpreferred-stack-boundary=2 -fno-align-functions \␊
    -march=pentium4 -msse2  -mfpmath=sse -msoft-float -fno-common ␊
␊
DEFINES=␊
 ␊
 OPTIM = -Os -Oz␊
 DEBUG = -DNOTHING␊
-CFLAGS␉= $(RC_CFLAGS) $(OPTIM) $(MORECPP) -arch i386 -g -Wmost \␊
+CFLAGS␉= $(RC_CFLAGS) $(OPTIM) $(MORECPP) -arch i386 -g -Wmost -fstack-protector-all \␊
     -D__ARCHITECTURE__=\"i386\" -DSAIO_INTERNAL_USER \␊
     -DRCZ_COMPRESSED_FILE_SUPPORT $(DEBUG) \␊
     -fno-builtin $(OMIT_FRAME_POINTER_CFLAG) \␊
-    -mpreferred-stack-boundary=2 -fno-align-functions -fno-stack-protector \␊
+    -mpreferred-stack-boundary=2 -fno-align-functions \␊
     -march=pentium4 -msse2  -mfpmath=sse -msoft-float -fno-common ␊
 ␊
 DEFINES=␊

-368
369 369
370 370
371 
371
372 372
373 
373
374 374
375 375
376 376
377 377
378 
378
379 379
380 380
381 381
... ...
385 385
386 386
387 387
388 
388
389 389
390 
390
391 391
392 392
393 393
... ...
421 421
422 422
423 423
424 
424
425 425
426 
426
427 427
428 428
429 429
... ...
444 444
445 445
446 446
447 
447
448 448
449 449
450 450
... ...
459 459
460 460
461 461
462 
462
463 463
464 
464
465 465
466 466
467 467
... ...
532 532
533 533
534 534
535 
535
536 536
537 
537
538 538
539 539
540 
540
541 541
542 542
543 543
... ...
913 913
914 914
915 915
916 
916
917 917
918 918
919 919
920 920
921 921
922 922
923 
923
924 924
925 925
926 
927 
926
927
928 928
929 929
930 930
... ...
945 945
946 946
947 947
948 
948
949 949
950 950
951 951
952 952
953 
953
954 954
955 
955
956 956
957 957
958 958
... ...
981 981
982 982
983 983
984 
985 984
985
986 986
987 
987
988 988
989 989
990 990
... ...
995 995
996 996
997 997
998 
998
999 999
1000 1000
1001 1001
... ...
1047 1047
1048 1048
1049 1049
1050 
1050
1051 1051
1052 1052
1053 1053
... ...
1060 1060
1061 1061
1062 1062
1063 
1063
1064 1064
1065 1065
1066 1066
... ...
1086 1086
1087 1087
1088 1088
1089 
1089
1090 1090
1091 1091
1092 1092
1093 1093
1094 1094
1095 
1095
1096 1096
1097 
1097
1098 1098
1099 
1099
1100 1100
1101 
1102 
1101
1102
1103
1104
1105
1103 1106
1104 
1105 
1106 
1107 
1108 
1109 
1110 
1111 
1107
1108
1109
1110
1111
1112 1112
1113 
1113
1114 1114
1115 
1115
1116 1116
1117 
1117
1118 1118
1119 1119
1120 1120
... ...
1132 1132
1133 1133
1134 1134
1135 
1135
1136 1136
1137 1137
1138 1138
... ...
1482 1482
1483 1483
1484 1484
1485 
1485
1486 1486
1487 1487
1488 1488
... ...
1862 1862
1863 1863
1864 1864
1865 
1865
1866 1866
1867 1867
1868 1868
... ...
2581 2581
2582 2582
2583 2583
2584
+␉␉if (images[i].image == NULL) {␊
␉␉␉images[i].image = malloc(sizeof(pixmap_t));␊
␉␉␉if (images[i].image == NULL) {␊
␊
␉␉␉␉␊
␉␉␉␉DBG("Unable to allocate memory for %s.png\n", image);␊
␊
␉␉␉␉␊
␉␉␉␉return 1;␊
␉␉␉}␊
␉␉}␊
        sprintf(dirspec, "%s/%s/%s.png", src, theme_name, image);␊
␊
␉␉␊
        width = 0;␊
        height = 0;␊
        imagedata = NULL;␊

            images[i].image->height = height;␊
            images[i].image->pixels = (pixel_t *)imagedata;␊
            flipRB(images[i].image);␊
␊
␉␉␉␊
␉␉␉DBG("[ %s ] succesfully loaded and registred !!\n", dirspec);␊
␊
␉␉␉␊
            return 0;␊
        }␊
#ifdef EMBED_THEME␊

␉␉␉␉images[i].image->pixels = images[alt_image].image->pixels;␊
␉␉␉␉␊
␉␉␉} else {␊
␊
␉␉␉␉␊
␉␉␉␉DBG("Unable to load %s, this image not vital anyway, reseting and returning success !!\n", dirspec);␊
␊
␉␉␉␉␊
␉␉␉␉free(images[i].image);␊
␉␉␉␉images[i].image = NULL;␊
␉␉␉} ␊

␉␉␉free(images[i].image);␊
␉␉␉images[i].image = NULL;␊
␉␉␉return 1;␊
␊
␉␉␉␊
        }␊
␉␉␊
    }␊

static int loadGraphics(char *src)␊
{␊
␉DBG("Loading image into memory....\n",theme_name);␊
␊
␉␊
␉LOADPNG(src, background,                     IMG_REQUIRED);␊
␊
␉␊
␉LOADPNG(src, logo,                           IMG_REQUIRED);␊
␉␊
␉LOADPNG(src, device_generic,                 IMG_REQUIRED);␊

␉␊
␉LOADPNG(src, font_console,                   IMG_REQUIRED);␊
␉LOADPNG(src, font_small,                     IMG_REQUIRED);␊
␊
␉␊
␉DBG("Initializing font....\n",theme_name);␊
␊
␉␊
␉initFont( &font_console, &images[iFontConsole]);␊
␉initFont( &font_small, &images[iFontSmall]);␊
␊
␉␊
␉DBG("Graphic objects successfully loaded !!\n",theme_name);␊
␉␊
␉return 0;␊

#define  MAX_tHEME 255␊
␊
static int randomTheme(char *dirspec, const char **theme) {␊
␉␉␊
␉␊
␉long         ret, flags, time;␊
␉long long␉ index;␊
␉␊
␉const char  * name;␉␉ ␊
␉index = 0;␉␉ ␊
␉uint8_t i=0;␊
␉␉␉␊
␉␊
␉char *list[MAX_tHEME];␊
#ifdef EMBED_THEME␊
␉␉␉list[i] = "";␊
␉␉␉i++;␊
␉list[i] = "";␊
␉i++;␊
#endif␊
␉␊
␉while (i < MAX_tHEME) {␊

␉}␊
␉␊
␉if (i) {␉␉␉␊
␉␉␉␉␊
␉␉␊
␉␉srand (time18());␉␉␊
␉␉␊
␉␉*theme = list[(rand() % i)];␉␉␉␊
␉␉␊
␉␉␉␉␊
␉␉␊
␉␉int ret = startGUI();␊
␊
␉␉␊
␉␉uint8_t l=0;␊
#ifdef EMBED_THEME␊
␉␉l++;␊

␉if (!dummybool) {␊
␉␉return 1;␊
␉}␊
␉␉␊
␉␊
␉␊
␉getBoolForKey("RandomTheme", &theme_ran, &bootInfo->bootConfig);␊
␉␉␉␉␊
␉␊
␉{␊
␉␉long flags;␊
␉␉long time;␊

␉␉␊
␉␉if (theme_ran) ␊
␉␉{␉␉␊
retry:␊
␉␉retry:␊
␉␉␉ret = GetFileInfo("rd(0,0)/Extra/", "Themes", &flags, &time);␊
␉␉␉if ((ret == 0) && ((flags & kFileTypeMask) == kFileTypeDirectory)) {␊
␉␉␉␉sprintf(dirsrc, "rd(0,0)/Extra/Themes");␊

␉␊
␉if (theme_ran)␊
␉{␊
␉␉␉␉␉␉␊
␉␉␊
␉␉ret = randomTheme(dirsrc, &theme_name);␊
 ␉␉␊
␉␉if (ret) printf("randomTheme Failed !! \n");␉␉␊

␉␉␉ret = startGUI();␊
␉␉␉␊
␉␉␉if (ret) printf("Failed to load Theme : %s !! \n", theme_name);␊
␊
␉␉␉␊
␉␉} ␊
#ifdef EMBED_THEME␉␊
␉␉if (ret) {␊

␉int        val;␉␊
␉char    dirspec[256];␊
␉␊
␉␉␊
␉␊
␉if ((unsigned)(strlen(theme_name) + strlen(dirsrc) + strlen("theme.plist") + 2 ) > sizeof(dirspec)) {␊
␉␉␊
␉␉DBG("Path of %s/%s/theme.plist to long\n", dirsrc, theme_name);␉␉␊
␉␉return 1;␊
␉}␊
␉␉␊
␉␊
␉sprintf(dirspec, "%s/%s/theme.plist", dirsrc ,theme_name);␊
␉␉␉␊
␉␊
␉if (loadConfigFile(dirspec, &bootInfo->themeConfig) != 0) {␊
␉␉␉␉␊
␉␉␊
#ifdef EMBED_THEME␊
␉␉␉if (strlen(theme_name) == 0) {␊
␉␉␉␉config_file_t    *config;␊
␉␉if (strlen(theme_name) == 0) {␊
␉␉␉config_file_t    *config;␊
␉␉␉␊
␉␉␉config = &bootInfo->themeConfig;␊
␉␉␉if (ParseXMLFile((char *)__theme_plist, &config->dictionary) != 0) {␊
␉␉␉␉␊
␉␉␉␉config = &bootInfo->themeConfig;␊
␉␉␉␉if (ParseXMLFile((char *)__theme_plist, &config->dictionary) != 0) {␊
␊
␉␉␉␉␉DBG("Unable to load embed theme plist datas.\n");␊
␊
␉␉␉␉␉return 1;␊
␉␉␉␉}␊
␉␉␉}␉␉␉␊
␉␉␉␉DBG("Unable to load embed theme plist datas.\n");␊
␉␉␉␉␊
␉␉␉␉return 1;␊
␉␉␉}␊
␉␉}␉␉␉␊
#else␊
␊
␉␉␊
␉␉DBG("Unable to load %s theme plist.\n",theme_name);␊
␊
␉␉␊
␉␉return 1;␊
␊
␉␉␊
#endif␉␉␊
    }␊
␉␊

␉else␊
␉{␊
␉␉printf("No getResolution function hook installed, using default resolution.\n",theme_name);␊
␊
␉␉␊
␉}␊
#endif␊
␉␊

void vramwrite (void *data, int width, int height)␊
#else␊
static inline␊
 void vramwrite (void *data, int width)␊
void vramwrite (void *data, int width)␊
#endif␊
{␊
␉if (VIDEO (depth) == 0x20 /*32*/ && VIDEO (rowBytes) == (unsigned long)gui.backbuffer->width * 4)␊

␉int width = 0;␊
␉int max_width = 0;␊
␉int height = font->height;␊
␊
␉␊
␉// calculate the width in pixels␊
␉for (i=0; i < strlen(text); i++) {␊
␉␉if (text[i] == '\n')␊

␉␊
    return ch;␊
}␊
␊
 ...
 ...
 ...
 ...
 ...
 ...
 ...
 ...
 ...
 ...
 ...
 ...
 ...
 ...
 ...
 ...
 ␉␉if (images[i].image == NULL) {␊
 ␉␉␉images[i].image = malloc(sizeof(pixmap_t));␊
 ␉␉␉if (images[i].image == NULL) {␊
-␊
+␉␉␉␉␊
 ␉␉␉␉DBG("Unable to allocate memory for %s.png\n", image);␊
-␊
+␉␉␉␉␊
 ␉␉␉␉return 1;␊
 ␉␉␉}␊
 ␉␉}␊
         sprintf(dirspec, "%s/%s/%s.png", src, theme_name, image);␊
-␊
+␉␉␊
         width = 0;␊
         height = 0;␊
         imagedata = NULL;␊
             images[i].image->height = height;␊
             images[i].image->pixels = (pixel_t *)imagedata;␊
             flipRB(images[i].image);␊
-␊
+␉␉␉␊
 ␉␉␉DBG("[ %s ] succesfully loaded and registred !!\n", dirspec);␊
-␊
+␉␉␉␊
             return 0;␊
         }␊
 #ifdef EMBED_THEME␊
 ␉␉␉␉images[i].image->pixels = images[alt_image].image->pixels;␊
 ␉␉␉␉␊
 ␉␉␉} else {␊
-␊
+␉␉␉␉␊
 ␉␉␉␉DBG("Unable to load %s, this image not vital anyway, reseting and returning success !!\n", dirspec);␊
-␊
+␉␉␉␉␊
 ␉␉␉␉free(images[i].image);␊
 ␉␉␉␉images[i].image = NULL;␊
 ␉␉␉} ␊
 ␉␉␉free(images[i].image);␊
 ␉␉␉images[i].image = NULL;␊
 ␉␉␉return 1;␊
-␊
+␉␉␉␊
         }␊
 ␉␉␊
     }␊
 static int loadGraphics(char *src)␊
 {␊
 ␉DBG("Loading image into memory....\n",theme_name);␊
-␊
+␉␊
 ␉LOADPNG(src, background,                     IMG_REQUIRED);␊
-␊
+␉␊
 ␉LOADPNG(src, logo,                           IMG_REQUIRED);␊
 ␉␊
 ␉LOADPNG(src, device_generic,                 IMG_REQUIRED);␊
 ␉␊
 ␉LOADPNG(src, font_console,                   IMG_REQUIRED);␊
 ␉LOADPNG(src, font_small,                     IMG_REQUIRED);␊
-␊
+␉␊
 ␉DBG("Initializing font....\n",theme_name);␊
-␊
+␉␊
 ␉initFont( &font_console, &images[iFontConsole]);␊
 ␉initFont( &font_small, &images[iFontSmall]);␊
-␊
+␉␊
 ␉DBG("Graphic objects successfully loaded !!\n",theme_name);␊
 ␉␊
 ␉return 0;␊
 #define  MAX_tHEME 255␊
 ␊
 static int randomTheme(char *dirspec, const char **theme) {␊
-␉␉␊
+␉␊
 ␉long         ret, flags, time;␊
 ␉long long␉ index;␊
 ␉␊
 ␉const char  * name;␉␉ ␊
 ␉index = 0;␉␉ ␊
 ␉uint8_t i=0;␊
-␉␉␉␊
+␉␊
 ␉char *list[MAX_tHEME];␊
 #ifdef EMBED_THEME␊
-␉␉␉list[i] = "";␊
-␉␉␉i++;␊
+␉list[i] = "";␊
+␉i++;␊
 #endif␊
 ␉␊
 ␉while (i < MAX_tHEME) {␊
 ␉}␊
 ␉␊
 ␉if (i) {␉␉␉␊
-␉␉␉␉␊
+␉␉␊
 ␉␉srand (time18());␉␉␊
 ␉␉␊
 ␉␉*theme = list[(rand() % i)];␉␉␉␊
 ␉␉␊
-␉␉␉␉␊
+␉␉␊
 ␉␉int ret = startGUI();␊
-␊
+␉␉␊
 ␉␉uint8_t l=0;␊
 #ifdef EMBED_THEME␊
 ␉␉l++;␊
 ␉if (!dummybool) {␊
 ␉␉return 1;␊
 ␉}␊
-␉␉␊
 ␉␊
+␉␊
 ␉getBoolForKey("RandomTheme", &theme_ran, &bootInfo->bootConfig);␊
-␉␉␉␉␊
+␉␊
 ␉{␊
 ␉␉long flags;␊
 ␉␉long time;␊
 ␉␉␊
 ␉␉if (theme_ran) ␊
 ␉␉{␉␉␊
-retry:␊
+␉␉retry:␊
 ␉␉␉ret = GetFileInfo("rd(0,0)/Extra/", "Themes", &flags, &time);␊
 ␉␉␉if ((ret == 0) && ((flags & kFileTypeMask) == kFileTypeDirectory)) {␊
 ␉␉␉␉sprintf(dirsrc, "rd(0,0)/Extra/Themes");␊
 ␉␊
 ␉if (theme_ran)␊
 ␉{␊
-␉␉␉␉␉␉␊
+␉␉␊
 ␉␉ret = randomTheme(dirsrc, &theme_name);␊
  ␉␉␊
 ␉␉if (ret) printf("randomTheme Failed !! \n");␉␉␊
 ␉␉␉ret = startGUI();␊
 ␉␉␉␊
 ␉␉␉if (ret) printf("Failed to load Theme : %s !! \n", theme_name);␊
-␊
+␉␉␉␊
 ␉␉} ␊
 #ifdef EMBED_THEME␉␊
 ␉␉if (ret) {␊
 ␉int        val;␉␊
 ␉char    dirspec[256];␊
 ␉␊
-␉␉␊
+␉␊
 ␉if ((unsigned)(strlen(theme_name) + strlen(dirsrc) + strlen("theme.plist") + 2 ) > sizeof(dirspec)) {␊
 ␉␉␊
 ␉␉DBG("Path of %s/%s/theme.plist to long\n", dirsrc, theme_name);␉␉␊
 ␉␉return 1;␊
 ␉}␊
-␉␉␊
+␉␊
 ␉sprintf(dirspec, "%s/%s/theme.plist", dirsrc ,theme_name);␊
-␉␉␉␊
+␉␊
 ␉if (loadConfigFile(dirspec, &bootInfo->themeConfig) != 0) {␊
-␉␉␉␉␊
+␉␉␊
 #ifdef EMBED_THEME␊
-␉␉␉if (strlen(theme_name) == 0) {␊
-␉␉␉␉config_file_t    *config;␊
+␉␉if (strlen(theme_name) == 0) {␊
+␉␉␉config_file_t    *config;␊
+␉␉␉␊
+␉␉␉config = &bootInfo->themeConfig;␊
+␉␉␉if (ParseXMLFile((char *)__theme_plist, &config->dictionary) != 0) {␊
 ␉␉␉␉␊
-␉␉␉␉config = &bootInfo->themeConfig;␊
-␉␉␉␉if (ParseXMLFile((char *)__theme_plist, &config->dictionary) != 0) {␊
-␊
-␉␉␉␉␉DBG("Unable to load embed theme plist datas.\n");␊
-␊
-␉␉␉␉␉return 1;␊
-␉␉␉␉}␊
-␉␉␉}␉␉␉␊
+␉␉␉␉DBG("Unable to load embed theme plist datas.\n");␊
+␉␉␉␉␊
+␉␉␉␉return 1;␊
+␉␉␉}␊
+␉␉}␉␉␉␊
 #else␊
-␊
+␉␉␊
 ␉␉DBG("Unable to load %s theme plist.\n",theme_name);␊
-␊
+␉␉␊
 ␉␉return 1;␊
-␊
+␉␉␊
 #endif␉␉␊
     }␊
 ␉␊
 ␉else␊
 ␉{␊
 ␉␉printf("No getResolution function hook installed, using default resolution.\n",theme_name);␊
-␊
+␉␉␊
 ␉}␊
 #endif␊
 ␉␊
 void vramwrite (void *data, int width, int height)␊
 #else␊
 static inline␊
- void vramwrite (void *data, int width)␊
+void vramwrite (void *data, int width)␊
 #endif␊
 {␊
 ␉if (VIDEO (depth) == 0x20 /*32*/ && VIDEO (rowBytes) == (unsigned long)gui.backbuffer->width * 4)␊
 ␉int width = 0;␊
 ␉int max_width = 0;␊
 ␉int height = font->height;␊
-␊
+␉␊
 ␉// calculate the width in pixels␊
 ␉for (i=0; i < strlen(text); i++) {␊
 ␉␉if (text[i] == '\n')␊
 ␉␊
     return ch;␊
 }␊
-␊

-23
24 24
25 25
26 
26
27 27
28 28
29 29
30 30
31 
31
32 32
33 33
34 34
+␊
OPTIM = -Os -Oz␊
DEBUG = -DNOTHING␊
CFLAGS␉= $(RC_CFLAGS) $(OPTIM) $(MORECPP) -arch i386 -g -Wmost \␊
CFLAGS␉= $(RC_CFLAGS) $(OPTIM) $(MORECPP) -arch i386 -g -Wmost -fstack-protector-all \␊
    -D__ARCHITECTURE__=\"i386\" -DSAIO_INTERNAL_USER \␊
    -DRCZ_COMPRESSED_FILE_SUPPORT $(DEBUG) \␊
    -fno-builtin $(OMIT_FRAME_POINTER_CFLAG) \␊
    -mpreferred-stack-boundary=2 -fno-align-functions \␊
    -march=pentium4 -msse2 -mfpmath=sse -msoft-float -fno-common -fno-stack-protector #-fstack-protector-all␊
    -march=pentium4 -msse2 -mfpmath=sse -msoft-float -fno-common #-fstack-protector-all␊
␊
DEFINES=␊
CONFIG = hd␊
 ␊
 OPTIM = -Os -Oz␊
 DEBUG = -DNOTHING␊
-CFLAGS␉= $(RC_CFLAGS) $(OPTIM) $(MORECPP) -arch i386 -g -Wmost \␊
+CFLAGS␉= $(RC_CFLAGS) $(OPTIM) $(MORECPP) -arch i386 -g -Wmost -fstack-protector-all \␊
     -D__ARCHITECTURE__=\"i386\" -DSAIO_INTERNAL_USER \␊
     -DRCZ_COMPRESSED_FILE_SUPPORT $(DEBUG) \␊
     -fno-builtin $(OMIT_FRAME_POINTER_CFLAG) \␊
     -mpreferred-stack-boundary=2 -fno-align-functions \␊
-    -march=pentium4 -msse2 -mfpmath=sse -msoft-float -fno-common -fno-stack-protector #-fstack-protector-all␊
+    -march=pentium4 -msse2 -mfpmath=sse -msoft-float -fno-common #-fstack-protector-all␊
 ␊
 DEFINES=␊
 CONFIG = hd␊

-23
24 24
25 25
26 
26
27 27
28 28
29 29
30 
30
31 31
32 32
33 33
+␊
OPTIM = -O3␊
DEBUG = -DNOTHING␊
CFLAGS␉= $(RC_CFLAGS) $(OPTIM) $(MORECPP) -arch i386 -g -Wmost \␊
CFLAGS␉= $(RC_CFLAGS) $(OPTIM) $(MORECPP) -arch i386 -g -Wmost -fstack-protector-all \␊
    -D__ARCHITECTURE__=\"i386\" -DSAIO_INTERNAL_USER \␊
    -DRCZ_COMPRESSED_FILE_SUPPORT $(DEBUG) \␊
    -fno-builtin $(OMIT_FRAME_POINTER_CFLAG) \␊
    -mpreferred-stack-boundary=2 -fno-align-functions -fno-stack-protector \␊
    -mpreferred-stack-boundary=2 -fno-align-functions \␊
    -march=pentium4 -msse2 -mfpmath=sse -msoft-float -fno-common  ␊
␊
DEFINES=␊
 ␊
 OPTIM = -O3␊
 DEBUG = -DNOTHING␊
-CFLAGS␉= $(RC_CFLAGS) $(OPTIM) $(MORECPP) -arch i386 -g -Wmost \␊
+CFLAGS␉= $(RC_CFLAGS) $(OPTIM) $(MORECPP) -arch i386 -g -Wmost -fstack-protector-all \␊
     -D__ARCHITECTURE__=\"i386\" -DSAIO_INTERNAL_USER \␊
     -DRCZ_COMPRESSED_FILE_SUPPORT $(DEBUG) \␊
     -fno-builtin $(OMIT_FRAME_POINTER_CFLAG) \␊
-    -mpreferred-stack-boundary=2 -fno-align-functions -fno-stack-protector \␊
+    -mpreferred-stack-boundary=2 -fno-align-functions \␊
     -march=pentium4 -msse2 -mfpmath=sse -msoft-float -fno-common  ␊
 ␊
 DEFINES=␊

-23
24 24
25 25
26 
26
27 27
28 28
29 29
30 
30
31 31
32 32
33 33
+␊
OPTIM = -Os -Oz␊
DEBUG = -DNOTHING␊
CFLAGS␉= $(RC_CFLAGS) $(OPTIM) $(MORECPP) -arch i386 -g -Wmost \␊
CFLAGS␉= $(RC_CFLAGS) $(OPTIM) $(MORECPP) -arch i386 -g -Wmost -fstack-protector-all \␊
    -D__ARCHITECTURE__=\"i386\" -DSAIO_INTERNAL_USER \␊
    -DRCZ_COMPRESSED_FILE_SUPPORT $(DEBUG) \␊
    -fno-builtin $(OMIT_FRAME_POINTER_CFLAG) \␊
    -mpreferred-stack-boundary=2 -fno-align-functions -fno-stack-protector \␊
    -mpreferred-stack-boundary=2 -fno-align-functions \␊
    -march=pentium4 -msse2 -mfpmath=sse -msoft-float -fno-common  ␊
␊
DEFINES=␊
 ␊
 OPTIM = -Os -Oz␊
 DEBUG = -DNOTHING␊
-CFLAGS␉= $(RC_CFLAGS) $(OPTIM) $(MORECPP) -arch i386 -g -Wmost \␊
+CFLAGS␉= $(RC_CFLAGS) $(OPTIM) $(MORECPP) -arch i386 -g -Wmost -fstack-protector-all \␊
     -D__ARCHITECTURE__=\"i386\" -DSAIO_INTERNAL_USER \␊
     -DRCZ_COMPRESSED_FILE_SUPPORT $(DEBUG) \␊
     -fno-builtin $(OMIT_FRAME_POINTER_CFLAG) \␊
-    -mpreferred-stack-boundary=2 -fno-align-functions -fno-stack-protector \␊
+    -mpreferred-stack-boundary=2 -fno-align-functions \␊
     -march=pentium4 -msse2 -mfpmath=sse -msoft-float -fno-common  ␊
 ␊
 DEFINES=␊

-23
24 24
25 25
26 
26
27 27
28 28
29 29
30 
30
31 31
32 32
33 33
+␊
OPTIM = -Os -Oz␊
DEBUG = -DNOTHING␊
CFLAGS␉= $(RC_CFLAGS) $(OPTIM) $(MORECPP) -arch i386 -g -Wmost \␊
CFLAGS␉= $(RC_CFLAGS) $(OPTIM) $(MORECPP) -arch i386 -g -Wmost -fstack-protector-all \␊
    -D__ARCHITECTURE__=\"i386\" -DSAIO_INTERNAL_USER \␊
    -DRCZ_COMPRESSED_FILE_SUPPORT $(DEBUG) \␊
    -fno-builtin $(OMIT_FRAME_POINTER_CFLAG) \␊
    -mpreferred-stack-boundary=2 -fno-align-functions -fno-stack-protector \␊
    -mpreferred-stack-boundary=2 -fno-align-functions \␊
    -march=pentium4 -msse2 -mfpmath=sse -msoft-float -fno-common ␊
␊
DEFINES=␊
 ␊
 OPTIM = -Os -Oz␊
 DEBUG = -DNOTHING␊
-CFLAGS␉= $(RC_CFLAGS) $(OPTIM) $(MORECPP) -arch i386 -g -Wmost \␊
+CFLAGS␉= $(RC_CFLAGS) $(OPTIM) $(MORECPP) -arch i386 -g -Wmost -fstack-protector-all \␊
     -D__ARCHITECTURE__=\"i386\" -DSAIO_INTERNAL_USER \␊
     -DRCZ_COMPRESSED_FILE_SUPPORT $(DEBUG) \␊
     -fno-builtin $(OMIT_FRAME_POINTER_CFLAG) \␊
-    -mpreferred-stack-boundary=2 -fno-align-functions -fno-stack-protector \␊
+    -mpreferred-stack-boundary=2 -fno-align-functions \␊
     -march=pentium4 -msse2 -mfpmath=sse -msoft-float -fno-common ␊
 ␊
 DEFINES=␊

-23
24 24
25 25
26 
26
27 27
28 28
29 29
30 30
31 
31
32 32
33 33
34 34
+␊
OPTIM = -Os -Oz␊
DEBUG = -DNOTHING␊
CFLAGS␉= $(RC_CFLAGS) $(OPTIM) $(MORECPP) -arch i386 -g -Wmost \␊
CFLAGS␉= $(RC_CFLAGS) $(OPTIM) $(MORECPP) -arch i386 -g -Wmost -fstack-protector-all \␊
    -D__ARCHITECTURE__=\"i386\" -DSAIO_INTERNAL_USER \␊
    -DRCZ_COMPRESSED_FILE_SUPPORT $(DEBUG) \␊
    -fno-builtin $(OMIT_FRAME_POINTER_CFLAG) \␊
    -mpreferred-stack-boundary=2 -fno-align-functions \␊
    -march=pentium4 -msse2 -mfpmath=sse -msoft-float -fno-common -fno-stack-protector #-fstack-protector-all␊
    -march=pentium4 -msse2 -mfpmath=sse -msoft-float -fno-common #-fstack-protector-all␊
␊
DEFINES=␊
CONFIG = hd␊
 ␊
 OPTIM = -Os -Oz␊
 DEBUG = -DNOTHING␊
-CFLAGS␉= $(RC_CFLAGS) $(OPTIM) $(MORECPP) -arch i386 -g -Wmost \␊
+CFLAGS␉= $(RC_CFLAGS) $(OPTIM) $(MORECPP) -arch i386 -g -Wmost -fstack-protector-all \␊
     -D__ARCHITECTURE__=\"i386\" -DSAIO_INTERNAL_USER \␊
     -DRCZ_COMPRESSED_FILE_SUPPORT $(DEBUG) \␊
     -fno-builtin $(OMIT_FRAME_POINTER_CFLAG) \␊
     -mpreferred-stack-boundary=2 -fno-align-functions \␊
-    -march=pentium4 -msse2 -mfpmath=sse -msoft-float -fno-common -fno-stack-protector #-fstack-protector-all␊
+    -march=pentium4 -msse2 -mfpmath=sse -msoft-float -fno-common #-fstack-protector-all␊
 ␊
 DEFINES=␊
 CONFIG = hd␊

-23
24 24
25 25
26 
26
27 27
28 28
29 29
30 
30
31 31
32 32
33 33
+␊
OPTIM = -Os -Oz␊
DEBUG = -DNOTHING␊
CFLAGS␉= $(RC_CFLAGS) $(OPTIM) $(MORECPP) -arch i386 -g -Wmost \␊
CFLAGS␉= $(RC_CFLAGS) $(OPTIM) $(MORECPP) -arch i386 -g -Wmost -fstack-protector-all \␊
    -D__ARCHITECTURE__=\"i386\" -DSAIO_INTERNAL_USER \␊
    -DRCZ_COMPRESSED_FILE_SUPPORT $(DEBUG) \␊
    -fno-builtin $(OMIT_FRAME_POINTER_CFLAG) \␊
    -mpreferred-stack-boundary=2 -fno-align-functions -fno-stack-protector \␊
    -mpreferred-stack-boundary=2 -fno-align-functions \␊
    -march=pentium4 -msse2 -mfpmath=sse -msoft-float -fno-common  ␊
␊
DEFINES=␊
 ␊
 OPTIM = -Os -Oz␊
 DEBUG = -DNOTHING␊
-CFLAGS␉= $(RC_CFLAGS) $(OPTIM) $(MORECPP) -arch i386 -g -Wmost \␊
+CFLAGS␉= $(RC_CFLAGS) $(OPTIM) $(MORECPP) -arch i386 -g -Wmost -fstack-protector-all \␊
     -D__ARCHITECTURE__=\"i386\" -DSAIO_INTERNAL_USER \␊
     -DRCZ_COMPRESSED_FILE_SUPPORT $(DEBUG) \␊
     -fno-builtin $(OMIT_FRAME_POINTER_CFLAG) \␊
-    -mpreferred-stack-boundary=2 -fno-align-functions -fno-stack-protector \␊
+    -mpreferred-stack-boundary=2 -fno-align-functions \␊
     -march=pentium4 -msse2 -mfpmath=sse -msoft-float -fno-common  ␊
 ␊
 DEFINES=␊

-23
24 24
25 25
26 
26
27 27
28 28
29 29
30 
30
31 31
32 32
33 33
+␊
OPTIM = -Os -Oz␊
DEBUG = -DNOTHING␊
CFLAGS␉= $(RC_CFLAGS) $(OPTIM) $(MORECPP) -arch i386 -g -Wmost \␊
CFLAGS␉= $(RC_CFLAGS) $(OPTIM) $(MORECPP) -arch i386 -g -Wmost -fstack-protector-all \␊
    -D__ARCHITECTURE__=\"i386\" -DSAIO_INTERNAL_USER \␊
    -DRCZ_COMPRESSED_FILE_SUPPORT $(DEBUG) \␊
    -fno-builtin $(OMIT_FRAME_POINTER_CFLAG) \␊
    -mpreferred-stack-boundary=2 -fno-align-functions -fno-stack-protector \␊
    -mpreferred-stack-boundary=2 -fno-align-functions \␊
    -march=pentium4 -msse2 -mfpmath=sse -msoft-float -fno-common ␊
␊
DEFINES=␊
 ␊
 OPTIM = -Os -Oz␊
 DEBUG = -DNOTHING␊
-CFLAGS␉= $(RC_CFLAGS) $(OPTIM) $(MORECPP) -arch i386 -g -Wmost \␊
+CFLAGS␉= $(RC_CFLAGS) $(OPTIM) $(MORECPP) -arch i386 -g -Wmost -fstack-protector-all \␊
     -D__ARCHITECTURE__=\"i386\" -DSAIO_INTERNAL_USER \␊
     -DRCZ_COMPRESSED_FILE_SUPPORT $(DEBUG) \␊
     -fno-builtin $(OMIT_FRAME_POINTER_CFLAG) \␊
-    -mpreferred-stack-boundary=2 -fno-align-functions -fno-stack-protector \␊
+    -mpreferred-stack-boundary=2 -fno-align-functions \␊
     -march=pentium4 -msse2 -mfpmath=sse -msoft-float -fno-common ␊
 ␊
 DEFINES=␊

-23
24 24
25 25
26 
26
27 27
28 28
29 29
30 
30
31 31
32 32
33 33
+␊
OPTIM = -Os -Oz␊
DEBUG = -DNOTHING␊
CFLAGS␉= $(RC_CFLAGS) $(OPTIM) $(MORECPP) -arch i386 -g -Wmost \␊
CFLAGS␉= $(RC_CFLAGS) $(OPTIM) $(MORECPP) -arch i386 -g -Wmost -fstack-protector-all \␊
    -D__ARCHITECTURE__=\"i386\" -DSAIO_INTERNAL_USER \␊
    -DRCZ_COMPRESSED_FILE_SUPPORT $(DEBUG) \␊
    -fno-builtin $(OMIT_FRAME_POINTER_CFLAG) \␊
    -mpreferred-stack-boundary=2 -fno-align-functions -fno-stack-protector \␊
    -mpreferred-stack-boundary=2 -fno-align-functions \␊
    -march=pentium4 -msse2 -mfpmath=sse -msoft-float -fno-common ␊
␊
DEFINES=␊
 ␊
 OPTIM = -Os -Oz␊
 DEBUG = -DNOTHING␊
-CFLAGS␉= $(RC_CFLAGS) $(OPTIM) $(MORECPP) -arch i386 -g -Wmost \␊
+CFLAGS␉= $(RC_CFLAGS) $(OPTIM) $(MORECPP) -arch i386 -g -Wmost -fstack-protector-all \␊
     -D__ARCHITECTURE__=\"i386\" -DSAIO_INTERNAL_USER \␊
     -DRCZ_COMPRESSED_FILE_SUPPORT $(DEBUG) \␊
     -fno-builtin $(OMIT_FRAME_POINTER_CFLAG) \␊
-    -mpreferred-stack-boundary=2 -fno-align-functions -fno-stack-protector \␊
+    -mpreferred-stack-boundary=2 -fno-align-functions \␊
     -march=pentium4 -msse2 -mfpmath=sse -msoft-float -fno-common ␊
 ␊
 DEFINES=␊

-23
24 24
25 25
26 
26
27 27
28 28
29 29
30 
30
31 31
32 32
33 33
+␊
OPTIM = -Os -Oz␊
DEBUG = -DNOTHING␊
CFLAGS␉= $(RC_CFLAGS) $(OPTIM) $(MORECPP) -arch i386 -g -Wmost \␊
CFLAGS␉= $(RC_CFLAGS) $(OPTIM) $(MORECPP) -arch i386 -g -Wmost -fstack-protector-all \␊
    -D__ARCHITECTURE__=\"i386\" -DSAIO_INTERNAL_USER \␊
    -DRCZ_COMPRESSED_FILE_SUPPORT $(DEBUG) \␊
    -fno-builtin $(OMIT_FRAME_POINTER_CFLAG) \␊
    -mpreferred-stack-boundary=2 -fno-align-functions -fno-stack-protector \␊
    -mpreferred-stack-boundary=2 -fno-align-functions \␊
    -march=pentium4 -msse2 -mfpmath=sse -msoft-float -fno-common  ␊
␊
DEFINES=␊
 ␊
 OPTIM = -Os -Oz␊
 DEBUG = -DNOTHING␊
-CFLAGS␉= $(RC_CFLAGS) $(OPTIM) $(MORECPP) -arch i386 -g -Wmost \␊
+CFLAGS␉= $(RC_CFLAGS) $(OPTIM) $(MORECPP) -arch i386 -g -Wmost -fstack-protector-all \␊
     -D__ARCHITECTURE__=\"i386\" -DSAIO_INTERNAL_USER \␊
     -DRCZ_COMPRESSED_FILE_SUPPORT $(DEBUG) \␊
     -fno-builtin $(OMIT_FRAME_POINTER_CFLAG) \␊
-    -mpreferred-stack-boundary=2 -fno-align-functions -fno-stack-protector \␊
+    -mpreferred-stack-boundary=2 -fno-align-functions \␊
     -march=pentium4 -msse2 -mfpmath=sse -msoft-float -fno-common  ␊
 ␊
 DEFINES=␊

-23
24 24
25 25
26 
26
27 27
28 28
29 29
30 
30
31 31
32 32
33 33
+␊
OPTIM = -Os -Oz␊
DEBUG = -DNOTHING␊
CFLAGS␉= $(RC_CFLAGS) $(OPTIM) $(MORECPP) -arch i386 -g -Wmost \␊
CFLAGS␉= $(RC_CFLAGS) $(OPTIM) $(MORECPP) -arch i386 -g -Wmost -fstack-protector-all \␊
    -D__ARCHITECTURE__=\"i386\" -DSAIO_INTERNAL_USER \␊
    -DRCZ_COMPRESSED_FILE_SUPPORT $(DEBUG) \␊
    -fno-builtin $(OMIT_FRAME_POINTER_CFLAG) \␊
    -mpreferred-stack-boundary=2 -fno-align-functions -fno-stack-protector \␊
    -mpreferred-stack-boundary=2 -fno-align-functions \␊
    -march=pentium4 -msse2 -mfpmath=sse -msoft-float -fno-common␊
␊
DEFINES=␊
 ␊
 OPTIM = -Os -Oz␊
 DEBUG = -DNOTHING␊
-CFLAGS␉= $(RC_CFLAGS) $(OPTIM) $(MORECPP) -arch i386 -g -Wmost \␊
+CFLAGS␉= $(RC_CFLAGS) $(OPTIM) $(MORECPP) -arch i386 -g -Wmost -fstack-protector-all \␊
     -D__ARCHITECTURE__=\"i386\" -DSAIO_INTERNAL_USER \␊
     -DRCZ_COMPRESSED_FILE_SUPPORT $(DEBUG) \␊
     -fno-builtin $(OMIT_FRAME_POINTER_CFLAG) \␊
-    -mpreferred-stack-boundary=2 -fno-align-functions -fno-stack-protector \␊
+    -mpreferred-stack-boundary=2 -fno-align-functions \␊
     -march=pentium4 -msse2 -mfpmath=sse -msoft-float -fno-common␊
 ␊
 DEFINES=␊

-23
24 24
25 25
26 
26
27 27
28 28
29 29
30 
30
31 31
32 32
33 33
+␊
OPTIM = -Os -Oz␊
DEBUG = -DNOTHING␊
CFLAGS␉= $(RC_CFLAGS) $(OPTIM) $(MORECPP) -arch i386 -g -Wmost \␊
CFLAGS␉= $(RC_CFLAGS) $(OPTIM) $(MORECPP) -arch i386 -g -Wmost -fstack-protector-all \␊
    -D__ARCHITECTURE__=\"i386\" -DSAIO_INTERNAL_USER \␊
    -DRCZ_COMPRESSED_FILE_SUPPORT $(DEBUG) \␊
    -fno-builtin $(OMIT_FRAME_POINTER_CFLAG) \␊
    -mpreferred-stack-boundary=2 -fno-align-functions -fno-stack-protector \␊
    -mpreferred-stack-boundary=2 -fno-align-functions \␊
    -march=pentium4 -msse2 -mfpmath=sse -msoft-float -fno-common  ␊
DEFINES=␊
CONFIG = hd␊
 ␊
 OPTIM = -Os -Oz␊
 DEBUG = -DNOTHING␊
-CFLAGS␉= $(RC_CFLAGS) $(OPTIM) $(MORECPP) -arch i386 -g -Wmost \␊
+CFLAGS␉= $(RC_CFLAGS) $(OPTIM) $(MORECPP) -arch i386 -g -Wmost -fstack-protector-all \␊
     -D__ARCHITECTURE__=\"i386\" -DSAIO_INTERNAL_USER \␊
     -DRCZ_COMPRESSED_FILE_SUPPORT $(DEBUG) \␊
     -fno-builtin $(OMIT_FRAME_POINTER_CFLAG) \␊
-    -mpreferred-stack-boundary=2 -fno-align-functions -fno-stack-protector \␊
+    -mpreferred-stack-boundary=2 -fno-align-functions \␊
     -march=pentium4 -msse2 -mfpmath=sse -msoft-float -fno-common  ␊
 DEFINES=␊
 CONFIG = hd␊

-23
24 24
25 25
26 
26
27 27
28 28
29 29
30 
30
31 31
32 32
33 33
+␊
OPTIM = -Os -Oz␊
DEBUG = -DNOTHING␊
CFLAGS␉= $(RC_CFLAGS) $(OPTIM) $(MORECPP) -arch i386 -g -Wmost \␊
CFLAGS␉= $(RC_CFLAGS) $(OPTIM) $(MORECPP) -arch i386 -g -Wmost -fstack-protector-all \␊
    -D__ARCHITECTURE__=\"i386\" -DSAIO_INTERNAL_USER \␊
    -DRCZ_COMPRESSED_FILE_SUPPORT $(DEBUG) \␊
    -fno-builtin $(OMIT_FRAME_POINTER_CFLAG) \␊
    -mpreferred-stack-boundary=2 -fno-align-functions -fno-stack-protector \␊
    -mpreferred-stack-boundary=2 -fno-align-functions \␊
    -march=pentium4 -msse2 -mfpmath=sse -msoft-float -fno-common  ␊
␊
DEFINES=␊
 ␊
 OPTIM = -Os -Oz␊
 DEBUG = -DNOTHING␊
-CFLAGS␉= $(RC_CFLAGS) $(OPTIM) $(MORECPP) -arch i386 -g -Wmost \␊
+CFLAGS␉= $(RC_CFLAGS) $(OPTIM) $(MORECPP) -arch i386 -g -Wmost -fstack-protector-all \␊
     -D__ARCHITECTURE__=\"i386\" -DSAIO_INTERNAL_USER \␊
     -DRCZ_COMPRESSED_FILE_SUPPORT $(DEBUG) \␊
     -fno-builtin $(OMIT_FRAME_POINTER_CFLAG) \␊
-    -mpreferred-stack-boundary=2 -fno-align-functions -fno-stack-protector \␊
+    -mpreferred-stack-boundary=2 -fno-align-functions \␊
     -march=pentium4 -msse2 -mfpmath=sse -msoft-float -fno-common  ␊
 ␊
 DEFINES=␊

-23
24 24
25 25
26 
26
27 27
28 28
29 29
30 
30
31 31
32 32
33 33
+␊
OPTIM = -Os -Oz␊
DEBUG = -DNOTHING␊
CFLAGS␉= $(RC_CFLAGS) $(OPTIM) $(MORECPP) -arch i386 -g -Wmost \␊
CFLAGS␉= $(RC_CFLAGS) $(OPTIM) $(MORECPP) -arch i386 -g -Wmost -fstack-protector-all \␊
    -D__ARCHITECTURE__=\"i386\" -DSAIO_INTERNAL_USER \␊
    -DRCZ_COMPRESSED_FILE_SUPPORT $(DEBUG) \␊
    -fno-builtin $(OMIT_FRAME_POINTER_CFLAG) \␊
    -mpreferred-stack-boundary=2 -fno-align-functions -fno-stack-protector \␊
    -mpreferred-stack-boundary=2 -fno-align-functions \␊
    -march=pentium4 -msse2 -mfpmath=sse  -msoft-float -fno-common ␊
␊
DEFINES=␊
 ␊
 OPTIM = -Os -Oz␊
 DEBUG = -DNOTHING␊
-CFLAGS␉= $(RC_CFLAGS) $(OPTIM) $(MORECPP) -arch i386 -g -Wmost \␊
+CFLAGS␉= $(RC_CFLAGS) $(OPTIM) $(MORECPP) -arch i386 -g -Wmost -fstack-protector-all \␊
     -D__ARCHITECTURE__=\"i386\" -DSAIO_INTERNAL_USER \␊
     -DRCZ_COMPRESSED_FILE_SUPPORT $(DEBUG) \␊
     -fno-builtin $(OMIT_FRAME_POINTER_CFLAG) \␊
-    -mpreferred-stack-boundary=2 -fno-align-functions -fno-stack-protector \␊
+    -mpreferred-stack-boundary=2 -fno-align-functions \␊
     -march=pentium4 -msse2 -mfpmath=sse  -msoft-float -fno-common ␊
 ␊
 DEFINES=␊

-106
107 107
108 108
109 
110 
111 
112 
113 
114 
115 
116 
117 
118 
119 
120 
121 
122 
123 
124 
125 
126 
127 
128 
129 
130 
131 
132 
133 
134 
135 
136 
137 
138 
139 
140 109
141 
142 
143 110
144 111
145 112
... ...
154 121
155 122
156 123
157 
124
158 125
159 126
160 127
... ...
190 157
191 158
192 159
193 
194 
160
161
195 162
196 
197 
198 163
199 164
200 165
... ...
206 171
207 172
208 173
209 
210 
211 
212 174
213 
214 175
215 176
216 177
... ...
802 763
803 764
804 765
805 
806 
807 
808 
809 
810 
811 
812 
813 
814 
815 
816 
817 
818 
819 
820 
821 
822 
823 
824 
825 
826 
827 
828 
829 
830 
831 
832 
833 
834 
835 
836 
837 
838 
839 
840 
841 
842 
843 
844 
845 
846 
847 
848 
849 
850 
851 
852 
853 
854 
855 
856 
857 
858 
859 
860 
861 
862 
863 
864 
865 
866 
867 
868 
869 
870 
871 
872 
873 
874 
875 
876 
877 
878 
879 
880 
881 
882 
883 
884 
885 
886 
887 
888 
889 
890 
891 
892 
893 
894 
895 
896 
897 
898 
899 
900 
901 
902 
903 
904 
905 
906 
907 
908 
909 
910 
911 
912 
913 
914 
915 
916 
917 
918 
919 
920 
921 
922 
923 
924 
925 
926 
927 
928 
929 
930 
931 
932 
933 
934 
935 
936 
937 
938 
939 
940 
941 
942 
943 
944 
945 
946 
947 
948 
949 
950 
951 
952 
953 
954 
955 
956 
957 
958 
959 
960 
961 
962 
963 
964 
965 
966 
967 
968 
969 
970 
971 
972 
973 
974 
975 
976 
977 
978 
979 
980 
981 
982 
983 
984 
985 
986 
987 
988 
989 
990 
991 
992 
993 
994 
995 
996 
997 
998 
999 
1000 
1001 
1002 
1003 
1004 
1005 
1006 
1007 
1008 
1009 
1010 
1011 
1012 
1013 
1014 
1015 
1016 
1017 
1018 
1019 
1020 
1021 
1022 
1023 
1024 
1025 
1026 
1027 
1028 
1029 
1030 
1031 
1032 
1033 
1034 
1035 
1036 
1037 
1038 
1039 
1040 
1041 
1042 
1043 
1044 
1045 
1046 
1047 
1048 
1049 
1050 
1051 
1052 
1053 
1054 
1055 
1056 
1057 
1058 
1059 
1060 
1061 
1062 
1063 
1064 
1065 
1066 
1067 
1068 
1069 
1070 
1071 
1072 
1073 
1074 
1075 
1076 
1077 
1078 
1079 
1080 
1081 
1082 
1083 
1084 
1085 
1086 
1087 
1088 
1089 
1090 
1091 
1092 
1093 
1094 
1095 
1096 
1097 
1098 
1099 
1100 
1101 
1102 
1103 
1104 
1105 
1106 
1107 
1108 
1109 
1110 
1111 
1112 
1113 
1114 
1115 
1116 
1117 
1118 
1119 
1120 
1121 
1122 
1123 
1124 
1125 
1126 
1127 
1128 
1129 
1130 
1131 
1132 
1133 
1134 
1135 
1136 
1137 
1138 
1139 
1140 
1141 
1142 
1143 
1144 
1145 
1146 
1147 
1148 
1149 
1150 
1151 
1152 
1153 
1154 
1155 
1156 
1157 
1158 
1159 
1160 
1161 
1162 
1163 
1164 
1165 
1166 
1167 
1168 
1169 
1170 
1171 
1172 
1173 
1174 
1175 
1176 
1177 
1178 
1179 
1180 
1181 
1182 
1183 
1184 
1185 
1186 
1187 
1188 
1189 
1190 
1191 
1192 
1193 
1194 
1195 
1196 
1197 
1198 
1199 
1200 
1201 
1202 
1203 
1204 
1205 
1206 
1207 
1208 
1209 
1210 
1211 
1212 
1213 
1214 
1215 
1216 
1217 
1218 
1219 
1220 
1221 
1222 
1223 
1224 
1225 
1226 
1227 
1228 
1229 
1230 
1231 
1232 
1233 
1234 
1235 
1236 
1237 
1238 
1239 
1240 
1241 
1242 
1243 
1244 
1245 
1246 
1247 
1248 
1249 
1250 
1251 
1252 
1253 
1254 
1255 
1256 
1257 
1258 
1259 
1260 
1261 
1262 
1263 
1264 
1265 
1266 
1267 
1268 
1269 
1270 
1271 
1272 
1273 
1274 
1275 
1276 
1277 
1278 
1279 
1280 
1281 
1282 
1283 
1284 
1285 
1286 
1287 
1288 
1289 
1290 
1291 
1292 
1293 
1294 
1295 
1296 
1297 
1298 
1299 
1300 
1301 
1302 
1303 
1304 
1305 
1306 
1307 
1308 
1309 
1310 
1311 
1312 
1313 
1314 
1315 
1316 
1317 
1318 
1319 
1320 
1321 
1322 
1323 
1324 
1325 
1326 
1327 
1328 
1329 
1330 
1331 
1332 
1333 
1334 
1335 
1336 
1337 
1338 
1339 
1340 
1341 
1342 
1343 
1344 
1345 
1346 
1347 
1348 
1349 
1350 
1351 
1352 
1353 
1354 
1355 
1356 
1357 
1358 
1359 
1360 
1361 
1362 
1363 
1364 
1365 
1366 
1367 
1368 
1369 
1370 
1371 
1372 
1373 
1374 
1375 
1376 
1377 
1378 
1379 
1380 
1381 
1382 
1383 
1384 
1385 
1386 
1387 
1388 
1389 
1390 
1391 
1392 
1393 
1394 
1395 
1396 
1397 
1398 
1399 
1400 
1401 
1402 
1403 
1404 
1405 
1406 
1407 
1408 
1409 
1410 
1411 
1412 
1413 
1414 
1415 
1416 
1417 
1418 
1419 
1420 
1421 
1422 
1423 
1424 
1425 
1426 
1427 
1428 
1429 
1430 
1431 
1432 
1433 
1434 
1435 
1436 
1437 
1438 
1439 
1440 
1441 
1442 
1443 
1444 
1445 
1446 
1447 
1448 
1449 
1450 
1451 
1452 
1453 
1454 
1455 
1456 
1457 
1458 
1459 
1460 
1461 
1462 
1463 
1464 
1465 
1466 
1467 
1468 
1469 
1470 
1471 
1472 
1473 
1474 
1475 
1476 
1477 
1478 
1479 
1480 
1481 
1482 
1483 
1484 766
1485 767
1486 768
... ...
1495 777
1496 778
1497 779
1498 
780
1499 781
1500 782
1501 783
... ...
1516 798
1517 799
1518 800
1519 
801
1520 802
1521 803
1522 804
... ...
1557 839
1558 840
1559 841
1560 
842
1561 843
1562 844
1563 845
... ...
1625 907
1626 908
1627 909
1628 
910
1629 911
1630 912
1631 913
... ...
1936 1218
1937 1219
1938 1220
1939 
1221
1940 1222
1941 1223
1942 1224
... ...
1990 1272
1991 1273
1992 1274
1993 
1275
1994 1276
1995 1277
1996 1278
... ...
2140 1422
2141 1423
2142 1424
2143 
2144 
2145 
2146 
2147 
2148 
2149 
2150 
2151 
2152 
2153 
2154 
2155 
2156 
2157 
2158 
2159 
2160 
2161 
2162 
2163 
2164 
2165 
2166 
2167 
2168 
2169 
2170 
2171 
2172 
2173 
2174 
2175 
2176 1425
1426
1427
1428
1429
1430
1431
1432
1433
1434
1435
1436
1437
1438
1439
1440
1441
1442
1443
1444
1445
1446
1447
1448
1449
1450
1451
1452
1453
1454
1455
1456
1457
1458
2177 1459
2178 1460
2179 1461
... ...
2186 1468
2187 1469
2188 1470
2189 
1471
2190 1472
2191 1473
2192 1474
... ...
2423 1705
2424 1706
2425 1707
2426 
1708
2427 1709
2428 1710
2429 1711
... ...
2802 2084
2803 2085
2804 2086
2805 
2087
2806 2088
2807 2089
2808 2090
... ...
4070 3352
4071 3353
4072 3354
4073 
3355
4074 3356
4075 3357
4076 3358
... ...
4283 3565
4284 3566
4285 3567
4286 
3568
4287 3569
4288 3570
4289 3571
... ...
4621 3903
4622 3904
4623 3905
4624 
4625 3906
4626 3907
4627 3908
... ...
5330 4611
5331 4612
5332 4613
5333 
5334 4614
5335 4615
5336 
5337 4616
5338 4617
5339 4618
... ...
5358 4637
5359 4638
5360 4639
5361 
5362 4640
5363 
5364 4641
5365 4642
5366 4643
5367 
5368 4644
5369 
5370 4645
5371 4646
5372 4647
... ...
5668 4943
5669 4944
5670 4945
5671 
5672 
5673 
5674 
5675 
5676 
5677 
5678 
5679 
5680 
5681 
5682 
5683 
5684 
5685 
5686 
5687 
5688 
5689 
5690 
5691 
5692 
5693 
5694 
5695 
5696 
5697 
5698 
5699 
5700 
5701 
5702 
5703 
5704 
5705 
5706 
5707 
5708 
5709 
5710 
5711 
5712 
5713 
5714 
4946
5715 4947
5716 4948
5717 4949
... ...
5749 4981
5750 4982
5751 4983
5752 
5753 4984
5754 4985
5755 4986
+static U32 process_rsdt(ACPI_TABLE_RSDP *rsdp_mod , bool gen_xsdt, U32 *new_table_list);␊
static ACPI_TABLE_FADT * patch_fadt(ACPI_TABLE_FADT *fadt, ACPI_TABLE_DSDT *new_dsdt, bool UpdateFADT);␊
␊
#if OLD_SSDT␊
#include "modules.h"␊
struct aml_chunk ␊
{␊
␉unsigned char␉␉Type;␊
␉unsigned int␉␉Length;␊
␉char*␉␉␉␉Buffer;␊
␉␊
␉unsigned int␉␉Size;␊
␉␊
␉struct aml_chunk*␉Next;␊
␉struct aml_chunk*␉First;␊
␉struct aml_chunk*␉Last;␊
};␊
static U32 get_needed_symbols (void);␊
static ACPI_TABLE_SSDT *generate_cst_ssdt(ACPI_TABLE_FADT* fadt);␊
static ACPI_TABLE_SSDT *generate_pss_ssdt(ACPI_TABLE_DSDT* dsdt);␊
struct aml_chunk* (*aml_create_node)(struct aml_chunk*) = NULL;␉␉␉␊
struct aml_chunk* (*aml_add_buffer)(struct aml_chunk*,const char*, unsigned int) = NULL;␉␉␉␊
struct aml_chunk* (*aml_add_byte)(struct aml_chunk*, unsigned char) = NULL;␉␉␉␊
struct aml_chunk* (*aml_add_word)(struct aml_chunk*, unsigned int) = NULL;␊
struct aml_chunk* (*aml_add_dword)(struct aml_chunk*, unsigned long) = NULL;␉␉␉␊
struct aml_chunk* (*aml_add_qword)(struct aml_chunk*, unsigned long long) = NULL;␉␉␉␊
struct aml_chunk* (*aml_add_scope)(struct aml_chunk*, const char*) = NULL;␊
struct aml_chunk* (*aml_add_name)(struct aml_chunk*, const char*) = NULL;␉␉␉␊
struct aml_chunk* (*aml_add_package)(struct aml_chunk*) = NULL;␉␉␉␊
struct aml_chunk* (*aml_add_alias)(struct aml_chunk*, const char*, const char*) = NULL;␉␉␉␊
void (*aml_destroy_node)(struct aml_chunk*) = NULL;␊
unsigned int (*aml_calculate_size)(struct aml_chunk*) = NULL;␊
unsigned int (*aml_write_node)(struct aml_chunk*, char*, unsigned int) = NULL;␊
bool (*aml_add_to_parent)(struct aml_chunk*, struct aml_chunk*) = NULL;␊
␊
#else␊
␊
#define IA32_MISC_ENABLES 0x01A0␊
#define MSR_TURBO_POWER_CURRENT_LIMIT 0x1AC␊
#define MSR_PKG_CST_CONFIG_CONTROL 0x00E2␊

static U32 encode_pstate(U32 ratio);␊
static void collect_cpu_info(CPU_DETAILS * cpu);␊
#ifndef BETA␊
static U32 BuildCoreIPstateInfo(CPU_DETAILS * cpu);␊
//static U32 BuildCoreIPstateInfo(CPU_DETAILS * cpu);␊
#endif␊
static U32 BuildCstateInfo(CPU_DETAILS * cpu, U32 pmbase);␊
static U32 BuildPstateInfo(CPU_DETAILS * cpu);␊

static bool is_sandybridge(void);␊
static bool is_jaketown(void);␊
static U32 get_bclk(void);␊
static U32 computePstateRatio(const U32 max, const U32 min, const U32 turboEnabled, const U32 numStates, const U32 pstate);␊
static U32 computeNumPstates(const U32 max, const U32 min, const U32 turboEnabled, const U32 pssLimit);␊
//static U32 computePstateRatio(const U32 max, const U32 min, const U32 turboEnabled, const U32 numStates, const U32 pstate);␊
//static U32 computeNumPstates(const U32 max, const U32 min, const U32 turboEnabled, const U32 pssLimit);␊
␊
#endif // OLD_SSDT␊
␊
#if UNUSED␊
static ACPI_TABLE_FACS* generate_facs(bool updatefacs );␊
#endif␊

// Security space for SSDT , FACP & MADT table generation,␊
// the size can be increased ␊
// note: the table will not placed in the reserved space if the 'normal' space is not full␊
#if OLD_SSDT␊
#define RESERVED_AERA 4␊
#else␊
#define RESERVED_AERA 3␊
#endif␊
␊
#define ACPI_TABLE_LIST_FULL MAX_ACPI_TABLE + RESERVED_AERA + 1␊
␊

    return (cpu_map_error = 0);␊
}␊
␊
#if OLD_SSDT␊
␊
static U32 get_needed_symbols (void)␊
{␉␊
␉/* aml_generator symbols */␊
␉aml_create_node = (void*)lookup_all_symbols("_aml_create_node");␊
␉if (aml_create_node == (void*)0xFFFFFFFF) goto Failed;␊
␉␊
␉aml_add_buffer = (void*)lookup_all_symbols("_aml_add_buffer");␊
␉if (aml_add_buffer == (void*)0xFFFFFFFF) goto Failed;␊
␉␊
␉aml_add_byte = (void*)lookup_all_symbols("_aml_add_byte");␊
␉if (aml_add_byte == (void*)0xFFFFFFFF) goto Failed;␊
␉␊
␉aml_add_word = (void*)lookup_all_symbols("_aml_add_word");␊
␉if (aml_add_word == (void*)0xFFFFFFFF) goto Failed;␊
␉␊
␉aml_add_dword = (void*)lookup_all_symbols("_aml_add_dword");␊
␉if (aml_add_dword == (void*)0xFFFFFFFF) goto Failed;␊
␉␊
␉aml_add_qword = (void*)lookup_all_symbols("_aml_add_qword");␊
␉if (aml_add_qword == (void*)0xFFFFFFFF) goto Failed;␊
␉␊
␉aml_add_scope = (void*)lookup_all_symbols("_aml_add_scope");␊
␉if (aml_add_scope == (void*)0xFFFFFFFF) goto Failed;␊
␉␊
␉aml_add_name = (void*)lookup_all_symbols("_aml_add_name");␊
␉if (aml_add_name == (void*)0xFFFFFFFF) goto Failed;␊
␉␊
␉aml_add_package = (void*)lookup_all_symbols("_aml_add_package");␊
␉if (aml_add_package == (void*)0xFFFFFFFF) goto Failed;␊
␉␊
␉aml_add_alias = (void*)lookup_all_symbols("_aml_add_alias");␊
␉if (aml_add_alias == (void*)0xFFFFFFFF) goto Failed;␊
␉␊
␉aml_destroy_node = (void*)lookup_all_symbols("_aml_destroy_node");␊
␉if (aml_destroy_node == (void*)0xFFFFFFFF) goto Failed;␊
␉␊
␉aml_calculate_size = (void*)lookup_all_symbols("_aml_calculate_size");␉␊
␉if (aml_calculate_size == (void*)0xFFFFFFFF) goto Failed;␊
␉␊
␉aml_write_node = (void*)lookup_all_symbols("_aml_write_node");␊
␉if (aml_write_node == (void*)0xFFFFFFFF) goto Failed;␊
␉␊
␉aml_add_to_parent = (void*)lookup_all_symbols("_aml_add_to_parent");␊
␉if (aml_add_to_parent == (void*)0xFFFFFFFF) goto Failed;␊
␉␊
␉DBG("struct aml_chunk* _aml_create_node: 0x%x\n",(UInt32)aml_create_node);␊
␉DBG("struct aml_chunk* _aml_add_buffer: 0x%x\n",(UInt32)aml_add_buffer);␊
␉DBG("struct aml_chunk* _aml_add_byte: 0x%x\n",(UInt32)aml_add_byte);␊
␉DBG("struct aml_chunk* _aml_add_word: 0x%x\n",(UInt32)aml_add_word);␊
␉DBG("struct aml_chunk* _aml_add_dword: 0x%x\n",(UInt32)aml_add_dword);␊
␉DBG("struct aml_chunk* _aml_add_qword: 0x%x\n",(UInt32)aml_add_qword);␊
␉DBG("struct aml_chunk* _aml_add_scope: 0x%x\n",(UInt32)aml_add_scope);␊
␉DBG("struct aml_chunk* _aml_add_name: 0x%x\n",(UInt32)aml_add_name);␊
␉DBG("struct aml_chunk* _aml_add_package: 0x%x\n",(UInt32)aml_add_package);␊
␉DBG("struct aml_chunk* _aml_add_alias: 0x%x\n",(UInt32)aml_add_alias);␊
␉DBG("void _aml_destroy_node: 0x%x\n",(UInt32)aml_destroy_node);␊
␉DBG("unsigned int _aml_calculate_size: 0x%x\n",(UInt32)aml_calculate_size);␊
␉DBG("unsigned int _aml_write_node: 0x%x\n",(UInt32)aml_write_node);␊
␉DBG("bool _aml_add_to_parent: 0x%x\n",(UInt32)aml_add_to_parent);␉␊
␉return (1);␊
Failed:␊
␉printf("Failed to find aml_generator symbols, SSDT will not be generated !!!");␊
␉return (0);␊
}␊
␊
static ACPI_TABLE_SSDT *generate_cst_ssdt(ACPI_TABLE_FADT* fadt)␊
{␉␊
␉char ssdt_header[] =␊
␉{␊
␉␉0x53, 0x53, 0x44, 0x54, 0xE7, 0x00, 0x00, 0x00, /* SSDT.... */␊
␉␉0x01, 0x17, 0x50, 0x6D, 0x52, 0x65, 0x66, 0x41, /* ..PmRefA */␊
␉␉0x43, 0x70, 0x75, 0x43, 0x73, 0x74, 0x00, 0x00, /* CpuCst.. */␊
␉␉0x00, 0x10, 0x00, 0x00, 0x49, 0x4E, 0x54, 0x4C, /* ....INTL */␊
␉␉0x31, 0x03, 0x10, 0x20 ␉␉␉␉␉␉␉/* 1.._␉␉*/␊
␉};␊
␉␊
␉char cstate_resource_template[] = ␊
␉{␊
␉␉0x11, 0x14, 0x0A, 0x11, 0x82, 0x0C, 0x00, 0x7F, ␊
␉␉0x01, 0x02, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, ␊
␉␉0x00, 0x00, 0x00, 0x79, 0x00␊
␉};␊
␉␊
␉if (Platform->CPU.Vendor != 0x756E6547) {␊
␉␉verbose ("Not an Intel platform: C-States will not be generated !!!\n");␊
␉␉return (void *)0ul;␊
␉}␊
␉␊
␉if (fadt == (void *)0ul) {␊
␉␉verbose ("FACP not exists: C-States will not be generated !!!\n");␊
␉␉return (void *)0ul;␊
␉}␊
    ␊
␉ACPI_TABLE_DSDT* dsdt = ((fadt->Header.Revision >= 3) && (fadt->XDsdt != 0)) ? (ACPI_TABLE_DSDT*)((U32)fadt->XDsdt):(ACPI_TABLE_DSDT*)fadt->Dsdt;␊
␉if (dsdt == (void *)0ul) {␊
␉␉verbose ("DSDT not found: C-States will not be generated !!!\n");␊
␉␉return (void *)0ul;␊
␉}␊
␉␉␊
␉if (generate_cpu_map_from_acpi(dsdt) == 0) ␊
␉{␊
␉␉bool c2_enabled = fadt->C2Latency < 100;␊
␉␉bool c3_enabled = fadt->C3Latency < 1000;␊
␉␉bool c4_enabled = false;␊
␉␉␊
␉␉getBoolForKey(kEnableC4State, &c4_enabled, &bootInfo->bootConfig);␊
        ␊
␉␉unsigned char cstates_count = 1 + (c2_enabled ? 1 : 0) + ((c3_enabled || c4_enabled) ? 1 : 0);␊
␉␉char *Lat = NULL, *Pw = NULL, *tmpstr =NULL;␊
␉␉int base = 16;␊
␉␉TagPtr personality = XMLCastDict(XMLGetProperty(bootInfo->bootConfig.dictionary, (const char*)"C-States"));␊
␉␉␊
␉␉if ((tmpstr = XMLCastString(XMLGetProperty(personality, (const char*)"Base")))) {␊
␉␉␉␊
␉␉␉int mybase = strtol(tmpstr, NULL, 10);␉␊
␉␉␉␊
␉␉␉if (mybase == 8 || mybase == 10 || mybase == 16 ) ␊
␉␉␉␉base = mybase;␉␉␉␉␉␉␉␉␉␊
␉␉}␊
␉␉␊
␉␉struct aml_chunk* root = aml_create_node(NULL);␊
        aml_add_buffer(root, ssdt_header, sizeof(ssdt_header)); // SSDT header␊
        struct aml_chunk* scop;␊
␉␉if (cpuNamespace == CPU_NAMESPACE_PR) ␊
␉␉␉scop = aml_add_scope(root, "\\_PR_");␊
␉␉else if (cpuNamespace == CPU_NAMESPACE_SB) ␊
␉␉␉scop = aml_add_scope(root, "\\_SB_");␊
␉␉else ␊
␉␉{␊
␉␉␉aml_destroy_node(root);␉␊
␉␉␉goto out;␊
␉␉}␊
        struct aml_chunk* name = aml_add_name(scop, "CST_");␊
        struct aml_chunk* pack = aml_add_package(name);␊
        aml_add_byte(pack, cstates_count);␊
␉␉␊
        struct aml_chunk* tmpl = aml_add_package(pack);␊
        TagPtr match_Status = XMLGetProperty(personality, (const char*)"C1");␊
        if (match_Status) {␉␊
            Pw   = XMLCastString(XMLGetProperty(match_Status, (const char*)"Power"));␊
            Lat  = XMLCastString(XMLGetProperty(match_Status, (const char*)"Latency"));␊
        }␊
        cstate_resource_template[11] = 0x00; // C1␊
        aml_add_buffer(tmpl, cstate_resource_template, sizeof(cstate_resource_template));␊
        aml_add_byte(tmpl, 0x01); // C1␊
        aml_add_byte(tmpl, (unsigned char)resolve_cst(0x01, Lat, base));  // Latency␊
        aml_add_word(tmpl, resolve_cst(0x03e8, Pw, base)); // Power␊
␉␉// C2␊
␉␉if (c2_enabled) ␊
␉␉{␊
␉␉␉tmpl = aml_add_package(pack);␊
␉␉␉Lat = NULL; ␊
␉␉␉Pw = NULL;␊
␉␉␉match_Status = XMLGetProperty(personality, (const char*)"C2");␊
␉␉␉if (match_Status) {␉␊
␉␉␉␉Pw   = XMLCastString(XMLGetProperty(match_Status, (const char*)"Power"));␊
␉␉␉␉Lat  = XMLCastString(XMLGetProperty(match_Status, (const char*)"Latency"));␊
␉␉␉}␊
␉␉␉␊
␉␉␉cstate_resource_template[11] = 0x10; // C2␊
␉␉␉aml_add_buffer(tmpl, cstate_resource_template, sizeof(cstate_resource_template));␊
␉␉␉aml_add_byte(tmpl, 0x02); // C2␉␉␉␉␊
␉␉␉aml_add_word(tmpl, resolve_cst(fadt->C2Latency, Lat, base));  // Latency␊
␉␉␉aml_add_word(tmpl, resolve_cst(0x01f4, Pw, base)); // Power␊
␉␉}␊
␉␉␊
␉␉// C4␊
␉␉if (c4_enabled) ␊
␉␉{␊
␉␉␉tmpl = aml_add_package(pack);␊
␉␉␉Lat = NULL; ␊
␉␉␉Pw = NULL;␊
␉␉␉match_Status = XMLGetProperty(personality, (const char*)"C4"); ␊
␉␉␉if (match_Status) {␉␊
␉␉␉␉Pw   = XMLCastString(XMLGetProperty(match_Status, (const char*)"Power"));␊
␉␉␉␉Lat  = XMLCastString(XMLGetProperty(match_Status, (const char*)"Latency"));␊
␉␉␉}␊
␉␉␉cstate_resource_template[11] = 0x30; // C4␊
␉␉␉aml_add_buffer(tmpl, cstate_resource_template, sizeof(cstate_resource_template));␊
␉␉␉aml_add_byte(tmpl, 0x04); // C4␉␊
␉␉␉aml_add_word(tmpl, resolve_cst(fadt->C3Latency / 2, Lat, base));  // TODO: right latency for C4␊
␉␉␉aml_add_word(tmpl, resolve_cst(0xfa, Pw, base)); // Power␊
␉␉␉␊
␉␉␉// you can check if the C4 state is correctly activated or not with the following command Lines (you will need the 'lspci for mac' package): ␊
␉␉␉␊
␉␉␉// according to the intel ich10 dataheet ( Power Management PCI Configuration Registers (PM—D31:F0) ):␊
␉␉␉// setpci -s 0:1f.0 0xa0.w (must return an hex where bit 12 is 0 and bit 7 is 1, usually 06a0h )␊
␉␉␉// setpci -s 0:1f.0 0xa6.b (must return an hex where bit 7 is 1, usually 80h )␊
␉␉␉␊
␉␉␉␊
␉␉}␉␉␊
␉␉// C3␊
␉␉else if (c3_enabled) ␊
␉␉{␊
␉␉␉tmpl = aml_add_package(pack);␊
␉␉␉Lat = NULL; ␊
␉␉␉Pw = NULL;␊
␉␉␉match_Status = XMLGetProperty(personality, (const char*)"C3"); ␊
␉␉␉if (match_Status) {␉␊
␉␉␉␉Pw   = XMLCastString(XMLGetProperty(match_Status, (const char*)"Power"));␊
␉␉␉␉Lat  = XMLCastString(XMLGetProperty(match_Status, (const char*)"Latency"));␊
␉␉␉}␊
␉␉␉cstate_resource_template[11] = 0x20; // C3␊
␉␉␉aml_add_buffer(tmpl, cstate_resource_template, sizeof(cstate_resource_template));␊
␉␉␉aml_add_byte(tmpl, 0x03); // C3␉␉␉␉␊
␉␉␉aml_add_word(tmpl, resolve_cst(fadt->C3Latency , Lat, base));  ␊
␉␉␉aml_add_word(tmpl, resolve_cst(0x015e, Pw, base)); // Power␊
␉␉␉␊
␉␉}␊
␉␉        ␊
        // Aliaces␊
        unsigned int i;␊
        for (i = 0; i < cpu_map_count; i++) ␊
        {␊
            char name[9];␊
            U32 nseg = *(U32*)cpu_map[i].nameseg;␊
            if (cpuNamespace == CPU_NAMESPACE_PR) {␊
                sprintf(name, "_PR_%c%c%c%c",␊
                        (int)(nseg & 0x000000ff),␊
                        (int)((nseg & 0x0000ff00) >> 8),␊
                        (int)((nseg & 0x00ff0000) >> 16),␊
                        (int)(nseg >> 24));␊
            } else if (cpuNamespace == CPU_NAMESPACE_SB) {␊
                sprintf(name, "_SB_%c%c%c%c",␊
                        (int)(nseg & 0x000000ff),␊
                        (int)((nseg & 0x0000ff00) >> 8),␊
                        (int)((nseg & 0x00ff0000) >> 16),␊
                        (int)(nseg >> 24));␊
            } else {␊
                aml_destroy_node(root);␉␊
                goto out;␊
            }␊
            ␊
            scop = aml_add_scope(root, name);␊
            aml_add_alias(scop, "CST_", "_CST");␊
        }␊
␉␉␊
␉␉aml_calculate_size(root);␊
␉␉␊
␉␉ACPI_TABLE_SSDT *ssdt = (ACPI_TABLE_SSDT *)AllocateKernelMemory(root->Size);␊
        ␊
␉␉aml_write_node(root, (void*)ssdt, 0);␊
␉␉␊
␉␉ssdt->Header.Length = root->Size;        ␊
␉␉␊
␉␉SetChecksum(&ssdt->Header);␊
        ␊
␉␉aml_destroy_node(root);␉␉␊
        ␊
␉␉verbose ("SSDT with CPU C-States generated successfully\n");␊
␉␉␊
␉␉return ssdt;␊
␉}␊
␉else ␊
␉{␊
out:␊
␉␉verbose ("ACPI CPUs not found: C-States will not be generated !!!\n");␊
␉}␊
    ␊
␉return (void *)0ul;␊
}␊
␊
static ACPI_TABLE_SSDT *generate_pss_ssdt(ACPI_TABLE_DSDT* dsdt)␊
{␉␉␊
␉␊
␉char ssdt_header[] =␊
␉{␊
␉␉0x53, 0x53, 0x44, 0x54, 0x7E, 0x00, 0x00, 0x00, /* SSDT.... */␊
␉␉0x01, 0x6A, 0x50, 0x6D, 0x52, 0x65, 0x66, 0x00, /* ..PmRef. */␊
␉␉0x43, 0x70, 0x75, 0x50, 0x6D, 0x00, 0x00, 0x00, /* CpuPm... */␊
␉␉0x00, 0x30, 0x00, 0x00, 0x49, 0x4E, 0x54, 0x4C, /* .0..INTL */␊
␉␉0x31, 0x03, 0x10, 0x20,␉␉␉␉␉␉␉/* 1.._␉␉*/␊
␉};␊
    ␊
␉if (Platform->CPU.Vendor != 0x756E6547) {␊
␉␉verbose ("Not an Intel platform: P-States will not be generated !!!\n");␊
␉␉return (void *)0ul;␊
␉}␊
␉␊
␉if (!(Platform->CPU.Features & CPUID_FEATURE_MSR)) {␊
␉␉verbose ("Unsupported CPU: P-States will not be generated !!!\n");␊
␉␉return (void *)0ul;␊
␉}␊
␉␊
␉if (dsdt == (void *)0ul) {␊
␉␉verbose ("DSDT not found: P-States will not be generated !!!\n");␊
␉␉return (void *)0ul;␊
␉}␊
␉␉   ␊
␉if (generate_cpu_map_from_acpi(dsdt) == 0 ) ␊
␉{␊
␉␉struct p_state /*initial,*/ maximum, minimum, p_states[32];␊
␉␉U8 p_states_count = 0;␉␉␊
␉␉␊
␉␉// Retrieving P-States, ported from code by superhai (c)␊
␉␉switch (Platform->CPU.Family) {␊
␉␉␉case 0x06: ␊
␉␉␉{␊
␉␉␉␉switch (Platform->CPU.Model) ␊
␉␉␉␉{␊
␉␉␉␉␉case CPUID_MODEL_DOTHAN: ␊
␉␉␉␉␉case CPUID_MODEL_YONAH: // Yonah␊
␉␉␉␉␉case CPUID_MODEL_MEROM: // Merom␊
␉␉␉␉␉case CPUID_MODEL_PENRYN: // Penryn␊
␉␉␉␉␉case CPUID_MODEL_ATOM: // Intel Atom (45nm)␊
␉␉␉␉␉{␊
␉␉␉␉␉␉bool cpu_dynamic_fsb = false;␊
␉␉␉␉␉␉␊
␉␉␉␉␉␉if (rdmsr64(MSR_IA32_EXT_CONFIG) & (1 << 27)) ␊
␉␉␉␉␉␉{␊
␉␉␉␉␉␉␉wrmsr64(MSR_IA32_EXT_CONFIG, (rdmsr64(MSR_IA32_EXT_CONFIG) | (1 << 28))); ␊
␉␉␉␉␉␉␉delay(1);␊
␉␉␉␉␉␉␉cpu_dynamic_fsb = rdmsr64(MSR_IA32_EXT_CONFIG) & (1 << 28);␊
␉␉␉␉␉␉}␊
␉␉␉␉␉␉␊
␉␉␉␉␉␉bool cpu_noninteger_bus_ratio = (rdmsr64(MSR_IA32_PERF_STATUS) & (1ULL << 46));␊
␉␉␉␉␉␉␊
␉␉␉␉␉␉initial.Control = rdmsr64(MSR_IA32_PERF_STATUS);␊
␉␉␉␉␉␉␊
␉␉␉␉␉␉maximum.Control = ((rdmsr64(MSR_IA32_PERF_STATUS) >> 32) & 0x1F3F) | (0x4000 * cpu_noninteger_bus_ratio);␊
␉␉␉␉␉␉maximum.CID = ((maximum.FID & 0x1F) << 1) | cpu_noninteger_bus_ratio;␊
␉␉␉␉␉␉␊
␉␉␉␉␉␉minimum.FID = ((rdmsr64(MSR_IA32_PERF_STATUS) >> 24) & 0x1F) | (0x80 * cpu_dynamic_fsb);␊
␉␉␉␉␉␉minimum.VID = ((rdmsr64(MSR_IA32_PERF_STATUS) >> 48) & 0x3F);␊
␉␉␉␉␉␉␊
␉␉␉␉␉␉if (minimum.FID == 0) ␊
␉␉␉␉␉␉{␊
␉␉␉␉␉␉␉U64 msr;␊
␉␉␉␉␉␉␉U8 i;␊
␉␉␉␉␉␉␉// Probe for lowest fid␊
␉␉␉␉␉␉␉for (i = maximum.FID; i >= 0x6; i--) ␊
␉␉␉␉␉␉␉{␊
␉␉␉␉␉␉␉␉msr = rdmsr64(MSR_IA32_PERF_CONTROL);␊
␉␉␉␉␉␉␉␉wrmsr64(MSR_IA32_PERF_CONTROL, (msr & 0xFFFFFFFFFFFF0000ULL) | (i << 8) | minimum.VID);␊
␉␉␉␉␉␉␉␉intel_waitforsts();␊
␉␉␉␉␉␉␉␉minimum.FID = (rdmsr64(MSR_IA32_PERF_STATUS) >> 8) & 0x1F; ␊
␉␉␉␉␉␉␉␉delay(1);␊
␉␉␉␉␉␉␉}␊
␉␉␉␉␉␉␉␊
␉␉␉␉␉␉␉msr = rdmsr64(MSR_IA32_PERF_CONTROL);␊
␉␉␉␉␉␉␉wrmsr64(MSR_IA32_PERF_CONTROL, (msr & 0xFFFFFFFFFFFF0000ULL) | (maximum.FID << 8) | maximum.VID);␊
␉␉␉␉␉␉␉intel_waitforsts();␊
␉␉␉␉␉␉}␊
␉␉␉␉␉␉␊
␉␉␉␉␉␉if (minimum.VID == maximum.VID) ␊
␉␉␉␉␉␉{␉␊
␉␉␉␉␉␉␉U64 msr;␊
␉␉␉␉␉␉␉U8 i;␊
␉␉␉␉␉␉␉// Probe for lowest vid␊
␉␉␉␉␉␉␉for (i = maximum.VID; i > 0xA; i--) ␊
␉␉␉␉␉␉␉{␊
␉␉␉␉␉␉␉␉msr = rdmsr64(MSR_IA32_PERF_CONTROL);␊
␉␉␉␉␉␉␉␉wrmsr64(MSR_IA32_PERF_CONTROL, (msr & 0xFFFFFFFFFFFF0000ULL) | (minimum.FID << 8) | i);␊
␉␉␉␉␉␉␉␉intel_waitforsts();␊
␉␉␉␉␉␉␉␉minimum.VID = rdmsr64(MSR_IA32_PERF_STATUS) & 0x3F; ␊
␉␉␉␉␉␉␉␉delay(1);␊
␉␉␉␉␉␉␉}␊
␉␉␉␉␉␉␉␊
␉␉␉␉␉␉␉msr = rdmsr64(MSR_IA32_PERF_CONTROL);␊
␉␉␉␉␉␉␉wrmsr64(MSR_IA32_PERF_CONTROL, (msr & 0xFFFFFFFFFFFF0000ULL) | (maximum.FID << 8) | maximum.VID);␊
␉␉␉␉␉␉␉intel_waitforsts();␊
␉␉␉␉␉␉}␊
␉␉␉␉␉␉␊
␉␉␉␉␉␉minimum.CID = ((minimum.FID & 0x1F) << 1) >> cpu_dynamic_fsb;␊
␉␉␉␉␉␉␊
␉␉␉␉␉␉// Sanity check␊
␉␉␉␉␉␉if (maximum.CID < minimum.CID) ␊
␉␉␉␉␉␉{␊
␉␉␉␉␉␉␉DBG("Insane FID values!");␊
␉␉␉␉␉␉␉p_states_count = 0;␊
␉␉␉␉␉␉}␊
␉␉␉␉␉␉else␊
␉␉␉␉␉␉{␊
␉␉␉␉␉␉␉// Finalize P-States␊
␉␉␉␉␉␉␉// Find how many P-States machine supports␊
␉␉␉␉␉␉␉p_states_count = maximum.CID - minimum.CID + 1;␊
␉␉␉␉␉␉␉␊
␉␉␉␉␉␉␉if (p_states_count > 32) // MAX_PSTATES ??␊
␉␉␉␉␉␉␉␉p_states_count = 32; // MAX_PSTATES ??␊
␉␉␉␉␉␉␉␊
␉␉␉␉␉␉␉U8 vidstep;␊
␉␉␉␉␉␉␉U8 i = 0, u, invalid = 0;␊
␉␉␉␉␉␉␉␊
␉␉␉␉␉␉␉vidstep = ((maximum.VID << 2) - (minimum.VID << 2)) / (p_states_count - 1);␊
␉␉␉␉␉␉␉␊
␉␉␉␉␉␉␉for (u = 0; u < p_states_count; u++) ␊
␉␉␉␉␉␉␉{␊
␉␉␉␉␉␉␉␉i = u - invalid;␊
␉␉␉␉␉␉␉␉␊
␉␉␉␉␉␉␉␉p_states[i].CID = maximum.CID - u;␊
␉␉␉␉␉␉␉␉p_states[i].FID = (p_states[i].CID >> 1);␊
␉␉␉␉␉␉␉␉␊
␉␉␉␉␉␉␉␉if (p_states[i].FID < 0x6) ␊
␉␉␉␉␉␉␉␉{␊
␉␉␉␉␉␉␉␉␉if (cpu_dynamic_fsb) ␊
␉␉␉␉␉␉␉␉␉␉p_states[i].FID = (p_states[i].FID << 1) | 0x80;␊
␉␉␉␉␉␉␉␉} ␊
␉␉␉␉␉␉␉␉else if (cpu_noninteger_bus_ratio) ␊
␉␉␉␉␉␉␉␉{␊
␉␉␉␉␉␉␉␉␉p_states[i].FID = p_states[i].FID | (0x40 * (p_states[i].CID & 0x1));␊
␉␉␉␉␉␉␉␉}␊
␉␉␉␉␉␉␉␉␊
␉␉␉␉␉␉␉␉if (i && p_states[i].FID == p_states[i-1].FID)␊
␉␉␉␉␉␉␉␉␉invalid++;␊
␉␉␉␉␉␉␉␉␊
␉␉␉␉␉␉␉␉p_states[i].VID = ((maximum.VID << 2) - (vidstep * u)) >> 2;␊
␉␉␉␉␉␉␉␉␊
␉␉␉␉␉␉␉␉U32 multiplier = p_states[i].FID & 0x1f;␉␉// = 0x08␊
␉␉␉␉␉␉␉␉bool half = p_states[i].FID & 0x40;␉␉␉␉␉// = 0x01␊
␉␉␉␉␉␉␉␉bool dfsb = p_states[i].FID & 0x80;␉␉␉␉␉// = 0x00␊
␉␉␉␉␉␉␉␉U32 fsb = Platform->CPU.FSBFrequency / 1000000; // = 400␊
␉␉␉␉␉␉␉␉U32 halffsb = (fsb + 1) >> 1;␉␉␉␉␉// = 200␊
␉␉␉␉␉␉␉␉U32 frequency = (multiplier * fsb);␉␉␉// = 3200␊
␉␉␉␉␉␉␉␉␊
␉␉␉␉␉␉␉␉p_states[i].Frequency = (frequency + (half * halffsb)) >> dfsb;␉// = 3200 + 200 = 3400␊
␉␉␉␉␉␉␉}␊
␉␉␉␉␉␉␉␊
␉␉␉␉␉␉␉p_states_count -= invalid;␊
␉␉␉␉␉␉}␊
␉␉␉␉␉␉break;␊
␉␉␉␉␉} ␊
␉␉␉␉␉case CPUID_MODEL_FIELDS:␊
␉␉␉␉␉case CPUID_MODEL_DALES:␊
␉␉␉␉␉case CPUID_MODEL_DALES_32NM:␊
␉␉␉␉␉case CPUID_MODEL_NEHALEM: ␊
␉␉␉␉␉case CPUID_MODEL_NEHALEM_EX:␊
␉␉␉␉␉case CPUID_MODEL_WESTMERE:␊
␉␉␉␉␉case CPUID_MODEL_WESTMERE_EX:␊
␉␉␉␉␉case CPUID_MODEL_SANDYBRIDGE:␊
                    case CPUID_MODEL_JAKETOWN:␊
␉␉␉␉␉{␉␉␊
␉␉␉␉␉␉maximum.Control = rdmsr64(MSR_IA32_PERF_STATUS) & 0xff; // Seems it always contains maximum multiplier value (with turbo, that's we need)...␊
␉␉␉␉␉␉minimum.Control = (rdmsr64(MSR_PLATFORM_INFO) >> 40) & 0xff;␊
␉␉␉␉␉␉␊
␉␉␉␉␉␉verbose("P-States: min 0x%x, max 0x%x\n", minimum.Control, maximum.Control);␊
␉␉␉␉␉␉␊
␉␉␉␉␉␉// Sanity check␊
␉␉␉␉␉␉if (maximum.Control < minimum.Control) ␊
␉␉␉␉␉␉{␊
␉␉␉␉␉␉␉DBG("Insane control values!");␊
␉␉␉␉␉␉␉p_states_count = 0;␊
␉␉␉␉␉␉}␊
␉␉␉␉␉␉else␊
␉␉␉␉␉␉{␊
␉␉␉␉␉␉␉U8 i;␊
␉␉␉␉␉␉␉p_states_count = 0;␊
␉␉␉␉␉␉␉␊
␉␉␉␉␉␉␉for (i = maximum.Control; i >= minimum.Control; i--) ␊
␉␉␉␉␉␉␉{␊
␉␉␉␉␉␉␉␉p_states[p_states_count].Control = i;␊
␉␉␉␉␉␉␉␉p_states[p_states_count].CID = p_states[p_states_count].Control << 1;␊
␉␉␉␉␉␉␉␉p_states[p_states_count].Frequency = (Platform->CPU.FSBFrequency / 1000000) * i;␊
␉␉␉␉␉␉␉␉p_states_count++;␊
␉␉␉␉␉␉␉␉if (p_states_count >= 32) {␊
␉␉␉␉␉␉␉␉␉␊
␉␉␉␉␉␉␉␉␉if (p_states_count > 32) // MAX_PSTATES ??␊
␉␉␉␉␉␉␉␉␉␉p_states_count = 32; // MAX_PSTATES ??␊
␉␉␉␉␉␉␉␉␉␊
␉␉␉␉␉␉␉␉␉break;␊
␉␉␉␉␉␉␉␉}␊
␉␉␉␉␉␉␉}␊
␉␉␉␉␉␉}␊
␉␉␉␉␉␉␊
␉␉␉␉␉␉break;␊
␉␉␉␉␉}␊
␉␉␉␉␉default:␊
␉␉␉␉␉␉verbose ("Unsupported CPU: P-States will not be generated !!!\n");␊
␉␉␉␉␉␉break;␊
␉␉␉␉}␊
␉␉␉}␊
␉␉␉default:␊
␉␉␉␉break;␊
␉␉}␊
␉␉␊
␉␉// Generating SSDT␊
␉␉if (p_states_count) ␊
␉␉{␉␊
␉␉␉unsigned int i;␊
␉␉␉␊
␉␉␉struct aml_chunk* root = aml_create_node(NULL);␊
            aml_add_buffer(root, ssdt_header, sizeof(ssdt_header)); // SSDT header␊
␉␉␉struct aml_chunk* scop;␊
␉␉␉if (cpuNamespace == CPU_NAMESPACE_PR) ␊
␉␉␉␉␉scop = aml_add_scope(root, "\\_PR_");␊
␉␉␉else if (cpuNamespace == CPU_NAMESPACE_SB) ␊
␉␉␉␉␉scop = aml_add_scope(root, "\\_SB_");␊
            else ␊
␉␉␉{␊
                    aml_destroy_node(root);␉␊
                    goto out;␊
            }␉␉␉␉␊
            struct aml_chunk* name = aml_add_name(scop, "PSS_");␊
            struct aml_chunk* pack = aml_add_package(name);␊
␉␉␉␊
            U8 minPSratio = (p_states[p_states_count-1].Frequency / (Platform->CPU.FSBFrequency / 10000000 ));␊
            U8 maxPSratio = (p_states[0].Frequency / (Platform->CPU.FSBFrequency / 10000000 ));␊
            ␊
            U8 cpu_div = Platform->CPU.CurrDiv;␊
            U8 cpu_ratio = 0;␊
␉␉␉␊
            if (cpu_div) ␉␉␉␉␉␉␉␉␊
                cpu_ratio = (Platform->CPU.CurrCoef * 10) + 5;␉␉␉␉␉␉␉␉␊
            else ␉␉␉␉␉␉␉␉␊
                cpu_ratio = Platform->CPU.CurrCoef * 10;␊
            ␊
␉␉␉␊
            int user_max_ratio = 0;␊
            getIntForKey(kMaxRatio, &user_max_ratio, &bootInfo->bootConfig);␊
            if (user_max_ratio >= minPSratio && maxPSratio >= user_max_ratio) {␉␉␉␉␉␉␉␉␉␊
␉␉␉␉␊
                U8 maxcurrdiv = 0, maxcurrcoef = (int)(user_max_ratio / 10);␉␉␉␉␉␉␉␉␉␊
␉␉␉␉␊
                U8 maxdiv = user_max_ratio - (maxcurrcoef * 10);␊
                if (maxdiv > 0)␊
                    maxcurrdiv = 1;␊
␉␉␉␉␊
                if (maxcurrdiv) ␉␉␉␉␉␉␉␉␉␊
                    cpu_ratio = (maxcurrcoef * 10) + 5;␉␉␉␉␉␉␉␉␉␊
                else ␉␉␉␉␉␉␉␉␉␊
                    cpu_ratio = maxcurrcoef * 10;␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉␊
            }␊
␉␉␉␊
            int user_min_ratio = 0;␊
            getIntForKey(kMinRatio, &user_min_ratio, &bootInfo->bootConfig);␊
            if (user_min_ratio >= minPSratio && cpu_ratio >= user_min_ratio) {␊
␉␉␉␉␊
                U8 mincurrdiv = 0, mincurrcoef = (int)(user_min_ratio / 10);␉␉␉␉␉␉␉␉␉␊
␉␉␉␉␊
                U8 mindiv = user_min_ratio - (mincurrcoef * 10);␊
␉␉␉␉␊
                if (mindiv > 0)␊
                    mincurrdiv = 1;␉␉␉␉␉␉␉␉␉␊
␉␉␉␉␊
                if (mincurrdiv) ␉␉␉␉␉␉␉␉␉␊
                    minPSratio = (mincurrcoef * 10) + 5;␉␉␉␉␉␉␉␉␉␊
                else ␉␉␉␉␉␉␉␉␉␊
                    minPSratio = mincurrcoef * 10;␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉␊
␉␉␉␉␊
            }␊
␉␉␉␊
            if (maxPSratio >= cpu_ratio && cpu_ratio >= minPSratio)␉maxPSratio = cpu_ratio;␉␉␉␉␉␉␉␉␉␉␉␉␉␊
␉␉␉␊
            TagPtr personality = XMLCastDict(XMLGetProperty(bootInfo->bootConfig.dictionary, (const char*)"P-States"));␊
            char* MatchStat = 0;␊
            int dropPSS = 0, Pstatus = 0, base = 16;␉␉␉␉␉␉␉␉␊
            int expert = 0;/* Default: 0 , mean mixed mode | expert mode : 1 , mean add only p-states found in boot.plist*/␊
            char *tmpstr = XMLCastString(XMLGetProperty(personality, (const char*)"Mode"));␊
            ␊
            if (strcmp(tmpstr,"Expert") == 0) {␊
                p_states_count = XMLTagCount(personality) - 1 ; // - 1 = - ("Mode" tag) ␉␉␉␉␉␉␉␉␉␉␊
                expert = 1;␊
            }␊
␉␉␉␊
            ␊
            if ((tmpstr = XMLCastString(XMLGetProperty(personality, (const char*)"Base")))) {␊
                ␊
                if (expert) p_states_count--; // -=  ("Base" tag) ␊
                ␊
                int mybase = strtol(tmpstr, NULL, 10);␉␊
                ␊
                if (mybase == 8 || mybase == 10 || mybase == 16 )␊
                    base = mybase;␉␉␉␉␉␉␉␉␉␊
            }␊
␉␉␉␊
            for (i = 0; i < p_states_count; i++) ␊
            {␉␉␉␉␉␉␉␉␉␊
                sprintf(MatchStat, "%d",i);␊
                TagPtr match_Status = XMLGetProperty(personality, (const char*)MatchStat); ␉␉␉␉␉␉␉␉   ␊
                ␊
                char *Lat1 = NULL, *clk = NULL, *Pw = NULL, *Lat2 = NULL, *Ctrl = NULL ;␊
                ␊
                if (match_Status) {␉␉␉␉␉␉␉␉␉␉␉␉␊
                    ␊
                    clk  = XMLCastString(XMLGetProperty(match_Status, (const char*)"CoreFreq"));␊
                    Pw   = XMLCastString(XMLGetProperty(match_Status, (const char*)"Power"));␊
                    Lat1 = XMLCastString(XMLGetProperty(match_Status, (const char*)"Transition Latency"));␊
                    Lat2 = XMLCastString(XMLGetProperty(match_Status, (const char*)"Bus Master Latency"));␊
                    Ctrl = XMLCastString(XMLGetProperty(match_Status, (const char*)"Control"));␊
                    ␊
                    ␊
                } else if (expert) ␊
                    continue;␊
                ␊
                ␊
                unsigned long Frequency  = 0x00000000;␊
                ␊
                if (!expert) Frequency  = p_states[i].Frequency;␊
                ␊
                if (clk) ␊
                    Frequency  = strtoul((const char *)clk, NULL,base);␊
                ␊
                if (!Frequency || Frequency > p_states[0].Frequency ) continue;␊
                ␊
                U8 curr_ratio = (Frequency / (Platform->CPU.FSBFrequency / 10000000 ));␊
                ␊
                if (curr_ratio > maxPSratio || minPSratio > curr_ratio)␊
                    goto dropPstate;␊
                ␊
                struct aml_chunk* pstt = aml_add_package(pack);␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉␊
                aml_add_dword(pstt, Frequency); // CoreFreq (in MHz).␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉␊
                aml_add_dword(pstt, resolve_pss(0x00000000, Pw, base)); // Power (in milliWatts)␉␉␉␉␉␉␉␉␉␊
                aml_add_dword(pstt, resolve_pss(0x0000000A, Lat1, base)); // Transition Latency (in microseconds).␉␉␉␉␉␉␉␉␉␊
                aml_add_dword(pstt, resolve_pss(0x0000000A, Lat2, base)); // Bus Master Latency (in microseconds).␉␉␉␉␉␉␉␉␉␊
                unsigned long Control  = 0x00000000;␊
                if (!expert) Control = p_states[i].Control;␉␉␉␉␉␉␉␉␉␊
                aml_add_dword(pstt, resolve_pss(Control, Ctrl, base)); // Control␉␉␉␉␉␉␉␉␉␊
                Pstatus++;␊
                aml_add_dword(pstt, Pstatus); // Status␉␉␉␉␉␉␉␉␉␊
                continue;␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉␊
            dropPstate:␊
                ␊
                DBG("state with cpu frequency :%d and ratio :%d will be dropped\n",p_states[i].Frequency,curr_ratio);␉␉␊
                ␊
                dropPSS++;␊
                ␊
                ␊
            }␉␉␉␊
␉␉␉␊
                        ␊
␉␉␉// Add aliaces␊
␉␉␉for (i = 0; i < cpu_map_count; i++) ␊
␉␉␉{␊
␉␉␉␉char name[9];␊
                U32 nseg = *(U32*)cpu_map[i].nameseg;␊
                if (cpuNamespace == CPU_NAMESPACE_PR) {␊
                    sprintf(name, "_PR_%c%c%c%c",␊
                            (int)(nseg & 0x000000ff),␊
                            (int)((nseg & 0x0000ff00) >> 8),␊
                            (int)((nseg & 0x00ff0000) >> 16),␊
                            (int)(nseg >> 24));␊
                } else if (cpuNamespace == CPU_NAMESPACE_SB) {␊
                    sprintf(name, "_SB_%c%c%c%c",␊
                            (int)(nseg & 0x000000ff),␊
                            (int)((nseg & 0x0000ff00) >> 8),␊
                            (int)((nseg & 0x00ff0000) >> 16),␊
                            (int)(nseg >> 24));␊
                } else {␊
                    aml_destroy_node(root);␉␊
                    goto out;␊
                }␊
                ␊
␉␉␉␉scop = aml_add_scope(root, name);␊
␉␉␉␉aml_add_alias(scop, "PSS_", "_PSS");␊
␉␉␉}␊
␉␉␉␊
␉␉␉aml_calculate_size(root);␊
␉␉␉␊
␉␉␉ACPI_TABLE_SSDT *ssdt = (ACPI_TABLE_SSDT *)AllocateKernelMemory(root->Size);␊
␉␉␉␊
␉␉␉aml_write_node(root, (void*)ssdt, 0);␊
␉␉␉␊
␉␉␉ssdt->Header.Length = root->Size;␊
␉␉␉␊
            SetChecksum(&ssdt->Header);␊
␉␉␉␊
␉␉␉aml_destroy_node(root);␉␉␉␊
␉␉␉␊
␉␉␉verbose ("SSDT with CPU P-States generated successfully");␊
␉␉␉␊
␉␉␉if (dropPSS)␊
                verbose(", %d P-state(s) dropped",dropPSS);␊
␉␉␉␊
␉␉␉verbose("\n");␊
␉␉␉␊
␉␉␉return ssdt;␊
␉␉}␊
␉}␊
␉else ␊
␉{␊
out:␊
␉␉verbose("ACPI CPUs not found: P-States will not be generated !!!\n");␊
␉}␊
␉␊
␉return (void *)0ul;␊
}␊
#else␊
␊
static bool is_sandybridge(void)␊
{␊
    return Platform->CPU.Model == CPUID_MODEL_SANDYBRIDGE;␊

{␊
␉return (is_jaketown() || is_sandybridge()) ? 100 : 133;␊
}␊
␊
/*␊
//-----------------------------------------------------------------------------␊
static U32 computePstateRatio(const U32 max, const U32 min, const U32 turboEnabled, const U32 numStates, const U32 pstate)␊
{␊

␉numStates = (pssLimit < maxStates) ? pssLimit : maxStates;␊
␉return (numStates < 2) ? 0 : numStates;␊
}␊
␊
*/␊
#if BUILD_ACPI_TSS || pstate_power_support␊
static U64 divU64byU64(U64 n, U64 d, U64 * rem)␊
{␊

    }␊
␉␊
}␊
#endif␊
#endif // BUILD_ACPI_TSS || pstate_power_support␊
␊
#if pstate_power_support␊
static U64 mulU64byU64(U64 a, U64 b, U64 * high)␊

␉␉return ((ratio_factor * ratio_factor * ratio_factor * Core_TDP) / PRECISION_FACTOR_CUBED) + Uncore_TDP;␊
␉}␊
}␊
#endif␊
#endif // pstate_power_support␊
␊
static U32 encode_pstate(U32 ratio)␊
{␊

␉return (1);␊
}␊
#else␊
␊
/*␊
//-----------------------------------------------------------------------------␊
static U32 BuildCoreIPstateInfo(CPU_DETAILS * cpu)␊
{␊

    ␊
␉return (1);␊
}␊
␊
*/␊
//-----------------------------------------------------------------------------␊
static U32 BuildPstateInfo(CPU_DETAILS * cpu)␊
{␉␊

␉␉␉␉␉case CPUID_MODEL_SANDYBRIDGE:␊
␉␉␉␉␉case CPUID_MODEL_JAKETOWN:␊
␉␉␉␉␉{␉␉␊
␉␉␉␉␉␉/*␊
␉␉␉␉␉␉ maximum.Control = rdmsr64(MSR_IA32_PERF_STATUS) & 0xff; // Seems it always contains maximum multiplier value (with turbo, that's we need)...␊
␉␉␉␉␉␉ minimum.Control = (rdmsr64(MSR_PLATFORM_INFO) >> 40) & 0xff;␊
␉␉␉␉␉␉ ␊
␉␉␉␉␉␉ verbose("P-States: min 0x%x, max 0x%x\n", minimum.Control, maximum.Control);␊
␉␉␉␉␉␉ ␊
␉␉␉␉␉␉ // Sanity check␊
␉␉␉␉␉␉ if (maximum.Control < minimum.Control) ␊
␉␉␉␉␉␉ {␊
␉␉␉␉␉␉ DBG("Insane control values!");␊
␉␉␉␉␉␉ p_states_count = 0;␊
␉␉␉␉␉␉ }␊
␉␉␉␉␉␉ else␊
␉␉␉␉␉␉ {␊
␉␉␉␉␉␉ U8 i;␊
␉␉␉␉␉␉ p_states_count = 0;␊
␉␉␉␉␉␉ ␊
␉␉␉␉␉␉ for (i = maximum.Control; i >= minimum.Control; i--) ␊
␉␉␉␉␉␉ {␊
␉␉␉␉␉␉ p_states[p_states_count].Control = i;␊
␉␉␉␉␉␉ p_states[p_states_count].CID = p_states[p_states_count].Control << 1;␊
␉␉␉␉␉␉ p_states[p_states_count].Frequency = (Platform->CPU.FSBFrequency / 1000000) * i;␊
␉␉␉␉␉␉ p_states_count++;␊
␉␉␉␉␉␉ if (p_states_count >= MAX_PSTATES) { // was 32␊
␉␉␉␉␉␉ ␊
␉␉␉␉␉␉ if (p_states_count > MAX_PSTATES) // was 32␊
␉␉␉␉␉␉ p_states_count = MAX_PSTATES; // was 32␊
␉␉␉␉␉␉ ␊
␉␉␉␉␉␉ break;␊
␉␉␉␉␉␉ }␊
␉␉␉␉␉␉ }␊
␉␉␉␉␉␉ }␊
␉␉␉␉␉␉ */␊
␉␉␉␉␉␉␊
␉␉␉␉␉␉maximum.Control = rdmsr64(MSR_IA32_PERF_STATUS) & 0xff; // Seems it always contains maximum multiplier value (with turbo, that's we need)...␊
␉␉␉␉␉␉minimum.Control = (rdmsr64(MSR_PLATFORM_INFO) >> 40) & 0xff;␊
␉␉␉␉␉␉␊
␉␉␉␉␉␉verbose("P-States: min 0x%x, max 0x%x\n", minimum.Control, maximum.Control);␊
␉␉␉␉␉␉␊
␉␉␉␉␉␉// Sanity check␊
␉␉␉␉␉␉if (maximum.Control < minimum.Control) ␊
␉␉␉␉␉␉{␊
␉␉␉␉␉␉␉DBG("Insane control values!");␊
␉␉␉␉␉␉␉p_states_count = 0;␊
␉␉␉␉␉␉}␊
␉␉␉␉␉␉else␊
␉␉␉␉␉␉{␊
␉␉␉␉␉␉␉U8 i;␊
␉␉␉␉␉␉␉p_states_count = 0;␊
␉␉␉␉␉␉␉␊
␉␉␉␉␉␉␉for (i = maximum.Control; i >= minimum.Control; i--) ␊
␉␉␉␉␉␉␉{␊
␉␉␉␉␉␉␉␉p_states[p_states_count].Control = i;␊
␉␉␉␉␉␉␉␉p_states[p_states_count].CID = p_states[p_states_count].Control << 1;␊
␉␉␉␉␉␉␉␉p_states[p_states_count].Frequency = (Platform->CPU.FSBFrequency / 1000000) * i;␊
␉␉␉␉␉␉␉␉p_states_count++;␊
␉␉␉␉␉␉␉␉if (p_states_count >= MAX_PSTATES) { // was 32␊
␉␉␉␉␉␉␉␉␉␊
␉␉␉␉␉␉␉␉␉if (p_states_count > MAX_PSTATES) // was 32␊
␉␉␉␉␉␉␉␉␉␉p_states_count = MAX_PSTATES; // was 32␊
␉␉␉␉␉␉␉␉␉␊
␉␉␉␉␉␉␉␉␉break;␊
␉␉␉␉␉␉␉␉}␊
␉␉␉␉␉␉␉}␊
␉␉␉␉␉␉}␊
␉␉␉␉␉␉ ␊
␉␉␉␉␉␉/*␊
␉␉␉␉␉␉U32 sta = BuildCoreIPstateInfo(cpu);␊
␉␉␉␉␉␉if (sta) ␊
␉␉␉␉␉␉{␊

␉␉␉␉␉␉␉verbose("CoreI _PSS Generation failed !!\n");␊
␉␉␉␉␉␉␉return (0);␊
␉␉␉␉␉␉}␊
␉␉␉␉␉␉␊
␉␉␉␉␉␉*/␊
␉␉␉␉␉␉break;␊
␉␉␉␉␉}␊
␉␉␉␉␉default:␊

␉DBG("_PSS PGK generated successfully\n");␊
␉return (1);␊
}␊
#endif␊
#endif // BETA␊
␊
//-----------------------------------------------------------------------------␊
static U32 BuildCstateInfo(CPU_DETAILS * cpu, U32 pmbase)␊

    }␊
    return (1);␊
}␊
#endif␊
#endif // BUILD_ACPI_TSS␊
␊
//-----------------------------------------------------------------------------␊
U32 ProcessMadt(ACPI_TABLE_MADT * madt, MADT_INFO * madt_info, void * buffer, U32 bufferSize, U32 nb_cpu)␊

    ␊
    return(current);␊
}␊
#endif␊
#endif // BUILD_ACPI_CSD␊
␊
#if BUILD_ACPI_TSS␊
//-----------------------------------------------------------------------------␊

    ␊
    return(current);␊
}␊
#endif␊
#endif // BUILD_ACPI_TSS␊
␊
//-----------------------------------------------------------------------------␊
static U32 BuildSsdt(MADT_INFO * madt_info, ACPI_TABLE_DSDT *dsdt, void * buffer, U32 bufferSize, bool enable_cstates, bool enable_pstates,  bool enable_tstates)␊

␉␊
␉return(1);␊
}␊
#endif␊
␊
#if UNUSED␊
static ACPI_TABLE_FACS* generate_facs(bool updatefacs )␊

␉bool update_acpi=false, gen_xsdt=false;␊
␉␊
␉bool gen_csta=false, gen_psta=false, speed_step=false;␊
#if !OLD_SSDT␊
␉bool gen_ssdt=false; // will force to generate ssdt even if gen_csta and gen_psta = false␊
    bool gen_tsta=false;␊
#endif␊
␉bool oem_dsdt=false, oem_fadt=false;␊
␉␊
␉// Find original rsdp        ␊

␉␉␉␉␊
␉␉gen_csta=getBoolForKey(kGenerateCStates, &tmpval, &bootInfo->bootConfig)&&tmpval;␊
␉␉gen_psta=getBoolForKey(kGeneratePStates, &tmpval, &bootInfo->bootConfig)&&tmpval;␊
#if !OLD_SSDT␊
␉␉gen_ssdt=getBoolForKey(KForceSSDT, &tmpval, &bootInfo->bootConfig)&&tmpval;␊
#endif␊
␉␉update_acpi=getBoolForKey(kUpdateACPI, &tmpval, &bootInfo->bootConfig)&&tmpval;␊
␉␉␊
␉␉speed_step=getBoolForKey(kSpeedstep, &tmpval, &bootInfo->bootConfig)&&tmpval;␊
#if !OLD_SSDT ␊
␉␉turbo_enabled=(U32)getBoolForKey(kCoreTurbo, &tmpval, &bootInfo->bootConfig)&&tmpval;␊
#endif␊
#if BUILD_ACPI_TSS ␊
␉␉gen_tsta=(U32)getBoolForKey(kGenerateTStates, &tmpval, &bootInfo->bootConfig)&&tmpval;␊
#endif␊

␉␉DsdtPtr = ((fadt_mod->Header.Revision >= 3) && (fadt_mod->XDsdt != 0)) ? (ACPI_TABLE_DSDT*)((U32)fadt_mod->XDsdt)␊
␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉:(ACPI_TABLE_DSDT*)fadt_mod->Dsdt;␊
␉}␊
#if OLD_SSDT␊
␉if (get_needed_symbols())␊
␉{␊
␉␉if (speed_step || gen_csta || gen_psta) ␊
␉␉{␊
␉␉␉U8 empty = get_0ul_index_in_list(new_table_list, true);␊
␉␉␉␊
␉␉␉// Generate _CST SSDT␊
␉␉␉if ( speed_step || gen_csta)␊
␉␉␉{␊
␉␉␉␉if (empty != ACPI_TABLE_LIST_FULL) ␊
␉␉␉␉{␊
␉␉␉␉␉if (new_table_list[empty] =(U32)generate_cst_ssdt(fadt_mod))␊
␉␉␉␉␉{␊
␉␉␉␉␉␉if (speed_step || gen_psta)␊
␉␉␉␉␉␉␉empty = get_0ul_index_in_list(new_table_list,true);␊
␉␉␉␉␉}␊
␉␉␉␉} ␊
␉␉␉␉else␊
␉␉␉␉{␊
␉␉␉␉␉printf("Error: not enought reserved space in the new acpi list for the _CST SSDT table,\n ");␊
␉␉␉␉␉printf("       please increase the RESERVED_AERA\n");␊
␉␉␉␉}␊
␉␉␉}␊
␉␉␉␊
␉␉␉␊
␉␉␉// Generating _PSS SSDT␊
␉␉␉if (speed_step || gen_psta)␊
␉␉␉{␊
␉␉␉␉if (empty != ACPI_TABLE_LIST_FULL)␊
␉␉␉␉{␊
␉␉␉␉␉␊
␉␉␉␉␉new_table_list[empty] =(U32)generate_pss_ssdt(DsdtPtr);␊
␉␉␉␉␉␊
␉␉␉␉}␊
␉␉␉␉else␊
␉␉␉␉{␊
␉␉␉␉␉printf("Error: not enought reserved space in the new acpi list for the _PSS SSDT table,\n ");␊
␉␉␉␉␉printf("       please increase the RESERVED_AERA\n");␊
␉␉␉␉}␊
␉␉␉}␊
␉␉}␊
␉}␉␊
#else␊
␊
    {␊
        MADT_INFO madt_info;␊
        bool strip_madt = true;␊

            ProcessSsdt(new_table_list, DsdtPtr, &madt_info, gen_csta, gen_psta, gen_tsta );␉␉␊
        }␊
    }    ␊
#endif␊
␉␊
␉if ((rsdp_mod != (void *)0ul) && (rsdp_mod->Length >= ACPI_RSDP_REV0_SIZE) ) ␊
␉{␊
 ...
 ...
 ...
 ...
 ...
 ...
 ...
 ...
 ...
 ...
 ...
 ...
 ...
 ...
 ...
 ...
 ...
 ...
 ...
 ...
 ...
 static U32 process_rsdt(ACPI_TABLE_RSDP *rsdp_mod , bool gen_xsdt, U32 *new_table_list);␊
 static ACPI_TABLE_FADT * patch_fadt(ACPI_TABLE_FADT *fadt, ACPI_TABLE_DSDT *new_dsdt, bool UpdateFADT);␊
 ␊
-#if OLD_SSDT␊
-#include "modules.h"␊
-struct aml_chunk ␊
-{␊
-␉unsigned char␉␉Type;␊
-␉unsigned int␉␉Length;␊
-␉char*␉␉␉␉Buffer;␊
-␉␊
-␉unsigned int␉␉Size;␊
-␉␊
-␉struct aml_chunk*␉Next;␊
-␉struct aml_chunk*␉First;␊
-␉struct aml_chunk*␉Last;␊
-};␊
-static U32 get_needed_symbols (void);␊
-static ACPI_TABLE_SSDT *generate_cst_ssdt(ACPI_TABLE_FADT* fadt);␊
-static ACPI_TABLE_SSDT *generate_pss_ssdt(ACPI_TABLE_DSDT* dsdt);␊
-struct aml_chunk* (*aml_create_node)(struct aml_chunk*) = NULL;␉␉␉␊
-struct aml_chunk* (*aml_add_buffer)(struct aml_chunk*,const char*, unsigned int) = NULL;␉␉␉␊
-struct aml_chunk* (*aml_add_byte)(struct aml_chunk*, unsigned char) = NULL;␉␉␉␊
-struct aml_chunk* (*aml_add_word)(struct aml_chunk*, unsigned int) = NULL;␊
-struct aml_chunk* (*aml_add_dword)(struct aml_chunk*, unsigned long) = NULL;␉␉␉␊
-struct aml_chunk* (*aml_add_qword)(struct aml_chunk*, unsigned long long) = NULL;␉␉␉␊
-struct aml_chunk* (*aml_add_scope)(struct aml_chunk*, const char*) = NULL;␊
-struct aml_chunk* (*aml_add_name)(struct aml_chunk*, const char*) = NULL;␉␉␉␊
-struct aml_chunk* (*aml_add_package)(struct aml_chunk*) = NULL;␉␉␉␊
-struct aml_chunk* (*aml_add_alias)(struct aml_chunk*, const char*, const char*) = NULL;␉␉␉␊
-void (*aml_destroy_node)(struct aml_chunk*) = NULL;␊
-unsigned int (*aml_calculate_size)(struct aml_chunk*) = NULL;␊
-unsigned int (*aml_write_node)(struct aml_chunk*, char*, unsigned int) = NULL;␊
-bool (*aml_add_to_parent)(struct aml_chunk*, struct aml_chunk*) = NULL;␊
 ␊
-#else␊
-␊
 #define IA32_MISC_ENABLES 0x01A0␊
 #define MSR_TURBO_POWER_CURRENT_LIMIT 0x1AC␊
 #define MSR_PKG_CST_CONFIG_CONTROL 0x00E2␊
 static U32 encode_pstate(U32 ratio);␊
 static void collect_cpu_info(CPU_DETAILS * cpu);␊
 #ifndef BETA␊
-static U32 BuildCoreIPstateInfo(CPU_DETAILS * cpu);␊
+//static U32 BuildCoreIPstateInfo(CPU_DETAILS * cpu);␊
 #endif␊
 static U32 BuildCstateInfo(CPU_DETAILS * cpu, U32 pmbase);␊
 static U32 BuildPstateInfo(CPU_DETAILS * cpu);␊
 static bool is_sandybridge(void);␊
 static bool is_jaketown(void);␊
 static U32 get_bclk(void);␊
-static U32 computePstateRatio(const U32 max, const U32 min, const U32 turboEnabled, const U32 numStates, const U32 pstate);␊
-static U32 computeNumPstates(const U32 max, const U32 min, const U32 turboEnabled, const U32 pssLimit);␊
+//static U32 computePstateRatio(const U32 max, const U32 min, const U32 turboEnabled, const U32 numStates, const U32 pstate);␊
+//static U32 computeNumPstates(const U32 max, const U32 min, const U32 turboEnabled, const U32 pssLimit);␊
 ␊
-#endif // OLD_SSDT␊
-␊
 #if UNUSED␊
 static ACPI_TABLE_FACS* generate_facs(bool updatefacs );␊
 #endif␊
 // Security space for SSDT , FACP & MADT table generation,␊
 // the size can be increased ␊
 // note: the table will not placed in the reserved space if the 'normal' space is not full␊
-#if OLD_SSDT␊
-#define RESERVED_AERA 4␊
-#else␊
 #define RESERVED_AERA 3␊
-#endif␊
 ␊
 #define ACPI_TABLE_LIST_FULL MAX_ACPI_TABLE + RESERVED_AERA + 1␊
 ␊
     return (cpu_map_error = 0);␊
 }␊
 ␊
-#if OLD_SSDT␊
-␊
-static U32 get_needed_symbols (void)␊
-{␉␊
-␉/* aml_generator symbols */␊
-␉aml_create_node = (void*)lookup_all_symbols("_aml_create_node");␊
-␉if (aml_create_node == (void*)0xFFFFFFFF) goto Failed;␊
-␉␊
-␉aml_add_buffer = (void*)lookup_all_symbols("_aml_add_buffer");␊
-␉if (aml_add_buffer == (void*)0xFFFFFFFF) goto Failed;␊
-␉␊
-␉aml_add_byte = (void*)lookup_all_symbols("_aml_add_byte");␊
-␉if (aml_add_byte == (void*)0xFFFFFFFF) goto Failed;␊
-␉␊
-␉aml_add_word = (void*)lookup_all_symbols("_aml_add_word");␊
-␉if (aml_add_word == (void*)0xFFFFFFFF) goto Failed;␊
-␉␊
-␉aml_add_dword = (void*)lookup_all_symbols("_aml_add_dword");␊
-␉if (aml_add_dword == (void*)0xFFFFFFFF) goto Failed;␊
-␉␊
-␉aml_add_qword = (void*)lookup_all_symbols("_aml_add_qword");␊
-␉if (aml_add_qword == (void*)0xFFFFFFFF) goto Failed;␊
-␉␊
-␉aml_add_scope = (void*)lookup_all_symbols("_aml_add_scope");␊
-␉if (aml_add_scope == (void*)0xFFFFFFFF) goto Failed;␊
-␉␊
-␉aml_add_name = (void*)lookup_all_symbols("_aml_add_name");␊
-␉if (aml_add_name == (void*)0xFFFFFFFF) goto Failed;␊
-␉␊
-␉aml_add_package = (void*)lookup_all_symbols("_aml_add_package");␊
-␉if (aml_add_package == (void*)0xFFFFFFFF) goto Failed;␊
-␉␊
-␉aml_add_alias = (void*)lookup_all_symbols("_aml_add_alias");␊
-␉if (aml_add_alias == (void*)0xFFFFFFFF) goto Failed;␊
-␉␊
-␉aml_destroy_node = (void*)lookup_all_symbols("_aml_destroy_node");␊
-␉if (aml_destroy_node == (void*)0xFFFFFFFF) goto Failed;␊
-␉␊
-␉aml_calculate_size = (void*)lookup_all_symbols("_aml_calculate_size");␉␊
-␉if (aml_calculate_size == (void*)0xFFFFFFFF) goto Failed;␊
-␉␊
-␉aml_write_node = (void*)lookup_all_symbols("_aml_write_node");␊
-␉if (aml_write_node == (void*)0xFFFFFFFF) goto Failed;␊
-␉␊
-␉aml_add_to_parent = (void*)lookup_all_symbols("_aml_add_to_parent");␊
-␉if (aml_add_to_parent == (void*)0xFFFFFFFF) goto Failed;␊
-␉␊
-␉DBG("struct aml_chunk* _aml_create_node: 0x%x\n",(UInt32)aml_create_node);␊
-␉DBG("struct aml_chunk* _aml_add_buffer: 0x%x\n",(UInt32)aml_add_buffer);␊
-␉DBG("struct aml_chunk* _aml_add_byte: 0x%x\n",(UInt32)aml_add_byte);␊
-␉DBG("struct aml_chunk* _aml_add_word: 0x%x\n",(UInt32)aml_add_word);␊
-␉DBG("struct aml_chunk* _aml_add_dword: 0x%x\n",(UInt32)aml_add_dword);␊
-␉DBG("struct aml_chunk* _aml_add_qword: 0x%x\n",(UInt32)aml_add_qword);␊
-␉DBG("struct aml_chunk* _aml_add_scope: 0x%x\n",(UInt32)aml_add_scope);␊
-␉DBG("struct aml_chunk* _aml_add_name: 0x%x\n",(UInt32)aml_add_name);␊
-␉DBG("struct aml_chunk* _aml_add_package: 0x%x\n",(UInt32)aml_add_package);␊
-␉DBG("struct aml_chunk* _aml_add_alias: 0x%x\n",(UInt32)aml_add_alias);␊
-␉DBG("void _aml_destroy_node: 0x%x\n",(UInt32)aml_destroy_node);␊
-␉DBG("unsigned int _aml_calculate_size: 0x%x\n",(UInt32)aml_calculate_size);␊
-␉DBG("unsigned int _aml_write_node: 0x%x\n",(UInt32)aml_write_node);␊
-␉DBG("bool _aml_add_to_parent: 0x%x\n",(UInt32)aml_add_to_parent);␉␊
-␉return (1);␊
-Failed:␊
-␉printf("Failed to find aml_generator symbols, SSDT will not be generated !!!");␊
-␉return (0);␊
-}␊
-␊
-static ACPI_TABLE_SSDT *generate_cst_ssdt(ACPI_TABLE_FADT* fadt)␊
-{␉␊
-␉char ssdt_header[] =␊
-␉{␊
-␉␉0x53, 0x53, 0x44, 0x54, 0xE7, 0x00, 0x00, 0x00, /* SSDT.... */␊
-␉␉0x01, 0x17, 0x50, 0x6D, 0x52, 0x65, 0x66, 0x41, /* ..PmRefA */␊
-␉␉0x43, 0x70, 0x75, 0x43, 0x73, 0x74, 0x00, 0x00, /* CpuCst.. */␊
-␉␉0x00, 0x10, 0x00, 0x00, 0x49, 0x4E, 0x54, 0x4C, /* ....INTL */␊
-␉␉0x31, 0x03, 0x10, 0x20 ␉␉␉␉␉␉␉/* 1.._␉␉*/␊
-␉};␊
-␉␊
-␉char cstate_resource_template[] = ␊
-␉{␊
-␉␉0x11, 0x14, 0x0A, 0x11, 0x82, 0x0C, 0x00, 0x7F, ␊
-␉␉0x01, 0x02, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, ␊
-␉␉0x00, 0x00, 0x00, 0x79, 0x00␊
-␉};␊
-␉␊
-␉if (Platform->CPU.Vendor != 0x756E6547) {␊
-␉␉verbose ("Not an Intel platform: C-States will not be generated !!!\n");␊
-␉␉return (void *)0ul;␊
-␉}␊
-␉␊
-␉if (fadt == (void *)0ul) {␊
-␉␉verbose ("FACP not exists: C-States will not be generated !!!\n");␊
-␉␉return (void *)0ul;␊
-␉}␊
-    ␊
-␉ACPI_TABLE_DSDT* dsdt = ((fadt->Header.Revision >= 3) && (fadt->XDsdt != 0)) ? (ACPI_TABLE_DSDT*)((U32)fadt->XDsdt):(ACPI_TABLE_DSDT*)fadt->Dsdt;␊
-␉if (dsdt == (void *)0ul) {␊
-␉␉verbose ("DSDT not found: C-States will not be generated !!!\n");␊
-␉␉return (void *)0ul;␊
-␉}␊
-␉␉␊
-␉if (generate_cpu_map_from_acpi(dsdt) == 0) ␊
-␉{␊
-␉␉bool c2_enabled = fadt->C2Latency < 100;␊
-␉␉bool c3_enabled = fadt->C3Latency < 1000;␊
-␉␉bool c4_enabled = false;␊
-␉␉␊
-␉␉getBoolForKey(kEnableC4State, &c4_enabled, &bootInfo->bootConfig);␊
-        ␊
-␉␉unsigned char cstates_count = 1 + (c2_enabled ? 1 : 0) + ((c3_enabled || c4_enabled) ? 1 : 0);␊
-␉␉char *Lat = NULL, *Pw = NULL, *tmpstr =NULL;␊
-␉␉int base = 16;␊
-␉␉TagPtr personality = XMLCastDict(XMLGetProperty(bootInfo->bootConfig.dictionary, (const char*)"C-States"));␊
-␉␉␊
-␉␉if ((tmpstr = XMLCastString(XMLGetProperty(personality, (const char*)"Base")))) {␊
-␉␉␉␊
-␉␉␉int mybase = strtol(tmpstr, NULL, 10);␉␊
-␉␉␉␊
-␉␉␉if (mybase == 8 || mybase == 10 || mybase == 16 ) ␊
-␉␉␉␉base = mybase;␉␉␉␉␉␉␉␉␉␊
-␉␉}␊
-␉␉␊
-␉␉struct aml_chunk* root = aml_create_node(NULL);␊
-        aml_add_buffer(root, ssdt_header, sizeof(ssdt_header)); // SSDT header␊
-        struct aml_chunk* scop;␊
-␉␉if (cpuNamespace == CPU_NAMESPACE_PR) ␊
-␉␉␉scop = aml_add_scope(root, "\\_PR_");␊
-␉␉else if (cpuNamespace == CPU_NAMESPACE_SB) ␊
-␉␉␉scop = aml_add_scope(root, "\\_SB_");␊
-␉␉else ␊
-␉␉{␊
-␉␉␉aml_destroy_node(root);␉␊
-␉␉␉goto out;␊
-␉␉}␊
-        struct aml_chunk* name = aml_add_name(scop, "CST_");␊
-        struct aml_chunk* pack = aml_add_package(name);␊
-        aml_add_byte(pack, cstates_count);␊
-␉␉␊
-        struct aml_chunk* tmpl = aml_add_package(pack);␊
-        TagPtr match_Status = XMLGetProperty(personality, (const char*)"C1");␊
-        if (match_Status) {␉␊
-            Pw   = XMLCastString(XMLGetProperty(match_Status, (const char*)"Power"));␊
-            Lat  = XMLCastString(XMLGetProperty(match_Status, (const char*)"Latency"));␊
-        }␊
-        cstate_resource_template[11] = 0x00; // C1␊
-        aml_add_buffer(tmpl, cstate_resource_template, sizeof(cstate_resource_template));␊
-        aml_add_byte(tmpl, 0x01); // C1␊
-        aml_add_byte(tmpl, (unsigned char)resolve_cst(0x01, Lat, base));  // Latency␊
-        aml_add_word(tmpl, resolve_cst(0x03e8, Pw, base)); // Power␊
-␉␉// C2␊
-␉␉if (c2_enabled) ␊
-␉␉{␊
-␉␉␉tmpl = aml_add_package(pack);␊
-␉␉␉Lat = NULL; ␊
-␉␉␉Pw = NULL;␊
-␉␉␉match_Status = XMLGetProperty(personality, (const char*)"C2");␊
-␉␉␉if (match_Status) {␉␊
-␉␉␉␉Pw   = XMLCastString(XMLGetProperty(match_Status, (const char*)"Power"));␊
-␉␉␉␉Lat  = XMLCastString(XMLGetProperty(match_Status, (const char*)"Latency"));␊
-␉␉␉}␊
-␉␉␉␊
-␉␉␉cstate_resource_template[11] = 0x10; // C2␊
-␉␉␉aml_add_buffer(tmpl, cstate_resource_template, sizeof(cstate_resource_template));␊
-␉␉␉aml_add_byte(tmpl, 0x02); // C2␉␉␉␉␊
-␉␉␉aml_add_word(tmpl, resolve_cst(fadt->C2Latency, Lat, base));  // Latency␊
-␉␉␉aml_add_word(tmpl, resolve_cst(0x01f4, Pw, base)); // Power␊
-␉␉}␊
-␉␉␊
-␉␉// C4␊
-␉␉if (c4_enabled) ␊
-␉␉{␊
-␉␉␉tmpl = aml_add_package(pack);␊
-␉␉␉Lat = NULL; ␊
-␉␉␉Pw = NULL;␊
-␉␉␉match_Status = XMLGetProperty(personality, (const char*)"C4"); ␊
-␉␉␉if (match_Status) {␉␊
-␉␉␉␉Pw   = XMLCastString(XMLGetProperty(match_Status, (const char*)"Power"));␊
-␉␉␉␉Lat  = XMLCastString(XMLGetProperty(match_Status, (const char*)"Latency"));␊
-␉␉␉}␊
-␉␉␉cstate_resource_template[11] = 0x30; // C4␊
-␉␉␉aml_add_buffer(tmpl, cstate_resource_template, sizeof(cstate_resource_template));␊
-␉␉␉aml_add_byte(tmpl, 0x04); // C4␉␊
-␉␉␉aml_add_word(tmpl, resolve_cst(fadt->C3Latency / 2, Lat, base));  // TODO: right latency for C4␊
-␉␉␉aml_add_word(tmpl, resolve_cst(0xfa, Pw, base)); // Power␊
-␉␉␉␊
-␉␉␉// you can check if the C4 state is correctly activated or not with the following command Lines (you will need the 'lspci for mac' package): ␊
-␉␉␉␊
-␉␉␉// according to the intel ich10 dataheet ( Power Management PCI Configuration Registers (PM—D31:F0) ):␊
-␉␉␉// setpci -s 0:1f.0 0xa0.w (must return an hex where bit 12 is 0 and bit 7 is 1, usually 06a0h )␊
-␉␉␉// setpci -s 0:1f.0 0xa6.b (must return an hex where bit 7 is 1, usually 80h )␊
-␉␉␉␊
-␉␉␉␊
-␉␉}␉␉␊
-␉␉// C3␊
-␉␉else if (c3_enabled) ␊
-␉␉{␊
-␉␉␉tmpl = aml_add_package(pack);␊
-␉␉␉Lat = NULL; ␊
-␉␉␉Pw = NULL;␊
-␉␉␉match_Status = XMLGetProperty(personality, (const char*)"C3"); ␊
-␉␉␉if (match_Status) {␉␊
-␉␉␉␉Pw   = XMLCastString(XMLGetProperty(match_Status, (const char*)"Power"));␊
-␉␉␉␉Lat  = XMLCastString(XMLGetProperty(match_Status, (const char*)"Latency"));␊
-␉␉␉}␊
-␉␉␉cstate_resource_template[11] = 0x20; // C3␊
-␉␉␉aml_add_buffer(tmpl, cstate_resource_template, sizeof(cstate_resource_template));␊
-␉␉␉aml_add_byte(tmpl, 0x03); // C3␉␉␉␉␊
-␉␉␉aml_add_word(tmpl, resolve_cst(fadt->C3Latency , Lat, base));  ␊
-␉␉␉aml_add_word(tmpl, resolve_cst(0x015e, Pw, base)); // Power␊
-␉␉␉␊
-␉␉}␊
-␉␉        ␊
-        // Aliaces␊
-        unsigned int i;␊
-        for (i = 0; i < cpu_map_count; i++) ␊
-        {␊
-            char name[9];␊
-            U32 nseg = *(U32*)cpu_map[i].nameseg;␊
-            if (cpuNamespace == CPU_NAMESPACE_PR) {␊
-                sprintf(name, "_PR_%c%c%c%c",␊
-                        (int)(nseg & 0x000000ff),␊
-                        (int)((nseg & 0x0000ff00) >> 8),␊
-                        (int)((nseg & 0x00ff0000) >> 16),␊
-                        (int)(nseg >> 24));␊
-            } else if (cpuNamespace == CPU_NAMESPACE_SB) {␊
-                sprintf(name, "_SB_%c%c%c%c",␊
-                        (int)(nseg & 0x000000ff),␊
-                        (int)((nseg & 0x0000ff00) >> 8),␊
-                        (int)((nseg & 0x00ff0000) >> 16),␊
-                        (int)(nseg >> 24));␊
-            } else {␊
-                aml_destroy_node(root);␉␊
-                goto out;␊
-            }␊
-            ␊
-            scop = aml_add_scope(root, name);␊
-            aml_add_alias(scop, "CST_", "_CST");␊
-        }␊
-␉␉␊
-␉␉aml_calculate_size(root);␊
-␉␉␊
-␉␉ACPI_TABLE_SSDT *ssdt = (ACPI_TABLE_SSDT *)AllocateKernelMemory(root->Size);␊
-        ␊
-␉␉aml_write_node(root, (void*)ssdt, 0);␊
-␉␉␊
-␉␉ssdt->Header.Length = root->Size;        ␊
-␉␉␊
-␉␉SetChecksum(&ssdt->Header);␊
-        ␊
-␉␉aml_destroy_node(root);␉␉␊
-        ␊
-␉␉verbose ("SSDT with CPU C-States generated successfully\n");␊
-␉␉␊
-␉␉return ssdt;␊
-␉}␊
-␉else ␊
-␉{␊
-out:␊
-␉␉verbose ("ACPI CPUs not found: C-States will not be generated !!!\n");␊
-␉}␊
-    ␊
-␉return (void *)0ul;␊
-}␊
-␊
-static ACPI_TABLE_SSDT *generate_pss_ssdt(ACPI_TABLE_DSDT* dsdt)␊
-{␉␉␊
-␉␊
-␉char ssdt_header[] =␊
-␉{␊
-␉␉0x53, 0x53, 0x44, 0x54, 0x7E, 0x00, 0x00, 0x00, /* SSDT.... */␊
-␉␉0x01, 0x6A, 0x50, 0x6D, 0x52, 0x65, 0x66, 0x00, /* ..PmRef. */␊
-␉␉0x43, 0x70, 0x75, 0x50, 0x6D, 0x00, 0x00, 0x00, /* CpuPm... */␊
-␉␉0x00, 0x30, 0x00, 0x00, 0x49, 0x4E, 0x54, 0x4C, /* .0..INTL */␊
-␉␉0x31, 0x03, 0x10, 0x20,␉␉␉␉␉␉␉/* 1.._␉␉*/␊
-␉};␊
-    ␊
-␉if (Platform->CPU.Vendor != 0x756E6547) {␊
-␉␉verbose ("Not an Intel platform: P-States will not be generated !!!\n");␊
-␉␉return (void *)0ul;␊
-␉}␊
-␉␊
-␉if (!(Platform->CPU.Features & CPUID_FEATURE_MSR)) {␊
-␉␉verbose ("Unsupported CPU: P-States will not be generated !!!\n");␊
-␉␉return (void *)0ul;␊
-␉}␊
-␉␊
-␉if (dsdt == (void *)0ul) {␊
-␉␉verbose ("DSDT not found: P-States will not be generated !!!\n");␊
-␉␉return (void *)0ul;␊
-␉}␊
-␉␉   ␊
-␉if (generate_cpu_map_from_acpi(dsdt) == 0 ) ␊
-␉{␊
-␉␉struct p_state /*initial,*/ maximum, minimum, p_states[32];␊
-␉␉U8 p_states_count = 0;␉␉␊
-␉␉␊
-␉␉// Retrieving P-States, ported from code by superhai (c)␊
-␉␉switch (Platform->CPU.Family) {␊
-␉␉␉case 0x06: ␊
-␉␉␉{␊
-␉␉␉␉switch (Platform->CPU.Model) ␊
-␉␉␉␉{␊
-␉␉␉␉␉case CPUID_MODEL_DOTHAN: ␊
-␉␉␉␉␉case CPUID_MODEL_YONAH: // Yonah␊
-␉␉␉␉␉case CPUID_MODEL_MEROM: // Merom␊
-␉␉␉␉␉case CPUID_MODEL_PENRYN: // Penryn␊
-␉␉␉␉␉case CPUID_MODEL_ATOM: // Intel Atom (45nm)␊
-␉␉␉␉␉{␊
-␉␉␉␉␉␉bool cpu_dynamic_fsb = false;␊
-␉␉␉␉␉␉␊
-␉␉␉␉␉␉if (rdmsr64(MSR_IA32_EXT_CONFIG) & (1 << 27)) ␊
-␉␉␉␉␉␉{␊
-␉␉␉␉␉␉␉wrmsr64(MSR_IA32_EXT_CONFIG, (rdmsr64(MSR_IA32_EXT_CONFIG) | (1 << 28))); ␊
-␉␉␉␉␉␉␉delay(1);␊
-␉␉␉␉␉␉␉cpu_dynamic_fsb = rdmsr64(MSR_IA32_EXT_CONFIG) & (1 << 28);␊
-␉␉␉␉␉␉}␊
-␉␉␉␉␉␉␊
-␉␉␉␉␉␉bool cpu_noninteger_bus_ratio = (rdmsr64(MSR_IA32_PERF_STATUS) & (1ULL << 46));␊
-␉␉␉␉␉␉␊
-␉␉␉␉␉␉initial.Control = rdmsr64(MSR_IA32_PERF_STATUS);␊
-␉␉␉␉␉␉␊
-␉␉␉␉␉␉maximum.Control = ((rdmsr64(MSR_IA32_PERF_STATUS) >> 32) & 0x1F3F) | (0x4000 * cpu_noninteger_bus_ratio);␊
-␉␉␉␉␉␉maximum.CID = ((maximum.FID & 0x1F) << 1) | cpu_noninteger_bus_ratio;␊
-␉␉␉␉␉␉␊
-␉␉␉␉␉␉minimum.FID = ((rdmsr64(MSR_IA32_PERF_STATUS) >> 24) & 0x1F) | (0x80 * cpu_dynamic_fsb);␊
-␉␉␉␉␉␉minimum.VID = ((rdmsr64(MSR_IA32_PERF_STATUS) >> 48) & 0x3F);␊
-␉␉␉␉␉␉␊
-␉␉␉␉␉␉if (minimum.FID == 0) ␊
-␉␉␉␉␉␉{␊
-␉␉␉␉␉␉␉U64 msr;␊
-␉␉␉␉␉␉␉U8 i;␊
-␉␉␉␉␉␉␉// Probe for lowest fid␊
-␉␉␉␉␉␉␉for (i = maximum.FID; i >= 0x6; i--) ␊
-␉␉␉␉␉␉␉{␊
-␉␉␉␉␉␉␉␉msr = rdmsr64(MSR_IA32_PERF_CONTROL);␊
-␉␉␉␉␉␉␉␉wrmsr64(MSR_IA32_PERF_CONTROL, (msr & 0xFFFFFFFFFFFF0000ULL) | (i << 8) | minimum.VID);␊
-␉␉␉␉␉␉␉␉intel_waitforsts();␊
-␉␉␉␉␉␉␉␉minimum.FID = (rdmsr64(MSR_IA32_PERF_STATUS) >> 8) & 0x1F; ␊
-␉␉␉␉␉␉␉␉delay(1);␊
-␉␉␉␉␉␉␉}␊
-␉␉␉␉␉␉␉␊
-␉␉␉␉␉␉␉msr = rdmsr64(MSR_IA32_PERF_CONTROL);␊
-␉␉␉␉␉␉␉wrmsr64(MSR_IA32_PERF_CONTROL, (msr & 0xFFFFFFFFFFFF0000ULL) | (maximum.FID << 8) | maximum.VID);␊
-␉␉␉␉␉␉␉intel_waitforsts();␊
-␉␉␉␉␉␉}␊
-␉␉␉␉␉␉␊
-␉␉␉␉␉␉if (minimum.VID == maximum.VID) ␊
-␉␉␉␉␉␉{␉␊
-␉␉␉␉␉␉␉U64 msr;␊
-␉␉␉␉␉␉␉U8 i;␊
-␉␉␉␉␉␉␉// Probe for lowest vid␊
-␉␉␉␉␉␉␉for (i = maximum.VID; i > 0xA; i--) ␊
-␉␉␉␉␉␉␉{␊
-␉␉␉␉␉␉␉␉msr = rdmsr64(MSR_IA32_PERF_CONTROL);␊
-␉␉␉␉␉␉␉␉wrmsr64(MSR_IA32_PERF_CONTROL, (msr & 0xFFFFFFFFFFFF0000ULL) | (minimum.FID << 8) | i);␊
-␉␉␉␉␉␉␉␉intel_waitforsts();␊
-␉␉␉␉␉␉␉␉minimum.VID = rdmsr64(MSR_IA32_PERF_STATUS) & 0x3F; ␊
-␉␉␉␉␉␉␉␉delay(1);␊
-␉␉␉␉␉␉␉}␊
-␉␉␉␉␉␉␉␊
-␉␉␉␉␉␉␉msr = rdmsr64(MSR_IA32_PERF_CONTROL);␊
-␉␉␉␉␉␉␉wrmsr64(MSR_IA32_PERF_CONTROL, (msr & 0xFFFFFFFFFFFF0000ULL) | (maximum.FID << 8) | maximum.VID);␊
-␉␉␉␉␉␉␉intel_waitforsts();␊
-␉␉␉␉␉␉}␊
-␉␉␉␉␉␉␊
-␉␉␉␉␉␉minimum.CID = ((minimum.FID & 0x1F) << 1) >> cpu_dynamic_fsb;␊
-␉␉␉␉␉␉␊
-␉␉␉␉␉␉// Sanity check␊
-␉␉␉␉␉␉if (maximum.CID < minimum.CID) ␊
-␉␉␉␉␉␉{␊
-␉␉␉␉␉␉␉DBG("Insane FID values!");␊
-␉␉␉␉␉␉␉p_states_count = 0;␊
-␉␉␉␉␉␉}␊
-␉␉␉␉␉␉else␊
-␉␉␉␉␉␉{␊
-␉␉␉␉␉␉␉// Finalize P-States␊
-␉␉␉␉␉␉␉// Find how many P-States machine supports␊
-␉␉␉␉␉␉␉p_states_count = maximum.CID - minimum.CID + 1;␊
-␉␉␉␉␉␉␉␊
-␉␉␉␉␉␉␉if (p_states_count > 32) // MAX_PSTATES ??␊
-␉␉␉␉␉␉␉␉p_states_count = 32; // MAX_PSTATES ??␊
-␉␉␉␉␉␉␉␊
-␉␉␉␉␉␉␉U8 vidstep;␊
-␉␉␉␉␉␉␉U8 i = 0, u, invalid = 0;␊
-␉␉␉␉␉␉␉␊
-␉␉␉␉␉␉␉vidstep = ((maximum.VID << 2) - (minimum.VID << 2)) / (p_states_count - 1);␊
-␉␉␉␉␉␉␉␊
-␉␉␉␉␉␉␉for (u = 0; u < p_states_count; u++) ␊
-␉␉␉␉␉␉␉{␊
-␉␉␉␉␉␉␉␉i = u - invalid;␊
-␉␉␉␉␉␉␉␉␊
-␉␉␉␉␉␉␉␉p_states[i].CID = maximum.CID - u;␊
-␉␉␉␉␉␉␉␉p_states[i].FID = (p_states[i].CID >> 1);␊
-␉␉␉␉␉␉␉␉␊
-␉␉␉␉␉␉␉␉if (p_states[i].FID < 0x6) ␊
-␉␉␉␉␉␉␉␉{␊
-␉␉␉␉␉␉␉␉␉if (cpu_dynamic_fsb) ␊
-␉␉␉␉␉␉␉␉␉␉p_states[i].FID = (p_states[i].FID << 1) | 0x80;␊
-␉␉␉␉␉␉␉␉} ␊
-␉␉␉␉␉␉␉␉else if (cpu_noninteger_bus_ratio) ␊
-␉␉␉␉␉␉␉␉{␊
-␉␉␉␉␉␉␉␉␉p_states[i].FID = p_states[i].FID | (0x40 * (p_states[i].CID & 0x1));␊
-␉␉␉␉␉␉␉␉}␊
-␉␉␉␉␉␉␉␉␊
-␉␉␉␉␉␉␉␉if (i && p_states[i].FID == p_states[i-1].FID)␊
-␉␉␉␉␉␉␉␉␉invalid++;␊
-␉␉␉␉␉␉␉␉␊
-␉␉␉␉␉␉␉␉p_states[i].VID = ((maximum.VID << 2) - (vidstep * u)) >> 2;␊
-␉␉␉␉␉␉␉␉␊
-␉␉␉␉␉␉␉␉U32 multiplier = p_states[i].FID & 0x1f;␉␉// = 0x08␊
-␉␉␉␉␉␉␉␉bool half = p_states[i].FID & 0x40;␉␉␉␉␉// = 0x01␊
-␉␉␉␉␉␉␉␉bool dfsb = p_states[i].FID & 0x80;␉␉␉␉␉// = 0x00␊
-␉␉␉␉␉␉␉␉U32 fsb = Platform->CPU.FSBFrequency / 1000000; // = 400␊
-␉␉␉␉␉␉␉␉U32 halffsb = (fsb + 1) >> 1;␉␉␉␉␉// = 200␊
-␉␉␉␉␉␉␉␉U32 frequency = (multiplier * fsb);␉␉␉// = 3200␊
-␉␉␉␉␉␉␉␉␊
-␉␉␉␉␉␉␉␉p_states[i].Frequency = (frequency + (half * halffsb)) >> dfsb;␉// = 3200 + 200 = 3400␊
-␉␉␉␉␉␉␉}␊
-␉␉␉␉␉␉␉␊
-␉␉␉␉␉␉␉p_states_count -= invalid;␊
-␉␉␉␉␉␉}␊
-␉␉␉␉␉␉break;␊
-␉␉␉␉␉} ␊
-␉␉␉␉␉case CPUID_MODEL_FIELDS:␊
-␉␉␉␉␉case CPUID_MODEL_DALES:␊
-␉␉␉␉␉case CPUID_MODEL_DALES_32NM:␊
-␉␉␉␉␉case CPUID_MODEL_NEHALEM: ␊
-␉␉␉␉␉case CPUID_MODEL_NEHALEM_EX:␊
-␉␉␉␉␉case CPUID_MODEL_WESTMERE:␊
-␉␉␉␉␉case CPUID_MODEL_WESTMERE_EX:␊
-␉␉␉␉␉case CPUID_MODEL_SANDYBRIDGE:␊
-                    case CPUID_MODEL_JAKETOWN:␊
-␉␉␉␉␉{␉␉␊
-␉␉␉␉␉␉maximum.Control = rdmsr64(MSR_IA32_PERF_STATUS) & 0xff; // Seems it always contains maximum multiplier value (with turbo, that's we need)...␊
-␉␉␉␉␉␉minimum.Control = (rdmsr64(MSR_PLATFORM_INFO) >> 40) & 0xff;␊
-␉␉␉␉␉␉␊
-␉␉␉␉␉␉verbose("P-States: min 0x%x, max 0x%x\n", minimum.Control, maximum.Control);␊
-␉␉␉␉␉␉␊
-␉␉␉␉␉␉// Sanity check␊
-␉␉␉␉␉␉if (maximum.Control < minimum.Control) ␊
-␉␉␉␉␉␉{␊
-␉␉␉␉␉␉␉DBG("Insane control values!");␊
-␉␉␉␉␉␉␉p_states_count = 0;␊
-␉␉␉␉␉␉}␊
-␉␉␉␉␉␉else␊
-␉␉␉␉␉␉{␊
-␉␉␉␉␉␉␉U8 i;␊
-␉␉␉␉␉␉␉p_states_count = 0;␊
-␉␉␉␉␉␉␉␊
-␉␉␉␉␉␉␉for (i = maximum.Control; i >= minimum.Control; i--) ␊
-␉␉␉␉␉␉␉{␊
-␉␉␉␉␉␉␉␉p_states[p_states_count].Control = i;␊
-␉␉␉␉␉␉␉␉p_states[p_states_count].CID = p_states[p_states_count].Control << 1;␊
-␉␉␉␉␉␉␉␉p_states[p_states_count].Frequency = (Platform->CPU.FSBFrequency / 1000000) * i;␊
-␉␉␉␉␉␉␉␉p_states_count++;␊
-␉␉␉␉␉␉␉␉if (p_states_count >= 32) {␊
-␉␉␉␉␉␉␉␉␉␊
-␉␉␉␉␉␉␉␉␉if (p_states_count > 32) // MAX_PSTATES ??␊
-␉␉␉␉␉␉␉␉␉␉p_states_count = 32; // MAX_PSTATES ??␊
-␉␉␉␉␉␉␉␉␉␊
-␉␉␉␉␉␉␉␉␉break;␊
-␉␉␉␉␉␉␉␉}␊
-␉␉␉␉␉␉␉}␊
-␉␉␉␉␉␉}␊
-␉␉␉␉␉␉␊
-␉␉␉␉␉␉break;␊
-␉␉␉␉␉}␊
-␉␉␉␉␉default:␊
-␉␉␉␉␉␉verbose ("Unsupported CPU: P-States will not be generated !!!\n");␊
-␉␉␉␉␉␉break;␊
-␉␉␉␉}␊
-␉␉␉}␊
-␉␉␉default:␊
-␉␉␉␉break;␊
-␉␉}␊
-␉␉␊
-␉␉// Generating SSDT␊
-␉␉if (p_states_count) ␊
-␉␉{␉␊
-␉␉␉unsigned int i;␊
-␉␉␉␊
-␉␉␉struct aml_chunk* root = aml_create_node(NULL);␊
-            aml_add_buffer(root, ssdt_header, sizeof(ssdt_header)); // SSDT header␊
-␉␉␉struct aml_chunk* scop;␊
-␉␉␉if (cpuNamespace == CPU_NAMESPACE_PR) ␊
-␉␉␉␉␉scop = aml_add_scope(root, "\\_PR_");␊
-␉␉␉else if (cpuNamespace == CPU_NAMESPACE_SB) ␊
-␉␉␉␉␉scop = aml_add_scope(root, "\\_SB_");␊
-            else ␊
-␉␉␉{␊
-                    aml_destroy_node(root);␉␊
-                    goto out;␊
-            }␉␉␉␉␊
-            struct aml_chunk* name = aml_add_name(scop, "PSS_");␊
-            struct aml_chunk* pack = aml_add_package(name);␊
-␉␉␉␊
-            U8 minPSratio = (p_states[p_states_count-1].Frequency / (Platform->CPU.FSBFrequency / 10000000 ));␊
-            U8 maxPSratio = (p_states[0].Frequency / (Platform->CPU.FSBFrequency / 10000000 ));␊
-            ␊
-            U8 cpu_div = Platform->CPU.CurrDiv;␊
-            U8 cpu_ratio = 0;␊
-␉␉␉␊
-            if (cpu_div) ␉␉␉␉␉␉␉␉␊
-                cpu_ratio = (Platform->CPU.CurrCoef * 10) + 5;␉␉␉␉␉␉␉␉␊
-            else ␉␉␉␉␉␉␉␉␊
-                cpu_ratio = Platform->CPU.CurrCoef * 10;␊
-            ␊
-␉␉␉␊
-            int user_max_ratio = 0;␊
-            getIntForKey(kMaxRatio, &user_max_ratio, &bootInfo->bootConfig);␊
-            if (user_max_ratio >= minPSratio && maxPSratio >= user_max_ratio) {␉␉␉␉␉␉␉␉␉␊
-␉␉␉␉␊
-                U8 maxcurrdiv = 0, maxcurrcoef = (int)(user_max_ratio / 10);␉␉␉␉␉␉␉␉␉␊
-␉␉␉␉␊
-                U8 maxdiv = user_max_ratio - (maxcurrcoef * 10);␊
-                if (maxdiv > 0)␊
-                    maxcurrdiv = 1;␊
-␉␉␉␉␊
-                if (maxcurrdiv) ␉␉␉␉␉␉␉␉␉␊
-                    cpu_ratio = (maxcurrcoef * 10) + 5;␉␉␉␉␉␉␉␉␉␊
-                else ␉␉␉␉␉␉␉␉␉␊
-                    cpu_ratio = maxcurrcoef * 10;␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉␊
-            }␊
-␉␉␉␊
-            int user_min_ratio = 0;␊
-            getIntForKey(kMinRatio, &user_min_ratio, &bootInfo->bootConfig);␊
-            if (user_min_ratio >= minPSratio && cpu_ratio >= user_min_ratio) {␊
-␉␉␉␉␊
-                U8 mincurrdiv = 0, mincurrcoef = (int)(user_min_ratio / 10);␉␉␉␉␉␉␉␉␉␊
-␉␉␉␉␊
-                U8 mindiv = user_min_ratio - (mincurrcoef * 10);␊
-␉␉␉␉␊
-                if (mindiv > 0)␊
-                    mincurrdiv = 1;␉␉␉␉␉␉␉␉␉␊
-␉␉␉␉␊
-                if (mincurrdiv) ␉␉␉␉␉␉␉␉␉␊
-                    minPSratio = (mincurrcoef * 10) + 5;␉␉␉␉␉␉␉␉␉␊
-                else ␉␉␉␉␉␉␉␉␉␊
-                    minPSratio = mincurrcoef * 10;␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉␊
-␉␉␉␉␊
-            }␊
-␉␉␉␊
-            if (maxPSratio >= cpu_ratio && cpu_ratio >= minPSratio)␉maxPSratio = cpu_ratio;␉␉␉␉␉␉␉␉␉␉␉␉␉␊
-␉␉␉␊
-            TagPtr personality = XMLCastDict(XMLGetProperty(bootInfo->bootConfig.dictionary, (const char*)"P-States"));␊
-            char* MatchStat = 0;␊
-            int dropPSS = 0, Pstatus = 0, base = 16;␉␉␉␉␉␉␉␉␊
-            int expert = 0;/* Default: 0 , mean mixed mode | expert mode : 1 , mean add only p-states found in boot.plist*/␊
-            char *tmpstr = XMLCastString(XMLGetProperty(personality, (const char*)"Mode"));␊
-            ␊
-            if (strcmp(tmpstr,"Expert") == 0) {␊
-                p_states_count = XMLTagCount(personality) - 1 ; // - 1 = - ("Mode" tag) ␉␉␉␉␉␉␉␉␉␉␊
-                expert = 1;␊
-            }␊
-␉␉␉␊
-            ␊
-            if ((tmpstr = XMLCastString(XMLGetProperty(personality, (const char*)"Base")))) {␊
-                ␊
-                if (expert) p_states_count--; // -=  ("Base" tag) ␊
-                ␊
-                int mybase = strtol(tmpstr, NULL, 10);␉␊
-                ␊
-                if (mybase == 8 || mybase == 10 || mybase == 16 )␊
-                    base = mybase;␉␉␉␉␉␉␉␉␉␊
-            }␊
-␉␉␉␊
-            for (i = 0; i < p_states_count; i++) ␊
-            {␉␉␉␉␉␉␉␉␉␊
-                sprintf(MatchStat, "%d",i);␊
-                TagPtr match_Status = XMLGetProperty(personality, (const char*)MatchStat); ␉␉␉␉␉␉␉␉   ␊
-                ␊
-                char *Lat1 = NULL, *clk = NULL, *Pw = NULL, *Lat2 = NULL, *Ctrl = NULL ;␊
-                ␊
-                if (match_Status) {␉␉␉␉␉␉␉␉␉␉␉␉␊
-                    ␊
-                    clk  = XMLCastString(XMLGetProperty(match_Status, (const char*)"CoreFreq"));␊
-                    Pw   = XMLCastString(XMLGetProperty(match_Status, (const char*)"Power"));␊
-                    Lat1 = XMLCastString(XMLGetProperty(match_Status, (const char*)"Transition Latency"));␊
-                    Lat2 = XMLCastString(XMLGetProperty(match_Status, (const char*)"Bus Master Latency"));␊
-                    Ctrl = XMLCastString(XMLGetProperty(match_Status, (const char*)"Control"));␊
-                    ␊
-                    ␊
-                } else if (expert) ␊
-                    continue;␊
-                ␊
-                ␊
-                unsigned long Frequency  = 0x00000000;␊
-                ␊
-                if (!expert) Frequency  = p_states[i].Frequency;␊
-                ␊
-                if (clk) ␊
-                    Frequency  = strtoul((const char *)clk, NULL,base);␊
-                ␊
-                if (!Frequency || Frequency > p_states[0].Frequency ) continue;␊
-                ␊
-                U8 curr_ratio = (Frequency / (Platform->CPU.FSBFrequency / 10000000 ));␊
-                ␊
-                if (curr_ratio > maxPSratio || minPSratio > curr_ratio)␊
-                    goto dropPstate;␊
-                ␊
-                struct aml_chunk* pstt = aml_add_package(pack);␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉␊
-                aml_add_dword(pstt, Frequency); // CoreFreq (in MHz).␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉␊
-                aml_add_dword(pstt, resolve_pss(0x00000000, Pw, base)); // Power (in milliWatts)␉␉␉␉␉␉␉␉␉␊
-                aml_add_dword(pstt, resolve_pss(0x0000000A, Lat1, base)); // Transition Latency (in microseconds).␉␉␉␉␉␉␉␉␉␊
-                aml_add_dword(pstt, resolve_pss(0x0000000A, Lat2, base)); // Bus Master Latency (in microseconds).␉␉␉␉␉␉␉␉␉␊
-                unsigned long Control  = 0x00000000;␊
-                if (!expert) Control = p_states[i].Control;␉␉␉␉␉␉␉␉␉␊
-                aml_add_dword(pstt, resolve_pss(Control, Ctrl, base)); // Control␉␉␉␉␉␉␉␉␉␊
-                Pstatus++;␊
-                aml_add_dword(pstt, Pstatus); // Status␉␉␉␉␉␉␉␉␉␊
-                continue;␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉␊
-            dropPstate:␊
-                ␊
-                DBG("state with cpu frequency :%d and ratio :%d will be dropped\n",p_states[i].Frequency,curr_ratio);␉␉␊
-                ␊
-                dropPSS++;␊
-                ␊
-                ␊
-            }␉␉␉␊
-␉␉␉␊
-                        ␊
-␉␉␉// Add aliaces␊
-␉␉␉for (i = 0; i < cpu_map_count; i++) ␊
-␉␉␉{␊
-␉␉␉␉char name[9];␊
-                U32 nseg = *(U32*)cpu_map[i].nameseg;␊
-                if (cpuNamespace == CPU_NAMESPACE_PR) {␊
-                    sprintf(name, "_PR_%c%c%c%c",␊
-                            (int)(nseg & 0x000000ff),␊
-                            (int)((nseg & 0x0000ff00) >> 8),␊
-                            (int)((nseg & 0x00ff0000) >> 16),␊
-                            (int)(nseg >> 24));␊
-                } else if (cpuNamespace == CPU_NAMESPACE_SB) {␊
-                    sprintf(name, "_SB_%c%c%c%c",␊
-                            (int)(nseg & 0x000000ff),␊
-                            (int)((nseg & 0x0000ff00) >> 8),␊
-                            (int)((nseg & 0x00ff0000) >> 16),␊
-                            (int)(nseg >> 24));␊
-                } else {␊
-                    aml_destroy_node(root);␉␊
-                    goto out;␊
-                }␊
-                ␊
-␉␉␉␉scop = aml_add_scope(root, name);␊
-␉␉␉␉aml_add_alias(scop, "PSS_", "_PSS");␊
-␉␉␉}␊
-␉␉␉␊
-␉␉␉aml_calculate_size(root);␊
-␉␉␉␊
-␉␉␉ACPI_TABLE_SSDT *ssdt = (ACPI_TABLE_SSDT *)AllocateKernelMemory(root->Size);␊
-␉␉␉␊
-␉␉␉aml_write_node(root, (void*)ssdt, 0);␊
-␉␉␉␊
-␉␉␉ssdt->Header.Length = root->Size;␊
-␉␉␉␊
-            SetChecksum(&ssdt->Header);␊
-␉␉␉␊
-␉␉␉aml_destroy_node(root);␉␉␉␊
-␉␉␉␊
-␉␉␉verbose ("SSDT with CPU P-States generated successfully");␊
-␉␉␉␊
-␉␉␉if (dropPSS)␊
-                verbose(", %d P-state(s) dropped",dropPSS);␊
-␉␉␉␊
-␉␉␉verbose("\n");␊
-␉␉␉␊
-␉␉␉return ssdt;␊
-␉␉}␊
-␉}␊
-␉else ␊
-␉{␊
-out:␊
-␉␉verbose("ACPI CPUs not found: P-States will not be generated !!!\n");␊
-␉}␊
-␉␊
-␉return (void *)0ul;␊
-}␊
-#else␊
-␊
 static bool is_sandybridge(void)␊
 {␊
     return Platform->CPU.Model == CPUID_MODEL_SANDYBRIDGE;␊
 {␊
 ␉return (is_jaketown() || is_sandybridge()) ? 100 : 133;␊
 }␊
-␊
+/*␊
 //-----------------------------------------------------------------------------␊
 static U32 computePstateRatio(const U32 max, const U32 min, const U32 turboEnabled, const U32 numStates, const U32 pstate)␊
 {␊
 ␉numStates = (pssLimit < maxStates) ? pssLimit : maxStates;␊
 ␉return (numStates < 2) ? 0 : numStates;␊
 }␊
-␊
+*/␊
 #if BUILD_ACPI_TSS || pstate_power_support␊
 static U64 divU64byU64(U64 n, U64 d, U64 * rem)␊
 {␊
     }␊
 ␉␊
 }␊
-#endif␊
+#endif // BUILD_ACPI_TSS || pstate_power_support␊
 ␊
 #if pstate_power_support␊
 static U64 mulU64byU64(U64 a, U64 b, U64 * high)␊
 ␉␉return ((ratio_factor * ratio_factor * ratio_factor * Core_TDP) / PRECISION_FACTOR_CUBED) + Uncore_TDP;␊
 ␉}␊
 }␊
-#endif␊
+#endif // pstate_power_support␊
 ␊
 static U32 encode_pstate(U32 ratio)␊
 {␊
 ␉return (1);␊
 }␊
 #else␊
-␊
+/*␊
 //-----------------------------------------------------------------------------␊
 static U32 BuildCoreIPstateInfo(CPU_DETAILS * cpu)␊
 {␊
     ␊
 ␉return (1);␊
 }␊
-␊
+*/␊
 //-----------------------------------------------------------------------------␊
 static U32 BuildPstateInfo(CPU_DETAILS * cpu)␊
 {␉␊
 ␉␉␉␉␉case CPUID_MODEL_SANDYBRIDGE:␊
 ␉␉␉␉␉case CPUID_MODEL_JAKETOWN:␊
 ␉␉␉␉␉{␉␉␊
-␉␉␉␉␉␉/*␊
-␉␉␉␉␉␉ maximum.Control = rdmsr64(MSR_IA32_PERF_STATUS) & 0xff; // Seems it always contains maximum multiplier value (with turbo, that's we need)...␊
-␉␉␉␉␉␉ minimum.Control = (rdmsr64(MSR_PLATFORM_INFO) >> 40) & 0xff;␊
-␉␉␉␉␉␉ ␊
-␉␉␉␉␉␉ verbose("P-States: min 0x%x, max 0x%x\n", minimum.Control, maximum.Control);␊
-␉␉␉␉␉␉ ␊
-␉␉␉␉␉␉ // Sanity check␊
-␉␉␉␉␉␉ if (maximum.Control < minimum.Control) ␊
-␉␉␉␉␉␉ {␊
-␉␉␉␉␉␉ DBG("Insane control values!");␊
-␉␉␉␉␉␉ p_states_count = 0;␊
-␉␉␉␉␉␉ }␊
-␉␉␉␉␉␉ else␊
-␉␉␉␉␉␉ {␊
-␉␉␉␉␉␉ U8 i;␊
-␉␉␉␉␉␉ p_states_count = 0;␊
-␉␉␉␉␉␉ ␊
-␉␉␉␉␉␉ for (i = maximum.Control; i >= minimum.Control; i--) ␊
-␉␉␉␉␉␉ {␊
-␉␉␉␉␉␉ p_states[p_states_count].Control = i;␊
-␉␉␉␉␉␉ p_states[p_states_count].CID = p_states[p_states_count].Control << 1;␊
-␉␉␉␉␉␉ p_states[p_states_count].Frequency = (Platform->CPU.FSBFrequency / 1000000) * i;␊
-␉␉␉␉␉␉ p_states_count++;␊
-␉␉␉␉␉␉ if (p_states_count >= MAX_PSTATES) { // was 32␊
-␉␉␉␉␉␉ ␊
-␉␉␉␉␉␉ if (p_states_count > MAX_PSTATES) // was 32␊
-␉␉␉␉␉␉ p_states_count = MAX_PSTATES; // was 32␊
-␉␉␉␉␉␉ ␊
-␉␉␉␉␉␉ break;␊
-␉␉␉␉␉␉ }␊
-␉␉␉␉␉␉ }␊
-␉␉␉␉␉␉ }␊
-␉␉␉␉␉␉ */␊
 ␉␉␉␉␉␉␊
+␉␉␉␉␉␉maximum.Control = rdmsr64(MSR_IA32_PERF_STATUS) & 0xff; // Seems it always contains maximum multiplier value (with turbo, that's we need)...␊
+␉␉␉␉␉␉minimum.Control = (rdmsr64(MSR_PLATFORM_INFO) >> 40) & 0xff;␊
+␉␉␉␉␉␉␊
+␉␉␉␉␉␉verbose("P-States: min 0x%x, max 0x%x\n", minimum.Control, maximum.Control);␊
+␉␉␉␉␉␉␊
+␉␉␉␉␉␉// Sanity check␊
+␉␉␉␉␉␉if (maximum.Control < minimum.Control) ␊
+␉␉␉␉␉␉{␊
+␉␉␉␉␉␉␉DBG("Insane control values!");␊
+␉␉␉␉␉␉␉p_states_count = 0;␊
+␉␉␉␉␉␉}␊
+␉␉␉␉␉␉else␊
+␉␉␉␉␉␉{␊
+␉␉␉␉␉␉␉U8 i;␊
+␉␉␉␉␉␉␉p_states_count = 0;␊
+␉␉␉␉␉␉␉␊
+␉␉␉␉␉␉␉for (i = maximum.Control; i >= minimum.Control; i--) ␊
+␉␉␉␉␉␉␉{␊
+␉␉␉␉␉␉␉␉p_states[p_states_count].Control = i;␊
+␉␉␉␉␉␉␉␉p_states[p_states_count].CID = p_states[p_states_count].Control << 1;␊
+␉␉␉␉␉␉␉␉p_states[p_states_count].Frequency = (Platform->CPU.FSBFrequency / 1000000) * i;␊
+␉␉␉␉␉␉␉␉p_states_count++;␊
+␉␉␉␉␉␉␉␉if (p_states_count >= MAX_PSTATES) { // was 32␊
+␉␉␉␉␉␉␉␉␉␊
+␉␉␉␉␉␉␉␉␉if (p_states_count > MAX_PSTATES) // was 32␊
+␉␉␉␉␉␉␉␉␉␉p_states_count = MAX_PSTATES; // was 32␊
+␉␉␉␉␉␉␉␉␉␊
+␉␉␉␉␉␉␉␉␉break;␊
+␉␉␉␉␉␉␉␉}␊
+␉␉␉␉␉␉␉}␊
+␉␉␉␉␉␉}␊
+␉␉␉␉␉␉ ␊
+␉␉␉␉␉␉/*␊
 ␉␉␉␉␉␉U32 sta = BuildCoreIPstateInfo(cpu);␊
 ␉␉␉␉␉␉if (sta) ␊
 ␉␉␉␉␉␉{␊
 ␉␉␉␉␉␉␉verbose("CoreI _PSS Generation failed !!\n");␊
 ␉␉␉␉␉␉␉return (0);␊
 ␉␉␉␉␉␉}␊
-␉␉␉␉␉␉␊
+␉␉␉␉␉␉*/␊
 ␉␉␉␉␉␉break;␊
 ␉␉␉␉␉}␊
 ␉␉␉␉␉default:␊
 ␉DBG("_PSS PGK generated successfully\n");␊
 ␉return (1);␊
 }␊
-#endif␊
+#endif // BETA␊
 ␊
 //-----------------------------------------------------------------------------␊
 static U32 BuildCstateInfo(CPU_DETAILS * cpu, U32 pmbase)␊
     }␊
     return (1);␊
 }␊
-#endif␊
+#endif // BUILD_ACPI_TSS␊
 ␊
 //-----------------------------------------------------------------------------␊
 U32 ProcessMadt(ACPI_TABLE_MADT * madt, MADT_INFO * madt_info, void * buffer, U32 bufferSize, U32 nb_cpu)␊
     ␊
     return(current);␊
 }␊
-#endif␊
+#endif // BUILD_ACPI_CSD␊
 ␊
 #if BUILD_ACPI_TSS␊
 //-----------------------------------------------------------------------------␊
     ␊
     return(current);␊
 }␊
-#endif␊
+#endif // BUILD_ACPI_TSS␊
 ␊
 //-----------------------------------------------------------------------------␊
 static U32 BuildSsdt(MADT_INFO * madt_info, ACPI_TABLE_DSDT *dsdt, void * buffer, U32 bufferSize, bool enable_cstates, bool enable_pstates,  bool enable_tstates)␊
 ␉␊
 ␉return(1);␊
 }␊
-#endif␊
 ␊
 #if UNUSED␊
 static ACPI_TABLE_FACS* generate_facs(bool updatefacs )␊
 ␉bool update_acpi=false, gen_xsdt=false;␊
 ␉␊
 ␉bool gen_csta=false, gen_psta=false, speed_step=false;␊
-#if !OLD_SSDT␊
 ␉bool gen_ssdt=false; // will force to generate ssdt even if gen_csta and gen_psta = false␊
     bool gen_tsta=false;␊
-#endif␊
 ␉bool oem_dsdt=false, oem_fadt=false;␊
 ␉␊
 ␉// Find original rsdp        ␊
 ␉␉␉␉␊
 ␉␉gen_csta=getBoolForKey(kGenerateCStates, &tmpval, &bootInfo->bootConfig)&&tmpval;␊
 ␉␉gen_psta=getBoolForKey(kGeneratePStates, &tmpval, &bootInfo->bootConfig)&&tmpval;␊
-#if !OLD_SSDT␊
 ␉␉gen_ssdt=getBoolForKey(KForceSSDT, &tmpval, &bootInfo->bootConfig)&&tmpval;␊
-#endif␊
 ␉␉update_acpi=getBoolForKey(kUpdateACPI, &tmpval, &bootInfo->bootConfig)&&tmpval;␊
 ␉␉␊
 ␉␉speed_step=getBoolForKey(kSpeedstep, &tmpval, &bootInfo->bootConfig)&&tmpval;␊
-#if !OLD_SSDT ␊
 ␉␉turbo_enabled=(U32)getBoolForKey(kCoreTurbo, &tmpval, &bootInfo->bootConfig)&&tmpval;␊
-#endif␊
 #if BUILD_ACPI_TSS ␊
 ␉␉gen_tsta=(U32)getBoolForKey(kGenerateTStates, &tmpval, &bootInfo->bootConfig)&&tmpval;␊
 #endif␊
 ␉␉DsdtPtr = ((fadt_mod->Header.Revision >= 3) && (fadt_mod->XDsdt != 0)) ? (ACPI_TABLE_DSDT*)((U32)fadt_mod->XDsdt)␊
 ␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉:(ACPI_TABLE_DSDT*)fadt_mod->Dsdt;␊
 ␉}␊
-#if OLD_SSDT␊
-␉if (get_needed_symbols())␊
-␉{␊
-␉␉if (speed_step || gen_csta || gen_psta) ␊
-␉␉{␊
-␉␉␉U8 empty = get_0ul_index_in_list(new_table_list, true);␊
-␉␉␉␊
-␉␉␉// Generate _CST SSDT␊
-␉␉␉if ( speed_step || gen_csta)␊
-␉␉␉{␊
-␉␉␉␉if (empty != ACPI_TABLE_LIST_FULL) ␊
-␉␉␉␉{␊
-␉␉␉␉␉if (new_table_list[empty] =(U32)generate_cst_ssdt(fadt_mod))␊
-␉␉␉␉␉{␊
-␉␉␉␉␉␉if (speed_step || gen_psta)␊
-␉␉␉␉␉␉␉empty = get_0ul_index_in_list(new_table_list,true);␊
-␉␉␉␉␉}␊
-␉␉␉␉} ␊
-␉␉␉␉else␊
-␉␉␉␉{␊
-␉␉␉␉␉printf("Error: not enought reserved space in the new acpi list for the _CST SSDT table,\n ");␊
-␉␉␉␉␉printf("       please increase the RESERVED_AERA\n");␊
-␉␉␉␉}␊
-␉␉␉}␊
-␉␉␉␊
-␉␉␉␊
-␉␉␉// Generating _PSS SSDT␊
-␉␉␉if (speed_step || gen_psta)␊
-␉␉␉{␊
-␉␉␉␉if (empty != ACPI_TABLE_LIST_FULL)␊
-␉␉␉␉{␊
-␉␉␉␉␉␊
-␉␉␉␉␉new_table_list[empty] =(U32)generate_pss_ssdt(DsdtPtr);␊
-␉␉␉␉␉␊
-␉␉␉␉}␊
-␉␉␉␉else␊
-␉␉␉␉{␊
-␉␉␉␉␉printf("Error: not enought reserved space in the new acpi list for the _PSS SSDT table,\n ");␊
-␉␉␉␉␉printf("       please increase the RESERVED_AERA\n");␊
-␉␉␉␉}␊
-␉␉␉}␊
-␉␉}␊
-␉}␉␊
-#else␊
+␊
     {␊
         MADT_INFO madt_info;␊
         bool strip_madt = true;␊
             ProcessSsdt(new_table_list, DsdtPtr, &madt_info, gen_csta, gen_psta, gen_tsta );␉␉␊
         }␊
     }    ␊
-#endif␊
 ␉␊
 ␉if ((rsdp_mod != (void *)0ul) && (rsdp_mod->Length >= ACPI_RSDP_REV0_SIZE) ) ␊
 ␉{␊

-23
24 24
25 25
26 
26
27 27
28 28
29 29
30 
30
31 31
32 32
33 33
+␊
OPTIM = -Os -Oz␊
DEBUG = -DNOTHING␊
CFLAGS␉= $(RC_CFLAGS) $(OPTIM) $(MORECPP) -arch i386 -g -Wmost \␊
CFLAGS␉= $(RC_CFLAGS) $(OPTIM) $(MORECPP) -arch i386 -g -Wmost -fstack-protector-all \␊
    -D__ARCHITECTURE__=\"i386\" -DSAIO_INTERNAL_USER \␊
    -DRCZ_COMPRESSED_FILE_SUPPORT $(DEBUG) \␊
    -fno-builtin $(OMIT_FRAME_POINTER_CFLAG) \␊
    -mpreferred-stack-boundary=2 -fno-align-functions -fno-stack-protector \␊
    -mpreferred-stack-boundary=2 -fno-align-functions \␊
    -march=pentium4 -msse2  -mfpmath=sse -msoft-float -fno-common ␊
␊
DEFINES=␊
 ␊
 OPTIM = -Os -Oz␊
 DEBUG = -DNOTHING␊
-CFLAGS␉= $(RC_CFLAGS) $(OPTIM) $(MORECPP) -arch i386 -g -Wmost \␊
+CFLAGS␉= $(RC_CFLAGS) $(OPTIM) $(MORECPP) -arch i386 -g -Wmost -fstack-protector-all \␊
     -D__ARCHITECTURE__=\"i386\" -DSAIO_INTERNAL_USER \␊
     -DRCZ_COMPRESSED_FILE_SUPPORT $(DEBUG) \␊
     -fno-builtin $(OMIT_FRAME_POINTER_CFLAG) \␊
-    -mpreferred-stack-boundary=2 -fno-align-functions -fno-stack-protector \␊
+    -mpreferred-stack-boundary=2 -fno-align-functions \␊
     -march=pentium4 -msse2  -mfpmath=sse -msoft-float -fno-common ␊
 ␊
 DEFINES=␊

-23
24 24
25 25
26 
26
27 27
28 28
29 29
30 
30
31 31
32 32
33 33
+␊
OPTIM = -Os -Oz␊
DEBUG = -DNOTHING␊
CFLAGS␉= $(RC_CFLAGS) $(OPTIM) $(MORECPP) -arch i386 -g -Wmost \␊
CFLAGS␉= $(RC_CFLAGS) $(OPTIM) $(MORECPP) -arch i386 -g -Wmost -fstack-protector-all \␊
    -D__ARCHITECTURE__=\"i386\" -DSAIO_INTERNAL_USER \␊
    -DRCZ_COMPRESSED_FILE_SUPPORT $(DEBUG) \␊
    -fno-builtin $(OMIT_FRAME_POINTER_CFLAG) \␊
    -mpreferred-stack-boundary=2 -fno-align-functions -fno-stack-protector \␊
    -mpreferred-stack-boundary=2 -fno-align-functions \␊
    -march=pentium4 -msse2 -mfpmath=sse -msoft-float -fno-common␊
␊
DEFINES=␊
 ␊
 OPTIM = -Os -Oz␊
 DEBUG = -DNOTHING␊
-CFLAGS␉= $(RC_CFLAGS) $(OPTIM) $(MORECPP) -arch i386 -g -Wmost \␊
+CFLAGS␉= $(RC_CFLAGS) $(OPTIM) $(MORECPP) -arch i386 -g -Wmost -fstack-protector-all \␊
     -D__ARCHITECTURE__=\"i386\" -DSAIO_INTERNAL_USER \␊
     -DRCZ_COMPRESSED_FILE_SUPPORT $(DEBUG) \␊
     -fno-builtin $(OMIT_FRAME_POINTER_CFLAG) \␊
-    -mpreferred-stack-boundary=2 -fno-align-functions -fno-stack-protector \␊
+    -mpreferred-stack-boundary=2 -fno-align-functions \␊
     -march=pentium4 -msse2 -mfpmath=sse -msoft-float -fno-common␊
 ␊
 DEFINES=␊

-18
19 19
20 20
21 
21
22 22
23 23
24 24
+CFILES = machOconv.c␊
ALLSRC = $(CFILES) $(MFILES) $(HFILES) $(EXPORT_HFILES)␊
␊
PROGRAMS = machOconv bdmesg␊
PROGRAMS = machOconv bdmesg amlsgn␊
␊
OUTFILES = $(PROGRAMS)␊
␊
 CFILES = machOconv.c␊
 ALLSRC = $(CFILES) $(MFILES) $(HFILES) $(EXPORT_HFILES)␊
 ␊
-PROGRAMS = machOconv bdmesg␊
+PROGRAMS = machOconv bdmesg amlsgn␊
 ␊
 OUTFILES = $(PROGRAMS)␊
 ␊

Download the corresponding diff file