Index: branches/chucko/i386/libsaio/asm.s =================================================================== --- branches/chucko/i386/libsaio/asm.s (revision 2328) +++ branches/chucko/i386/libsaio/asm.s (revision 2329) @@ -82,7 +82,7 @@ * New boot0 (boot1 has been deprecated). Booter must now reside in its own partition, no disk label required. * * Revision 1.1.1.2 1999/08/04 21:16:57 wsanchez - * Impoort of boot-66 + * Import of boot-66 * * Revision 1.3 1999/08/04 21:12:12 wsanchez * Update APSL @@ -348,7 +348,7 @@ push %ebp mov %esp, %ebp - mov 0xc(%ebp), %eax // argument to program + mov 0xc(%ebp), %eax // argument to program - bootargs to mach_kernel mov 0x8(%ebp), %ecx // entry offset mov $0x28, %ebx // segment push %ebx Index: branches/chucko/i386/libsaio/console.c =================================================================== --- branches/chucko/i386/libsaio/console.c (revision 2328) +++ branches/chucko/i386/libsaio/console.c (revision 2329) @@ -50,8 +50,8 @@ extern int vprf(const char * fmt, va_list ap); -bool gVerboseMode; -bool gErrors; +bool gVerboseMode = false; +bool gErrors = false; /* * Azi: Doubled available log size; this seems to fix some hangs and instant reboots caused by @@ -69,8 +69,8 @@ struct putc_info //Azi: exists on gui.c & printf.c { - char * str; - char * last_str; + char * str; + char * last_str; }; static int @@ -83,7 +83,7 @@ return 0; } *(pi->str)++ = c; - return c; + return c; } void initBooterLog(void) @@ -99,11 +99,13 @@ va_list ap; struct putc_info pi; - if (!msgbuf) + if (!msgbuf) { return; + } - if (((cursor - msgbuf) > (BOOTER_LOG_SIZE - SAFE_LOG_SIZE))) + if (((cursor - msgbuf) > (BOOTER_LOG_SIZE - SAFE_LOG_SIZE))) { return; + } va_start(ap, fmt); pi.str = cursor; @@ -115,8 +117,9 @@ void setupBooterLog(void) { - if (!msgbuf) + if (!msgbuf) { return; + } Node *node = DT__FindNode("/", false); if (node) @@ -129,30 +132,29 @@ */ int putchar(int c) { - if ( c == '\t' ) - { + if ( c == '\t' ) { for (c = 0; c < 8; c++) bios_putchar(' '); return c; } - if ( c == '\n' ) - { + if ( c == '\n' ) { bios_putchar('\r'); - } + } bios_putchar(c); - return c; + return c; } int getc() { - int c = bgetc(); + int c = bgetc(); - if ((c & 0xff) == 0) - return c; - else - return (c & 0xff); + if ((c & 0xff) == 0) { + return c; + } else { + return (c & 0xff); + } } // Read and echo a character from console. This doesn't echo backspace @@ -165,28 +167,31 @@ // if ( c == '\r' ) c = '\n'; // if ( c >= ' ' && c < 0x7f) putchar(c); - + return (c); } int printf(const char * fmt, ...) { - va_list ap; + va_list ap; va_start(ap, fmt); - if (bootArgs->Video.v_display == VGA_TEXT_MODE) + if (bootArgs->Video.v_display == VGA_TEXT_MODE) { prf(fmt, ap, putchar, 0); - else + } else { vprf(fmt, ap); + } { // Kabyl: BooterLog struct putc_info pi; - if (!msgbuf) + if (!msgbuf) { return 0; + } - if (((cursor - msgbuf) > (BOOTER_LOG_SIZE - SAFE_LOG_SIZE))) + if (((cursor - msgbuf) > (BOOTER_LOG_SIZE - SAFE_LOG_SIZE))) { return 0; + } pi.str = cursor; pi.last_str = 0; prf(fmt, ap, sputc, &pi); @@ -194,52 +199,55 @@ } va_end(ap); - return 0; + return 0; } int verbose(const char * fmt, ...) { - va_list ap; + va_list ap; va_start(ap, fmt); - if (gVerboseMode) - { - if (bootArgs->Video.v_display == VGA_TEXT_MODE) + if (gVerboseMode) { + if (bootArgs->Video.v_display == VGA_TEXT_MODE) { prf(fmt, ap, putchar, 0); - else + } else { vprf(fmt, ap); - } + } + } { // Kabyl: BooterLog struct putc_info pi; - if (!msgbuf) + if (!msgbuf) { return 0; + } - if (((cursor - msgbuf) > (BOOTER_LOG_SIZE - SAFE_LOG_SIZE))) + if (((cursor - msgbuf) > (BOOTER_LOG_SIZE - SAFE_LOG_SIZE))) { return 0; + } pi.str = cursor; pi.last_str = 0; prf(fmt, ap, sputc, &pi); cursor += strlen((char *)cursor); } - va_end(ap); - return(0); + va_end(ap); + return(0); } int error(const char * fmt, ...) { - va_list ap; - gErrors = true; - va_start(ap, fmt); - if (bootArgs->Video.v_display == VGA_TEXT_MODE) + va_list ap; + gErrors = true; + va_start(ap, fmt); + if (bootArgs->Video.v_display == VGA_TEXT_MODE) { prf(fmt, ap, putchar, 0); - else + } else { vprf(fmt, ap); + } va_end(ap); - return(0); + return(0); } void stop(const char * fmt, ...) Index: branches/chucko/i386/libsaio/xml.h =================================================================== --- branches/chucko/i386/libsaio/xml.h (revision 2328) +++ branches/chucko/i386/libsaio/xml.h (revision 2329) @@ -26,16 +26,16 @@ #define __LIBSAIO_XML_H enum xmltype { - kTagTypeNone = 0, - kTagTypeDict, - kTagTypeKey, - kTagTypeString, - kTagTypeInteger, - kTagTypeData, - kTagTypeDate, - kTagTypeFalse, - kTagTypeTrue, - kTagTypeArray + kTagTypeNone = 0, + kTagTypeDict, + kTagTypeKey, + kTagTypeString, + kTagTypeInteger, + kTagTypeData, + kTagTypeDate, + kTagTypeFalse, + kTagTypeTrue, + kTagTypeArray }; struct string_ref @@ -48,20 +48,21 @@ extern string_ref* ref_strings; -#define kXMLTagPList "plist " -#define kXMLTagDict "dict" -#define kXMLTagKey "key" -#define kXMLTagString "string" -#define kXMLTagInteger "integer" -#define kXMLTagData "data" -#define kXMLTagDate "date" -#define kXMLTagFalse "false/" -#define kXMLTagTrue "true/" -#define kXMLTagArray "array" +#define kXMLTagPList "plist " +#define kXMLTagDict "dict" +#define kXMLTagKey "key" +#define kXMLTagString "string" +#define kXMLTagInteger "integer" +#define kXMLTagData "data" +#define kXMLTagDate "date" +#define kXMLTagFalse "false/" +#define kXMLTagTrue "true/" +#define kXMLTagArray "array" +// for back-references used by libkern serializer +#define kXMLTagReference "reference" +#define kXMLStringID "ID=" +#define kXMLStringIDRef "IDREF=" -#define kXMLStringID "ID=" -#define kXMLStringIDRef "IDREF=" - #define kPropCFBundleIdentifier ("CFBundleIdentifier") #define kPropCFBundleExecutable ("CFBundleExecutable") #define kPropOSBundleRequired ("OSBundleRequired") @@ -71,10 +72,10 @@ /* struct Tag { - long type; - char *string; - struct Tag *tag; - struct Tag *tagNext; + long type; + char *string; + struct Tag *tag; + struct Tag *tagNext; }; typedef struct Tag Tag, *TagPtr; */ Index: branches/chucko/i386/libsaio/efi.h =================================================================== --- branches/chucko/i386/libsaio/efi.h (revision 2328) +++ branches/chucko/i386/libsaio/efi.h (revision 2329) @@ -71,9 +71,8 @@ */ -// // Modifiers for EFI Runtime and Boot Services -// + #define EFI_RUNTIMESERVICE #define EFIAPI #define IN @@ -82,9 +81,7 @@ #define EFI_MAX_BIT 0x80000000 -// // Set the upper bit to indicate EFI Error. -// #define EFIERR(a) (EFI_MAX_BIT | (a)) #define EFIWARN(a) (a) @@ -118,11 +115,16 @@ #define EFI_INCOMPATIBLE_VERSION EFIERR (25) #define EFI_SECURITY_VIOLATION EFIERR (26) #define EFI_CRC_ERROR EFIERR (27) +#define EFI_END_OF_MEDIA EFIERR (28) +#define EFI_END_OF_FILE EFIERR (31) +#define EFI_INVALID_LANGUAGE EFIERR (32) +#define EFI_COMPROMISED_DATA EFIERR (33) #define EFI_WARN_UNKNOWN_GLYPH EFIWARN (1) #define EFI_WARN_DELETE_FAILURE EFIWARN (2) #define EFI_WARN_WRITE_FAILURE EFIWARN (3) #define EFI_WARN_BUFFER_TOO_SMALL EFIWARN (4) +#define EFI_WARN_STALE_DATA EFIWARN (5) // // EFI Specification Revision information @@ -141,7 +143,7 @@ {0xAC39C713, 0x7E50, 0x423D, {0x88, 0x9D, 0x27,0x8F, 0xCC, 0x34, 0x22, 0xB6} } #define EFI_GLOBAL_VARIABLE_GUID \ - {0x8BE4DF61, 0x93CA, 0x11d2, {0xAA, 0x0D, 0x00, 0xE0, 0x98, 0x03, 0x2B, 0x8C} } + {0x8BE4DF61, 0x93CA, 0x11D2, {0xAA, 0x0D, 0x00, 0xE0, 0x98, 0x03, 0x2B, 0x8C} } typedef union { EFI_GUID Guid; @@ -160,75 +162,74 @@ // TimeZone: -1440 to 1440 or 2047 // typedef struct { - EFI_UINT16 Year; - EFI_UINT8 Month; - EFI_UINT8 Day; - EFI_UINT8 Hour; - EFI_UINT8 Minute; - EFI_UINT8 Second; - EFI_UINT8 Pad1; - EFI_UINT32 Nanosecond; - EFI_INT16 TimeZone; - EFI_UINT8 Daylight; - EFI_UINT8 Pad2; + EFI_UINT16 Year; + EFI_UINT8 Month; + EFI_UINT8 Day; + EFI_UINT8 Hour; + EFI_UINT8 Minute; + EFI_UINT8 Second; + EFI_UINT8 Pad1; + EFI_UINT32 Nanosecond; + EFI_INT16 TimeZone; + EFI_UINT8 Daylight; + EFI_UINT8 Pad2; } EFI_TIME; -// + // Bit definitions for EFI_TIME.Daylight -// + #define EFI_TIME_ADJUST_DAYLIGHT 0x01 #define EFI_TIME_IN_DAYLIGHT 0x02 -// + // Value definition for EFI_TIME.TimeZone -// + #define EFI_UNSPECIFIED_TIMEZONE 0x07FF typedef enum { - EfiReservedMemoryType, - EfiLoaderCode, - EfiLoaderData, - EfiBootServicesCode, - EfiBootServicesData, - EfiRuntimeServicesCode, - EfiRuntimeServicesData, - EfiConventionalMemory, - EfiUnusableMemory, - EfiACPIReclaimMemory, - EfiACPIMemoryNVS, - EfiMemoryMappedIO, - EfiMemoryMappedIOPortSpace, - EfiPalCode, - EfiMaxMemoryType + EfiReservedMemoryType, + EfiLoaderCode, + EfiLoaderData, + EfiBootServicesCode, + EfiBootServicesData, + EfiRuntimeServicesCode, + EfiRuntimeServicesData, + EfiConventionalMemory, + EfiUnusableMemory, + EfiACPIReclaimMemory, + EfiACPIMemoryNVS, + EfiMemoryMappedIO, + EfiMemoryMappedIOPortSpace, + EfiPalCode, + EfiMaxMemoryType } EFI_MEMORY_TYPE; typedef struct { - EFI_UINT64 Signature; - EFI_UINT32 Revision; - EFI_UINT32 HeaderSize; - EFI_UINT32 CRC32; - EFI_UINT32 Reserved; + EFI_UINT64 Signature; + EFI_UINT32 Revision; + EFI_UINT32 HeaderSize; + EFI_UINT32 CRC32; + EFI_UINT32 Reserved; } __attribute__((aligned(8))) EFI_TABLE_HEADER; -// // possible caching types for the memory range -// + #define EFI_MEMORY_UC 0x0000000000000001ULL #define EFI_MEMORY_WC 0x0000000000000002ULL #define EFI_MEMORY_WT 0x0000000000000004ULL #define EFI_MEMORY_WB 0x0000000000000008ULL #define EFI_MEMORY_UCE 0x0000000000000010ULL -// + // physical memory protection on range -// + #define EFI_MEMORY_WP 0x0000000000001000ULL #define EFI_MEMORY_RP 0x0000000000002000ULL #define EFI_MEMORY_XP 0x0000000000004000ULL -// + // range requires a runtime mapping -// + #define EFI_MEMORY_RUNTIME 0x8000000000000000ULL typedef EFI_UINT64 EFI_PHYSICAL_ADDRESS; @@ -236,12 +237,12 @@ #define EFI_MEMORY_DESCRIPTOR_VERSION 1 typedef struct { - EFI_UINT32 Type; - EFI_UINT32 Pad; - EFI_PHYSICAL_ADDRESS PhysicalStart; - EFI_VIRTUAL_ADDRESS VirtualStart; - EFI_UINT64 NumberOfPages; - EFI_UINT64 Attribute; + EFI_UINT32 Type; + EFI_UINT32 Pad; + EFI_PHYSICAL_ADDRESS PhysicalStart; + EFI_VIRTUAL_ADDRESS VirtualStart; + EFI_UINT64 NumberOfPages; + EFI_UINT64 Attribute; } __attribute__((aligned(8))) EFI_MEMORY_DESCRIPTOR; @@ -263,9 +264,9 @@ IN OUT VOID **Address ) __attribute__((regparm(0))); -// + // Variable attributes -// + #define EFI_VARIABLE_NON_VOLATILE 0x00000001 #define EFI_VARIABLE_BOOTSERVICE_ACCESS 0x00000002 #define EFI_VARIABLE_RUNTIME_ACCESS 0x00000004 @@ -302,13 +303,13 @@ IN VOID * Data ) __attribute__((regparm(0))); -// + // EFI Time -// + typedef struct { - EFI_UINT32 Resolution; - EFI_UINT32 Accuracy; - EFI_BOOLEAN SetsToZero; + EFI_UINT32 Resolution; + EFI_UINT32 Accuracy; + EFI_BOOLEAN SetsToZero; } __attribute__((aligned(4))) EFI_TIME_CAPABILITIES; typedef @@ -371,18 +372,14 @@ OUT EFI_UINT32 * HighCount ) __attribute__((regparm(0))); -// // Definition of Status Code extended data header -// -// HeaderSize The size of the architecture. This is specified to enable -// the future expansion -// -// Size The size of the data in bytes. This does not include the size -// of the header structure. -// + +// HeaderSize The size of the architecture. This is specified to enable the future expansion + +// Size The size of the data in bytes. This does not include the size of the header structure. + // Type A GUID defining the type of the data -// -// + #ifdef TIANO_EXTENSION_FLAG typedef @@ -404,83 +401,74 @@ #define EFI_RUNTIME_SERVICES_REVISION ((EFI_SPECIFICATION_MAJOR_REVISION << 16) | (EFI_SPECIFICATION_MINOR_REVISION)) typedef struct { - EFI_TABLE_HEADER Hdr; + EFI_TABLE_HEADER Hdr; - // - // Time services - // - EFI_PTR32 GetTime; - EFI_PTR32 SetTime; - EFI_PTR32 GetWakeupTime; - EFI_PTR32 SetWakeupTime; + // Time Services + EFI_PTR32 GetTime; + EFI_PTR32 SetTime; + EFI_PTR32 GetWakeupTime; + EFI_PTR32 SetWakeupTime; - // - // Virtual memory services - // - EFI_PTR32 SetVirtualAddressMap; - EFI_PTR32 ConvertPointer; + // Virtual Memory Services - // - // Variable services - // - EFI_PTR32 GetVariable; - EFI_PTR32 GetNextVariableName; - EFI_PTR32 SetVariable; + EFI_PTR32 SetVirtualAddressMap; + EFI_PTR32 ConvertPointer; - // - // Misc - // - EFI_PTR32 GetNextHighMonotonicCount; - EFI_PTR32 ResetSystem; + // Variable Services + EFI_PTR32 GetVariable; + EFI_PTR32 GetNextVariableName; + EFI_PTR32 SetVariable; + + // Miscellaneous Services + EFI_PTR32 GetNextHighMonotonicCount; + EFI_PTR32 ResetSystem; + #ifdef TIANO_EXTENSION_FLAG - // - // //////////////////////////////////////////////////// - // Extended EFI Services - ////////////////////////////////////////////////////// - // - EFI_PTR32 ReportStatusCode; + + // //////////////////////////////////////////////////// + // Extended EFI Services + ////////////////////////////////////////////////////// + + EFI_PTR32 ReportStatusCode; #endif } __attribute__((aligned(8))) EFI_RUNTIME_SERVICES_32; typedef struct { - EFI_TABLE_HEADER Hdr; + EFI_TABLE_HEADER Hdr; - // - // Time services - // - EFI_PTR64 GetTime; - EFI_PTR64 SetTime; - EFI_PTR64 GetWakeupTime; - EFI_PTR64 SetWakeupTime; - // - // Virtual memory services - // - EFI_PTR64 SetVirtualAddressMap; - EFI_PTR64 ConvertPointer; + // Time services - // - // Variable services - // - EFI_PTR64 GetVariable; - EFI_PTR64 GetNextVariableName; - EFI_PTR64 SetVariable; + EFI_PTR64 GetTime; + EFI_PTR64 SetTime; + EFI_PTR64 GetWakeupTime; + EFI_PTR64 SetWakeupTime; - // - // Misc - // - EFI_PTR64 GetNextHighMonotonicCount; - EFI_PTR64 ResetSystem; + // Virtual memory services + EFI_PTR64 SetVirtualAddressMap; + EFI_PTR64 ConvertPointer; + + // Variable services + + EFI_PTR64 GetVariable; + EFI_PTR64 GetNextVariableName; + EFI_PTR64 SetVariable; + + // Misc + + EFI_PTR64 GetNextHighMonotonicCount; + EFI_PTR64 ResetSystem; + #ifdef TIANO_EXTENSION_FLAG - // - // //////////////////////////////////////////////////// - // Extended EFI Services - ////////////////////////////////////////////////////// - // - EFI_PTR64 ReportStatusCode; + + // //////////////////////////////////////////////////// + // Extended EFI Services + ////////////////////////////////////////////////////// + + EFI_PTR64 ReportStatusCode; #endif } __attribute__((aligned(8))) EFI_RUNTIME_SERVICES_64; @@ -489,18 +477,18 @@ // EFI Configuration Table // typedef struct { - EFI_GUID VendorGuid; - EFI_PTR32 VendorTable; + EFI_GUID VendorGuid; + EFI_PTR32 VendorTable; } EFI_CONFIGURATION_TABLE_32; typedef struct { - EFI_GUID VendorGuid; - EFI_PTR64 VendorTable; + EFI_GUID VendorGuid; + EFI_PTR64 VendorTable; } __attribute__((aligned(8))) EFI_CONFIGURATION_TABLE_64; -// + // EFI System Table -// + #define EFI_SYSTEM_TABLE_SIGNATURE 0x5453595320494249ULL #define EFI_SYSTEM_TABLE_REVISION ((EFI_SPECIFICATION_MAJOR_REVISION << 16) | (EFI_SPECIFICATION_MINOR_REVISION)) #define EFI_2_00_SYSTEM_TABLE_REVISION ((2 << 16) | 00) @@ -508,51 +496,49 @@ #define EFI_1_10_SYSTEM_TABLE_REVISION ((1 << 16) | 10) typedef struct EFI_SYSTEM_TABLE_32 { - EFI_TABLE_HEADER Hdr; + EFI_TABLE_HEADER Hdr; - EFI_PTR32 FirmwareVendor; - EFI_UINT32 FirmwareRevision; + EFI_PTR32 FirmwareVendor; + EFI_UINT32 FirmwareRevision; - EFI_HANDLE32 ConsoleInHandle; - EFI_PTR32 ConIn; + EFI_HANDLE32 ConsoleInHandle; + EFI_PTR32 ConIn; - EFI_HANDLE32 ConsoleOutHandle; - EFI_PTR32 ConOut; + EFI_HANDLE32 ConsoleOutHandle; + EFI_PTR32 ConOut; - EFI_HANDLE32 StandardErrorHandle; - EFI_PTR32 StdErr; + EFI_HANDLE32 StandardErrorHandle; + EFI_PTR32 StdErr; - EFI_PTR32 RuntimeServices; - EFI_PTR32 BootServices; + EFI_PTR32 RuntimeServices; + EFI_PTR32 BootServices; - EFI_UINT32 NumberOfTableEntries; - EFI_PTR32 ConfigurationTable; + EFI_UINT32 NumberOfTableEntries; + EFI_PTR32 ConfigurationTable; } __attribute__((aligned(8))) EFI_SYSTEM_TABLE_32; typedef struct EFI_SYSTEM_TABLE_64 { - EFI_TABLE_HEADER Hdr; + EFI_TABLE_HEADER Hdr; - EFI_PTR64 FirmwareVendor; - EFI_UINT32 FirmwareRevision; + EFI_PTR64 FirmwareVendor; + EFI_UINT32 FirmwareRevision; - EFI_UINT32 __pad; + EFI_UINT32 __pad; + EFI_HANDLE64 ConsoleInHandle; + EFI_PTR64 ConIn; - EFI_HANDLE64 ConsoleInHandle; - EFI_PTR64 ConIn; + EFI_HANDLE64 ConsoleOutHandle; + EFI_PTR64 ConOut; - EFI_HANDLE64 ConsoleOutHandle; - EFI_PTR64 ConOut; + EFI_HANDLE64 StandardErrorHandle; + EFI_PTR64 StdErr; - EFI_HANDLE64 StandardErrorHandle; - EFI_PTR64 StdErr; + EFI_PTR64 RuntimeServices; + EFI_PTR64 BootServices; - EFI_PTR64 RuntimeServices; - EFI_PTR64 BootServices; - - EFI_UINT64 NumberOfTableEntries; - EFI_PTR64 ConfigurationTable; - + EFI_UINT64 NumberOfTableEntries; + EFI_PTR64 ConfigurationTable; } __attribute__((aligned(8))) EFI_SYSTEM_TABLE_64; #endif /* _PEXPERT_I386_EFI_H */ Index: branches/chucko/i386/libsaio/bootstruct.h =================================================================== --- branches/chucko/i386/libsaio/bootstruct.h (revision 2328) +++ branches/chucko/i386/libsaio/bootstruct.h (revision 2329) @@ -44,7 +44,6 @@ //#define FB_TEXT_MODE 2 - /* * Maximum number of boot drivers that can be loaded. */ @@ -75,9 +74,9 @@ } PCI_bus_info_t; typedef struct { - unsigned long address; // address where driver was loaded - unsigned long size; // number of bytes - unsigned long type; // driver type + unsigned long address; // address where driver was loaded + unsigned long size; // number of bytes + unsigned long type; // driver type } driver_config_t; /* @@ -91,12 +90,12 @@ * ACPI defined memory range types. */ enum { - kMemoryRangeUsable = 1, // RAM usable by the OS. - kMemoryRangeReserved = 2, // Reserved. (Do not use) - kMemoryRangeACPI = 3, // ACPI tables. Can be reclaimed. - kMemoryRangeNVS = 4, // ACPI NVS memory. (Do not use) + kMemoryRangeUsable = 1, // RAM usable by the OS. + kMemoryRangeReserved = 2, // Reserved. (Do not use) + kMemoryRangeACPI = 3, // ACPI tables. Can be reclaimed. + kMemoryRangeNVS = 4, // ACPI NVS memory. (Do not use) - /* Undefined types should be treated as kMemoryRangeReserved */ + /* Undefined types should be treated as kMemoryRangeReserved */ }; /*! @@ -108,30 +107,30 @@ to the kernel and are thus located in bootArgs although with different field names. */ typedef struct PrivateBootInfo { - int convmem; // conventional memory - int extmem; // extended memory + int convmem; // conventional memory + int extmem; // extended memory #if 0 - int numBootDrivers; // number of drivers loaded + int numBootDrivers; // number of drivers loaded #endif - char bootFile[128]; // kernel file name + char bootFile[128]; // kernel file name - unsigned long memoryMapCount; - MemoryRange memoryMap[kMemoryMapCountMax]; + unsigned long memoryMapCount; + MemoryRange memoryMap[kMemoryMapCountMax]; - PCI_bus_info_t pciInfo; + PCI_bus_info_t pciInfo; #if 0 - driver_config_t driverConfig[NDRIVERS]; + driver_config_t driverConfig[NDRIVERS]; #endif - char * configEnd; // pointer to end of config files - char config[CONFIG_SIZE]; + char * configEnd; // pointer to end of config files + char config[CONFIG_SIZE]; - config_file_t bootConfig; // com.apple.Boot.plist - config_file_t chameleonConfig; // org.chameleon.Boot.plist which can override bootConfig keys - config_file_t themeConfig; // theme.plist - config_file_t smbiosConfig; // smbios.plist - config_file_t helperConfig; // boot helper partition's boot.plist - config_file_t ramdiskConfig; // RAMDisk.plist + config_file_t bootConfig; // com.apple.Boot.plist + config_file_t chameleonConfig; // org.chameleon.Boot.plist which can override bootConfig keys + config_file_t themeConfig; // theme.plist + config_file_t smbiosConfig; // smbios.plist + config_file_t helperConfig; // boot helper partition's boot.plist + config_file_t ramdiskConfig; // RAMDisk.plist bool memDetect; } PrivateBootInfo_t; Index: branches/chucko/i386/libsaio/device_tree.c =================================================================== --- branches/chucko/i386/libsaio/device_tree.c (revision 2328) +++ branches/chucko/i386/libsaio/device_tree.c (revision 2329) @@ -1,31 +1,49 @@ /* - * Copyright (c) 2005 Apple Computer, Inc. All Rights Reserved. + * Copyright (c) 2005 Apple Computer, Inc. All rights reserved. + * + * Portions Copyright (c) 1999-2003 Apple Computer, Inc. All Rights + * Reserved. This file contains Original Code and/or Modifications of + * Original Code as defined in and that are subject to the Apple Public + * Source License Version 2.0 (the "License"). You may not use this file + * except in compliance with the License. Please obtain a copy of the + * License at http://www.apple.com/publicsource and read it before using + * this file. + * + * The Original Code and all software distributed under the License are + * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER + * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES, + * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE OR NON- INFRINGEMENT. Please see the + * License for the specific language governing rights and limitations + * under the License. + * */ #if 1 /* - + Structures for a Flattened Device Tree */ #define kPropNameLength 32 typedef struct DeviceTreeNodeProperty { - char name[kPropNameLength]; // NUL terminated property name - unsigned long length; // Length (bytes) of folloing prop value + char name[kPropNameLength]; // NUL terminated property name + unsigned long length; // Length (bytes) of folloing prop value // unsigned long value[1]; // Variable length value of property // Padded to a multiple of a longword? } DeviceTreeNodeProperty; typedef struct OpaqueDTEntry { - unsigned long nProperties; // Number of props[] elements (0 => end) - unsigned long nChildren; // Number of children[] elements + unsigned long nProperties; // Number of props[] elements (0 => end) + unsigned long nChildren; // Number of children[] elements // DeviceTreeNodeProperty props[];// array size == nProperties // DeviceTreeNode children[]; // array size == nChildren } DeviceTreeNode; typedef char DTPropertyNameBuf[32]; -/* Entry Name Definitions (Entry Names are C-Strings)*/ + +// Entry Name Definitions (Entry Names are C-Strings). enum { kDTMaxEntryNameLength = 31 /* Max length of a C-String Entry Name (terminator not included) */ }; @@ -49,9 +67,9 @@ #define RoundToLong(x) (((x) + 3) & ~3) static struct _DTSizeInfo { - uint32_t numNodes; - uint32_t numProperties; - uint32_t totalPropertySize; + uint32_t numNodes; + uint32_t numProperties; + uint32_t totalPropertySize; } DTInfo; #define kAllocSize 4096 @@ -61,105 +79,142 @@ static Node *freeNodes, *allocedNodes; static Property *freeProperties, *allocedProperties; + +//============================================================================== + Property * DT__AddProperty(Node *node, const char *name, uint32_t length, void *value) { - Property *prop; + Property *prop; - DPRINTF("DT__AddProperty([Node '%s'], '%s', %d, 0x%x)\n", DT__GetName(node), name, length, value); - if (freeProperties == NULL) { - void *buf = malloc(kAllocSize); - int i; - - DPRINTF("Allocating more free properties\n"); - if (buf == 0) return 0; - bzero(buf, kAllocSize); - // Use the first property to record the allocated buffer - // for later freeing. - prop = (Property *)buf; - prop->next = allocedProperties; - allocedProperties = prop; - prop->value = buf; - prop++; - for (i=1; i<(kAllocSize / sizeof(Property)); i++) { - prop->next = freeProperties; - freeProperties = prop; - prop++; - } - } - prop = freeProperties; - freeProperties = prop->next; + DPRINTF("DT__AddProperty([Node '%s'], '%s', %d, 0x%x)\n", DT__GetName(node), name, length, value); - prop->name = name; - prop->length = length; - prop->value = value; + if (freeProperties == NULL) { + void *buf = malloc(kAllocSize); + int i; - // Always add to end of list - if (node->properties == 0) { - node->properties = prop; - } else { - node->last_prop->next = prop; - } - node->last_prop = prop; - prop->next = 0; + DPRINTF("Allocating more free properties\n"); - DPRINTF("Done [0x%x]\n", prop); - - DTInfo.numProperties++; - DTInfo.totalPropertySize += RoundToLong(length); + if (buf == 0) { + return 0; + } - return prop; + bzero(buf, kAllocSize); + // Use the first property to record the allocated buffer + // for later freeing. + prop = (Property *)buf; + prop->next = allocedProperties; + allocedProperties = prop; + prop->value = buf; + prop++; + + for (i = 1; i < (kAllocSize / sizeof(Property)); i++) { + prop->next = freeProperties; + freeProperties = prop; + prop++; + } + } + + prop = freeProperties; + freeProperties = prop->next; + + prop->name = name; + prop->length = length; + prop->value = value; + + // Always add to end of list + if (node->properties == 0) { + node->properties = prop; + } else { + node->last_prop->next = prop; + } + + node->last_prop = prop; + prop->next = 0; + + DPRINTF("Done [0x%x]\n", prop); + + DTInfo.numProperties++; + DTInfo.totalPropertySize += RoundToLong(length); + + return prop; } + +//============================================================================== + Node * DT__AddChild(Node *parent, const char *name) { - Node *node; + Node *node; - if (freeNodes == NULL) { - void *buf = malloc(kAllocSize); - int i; - - DPRINTF("Allocating more free nodes\n"); - if (buf == 0) return 0; - bzero(buf, kAllocSize); - node = (Node *)buf; - // Use the first node to record the allocated buffer - // for later freeing. - node->next = allocedNodes; - allocedNodes = node; - node->children = (Node *)buf; - node++; - for (i=1; i<(kAllocSize / sizeof(Node)); i++) { - node->next = freeNodes; - freeNodes = node; - node++; - } - } - DPRINTF("DT__AddChild(0x%x, '%s')\n", parent, name); - node = freeNodes; - freeNodes = node->next; - DPRINTF("Got free node 0x%x\n", node); - DPRINTF("prop = 0x%x, children = 0x%x, next = 0x%x\n", node->properties, node->children, node->next); + if (freeNodes == NULL) + { + void *buf = malloc(kAllocSize); - if (parent == NULL) { - rootNode = node; - node->next = 0; - } else { - node->next = parent->children; - parent->children = node; - } - DTInfo.numNodes++; - DT__AddProperty(node, "name", strlen(name) + 1, (void *) name); - return node; + if (buf == 0) + { + return 0; + } + + int i; + + DPRINTF("Allocating more free nodes\n"); + + bzero(buf, kAllocSize); + node = (Node *)buf; + + // Use the first node to record the allocated buffer for later freeing. + node->next = allocedNodes; + allocedNodes = node; + node->children = (Node *)buf; + node++; + + for (i = 1; i < (kAllocSize / sizeof(Node)); i++) + { + node->next = freeNodes; + freeNodes = node; + node++; + } + } + + DPRINTF("DT__AddChild(0x%x, '%s')\n", parent, name); + + node = freeNodes; + freeNodes = node->next; + + DPRINTF("Got free node 0x%x\n", node); + DPRINTF("prop = 0x%x, children = 0x%x, next = 0x%x\n", node->properties, node->children, node->next); + + if (parent == NULL) + { + rootNode = node; + node->next = 0; + } + else + { + node->next = parent->children; + parent->children = node; + } + + DTInfo.numNodes++; + DT__AddProperty(node, "name", strlen(name) + 1, (void *) name); + + return node; } + +//============================================================================== + void DT__FreeProperty(Property *prop) { - prop->next = freeProperties; - freeProperties = prop; + prop->next = freeProperties; + freeProperties = prop; } + +//============================================================================== + void DT__FreeNode(Node *node) { @@ -167,89 +222,103 @@ freeNodes = node; } +//============================================================================== + void DT__Initialize(void) { - DPRINTF("DT__Initialize\n"); - - freeNodes = 0; - allocedNodes = 0; - freeProperties = 0; - allocedProperties = 0; - - DTInfo.numNodes = 0; - DTInfo.numProperties = 0; - DTInfo.totalPropertySize = 0; - - rootNode = DT__AddChild(NULL, "/"); - DPRINTF("DT__Initialize done\n"); + DPRINTF("DT__Initialize\n"); + + freeNodes = 0; + allocedNodes = 0; + freeProperties = 0; + allocedProperties = 0; + + DTInfo.numNodes = 0; + DTInfo.numProperties = 0; + DTInfo.totalPropertySize = 0; + + rootNode = DT__AddChild(NULL, "/"); + DPRINTF("DT__Initialize done\n"); } +//============================================================================== /* - * Free up memory used by in-memory representation - * of device tree. + * Free up memory used by in-memory representation of device tree. */ void DT__Finalize(void) { - Node *node; - Property *prop; + Node *node; + Property *prop; - DPRINTF("DT__Finalize\n"); - for (prop = allocedProperties; prop != NULL; prop = prop->next) { - free(prop->value); - } - allocedProperties = NULL; - freeProperties = NULL; + DPRINTF("DT__Finalize\n"); - for (node = allocedNodes; node != NULL; node = node->next) { - free((void *)node->children); - } - allocedNodes = NULL; - freeNodes = NULL; - rootNode = NULL; + for (prop = allocedProperties; prop != NULL; prop = prop->next) + { + free(prop->value); + } + + allocedProperties = NULL; + freeProperties = NULL; + + for (node = allocedNodes; node != NULL; node = node->next) + { + free((void *)node->children); + } + + allocedNodes = NULL; + freeNodes = NULL; + rootNode = NULL; - // XXX leaks any created strings - - DTInfo.numNodes = 0; - DTInfo.numProperties = 0; - DTInfo.totalPropertySize = 0; + // XXX leaks any created strings + DTInfo.numNodes = 0; + DTInfo.numProperties = 0; + DTInfo.totalPropertySize = 0; } +//============================================================================== + static void * FlattenNodes(Node *node, void *buffer) { - Property *prop; - DeviceTreeNode *flatNode; - DeviceTreeNodeProperty *flatProp; - int count; + Property *prop; + DeviceTreeNode *flatNode; + DeviceTreeNodeProperty *flatProp; + int count; - if (node == 0) return buffer; + if (node == 0) { + return buffer; + } - flatNode = (DeviceTreeNode *)buffer; - buffer += sizeof(DeviceTreeNode); + flatNode = (DeviceTreeNode *)buffer; + buffer += sizeof(DeviceTreeNode); - for (count = 0, prop = node->properties; prop != 0; count++, prop = prop->next) { - flatProp = (DeviceTreeNodeProperty *)buffer; - strcpy(flatProp->name, prop->name); - flatProp->length = prop->length; - buffer += sizeof(DeviceTreeNodeProperty); - bcopy(prop->value, buffer, prop->length); - buffer += RoundToLong(prop->length); - } - flatNode->nProperties = count; + for (count = 0, prop = node->properties; prop != 0; count++, prop = prop->next) + { + flatProp = (DeviceTreeNodeProperty *)buffer; + strcpy(flatProp->name, prop->name); + flatProp->length = prop->length; + buffer += sizeof(DeviceTreeNodeProperty); + bcopy(prop->value, buffer, prop->length); + buffer += RoundToLong(prop->length); + } - for (count = 0, node = node->children; node != 0; count++, node = node->next) { - buffer = FlattenNodes(node, buffer); - } - flatNode->nChildren = count; + flatNode->nProperties = count; - return buffer; + for (count = 0, node = node->children; node != 0; count++, node = node->next) + { + buffer = FlattenNodes(node, buffer); + } + + flatNode->nChildren = count; + + return buffer; } -/* - * Flatten the in-memory representation of the device tree - * into a binary DT block. + +/*============================================================================== + * Flatten the in-memory representation of the device tree into a binary DT block. * To get the buffer size needed, call with result = 0. * To have a buffer allocated for you, call with *result = 0. * To use your own buffer, call with *result = &buffer. @@ -258,282 +327,361 @@ void DT__FlattenDeviceTree(void **buffer_p, uint32_t *length) { - uint32_t totalSize; - void *buf; + uint32_t totalSize; + void * buf; - DPRINTF("DT__FlattenDeviceTree(0x%x, 0x%x)\n", buffer_p, length); + DPRINTF("DT__FlattenDeviceTree(0x%x, 0x%x)\n", buffer_p, length); + #if DEBUG - if (buffer_p) DT__PrintTree(rootNode); + if (buffer_p) { + DT__PrintTree(rootNode); + } #endif - totalSize = DTInfo.numNodes * sizeof(DeviceTreeNode) + - DTInfo.numProperties * sizeof(DeviceTreeNodeProperty) + - DTInfo.totalPropertySize; + totalSize = DTInfo.numNodes * sizeof(DeviceTreeNode) + + DTInfo.numProperties * sizeof(DeviceTreeNodeProperty) + + DTInfo.totalPropertySize; - DPRINTF("Total size 0x%x\n", totalSize); - if (buffer_p != 0) { - if (totalSize == 0) { - buf = 0; - } else { - if (*buffer_p == 0) { - buf = malloc(totalSize); - } else { - buf = *buffer_p; - } - bzero(buf, totalSize); - - FlattenNodes(rootNode, buf); - } - *buffer_p = buf; - } - if (length) - *length = totalSize; + DPRINTF("Total size 0x%x\n", totalSize); + + if (buffer_p != 0) + { + if (totalSize == 0) + { + buf = 0; + } + else + { + if (*buffer_p == 0) + { + buf = malloc(totalSize); + } + else + { + buf = *buffer_p; + } + + bzero(buf, totalSize); + + FlattenNodes(rootNode, buf); + } + + *buffer_p = buf; + } + + if (length) + { + *length = totalSize; + } } +//============================================================================== + char * DT__GetName(Node *node) { - Property *prop; + Property *prop; - //DPRINTF("DT__GetName(0x%x)\n", node); - //DPRINTF("Node properties = 0x%x\n", node->properties); - for (prop = node->properties; prop; prop = prop->next) { - //DPRINTF("Prop '%s'\n", prop->name); - if (strcmp(prop->name, "name") == 0) { - return prop->value; - } - } - //DPRINTF("DT__GetName returns 0\n"); - return "(null)"; + //DPRINTF("DT__GetName(0x%x)\n", node); + //DPRINTF("Node properties = 0x%x\n", node->properties); + for (prop = node->properties; prop; prop = prop->next) + { + //DPRINTF("Prop '%s'\n", prop->name); + if (strcmp(prop->name, "name") == 0) + { + return prop->value; + } + } + + //DPRINTF("DT__GetName returns 0\n"); + return "(null)"; } +//============================================================================== + Node * DT__FindNode(const char *path, bool createIfMissing) { - Node *node, *child; - DTPropertyNameBuf nameBuf; - char *bp; - int i; + Node *node, *child; + DTPropertyNameBuf nameBuf; + char *bp; + int i; - DPRINTF("DT__FindNode('%s', %d)\n", path, createIfMissing); + DPRINTF("DT__FindNode('%s', %d)\n", path, createIfMissing); - // Start at root - node = rootNode; - DPRINTF("root = 0x%x\n", rootNode); + // Start at root + node = rootNode; - while (node) { - // Skip leading slash - while (*path == '/') path++; + DPRINTF("root = 0x%x\n", rootNode); - for (i=0, bp = nameBuf; ++i < kDTMaxEntryNameLength && *path && *path != '/'; bp++, path++) *bp = *path; - *bp = '\0'; + while (node) + { + // Skip leading slash + while (*path == '/') + { + path++; + } - if (nameBuf[0] == '\0') { - // last path entry - break; - } - DPRINTF("Node '%s'\n", nameBuf); + for (i = 0, bp = nameBuf; ++i < kDTMaxEntryNameLength && *path && *path != '/'; bp++, path++) + { + *bp = *path; + } - for (child = node->children; child != 0; child = child->next) { - DPRINTF("Child 0x%x\n", child); - if (strcmp(DT__GetName(child), nameBuf) == 0) { - break; - } - } - if (child == 0 && createIfMissing) { - DPRINTF("Creating node\n"); - char *str = malloc(strlen(nameBuf) + 1); - // XXX this will leak - strcpy(str, nameBuf); + *bp = '\0'; - child = DT__AddChild(node, str); - } - node = child; - } - return node; + if (nameBuf[0] == '\0') + { + // last path entry + break; + } + + DPRINTF("Node '%s'\n", nameBuf); + + for (child = node->children; child != 0; child = child->next) + { + DPRINTF("Child 0x%x\n", child); + + if (strcmp(DT__GetName(child), nameBuf) == 0) + { + break; + } + } + + if (child == 0 && createIfMissing) + { + DPRINTF("Creating node\n"); + + char *str = malloc(strlen(nameBuf) + 1); + // XXX this will leak + strcpy(str, nameBuf); + + child = DT__AddChild(node, str); + } + + node = child; + } + + return node; } #if DEBUG +//============================================================================== + void DT__PrintNode(Node *node, int level) { - char spaces[10], *cp = spaces; - Property *prop; + char spaces[10], *cp = spaces; + Property *prop; - if (level > 9) level = 9; - while (level--) *cp++ = ' '; - *cp = '\0'; + if (level > 9) + { + level = 9; + } - printf("%s===Node===\n", spaces); - for (prop = node->properties; prop; prop = prop->next) { - char c = *((char *)prop->value); - if (prop->length < 64 && ( - strcmp(prop->name, "name") == 0 || - (c >= '0' && c <= '9') || - (c >= 'a' && c <= 'z') || - (c >= 'A' && c <= 'Z') || c == '_')) { - printf("%s Property '%s' [%d] = '%s'\n", spaces, prop->name, prop->length, prop->value); - } else { - printf("%s Property '%s' [%d] = (data)\n", spaces, prop->name, prop->length); - } - } - printf("%s==========\n", spaces); + while (level--) + { + *cp++ = ' '; + } + + *cp = '\0'; + + printf("%s===Node===\n", spaces); + + for (prop = node->properties; prop; prop = prop->next) + { + char c = *((char *)prop->value); + if (prop->length < 64 && (strcmp(prop->name, "name") == 0 || (c >= '0' && c <= '9') || (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') || c == '_')) + { + printf("%s Property '%s' [%d] = '%s'\n", spaces, prop->name, prop->length, prop->value); + } + else + { + printf("%s Property '%s' [%d] = (data)\n", spaces, prop->name, prop->length); + } + } + + printf("%s==========\n", spaces); } +//============================================================================== + static void _PrintTree(Node *node, int level) { - DT__PrintNode(node, level); - level++; - for (node = node->children; node; node = node->next) - _PrintTree(node, level); + DT__PrintNode(node, level); + + level++; + + for (node = node->children; node; node = node->next) + { + _PrintTree(node, level); + } } +//============================================================================== + void DT__PrintTree(Node *node) { - if (node == 0) node = rootNode; - _PrintTree(node, 0); + if (node == 0) node = rootNode; + _PrintTree(node, 0); } +//============================================================================== + void DT__PrintFlattenedNode(DTEntry entry, int level) { - char spaces[10], *cp = spaces; - DTPropertyIterator propIter; - char *name; - void *prop; - int propSize; + char spaces[10], *cp = spaces; + DTPropertyIterator propIter; + char *name; + void *prop; + int propSize; - if (level > 9) level = 9; - while (level--) *cp++ = ' '; - *cp = '\0'; + if (level > 9) level = 9; + while (level--) *cp++ = ' '; + *cp = '\0'; - printf("%s===Entry %p===\n", spaces, entry); - if (kSuccess != DTCreatePropertyIterator(entry, &propIter)) { - printf("Couldn't create property iterator\n"); - return; - } - while( kSuccess == DTIterateProperties( propIter, &name)) { - if( kSuccess != DTGetProperty( entry, name, &prop, &propSize )) - continue; - printf("%s Property %s = %s\n", spaces, name, prop); - } - DTDisposePropertyIterator(propIter); + printf("%s===Entry %p===\n", spaces, entry); + if (kSuccess != DTCreatePropertyIterator(entry, &propIter)) + { + printf("Couldn't create property iterator\n"); + return; + } + while( kSuccess == DTIterateProperties( propIter, &name)) + { + if( kSuccess != DTGetProperty( entry, name, &prop, &propSize )) + continue; + printf("%s Property %s = %s\n", spaces, name, prop); + } + DTDisposePropertyIterator(propIter); - printf("%s==========\n", spaces); + printf("%s==========\n", spaces); } +//============================================================================== + static void _PrintFlattenedTree(DTEntry entry, int level) { - DTEntryIterator entryIter; + DTEntryIterator entryIter; - PrintFlattenedNode(entry, level); + PrintFlattenedNode(entry, level); - if (kSuccess != DTCreateEntryIterator(entry, &entryIter)) { - printf("Couldn't create entry iterator\n"); - return; - } - level++; - while (kSuccess == DTIterateEntries( entryIter, &entry )) { - _PrintFlattenedTree(entry, level); - } - DTDisposeEntryIterator(entryIter); + if (kSuccess != DTCreateEntryIterator(entry, &entryIter)) + { + printf("Couldn't create entry iterator\n"); + return; + } + level++; + while (kSuccess == DTIterateEntries( entryIter, &entry )) + { + _PrintFlattenedTree(entry, level); + } + DTDisposeEntryIterator(entryIter); } +//============================================================================== + void DT__PrintFlattenedTree(DTEntry entry) { - _PrintFlattenedTree(entry, 0); + _PrintFlattenedTree(entry, 0); } +//============================================================================== int main(int argc, char **argv) { - DTEntry dtEntry; - DTPropertyIterator propIter; - DTEntryIterator entryIter; - void *prop; - int propSize; - char *name; - void *flatTree; - uint32_t flatSize; + DTEntry dtEntry; + DTPropertyIterator propIter; + DTEntryIterator entryIter; + void *prop; + int propSize; + char *name; + void *flatTree; + uint32_t flatSize; - Node *node; + Node *node; - node = AddChild(NULL, "device-tree"); - AddProperty(node, "potato", 4, "foo"); - AddProperty(node, "chemistry", 4, "bar"); - AddProperty(node, "physics", 4, "baz"); + node = AddChild(NULL, "device-tree"); + AddProperty(node, "potato", 4, "foo"); + AddProperty(node, "chemistry", 4, "bar"); + AddProperty(node, "physics", 4, "baz"); - node = AddChild(node, "dev"); - AddProperty(node, "one", 4, "one"); - AddProperty(node, "two", 4, "two"); - AddProperty(node, "three", 6, "three"); + node = AddChild(node, "dev"); + AddProperty(node, "one", 4, "one"); + AddProperty(node, "two", 4, "two"); + AddProperty(node, "three", 6, "three"); - node = AddChild(rootNode, "foo"); - AddProperty(node, "aaa", 4, "aab"); - AddProperty(node, "bbb", 4, "bbc"); - AddProperty(node, "cccc", 6, "ccccd"); + node = AddChild(rootNode, "foo"); + AddProperty(node, "aaa", 4, "aab"); + AddProperty(node, "bbb", 4, "bbc"); + AddProperty(node, "cccc", 6, "ccccd"); - node = FindNode("/this/is/a/test", 1); - AddProperty(node, "dddd", 12, "abcdefghijk"); + node = FindNode("/this/is/a/test", 1); + AddProperty(node, "dddd", 12, "abcdefghijk"); - printf("In-memory tree:\n\n"); + printf("In-memory tree:\n\n"); - PrintTree(rootNode); + PrintTree(rootNode); - FlattenDeviceTree(&flatTree, &flatSize); + FlattenDeviceTree(&flatTree, &flatSize); - printf("Flat tree = %p, size %d\n", flatTree, flatSize); + printf("Flat tree = %p, size %d\n", flatTree, flatSize); - dtEntry = (DTEntry)flatTree; + dtEntry = (DTEntry)flatTree; - printf("\n\nPrinting flat tree\n\n"); + printf("\n\nPrinting flat tree\n\n"); - DTInit(dtEntry); + DTInit(dtEntry); - PrintFlattenedTree((DTEntry)flatTree); + PrintFlattenedTree((DTEntry)flatTree); #if 0 - printf("=== Entry %p ===\n", dtEntry); - if (kSuccess != DTCreatePropertyIterator(dtEntry, &propIter)) { - printf("Couldn't create property iterator\n"); - return 1; + printf("=== Entry %p ===\n", dtEntry); + if (kSuccess != DTCreatePropertyIterator(dtEntry, &propIter)) + { + printf("Couldn't create property iterator\n"); + return 1; + } + while( kSuccess == DTIterateProperties( propIter, &name)) + { + if( kSuccess != DTGetProperty( dtEntry, name, &prop, &propSize )) + continue; + printf(" Property %s = %s\n", name, prop); } - while( kSuccess == DTIterateProperties( propIter, &name)) { - if( kSuccess != DTGetProperty( dtEntry, name, &prop, &propSize )) - continue; - printf(" Property %s = %s\n", name, prop); - } - DTDisposePropertyIterator(propIter); - printf("========\n"); + DTDisposePropertyIterator(propIter); + printf("========\n"); - if (kSuccess != DTCreateEntryIterator(dtEntry, &entryIter)) { - printf("Couldn't create entry iterator\n"); - return 1; - } - while (kSuccess == DTIterateEntries( entryIter, &dtEntry )) { - printf("=== Entry %p ===\n", dtEntry); + if (kSuccess != DTCreateEntryIterator(dtEntry, &entryIter)) + { + printf("Couldn't create entry iterator\n"); + return 1; + } + while (kSuccess == DTIterateEntries( entryIter, &dtEntry )) + { + printf("=== Entry %p ===\n", dtEntry); - if (kSuccess != DTCreatePropertyIterator(dtEntry, &propIter)) { - printf("Couldn't create property iterator\n"); - return 1; - } - while( kSuccess == DTIterateProperties( propIter, &name)) { - if( kSuccess != DTGetProperty( dtEntry, name, &prop, &propSize )) - continue; - printf(" Property %s = %s\n", name, prop); - } - DTDisposePropertyIterator(propIter); - printf("========\n"); - } - DTDisposeEntryIterator(entryIter); + if (kSuccess != DTCreatePropertyIterator(dtEntry, &propIter)) + { + printf("Couldn't create property iterator\n"); + return 1; + } + while( kSuccess == DTIterateProperties( propIter, &name)) + { + if( kSuccess != DTGetProperty( dtEntry, name, &prop, &propSize )) + continue; + printf(" Property %s = %s\n", name, prop); + } + DTDisposePropertyIterator(propIter); + printf("========\n"); + } + DTDisposeEntryIterator(entryIter); #endif - return 0; + return 0; } #endif Index: branches/chucko/i386/libsaio/hfs.c =================================================================== --- branches/chucko/i386/libsaio/hfs.c (revision 2328) +++ branches/chucko/i386/libsaio/hfs.c (revision 2329) @@ -109,156 +109,187 @@ u_int16_t *uniStr2, u_int32_t len2); +//============================================================================== + static void SwapFinderInfo(FndrFileInfo *dst, FndrFileInfo *src) { - dst->fdType = SWAP_BE32(src->fdType); - dst->fdCreator = SWAP_BE32(src->fdCreator); - dst->fdFlags = SWAP_BE16(src->fdFlags); - // Don't bother with location + dst->fdType = SWAP_BE32(src->fdType); + dst->fdCreator = SWAP_BE32(src->fdCreator); + dst->fdFlags = SWAP_BE16(src->fdFlags); + // Don't bother with location } + +//============================================================================== + void HFSFree(CICell ih) { - if(gCurrentIH == ih) - gCurrentIH = 0; - free(ih); + if(gCurrentIH == ih) { + gCurrentIH = 0; + } + free(ih); } + +//============================================================================== + bool HFSProbe (const void *buf) { const HFSMasterDirectoryBlock *mdb; const HFSPlusVolumeHeader *header; - mdb=(const HFSMasterDirectoryBlock *)(((const char*)buf)+kMDBBaseOffset); - header=(const HFSPlusVolumeHeader *)(((const char*)buf)+kMDBBaseOffset); + mdb = (const HFSMasterDirectoryBlock *)(((const char*)buf)+kMDBBaseOffset); + header = (const HFSPlusVolumeHeader *)(((const char*)buf)+kMDBBaseOffset); - if ( SWAP_BE16(mdb->drSigWord) == kHFSSigWord ) + if ( SWAP_BE16(mdb->drSigWord) == kHFSSigWord ) { return true; - if (SWAP_BE16(header->signature) != kHFSPlusSigWord && - SWAP_BE16(header->signature) != kHFSXSigWord) + } + + if (SWAP_BE16(header->signature) != kHFSPlusSigWord && SWAP_BE16(header->signature) != kHFSXSigWord) { return false; + } return true; } + +//============================================================================== + long HFSInitPartition(CICell ih) { - long extentSize, extentFile, nodeSize; - void *extent; + long extentSize, extentFile, nodeSize; + void *extent; - if (ih == gCurrentIH) { + if (ih == gCurrentIH) + { #ifdef __i386__ - CacheInit(ih, gCacheBlockSize); + CacheInit(ih, gCacheBlockSize); #endif - return 0; - } + return 0; + } #ifdef __i386__ - if (!gTempStr) gTempStr = (char *)malloc(4096); - if (!gLinkTemp) gLinkTemp = (char *)malloc(64); - if (!gBTreeHeaderBuffer) gBTreeHeaderBuffer = (char *)malloc(512); - if (!gHFSMdbVib) { - gHFSMdbVib = (char *)malloc(kBlockSize); - gHFSMDB = (HFSMasterDirectoryBlock *)gHFSMdbVib; - } - if (!gHFSPlusHeader) { - gHFSPlusHeader = (char *)malloc(kBlockSize); - gHFSPlus = (HFSPlusVolumeHeader *)gHFSPlusHeader; - } - if (!gTempStr || !gLinkTemp || !gBTreeHeaderBuffer || - !gHFSMdbVib || !gHFSPlusHeader) return -1; + if (!gTempStr) + { + gTempStr = (char *)malloc(4096); + } + if (!gLinkTemp) + { + gLinkTemp = (char *)malloc(64); + } + if (!gBTreeHeaderBuffer) + { + gBTreeHeaderBuffer = (char *)malloc(512); + } + if (!gHFSMdbVib) + { + gHFSMdbVib = (char *)malloc(kBlockSize); + gHFSMDB = (HFSMasterDirectoryBlock *)gHFSMdbVib; + } + if (!gHFSPlusHeader) + { + gHFSPlusHeader = (char *)malloc(kBlockSize); + gHFSPlus = (HFSPlusVolumeHeader *)gHFSPlusHeader; + } + if (!gTempStr || !gLinkTemp || !gBTreeHeaderBuffer || !gHFSMdbVib || !gHFSPlusHeader) + { + return -1; + } #endif /* __i386__ */ - gAllocationOffset = 0; - gIsHFSPlus = 0; - gCaseSensitive = 0; - gBTHeaders[0] = 0; - gBTHeaders[1] = 0; + gAllocationOffset = 0; + gIsHFSPlus = 0; + gCaseSensitive = 0; + gBTHeaders[0] = 0; + gBTHeaders[1] = 0; - // Look for the HFS MDB - Seek(ih, kMDBBaseOffset); - Read(ih, (long)gHFSMdbVib, kBlockSize); + // Look for the HFS MDB + Seek(ih, kMDBBaseOffset); + Read(ih, (long)gHFSMdbVib, kBlockSize); - if ( SWAP_BE16(gHFSMDB->drSigWord) == kHFSSigWord ) { - gAllocationOffset = SWAP_BE16(gHFSMDB->drAlBlSt) * kBlockSize; + if (SWAP_BE16(gHFSMDB->drSigWord) == kHFSSigWord) + { + gAllocationOffset = SWAP_BE16(gHFSMDB->drAlBlSt) * kBlockSize; - // See if it is HFSPlus - if (SWAP_BE16(gHFSMDB->drEmbedSigWord) != kHFSPlusSigWord) { - // Normal HFS; - gCacheBlockSize = gBlockSize = SWAP_BE32(gHFSMDB->drAlBlkSiz); - CacheInit(ih, gCacheBlockSize); - gCurrentIH = ih; + // See if it is HFSPlus + if (SWAP_BE16(gHFSMDB->drEmbedSigWord) != kHFSPlusSigWord) + { + // Normal HFS; + gCacheBlockSize = gBlockSize = SWAP_BE32(gHFSMDB->drAlBlkSiz); + CacheInit(ih, gCacheBlockSize); + gCurrentIH = ih; - // grab the 64 bit volume ID - bcopy(&gHFSMDB->drFndrInfo[6], &gVolID, 8); + // grab the 64 bit volume ID + bcopy(&gHFSMDB->drFndrInfo[6], &gVolID, 8); - // Get the Catalog BTree node size. - extent = (HFSExtentDescriptor *)&gHFSMDB->drCTExtRec; - extentSize = SWAP_BE32(gHFSMDB->drCTFlSize); - extentFile = kHFSCatalogFileID; - ReadExtent(extent, extentSize, extentFile, 0, 256, - gBTreeHeaderBuffer + kBTreeCatalog * 256, 0); + // Get the Catalog BTree node size. + extent = (HFSExtentDescriptor *)&gHFSMDB->drCTExtRec; + extentSize = SWAP_BE32(gHFSMDB->drCTFlSize); + extentFile = kHFSCatalogFileID; + ReadExtent(extent, extentSize, extentFile, 0, 256, gBTreeHeaderBuffer + kBTreeCatalog * 256, 0); - nodeSize = SWAP_BE16(((BTHeaderRec *)(gBTreeHeaderBuffer + kBTreeCatalog * 256 + - sizeof(BTNodeDescriptor)))->nodeSize); + nodeSize = SWAP_BE16(((BTHeaderRec *)(gBTreeHeaderBuffer + kBTreeCatalog * 256 + sizeof(BTNodeDescriptor)))->nodeSize); - // If the BTree node size is larger than the block size, reset the cache. - if (nodeSize > gBlockSize) { - gCacheBlockSize = nodeSize; - CacheInit(ih, gCacheBlockSize); - } + // If the BTree node size is larger than the block size, reset the cache. + if (nodeSize > gBlockSize) + { + gCacheBlockSize = nodeSize; + CacheInit(ih, gCacheBlockSize); + } - return 0; - } + return 0; + } - // Calculate the offset to the embeded HFSPlus volume. - gAllocationOffset += (long long)SWAP_BE16(gHFSMDB->drEmbedExtent.startBlock) * + // Calculate the offset to the embeded HFSPlus volume. + gAllocationOffset += (long long)SWAP_BE16(gHFSMDB->drEmbedExtent.startBlock) * SWAP_BE32(gHFSMDB->drAlBlkSiz); - } + } - // Look for the HFSPlus Header - Seek(ih, gAllocationOffset + kMDBBaseOffset); - Read(ih, (long)gHFSPlusHeader, kBlockSize); + // Look for the HFSPlus Header + Seek(ih, gAllocationOffset + kMDBBaseOffset); + Read(ih, (long)gHFSPlusHeader, kBlockSize); - // Not a HFS+ or HFSX volume. - if (SWAP_BE16(gHFSPlus->signature) != kHFSPlusSigWord && - SWAP_BE16(gHFSPlus->signature) != kHFSXSigWord) { - verbose("HFS signature was not present.\n"); - gCurrentIH = 0; - return -1; - } + // Not a HFS+ or HFSX volume. + if (SWAP_BE16(gHFSPlus->signature) != kHFSPlusSigWord && SWAP_BE16(gHFSPlus->signature) != kHFSXSigWord) + { + verbose("HFS signature was not present.\n"); + gCurrentIH = 0; + return -1; + } - gIsHFSPlus = 1; - gCacheBlockSize = gBlockSize = SWAP_BE32(gHFSPlus->blockSize); - CacheInit(ih, gCacheBlockSize); - gCurrentIH = ih; + gIsHFSPlus = 1; + gCacheBlockSize = gBlockSize = SWAP_BE32(gHFSPlus->blockSize); + CacheInit(ih, gCacheBlockSize); + gCurrentIH = ih; ih->modTime = SWAP_BE32(gHFSPlus->modifyDate) - 2082844800; - - // grab the 64 bit volume ID - bcopy(&gHFSPlus->finderInfo[24], &gVolID, 8); - // Get the Catalog BTree node size. - extent = &gHFSPlus->catalogFile.extents; - extentSize = SWAP_BE64(gHFSPlus->catalogFile.logicalSize); - extentFile = kHFSCatalogFileID; + // grab the 64 bit volume ID + bcopy(&gHFSPlus->finderInfo[24], &gVolID, 8); - ReadExtent(extent, extentSize, extentFile, 0, 256, - gBTreeHeaderBuffer + kBTreeCatalog * 256, 0); + // Get the Catalog BTree node size. + extent = &gHFSPlus->catalogFile.extents; + extentSize = SWAP_BE64(gHFSPlus->catalogFile.logicalSize); + extentFile = kHFSCatalogFileID; - nodeSize = SWAP_BE16(((BTHeaderRec *)(gBTreeHeaderBuffer + kBTreeCatalog * 256 + - sizeof(BTNodeDescriptor)))->nodeSize); + ReadExtent(extent, extentSize, extentFile, 0, 256, gBTreeHeaderBuffer + kBTreeCatalog * 256, 0); - // If the BTree node size is larger than the block size, reset the cache. - if (nodeSize > gBlockSize) { - gCacheBlockSize = nodeSize; - CacheInit(ih, gCacheBlockSize); - } + nodeSize = SWAP_BE16(((BTHeaderRec *)(gBTreeHeaderBuffer + kBTreeCatalog * 256 + sizeof(BTNodeDescriptor)))->nodeSize); - return 0; + // If the BTree node size is larger than the block size, reset the cache. + if (nodeSize > gBlockSize) + { + gCacheBlockSize = nodeSize; + CacheInit(ih, gCacheBlockSize); + } + + return 0; } + +//============================================================================== + long HFSLoadFile(CICell ih, char * filePath) { - return HFSReadFile(ih, filePath, (void *)gFSLoadAddress, 0, 0); + return HFSReadFile(ih, filePath, (void *)gFSLoadAddress, 0, 0); } long HFSReadFile(CICell ih, char * filePath, void *base, uint64_t offset, uint64_t length) @@ -267,43 +298,64 @@ char devStr[12]; long dirID, result, flags; - if (HFSInitPartition(ih) == -1) return -1; - - dirID = kHFSRootFolderID; - // Skip a lead '\'. Start in the system folder if there are two. - if (filePath[0] == '/') { - if (filePath[1] == '/') { - if (gIsHFSPlus) dirID = SWAP_BE32(((long *)gHFSPlus->finderInfo)[5]); - else dirID = SWAP_BE32(gHFSMDB->drFndrInfo[5]); - if (dirID == 0) { + if (HFSInitPartition(ih) == -1) + { return -1; - } - filePath++; - } - filePath++; - } + } - result = ResolvePathToCatalogEntry(filePath, &flags, entry, dirID, 0); - if ((result == -1) || ((flags & kFileTypeMask) != kFileTypeFlat)) { - return -1; - } + dirID = kHFSRootFolderID; + // Skip a lead '\'. Start in the system folder if there are two. + if (filePath[0] == '/') + { + if (filePath[1] == '/') + { + if (gIsHFSPlus) + { + dirID = SWAP_BE32(((long *)gHFSPlus->finderInfo)[5]); + } + else + { + dirID = SWAP_BE32(gHFSMDB->drFndrInfo[5]); + } + if (dirID == 0) + { + return -1; + } + + filePath++; + } + + filePath++; + } + + result = ResolvePathToCatalogEntry(filePath, &flags, entry, dirID, 0); + + if ((result == -1) || ((flags & kFileTypeMask) != kFileTypeFlat)) + { + return -1; + } + #if UNUSED - // Not yet for Intel. System.config/Default.table will fail this check. - // Check file owner and permissions. - if (flags & (kOwnerNotRoot | kPermGroupWrite | kPermOtherWrite)) return -1; + // Not yet for Intel. System.config/Default.table will fail this check. + // Check file owner and permissions. + if (flags & (kOwnerNotRoot | kPermGroupWrite | kPermOtherWrite)) + { + return -1; + } #endif - result = ReadFile(entry, &length, base, offset); - if (result == -1) { - return -1; - } + result = ReadFile(entry, &length, base, offset); + if (result == -1) + { + return -1; + } - getDeviceDescription(ih, devStr); - verbose("Read HFS%s file: [%s/%s] %d bytes.\n", - (gIsHFSPlus ? "+" : ""), devStr, filePath, (uint32_t)length); - - return length; + getDeviceDescription(ih, devStr); + verbose("Read HFS%s file: [%s/%s] %d bytes.\n", + (gIsHFSPlus ? "+" : ""), devStr, filePath, (uint32_t)length); + + return length; } long HFSGetDirEntry(CICell ih, char * dirPath, long long * dirIndex, char ** name, @@ -1030,13 +1082,13 @@ { HFSPlusExtentKey *searchKey, *trialKey; long result; - + searchKey = key; trialKey = testKey; - + // assume searchKey < trialKey - result = -1; - + result = -1; + if (searchKey->fileID == trialKey->fileID) { // FileNum's are equal; compare fork types if (searchKey->forkType == trialKey->forkType) { Index: branches/chucko/i386/libsaio/acpi_patcher.c =================================================================== --- branches/chucko/i386/libsaio/acpi_patcher.c (revision 2328) +++ branches/chucko/i386/libsaio/acpi_patcher.c (revision 2329) @@ -103,19 +103,17 @@ // Start searching any potential location for ACPI Table snprintf(dirSpec, sizeof(dirSpec), "%s", filename); fd = open(dirSpec, 0); - if (fd < 0) - { - snprintf(dirSpec, sizeof(dirSpec), "/Extra/%s", filename); - fd = open(dirSpec, 0); - if (fd < 0) + if (fd < 0) { + snprintf(dirSpec, sizeof(dirSpec), "/Extra/%s", filename); + fd = open(dirSpec, 0); + if (fd < 0) { - snprintf(dirSpec, sizeof(dirSpec), "bt(0,0)/Extra/%s", filename); - fd = open(dirSpec, 0); - if (fd < 0) - { - // NOT FOUND: - verbose("ACPI Table not found: %s\n", filename); - *dirSpec = '\0'; + snprintf(dirSpec, sizeof(dirSpec), "bt(0,0)/Extra/%s", filename); + fd = open(dirSpec, 0); + if (fd < 0) { + // NOT FOUND: + verbose("ACPI Table not found: %s\n", filename); + *dirSpec = '\0'; } } } @@ -273,14 +271,14 @@ unsigned char cstates_count = 1 + (c2_enabled ? 1 : 0) + (c3_enabled ? 1 : 0); - struct aml_chunk* root = aml_create_node(NULL); + AML_CHUNK* root = aml_create_node(NULL); aml_add_buffer(root, ssdt_header, sizeof(ssdt_header)); // SSDT header - struct aml_chunk* scop = aml_add_scope(root, "\\_PR_"); - struct aml_chunk* name = aml_add_name(scop, "CST_"); - struct aml_chunk* pack = aml_add_package(name); + AML_CHUNK* scop = aml_add_scope(root, "\\_PR_"); + AML_CHUNK* name = aml_add_name(scop, "CST_"); + AML_CHUNK* pack = aml_add_package(name); aml_add_byte(pack, cstates_count); - struct aml_chunk* tmpl = aml_add_package(pack); + AML_CHUNK* tmpl = aml_add_package(pack); if (cst_using_systemio) { // C1 @@ -288,9 +286,9 @@ resource_template_register_fixedhw[9] = 0x00; resource_template_register_fixedhw[18] = 0x00; aml_add_buffer(tmpl, resource_template_register_fixedhw, sizeof(resource_template_register_fixedhw)); - aml_add_byte(tmpl, 0x01); // C1 - aml_add_word(tmpl, 0x0001); // Latency - aml_add_dword(tmpl, 0x000003e8); // Power + aml_add_byte(tmpl, 0x01); // C1 + aml_add_word(tmpl, 0x0001); // Latency + aml_add_dword(tmpl, 0x000003e8); // Power uint8_t p_blk_lo, p_blk_hi; @@ -303,9 +301,9 @@ resource_template_register_systemio[11] = p_blk_lo; // C2 resource_template_register_systemio[12] = p_blk_hi; // C2 aml_add_buffer(tmpl, resource_template_register_systemio, sizeof(resource_template_register_systemio)); - aml_add_byte(tmpl, 0x02); // C2 - aml_add_word(tmpl, 0x0040); // Latency - aml_add_dword(tmpl, 0x000001f4); // Power + aml_add_byte(tmpl, 0x02); // C2 + aml_add_word(tmpl, 0x0040); // Latency + aml_add_dword(tmpl, 0x000001f4); // Power } if (c4_enabled) // C4 @@ -317,9 +315,9 @@ resource_template_register_systemio[11] = p_blk_lo; // C4 resource_template_register_systemio[12] = p_blk_hi; // C4 aml_add_buffer(tmpl, resource_template_register_systemio, sizeof(resource_template_register_systemio)); - aml_add_byte(tmpl, 0x04); // C4 - aml_add_word(tmpl, 0x0080); // Latency - aml_add_dword(tmpl, 0x000000C8); // Power + aml_add_byte(tmpl, 0x04); // C4 + aml_add_word(tmpl, 0x0080); // Latency + aml_add_dword(tmpl, 0x000000C8); // Power } else if (c3_enabled) // C3 { @@ -330,8 +328,8 @@ resource_template_register_systemio[11] = p_blk_lo; // C3 resource_template_register_systemio[12] = p_blk_hi; // C3 aml_add_buffer(tmpl, resource_template_register_systemio, sizeof(resource_template_register_systemio)); - aml_add_byte(tmpl, 0x03); // C3 - aml_add_word(tmpl, 0x0060); // Latency + aml_add_byte(tmpl, 0x03); // C3 + aml_add_word(tmpl, 0x0060); // Latency aml_add_dword(tmpl, 0x0000015e); // Power } } @@ -340,8 +338,8 @@ // C1 resource_template_register_fixedhw[11] = 0x00; // C1 aml_add_buffer(tmpl, resource_template_register_fixedhw, sizeof(resource_template_register_fixedhw)); - aml_add_byte(tmpl, 0x01); // C1 - aml_add_word(tmpl, 0x0001); // Latency + aml_add_byte(tmpl, 0x01); // C1 + aml_add_word(tmpl, 0x0001); // Latency aml_add_dword(tmpl, 0x000003e8); // Power resource_template_register_fixedhw[18] = 0x03; @@ -351,8 +349,8 @@ tmpl = aml_add_package(pack); resource_template_register_fixedhw[11] = 0x10; // C2 aml_add_buffer(tmpl, resource_template_register_fixedhw, sizeof(resource_template_register_fixedhw)); - aml_add_byte(tmpl, 0x02); // C2 - aml_add_word(tmpl, 0x0040); // Latency + aml_add_byte(tmpl, 0x02); // C2 + aml_add_word(tmpl, 0x0040); // Latency aml_add_dword(tmpl, 0x000001f4); // Power } @@ -361,8 +359,8 @@ tmpl = aml_add_package(pack); resource_template_register_fixedhw[11] = 0x30; // C4 aml_add_buffer(tmpl, resource_template_register_fixedhw, sizeof(resource_template_register_fixedhw)); - aml_add_byte(tmpl, 0x04); // C4 - aml_add_word(tmpl, 0x0080); // Latency + aml_add_byte(tmpl, 0x04); // C4 + aml_add_word(tmpl, 0x0080); // Latency aml_add_dword(tmpl, 0x000000C8); // Power } else if (c3_enabled) @@ -370,8 +368,8 @@ tmpl = aml_add_package(pack); resource_template_register_fixedhw[11] = 0x20; // C3 aml_add_buffer(tmpl, resource_template_register_fixedhw, sizeof(resource_template_register_fixedhw)); - aml_add_byte(tmpl, 0x03); // C3 - aml_add_word(tmpl, 0x0060); // Latency + aml_add_byte(tmpl, 0x03); // C3 + aml_add_word(tmpl, 0x0060); // Latency aml_add_dword(tmpl, 0x0000015e); // Power } } @@ -638,16 +636,16 @@ { int i; - struct aml_chunk* root = aml_create_node(NULL); + AML_CHUNK* root = aml_create_node(NULL); aml_add_buffer(root, ssdt_header, sizeof(ssdt_header)); // SSDT header - struct aml_chunk* scop = aml_add_scope(root, "\\_PR_"); - struct aml_chunk* name = aml_add_name(scop, "PSS_"); - struct aml_chunk* pack = aml_add_package(name); + AML_CHUNK* scop = aml_add_scope(root, "\\_PR_"); + AML_CHUNK* name = aml_add_name(scop, "PSS_"); + AML_CHUNK* pack = aml_add_package(name); for (i = 0; i < p_states_count; i++) { - struct aml_chunk* pstt = aml_add_package(pack); + AML_CHUNK* pstt = aml_add_package(pack); aml_add_dword(pstt, p_states[i].Frequency); aml_add_dword(pstt, 0x00000000); // Power @@ -862,11 +860,12 @@ /* Try using the file specified with the DSDT option */ if (getValueForKey(kDSDT, &filename, &len, &bootInfo->chameleonConfig)) { - snprintf(dirSpec, sizeof(dirSpec), filename); + snprintf(dirSpec, sizeof(dirSpec), filename); } else { sprintf(dirSpec, "DSDT.aml"); + //verbose("dirSpec, DSDT.aml"); } // Load replacement DSDT @@ -894,11 +893,11 @@ { int i; - for (i=0; i<30; i++) + for (i = 0; i < 30; i++) { char filename[512]; - sprintf(filename, i>0?"SSDT-%d.aml":"SSDT.aml", i); + sprintf(filename, i > 0?"SSDT-%d.aml":"SSDT.aml", i); if ( (new_ssdt[ssdt_count] = loadACPITable(filename)) ) { @@ -912,7 +911,7 @@ } // Do the same procedure for both versions of ACPI - for (version=0; version<2; version++) { + for (version = 0; version < 2; version++) { struct acpi_2_rsdp *rsdp, *rsdp_mod; struct acpi_2_rsdt *rsdt, *rsdt_mod; int rsdplength; @@ -974,13 +973,14 @@ if (drop_ssdt && tableSign(table, "SSDT")) { + verbose("OEM SSDT tables was dropped\n"); dropoffset++; continue; } if (tableSign(table, "DSDT")) { DBG("DSDT found\n"); - + verbose("Custom DSDT table was found\n"); if(new_dsdt) { rsdt_entries[i-dropoffset]=(uint32_t)new_dsdt; @@ -1094,6 +1094,7 @@ if (drop_ssdt && tableSign(table, "SSDT")) { + verbose("OEM SSDT tables was dropped\n"); dropoffset++; continue; } @@ -1160,7 +1161,7 @@ xsdt_entries=(uint64_t *)(xsdt_mod+1); // Mozodojo: Insert additional SSDTs into XSDT - if(ssdt_count>0) + if(ssdt_count > 0) { int j; Index: branches/chucko/i386/libsaio/device_tree.h =================================================================== --- branches/chucko/i386/libsaio/device_tree.h (revision 2328) +++ branches/chucko/i386/libsaio/device_tree.h (revision 2329) @@ -1,5 +1,25 @@ /* - * Copyright (c) 2005 Apple Computer, Inc. All Rights Reserved. + * Copyright (c) 2005 Apple Computer, Inc. All rights reserved. + * + * @APPLE_LICENSE_HEADER_START@ + * + * Portions Copyright (c) 1999-2003 Apple Computer, Inc. All Rights + * Reserved. This file contains Original Code and/or Modifications of + * Original Code as defined in and that are subject to the Apple Public + * Source License Version 2.0 (the "License"). You may not use this file + * except in compliance with the License. Please obtain a copy of the + * License at http://www.apple.com/publicsource and read it before using + * this file. + * + * The Original Code and all software distributed under the License are + * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER + * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES, + * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE OR NON- INFRINGEMENT. Please see the + * License for the specific language governing rights and limitations + * under the License. + * + * @APPLE_LICENSE_HEADER_END@ */ #ifndef __DEVICE_TREE_H @@ -8,21 +28,24 @@ #include #include + +//============================================================================== + typedef struct _Property { - const char * name; - uint32_t length; - void * value; - - struct _Property * next; + const char * name; + uint32_t length; + void * value; + struct _Property * next; } Property; + +//============================================================================== + typedef struct _Node { - struct _Property * properties; - struct _Property * last_prop; - - struct _Node * children; - - struct _Node * next; + struct _Property * properties; + struct _Property * last_prop; + struct _Node * children; + struct _Node * next; } Node; @@ -47,10 +70,9 @@ void DT__Initialize(void); -/* - * Free up memory used by in-memory representation - * of device tree. - */ + +// Free up memory used by in-memory representation of device tree. + extern void DT__Finalize(void); Index: branches/chucko/i386/libsaio/allocate.c =================================================================== --- branches/chucko/i386/libsaio/allocate.c (revision 2328) +++ branches/chucko/i386/libsaio/allocate.c (revision 2329) @@ -33,47 +33,55 @@ #define RoundPage(x) ((((unsigned)(x)) + kPageSize - 1) & ~(kPageSize - 1)) +//============================================================================== + long AllocateMemoryRange(char * rangeName, long start, long length, long type) { - char *nameBuf; - uint32_t *buffer; - - nameBuf = malloc(strlen(rangeName) + 1); - if (nameBuf == 0) return -1; - - buffer = malloc(2 * sizeof(uint32_t)); - if (buffer == 0) { - free(nameBuf); - return -1; - } - - strcpy(nameBuf, rangeName); - buffer[0] = start; - buffer[1] = length; - - DT__AddProperty(gMemoryMapNode, nameBuf, 2 * sizeof(uint32_t), (char *)buffer); - - return 0; + char *nameBuf; + uint32_t *buffer; + + nameBuf = malloc(strlen(rangeName) + 1); + + if (nameBuf == 0) { + return -1; + } + + buffer = malloc(2 * sizeof(uint32_t)); + + if (buffer == 0) { + free(nameBuf); + return -1; + } + + strcpy(nameBuf, rangeName); + buffer[0] = start; + buffer[1] = length; + + DT__AddProperty(gMemoryMapNode, nameBuf, 2 * sizeof(uint32_t), (char *)buffer); + + return 0; } + +//============================================================================== + long -AllocateKernelMemory( long inSize ) +AllocateKernelMemory(long inSize) { - long addr; + long addr; - if (gImageLastKernelAddr == 0) { - gImageLastKernelAddr = RoundPage( bootArgs->kaddr + - bootArgs->ksize ); - } - addr = gImageLastKernelAddr; - gImageLastKernelAddr += RoundPage(inSize); + if (gImageLastKernelAddr == 0) { + gImageLastKernelAddr = RoundPage(bootArgs->kaddr + bootArgs->ksize); + } + addr = gImageLastKernelAddr; + gImageLastKernelAddr += RoundPage(inSize); - if ( gImageLastKernelAddr >= (KERNEL_ADDR + KERNEL_LEN) ) { - stop ("AllocateKernelMemory error"); - } - - bootArgs->ksize = gImageLastKernelAddr - bootArgs->kaddr; + if ( gImageLastKernelAddr >= (KERNEL_ADDR + KERNEL_LEN) ) { + stop ("AllocateKernelMemory error"); + } - return addr; + bootArgs->ksize = gImageLastKernelAddr - bootArgs->kaddr; + + return addr; } Index: branches/chucko/i386/libsaio/bootargs.h =================================================================== --- branches/chucko/i386/libsaio/bootargs.h (revision 2328) +++ branches/chucko/i386/libsaio/bootargs.h (revision 2329) @@ -45,8 +45,8 @@ enum { kEfiReservedMemoryType = 0, - kEfiLoaderCode = 1, - kEfiLoaderData = 2, + kEfiLoaderCode = 1, + kEfiLoaderData = 2, kEfiBootServicesCode = 3, kEfiBootServicesData = 4, kEfiRuntimeServicesCode = 5, @@ -57,7 +57,7 @@ kEfiACPIMemoryNVS = 10, kEfiMemoryMappedIO = 11, kEfiMemoryMappedIOPortSpace = 12, - kEfiPalCode = 13, + kEfiPalCode = 13, kEfiMaxMemoryType = 14 }; @@ -93,15 +93,15 @@ /* Values for v_display */ -#define GRAPHICS_MODE 1 -#define FB_TEXT_MODE 2 +#define GRAPHICS_MODE 1 +#define FB_TEXT_MODE 2 /* Boot argument structure - passed into Mach kernel at boot time. * "Revision" can be incremented for compatible changes */ // Lion -#define kBootArgsRevision 0 -#define kBootArgsVersion 2 +#define kBootArgsRevision 0 +#define kBootArgsVersion 2 // Snow Leopard and older #define kBootArgsPreLionRevision 6 @@ -109,42 +109,42 @@ /* Snapshot constants of previous revisions that are supported */ -#define kBootArgsEfiMode32 32 -#define kBootArgsEfiMode64 64 +#define kBootArgsEfiMode32 32 +#define kBootArgsEfiMode64 64 typedef struct boot_args { uint16_t Revision; /* Revision of boot_args structure */ uint16_t Version; /* Version of boot_args structure */ - + uint8_t efiMode; /* 32 = 32-bit, 64 = 64-bit */ uint8_t debugMode; /* Bit field with behavior changes */ uint8_t __reserved1[2]; - + char CommandLine[BOOT_LINE_LENGTH]; /* Passed in command line */ - + uint32_t MemoryMap; /* Physical address of memory map */ uint32_t MemoryMapSize; uint32_t MemoryMapDescriptorSize; uint32_t MemoryMapDescriptorVersion; - + Boot_Video Video; /* Video Information */ - + uint32_t deviceTreeP; /* Physical address of flattened device tree */ uint32_t deviceTreeLength; /* Length of flattened tree */ - + uint32_t kaddr; /* Physical address of beginning of kernel text */ uint32_t ksize; /* Size of combined kernel text+data+efi */ - + uint32_t efiRuntimeServicesPageStart; /* physical address of defragmented runtime pages */ uint32_t efiRuntimeServicesPageCount; uint64_t efiRuntimeServicesVirtualPageStart; /* virtual address of defragmented runtime pages */ - + uint32_t efiSystemTable; /* physical address of system table in runtime area */ uint32_t __reserved2; - + uint32_t performanceDataStart; /* physical address of log */ uint32_t performanceDataSize; - + uint32_t keyStoreDataStart; /* physical address of key store data */ uint32_t keyStoreDataSize; uint64_t bootMemStart; @@ -152,32 +152,32 @@ uint64_t PhysicalMemorySize; uint64_t FSBFrequency; uint32_t __reserved4[734]; - + } boot_args; typedef struct boot_args_pre_lion { uint16_t Revision; /* Revision of boot_args structure */ uint16_t Version; /* Version of boot_args structure */ - + char CommandLine[BOOT_LINE_LENGTH]; /* Passed in command line */ - + uint32_t MemoryMap; /* Physical address of memory map */ uint32_t MemoryMapSize; uint32_t MemoryMapDescriptorSize; uint32_t MemoryMapDescriptorVersion; - + Boot_Video Video; /* Video Information */ - + uint32_t deviceTreeP; /* Physical address of flattened device tree */ uint32_t deviceTreeLength; /* Length of flattened tree */ - + uint32_t kaddr; /* Physical address of beginning of kernel text */ uint32_t ksize; /* Size of combined kernel text+data+efi */ - + uint32_t efiRuntimeServicesPageStart; /* physical address of defragmented runtime pages */ uint32_t efiRuntimeServicesPageCount; uint32_t efiSystemTable; /* physical address of system table in runtime area */ - + uint8_t efiMode; /* 32 = 32-bit, 64 = 64-bit */ uint8_t __reserved1[3]; uint32_t __reserved2[1]; @@ -185,7 +185,7 @@ uint32_t performanceDataSize; uint64_t efiRuntimeServicesVirtualPageStart; /* virtual address of defragmented runtime pages */ uint32_t __reserved3[2]; - + } boot_args_pre_lion; extern char gMacOSVersion[8]; Index: branches/chucko/i386/libsaio/spd.c =================================================================== --- branches/chucko/i386/libsaio/spd.c (revision 2328) +++ branches/chucko/i386/libsaio/spd.c (revision 2329) @@ -69,43 +69,6 @@ #define SMBHSTDAT 5 #define SBMBLKDAT 7 -/** Read one byte from the intel i2c, used for reading SPD on intel chipsets only. */ -unsigned char smb_read_byte_intel(uint32_t base, uint8_t adr, uint8_t cmd) -{ - int l1, h1, l2, h2; - unsigned long long t; - - outb(base + SMBHSTSTS, 0x1f); // reset SMBus Controller - outb(base + SMBHSTDAT, 0xff); - - rdtsc(l1, h1); - while ( inb(base + SMBHSTSTS) & 0x01) // wait until read - { - rdtsc(l2, h2); - t = ((h2 - h1) * 0xffffffff + (l2 - l1)) / (Platform.CPU.TSCFrequency / 100); - if (t > 5) - return 0xFF; // break - } - - outb(base + SMBHSTCMD, cmd); - outb(base + SMBHSTADD, (adr << 1) | 0x01 ); - outb(base + SMBHSTCNT, 0x48 ); - - rdtsc(l1, h1); - - while (!( inb(base + SMBHSTSTS) & 0x02)) // wait til command finished - { - rdtsc(l2, h2); - t = ((h2 - h1) * 0xffffffff + (l2 - l1)) / (Platform.CPU.TSCFrequency / 100); - if (t > 5) - break; // break after 5ms - } - return inb(base + SMBHSTDAT); -} - -/* SPD i2c read optimization: prefetch only what we need, read non prefetcheable bytes on the fly */ -#define READ_SPD(spd, base, slot, x) spd[x] = smb_read_byte_intel(base, 0x50 + slot, x) - int spd_indexes[] = { SPD_MEMORY_TYPE, SPD_DDR3_MEMORY_BANK, @@ -119,6 +82,49 @@ }; #define SPD_INDEXES_SIZE (sizeof(spd_indexes) / sizeof(int)) +/** Read one byte from the intel i2c, used for reading SPD on intel chipsets only. */ + +unsigned char smb_read_byte_intel(uint32_t base, uint8_t adr, uint8_t cmd) +{ + int l1, h1, l2, h2; + unsigned long long t; + + outb(base + SMBHSTSTS, 0x1f); // reset SMBus Controller + outb(base + SMBHSTDAT, 0xff); + + rdtsc(l1, h1); + while ( inb(base + SMBHSTSTS) & 0x01) // wait until read + { + rdtsc(l2, h2); + t = ((h2 - h1) * 0xffffffff + (l2 - l1)) / (Platform.CPU.TSCFrequency / 100); + if (t > 5) + { + return 0xFF; // break + } + } + + outb(base + SMBHSTCMD, cmd); + outb(base + SMBHSTADD, (adr << 1) | 0x01 ); + outb(base + SMBHSTCNT, 0x48 ); + + rdtsc(l1, h1); + + while (!( inb(base + SMBHSTSTS) & 0x02)) // wait til command finished + { + rdtsc(l2, h2); + t = ((h2 - h1) * 0xffffffff + (l2 - l1)) / (Platform.CPU.TSCFrequency / 100); + if (t > 5) + { + break; // break after 5ms + } + } + return inb(base + SMBHSTDAT); +} + +/* SPD i2c read optimization: prefetch only what we need, read non prefetcheable bytes on the fly */ +#define READ_SPD(spd, base, slot, x) spd[x] = smb_read_byte_intel(base, 0x50 + slot, x) + + /** Read from spd *used* values only*/ static void init_spd(char * spd, uint32_t base, int slot) { @@ -132,115 +138,147 @@ have different formats, always return a valid ptr.*/ const char * getVendorName(RamSlotInfo_t* slot, uint32_t base, int slot_num) { - uint8_t bank = 0; - uint8_t code = 0; - int i = 0; - uint8_t * spd = (uint8_t *) slot->spd; + uint8_t bank = 0; + uint8_t code = 0; + int i = 0; + uint8_t * spd = (uint8_t *) slot->spd; - if (spd[SPD_MEMORY_TYPE]==SPD_MEMORY_TYPE_SDRAM_DDR3) { // DDR3 - bank = (spd[SPD_DDR3_MEMORY_BANK] & 0x07f); // constructors like Patriot use b7=1 - code = spd[SPD_DDR3_MEMORY_CODE]; - for (i=0; i < VEN_MAP_SIZE; i++) - if (bank==vendorMap[i].bank && code==vendorMap[i].code) - return vendorMap[i].name; - } - else if (spd[SPD_MEMORY_TYPE]==SPD_MEMORY_TYPE_SDRAM_DDR2) { - if(spd[64]==0x7f) { - for (i=64; i<72 && spd[i]==0x7f;i++) { - bank++; - READ_SPD(spd, base, slot_num,i+1); // prefetch next spd byte to read for next loop + if (spd[SPD_MEMORY_TYPE]==SPD_MEMORY_TYPE_SDRAM_DDR3) + { // DDR3 + bank = (spd[SPD_DDR3_MEMORY_BANK] & 0x07f); // constructors like Patriot use b7=1 + code = spd[SPD_DDR3_MEMORY_CODE]; + for (i=0; i < VEN_MAP_SIZE; i++) + { + if (bank==vendorMap[i].bank && code==vendorMap[i].code) + { + return vendorMap[i].name; } - READ_SPD(spd, base, slot_num,i); - code = spd[i]; - } else { - code = spd[64]; - bank = 0; - } - for (i=0; i < VEN_MAP_SIZE; i++) - if (bank==vendorMap[i].bank && code==vendorMap[i].code) - return vendorMap[i].name; - } - /* OK there is no vendor id here lets try to match the partnum if it exists */ - if (strstr(slot->PartNo,"GU332") == slot->PartNo) // Unifosa fingerprint - return "Unifosa"; - return "NoName"; + } + } + else if (spd[SPD_MEMORY_TYPE]==SPD_MEMORY_TYPE_SDRAM_DDR2 || spd[SPD_MEMORY_TYPE]==SPD_MEMORY_TYPE_SDRAM_DDR) + { + if(spd[64]==0x7f) + { + for (i=64; i<72 && spd[i]==0x7f;i++) + { + bank++; + READ_SPD(spd, base, slot_num, (uint8_t)(i+1)); // prefetch next spd byte to read for next loop + } + READ_SPD(spd, base, slot_num,(uint8_t)i); + code = spd[i]; + } + else + { + code = spd[64]; + bank = 0; + } + for (i=0; i < VEN_MAP_SIZE; i++) + { + if (bank==vendorMap[i].bank && code==vendorMap[i].code) + { + return vendorMap[i].name; + } + } + } + /* OK there is no vendor id here lets try to match the partnum if it exists */ + if (strstr(slot->PartNo,"GU332") == slot->PartNo) // Unifosa fingerprint + { + return "Unifosa"; + } + return "NoName"; } -/** Get Default Memory Module Speed (no overclocking handled) */ +/* Get Default Memory Module Speed (no overclocking handled) */ int getDDRspeedMhz(const char * spd) { - if (spd[SPD_MEMORY_TYPE]==SPD_MEMORY_TYPE_SDRAM_DDR3) { - switch(spd[12]) { - case 0x0f: - return 1066; - case 0x0c: - return 1333; - case 0x0a: - return 1600; - case 0x14: - default: - return 800; - } - } - else if (spd[SPD_MEMORY_TYPE]==SPD_MEMORY_TYPE_SDRAM_DDR2) { - switch(spd[9]) { - case 0x50: - return 400; - case 0x3d: - return 533; - case 0x30: - return 667; - case 0x25: - default: - return 800; - } - } - return 800; // default freq for unknown types + if (spd[SPD_MEMORY_TYPE]==SPD_MEMORY_TYPE_SDRAM_DDR3) + { + switch(spd[12]) + { + case 0x0f: + return 1066; + case 0x0c: + return 1333; + case 0x0a: + return 1600; + case 0x14: + default: + return 800; + } + } + else if (spd[SPD_MEMORY_TYPE]==SPD_MEMORY_TYPE_SDRAM_DDR2 || spd[SPD_MEMORY_TYPE]==SPD_MEMORY_TYPE_SDRAM_DDR) + { + switch(spd[9]) + { + case 0x50: + return 400; + case 0x3d: + return 533; + case 0x30: + return 667; + case 0x25: + default: + return 800; + case 0x1E: + return 1066; + } + } + return 800; // default freq for unknown types } #define SMST(a) ((uint8_t)((spd[a] & 0xf0) >> 4)) #define SLST(a) ((uint8_t)(spd[a] & 0x0f)) -/** Get DDR3 or DDR2 serial number, 0 most of the times, always return a valid ptr */ +/* Get DDR3 or DDR2 serial number, 0 most of the times, always return a valid ptr */ const char *getDDRSerial(const char* spd) { - static char asciiSerial[16]; + static char asciiSerial[16]; - if (spd[SPD_MEMORY_TYPE]==SPD_MEMORY_TYPE_SDRAM_DDR3) // DDR3 - { - sprintf(asciiSerial, "%X%X%X%X%X%X%X%X", SMST(122) /*& 0x7*/, SLST(122), SMST(123), SLST(123), SMST(124), SLST(124), SMST(125), SLST(125)); - } - else if (spd[SPD_MEMORY_TYPE]==SPD_MEMORY_TYPE_SDRAM_DDR2) // DDR2 or DDR - { - sprintf(asciiSerial, "%X%X%X%X%X%X%X%X", SMST(95) /*& 0x7*/, SLST(95), SMST(96), SLST(96), SMST(97), SLST(97), SMST(98), SLST(98)); - } + if (spd[SPD_MEMORY_TYPE]==SPD_MEMORY_TYPE_SDRAM_DDR3) // DDR3 + { + sprintf(asciiSerial, "%X%X%X%X%X%X%X%X", SMST(122) /*& 0x7*/, SLST(122), SMST(123), SLST(123), SMST(124), SLST(124), SMST(125), SLST(125)); + } + else if (spd[SPD_MEMORY_TYPE]==SPD_MEMORY_TYPE_SDRAM_DDR2 || spd[SPD_MEMORY_TYPE]==SPD_MEMORY_TYPE_SDRAM_DDR) // DDR2 or DDR + { + sprintf(asciiSerial, "%X%X%X%X%X%X%X%X", SMST(95) /*& 0x7*/, SLST(95), SMST(96), SLST(96), SMST(97), SLST(97), SMST(98), SLST(98)); + } else { + sprintf(asciiSerial, "0000000000000000"); + } - return strdup(asciiSerial); + return strdup(asciiSerial); } -/** Get DDR3 or DDR2 Part Number, always return a valid ptr */ +/* Get DDR3 or DDR2 Part Number, always return a valid ptr */ const char * getDDRPartNum(char* spd, uint32_t base, int slot) { static char asciiPartNo[32]; int i, start=0, index = 0; - if (spd[SPD_MEMORY_TYPE]==SPD_MEMORY_TYPE_SDRAM_DDR3) { + if (spd[SPD_MEMORY_TYPE]==SPD_MEMORY_TYPE_SDRAM_DDR3) + { start = 128; } - else if (spd[SPD_MEMORY_TYPE]==SPD_MEMORY_TYPE_SDRAM_DDR2) { + else if (spd[SPD_MEMORY_TYPE]==SPD_MEMORY_TYPE_SDRAM_DDR2 || spd[SPD_MEMORY_TYPE]==SPD_MEMORY_TYPE_SDRAM_DDR) + { start = 73; } - // Check that the spd part name is zero terminated and that it is ascii: - bzero(asciiPartNo, sizeof(asciiPartNo)); + // Check that the spd part name is zero terminated and that it is ascii: + bzero(asciiPartNo, sizeof(asciiPartNo)); char c; - for (i=start; i < start + sizeof(asciiPartNo); i++) { + for (i=start; i < start + sizeof(asciiPartNo); i++) + { READ_SPD(spd, base, slot, i); // only read once the corresponding model part (ddr3 or ddr2) c = spd[i]; - if (isalpha(c) || isdigit(c) || ispunct(c)) // It seems that System Profiler likes only letters and digits... + if (isalpha(c) || isdigit(c) || ispunct(c)) + { + // It seems that System Profiler likes only letters and digits... asciiPartNo[index++] = c; + } else if (!isascii(c)) + { break; + } } return strdup(asciiPartNo); @@ -249,82 +287,103 @@ int mapping []= {0,2,1,3,4,6,5,7,8,10,9,11}; -/** Read from smbus the SPD content and interpret it for detecting memory attributes */ +/* Read from smbus the SPD content and interpret it for detecting memory attributes */ static void read_smb_intel(pci_dt_t *smbus_dev) { - int i, speed; - uint8_t spd_size, spd_type; - uint32_t base, mmio, hostc; -// bool dump = false; - RamSlotInfo_t* slot; + uint16_t speed; + uint8_t i, spd_size, spd_type; + uint32_t base, mmio, hostc; +// bool dump = false; + RamSlotInfo_t* slot; uint16_t cmd = pci_config_read16(smbus_dev->dev.addr, 0x04); DBG("SMBus CmdReg: 0x%x\n", cmd); pci_config_write16(smbus_dev->dev.addr, 0x04, cmd | 1); mmio = pci_config_read32(smbus_dev->dev.addr, 0x10);// & ~0x0f; - base = pci_config_read16(smbus_dev->dev.addr, 0x20) & 0xFFFE; + base = pci_config_read16(smbus_dev->dev.addr, 0x20) & 0xFFFE; hostc = pci_config_read8(smbus_dev->dev.addr, 0x40); - verbose("Scanning SMBus [%04x:%04x], mmio: 0x%x, ioport: 0x%x, hostc: 0x%x\n", - smbus_dev->vendor_id, smbus_dev->device_id, mmio, base, hostc); + verbose("Scanning SMBus [%04x:%04x], mmio: 0x%x, ioport: 0x%x, hostc: 0x%x\n", + smbus_dev->vendor_id, smbus_dev->device_id, mmio, base, hostc); -//Azi: no use for this! -// getBoolForKey("DumpSPD", &dump, &bootInfo->chameleonConfig); + //Azi: no use for this! + // getBoolForKey("DumpSPD", &dump, &bootInfo->chameleonConfig); // needed at least for laptops - bool fullBanks = Platform.DMI.MemoryModules == Platform.DMI.CntMemorySlots; + bool fullBanks = Platform.DMI.MemoryModules == Platform.DMI.CntMemorySlots; char spdbuf[MAX_SPD_SIZE]; - // Search MAX_RAM_SLOTS slots - for (i = 0; i < MAX_RAM_SLOTS; i++){ - slot = &Platform.RAM.DIMM[i]; - spd_size = smb_read_byte_intel(base, 0x50 + i, 0); - DBG("SPD[0] (size): %d @0x%x\n", spd_size, 0x50 + i); - // Check spd is present - if (spd_size && (spd_size != 0xff)) - { + // Search MAX_RAM_SLOTS slots + for (i = 0; i < MAX_RAM_SLOTS; i++) + { + // ---- + slot = &Platform.RAM.DIMM[i]; + spd_size = smb_read_byte_intel(base, 0x50 + i, 0); + DBG("SPD[0] (size): 0x%02x @0x%x\n", spd_size, 0x50 + i); + // Check spd is present + if (spd_size && (spd_size != 0xff)) + { slot->spd = spdbuf; - slot->InUse = true; + // ----- + slot->InUse = true; - bzero(slot->spd, spd_size); - - // Copy spd data into buffer - + bzero(slot->spd, spd_size); + + // Copy spd data into buffer + //for (x = 0; x < spd_size; x++) slot->spd[x] = smb_read_byte_intel(base, 0x50 + i, x); - init_spd(slot->spd, base, i); - - switch (slot->spd[SPD_MEMORY_TYPE]) { - case SPD_MEMORY_TYPE_SDRAM_DDR2: - - slot->ModuleSize = ((1 << ((slot->spd[SPD_NUM_ROWS] & 0x0f) + (slot->spd[SPD_NUM_COLUMNS] & 0x0f) - 17)) * - ((slot->spd[SPD_NUM_DIMM_BANKS] & 0x7) + 1) * slot->spd[SPD_NUM_BANKS_PER_SDRAM]); - break; - - case SPD_MEMORY_TYPE_SDRAM_DDR3: - - slot->ModuleSize = ((slot->spd[4] & 0x0f) + 28 ) + ((slot->spd[8] & 0x7) + 3 ); - slot->ModuleSize -= (slot->spd[7] & 0x7) + 25; - slot->ModuleSize = ((1 << slot->ModuleSize) * (((slot->spd[7] >> 3) & 0x1f) + 1)); - - break; - } - - spd_type = (slot->spd[SPD_MEMORY_TYPE] < ((char) 12) ? slot->spd[SPD_MEMORY_TYPE] : 0); - slot->Type = spd_mem_to_smbios[spd_type]; - slot->PartNo = getDDRPartNum(slot->spd, base, i); - slot->Vendor = getVendorName(slot, base, i); - slot->SerialNo = getDDRSerial(slot->spd); + init_spd(slot->spd, base, i); - // determine spd speed - speed = getDDRspeedMhz(slot->spd); - if (slot->FrequencyFrequency = speed; + switch (slot->spd[SPD_MEMORY_TYPE]) + { + case SPD_MEMORY_TYPE_SDRAM_DDR: + + slot->ModuleSize = (((1 << ((slot->spd[SPD_NUM_ROWS] & 0x0f) + + (slot->spd[SPD_NUM_COLUMNS] & 0x0f) - 17)) * + ((slot->spd[SPD_NUM_DIMM_BANKS] & 0x7) + 1) * + slot->spd[SPD_NUM_BANKS_PER_SDRAM])/3)*2; + break; + + case SPD_MEMORY_TYPE_SDRAM_DDR2: + + slot->ModuleSize = ((1 << ((slot->spd[SPD_NUM_ROWS] & 0x0f) + (slot->spd[SPD_NUM_COLUMNS] & 0x0f) - 17)) * + ((slot->spd[SPD_NUM_DIMM_BANKS] & 0x7) + 1) * slot->spd[SPD_NUM_BANKS_PER_SDRAM]); + break; + + case SPD_MEMORY_TYPE_SDRAM_DDR3: + + slot->ModuleSize = ((slot->spd[4] & 0x0f) + 28 ) + ((slot->spd[8] & 0x7) + 3 ); + slot->ModuleSize -= (slot->spd[7] & 0x7) + 25; + slot->ModuleSize = ((1 << slot->ModuleSize) * (((slot->spd[7] >> 3) & 0x1f) + 1)); + + break; + } + + spd_type = (slot->spd[SPD_MEMORY_TYPE] < ((char) 12) ? slot->spd[SPD_MEMORY_TYPE] : 0); + slot->Type = spd_mem_to_smbios[spd_type]; + if (slot->Type == UNKNOWN_MEM_TYPE) + { + continue; + } + slot->PartNo = getDDRPartNum(slot->spd, base, i); + slot->Vendor = getVendorName(slot, base, i); + slot->SerialNo = getDDRSerial(slot->spd); + + // determine spd speed + speed = getDDRspeedMhz(slot->spd); + if (slot->FrequencyFrequency = speed; + } // pci memory controller if available, is more reliable - if (Platform.RAM.Frequency > 0) { + if (Platform.RAM.Frequency > 0) + { uint32_t freq = (uint32_t)Platform.RAM.Frequency / 500000; // now round off special cases uint32_t fmod100 = freq %100; - switch(fmod100) { + switch(fmod100) + { case 1: freq--; break; case 32: freq++; break; case 65: freq++; break; @@ -342,42 +401,47 @@ slot->Frequency, slot->Vendor, slot->PartNo, - slot->SerialNo); - + slot->SerialNo); + slot->InUse = true; + } - } - - // laptops sometimes show slot 0 and 2 with slot 1 empty when only 2 slots are presents so: - Platform.DMI.DIMM[i]= - i>0 && Platform.RAM.DIMM[1].InUse==false && fullBanks && Platform.DMI.CntMemorySlots == 2 ? - mapping[i] : i; // for laptops case, mapping setup would need to be more generic than this - - - + // laptops sometimes show slot 0 and 2 with slot 1 empty when only 2 slots are presents so: + Platform.DMI.DIMM[i]= + (uint32_t)((i>0 && Platform.RAM.DIMM[1].InUse==false && !fullBanks && Platform.DMI.CntMemorySlots == 2) ? + mapping[i] : i); // for laptops case, mapping setup would need to be more generic than this slot->spd = NULL; - } // for + } // for } static struct smbus_controllers_t smbus_controllers[] = { +// Info from here: http://cateee.net/lkddb/web-lkddb/I2C_I801.html - {0x8086, 0x269B, "ESB2", read_smb_intel }, - {0x8086, 0x25A4, "6300ESB", read_smb_intel }, - {0x8086, 0x24C3, "ICH4", read_smb_intel }, - {0x8086, 0x24D3, "ICH5", read_smb_intel }, - {0x8086, 0x266A, "ICH6", read_smb_intel }, - {0x8086, 0x27DA, "ICH7", read_smb_intel }, - {0x8086, 0x283E, "ICH8", read_smb_intel }, - {0x8086, 0x2930, "ICH9", read_smb_intel }, - {0x8086, 0x3A30, "ICH10R", read_smb_intel }, - {0x8086, 0x3A60, "ICH10B", read_smb_intel }, - {0x8086, 0x3B30, "5 Series", read_smb_intel }, - {0x8086, 0x1C22, "6 Series", read_smb_intel }, - {0x8086, 0x1D22, "C600/X79 Series", read_smb_intel }, - {0x8086, 0x1E22, "7 Series", read_smb_intel }, - {0x8086, 0x5032, "EP80579", read_smb_intel }, - {0x8086, 0x8C22, "8 Series", read_smb_intel }, - {0x8086, 0x9C22, "Lynx Point-LP", read_smb_intel } + {0x8086, 0x1C22, "6 Series", read_smb_intel }, + {0x8086, 0x1D22, "C600/X79 Series", read_smb_intel }, + {0x8086, 0x1D70, "C600/X79 Series", read_smb_intel }, + {0x8086, 0x1D71, "C608/C606/X79 Series", read_smb_intel }, + {0x8086, 0x1D72, "C608", read_smb_intel }, + {0x8086, 0x1E22, "7 Series/C210 Series", read_smb_intel }, + {0x8086, 0x2330, "DH89xxCC", read_smb_intel }, + {0x8086, 0x2413, "82801AA", read_smb_intel }, + {0x8086, 0x2423, "82801BA/BAM", read_smb_intel }, + {0x8086, 0x2443, "82801BA/BAM", read_smb_intel }, + {0x8086, 0x2483, "82801CA/CAM", read_smb_intel }, + {0x8086, 0x24C3, "82801DB/DBL/DBM (ICH4/ICH4-L/ICH4-M)", read_smb_intel }, + {0x8086, 0x24D3, "82801EB/ER (ICH5/ICH5R)", read_smb_intel }, + {0x8086, 0x25A4, "6300ESB", read_smb_intel }, + {0x8086, 0x266A, "82801FB/FBM/FR/FW/FRW (ICH6 Family)", read_smb_intel }, + {0x8086, 0x269B, "631xESB/632xESB/3100", read_smb_intel }, + {0x8086, 0x27DA, "N10/ICH 7 Family", read_smb_intel }, + {0x8086, 0x283E, "82801H (ICH8 Family) ", read_smb_intel }, + {0x8086, 0x2930, "82801I (ICH9 Family)", read_smb_intel }, + {0x8086, 0x3A30, "82801JI (ICH10 Family)", read_smb_intel }, + {0x8086, 0x3A60, "82801JD/DO (ICH10 Family)", read_smb_intel }, + {0x8086, 0x3B30, "5 Series/3400 Series", read_smb_intel }, + {0x8086, 0x5032, "EP80579", read_smb_intel }, + {0x8086, 0x8C22, "8 Series/C220", read_smb_intel }, + {0x8086, 0x9C22, "Lynx Point-LP", read_smb_intel } }; @@ -385,33 +449,33 @@ // find_and_read_smbus_controller(root_pci_dev); bool find_and_read_smbus_controller(pci_dt_t* pci_dt) { - pci_dt_t *current = pci_dt; - int i; + pci_dt_t *current = pci_dt; + int i; - while (current) { + while (current) + { #if 0 - printf("%02x:%02x.%x [%04x] [%04x:%04x] :: %s\n", - current->dev.bits.bus, current->dev.bits.dev, current->dev.bits.func, - current->class_id, current->vendor_id, current->device_id, - get_pci_dev_path(current)); + printf("%02x:%02x.%x [%04x] [%04x:%04x] :: %s\n", + current->dev.bits.bus, current->dev.bits.dev, current->dev.bits.func, + current->class_id, current->vendor_id, current->device_id, + get_pci_dev_path(current)); #endif - for ( i = 0; i < sizeof(smbus_controllers) / sizeof(smbus_controllers[0]); i++ ) - { - if (current->vendor_id == smbus_controllers[i].vendor && - current->device_id == smbus_controllers[i].device) - { - smbus_controllers[i].read_smb(current); // read smb - return true; - } - } - find_and_read_smbus_controller(current->children); - current = current->next; - } - return false; // not found + for ( i = 0; i < sizeof(smbus_controllers) / sizeof(smbus_controllers[0]); i++ ) + { + if (current->vendor_id == smbus_controllers[i].vendor && current->device_id == smbus_controllers[i].device) + { + smbus_controllers[i].read_smb(current); // read smb + return true; + } + } + find_and_read_smbus_controller(current->children); + current = current->next; + } + return false; // not found } void scan_spd(PlatformInfo_t *p) { - find_and_read_smbus_controller(root_pci_dev); + find_and_read_smbus_controller(root_pci_dev); } Index: branches/chucko/i386/libsaio/spd.h =================================================================== --- branches/chucko/i386/libsaio/spd.h (revision 2328) +++ branches/chucko/i386/libsaio/spd.h (revision 2329) @@ -16,7 +16,7 @@ uint32_t vendor; uint32_t device; char *name; - void (*read_smb)(pci_dt_t *smbus_dev); + void (*read_smb)(pci_dt_t *smbus_dev); }; @@ -38,6 +38,7 @@ /* Byte numbers. */ #define SPD_NUM_MANUFACTURER_BYTES 0 /* Number of bytes used by module manufacturer */ #define SPD_TOTAL_SPD_MEMORY_SIZE 1 /* Total SPD memory size */ +// (Essentially) common to DDR & DDR2 #define SPD_MEMORY_TYPE 2 /* (Fundamental) memory type */ #define SPD_NUM_ROWS 3 /* Number of row address bits */ #define SPD_NUM_COLUMNS 4 /* Number of column address bits */ @@ -130,6 +131,9 @@ #define ERROR_SCHEME_NONE 0 #define ERROR_SCHEME_PARITY 1 #define ERROR_SCHEME_ECC 2 +#define DDR2_DATA_PARITY (1<<0) +#define DDR2_DATA_ECC (1<<1) +#define DDR2_ADDRESS_PARITY (1<<2) /* SPD_ACCEPTABLE_CAS_LATENCIES values. */ // TODO: Check values. @@ -141,6 +145,7 @@ #define SPD_CAS_LATENCY_3_5 0x20 #define SPD_CAS_LATENCY_4_0 0x40 +#define SPD_CAS_LATENCY_DDR2_2 (1 << 2) #define SPD_CAS_LATENCY_DDR2_3 (1 << 3) #define SPD_CAS_LATENCY_DDR2_4 (1 << 4) #define SPD_CAS_LATENCY_DDR2_5 (1 << 5) Index: branches/chucko/i386/libsaio/bios.h =================================================================== --- branches/chucko/i386/libsaio/bios.h (revision 2328) +++ branches/chucko/i386/libsaio/bios.h (revision 2329) @@ -32,63 +32,63 @@ #include "bootargs.h" typedef union { - unsigned int rx; - unsigned short rr; - struct { - unsigned char l; - unsigned char h; - } r; + unsigned int rx; + unsigned short rr; + struct { + unsigned char l; + unsigned char h; + } r; } machineRegister_t; typedef struct { - unsigned short cf :1; - unsigned short :1; - unsigned short pf :1; - unsigned short :1; - unsigned short af :1; - unsigned short :1; - unsigned short zf :1; - unsigned short sf :1; - unsigned short tf :1; - unsigned short _if :1; - unsigned short df :1; - unsigned short of :1; - unsigned short iopl:2; - unsigned short nt :1; + unsigned short cf :1; + unsigned short :1; + unsigned short pf :1; + unsigned short :1; + unsigned short af :1; + unsigned short :1; + unsigned short zf :1; + unsigned short sf :1; + unsigned short tf :1; + unsigned short _if :1; + unsigned short df :1; + unsigned short of :1; + unsigned short iopl:2; + unsigned short nt :1; } machineFlags_t; typedef struct { - unsigned int intno; - machineRegister_t eax; - machineRegister_t ebx; - machineRegister_t ecx; - machineRegister_t edx; - machineRegister_t edi; - machineRegister_t esi; - machineRegister_t ebp; - unsigned short cs; - unsigned short ds; - unsigned short es; - machineFlags_t flags; + unsigned int intno; + machineRegister_t eax; + machineRegister_t ebx; + machineRegister_t ecx; + machineRegister_t edx; + machineRegister_t edi; + machineRegister_t esi; + machineRegister_t ebp; + unsigned short cs; + unsigned short ds; + unsigned short es; + machineFlags_t flags; } biosBuf_t; -#define EBIOS_FIXED_DISK_ACCESS 0x01 -#define EBIOS_LOCKING_ACCESS 0x02 -#define EBIOS_ENHANCED_DRIVE_INFO 0x04 +#define EBIOS_FIXED_DISK_ACCESS 0x01 +#define EBIOS_LOCKING_ACCESS 0x02 +#define EBIOS_ENHANCED_DRIVE_INFO 0x04 -#define BASE_HD_DRIVE 0x80 +#define BASE_HD_DRIVE 0x80 #if 0 /* * ACPI defined memory range types. */ enum { - kMemoryRangeUsable = 1, // RAM usable by the OS. - kMemoryRangeReserved = 2, // Reserved. (Do not use) - kMemoryRangeACPI = 3, // ACPI tables. Can be reclaimed. - kMemoryRangeNVS = 4, // ACPI NVS memory. (Do not use) + kMemoryRangeUsable = 1, // RAM usable by the OS. + kMemoryRangeReserved = 2, // Reserved. (Do not use) + kMemoryRangeACPI = 3, // ACPI tables. Can be reclaimed. + kMemoryRangeNVS = 4, // ACPI NVS memory. (Do not use) - /* Undefined types should be treated as kMemoryRangeReserved */ + /* Undefined types should be treated as kMemoryRangeReserved */ }; #endif @@ -96,10 +96,10 @@ * Memory range descriptor. */ typedef struct MemoryRange { - unsigned long long base; // 64-bit base address - unsigned long long length; // 64-bit length in bytes - unsigned long type; // type of memory range - unsigned long reserved; + unsigned long long base; // 64-bit base address + unsigned long long length; // 64-bit length in bytes + unsigned long type; // type of memory range + unsigned long reserved; } MemoryRange; #endif /* !__LIBSAIO_BIOS_H */ Index: branches/chucko/i386/libsaio/gma.c =================================================================== --- branches/chucko/i386/libsaio/gma.c (revision 2328) +++ branches/chucko/i386/libsaio/gma.c (revision 2329) @@ -354,7 +354,7 @@ { if (intel_gfx_chipsets[i].model == ((device_id << 16) | vendor_id)) { - snprintf(desc, sizeof(desc), "%s %s", INTEL_NAME, intel_gfx_chipsets[i].label_info); + snprintf(desc, sizeof(desc), "%s %s", INTEL_NAME, intel_gfx_chipsets[i].label_info); return desc; } } @@ -388,14 +388,12 @@ verbose("Class code: [%04x]\n%s [%04x:%04x] (rev %02x)\nSubsystem: [%04x:%04x] :: %s\n", gma_dev->class_id, model, gma_dev->vendor_id, gma_dev->device_id, gma_dev->revision_id, gma_dev->subsys_id.subsys.vendor_id, gma_dev->subsys_id.subsys.device_id, devicepath); - if (!string) - { + if (!string) { string = devprop_create_string(); } struct DevPropDevice *device = devprop_add_device(string, devicepath); - if (!device) - { + if (!device) { printf("Failed initializing dev-prop string dev-entry.\n"); pause(); return false; Index: branches/chucko/i386/libsaio/pci_root.c =================================================================== --- branches/chucko/i386/libsaio/pci_root.c (revision 2328) +++ branches/chucko/i386/libsaio/pci_root.c (revision 2329) @@ -79,7 +79,7 @@ // Try using the file specified with the DSDT option if (getValueForKey(kDSDT, &dsdt_filename, &len, &bootInfo->chameleonConfig)) { - snprintf(dsdt_dirSpec, sizeof(dsdt_dirSpec), dsdt_filename); + snprintf(dsdt_dirSpec, sizeof(dsdt_dirSpec), dsdt_filename); } else { @@ -105,7 +105,7 @@ } if (read (fd, new_dsdt, fsize) != fsize) { verbose("[ERROR] read %s failed\n", dsdt_filename); - free(new_dsdt); + free(new_dsdt); close (fd); goto out; } Index: branches/chucko/i386/libsaio/aml_generator.c =================================================================== --- branches/chucko/i386/libsaio/aml_generator.c (revision 2328) +++ branches/chucko/i386/libsaio/aml_generator.c (revision 2329) @@ -5,11 +5,12 @@ * Created by Mozodojo on 20/07/10. * Copyright 2010 mozo. All rights reserved. * + * additions and corrections by Slice and pcj, 2012. */ #include "aml_generator.h" -bool aml_add_to_parent(struct aml_chunk* parent, struct aml_chunk* node) +bool aml_add_to_parent(AML_CHUNK* parent, AML_CHUNK* node) { if (parent && node) { @@ -24,8 +25,7 @@ verbose("aml_add_to_parent: Node doesn't support child nodes!\n"); return false; case AML_CHUNK_NAME: - if (parent->First) - { + if (parent->First) { verbose("aml_add_to_parent: Name node supports only one child node!\n"); return false; } @@ -35,12 +35,12 @@ break; } - if (!parent->First) + if (!parent->First) { parent->First = node; - - if (parent->Last) + } + if (parent->Last) { parent->Last->Next = node; - + } parent->Last = node; return true; @@ -49,47 +49,47 @@ return false; } -struct aml_chunk* aml_create_node(struct aml_chunk* parent) +AML_CHUNK* aml_create_node(AML_CHUNK* parent) { - struct aml_chunk* node = (struct aml_chunk*)malloc(sizeof(struct aml_chunk)); + AML_CHUNK* node = (AML_CHUNK*)malloc(sizeof(AML_CHUNK)); aml_add_to_parent(parent, node); return node; } -void aml_destroy_node(struct aml_chunk* node) +void aml_destroy_node(AML_CHUNK* node) { // Delete child nodes - struct aml_chunk* child = node->First; + AML_CHUNK* child = node->First; while (child) { - struct aml_chunk* next = child->Next; + AML_CHUNK* next = child->Next; - if (child->Buffer) + if (child->Buffer) { free(child->Buffer); - + } free(child); child = next; } // Free node - if (node->Buffer) + if (node->Buffer) { free(node->Buffer); + } free(node); } -struct aml_chunk* aml_add_buffer(struct aml_chunk* parent, const char* buffer, unsigned int size) +AML_CHUNK* aml_add_buffer(AML_CHUNK* parent, char* buffer, uint32_t size) { - struct aml_chunk* node = aml_create_node(parent); + AML_CHUNK* node = aml_create_node(parent); - if (node) - { + if (node) { node->Type = AML_CHUNK_NONE; - node->Length = size; + node->Length = (uint16_t)size; node->Buffer = malloc(node->Length); memcpy(node->Buffer, buffer, node->Length); } @@ -97,44 +97,38 @@ return node; } -struct aml_chunk* aml_add_byte(struct aml_chunk* parent, unsigned char value) +AML_CHUNK* aml_add_byte(AML_CHUNK* parent, uint8_t value) { - struct aml_chunk* node = aml_create_node(parent); + AML_CHUNK* node = aml_create_node(parent); - if (node) - { + if (node) { node->Type = AML_CHUNK_BYTE; - node->Length = 1; node->Buffer = malloc(node->Length); node->Buffer[0] = value; } - return node; } -struct aml_chunk* aml_add_word(struct aml_chunk* parent, unsigned int value) +AML_CHUNK* aml_add_word(AML_CHUNK* parent, uint16_t value) { - struct aml_chunk* node = aml_create_node(parent); + AML_CHUNK* node = aml_create_node(parent); - if (node) - { + if (node) { node->Type = AML_CHUNK_WORD; node->Length = 2; node->Buffer = malloc(node->Length); node->Buffer[0] = value & 0xff; node->Buffer[1] = value >> 8; } - return node; } -struct aml_chunk* aml_add_dword(struct aml_chunk* parent, unsigned long value) +AML_CHUNK* aml_add_dword(AML_CHUNK* parent, uint32_t value) { - struct aml_chunk* node = aml_create_node(parent); + AML_CHUNK* node = aml_create_node(parent); - if (node) - { + if (node) { node->Type = AML_CHUNK_DWORD; node->Length = 4; node->Buffer = malloc(node->Length); @@ -143,16 +137,14 @@ node->Buffer[2] = (value >> 16) & 0xff; node->Buffer[3] = (value >> 24) & 0xff; } - return node; } -struct aml_chunk* aml_add_qword(struct aml_chunk* parent, unsigned long long value) +AML_CHUNK* aml_add_qword(AML_CHUNK* parent, uint64_t value) { - struct aml_chunk* node = aml_create_node(parent); + AML_CHUNK* node = aml_create_node(parent); - if (node) - { + if (node) { node->Type = AML_CHUNK_QWORD; node->Length = 8; node->Buffer = malloc(node->Length); @@ -165,117 +157,126 @@ node->Buffer[6] = (value >> 48) & 0xff; node->Buffer[7] = (value >> 56) & 0xff; } - return node; } -unsigned int aml_fill_simple_name(char* buffer, const char* name) +uint32_t aml_fill_simple_name(char* buffer, char* name) { - if (strlen(name) < 4) - { + if (strlen(name) < 4) { verbose("aml_fill_simple_name: simple name %s has incorrect lengh! Must be 4.\n", name); return 0; } - memcpy(buffer, name, 4); return 4; } -unsigned int aml_fill_name(struct aml_chunk* node, const char* name) +uint32_t aml_fill_name(AML_CHUNK* node, char* name) { - if (!node) + int len, offset, count; + uint32_t root = 0; + + if (!node) { return 0; + } - int len = strlen(name), offset = 0, count = len / 4; + len = strlen(name); + offset = 0; + count = len >> 2; - if ((len % 4) > 1 || count == 0) - { + if ((len % 4) > 1 || count == 0) { verbose("aml_fill_name: pathname %s has incorrect length! Must be 4, 8, 12, 16, etc...\n", name); return 0; } - - unsigned int root = 0; - if ((len % 4) == 1 && name[0] == '\\') + if (((len % 4) == 1) && (name[0] == '\\')) { root++; - - if (count == 1) - { - node->Length = 4 + root; - node->Buffer = malloc(node->Length); + } + + if (count == 1) { + node->Length = (uint16_t)(4 + root); + node->Buffer = malloc(node->Length+4); memcpy(node->Buffer, name, 4 + root); - return node->Length; + offset += 4 + root; + return (uint32_t)offset; } - if (count == 2) - { + if (count == 2) { node->Length = 2 + 8; - node->Buffer = malloc(node->Length); + node->Buffer = malloc(node->Length+4); node->Buffer[offset++] = 0x5c; // Root Char node->Buffer[offset++] = 0x2e; // Double name memcpy(node->Buffer+offset, name + root, 8); - return node->Length; + offset += 8; + return (uint32_t)offset; } - node->Length = 3 + count*4; - node->Buffer = malloc(node->Length); + node->Length = (uint16_t)(3 + (count << 2)); + node->Buffer = malloc(node->Length+4); node->Buffer[offset++] = 0x5c; // Root Char node->Buffer[offset++] = 0x2f; // Multi name - node->Buffer[offset++] = count; // Names count + node->Buffer[offset++] = (char)count; // Names count memcpy(node->Buffer+offset, name + root, count*4); - - return node->Length; + offset += count*4; + return (uint32_t)offset; } -struct aml_chunk* aml_add_scope(struct aml_chunk* parent, const char* name) +AML_CHUNK* aml_add_scope(AML_CHUNK* parent, char* name) { - struct aml_chunk* node = aml_create_node(parent); + AML_CHUNK* node = aml_create_node(parent); - if (node) - { + if (node) { node->Type = AML_CHUNK_SCOPE; aml_fill_name(node, name); } - return node; } -struct aml_chunk* aml_add_name(struct aml_chunk* parent, const char* name) +AML_CHUNK* aml_add_name(AML_CHUNK* parent, char* name) { - struct aml_chunk* node = aml_create_node(parent); + AML_CHUNK* node = aml_create_node(parent); - if (node) - { + if (node) { node->Type = AML_CHUNK_NAME; aml_fill_name(node, name); } + return node; +} +AML_CHUNK* aml_add_method(AML_CHUNK* parent, char* name, uint8_t args) +{ + AML_CHUNK* node = aml_create_node(parent); + + if (node) { + unsigned int offset = aml_fill_name(node, name); + node->Type = AML_CHUNK_METHOD; + + node->Length++; + node->Buffer[offset] = args; + + } return node; } -struct aml_chunk* aml_add_package(struct aml_chunk* parent) +AML_CHUNK* aml_add_package(AML_CHUNK* parent) { - struct aml_chunk* node = aml_create_node(parent); + AML_CHUNK* node = aml_create_node(parent); - if (node) - { + if (node) { node->Type = AML_CHUNK_PACKAGE; node->Length = 1; node->Buffer = malloc(node->Length); } - return node; } -struct aml_chunk* aml_add_alias(struct aml_chunk* parent, const char* name1, const char* name2) +AML_CHUNK* aml_add_alias(AML_CHUNK* parent, char* name1, char* name2) { - struct aml_chunk* node = aml_create_node(parent); + AML_CHUNK* node = aml_create_node(parent); - if (node) - { + if (node) { node->Type = AML_CHUNK_ALIAS; node->Length = 8; @@ -287,46 +288,177 @@ return node; } -unsigned char aml_get_size_length(unsigned int size) +AML_CHUNK* aml_add_return_name(AML_CHUNK* parent, char* name) { + AML_CHUNK* node = aml_create_node(parent); + + if (node) { + node->Type = AML_CHUNK_RETURN; + aml_fill_name(node, name); + } + + return node; +} + +AML_CHUNK* aml_add_return_byte(AML_CHUNK* parent, uint8_t value) +{ + AML_CHUNK* node = aml_create_node(parent); + + if (node) { + node->Type = AML_CHUNK_RETURN; + aml_add_byte(node, value); + } + + return node; +} + +AML_CHUNK* aml_add_device(AML_CHUNK* parent, char* name) +{ + AML_CHUNK* node = aml_create_node(parent); + + if (node) { + node->Type = AML_CHUNK_DEVICE; + aml_fill_name(node, name); + } + + return node; +} + +AML_CHUNK* aml_add_local0(AML_CHUNK* parent) +{ + AML_CHUNK* node = aml_create_node(parent); + + if (node) { + node->Type = AML_CHUNK_LOCAL0; + node->Length = 1; + } + + return node; +} + +AML_CHUNK* aml_add_store(AML_CHUNK* parent) +{ + AML_CHUNK* node = aml_create_node(parent); + + if (node) { + node->Type = AML_STORE_OP; + node->Length = 1; + } + + return node; +} + +AML_CHUNK* aml_add_byte_buffer(AML_CHUNK* parent, char* data, uint32_t size) +{ + AML_CHUNK* node = aml_create_node(parent); + + if (node) { + int offset = 0; + node->Type = AML_CHUNK_BUFFER; + node->Length = (uint8_t)(size + 2); + node->Buffer = malloc (node->Length); + node->Buffer[offset++] = AML_CHUNK_BYTE; //0x0A + node->Buffer[offset++] = (char)size; + memcpy(node->Buffer+offset,data, node->Length); + } + + return node; +} + +AML_CHUNK* aml_add_string_buffer(AML_CHUNK* parent, char* StringBuf) +{ + AML_CHUNK* node = aml_create_node(parent); + + if (node) { + unsigned int offset = 0; + unsigned int len = strlen(StringBuf)+1; + node->Type = AML_CHUNK_BUFFER; + node->Length = (uint8_t)(len + 3); + node->Buffer = malloc (node->Length); + node->Buffer[offset++] = AML_CHUNK_BYTE; + node->Buffer[offset++] = (char)len; + memcpy(node->Buffer+offset, StringBuf, len); + node->Buffer[offset+len] = '\0'; + } + + return node; +} + +AML_CHUNK* aml_add_string(AML_CHUNK* parent, char* StringBuf) +{ + AML_CHUNK* node = aml_create_node(parent); + + if (node) { + int len = strlen(StringBuf); + node->Type = AML_CHUNK_STRING; + node->Length = (uint8_t)(len + 1); + node->Buffer = malloc (len); + memcpy(node->Buffer, StringBuf, len); + node->Buffer[len] = '\0'; + } + + return node; +} + +AML_CHUNK* aml_add_return(AML_CHUNK* parent) +{ + AML_CHUNK* node = aml_create_node(parent); + + if (node) { + node->Type = AML_CHUNK_RETURN; + //aml_add_byte(node, value); + } + + return node; +} + +uint8_t aml_get_size_length(uint32_t size) +{ if (size + 1 <= 0x3f) return 1; - else if (size + 2 <= 0x3fff) + else if (size + 2 <= 0xfff) /* Encode in 4 bits and 1 byte */ return 2; - else if (size + 3 <= 0x3fffff) + else if (size + 3 <= 0xfffff) /* Encode in 4 bits and 2 bytes */ return 3; - return 4; + return 4; /* Encode 0xfffffff in 4 bits and 2 bytes */ } -unsigned int aml_calculate_size(struct aml_chunk* node) +uint32_t aml_calculate_size(AML_CHUNK* node) { - if (node) - { - node->Size = 0; - + if (node) { // Calculate child nodes size - struct aml_chunk* child = node->First; - unsigned char child_count = 0; + AML_CHUNK* child = node->First; + uint8_t child_count = 0; - while (child) - { + node->Size = 0; + while (child) { child_count++; - node->Size += aml_calculate_size(child); + node->Size += (uint16_t)aml_calculate_size(child); child = child->Next; } - switch (node->Type) - { + switch (node->Type) { case AML_CHUNK_NONE: + case AML_STORE_OP: + case AML_CHUNK_LOCAL0: node->Size += node->Length; break; + + case AML_CHUNK_METHOD: case AML_CHUNK_SCOPE: + case AML_CHUNK_BUFFER: node->Size += 1 + node->Length; node->Size += aml_get_size_length(node->Size); break; + + case AML_CHUNK_DEVICE: + node->Size += 2 + node->Length; + node->Size += aml_get_size_length(node->Size); + break; + case AML_CHUNK_PACKAGE: node->Buffer[0] = child_count; node->Size += 1 + node->Length; @@ -334,15 +466,11 @@ break; case AML_CHUNK_BYTE: - if (node->Buffer[0] == 0x0 || node->Buffer[0] == 0x1) - { + if (node->Buffer[0] == 0x0 || node->Buffer[0] == 0x1) { node->Size += node->Length; - } - else - { + } else { node->Size += 1 + node->Length; } - break; case AML_CHUNK_WORD: @@ -350,24 +478,24 @@ case AML_CHUNK_QWORD: case AML_CHUNK_ALIAS: case AML_CHUNK_NAME: + case AML_CHUNK_RETURN: + case AML_CHUNK_STRING: node->Size += 1 + node->Length; break; } - return node->Size; } - return 0; } -unsigned int aml_write_byte(unsigned char value, char* buffer, unsigned int offset) +uint32_t aml_write_byte(uint8_t value, char* buffer, uint32_t offset) { buffer[offset++] = value; return offset; } -unsigned int aml_write_word(unsigned int value, char* buffer, unsigned int offset) +uint32_t aml_write_word(uint16_t value, char* buffer, uint32_t offset) { buffer[offset++] = value & 0xff; buffer[offset++] = value >> 8; @@ -375,7 +503,7 @@ return offset; } -unsigned int aml_write_dword(unsigned long value, char* buffer, unsigned int offset) +uint32_t aml_write_dword(uint32_t value, char* buffer, uint32_t offset) { buffer[offset++] = value & 0xff; buffer[offset++] = (value >> 8) & 0xff; @@ -385,7 +513,7 @@ return offset; } -unsigned int aml_write_qword(unsigned long long value, char* buffer, unsigned int offset) +uint32_t aml_write_qword(uint64_t value, char* buffer, uint32_t offset) { buffer[offset++] = value & 0xff; buffer[offset++] = (value >> 8) & 0xff; @@ -399,37 +527,29 @@ return offset; } -unsigned int aml_write_buffer(const char* value, unsigned int size, char* buffer, unsigned int offset) +uint32_t aml_write_buffer(const char* value, uint32_t size, char* buffer, uint32_t offset) { - if (size > 0) - { + if (size > 0) { memcpy(buffer + offset, value, size); } return offset + size; } -unsigned int aml_write_size(unsigned int size, char* buffer, unsigned int offset) +uint32_t aml_write_size(uint32_t size, char* buffer, uint32_t offset) { - if (size <= 0x3f) - { - buffer[offset++] = size; - } - else if (size <= 0x3fff) - { - buffer[offset++] = 0x40 | (size & 0xf); - buffer[offset++] = (size >> 4) & 0xff; - } - else if (size <= 0x3fffff) - { - buffer[offset++] = 0x80 | (size & 0xf); - buffer[offset++] = (size >> 4) & 0xff; + if (size <= 0x3f) { /* simple 1 byte length in 6 bits */ + buffer[offset++] = (char)size; + } else if (size <= 0xfff) { + buffer[offset++] = 0x40 | (size & 0xf); /* 0x40 is type, 0x0X is first nibble of length */ + buffer[offset++] = (size >> 4) & 0xff; /* +1 bytes for rest length */ + } else if (size <= 0xfffff) { + buffer[offset++] = 0x80 | (size & 0xf); /* 0x80 is type, 0x0X is first nibble of length */ + buffer[offset++] = (size >> 4) & 0xff; /* +2 bytes for rest length */ buffer[offset++] = (size >> 12) & 0xff; - } - else - { - buffer[offset++] = 0xc0 | (size & 0xf); - buffer[offset++] = (size >> 4) & 0xff; + } else { + buffer[offset++] = 0xc0 | (size & 0xf); /* 0xC0 is type, 0x0X is first nibble of length */ + buffer[offset++] = (size >> 4) & 0xff; /* +3 bytes for rest length */ buffer[offset++] = (size >> 12) & 0xff; buffer[offset++] = (size >> 20) & 0xff; } @@ -437,32 +557,42 @@ return offset; } -unsigned int aml_write_node(struct aml_chunk* node, char* buffer, unsigned int offset) +uint32_t aml_write_node(AML_CHUNK* node, char* buffer, uint32_t offset) { - if (node && buffer) - { - unsigned int old = offset; + if (node && buffer) { + uint32_t old = offset; + AML_CHUNK* child = node->First; - switch (node->Type) - { + switch (node->Type) { case AML_CHUNK_NONE: offset = aml_write_buffer(node->Buffer, node->Length, buffer, offset); break; + case AML_CHUNK_LOCAL0: + case AML_STORE_OP: + offset = aml_write_byte(node->Type, buffer, offset); + break; + + case AML_CHUNK_DEVICE: + offset = aml_write_byte(AML_CHUNK_OP, buffer, offset); + offset = aml_write_byte(node->Type, buffer, offset); + offset = aml_write_size(node->Size-3, buffer, offset); + offset = aml_write_buffer(node->Buffer, node->Length, buffer, offset); + break; + case AML_CHUNK_SCOPE: + case AML_CHUNK_METHOD: case AML_CHUNK_PACKAGE: + case AML_CHUNK_BUFFER: offset = aml_write_byte(node->Type, buffer, offset); offset = aml_write_size(node->Size-1, buffer, offset); offset = aml_write_buffer(node->Buffer, node->Length, buffer, offset); break; case AML_CHUNK_BYTE: - if (node->Buffer[0] == 0x0 || node->Buffer[0] == 0x1) - { + if (node->Buffer[0] == 0x0 || node->Buffer[0] == 0x1) { offset = aml_write_buffer(node->Buffer, node->Length, buffer, offset); - } - else - { + } else { offset = aml_write_byte(node->Type, buffer, offset); offset = aml_write_buffer(node->Buffer, node->Length, buffer, offset); } @@ -473,6 +603,8 @@ case AML_CHUNK_QWORD: case AML_CHUNK_ALIAS: case AML_CHUNK_NAME: + case AML_CHUNK_RETURN: + case AML_CHUNK_STRING: offset = aml_write_byte(node->Type, buffer, offset); offset = aml_write_buffer(node->Buffer, node->Length, buffer, offset); break; @@ -481,18 +613,65 @@ break; } - struct aml_chunk* child = node->First; + while (child) { + offset = aml_write_node(child, buffer, offset); - while (child) - { - offset = aml_write_node(child, buffer, offset); - child = child->Next; } - if (offset - old != node->Size) - verbose("Node size incorrect: 0x%x\n", node->Type); + if (offset - old != node->Size) { + verbose("Node size incorrect: type=0x%x size=%x offset=%x\n", + node->Type, node->Size, (offset - old)); + } } return offset; } + +//the procedure can find array char sizeof N inside part of large array "dsdt" size of len +int32_t FindBin (uint8_t *dsdt, uint32_t len, uint8_t *bin, unsigned int N) +{ + uint32_t i, j; + bool eq; + + for (i=0; ilength; return devprop_generate_string(string); } @@ -56,17 +55,14 @@ /* Use the static "device-properties" boot config key contents if available, * otheriwse use the generated one. */ - if (!getValueForKey(kDeviceProperties, &val, &cnt, &bootInfo->chameleonConfig) && string) - { + if (!getValueForKey(kDeviceProperties, &val, &cnt, &bootInfo->chameleonConfig) && string) { val = (const char*)string; cnt = strlength * 2; } - if (cnt > 1) - { + if (cnt > 1) { binStr = convertHexStr2Binary(val, &cnt2); - if (cnt2 > 0) - { + if (cnt2 > 0) { DT__AddProperty(node, DEVICE_PROPERTIES_PROP, cnt2, binStr); } } @@ -75,15 +71,17 @@ struct DevPropString *devprop_create_string(void) { string = (struct DevPropString*)malloc(sizeof(struct DevPropString)); - if (string == NULL) - return NULL; + + if(string == NULL) { + return NULL; + } memset(string, 0, sizeof(struct DevPropString)); string->length = 12; string->WHAT2 = 0x01000000; return string; } - + struct DevPropDevice *devprop_add_device(struct DevPropString *string, char *path) { struct DevPropDevice *device = NULL; @@ -101,9 +99,9 @@ } if (!(device = malloc(sizeof(struct DevPropDevice)))) { - printf("ERROR malloc failed\n"); - return NULL; - } + printf("ERROR malloc failed\n"); + return NULL; + } memset(device, 0, sizeof(struct DevPropDevice)); device->acpi_dev_path._UID = getPciRootUID(); @@ -117,12 +115,11 @@ x+=strlen(pci_device_string); curr=x; while(path[++x] != ','); - if(x-curr == 2) + if(x-curr == 2) { sprintf(buff, "%c%c", path[curr], path[curr+1]); - else if(x-curr == 1) + } else if(x-curr == 1) { sprintf(buff, "%c", path[curr]); - else - { + } else { printf("ERROR parsing device path\n"); numpaths = 0; break; @@ -132,12 +129,11 @@ x += 3; // 0x curr = x; while(path[++x] != ')'); - if(x-curr == 2) + if(x-curr == 2) { sprintf(buff, "%c%c", path[curr], path[curr+1]); - else if(x-curr == 1) + } else if(x-curr == 1) { sprintf(buff, "%c", path[curr]); - else - { + } else { printf("ERROR parsing device path\n"); numpaths = 0; break; @@ -148,10 +144,10 @@ } } - if (!numpaths) { - free(device); - return NULL; - } + if(!numpaths) { + free(device); + return NULL; + } device->numentries = 0x00; @@ -163,7 +159,7 @@ device->num_pci_devpaths = numpaths; device->length = 24 + (6*numpaths); - int i; + int i; for(i = 0; i < numpaths; i++) { @@ -178,27 +174,28 @@ device->string = string; device->data = NULL; - - if (!string->entries) - if (!(string->entries = (struct DevPropDevice**) malloc(sizeof(device) * DEV_PROP_DEVICE_MAX_ENTRIES))) { - free(device); - return NULL; - } - - /* FIXME: probably needs bounds checking, as well as error handling in event of malloc failure */ + + if(!string->entries) { + if (!(string->entries = (struct DevPropDevice**) malloc(sizeof(device) * DEV_PROP_DEVICE_MAX_ENTRIES))) { + free(device); + return NULL; + } + } + + /* FIXME: probably needs bounds checking, as well as error handling in event of malloc failure */ string->length += device->length; string->entries[string->numentries++] = (struct DevPropDevice*)malloc(sizeof(device)); string->entries[string->numentries-1] = device; - + return device; } int devprop_add_value(struct DevPropDevice *device, char *nm, uint8_t *vl, uint32_t len) { - - if(!nm || !vl || !len) + + if(!nm || !vl || !len) { return 0; - + } uint32_t length = ((strlen(nm) * 2) + len + (2 * sizeof(uint32_t)) + 2); uint8_t *data = (uint8_t*)malloc(length); { @@ -222,13 +219,13 @@ off += 2; l = len; uint32_t *datalength = (uint32_t*)&data[off]; - *datalength = l + 4; + *datalength = (uint32_t)(l + 4); off += 4; for(i = 0 ; i < l ; i++, off++) { data[off] = *vl++; } - } + } uint32_t offset = device->length - (24 + (6 * device->num_pci_devpaths)); @@ -294,7 +291,7 @@ dp_swap32(string->entries[i]->acpi_dev_path._UID)); buffer += 24; - for(x=0;x < string->entries[i]->num_pci_devpaths; x++) + for(x = 0;x < string->entries[i]->num_pci_devpaths; x++) { sprintf(buffer, "%02x%02x%04x%02x%02x", string->entries[i]->pci_dev_path[x].type, string->entries[i]->pci_dev_path[x].subtype, @@ -310,7 +307,7 @@ buffer += 8; uint8_t *dataptr = string->entries[i]->data; - for(x = 0; x < (string->entries[i]->length) - (24 + (6 * string->entries[i]->num_pci_devpaths)) ; x++) + for(x = 0; (uint32_t)x < (string->entries[i]->length) - (24 + (6 * string->entries[i]->num_pci_devpaths)) ; x++) { sprintf(buffer, "%02x", *dataptr++); buffer += 2; @@ -410,17 +407,18 @@ verbose("LAN Controller [%04x:%04x] :: %s\n", eth_dev->vendor_id, eth_dev->device_id, devicepath); - if(!string) - string = devprop_create_string(); + if(!string) { + string = devprop_create_string(); + } - device = devprop_add_device(string, devicepath); + device = devprop_add_device(string, devicepath); if(device) { - verbose("Setting up lan keys\n"); - devprop_add_network_template(device, eth_dev->vendor_id); - stringdata = (uint8_t*)malloc(sizeof(uint8_t) * string->length); - if(stringdata) { - memcpy(stringdata, (uint8_t*)devprop_generate_string(string), string->length); - stringlength = string->length; - } + verbose("Setting up lan keys\n"); + devprop_add_network_template(device, eth_dev->vendor_id); + stringdata = (uint8_t*)malloc(sizeof(uint8_t) * string->length); + if(stringdata) { + memcpy(stringdata, (uint8_t*)devprop_generate_string(string), string->length); + stringlength = string->length; + } } } Index: branches/chucko/i386/libsaio/device_inject.h =================================================================== --- branches/chucko/i386/libsaio/device_inject.h (revision 2328) +++ branches/chucko/i386/libsaio/device_inject.h (revision 2329) @@ -43,7 +43,7 @@ uint16_t numentries; uint16_t WHAT2; // 0x0000 ? struct ACPIDevPath acpi_dev_path; // = 0x02010c00 0xd041030a - struct PCIDevPath pci_dev_path[MAX_PCI_DEV_PATHS]; // = 0x01010600 func dev + struct PCIDevPath pci_dev_path[MAX_PCI_DEV_PATHS]; // = 0x01010600 func dev struct DevicePathEnd path_end; // = 0x7fff0400 uint8_t *data; Index: branches/chucko/i386/libsaio/base64-decode.c =================================================================== --- branches/chucko/i386/libsaio/base64-decode.c (revision 2328) +++ branches/chucko/i386/libsaio/base64-decode.c (revision 2329) @@ -36,8 +36,7 @@ { /* Wrong base64 string length */ return NULL; - - } + } result = dest = malloc(in_len / 4 * 3 + 1); if (result == NULL) return NULL; /* out of memory */ @@ -68,4 +67,4 @@ } -/* end of base64.c */ \ No newline at end of file +/* end of base64.c */ Index: branches/chucko/i386/libsaio/fdisk.h =================================================================== --- branches/chucko/i386/libsaio/fdisk.h (revision 2328) +++ branches/chucko/i386/libsaio/fdisk.h (revision 2329) @@ -35,58 +35,58 @@ #ifndef __LIBSAIO_FDISK_H #define __LIBSAIO_FDISK_H -#define DISK_BLK0 0 /* blkno of boot block */ -#define DISK_BLK0SZ 512 /* size of boot block */ -#define DISK_BOOTSZ 446 /* size of boot code in boot block */ +#define DISK_BLK0 0 /* blkno of boot block */ +#define DISK_BLK0SZ 512 /* size of boot block */ +#define DISK_BOOTSZ 446 /* size of boot code in boot block */ #define DISK_SIGNATURE 0xAA55 /* signature of the boot record */ -#define FDISK_NPART 4 /* number of entries in fdisk table */ +#define FDISK_NPART 4 /* number of entries in fdisk table */ #define FDISK_ACTIVE 0x80 /* indicator of active partition */ #define FDISK_NEXTNAME 0xA7 /* indicator of NeXT partition */ -#define FDISK_DOS12 0x01 /* 12-bit fat < 10MB dos partition */ +#define FDISK_DOS12 0x01 /* 12-bit fat < 10MB dos partition */ #define FDISK_DOS16S 0x04 /* 16-bit fat < 32MB dos partition */ -#define FDISK_DOSEXT 0x05 /* extended dos partition */ +#define FDISK_DOSEXT 0x05 /* extended DOS partition */ #define FDISK_DOS16B 0x06 /* 16-bit fat >= 32MB dos partition */ -#define FDISK_NTFS 0x07 /* NTFS partition */ -#define FDISK_SMALLFAT32 0x0b /* FAT32 partition */ -#define FDISK_FAT32 0x0c /* FAT32 partition */ -#define FDISK_DOS16SLBA 0x0e -#define FDISK_LINUX 0x83 +#define FDISK_NTFS 0x07 /* NTFS partition */ +#define FDISK_SMALLFAT32 0x0b /* FAT32 partition */ +#define FDISK_FAT32 0x0c /* FAT32 partition */ +#define FDISK_DOS16SLBA 0x0e /* 16-bit FAT, LBA-mapped */ +#define FDISK_LINUX 0x83 /* Linux native */ #define FDISK_OPENBSD 0xa6 /* OpenBSD FFS partition */ #define FDISK_FREEBSD 0xa5 /* FreeBSD UFS2 partition */ #define FDISK_BEFS 0xeb /* Haiku BeFS partition */ -#define FDISK_UFS 0xa8 /* Apple UFS partition */ -#define FDISK_HFS 0xaf /* Apple HFS partition */ +#define FDISK_UFS 0xa8 /* Apple UFS partition */ +#define FDISK_HFS 0xaf /* Apple HFS partition */ #define FDISK_BOOTER 0xab /* Apple booter partition */ /* * Format of fdisk partion entry (if present). */ struct fdisk_part { - unsigned char bootid; /* bootable or not */ - unsigned char beghead; /* begining head, sector, cylinder */ - unsigned char begsect; /* begcyl is a 10-bit number */ - unsigned char begcyl; /* High 2 bits are in begsect */ - unsigned char systid; /* OS type */ - unsigned char endhead; /* ending head, sector, cylinder */ - unsigned char endsect; /* endcyl is a 10-bit number */ - unsigned char endcyl; /* High 2 bits are in endsect */ - unsigned long relsect; /* partion physical offset on disk */ - unsigned long numsect; /* number of sectors in partition */ + unsigned char bootid; /* bootable or not */ + unsigned char beghead; /* begining head, sector, cylinder */ + unsigned char begsect; /* begcyl is a 10-bit number */ + unsigned char begcyl; /* High 2 bits are in begsect */ + unsigned char systid; /* OS type */ + unsigned char endhead; /* ending head, sector, cylinder */ + unsigned char endsect; /* endcyl is a 10-bit number */ + unsigned char endcyl; /* High 2 bits are in endsect */ + unsigned long relsect; /* partion physical offset on disk */ + unsigned long numsect; /* number of sectors in partition */ } __attribute__((packed)); /* * Format of boot block. */ struct disk_blk0 { - unsigned char bootcode[DISK_BOOTSZ]; - unsigned char parts[FDISK_NPART][sizeof (struct fdisk_part)]; - unsigned short signature; + unsigned char bootcode[DISK_BOOTSZ]; + unsigned char parts[FDISK_NPART][sizeof (struct fdisk_part)]; + unsigned short signature; }; struct REAL_disk_blk0 { - unsigned char bootcode[DISK_BOOTSZ]; - struct fdisk_part parts[FDISK_NPART]; - unsigned short signature; + unsigned char bootcode[DISK_BOOTSZ]; + struct fdisk_part parts[FDISK_NPART]; + unsigned short signature; } __attribute__((packed)); #endif /* !__LIBSAIO_FDISK_H */ Index: branches/chucko/i386/libsaio/dram_controllers.c =================================================================== --- branches/chucko/i386/libsaio/dram_controllers.c (revision 2328) +++ branches/chucko/i386/libsaio/dram_controllers.c (revision 2329) @@ -37,7 +37,7 @@ static void setup_p35(pci_dt_t *dram_dev) { uint32_t dev0; - + // Activate MMR I/O dev0 = pci_config_read32(dram_dev->dev.addr, 0x48); if (!(dev0 & 0x1)) @@ -63,7 +63,7 @@ did = pci_config_read16(PCIADDR(possible_nhm_bus[i], 3, 4), PCI_DEVICE_ID); vid &= 0xFFFF; did &= 0xFF00; - + if(vid == 0x8086 && did >= 0x2C00) { nhm_bus = possible_nhm_bus[i]; @@ -82,28 +82,28 @@ uint32_t dev0, mch_ratio, mch_cfg, mch_fsb; long *ptr; - + // Find Ratio dev0 = pci_config_read32(dram_dev->dev.addr, 0x48); dev0 &= 0xFFFFC000; ptr = (long*)(dev0 + 0xC00); mch_cfg = *ptr & 0xFFFF; - + mch_ratio = 100000; - + switch (mch_cfg & 7) { case 0: mch_fsb = 1066; break; case 1: mch_fsb = 533; break; - default: + default: case 2: mch_fsb = 800; break; - case 3: mch_fsb = 667; break; + case 3: mch_fsb = 667; break; case 4: mch_fsb = 1333; break; - case 6: mch_fsb = 1600; break; + case 6: mch_fsb = 1600; break; } - + DBG("mch_fsb %d\n", mch_fsb); - + switch (mch_fsb) { case 533: @@ -114,7 +114,7 @@ case 3: mch_ratio = 300000; break; } break; - + default: case 800: switch ((mch_cfg >> 4) & 7) @@ -127,7 +127,7 @@ case 5: mch_ratio = 333333; break; // 3.333333333 } break; - + case 1066: switch ((mch_cfg >> 4) & 7) { @@ -138,7 +138,7 @@ case 5: mch_ratio = 250000; break; } break; - + case 1333: switch ((mch_cfg >> 4) & 7) { @@ -148,7 +148,7 @@ case 5: mch_ratio = 200000; break; } break; - + case 1600: switch ((mch_cfg >> 4) & 7) { @@ -159,12 +159,12 @@ } break; } - + DBG("mch_ratio %d\n", mch_ratio); // Compute RAM Frequency Platform.RAM.Frequency = (Platform.CPU.FSBFrequency * mch_ratio) / 100000; - + DBG("ram_fsb %d\n", Platform.RAM.Frequency); } @@ -175,24 +175,24 @@ uint32_t dev0, mch_ratio, mch_cfg, mch_fsb; long *ptr; - + // Find Ratio dev0 = pci_config_read32(dram_dev->dev.addr, 0x48); dev0 &= 0xFFFFC000; ptr = (long*)(dev0 + 0xC00); mch_cfg = *ptr & 0xFFFF; - + mch_ratio = 100000; - + switch (mch_cfg & 7) { case 1: mch_fsb = 533; break; default: case 2: mch_fsb = 800; break; - case 3: mch_fsb = 667; break; - case 6: mch_fsb = 1066; break; + case 3: mch_fsb = 667; break; + case 6: mch_fsb = 1066; break; } - + switch (mch_fsb) { case 533: @@ -203,7 +203,7 @@ case 3: mch_ratio = 200000; break; } break; - + case 667: switch ((mch_cfg >> 4)& 7) { @@ -214,7 +214,7 @@ case 5: mch_ratio = 240000; break; } break; - + default: case 800: switch ((mch_cfg >> 4) & 7) @@ -232,9 +232,9 @@ case 5: mch_ratio = 150000; break; case 6: mch_ratio = 200000; break; } - + } - + // Compute RAM Frequency Platform.RAM.Frequency = (Platform.CPU.FSBFrequency * mch_ratio) / 100000; } @@ -244,11 +244,11 @@ static void get_fsb_nhm(pci_dt_t *dram_dev) { uint32_t mch_ratio, mc_dimm_clk_ratio; - + // Get the clock ratio mc_dimm_clk_ratio = pci_config_read16(PCIADDR(nhm_bus, 3, 4), 0x54 ); mch_ratio = (mc_dimm_clk_ratio & 0x1F); - + // Compute RAM Frequency Platform.RAM.Frequency = Platform.CPU.FSBFrequency * mch_ratio / 2; } @@ -259,60 +259,61 @@ // Get i965 Memory Timings static void get_timings_i965(pci_dt_t *dram_dev) -{ +{ // Thanks for CDH optis uint32_t dev0, c0ckectrl, c1ckectrl, offset; uint32_t ODT_Control_Register, Precharge_Register, ACT_Register, Read_Register, Misc_Register; long *ptr; - + // Read MMR Base Address dev0 = pci_config_read32(dram_dev->dev.addr, 0x48); dev0 &= 0xFFFFC000; - + ptr = (long*)(dev0 + 0x260); c0ckectrl = *ptr & 0xFFFFFFFF; - + ptr = (long*)(dev0 + 0x660); c1ckectrl = *ptr & 0xFFFFFFFF; - + // If DIMM 0 not populated, check DIMM 1 ((c0ckectrl) >> 20 & 0xF) ? (offset = 0) : (offset = 0x400); - + ptr = (long*)(dev0 + offset + 0x29C); ODT_Control_Register = *ptr & 0xFFFFFFFF; - + ptr = (long*)(dev0 + offset + 0x250); Precharge_Register = *ptr & 0xFFFFFFFF; - + ptr = (long*)(dev0 + offset + 0x252); ACT_Register = *ptr & 0xFFFFFFFF; - + ptr = (long*)(dev0 + offset + 0x258); Read_Register = *ptr & 0xFFFFFFFF; - + ptr = (long*)(dev0 + offset + 0x244); Misc_Register = *ptr & 0xFFFFFFFF; - + // 965 Series only support DDR2 Platform.RAM.Type = SMB_MEM_TYPE_DDR2; - + // CAS Latency (tCAS) Platform.RAM.CAS = ((ODT_Control_Register >> 17) & 7) + 3; - + // RAS-To-CAS (tRCD) Platform.RAM.TRC = (Read_Register >> 16) & 0xF; - + // RAS Precharge (tRP) Platform.RAM.TRP = (ACT_Register >> 13) & 0xF; - + // RAS Active to precharge (tRAS) Platform.RAM.RAS = (Precharge_Register >> 11) & 0x1F; - - if ((c0ckectrl >> 20 & 0xF) && (c1ckectrl >> 20 & 0xF)) + + if ((c0ckectrl >> 20 & 0xF) && (c1ckectrl >> 20 & 0xF)) { Platform.RAM.Channels = SMB_MEM_CHANNEL_DUAL; - else + } else { Platform.RAM.Channels = SMB_MEM_CHANNEL_SINGLE; + } } // Get im965 Memory Timings @@ -321,127 +322,131 @@ // Thanks for CDH optis uint32_t dev0, c0ckectrl, c1ckectrl, offset, ODT_Control_Register, Precharge_Register; long *ptr; - + // Read MMR Base Address dev0 = pci_config_read32(dram_dev->dev.addr, 0x48); dev0 &= 0xFFFFC000; - + ptr = (long*)(dev0 + 0x1200); c0ckectrl = *ptr & 0xFFFFFFFF; - + ptr = (long*)(dev0 + 0x1300); c1ckectrl = *ptr & 0xFFFFFFFF; - + // If DIMM 0 not populated, check DIMM 1 ((c0ckectrl) >> 20 & 0xF) ? (offset = 0) : (offset = 0x100); - + ptr = (long*)(dev0 + offset + 0x121C); ODT_Control_Register = *ptr & 0xFFFFFFFF; - + ptr = (long*)(dev0 + offset + 0x1214); Precharge_Register = *ptr & 0xFFFFFFFF; - + // Series only support DDR2 Platform.RAM.Type = SMB_MEM_TYPE_DDR2; - + // CAS Latency (tCAS) Platform.RAM.CAS = ((ODT_Control_Register >> 23) & 7) + 3; - + // RAS-To-CAS (tRCD) Platform.RAM.TRC = ((Precharge_Register >> 5) & 7) + 2; - + // RAS Precharge (tRP) Platform.RAM.TRP= (Precharge_Register & 7) + 2; - + // RAS Active to precharge (tRAS) Platform.RAM.RAS = (Precharge_Register >> 21) & 0x1F; - - if ((c0ckectrl >> 20 & 0xF) && (c1ckectrl >> 20 & 0xF)) + + if ((c0ckectrl >> 20 & 0xF) && (c1ckectrl >> 20 & 0xF)) { Platform.RAM.Channels = SMB_MEM_CHANNEL_DUAL; - else + } else { Platform.RAM.Channels = SMB_MEM_CHANNEL_SINGLE; + } } // Get P35 Memory Timings static void get_timings_p35(pci_dt_t *dram_dev) -{ +{ // Thanks for CDH optis unsigned long dev0, Memory_Check, c0ckectrl, c1ckectrl, offset; unsigned long ODT_Control_Register, Precharge_Register, ACT_Register, Read_Register, Misc_Register; long *ptr; - + //Device_ID = pci_config_read16(dram_dev->dev.addr, 0x02); //Device_ID &= 0xFFFF; - + // Now, read MMR Base Address dev0 = pci_config_read32(dram_dev->dev.addr, 0x48); dev0 &= 0xFFFFC000; - + ptr = (long*)(dev0 + 0x260); - c0ckectrl = *ptr & 0xFFFFFFFF; - + c0ckectrl = *ptr & 0xFFFFFFFF; + ptr = (long*)(dev0 + 0x660); c1ckectrl = *ptr & 0xFFFFFFFF; - + // If DIMM 0 not populated, check DIMM 1 ((c0ckectrl) >> 20 & 0xF) ? (offset = 0) : (offset = 0x400); - + ptr = (long*)(dev0 + offset + 0x265); ODT_Control_Register = *ptr & 0xFFFFFFFF; - - ptr = (long*)(dev0 + offset + 0x25D); + + ptr = (long*)(dev0 + offset + 0x25D); Precharge_Register = *ptr & 0xFFFFFFFF; - + ptr = (long*)(dev0 + offset + 0x252); ACT_Register = *ptr & 0xFFFFFFFF; - + ptr = (long*)(dev0 + offset + 0x258); Read_Register = *ptr & 0xFFFFFFFF; - + ptr = (long*)(dev0 + offset + 0x244); Misc_Register = *ptr & 0xFFFFFFFF; - + ptr = (long*)(dev0 + offset + 0x1E8); - Memory_Check = *ptr & 0xFFFFFFFF; - + Memory_Check = *ptr & 0xFFFFFFFF; + // On P45, check 1A8 if(dram_dev->device_id > 0x2E00) { ptr = (long*)(dev0 + offset + 0x1A8); - Memory_Check = *ptr & 0xFFFFFFFF; + Memory_Check = *ptr & 0xFFFFFFFF; Memory_Check >>= 2; Memory_Check &= 1; Memory_Check = !Memory_Check; } else { ptr = (long*)(dev0 + offset + 0x1E8); - Memory_Check = *ptr & 0xFFFFFFFF; + Memory_Check = *ptr & 0xFFFFFFFF; } - + // Determine DDR-II or DDR-III - if (Memory_Check & 1) + if (Memory_Check & 1) { Platform.RAM.Type = SMB_MEM_TYPE_DDR2; - else + } else { Platform.RAM.Type = SMB_MEM_TYPE_DDR3; + } // CAS Latency (tCAS) - if(dram_dev->device_id > 0x2E00) + if(dram_dev->device_id > 0x2E00) { Platform.RAM.CAS = ((ODT_Control_Register >> 8) & 0x3F) - 6; - else + } else { Platform.RAM.CAS = ((ODT_Control_Register >> 8) & 0x3F) - 9; + } // RAS-To-CAS (tRCD) Platform.RAM.TRC = (Read_Register >> 17) & 0xF; - + // RAS Precharge (tRP) Platform.RAM.TRP = (ACT_Register >> 13) & 0xF; - + // RAS Active to precharge (tRAS) Platform.RAM.RAS = Precharge_Register & 0x3F; - + // Channel configuration - if (((c0ckectrl >> 20) & 0xF) && ((c1ckectrl >> 20) & 0xF)) + if (((c0ckectrl >> 20) & 0xF) && ((c1ckectrl >> 20) & 0xF)) { Platform.RAM.Channels = SMB_MEM_CHANNEL_DUAL; - else + } else { Platform.RAM.Channels = SMB_MEM_CHANNEL_SINGLE; + } } // Get Nehalem Memory Timings @@ -449,45 +454,47 @@ { unsigned long mc_channel_bank_timing, mc_control, mc_channel_mrs_value; int fvc_bn = 4; - + // Find which channels are populated mc_control = pci_config_read16(PCIADDR(nhm_bus, 3, 0), 0x48); mc_control = (mc_control >> 8) & 0x7; - + // DDR-III Platform.RAM.Type = SMB_MEM_TYPE_DDR3; - + // Get the first valid channel - if(mc_control & 1) + if(mc_control & 1) { fvc_bn = 4; - else if(mc_control & 2) + } else if(mc_control & 2) { fvc_bn = 5; - else if(mc_control & 7) + } else if(mc_control & 7) { fvc_bn = 6; + } // Now, detect timings mc_channel_bank_timing = pci_config_read32(PCIADDR(nhm_bus, fvc_bn, 0), 0x88); mc_channel_mrs_value = pci_config_read32(PCIADDR(nhm_bus, fvc_bn, 0), 0x70); - + // CAS Latency (tCAS) Platform.RAM.CAS = ((mc_channel_mrs_value >> 4) & 0xF ) + 4; - + // RAS-To-CAS (tRCD) Platform.RAM.TRC = (mc_channel_bank_timing >> 9) & 0xF; - + // RAS Active to precharge (tRAS) Platform.RAM.RAS = (mc_channel_bank_timing >> 4) & 0x1F; - + // RAS Precharge (tRP) Platform.RAM.TRP = mc_channel_bank_timing & 0xF; - + // Single , Dual or Triple Channels - if (mc_control == 1 || mc_control == 2 || mc_control == 4 ) + if (mc_control == 1 || mc_control == 2 || mc_control == 4 ) { Platform.RAM.Channels = SMB_MEM_CHANNEL_SINGLE; - else if (mc_control == 7) + } else if (mc_control == 7) { Platform.RAM.Channels = SMB_MEM_CHANNEL_TRIPLE; - else + } else { Platform.RAM.Channels = SMB_MEM_CHANNEL_DUAL; + } } static struct mem_controller_t dram_controllers[] = { @@ -496,72 +503,100 @@ { 0, 0, "", NULL, NULL, NULL }, // Intel +// { 0x8086, 0x0100, "2rd Gen Core processor", NULL, NULL, NULL }, +// { 0x8086, 0x0104, "2rd Gen Core processor", NULL, NULL, NULL }, +// { 0x8086, 0x010C, "Xeon E3-1200/2rd Gen Core processor", NULL, NULL, NULL }, +// { 0x8086, 0x0150, "Xeon E3-1200 v2/3rd Gen Core processor", NULL, NULL, NULL }, +// { 0x8086, 0x0154, "3rd Gen Core processor", NULL, NULL, NULL }, +// { 0x8086, 0x0158, "Xeon E3-1200 v2/Ivy Bridge", NULL, NULL, NULL }, +// { 0x8086, 0x015C, "Xeon E3-1200 v2/3rd Gen Core processor", NULL, NULL, NULL }, + +// { 0x8086, 0x0BF0, "Atom Processor D2xxx/N2xxx", NULL, NULL, NULL }, +// { 0x8086, 0x0BF1, "Atom Processor D2xxx/N2xxx", NULL, NULL, NULL }, +// { 0x8086, 0x0BF2, "Atom Processor D2xxx/N2xxx", NULL, NULL, NULL }, +// { 0x8086, 0x0BF3, "Atom Processor D2xxx/N2xxx", NULL, NULL, NULL }, +// { 0x8086, 0x0BF4, "Atom Processor D2xxx/N2xxx", NULL, NULL, NULL }, +// { 0x8086, 0x0BF5, "Atom Processor D2xxx/N2xxx", NULL, NULL, NULL }, +// { 0x8086, 0x0BF6, "Atom Processor D2xxx/N2xxx", NULL, NULL, NULL }, +// { 0x8086, 0x0BF7, "Atom Processor D2xxx/N2xxx", NULL, NULL, NULL }, + +// { 0x8086, 0x0C00, "Haswell", NULL, NULL, NULL }, +// { 0x8086, 0x0C04, "Haswell", NULL, NULL, NULL }, +// { 0x8086, 0x0C08, "Haswell", NULL, NULL, NULL }, + { 0x8086, 0x7190, "VMWare", NULL, NULL, NULL }, - { 0x8086, 0x1A30, "i845", NULL, NULL, NULL }, + { 0x8086, 0x1A30, "82845 845 [Brookdale]", NULL, NULL, NULL }, - { 0x8086, 0x2970, "i946PL/GZ", setup_p35, get_fsb_i965, get_timings_i965 }, - { 0x8086, 0x2990, "Q963/Q965", setup_p35, get_fsb_i965, get_timings_i965 }, + { 0x8086, 0x2970, "82946GZ/PL/GL", setup_p35, get_fsb_i965, get_timings_i965 }, + { 0x8086, 0x2990, "82Q963/Q965", setup_p35, get_fsb_i965, get_timings_i965 }, { 0x8086, 0x29A0, "P965/G965", setup_p35, get_fsb_i965, get_timings_i965 }, { 0x8086, 0x2A00, "GM965/GL960", setup_p35, get_fsb_im965, get_timings_im965 }, { 0x8086, 0x2A10, "GME965/GLE960", setup_p35, get_fsb_im965, get_timings_im965 }, { 0x8086, 0x2A40, "PM/GM45/47", setup_p35, get_fsb_im965, get_timings_im965 }, - { 0x8086, 0x29B0, "Q35", setup_p35, get_fsb_i965, get_timings_p35 }, - { 0x8086, 0x29C0, "P35/G33", setup_p35, get_fsb_i965, get_timings_p35 }, - { 0x8086, 0x29D0, "Q33", setup_p35, get_fsb_i965, get_timings_p35 }, - { 0x8086, 0x29E0, "X38/X48", setup_p35, get_fsb_i965, get_timings_p35 }, + { 0x8086, 0x29B0, "82Q35 Express", setup_p35, get_fsb_i965, get_timings_p35 }, + { 0x8086, 0x29C0, "82G33/G31/P35/P31", setup_p35, get_fsb_i965, get_timings_p35 }, + { 0x8086, 0x29D0, "82Q33 Express", setup_p35, get_fsb_i965, get_timings_p35 }, + { 0x8086, 0x29E0, "82X38/X48 Express", setup_p35, get_fsb_i965, get_timings_p35 }, +// { 0x8086, 0x29F0, "3200/3210 Chipset", NULL, NULL, NULL }, + { 0x8086, 0x2E00, "Eaglelake", setup_p35, get_fsb_i965, get_timings_p35 }, { 0x8086, 0x2E10, "Q45/Q43", setup_p35, get_fsb_i965, get_timings_p35 }, { 0x8086, 0x2E20, "P45/G45", setup_p35, get_fsb_i965, get_timings_p35 }, - { 0x8086, 0x2E30, "G41", setup_p35, get_fsb_i965, get_timings_p35 }, + { 0x8086, 0x2E30, "G41", setup_p35, get_fsb_i965, get_timings_p35 }, +// { 0x8086, 0x2E40, "4 Series Chipset", NULL, NULL, NULL }, +// { 0x8086, 0x2E90, "4 Series Chipset", NULL, NULL, NULL }, { 0x8086, 0xD131, "NHM IMC", setup_nhm, get_fsb_nhm, get_timings_nhm }, { 0x8086, 0xD132, "NHM IMC", setup_nhm, get_fsb_nhm, get_timings_nhm }, - { 0x8086, 0x3400, "NHM IMC", setup_nhm, get_fsb_nhm, get_timings_nhm }, - { 0x8086, 0x3401, "NHM IMC", setup_nhm, get_fsb_nhm, get_timings_nhm }, - { 0x8086, 0x3402, "NHM IMC", setup_nhm, get_fsb_nhm, get_timings_nhm }, - { 0x8086, 0x3403, "NHM IMC", setup_nhm, get_fsb_nhm, get_timings_nhm }, - { 0x8086, 0x3404, "NHM IMC", setup_nhm, get_fsb_nhm, get_timings_nhm }, - { 0x8086, 0x3405, "NHM IMC", setup_nhm, get_fsb_nhm, get_timings_nhm }, - { 0x8086, 0x3406, "NHM IMC", setup_nhm, get_fsb_nhm, get_timings_nhm }, - { 0x8086, 0x3407, "NHM IMC", setup_nhm, get_fsb_nhm, get_timings_nhm }, + { 0x8086, 0x3400, "5520/5500/X58", setup_nhm, get_fsb_nhm, get_timings_nhm }, + { 0x8086, 0x3401, "5520/5500/X58", setup_nhm, get_fsb_nhm, get_timings_nhm }, + { 0x8086, 0x3402, "5520/5500/X58", setup_nhm, get_fsb_nhm, get_timings_nhm }, + { 0x8086, 0x3403, "5500", setup_nhm, get_fsb_nhm, get_timings_nhm }, + { 0x8086, 0x3404, "5520/5500/X58", setup_nhm, get_fsb_nhm, get_timings_nhm }, + { 0x8086, 0x3405, "5520/5500/X58", setup_nhm, get_fsb_nhm, get_timings_nhm }, + { 0x8086, 0x3406, "5520", setup_nhm, get_fsb_nhm, get_timings_nhm }, + { 0x8086, 0x3407, "5520/5500/X58", setup_nhm, get_fsb_nhm, get_timings_nhm }, }; static const char *memory_channel_types[] = { "Unknown", "Single", "Dual", "Triple" -}; +}; void scan_dram_controller(pci_dt_t *dram_dev) { int i; for(i = 1; i < sizeof(dram_controllers) / sizeof(dram_controllers[0]); i++) - if ((dram_controllers[i].vendor == dram_dev->vendor_id) - && (dram_controllers[i].device == dram_dev->device_id)) + { + if ((dram_controllers[i].vendor == dram_dev->vendor_id) && (dram_controllers[i].device == dram_dev->device_id)) { verbose("%s%s DRAM Controller [%4x:%4x] at %02x:%02x.%x\n", - (dram_dev->vendor_id == 0x8086) ? "Intel " : "" , - dram_controllers[i].name, dram_dev->vendor_id, dram_dev->device_id, - dram_dev->dev.bits.bus, dram_dev->dev.bits.dev, dram_dev->dev.bits.func); - - if (dram_controllers[i].initialise != NULL) + (dram_dev->vendor_id == 0x8086) ? "Intel Corporation " : "" , + dram_controllers[i].name, dram_dev->vendor_id, dram_dev->device_id, + dram_dev->dev.bits.bus, dram_dev->dev.bits.dev, dram_dev->dev.bits.func); + + if (dram_controllers[i].initialise != NULL) { dram_controllers[i].initialise(dram_dev); + } - if (dram_controllers[i].poll_timings != NULL) + if (dram_controllers[i].poll_timings != NULL) { dram_controllers[i].poll_timings(dram_dev); + } - if (dram_controllers[i].poll_speed != NULL) + if (dram_controllers[i].poll_speed != NULL) { dram_controllers[i].poll_speed(dram_dev); + } verbose("Frequency detected: %d MHz (%d) %s Channel \n\tCAS:%d tRC:%d tRP:%d RAS:%d (%d-%d-%d-%d)\n", - (uint32_t)Platform.RAM.Frequency / 1000000, - (uint32_t)Platform.RAM.Frequency / 500000, - memory_channel_types[Platform.RAM.Channels] - ,Platform.RAM.CAS, Platform.RAM.TRC, Platform.RAM.TRP, Platform.RAM.RAS - ,Platform.RAM.CAS, Platform.RAM.TRC, Platform.RAM.TRP, Platform.RAM.RAS - ); -// getchar(); + (uint32_t)Platform.RAM.Frequency / 1000000, + (uint32_t)Platform.RAM.Frequency / 500000, + memory_channel_types[Platform.RAM.Channels] + ,Platform.RAM.CAS, Platform.RAM.TRC, Platform.RAM.TRP, Platform.RAM.RAS + ,Platform.RAM.CAS, Platform.RAM.TRC, Platform.RAM.TRP, Platform.RAM.RAS); +// getchar(); } + } } Index: branches/chucko/i386/libsaio/nvidia.c =================================================================== --- branches/chucko/i386/libsaio/nvidia.c (revision 2328) +++ branches/chucko/i386/libsaio/nvidia.c (revision 2329) @@ -1057,7 +1057,7 @@ { 0x10DE1048, "GeForce 605" }, { 0x10DE1049, "GeForce GT 620" }, { 0x10DE104A, "GeForce GT 610" }, - { 0x10DE104B, "GeForce GT 625" }, + { 0x10DE104B, "GeForce GT 625 (OEM)" }, // 1050 - 105F { 0x10DE1050, "GeForce GT 520M" }, { 0x10DE1051, "GeForce GT 520MX" }, @@ -1304,9 +1304,14 @@ { 0x10DE06CD, 0x10DE079F, "Point of View GeForce GTX 470" }, { 0x10DE06CD, 0x14622220, "MSi GeForce GTX 470 Twin Frozr II" }, + { 0x10DE06D1, 0x10DE0771, "nVidia Tesla C2050" }, { 0x10DE06D1, 0x10DE0772, "nVidia Tesla C2070" }, + { 0x10DE06D2, 0x10DE0774, "nVidia Tesla M2070" }, + { 0x10DE06D2, 0x10DE0830, "nVidia Tesla M2070" }, + { 0x10DE06D2, 0x10DE0842, "nVidia Tesla M2070" }, { 0x10DE06D2, 0x10DE088F, "nVidia Tesla X2070" }, + { 0x10DE06D2, 0x10DE0908, "nVidia Tesla M2070" }, { 0x10DE06DE, 0x10DE0773, "nVidia Tesla S2050" }, { 0x10DE06DE, 0x10DE0830, "nVidia Tesla M2070" }, @@ -1366,6 +1371,12 @@ { 0x10DE1091, 0x10DE088E, "nVidia Tesla X2090" }, { 0x10DE1091, 0x10DE0891, "nVidia Tesla X2090" }, + + { 0x10DE1094, 0x10DE0888, "nVidia Tesla M2075" }, + + { 0x10DE1096, 0x10DE0910, "nVidia Tesla C2075" }, + { 0x10DE1096, 0x10DE0911, "nVidia Tesla C2050" }, + // 1100 - 11FF { 0x10DE1140, 0x1025064A, "Acer GeForce GT 620M" }, { 0x10DE1140, 0x1025064C, "Acer GeForce GT 620M" }, @@ -1702,9 +1713,9 @@ { if (nvidia_card_vendors[j].device == (subsys_id & 0xffff0000)) { - snprintf(name_model, sizeof(name_model), "%s %s", - nvidia_card_vendors[j].name, nvidia_card_generic[i].name); - return name_model; + snprintf(name_model, sizeof(name_model), "%s %s", + nvidia_card_vendors[j].name, nvidia_card_generic[i].name); + return name_model; } } } @@ -2171,7 +2182,7 @@ memcpy(stringdata, (uint8_t*)devprop_generate_string(string), string->length); stringlength = string->length; - free(version_str); + free(version_str); free(rom); return true; } Index: branches/chucko/i386/libsaio/ntfs.c =================================================================== --- branches/chucko/i386/libsaio/ntfs.c (revision 2328) +++ branches/chucko/i386/libsaio/ntfs.c (revision 2329) @@ -270,9 +270,8 @@ //verbose("NTFS: lseek to $Volume failed: %s\n", strerror(errno)); goto error; } - if (read(fd, buf, mftRecordSize) != mftRecordSize) - { - //verbose("NTFS: error reading MFT $Volume record: %s\n", strerror(errno)); + if (read(fd, buf, mftRecordSize) != mftRecordSize) { + //verbose("NTFS: error reading MFT $Volume record: %s\n", strerror(errno)); goto error; } #endif @@ -310,8 +309,9 @@ struct bootfile *boot; void *buf = malloc(MAX_BLOCK_SIZE); - if ( !buf ) + if ( !buf ) { return -1; + } /* * Read the boot sector, check signatures, and do some minimal @@ -339,21 +339,21 @@ (unsigned short)boot->bf_volsn & 0xFFFF); return 0; -} +} bool NTFSProbe(const void * buffer) { bool result = false; const struct bootfile * part_bootfile = buffer; // NTFS boot sector structure - + // Looking for NTFS signature. if (strncmp((const char *)part_bootfile->bf_sysid, NTFS_BBID, NTFS_BBIDLEN) == 0) result = true; - + // If not NTFS, maybe it is EXFAT if (!result) result = EXFATProbe(buffer); - + return result; } Index: branches/chucko/i386/libsaio/platform.c =================================================================== --- branches/chucko/i386/libsaio/platform.c (revision 2328) +++ branches/chucko/i386/libsaio/platform.c (revision 2329) @@ -37,30 +37,34 @@ } /** scan mem for memory autodection purpose */ -void scan_mem() { - static bool done = false; - if (done) return; +void scan_mem() +{ + static bool done = false; + if (done) { + return; + } /* our code only works on Intel chipsets so make sure here */ - if (pci_config_read16(PCIADDR(0, 0x00, 0), 0x00) != 0x8086) + if (pci_config_read16(PCIADDR(0, 0x00, 0), 0x00) != 0x8086) { bootInfo->memDetect = false; - else + } else { bootInfo->memDetect = true; + } /* manually */ - getBoolForKey(kUseMemDetect, &bootInfo->memDetect, &bootInfo->chameleonConfig); + getBoolForKey(kUseMemDetect, &bootInfo->memDetect, &bootInfo->chameleonConfig); - if (bootInfo->memDetect) { + if (bootInfo->memDetect) { if (dram_controller_dev != NULL) { scan_dram_controller(dram_controller_dev); // Rek: pci dev ram controller direct and fully informative scan ... } - scan_spd(&Platform); - } - done = true; + scan_spd(&Platform); + } + done = true; } -/** - Scan platform hardware information, called by the main entry point (common_boot() ) - _before_ bootConfig xml parsing settings are loaded +/* + * Scan platform hardware information, called by the main entry point (common_boot() ) + * _before_ bootConfig xml parsing settings are loaded */ void scan_platform(void) { Index: branches/chucko/i386/libsaio/cpu.c =================================================================== --- branches/chucko/i386/libsaio/cpu.c (revision 2328) +++ branches/chucko/i386/libsaio/cpu.c (revision 2329) @@ -310,6 +310,7 @@ p->CPU.Stepping = bitfield(p->CPU.CPUID[CPUID_1][0], 3, 0); p->CPU.Model = bitfield(p->CPU.CPUID[CPUID_1][0], 7, 4); p->CPU.Family = bitfield(p->CPU.CPUID[CPUID_1][0], 11, 8); + p->CPU.Type = bitfield(p->CPU.CPUID[CPUID_1][0], 13, 12); p->CPU.ExtModel = bitfield(p->CPU.CPUID[CPUID_1][0], 19, 16); p->CPU.ExtFamily = bitfield(p->CPU.CPUID[CPUID_1][0], 27, 20); @@ -421,11 +422,9 @@ fsbFrequency = 0; cpuFrequency = 0; - if ((p->CPU.Vendor == CPUID_VENDOR_INTEL) && ((p->CPU.Family == 0x06) || (p->CPU.Family == 0x0f))) - { + if ((p->CPU.Vendor == CPUID_VENDOR_INTEL) && ((p->CPU.Family == 0x06) || (p->CPU.Family == 0x0f))) { int intelCPU = p->CPU.Model; - if ((p->CPU.Family == 0x06 && p->CPU.Model >= 0x0c) || (p->CPU.Family == 0x0f && p->CPU.Model >= 0x03)) - { + if ((p->CPU.Family == 0x06 && p->CPU.Model >= 0x0c) || (p->CPU.Family == 0x0f && p->CPU.Model >= 0x03)) { /* Nehalem CPU model */ if (p->CPU.Family == 0x06 && (p->CPU.Model == CPU_MODEL_NEHALEM || p->CPU.Model == CPU_MODEL_FIELDS || @@ -529,9 +528,7 @@ myfsb = fsbFrequency / 1000000; verbose("Sticking with [BCLK: %dMhz, Bus-Ratio: %d]\n", myfsb, max_ratio/10); currcoef = bus_ratio_max; - } - else - { + } else { msr = rdmsr64(MSR_IA32_PERF_STATUS); DBG("msr(%d): ia32_perf_stat 0x%08x\n", __LINE__, bitfield(msr, 31, 0)); currcoef = bitfield(msr, 12, 8); @@ -576,15 +573,11 @@ } } /* Mobile CPU */ - if (rdmsr64(MSR_IA32_PLATFORM_ID) & (1<<28)) - { + if (rdmsr64(MSR_IA32_PLATFORM_ID) & (1<<28)) { p->CPU.Features |= CPU_FEATURE_MOBILE; } - } - else if ((p->CPU.Vendor == CPUID_VENDOR_AMD) && (p->CPU.Family == 0x0f)) - { - switch(p->CPU.ExtFamily) - { + } else if ((p->CPU.Vendor == CPUID_VENDOR_AMD) && (p->CPU.Family == 0x0f)) { + switch(p->CPU.ExtFamily) { case 0x00: /* K8 */ msr = rdmsr64(K8_FIDVID_STATUS); maxcoef = bitfield(msr, 21, 16) / 2 + 4; @@ -622,47 +615,31 @@ break; } - if (maxcoef) - { - if (currdiv) - { - if (!currcoef) - { + if (maxcoef) { + if (currdiv) { + if (!currcoef) { currcoef = maxcoef; } - if (!cpuFrequency) - { + if (!cpuFrequency) { fsbFrequency = ((tscFrequency * currdiv) / currcoef); - } - else - { + } else { fsbFrequency = ((cpuFrequency * currdiv) / currcoef); } DBG("%d.%d\n", currcoef / currdiv, ((currcoef % currdiv) * 100) / currdiv); - } - else - { - if (!cpuFrequency) - { + } else { + if (!cpuFrequency) { fsbFrequency = (tscFrequency / maxcoef); - } - else - { + } else { fsbFrequency = (cpuFrequency / maxcoef); } DBG("%d\n", currcoef); } - } - else if (currcoef) - { - if (currdiv) - { + } else if (currcoef) { + if (currdiv) { fsbFrequency = ((tscFrequency * currdiv) / currcoef); DBG("%d.%d\n", currcoef / currdiv, ((currcoef % currdiv) * 100) / currdiv); - } - else - { + } else { fsbFrequency = (tscFrequency / currcoef); DBG("%d\n", currcoef); } @@ -689,15 +666,15 @@ // keep formatted with spaces instead of tabs DBG("CPU: Brand String: %s\n", p->CPU.BrandString); - DBG("CPU: Vendor/Family/ExtFamily: 0x%x/0x%x/0x%x\n", p->CPU.Vendor, p->CPU.Family, p->CPU.ExtFamily); - DBG("CPU: Model/ExtModel/Stepping: 0x%x/0x%x/0x%x\n", p->CPU.Model, p->CPU.ExtModel, p->CPU.Stepping); - DBG("CPU: MaxCoef/CurrCoef: 0x%x/0x%x\n", p->CPU.MaxCoef, p->CPU.CurrCoef); - DBG("CPU: MaxDiv/CurrDiv: 0x%x/0x%x\n", p->CPU.MaxDiv, p->CPU.CurrDiv); - DBG("CPU: TSCFreq: %dMHz\n", p->CPU.TSCFrequency / 1000000); - DBG("CPU: FSBFreq: %dMHz\n", p->CPU.FSBFrequency / 1000000); - DBG("CPU: CPUFreq: %dMHz\n", p->CPU.CPUFrequency / 1000000); - DBG("CPU: NoCores/NoThreads: %d/%d\n", p->CPU.NoCores, p->CPU.NoThreads); - DBG("CPU: Features: 0x%08x\n", p->CPU.Features); + DBG("CPU: Vendor/Family/ExtFamily: 0x%x/0x%x/0x%x\n", p->CPU.Vendor, p->CPU.Family, p->CPU.ExtFamily); + DBG("CPU: Model/ExtModel/Stepping: 0x%x/0x%x/0x%x\n", p->CPU.Model, p->CPU.ExtModel, p->CPU.Stepping); + DBG("CPU: MaxCoef/CurrCoef: 0x%x/0x%x\n", p->CPU.MaxCoef, p->CPU.CurrCoef); + DBG("CPU: MaxDiv/CurrDiv: 0x%x/0x%x\n", p->CPU.MaxDiv, p->CPU.CurrDiv); + DBG("CPU: TSCFreq: %dMHz\n", p->CPU.TSCFrequency / 1000000); + DBG("CPU: FSBFreq: %dMHz\n", p->CPU.FSBFrequency / 1000000); + DBG("CPU: CPUFreq: %dMHz\n", p->CPU.CPUFrequency / 1000000); + DBG("CPU: NoCores/NoThreads: %d/%d\n", p->CPU.NoCores, p->CPU.NoThreads); + DBG("CPU: Features: 0x%08x\n", p->CPU.Features); #if DEBUG_CPU pause(); #endif Index: branches/chucko/i386/libsaio/platform.h =================================================================== --- branches/chucko/i386/libsaio/platform.h (revision 2328) +++ branches/chucko/i386/libsaio/platform.h (revision 2329) @@ -129,12 +129,15 @@ uint8_t BankConnCnt; } RamSlotInfo_t; +//============================================================================== + typedef struct _PlatformInfo_t { struct CPU { uint32_t Features; // CPU Features like MMX, SSE2, VT, MobileCPU uint32_t Vendor; // Vendor - uint32_t Signature; // Signature + uint32_t Signature; // Processor Signature uint32_t Stepping; // Stepping + uint32_t Type; // Type uint32_t Model; // Model uint32_t ExtModel; // Extended Model uint32_t Family; // Family @@ -168,10 +171,10 @@ } RAM; struct DMI { - int MaxMemorySlots; // number of memory slots populated by SMBIOS - int CntMemorySlots; // number of memory slots counted - int MemoryModules; // number of memory modules installed - int DIMM[MAX_RAM_SLOTS]; // Information and SPD mapping for each slot + int MaxMemorySlots; // number of memory slots populated by SMBIOS + int CntMemorySlots; // number of memory slots counted + int MemoryModules; // number of memory modules installed + int DIMM[MAX_RAM_SLOTS]; // Information and SPD mapping for each slot } DMI; uint8_t Type; // System Type: 1=Desktop, 2=Portable... according ACPI2.0 (FACP: PM_Profile) Index: branches/chucko/i386/libsaio/disk.c =================================================================== --- branches/chucko/i386/libsaio/disk.c (revision 2328) +++ branches/chucko/i386/libsaio/disk.c (revision 2329) @@ -139,84 +139,103 @@ static int getDriveInfo( int biosdev, struct driveInfo *dip ) { - static struct driveInfo cached_di; - int cc; - - // Real BIOS devices are 8-bit, so anything above that is for internal use. - // Don't cache ramdisk drive info since it doesn't require several BIOS - // calls and is thus not worth it. - if(biosdev >= 0x100) - { - if(p_get_ramdisk_info != NULL) - cc = (*p_get_ramdisk_info)(biosdev, dip); - else - cc = -1; - if(cc < 0) - { - dip->valid = 0; - return -1; - } - else - return 0; - } + static struct driveInfo cached_di; + int cc; - if ( !cached_di.valid || biosdev != cached_di.biosdev ) - { - cc = get_drive_info(biosdev, &cached_di); - if (cc < 0) { - cached_di.valid = 0; - DEBUG_DISK(("get_drive_info returned error\n")); - return (-1); // BIOS call error + // Real BIOS devices are 8-bit, so anything above that is for internal use. + // Don't cache ramdisk drive info since it doesn't require several BIOS + // calls and is thus not worth it. + if (biosdev >= 0x100) + { + if (p_get_ramdisk_info != NULL) + { + cc = (*p_get_ramdisk_info)(biosdev, dip); + } + else + { + cc = -1; + } + if (cc < 0) + { + dip->valid = 0; + return -1; + } + else + { + return 0; + } } - } - bcopy(&cached_di, dip, sizeof(cached_di)); + if (!cached_di.valid || biosdev != cached_di.biosdev) + { + cc = get_drive_info(biosdev, &cached_di); - return 0; + if (cc < 0) + { + cached_di.valid = 0; + DEBUG_DISK(("get_drive_info returned error\n")); + return (-1); // BIOS call error + } + } + + bcopy(&cached_di, dip, sizeof(cached_di)); + + return 0; } //========================================================================== // Maps (E)BIOS return codes to message strings. struct NamedValue { - unsigned char value; - const char * name; + unsigned char value; + const char * name; }; +//========================================================================== + static const char * getNameForValue( const struct NamedValue * nameTable, unsigned char value ) { - const struct NamedValue * np; + const struct NamedValue * np; - for ( np = nameTable; np->value; np++) - if (np->value == value) - return np->name; + for ( np = nameTable; np->value; np++) + { + if (np->value == value) + { + return np->name; + } + } - return NULL; + return NULL; } #define ECC_CORRECTED_ERR 0x11 -static const struct NamedValue bios_errors[] = { - { 0x10, "Media error" }, - { 0x11, "Corrected ECC error" }, - { 0x20, "Controller or device error" }, - { 0x40, "Seek failed" }, - { 0x80, "Device timeout" }, - { 0xAA, "Drive not ready" }, - { 0x00, 0 } +static const struct NamedValue bios_errors[] = +{ + { 0x10, "Media error" }, + { 0x11, "Corrected ECC error" }, + { 0x20, "Controller or device error" }, + { 0x40, "Seek failed" }, + { 0x80, "Device timeout" }, + { 0xAA, "Drive not ready" }, + { 0x00, 0 } }; static const char * bios_error(int errnum) { - static char errorstr[] = "Error 0x00"; - const char * errname; + static char errorstr[] = "Error 0x00"; + const char * errname; - errname = getNameForValue( bios_errors, errnum ); - if ( errname ) return errname; + errname = getNameForValue(bios_errors, errnum); - sprintf(errorstr, "Error 0x%02x", errnum); - return errorstr; // No string, print error code only + if (errname) + { + return errname; + } + + sprintf(errorstr, "Error 0x%02x", errnum); + return errorstr; // No string, print error code only } //========================================================================== @@ -231,272 +250,283 @@ static int Biosread( int biosdev, unsigned long long secno ) { - static int xbiosdev, xcyl, xhead; - static unsigned int xsec, xnsecs; - struct driveInfo di; + static int xbiosdev, xcyl, xhead; + static unsigned int xsec, xnsecs; + struct driveInfo di; - int rc = -1; - int cyl, head, sec; - int tries = 0; - int bps, divisor; + int rc = -1; + int cyl, head, sec; + int tries = 0; + int bps, divisor; - if (getDriveInfo(biosdev, &di) < 0) { - return -1; - } - if (di.no_emulation) { - /* Always assume 2k block size; BIOS may lie about geometry */ - bps = 2048; - } else { - bps = di.di.params.phys_nbps; - if (bps == 0) { - return -1; - } - } - divisor = bps / BPS; + if (getDriveInfo(biosdev, &di) < 0) + { + return -1; + } - DEBUG_DISK(("Biosread dev %x sec %d bps %d\n", biosdev, secno, bps)); + if (di.no_emulation) + { + bps = 2048; /* Always assume 2K block size since the BIOS may lie about the geometry */ + } + else + { + bps = di.di.params.phys_nbps; - // To read the disk sectors, use EBIOS if we can. Otherwise, - // revert to the standard BIOS calls. + if (bps == 0) + { + return -1; + } + } - if ((biosdev >= kBIOSDevTypeHardDrive) && - (di.uses_ebios & EBIOS_FIXED_DISK_ACCESS)) - { - if (cache_valid && - (biosdev == xbiosdev) && - (secno >= xsec) && - ((unsigned int)secno < (xsec + xnsecs))) - { - biosbuf = trackbuf + (BPS * (secno - xsec)); - return 0; - } + divisor = bps / BPS; - xnsecs = N_CACHE_SECS; - xsec = (secno / divisor) * divisor; - cache_valid = false; + DEBUG_DISK(("Biosread dev %x sec %d bps %d\n", biosdev, secno, bps)); - while ((rc = ebiosread(biosdev, secno / divisor, xnsecs / divisor)) && (++tries < 5)) - { - if (rc == ECC_CORRECTED_ERR) { - /* Ignore corrected ECC errors */ - rc = 0; - break; - } - error(" EBIOS read error: %s\n", bios_error(rc), rc); - error(" Block 0x%x Sectors %d\n", secno, xnsecs); - sleep(1); - } - } - else - { - /* spc = spt * heads */ - int spc = (di.di.params.phys_spt * di.di.params.phys_heads); - cyl = secno / spc; - head = (secno % spc) / di.di.params.phys_spt; - sec = secno % di.di.params.phys_spt; + // To read the disk sectors, use EBIOS if we can. Otherwise, + // revert to the standard BIOS calls. - if (cache_valid && - (biosdev == xbiosdev) && - (cyl == xcyl) && - (head == xhead) && - ((unsigned int)sec >= xsec) && - ((unsigned int)sec < (xsec + xnsecs))) - { - // this sector is in trackbuf cache - biosbuf = trackbuf + (BPS * (sec - xsec)); - return 0; - } + if ((biosdev >= kBIOSDevTypeHardDrive) && (di.uses_ebios & EBIOS_FIXED_DISK_ACCESS)) + { + if (cache_valid && (biosdev == xbiosdev) && (secno >= xsec) && ((unsigned int)secno < (xsec + xnsecs))) + { + biosbuf = trackbuf + (BPS * (secno - xsec)); + return 0; + } - // Cache up to a track worth of sectors, but do not cross a - // track boundary. + xnsecs = N_CACHE_SECS; + xsec = (secno / divisor) * divisor; + cache_valid = false; - xcyl = cyl; - xhead = head; - xsec = sec; - xnsecs = ((unsigned int)(sec + N_CACHE_SECS) > di.di.params.phys_spt) ? (di.di.params.phys_spt - sec) : N_CACHE_SECS; - cache_valid = false; + while ((rc = ebiosread(biosdev, secno / divisor, xnsecs / divisor)) && (++tries < 5)) + { + if (rc == ECC_CORRECTED_ERR) + { + rc = 0; /* Ignore corrected ECC errors */ + break; + } - while ((rc = biosread(biosdev, cyl, head, sec, xnsecs)) && - (++tries < 5)) - { - if (rc == ECC_CORRECTED_ERR) { - /* Ignore corrected ECC errors */ - rc = 0; - break; - } - error(" BIOS read error: %s\n", bios_error(rc), rc); - error(" Block %d, Cyl %d Head %d Sector %d\n", - secno, cyl, head, sec); - sleep(1); - } - } + error(" EBIOS read error: %s\n", bios_error(rc), rc); + error(" Block 0x%x Sectors %d\n", secno, xnsecs); + sleep(1); + } + } - // If the BIOS reported success, mark the sector cache as valid. + else + { + /* spc = spt * heads */ + int spc = (di.di.params.phys_spt * di.di.params.phys_heads); + cyl = secno / spc; + head = (secno % spc) / di.di.params.phys_spt; + sec = secno % di.di.params.phys_spt; - if (rc == 0) { - cache_valid = true; - } - biosbuf = trackbuf + (secno % divisor) * BPS; - xbiosdev = biosdev; - - spinActivityIndicator(xnsecs); + if (cache_valid && (biosdev == xbiosdev) && (cyl == xcyl) && + (head == xhead) && ((unsigned int)sec >= xsec) && ((unsigned int)sec < (xsec + xnsecs))) - return rc; + { + // this sector is in trackbuf cache + biosbuf = trackbuf + (BPS * (sec - xsec)); + return 0; + } + + // Cache up to a track worth of sectors, but do not cross a track boundary. + + xcyl = cyl; + xhead = head; + xsec = sec; + xnsecs = ((unsigned int)(sec + N_CACHE_SECS) > di.di.params.phys_spt) ? (di.di.params.phys_spt - sec) : N_CACHE_SECS; + + cache_valid = false; + + while ((rc = biosread(biosdev, cyl, head, sec, xnsecs)) && (++tries < 5)) + { + if (rc == ECC_CORRECTED_ERR) + { + rc = 0; /* Ignore corrected ECC errors */ + break; + } + error(" BIOS read error: %s\n", bios_error(rc), rc); + error(" Block %d, Cyl %d Head %d Sector %d\n", secno, cyl, head, sec); + sleep(1); + } + } + + // If the BIOS reported success, mark the sector cache as valid. + + if (rc == 0) + { + cache_valid = true; + } + + biosbuf = trackbuf + (secno % divisor) * BPS; + xbiosdev = biosdev; + + spinActivityIndicator(xnsecs); + + return rc; } -//========================================================================== -int testBiosread( int biosdev, unsigned long long secno ) +//============================================================================== + +int testBiosread(int biosdev, unsigned long long secno) { return Biosread(biosdev, secno); } -//========================================================================== +//============================================================================== -static int readBytes( int biosdev, unsigned long long blkno, - unsigned int byteoff, - unsigned int byteCount, void * buffer ) +static int readBytes(int biosdev, unsigned long long blkno, unsigned int byteoff, unsigned int byteCount, void * buffer) { - // ramdisks require completely different code for reading. - if(p_ramdiskReadBytes != NULL && biosdev >= 0x100) - return (*p_ramdiskReadBytes)(biosdev, blkno, byteoff, byteCount, buffer); + // ramdisks require completely different code for reading. + if(p_ramdiskReadBytes != NULL && biosdev >= 0x100) + { + return (*p_ramdiskReadBytes)(biosdev, blkno, byteoff, byteCount, buffer); + } - char * cbuf = (char *) buffer; - int error; - int copy_len; + char * cbuf = (char *) buffer; + int error; + int copy_len; - DEBUG_DISK(("%s: dev %x block %x [%d] -> 0x%x...", __FUNCTION__, - biosdev, blkno, byteCount, (unsigned)cbuf)); + DEBUG_DISK(("%s: dev %x block %x [%d] -> 0x%x...", __FUNCTION__, biosdev, blkno, byteCount, (unsigned)cbuf)); - for ( ; byteCount; cbuf += copy_len, blkno++ ) - { - error = Biosread( biosdev, blkno ); - if ( error ) - { - DEBUG_DISK(("error\n")); - return (-1); - } + for (; byteCount; cbuf += copy_len, blkno++) + { + error = Biosread(biosdev, blkno); - copy_len = ((byteCount + byteoff) > BPS) ? (BPS - byteoff) : byteCount; - bcopy( biosbuf + byteoff, cbuf, copy_len ); - byteCount -= copy_len; - byteoff = 0; - } + if (error) + { + DEBUG_DISK(("error\n")); - DEBUG_DISK(("done\n")); + return (-1); + } - return 0; + copy_len = ((byteCount + byteoff) > BPS) ? (BPS - byteoff) : byteCount; + bcopy( biosbuf + byteoff, cbuf, copy_len ); + byteCount -= copy_len; + byteoff = 0; + } + + DEBUG_DISK(("done\n")); + + return 0; } -//========================================================================== +//============================================================================== static int isExtendedFDiskPartition( const struct fdisk_part * part ) { - static unsigned char extParts[] = - { - 0x05, /* Extended */ - 0x0f, /* Win95 extended */ - 0x85, /* Linux extended */ - }; + static unsigned char extParts[] = + { + 0x05, /* Extended */ + 0x0f, /* Win95 extended */ + 0x85, /* Linux extended */ + }; - unsigned int i; + unsigned int i; - for (i = 0; i < sizeof(extParts)/sizeof(extParts[0]); i++) - { - if (extParts[i] == part->systid) return 1; - } - return 0; + for (i = 0; i < sizeof(extParts)/sizeof(extParts[0]); i++) + { + if (extParts[i] == part->systid) + { + return 1; + } + } + return 0; } -//========================================================================== +//============================================================================== static int getNextFDiskPartition( int biosdev, int * partno, const struct fdisk_part ** outPart ) { - static int sBiosdev = -1; - static int sNextPartNo; - static unsigned int sFirstBase; - static unsigned int sExtBase; - static unsigned int sExtDepth; - static struct fdisk_part * sExtPart; - struct fdisk_part * part; + static int sBiosdev = -1; + static int sNextPartNo; + static unsigned int sFirstBase; + static unsigned int sExtBase; + static unsigned int sExtDepth; + static struct fdisk_part * sExtPart; + struct fdisk_part * part; - if ( sBiosdev != biosdev || *partno < 0 ) - { - // Fetch MBR. - if ( readBootSector( biosdev, DISK_BLK0, 0 ) ) return 0; + if ( sBiosdev != biosdev || *partno < 0 ) + { + // Fetch MBR. + if ( readBootSector( biosdev, DISK_BLK0, 0 ) ) + { + return 0; + } - sBiosdev = biosdev; - sNextPartNo = 0; - sFirstBase = 0; - sExtBase = 0; - sExtDepth = 0; - sExtPart = NULL; - } + sBiosdev = biosdev; + sNextPartNo = 0; + sFirstBase = 0; + sExtBase = 0; + sExtDepth = 0; + sExtPart = NULL; + } - while (1) - { - part = NULL; + while (1) + { + part = NULL; - if ( sNextPartNo < FDISK_NPART ) - { - part = (struct fdisk_part *) gBootSector->parts[sNextPartNo]; - } - else if ( sExtPart ) - { - unsigned int blkno = sExtPart->relsect + sFirstBase; + if ( sNextPartNo < FDISK_NPART ) + { + part = (struct fdisk_part *) gBootSector->parts[sNextPartNo]; + } + else if ( sExtPart ) + { + unsigned int blkno = sExtPart->relsect + sFirstBase; - // Save the block offset of the first extended partition. + // Save the block offset of the first extended partition. - if (sExtDepth == 0) { - sFirstBase = blkno; - } - sExtBase = blkno; + if (sExtDepth == 0) + { + sFirstBase = blkno; + } + sExtBase = blkno; - // Load extended partition table. + // Load extended partition table. - if ( readBootSector( biosdev, blkno, 0 ) == 0 ) - { - sNextPartNo = 0; - sExtDepth++; - sExtPart = NULL; - continue; - } - // Fall through to part == NULL - } + if ( readBootSector( biosdev, blkno, 0 ) == 0 ) + { + sNextPartNo = 0; + sExtDepth++; + sExtPart = NULL; + continue; + } + // Fall through to part == NULL + } - if ( part == NULL ) break; // Reached end of partition chain. + if ( part == NULL ) break; // Reached end of partition chain. - // Advance to next partition number. + // Advance to next partition number. - sNextPartNo++; + sNextPartNo++; - if ( isExtendedFDiskPartition(part) ) - { - sExtPart = part; - continue; - } + if ( isExtendedFDiskPartition(part) ) + { + sExtPart = part; + continue; + } - // Skip empty slots. + // Skip empty slots. - if ( part->systid == 0x00 ) - { - continue; - } + if ( part->systid == 0x00 ) + { + continue; + } - // Change relative offset to an absolute offset. - part->relsect += sExtBase; + // Change relative offset to an absolute offset. + part->relsect += sExtBase; - *outPart = part; - *partno = sExtDepth ? (int)(sExtDepth + FDISK_NPART) : sNextPartNo; + *outPart = part; + *partno = sExtDepth ? (int)(sExtDepth + FDISK_NPART) : sNextPartNo; - break; - } + break; + } - return (part != NULL); + return (part != NULL); } -//========================================================================== +//============================================================================== static BVRef newFDiskBVRef( int biosdev, int partno, unsigned int blkoff, const struct fdisk_part * part, @@ -509,63 +539,68 @@ BVFree bvFreeFunc, int probe, int type, unsigned int bvrFlags ) { - BVRef bvr = (BVRef) malloc( sizeof(*bvr) ); - if ( bvr ) - { - bzero(bvr, sizeof(*bvr)); + BVRef bvr = (BVRef) malloc( sizeof(*bvr) ); + if ( bvr ) + { + bzero(bvr, sizeof(*bvr)); - bvr->biosdev = biosdev; - bvr->part_no = partno; - bvr->part_boff = blkoff; - bvr->part_type = part->systid; - bvr->fs_loadfile = loadFunc; - bvr->fs_readfile = readFunc; - bvr->fs_getdirentry = getdirFunc; - bvr->fs_getfileblock= getBlockFunc; - bvr->fs_getuuid = getUUIDFunc; - bvr->description = getDescriptionFunc; - bvr->type = type; - bvr->bv_free = bvFreeFunc; + bvr->biosdev = biosdev; + bvr->part_no = partno; + bvr->part_boff = blkoff; + bvr->part_type = part->systid; + bvr->fs_loadfile = loadFunc; + bvr->fs_readfile = readFunc; + bvr->fs_getdirentry = getdirFunc; + bvr->fs_getfileblock= getBlockFunc; + bvr->fs_getuuid = getUUIDFunc; + bvr->description = getDescriptionFunc; + bvr->type = type; + bvr->bv_free = bvFreeFunc; - if ((part->bootid & FDISK_ACTIVE) && (part->systid == FDISK_HFS)) - bvr->flags |= kBVFlagPrimary; + if ((part->bootid & FDISK_ACTIVE) && (part->systid == FDISK_HFS)) + { + bvr->flags |= kBVFlagPrimary; + } - // Probe the filesystem. + // Probe the filesystem. - if ( initFunc ) - { - bvr->flags |= kBVFlagNativeBoot; + if ( initFunc ) + { + bvr->flags |= kBVFlagNativeBoot; - if ( probe && initFunc( bvr ) != 0 ) - { - // filesystem probe failed. + if ( probe && initFunc( bvr ) != 0 ) + { + // filesystem probe failed. - DEBUG_DISK(("%s: failed probe on dev %x part %d\n", - __FUNCTION__, biosdev, partno)); + DEBUG_DISK(("%s: failed probe on dev %x part %d\n", __FUNCTION__, biosdev, partno)); - (*bvr->bv_free)(bvr); - bvr = NULL; - } - if ( readBootSector( biosdev, blkoff, (void *)0x7e00 ) == 0 ) - { - bvr->flags |= kBVFlagBootable; - } - } - else if ( readBootSector( biosdev, blkoff, (void *)0x7e00 ) == 0 ) - { - bvr->flags |= kBVFlagForeignBoot; - } - else - { - (*bvr->bv_free)(bvr); - bvr = NULL; - } - } - if (bvr) bvr->flags |= bvrFlags; - return bvr; + (*bvr->bv_free)(bvr); + bvr = NULL; + } + + if ( readBootSector( biosdev, blkoff, (void *)0x7e00 ) == 0 ) + { + bvr->flags |= kBVFlagBootable; + } + } + else if ( readBootSector( biosdev, blkoff, (void *)0x7e00 ) == 0 ) + { + bvr->flags |= kBVFlagForeignBoot; + } + else + { + (*bvr->bv_free)(bvr); + bvr = NULL; + } + } + + if (bvr) bvr->flags |= bvrFlags; + { + return bvr; + } } -//========================================================================== +//============================================================================== BVRef newAPMBVRef( int biosdev, int partno, unsigned int blkoff, const DPME * part, @@ -578,64 +613,68 @@ BVFree bvFreeFunc, int probe, int type, unsigned int bvrFlags ) { - BVRef bvr = (BVRef) malloc( sizeof(*bvr) ); - if ( bvr ) - { - bzero(bvr, sizeof(*bvr)); + BVRef bvr = (BVRef) malloc( sizeof(*bvr) ); + if ( bvr ) + { + bzero(bvr, sizeof(*bvr)); - bvr->biosdev = biosdev; - bvr->part_no = partno; - bvr->part_boff = blkoff; - bvr->fs_loadfile = loadFunc; - bvr->fs_readfile = readFunc; - bvr->fs_getdirentry = getdirFunc; - bvr->fs_getfileblock= getBlockFunc; - bvr->fs_getuuid = getUUIDFunc; - bvr->description = getDescriptionFunc; - bvr->type = type; - bvr->bv_free = bvFreeFunc; - strlcpy(bvr->name, part->dpme_name, DPISTRLEN); - strlcpy(bvr->type_name, part->dpme_type, DPISTRLEN); + bvr->biosdev = biosdev; + bvr->part_no = partno; + bvr->part_boff = blkoff; + bvr->fs_loadfile = loadFunc; + bvr->fs_readfile = readFunc; + bvr->fs_getdirentry = getdirFunc; + bvr->fs_getfileblock= getBlockFunc; + bvr->fs_getuuid = getUUIDFunc; + bvr->description = getDescriptionFunc; + bvr->type = type; + bvr->bv_free = bvFreeFunc; + strlcpy(bvr->name, part->dpme_name, DPISTRLEN); + strlcpy(bvr->type_name, part->dpme_type, DPISTRLEN); - /* - if ( part->bootid & FDISK_ACTIVE ) - bvr->flags |= kBVFlagPrimary; - */ + /* + if ( part->bootid & FDISK_ACTIVE ) + { + bvr->flags |= kBVFlagPrimary; + } + */ - // Probe the filesystem. + // Probe the filesystem. - if ( initFunc ) - { - bvr->flags |= kBVFlagNativeBoot | kBVFlagBootable | kBVFlagSystemVolume; + if ( initFunc ) + { + bvr->flags |= kBVFlagNativeBoot | kBVFlagBootable | kBVFlagSystemVolume; - if ( probe && initFunc( bvr ) != 0 ) - { - // filesystem probe failed. + if ( probe && initFunc( bvr ) != 0 ) + { + // filesystem probe failed. - DEBUG_DISK(("%s: failed probe on dev %x part %d\n", - __FUNCTION__, biosdev, partno)); + DEBUG_DISK(("%s: failed probe on dev %x part %d\n", __FUNCTION__, biosdev, partno)); - (*bvr->bv_free)(bvr); - bvr = NULL; - } - } - /* - else if ( readBootSector( biosdev, blkoff, (void *)0x7e00 ) == 0 ) - { - bvr->flags |= kBVFlagForeignBoot; - } - */ - else - { - (*bvr->bv_free)(bvr); - bvr = NULL; - } - } - if (bvr) bvr->flags |= bvrFlags; - return bvr; + (*bvr->bv_free)(bvr); + bvr = NULL; + } + } + /* + else if ( readBootSector( biosdev, blkoff, (void *)0x7e00 ) == 0 ) + { + bvr->flags |= kBVFlagForeignBoot; + } + */ + else + { + (*bvr->bv_free)(bvr); + bvr = NULL; + } + } + if (bvr) + { + bvr->flags |= bvrFlags; + } + return bvr; } -//========================================================================== +//============================================================================== // GUID's in LE form: // HFS+ partition - 48465300-0000-11AA-AA11-00306543ECAC @@ -665,71 +704,65 @@ BVFree bvFreeFunc, int probe, int type, unsigned int bvrFlags ) { - BVRef bvr = (BVRef) malloc( sizeof(*bvr) ); - if ( bvr ) - { - bzero(bvr, sizeof(*bvr)); + BVRef bvr = (BVRef) malloc( sizeof(*bvr) ); + if ( bvr ) { + bzero(bvr, sizeof(*bvr)); - bvr->biosdev = biosdev; - bvr->part_no = partno; - bvr->part_boff = blkoff; - bvr->fs_loadfile = loadFunc; - bvr->fs_readfile = readFunc; - bvr->fs_getdirentry = getdirFunc; - bvr->fs_getfileblock= getBlockFunc; - bvr->fs_getuuid = getUUIDFunc; - bvr->description = getDescriptionFunc; - bvr->type = type; - bvr->bv_free = bvFreeFunc; - // FIXME: UCS-2 -> UTF-8 the name - strlcpy(bvr->name, "----", DPISTRLEN); - if ( (efi_guid_compare(&GPT_BOOT_GUID, (EFI_GUID const*)part->ent_type) == 0) || - (efi_guid_compare(&GPT_HFS_GUID, (EFI_GUID const*)part->ent_type) == 0) ) - strlcpy(bvr->type_name, "GPT HFS+", DPISTRLEN); - else - strlcpy(bvr->type_name, "GPT Unknown", DPISTRLEN); + bvr->biosdev = biosdev; + bvr->part_no = partno; + bvr->part_boff = blkoff; + bvr->fs_loadfile = loadFunc; + bvr->fs_readfile = readFunc; + bvr->fs_getdirentry = getdirFunc; + bvr->fs_getfileblock= getBlockFunc; + bvr->fs_getuuid = getUUIDFunc; + bvr->description = getDescriptionFunc; + bvr->type = type; + bvr->bv_free = bvFreeFunc; + // FIXME: UCS-2 -> UTF-8 the name + strlcpy(bvr->name, "----", DPISTRLEN); + if ( (efi_guid_compare(&GPT_BOOT_GUID, (EFI_GUID const*)part->ent_type) == 0) || (efi_guid_compare(&GPT_HFS_GUID, (EFI_GUID const*)part->ent_type) == 0) ) { + strlcpy(bvr->type_name, "GPT HFS+", DPISTRLEN); + } else { + strlcpy(bvr->type_name, "GPT Unknown", DPISTRLEN); + } - /* - if ( part->bootid & FDISK_ACTIVE ) - bvr->flags |= kBVFlagPrimary; - */ + /* + if ( part->bootid & FDISK_ACTIVE ) { + bvr->flags |= kBVFlagPrimary; + } + */ - // Probe the filesystem. + // Probe the filesystem. - if ( initFunc ) - { - bvr->flags |= kBVFlagNativeBoot; + if ( initFunc ) { + bvr->flags |= kBVFlagNativeBoot; - if ( probe && initFunc( bvr ) != 0 ) - { - // filesystem probe failed. + if ( probe && initFunc( bvr ) != 0 ) { + // filesystem probe failed. - DEBUG_DISK(("%s: failed probe on dev %x part %d\n", - __FUNCTION__, biosdev, partno)); + DEBUG_DISK(("%s: failed probe on dev %x part %d\n", __FUNCTION__, biosdev, partno)); - (*bvr->bv_free)(bvr); - bvr = NULL; - } - if ( readBootSector( biosdev, blkoff, (void *)0x7e00 ) == 0 ) - { - bvr->flags |= kBVFlagBootable; - } - } - else if ( readBootSector( biosdev, blkoff, (void *)0x7e00 ) == 0 ) - { - bvr->flags |= kBVFlagForeignBoot; - } - else - { - (*bvr->bv_free)(bvr); - bvr = NULL; - } - } - if (bvr) bvr->flags |= bvrFlags; - return bvr; + (*bvr->bv_free)(bvr); + bvr = NULL; + } + if ( readBootSector( biosdev, blkoff, (void *)0x7e00 ) == 0 ) { + bvr->flags |= kBVFlagBootable; + } + } else if ( readBootSector( biosdev, blkoff, (void *)0x7e00 ) == 0 ) { + bvr->flags |= kBVFlagForeignBoot; + } else { + (*bvr->bv_free)(bvr); + bvr = NULL; + } + } + if (bvr) { + bvr->flags |= bvrFlags; + } + return bvr; } -//========================================================================== +//============================================================================== /* A note on partition numbers: * IOKit makes the primary partitions numbers 1-4, and then @@ -751,17 +784,22 @@ struct driveInfo di; boot_drive_info_t *dp; - /* Initialize disk info */ - if (getDriveInfo(biosdev, &di) != 0) { - return NULL; - } - dp = &di.di; - spc = (dp->params.phys_spt * dp->params.phys_heads); - if (spc == 0) { - /* This is probably a CD-ROM; punt on the geometry. */ - spc = 1; - } + /* Initialize disk info */ + if (getDriveInfo(biosdev, &di) != 0) + { + return NULL; + } + + dp = &di.di; + spc = (dp->params.phys_spt * dp->params.phys_heads); + + if (spc == 0) + { + /* This is probably a CD-ROM; punt on the geometry. */ + spc = 1; + } + do { // Create a new mapping. @@ -879,7 +917,7 @@ 0, kBIOSDevTypeHardDrive, 0); break; - + case FDISK_NTFS: bvr = newFDiskBVRef( biosdev, partno, @@ -903,7 +941,7 @@ (BVFree)free, 0, kBIOSDevTypeHardDrive, 0); break; - + case FDISK_BEFS: bvr = newFDiskBVRef( biosdev, partno, @@ -936,7 +974,7 @@ (BVFree)free, 0, kBIOSDevTypeHardDrive, 0); break; - + default: bvr = newFDiskBVRef( biosdev, partno, @@ -961,386 +999,451 @@ // Booting from a CD with an UFS filesystem embedded // in a booter partition. - if ( booterUFS ) - { - if ( map->bvrcnt == 0 ) - { - map->bvr = booterUFS; - map->bvrcnt++; - } - else free( booterUFS ); - } + if ( booterUFS ) + { + if ( map->bvrcnt == 0 ) + { + map->bvr = booterUFS; + map->bvrcnt++; + } + else + { + free( booterUFS ); + } + } #endif - } - } while (0); + } + } while (0); - /* - * If no FDisk partition, then we will check for - * an Apple partition map elsewhere. - */ + /* + * If no FDisk partition, then we will check for + * an Apple partition map elsewhere. + */ #if UNUSED - if (map->bvrcnt == 0) { - static struct fdisk_part cdpart; - cdpart.systid = 0xCD; + if (map->bvrcnt == 0) + { + static struct fdisk_part cdpart; + cdpart.systid = 0xCD; - /* Let's try assuming we are on a hybrid HFS/ISO9660 CD. */ - bvr = newFDiskBVRef( - biosdev, 0, - 0, - &cdpart, - HFSInitPartition, - HFSLoadFile, - HFSReadFile, - HFSGetDirEntry, - HFSGetFileBlock, - HFSGetUUID, - 0, - kBIOSDevTypeHardDrive); - bvr->next = map->bvr; - map->bvr = bvr; - map->bvrcnt++; - } + /* Let's try assuming we are on a hybrid HFS/ISO9660 CD. */ + bvr = newFDiskBVRef( + biosdev, 0, + 0, + &cdpart, + HFSInitPartition, + HFSLoadFile, + HFSReadFile, + HFSGetDirEntry, + HFSGetFileBlock, + HFSGetUUID, + 0, + kBIOSDevTypeHardDrive); + bvr->next = map->bvr; + map->bvr = bvr; + map->bvrcnt++; + } #endif - // Actually this should always be true given the above code - if(map == gDiskBVMap) - { - // Don't leave a null map in the chain - if(map->bvrcnt == 0 && map->bvr == NULL) - { - gDiskBVMap = map->next; - free(map); - map = NULL; - } - } + // Actually this should always be true given the above code + if(map == gDiskBVMap) + { + // Don't leave a null map in the chain + if(map->bvrcnt == 0 && map->bvr == NULL) + { + gDiskBVMap = map->next; + free(map); + map = NULL; + } + } - if (countPtr) *countPtr = map ? map->bvrcnt : 0; + if (countPtr) *countPtr = map ? map->bvrcnt : 0; - return map ? map->bvr : NULL; + return map ? map->bvr : NULL; } -//========================================================================== +//============================================================================== static BVRef diskScanAPMBootVolumes( int biosdev, int * countPtr ) { - struct DiskBVMap * map; - struct Block0 *block0_p; - unsigned int blksize; - unsigned int factor; - void *buffer = malloc(BPS); + struct DiskBVMap * map; + struct Block0 *block0_p; + unsigned int blksize; + unsigned int factor; + void *buffer = malloc(BPS); - /* Check for alternate block size */ - if (readBytes( biosdev, 0, 0, BPS, buffer ) != 0) { - return NULL; - } - block0_p = buffer; - if (OSSwapBigToHostInt16(block0_p->sbSig) == BLOCK0_SIGNATURE) { - blksize = OSSwapBigToHostInt16(block0_p->sbBlkSize); - if (blksize != BPS) { - free(buffer); - buffer = malloc(blksize); - } - factor = blksize / BPS; - } else { - blksize = BPS; - factor = 1; - } - - do { - // Create a new mapping. + if (!buffer) + { + return NULL; + } - map = (struct DiskBVMap *) malloc( sizeof(*map) ); - if ( map ) - { - int error; - DPME *dpme_p = (DPME *)buffer; - UInt32 i, npart = UINT_MAX; - BVRef bvr; + /* Check for alternate block size */ + if (readBytes( biosdev, 0, 0, BPS, buffer ) != 0) + { + return NULL; + } + block0_p = buffer; + if (OSSwapBigToHostInt16(block0_p->sbSig) == BLOCK0_SIGNATURE) + { + blksize = OSSwapBigToHostInt16(block0_p->sbBlkSize); + if (blksize != BPS) + { + free(buffer); + buffer = malloc(blksize); + if (!buffer) + { + return NULL; + } + } + factor = blksize / BPS; + } + else + { + blksize = BPS; + factor = 1; + } - map->biosdev = biosdev; - map->bvr = NULL; - map->bvrcnt = 0; - map->next = gDiskBVMap; - gDiskBVMap = map; + do + { + // Create a new mapping. - for (i=0; idpme_signature) != DPME_SIGNATURE) { - break; - } + map->biosdev = biosdev; + map->bvr = NULL; + map->bvrcnt = 0; + map->next = gDiskBVMap; + gDiskBVMap = map; - if (i==0) { - npart = OSSwapBigToHostInt32(dpme_p->dpme_map_entries); - } - /* - printf("name = %s, %s%s %d -> %d [%d -> %d] {%d}\n", - dpme.dpme_name, dpme.dpme_type, (dpme.dpme_flags & DPME_FLAGS_BOOTABLE) ? "(bootable)" : "", - dpme.dpme_pblock_start, dpme.dpme_pblocks, - dpme.dpme_lblock_start, dpme.dpme_lblocks, - dpme.dpme_boot_block); - */ + for (i=0; idpme_type, "Apple_HFS") == 0) { - bvr = newAPMBVRef(biosdev, - i, - OSSwapBigToHostInt32(dpme_p->dpme_pblock_start) * factor, - dpme_p, - HFSInitPartition, - HFSLoadFile, - HFSReadFile, - HFSGetDirEntry, - HFSGetFileBlock, - HFSGetUUID, - HFSGetDescription, - HFSFree, - 0, - kBIOSDevTypeHardDrive, 0); - bvr->next = map->bvr; - map->bvr = bvr; - map->bvrcnt++; - } - } - } - } while (0); + if (error || OSSwapBigToHostInt16(dpme_p->dpme_signature) != DPME_SIGNATURE) + { + break; + } - free(buffer); + if (i==0) + { + npart = OSSwapBigToHostInt32(dpme_p->dpme_map_entries); + } + /* + printf("name = %s, %s%s %d -> %d [%d -> %d] {%d}\n", + dpme.dpme_name, dpme.dpme_type, (dpme.dpme_flags & DPME_FLAGS_BOOTABLE) ? "(bootable)" : "", + dpme.dpme_pblock_start, dpme.dpme_pblocks, + dpme.dpme_lblock_start, dpme.dpme_lblocks, + dpme.dpme_boot_block); + */ - if (countPtr) *countPtr = map ? map->bvrcnt : 0; + if (strcmp(dpme_p->dpme_type, "Apple_HFS") == 0) + { + bvr = newAPMBVRef(biosdev, + i, + OSSwapBigToHostInt32(dpme_p->dpme_pblock_start) * factor, + dpme_p, + HFSInitPartition, + HFSLoadFile, + HFSReadFile, + HFSGetDirEntry, + HFSGetFileBlock, + HFSGetUUID, + HFSGetDescription, + HFSFree, + 0, + kBIOSDevTypeHardDrive, 0); + bvr->next = map->bvr; + map->bvr = bvr; + map->bvrcnt++; + } + } + } + } while (0); - return map ? map->bvr : NULL; + free(buffer); + + if (countPtr) *countPtr = map ? map->bvrcnt : 0; + + return map ? map->bvr : NULL; } -//========================================================================== +//============================================================================== -// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - /* * Trying to figure out the filsystem type of a given partition. */ static int probeFileSystem(int biosdev, unsigned int blkoff) { - // detected filesystem type; - int result = -1; - int fatbits; + // detected filesystem type; + int result = -1; + int fatbits; - // Allocating buffer for 4 sectors. - const void * probeBuffer = malloc(PROBEFS_SIZE); - if (probeBuffer == NULL) - goto exit; + // Allocating buffer for 4 sectors. + const void * probeBuffer = malloc(PROBEFS_SIZE); + if (probeBuffer == NULL) + { + goto exit; + } - // Reading first 4 sectors of current partition - int error = readBytes(biosdev, blkoff, 0, PROBEFS_SIZE, (void *)probeBuffer); - if (error) - goto exit; + // Reading first 4 sectors of current partition + int error = readBytes(biosdev, blkoff, 0, PROBEFS_SIZE, (void *)probeBuffer); - if (HFSProbe(probeBuffer)) - result = FDISK_HFS; - else if (EX2Probe(probeBuffer)) - result = FDISK_LINUX; - else if (FreeBSDProbe(probeBuffer)) - result = FDISK_FREEBSD; - else if (OpenBSDProbe(probeBuffer)) - result = FDISK_OPENBSD; - else if (NTFSProbe(probeBuffer)) - result = FDISK_NTFS; - else if (BeFSProbe(probeBuffer)) - result = FDISK_BEFS; - else if ( (fatbits = MSDOSProbe(probeBuffer)) ) - { - switch (fatbits) - { - case 32: - default: - result = FDISK_FAT32; - break; - case 16: - result = FDISK_DOS16B; - break; - case 12: - result = FDISK_DOS12; - break; - } - } - else - // Couldn't detect filesystem type - result = 0; - + if (error) + { + goto exit; + } + + if (HFSProbe(probeBuffer)) + { + result = FDISK_HFS; + } + else if (EX2Probe(probeBuffer)) + { + result = FDISK_LINUX; + } + else if (FreeBSDProbe(probeBuffer)) + { + result = FDISK_FREEBSD; + } + + else if (OpenBSDProbe(probeBuffer)) + { + result = FDISK_OPENBSD; + } + + else if (BeFSProbe(probeBuffer)) + { + result = FDISK_BEFS; + } + + else if (NTFSProbe(probeBuffer)) + { + result = FDISK_NTFS; + } + + else if ( (fatbits = MSDOSProbe(probeBuffer)) ) + { + switch (fatbits) + { + case 32: + default: + result = FDISK_FAT32; + break; + case 16: + result = FDISK_DOS16B; + break; + case 12: + result = FDISK_DOS12; + break; + } + } + else + { + // Couldn't detect filesystem type + result = 0; + } + exit: - if (probeBuffer != NULL) free((void *)probeBuffer); - return result; + if (probeBuffer != NULL) free((void *)probeBuffer); + { + return result; + } } +//============================================================================== + static bool isPartitionUsed(gpt_ent * partition) { - // - // Ask whether the given partition is used. - // - return efi_guid_is_null((EFI_GUID const*)partition->ent_type) ? false : true; + // Ask whether the given partition is used. + + return efi_guid_is_null((EFI_GUID const*)partition->ent_type) ? false : true; } -// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - +//============================================================================== -static BVRef diskScanGPTBootVolumes( int biosdev, int * countPtr ) +static BVRef diskScanGPTBootVolumes(int biosdev, int * countPtr) { - struct DiskBVMap * map = NULL; - void *buffer = malloc(BPS); - int error; - if ( (error = readBytes( biosdev, /*secno*/0, 0, BPS, buffer )) != 0) { - verbose("Failed to read boot sector from BIOS device %02xh. Error=%d\n", biosdev, error); - goto scanErr; - } - struct REAL_disk_blk0 *fdiskMap = buffer; - if ( OSSwapLittleToHostInt16(fdiskMap->signature) != DISK_SIGNATURE ) - { - verbose("Failed to find boot signature on BIOS device %02xh\n", biosdev); - goto scanErr; - } + struct DiskBVMap *map = NULL; - int fdiskID = 0; - unsigned index; - for ( index = 0; index < FDISK_NPART; index++ ) - { - if ( fdiskMap->parts[index].systid ) - { - if ( fdiskMap->parts[index].systid == 0xEE ) - { - // Fail if two 0xEE partitions are present which - // means the FDISK code will wind up parsing it. - if ( fdiskID ) goto scanErr; + void *buffer = malloc(BPS); - fdiskID = index + 1; - } - } - } + int error; + if ( (error = readBytes( biosdev, /*secno*/0, 0, BPS, buffer )) != 0) + { + verbose("Failed to read boot sector from BIOS device %02xh. Error=%d\n", biosdev, error); + goto scanErr; + } + struct REAL_disk_blk0 *fdiskMap = buffer; + if ( OSSwapLittleToHostInt16(fdiskMap->signature) != DISK_SIGNATURE ) + { + verbose("Failed to find boot signature on BIOS device %02xh\n", biosdev); + goto scanErr; + } - if ( fdiskID == 0 ) goto scanErr; - verbose("Attempting to read GPT\n"); + int fdiskID = 0; + unsigned index; + for ( index = 0; index < FDISK_NPART; index++ ) + { + if ( fdiskMap->parts[index].systid ) + { + if ( fdiskMap->parts[index].systid == 0xEE ) + { + // Fail if two 0xEE partitions are present which + // means the FDISK code will wind up parsing it. + if ( fdiskID ) + { + goto scanErr; + } - if(readBytes(biosdev, 1, 0, BPS, buffer) != 0) - goto scanErr; - - gpt_hdr *headerMap = buffer; + fdiskID = index + 1; + } + } + } - // Determine whether the partition header signature is present. + if ( fdiskID == 0 ) + { + goto scanErr; + } - if ( memcmp(headerMap->hdr_sig, GPT_HDR_SIG, strlen(GPT_HDR_SIG)) ) - { - goto scanErr; - } + verbose("Attempting to read GPT\n"); - // Determine whether the partition header size is valid. + if(readBytes(biosdev, 1, 0, BPS, buffer) != 0) + { + goto scanErr; + } - UInt32 headerCheck = OSSwapLittleToHostInt32(headerMap->hdr_crc_self); - UInt32 headerSize = OSSwapLittleToHostInt32(headerMap->hdr_size); + gpt_hdr *headerMap = buffer; - if ( headerSize < offsetof(gpt_hdr, padding) ) - { - goto scanErr; - } + // Determine whether the partition header signature is present. - if ( headerSize > BPS ) - { - goto scanErr; - } + if ( memcmp(headerMap->hdr_sig, GPT_HDR_SIG, strlen(GPT_HDR_SIG)) ) + { + goto scanErr; + } - // Determine whether the partition header checksum is valid. + // Determine whether the partition header size is valid. - headerMap->hdr_crc_self = 0; + UInt32 headerCheck = OSSwapLittleToHostInt32(headerMap->hdr_crc_self); + UInt32 headerSize = OSSwapLittleToHostInt32(headerMap->hdr_size); - if ( crc32(0, headerMap, headerSize) != headerCheck ) - { - goto scanErr; - } + if ( headerSize < offsetof(gpt_hdr, padding) ) + { + goto scanErr; + } - // Determine whether the partition entry size is valid. + if ( headerSize > BPS ) + { + goto scanErr; + } - UInt64 gptBlock = 0; - UInt32 gptCheck = 0; - UInt32 gptCount = 0; - UInt32 gptID = 0; - gpt_ent * gptMap = 0; - UInt32 gptSize = 0; + // Determine whether the partition header checksum is valid. - gptBlock = OSSwapLittleToHostInt64(headerMap->hdr_lba_table); - gptCheck = OSSwapLittleToHostInt32(headerMap->hdr_crc_table); - gptCount = OSSwapLittleToHostInt32(headerMap->hdr_entries); - gptSize = OSSwapLittleToHostInt32(headerMap->hdr_entsz); + headerMap->hdr_crc_self = 0; - if ( gptSize < sizeof(gpt_ent) ) - { - goto scanErr; - } + if ( crc32(0, headerMap, headerSize) != headerCheck ) + { + goto scanErr; + } - // Allocate a buffer large enough to hold one map, rounded to a media block. - free(buffer); - buffer = NULL; + // Determine whether the partition entry size is valid. - UInt32 bufferSize = IORound(gptCount * gptSize, BPS); - if(bufferSize == 0) - goto scanErr; - buffer = malloc(bufferSize); + UInt64 gptBlock = 0; + UInt32 gptCheck = 0; + UInt32 gptCount = 0; + UInt32 gptID = 0; + gpt_ent * gptMap = 0; + UInt32 gptSize = 0; - if(readBytes(biosdev, gptBlock, 0, bufferSize, buffer) != 0) - goto scanErr; + gptBlock = OSSwapLittleToHostInt64(headerMap->hdr_lba_table); + gptCheck = OSSwapLittleToHostInt32(headerMap->hdr_crc_table); + gptCount = OSSwapLittleToHostInt32(headerMap->hdr_entries); + gptSize = OSSwapLittleToHostInt32(headerMap->hdr_entsz); - verbose("Read GPT\n"); + if ( gptSize < sizeof(gpt_ent) ) + { + goto scanErr; + } - // Allocate a new map for this BIOS device and insert it into the chain - map = malloc(sizeof(*map)); - map->biosdev = biosdev; - map->bvr = NULL; - map->bvrcnt = 0; - map->next = gDiskBVMap; - gDiskBVMap = map; + // Allocate a buffer large enough to hold one map, rounded to a media block. + free(buffer); + buffer = NULL; - // fdisk like partition type id. - int fsType = 0; - - for(gptID = 1; gptID <= gptCount; ++gptID) - { - BVRef bvr = NULL; - unsigned int bvrFlags = 0; - - // size on disk can be larger than sizeof(gpt_ent) - gptMap = (gpt_ent *) ( buffer + ( (gptID - 1) * gptSize) ); + UInt32 bufferSize = IORound(gptCount * gptSize, BPS); + if (bufferSize == 0) + { + goto scanErr; + } + buffer = malloc(bufferSize); + if (!buffer) + { + goto scanErr; + } - // NOTE: EFI_GUID's are in LE and we know we're on an x86. - // The IOGUIDPartitionScheme.cpp code uses byte-based UUIDs, we don't. + if (readBytes(biosdev, gptBlock, 0, bufferSize, buffer) != 0) + { + goto scanErr; + } + verbose("Read GPT\n"); - if (isPartitionUsed(gptMap)) - { - char stringuuid[100]; - efi_guid_unparse_upper((EFI_GUID*)gptMap->ent_type, stringuuid); - verbose("Reading GPT partition %d, type %s\n", gptID, stringuuid); + // Allocate a new map for this BIOS device and insert it into the chain + map = malloc(sizeof(*map)); + if (!map) + { + goto scanErr; + } + map->biosdev = biosdev; + map->bvr = NULL; + map->bvrcnt = 0; + map->next = gDiskBVMap; + gDiskBVMap = map; - // Getting fdisk like partition type. - fsType = probeFileSystem(biosdev, gptMap->ent_lba_start); + // fdisk like partition type id. + int fsType = 0; - if ( (efi_guid_compare(&GPT_BOOT_GUID, (EFI_GUID const*)gptMap->ent_type) == 0) || - (efi_guid_compare(&GPT_HFS_GUID, (EFI_GUID const*)gptMap->ent_type) == 0) ) - { - bvrFlags = (efi_guid_compare(&GPT_BOOT_GUID, (EFI_GUID const*)gptMap->ent_type) == 0) ? kBVFlagBooter : 0; - bvr = newGPTBVRef(biosdev, - gptID, - gptMap->ent_lba_start, - gptMap, - HFSInitPartition, - HFSLoadFile, - HFSReadFile, - HFSGetDirEntry, - HFSGetFileBlock, - HFSGetUUID, - HFSGetDescription, - HFSFree, - 0, - kBIOSDevTypeHardDrive, bvrFlags); - } + for(gptID = 1; gptID <= gptCount; ++gptID) { + BVRef bvr = NULL; + unsigned int bvrFlags = 0; + // size on disk can be larger than sizeof(gpt_ent) + gptMap = (gpt_ent *) ( buffer + ( (gptID - 1) * gptSize) ); + + // NOTE: EFI_GUID's are in LE and we know we're on an x86. + // The IOGUIDPartitionScheme.cpp code uses byte-based UUIDs, we don't. + + if (isPartitionUsed(gptMap)) { + char stringuuid[100]; + efi_guid_unparse_upper((EFI_GUID*)gptMap->ent_type, stringuuid); + verbose("Reading GPT partition %d, type %s\n", gptID, stringuuid); + + // Getting fdisk like partition type. + fsType = probeFileSystem(biosdev, gptMap->ent_lba_start); + + if ( (efi_guid_compare(&GPT_BOOT_GUID, (EFI_GUID const*)gptMap->ent_type) == 0) || (efi_guid_compare(&GPT_HFS_GUID, (EFI_GUID const*)gptMap->ent_type) == 0) ) { + bvrFlags = (efi_guid_compare(&GPT_BOOT_GUID, (EFI_GUID const*)gptMap->ent_type) == 0) ? kBVFlagBooter : 0; + bvr = newGPTBVRef(biosdev, + gptID, + gptMap->ent_lba_start, + gptMap, + HFSInitPartition, + HFSLoadFile, + HFSReadFile, + HFSGetDirEntry, + HFSGetFileBlock, + HFSGetUUID, + HFSGetDescription, + HFSFree, + 0, + kBIOSDevTypeHardDrive, bvrFlags); + } + // zef - foreign OS support if ( (efi_guid_compare(&GPT_BASICDATA_GUID, (EFI_GUID const*)gptMap->ent_type) == 0) || - (efi_guid_compare(&GPT_BASICDATA2_GUID, (EFI_GUID const*)gptMap->ent_type) == 0) ) - { + (efi_guid_compare(&GPT_BASICDATA2_GUID, (EFI_GUID const*)gptMap->ent_type) == 0) ) { switch (fsType) { case FDISK_NTFS: @@ -1364,198 +1467,188 @@ } - // turbo - save our booter partition - // zef - only on original boot device - if ( (efi_guid_compare(&GPT_EFISYS_GUID, (EFI_GUID const*)gptMap->ent_type) == 0) ) - { - switch (fsType) - { - case FDISK_HFS: - if (readBootSector( biosdev, gptMap->ent_lba_start, (void *)0x7e00 ) == 0) - { - bvr = newGPTBVRef(biosdev, gptID, gptMap->ent_lba_start, gptMap, - HFSInitPartition, - HFSLoadFile, - HFSReadFile, - HFSGetDirEntry, - HFSGetFileBlock, - HFSGetUUID, - HFSGetDescription, - HFSFree, - 0, kBIOSDevTypeHardDrive, kBVFlagEFISystem); - } - break; + // turbo - save our booter partition + // zef - only on original boot device + if ( (efi_guid_compare(&GPT_EFISYS_GUID, (EFI_GUID const*)gptMap->ent_type) == 0) ) { + switch (fsType) { + case FDISK_HFS: + if (readBootSector( biosdev, gptMap->ent_lba_start, (void *)0x7e00 ) == 0) { + bvr = newGPTBVRef(biosdev, gptID, gptMap->ent_lba_start, gptMap, + HFSInitPartition, + HFSLoadFile, + HFSReadFile, + HFSGetDirEntry, + HFSGetFileBlock, + HFSGetUUID, + HFSGetDescription, + HFSFree, + 0, kBIOSDevTypeHardDrive, kBVFlagEFISystem); + } + break; - case FDISK_FAT32: - if (testFAT32EFIBootSector( biosdev, gptMap->ent_lba_start, (void *)0x7e00 ) == 0) - { - bvr = newGPTBVRef(biosdev, gptID, gptMap->ent_lba_start, gptMap, - MSDOSInitPartition, - MSDOSLoadFile, - MSDOSReadFile, - MSDOSGetDirEntry, - MSDOSGetFileBlock, - MSDOSGetUUID, - MSDOSGetDescription, - MSDOSFree, - 0, kBIOSDevTypeHardDrive, kBVFlagEFISystem); - } - break; + case FDISK_FAT32: + if (testFAT32EFIBootSector( biosdev, gptMap->ent_lba_start, (void *)0x7e00 ) == 0) { + bvr = newGPTBVRef(biosdev, gptID, gptMap->ent_lba_start, gptMap, + MSDOSInitPartition, + MSDOSLoadFile, + MSDOSReadFile, + MSDOSGetDirEntry, + MSDOSGetFileBlock, + MSDOSGetUUID, + MSDOSGetDescription, + MSDOSFree, + 0, kBIOSDevTypeHardDrive, kBVFlagEFISystem); + } + break; - if (biosdev == gBIOSDev) - gBIOSBootVolume = bvr; - } - } + default: + if (biosdev == gBIOSDev) { + gBIOSBootVolume = bvr; + } + break; + } + } - if (bvr) - { - // Fixup bvr with the fake fdisk partition type. - if (fsType > 0) bvr->part_type = fsType; + if (bvr) + { + // Fixup bvr with the fake fdisk partition type. + if (fsType > 0) { + bvr->part_type = fsType; + } - bvr->next = map->bvr; - map->bvr = bvr; - ++map->bvrcnt; - } + bvr->next = map->bvr; + map->bvr = bvr; + ++map->bvrcnt; + } - } - } + } + } -scanErr: - free(buffer); + scanErr: + if (buffer) { + free(buffer); + } - if(map) - { - if(countPtr) *countPtr = map->bvrcnt; - return map->bvr; - } - else - { - if(countPtr) *countPtr = 0; - return NULL; - } + if(map) { + if(countPtr) *countPtr = map->bvrcnt; + { + return map->bvr; + } + + } else { + if(countPtr) *countPtr = 0; + { + return NULL; + } + } } +//============================================================================== + static bool getOSVersion(BVRef bvr, char *str) { bool valid = false; config_file_t systemVersion; char dirSpec[512]; - + sprintf(dirSpec, "hd(%d,%d)/System/Library/CoreServices/SystemVersion.plist", BIOS_DEV_UNIT(bvr), bvr->part_no); - if (!loadConfigFile(dirSpec, &systemVersion)) - { + if (!loadConfigFile(dirSpec, &systemVersion)) { valid = true; - } - else - { + } else { sprintf(dirSpec, "hd(%d,%d)/System/Library/CoreServices/ServerVersion.plist", BIOS_DEV_UNIT(bvr), bvr->part_no); - + if (!loadConfigFile(dirSpec, &systemVersion)) { - bvr->OSisServer = true; + bvr->OSisServer = true; valid = true; - } + } } - if (valid) - { + if (valid) { const char *val; int len; - if (getValueForKey(kProductVersion, &val, &len, &systemVersion)) - { + if (getValueForKey(kProductVersion, &val, &len, &systemVersion)) { // getValueForKey uses const char for val // so copy it and trim *str = '\0'; strncat(str, val, MIN(len, 4)); + } else { + valid = false; } - else - valid = false; } - if(!valid) - { + if(!valid) { int fh = -1; sprintf(dirSpec, "hd(%d,%d)/.PhysicalMediaInstall", BIOS_DEV_UNIT(bvr), bvr->part_no); fh = open(dirSpec, 0); - - if (fh >= 0) - { + + if (fh >= 0) { valid = true; bvr->OSisInstaller = true; strcpy(bvr->OSVersion, "10.7"); // 10.7 + - } - else - { + } else { close(fh); } } - return valid; } -//========================================================================== +//============================================================================== static void scanFSLevelBVRSettings(BVRef chain) { - BVRef bvr; - char dirSpec[512], fileSpec[512]; - char label[BVSTRLEN]; - int ret; - long flags, time; - int fh, fileSize, error; + BVRef bvr; + char dirSpec[512], fileSpec[512]; + char label[BVSTRLEN]; + int ret; + long flags, time; + int fh, fileSize, error; - for (bvr = chain; bvr; bvr = bvr->next) - { - ret = -1; - error = 0; + for (bvr = chain; bvr; bvr = bvr->next) { + ret = -1; + error = 0; - // - // Check for alternate volume label on boot helper partitions. - // - if (bvr->flags & kBVFlagBooter) - { - sprintf(dirSpec, "hd(%d,%d)/System/Library/CoreServices/", BIOS_DEV_UNIT(bvr), bvr->part_no); - strcpy(fileSpec, ".disk_label.contentDetails"); - ret = GetFileInfo(dirSpec, fileSpec, &flags, &time); - if (!ret) - { - fh = open(strcat(dirSpec, fileSpec), 0); - fileSize = file_size(fh); - if (fileSize > 0 && fileSize < BVSTRLEN) - { - if (read(fh, label, fileSize) != fileSize) - error = -1; - } - else - error = -1; + // + // Check for alternate volume label on boot helper partitions. + // + if (bvr->flags & kBVFlagBooter) { + sprintf(dirSpec, "hd(%d,%d)/System/Library/CoreServices/", BIOS_DEV_UNIT(bvr), bvr->part_no); + strcpy(fileSpec, ".disk_label.contentDetails"); + ret = GetFileInfo(dirSpec, fileSpec, &flags, &time); + if (!ret) { + fh = open(strcat(dirSpec, fileSpec), 0); + fileSize = file_size(fh); + if (fileSize > 0 && fileSize < BVSTRLEN) { + if (read(fh, label, fileSize) != fileSize) { + error = -1; + } + } else { + error = -1; + } - close(fh); + close(fh); - if (!error) - { - label[fileSize] = '\0'; - strcpy(bvr->altlabel, label); - } - } - } + if (!error) { + label[fileSize] = '\0'; + strcpy(bvr->altlabel, label); + } + } + } - // - // Check for SystemVersion.plist or ServerVersion.plist - // to determine if a volume hosts an installed system. - // - if (bvr->flags & kBVFlagNativeBoot) - { - if (getOSVersion(bvr,bvr->OSVersion) == true) - { - bvr->flags |= kBVFlagSystemVolume; - } - } + // Check for SystemVersion.plist or ServerVersion.plist to determine if a volume hosts an installed system. - } + if (bvr->flags & kBVFlagNativeBoot) { + if (getOSVersion(bvr,bvr->OSVersion) == true) { + bvr->flags |= kBVFlagSystemVolume; + } + } + } } +//============================================================================== + void rescanBIOSDevice(int biosdev) { struct DiskBVMap *oldMap = diskResetBootVolumes(biosdev); @@ -1565,225 +1658,261 @@ scanBootVolumes(biosdev, 0); } +//============================================================================== + struct DiskBVMap* diskResetBootVolumes(int biosdev) { - struct DiskBVMap * map; - struct DiskBVMap *prevMap = NULL; - for ( map = gDiskBVMap; map; prevMap = map, map = map->next ) { - if ( biosdev == map->biosdev ) { - break; - } - } - if(map != NULL) - { - verbose("Resetting BIOS device %xh\n", biosdev); - // Reset the biosbuf cache - cache_valid = false; - if(map == gDiskBVMap) - gDiskBVMap = map->next; - else if(prevMap != NULL) - prevMap->next = map->next; - else - stop(""); - } - // Return the old map, either to be freed, or reinserted later - return map; + struct DiskBVMap * map; + struct DiskBVMap *prevMap = NULL; + for ( map = gDiskBVMap; map; prevMap = map, map = map->next ) { + if ( biosdev == map->biosdev ) { + break; + } + } + + if(map != NULL) { + verbose("Resetting BIOS device %xh\n", biosdev); + // Reset the biosbuf cache + cache_valid = false; + if(map == gDiskBVMap) { + gDiskBVMap = map->next; + } else if(prevMap != NULL) { + prevMap->next = map->next; + } else { + stop(""); + } + } + // Return the old map, either to be freed, or reinserted later + return map; } +//============================================================================== + // Frees a DiskBVMap and all of its BootVolume's void diskFreeMap(struct DiskBVMap *map) { - if(map != NULL) - { - while(map->bvr != NULL) - { - BVRef bvr = map->bvr; - map->bvr = bvr->next; - (*bvr->bv_free)(bvr); - } - free(map); - } + if(map != NULL) + { + while(map->bvr != NULL) + { + BVRef bvr = map->bvr; + map->bvr = bvr->next; + (*bvr->bv_free)(bvr); + } + + free(map); + } } -BVRef diskScanBootVolumes( int biosdev, int * countPtr ) +//============================================================================== + +BVRef diskScanBootVolumes(int biosdev, int * countPtr) { - struct DiskBVMap * map; - BVRef bvr; - int count = 0; + struct DiskBVMap *map; + BVRef bvr; + int count = 0; - // Find an existing mapping for this device. + // Find an existing mapping for this device. - for ( map = gDiskBVMap; map; map = map->next ) { - if ( biosdev == map->biosdev ) { - count = map->bvrcnt; - break; - } - } + for (map = gDiskBVMap; map; map = map->next) + { + if (biosdev == map->biosdev) + { + count = map->bvrcnt; + break; + } + } - if (map == NULL) { - bvr = diskScanGPTBootVolumes(biosdev, &count); - if (bvr == NULL) { - bvr = diskScanFDiskBootVolumes(biosdev, &count); - } - if (bvr == NULL) { - bvr = diskScanAPMBootVolumes(biosdev, &count); - } - if (bvr) - { - scanFSLevelBVRSettings(bvr); - } - } else { - bvr = map->bvr; - } - if (countPtr) *countPtr += count; - return bvr; + if (map == NULL) + { + bvr = diskScanGPTBootVolumes(biosdev, &count); + if (bvr == NULL) + { + bvr = diskScanFDiskBootVolumes(biosdev, &count); + } + if (bvr == NULL) + { + bvr = diskScanAPMBootVolumes(biosdev, &count); + } + if (bvr) + { + scanFSLevelBVRSettings(bvr); + } + } + else + { + bvr = map->bvr; + } + if (countPtr) + { + *countPtr += count; + } + return bvr; } +//============================================================================== + BVRef getBVChainForBIOSDev(int biosdev) { - BVRef chain = NULL; - struct DiskBVMap * map = NULL; + BVRef chain = NULL; + struct DiskBVMap * map = NULL; - for (map = gDiskBVMap; map; map = map->next) - { - if (map->biosdev == biosdev) - { - chain = map->bvr; - break; - } - } - - return chain; + for (map = gDiskBVMap; map; map = map->next) + { + if (map->biosdev == biosdev) + { + chain = map->bvr; + break; + } + } + + return chain; } +//============================================================================== + BVRef newFilteredBVChain(int minBIOSDev, int maxBIOSDev, unsigned int allowFlags, unsigned int denyFlags, int *count) { - BVRef chain = NULL; - BVRef bvr = NULL; - BVRef newBVR = NULL; - BVRef prevBVR = NULL; + BVRef chain = NULL; + BVRef bvr = NULL; + BVRef newBVR = NULL; + BVRef prevBVR = NULL; - struct DiskBVMap * map = NULL; - int bvCount = 0; + struct DiskBVMap * map = NULL; + int bvCount = 0; - const char *raw = 0; - char* val = 0; - int len; + const char *raw = 0; + char* val = 0; + int len; - getValueForKey(kHidePartition, &raw, &len, &bootInfo->chameleonConfig); - if(raw) - { - val = XMLDecode(raw); - } + getValueForKey(kHidePartition, &raw, &len, &bootInfo->chameleonConfig); + if(raw) + { + val = XMLDecode(raw); + } - /* - * Traverse gDISKBVmap to get references for - * individual bvr chains of each drive. - */ - for (map = gDiskBVMap; map; map = map->next) - { - for (bvr = map->bvr; bvr; bvr = bvr->next) - { - /* - * Save the last bvr. - */ - if (newBVR) prevBVR = newBVR; + /* + * Traverse gDISKBVmap to get references for + * individual bvr chains of each drive. + */ + for (map = gDiskBVMap; map; map = map->next) + { + for (bvr = map->bvr; bvr; bvr = bvr->next) + { + /* + * Save the last bvr. + */ + if (newBVR) + { + prevBVR = newBVR; + } - /* - * Allocate and copy the matched bvr entry into a new one. - */ - newBVR = (BVRef) malloc(sizeof(*newBVR)); - bcopy(bvr, newBVR, sizeof(*newBVR)); + /* + * Allocate and copy the matched bvr entry into a new one. + */ + newBVR = (BVRef) malloc(sizeof(*newBVR)); + if (!newBVR) + { + continue; + } + bcopy(bvr, newBVR, sizeof(*newBVR)); - /* - * Adjust the new bvr's fields. - */ - newBVR->next = NULL; - newBVR->filtered = true; + /* + * Adjust the new bvr's fields. + */ + newBVR->next = NULL; + newBVR->filtered = true; - if ( (!allowFlags || newBVR->flags & allowFlags) - && (!denyFlags || !(newBVR->flags & denyFlags) ) - && (newBVR->biosdev >= minBIOSDev && newBVR->biosdev <= maxBIOSDev) - ) - newBVR->visible = true; - - /* - * Looking for "Hide Partition" entries in 'hd(x,y)|uuid|"label" hd(m,n)|uuid|"label"' format, - * to be able to hide foreign partitions from the boot menu. - * - */ - if ( (newBVR->flags & kBVFlagForeignBoot) ) - { - char *start, *next = val; - long len = 0; - do - { - start = strbreak(next, &next, &len); - if(len && matchVolumeToString(newBVR, start, len) ) - newBVR->visible = false; - } - while ( next && *next ); - } + if ( (!allowFlags || newBVR->flags & allowFlags) + && (!denyFlags || !(newBVR->flags & denyFlags) ) + && (newBVR->biosdev >= minBIOSDev && newBVR->biosdev <= maxBIOSDev) + ) { + newBVR->visible = true; + } - /* - * Use the first bvr entry as the starting chain pointer. - */ - if (!chain) - chain = newBVR; + /* + * Looking for "Hide Partition" entries in 'hd(x,y)|uuid|"label" hd(m,n)|uuid|"label"' format, + * to be able to hide foreign partitions from the boot menu. + * + */ + if ( (newBVR->flags & kBVFlagForeignBoot) ) { + char *start, *next = val; + long len = 0; + do + { + start = strbreak(next, &next, &len); + if(len && matchVolumeToString(newBVR, start, len) ) + { + newBVR->visible = false; + } + } + while ( next && *next ); + } - /* - * Update the previous bvr's link pointer to use the new memory area. - */ - if (prevBVR) - prevBVR->next = newBVR; - - if (newBVR->visible) - bvCount++; - } - } + /* + * Use the first bvr entry as the starting chain pointer. + */ + if (!chain) { + chain = newBVR; + } + /* + * Update the previous bvr's link pointer to use the new memory area. + */ + if (prevBVR) { + prevBVR->next = newBVR; + } + + if (newBVR->visible) { + bvCount++; + } + } + } + #if DEBUG //Azi: warning - too big for boot-log.. far too big.. i mean HUGE!! :P - for (bvr = chain; bvr; bvr = bvr->next) - { - printf(" bvr: %d, dev: %d, part: %d, flags: %d, vis: %d\n", bvr, bvr->biosdev, bvr->part_no, bvr->flags, bvr->visible); - } - printf("count: %d\n", bvCount); - getchar(); + for (bvr = chain; bvr; bvr = bvr->next) + { + printf(" bvr: %d, dev: %d, part: %d, flags: %d, vis: %d\n", bvr, bvr->biosdev, bvr->part_no, bvr->flags, bvr->visible); + } + printf("count: %d\n", bvCount); + getchar(); #endif - *count = bvCount; - - free(val); - return chain; + *count = bvCount; + + free(val); + return chain; } +//============================================================================== + int freeFilteredBVChain(const BVRef chain) { - int ret = 1; - BVRef bvr = chain; - BVRef nextBVR = NULL; + int ret = 1; + BVRef bvr = chain; + BVRef nextBVR = NULL; - while (bvr) - { - nextBVR = bvr->next; + while (bvr) + { + nextBVR = bvr->next; - if (bvr->filtered) - { - free(bvr); - } - else - { - ret = 0; - break; - } + if (bvr->filtered) + { + free(bvr); + } + else + { + ret = 0; + break; + } - bvr = nextBVR; - } - - return ret; + bvr = nextBVR; + } + + return ret; } -//========================================================================== +//============================================================================== static const struct NamedValue fdiskTypes[] = { @@ -1805,41 +1934,53 @@ { 0x00, 0 } /* must be last */ }; -//========================================================================== +//============================================================================== bool matchVolumeToString( BVRef bvr, const char* match, long matchLen) { char testStr[128]; if ( !bvr || !match || !*match) + { return 0; - + } + if ( bvr->biosdev < 0x80 || bvr->biosdev >= 0x100 ) + { return 0; - - // Try to match hd(x,y) first. - sprintf(testStr, "hd(%d,%d)", BIOS_DEV_UNIT(bvr), bvr->part_no); - if ( matchLen ? !strncmp(match, testStr, matchLen) : !strcmp(match, testStr) ) - return true; - - // Try to match volume UUID. - if ( bvr->fs_getuuid && bvr->fs_getuuid(bvr, testStr) == 0) - { - if( matchLen ? !strncmp(match, testStr, matchLen) : !strcmp(match, testStr) ) - return true; - } - - // Try to match volume label (always quoted). - if ( bvr->description ) - { - bvr->description(bvr, testStr, sizeof(testStr)-1); - if( matchLen ? !strncmp(match, testStr, matchLen) : !strcmp(match, testStr) ) - return true; - } - - return false; + } + + // Try to match hd(x,y) first. + sprintf(testStr, "hd(%d,%d)", BIOS_DEV_UNIT(bvr), bvr->part_no); + if ( matchLen ? !strncmp(match, testStr, matchLen) : !strcmp(match, testStr) ) + { + return true; + } + + // Try to match volume UUID. + if ( bvr->fs_getuuid && bvr->fs_getuuid(bvr, testStr) == 0) + { + if ( matchLen ? !strncmp(match, testStr, matchLen) : !strcmp(match, testStr) ) + { + return true; + } + } + + // Try to match volume label (always quoted). + if ( bvr->description ) + { + bvr->description(bvr, testStr, sizeof(testStr)-1); + if ( matchLen ? !strncmp(match, testStr, matchLen) : !strcmp(match, testStr) ) + { + return true; + } + } + + return false; } +//============================================================================== + /* If Rename Partition has defined an alias, then extract it for description purpose. * The format for the rename string is the following: * hd(x,y)|uuid|"label" "alias";hd(m,n)|uuid|"label" "alias"; etc... @@ -1847,225 +1988,273 @@ bool getVolumeLabelAlias(BVRef bvr, char* str, long strMaxLen) { - char *aliasList, *entryStart, *entryNext; + char *aliasList, *entryStart, *entryNext; - if ( !str || strMaxLen <= 0) - return false; - - aliasList = XMLDecode(getStringForKey(kRenamePartition, &bootInfo->chameleonConfig)); - if ( !aliasList ) - return false; - - for ( entryStart = entryNext = aliasList; - entryNext && *entryNext; - entryStart = entryNext ) - { - char *volStart, *volEnd, *aliasStart; - long volLen, aliasLen; + if ( !str || strMaxLen <= 0) + { + return false; + } + + aliasList = XMLDecode(getStringForKey(kRenamePartition, &bootInfo->chameleonConfig)); + if ( !aliasList ) + { + return false; + } + + for ( entryStart = entryNext = aliasList; entryNext && *entryNext; entryStart = entryNext ) + { + char *volStart, *volEnd, *aliasStart; + long volLen, aliasLen; - // Delimit current entry - entryNext = strchr(entryStart, ';'); - if ( entryNext ) - { - *entryNext = '\0'; - entryNext++; - } + // Delimit current entry + entryNext = strchr(entryStart, ';'); + if ( entryNext ) + { + *entryNext = '\0'; + entryNext++; + } - volStart = strbreak(entryStart, &volEnd, &volLen); - if(!volLen) - continue; - - aliasStart = strbreak(volEnd, 0, &aliasLen); - if(!aliasLen) - continue; - - if ( matchVolumeToString(bvr, volStart, volLen) ) - { - strncat(str, aliasStart, MIN(strMaxLen, aliasLen)); - free(aliasList); - - return true; - } - } + volStart = strbreak(entryStart, &volEnd, &volLen); + if(!volLen) + { + continue; + } + + aliasStart = strbreak(volEnd, 0, &aliasLen); + if(!aliasLen) + { + continue; + } + + if ( matchVolumeToString(bvr, volStart, volLen) ) + { + strncat(str, aliasStart, MIN(strMaxLen, aliasLen)); + free(aliasList); + + return true; + } + } - free(aliasList); - return false; + free(aliasList); + return false; } +//============================================================================== + void getBootVolumeDescription( BVRef bvr, char * str, long strMaxLen, bool useDeviceDescription ) { - unsigned char type; - char *p = str; + unsigned char type; + char *p = str; - if(!bvr || !p || strMaxLen <= 0) - return; - - type = (unsigned char) bvr->part_type; - - if (useDeviceDescription) - { - int len = getDeviceDescription(bvr, str); - if(len >= strMaxLen) - return; - - strcpy(str + len, bvr->OSisInstaller ? " (Installer) " : " "); - len += bvr->OSisInstaller ? 13 : 1; - strMaxLen -= len; - p += len; - } - - /* See if a partition rename is preferred */ - if(getVolumeLabelAlias(bvr, p, strMaxLen)) { - strncpy(bvr->label, p, strMaxLen); - return; // we're done here no need to seek for real name - } - - // - // Get the volume label using filesystem specific functions - // or use the alternate volume label if available. - // + if(!bvr || !p || strMaxLen <= 0) + { + return; + } + + type = (unsigned char) bvr->part_type; + + if (useDeviceDescription) + { + int len = getDeviceDescription(bvr, str); + if(len >= strMaxLen) + { + return; + } + + strcpy(str + len, bvr->OSisInstaller ? " (Installer) " : " "); + len += bvr->OSisInstaller ? 13 : 1; + strMaxLen -= len; + p += len; + } + + /* See if a partition rename is preferred */ + if (getVolumeLabelAlias(bvr, p, strMaxLen)) + { + strncpy(bvr->label, p, strMaxLen); + return; // we're done here no need to seek for real name + } + + // Get the volume label using filesystem specific functions or use the alternate volume label if available. + if (*bvr->altlabel != '\0') - strncpy(p, bvr->altlabel, strMaxLen); + { + strncpy(p, bvr->altlabel, strMaxLen); + } else if (bvr->description) - bvr->description(bvr, p, strMaxLen); + { + bvr->description(bvr, p, strMaxLen); + } - if (*p == '\0') { - const char * name = getNameForValue( fdiskTypes, type ); - if (name == NULL) { - name = bvr->type_name; - } - if (name == NULL) { - sprintf(p, "TYPE %02x", type); - } else { - strncpy(p, name, strMaxLen); - } - } - - // Set the devices label - sprintf(bvr->label, p); + if (*p == '\0') + { + const char * name = getNameForValue( fdiskTypes, type ); + + if (name == NULL) + { + name = bvr->type_name; + } + + if (name == NULL) + { + sprintf(p, "TYPE %02x", type); + } + else + { + strncpy(p, name, strMaxLen); + } + } + + // Set the devices label + sprintf(bvr->label, p); } -//========================================================================== -int readBootSector( int biosdev, unsigned int secno, void * buffer ) + +//============================================================================== + +int readBootSector(int biosdev, unsigned int secno, void * buffer) { - struct disk_blk0 * bootSector = (struct disk_blk0 *) buffer; - int error; + int error; + struct disk_blk0 * bootSector = (struct disk_blk0 *) buffer; - if ( bootSector == NULL ) - { - if ( gBootSector == NULL ) - { - gBootSector = (struct disk_blk0 *) malloc(sizeof(*gBootSector)); - if ( gBootSector == NULL ) return -1; - } - bootSector = gBootSector; - } + if (bootSector == NULL) + { + if (gBootSector == NULL) + { + gBootSector = (struct disk_blk0 *) malloc(sizeof(*gBootSector)); - error = readBytes( biosdev, secno, 0, BPS, bootSector ); - if ( error || bootSector->signature != DISK_SIGNATURE ) - return -1; + if (gBootSector == NULL) + { + return -1; + } + } - return 0; + bootSector = gBootSector; + } + + error = readBytes(biosdev, secno, 0, BPS, bootSector); + + if (error || bootSector->signature != DISK_SIGNATURE) + { + return -1; + } + return 0; } +//============================================================================== + /* * Format of boot1f32 block. */ - + #define BOOT1F32_MAGIC "BOOT " #define BOOT1F32_MAGICLEN 11 -struct disk_boot1f32_blk { - unsigned char init[3]; - unsigned char fsheader[87]; - unsigned char magic[BOOT1F32_MAGICLEN]; - unsigned char bootcode[409]; - unsigned short signature; +struct disk_boot1f32_blk +{ + unsigned char init[3]; + unsigned char fsheader[87]; + unsigned char magic[BOOT1F32_MAGICLEN]; + unsigned char bootcode[409]; + unsigned short signature; }; +//============================================================================== + int testFAT32EFIBootSector( int biosdev, unsigned int secno, void * buffer ) { - struct disk_boot1f32_blk * bootSector = (struct disk_boot1f32_blk *) buffer; - int error; + struct disk_boot1f32_blk * bootSector = (struct disk_boot1f32_blk *) buffer; + int error; - if ( bootSector == NULL ) - { - if ( gBootSector == NULL ) - { - gBootSector = (struct disk_blk0 *) malloc(sizeof(*gBootSector)); - if ( gBootSector == NULL ) return -1; - } - bootSector = (struct disk_boot1f32_blk *) gBootSector; - } + if ( bootSector == NULL ) + { + if ( gBootSector == NULL ) + { + gBootSector = (struct disk_blk0 *) malloc(sizeof(*gBootSector)); + if ( gBootSector == NULL ) + { + return -1; + } + } + bootSector = (struct disk_boot1f32_blk *) gBootSector; + } - error = readBytes( biosdev, secno, 0, BPS, bootSector ); - if ( error || bootSector->signature != DISK_SIGNATURE - || strncmp((const char *)bootSector->magic, BOOT1F32_MAGIC, BOOT1F32_MAGICLEN) ) - return -1; - - return 0; + error = readBytes( biosdev, secno, 0, BPS, bootSector ); + if ( error || bootSector->signature != DISK_SIGNATURE || strncmp((const char *)bootSector->magic, BOOT1F32_MAGIC, BOOT1F32_MAGICLEN) ) + { + return -1; + } + return 0; } -//========================================================================== + +//============================================================================== // Handle seek request from filesystem modules. -void diskSeek( BVRef bvr, long long position ) +void diskSeek(BVRef bvr, long long position) { - bvr->fs_boff = position / BPS; - bvr->fs_byteoff = position % BPS; + bvr->fs_boff = position / BPS; + bvr->fs_byteoff = position % BPS; } -//========================================================================== + +//============================================================================== // Handle read request from filesystem modules. -int diskRead( BVRef bvr, long addr, long length ) +int diskRead(BVRef bvr, long addr, long length) { - return readBytes( bvr->biosdev, - bvr->fs_boff + bvr->part_boff, - bvr->fs_byteoff, - length, - (void *) addr ); + return readBytes(bvr->biosdev, bvr->fs_boff + bvr->part_boff, bvr->fs_byteoff, length, (void *) addr); } +//============================================================================== + int rawDiskRead( BVRef bvr, unsigned int secno, void *buffer, unsigned int len ) { - int secs; - unsigned char *cbuf = (unsigned char *)buffer; - unsigned int copy_len; - int rc; + int secs; + unsigned char *cbuf = (unsigned char *)buffer; + unsigned int copy_len; + int rc; - if ((len & (BPS-1)) != 0) { - error("raw disk read not sector aligned"); - return -1; - } - secno += bvr->part_boff; + if ((len & (BPS-1)) != 0) + { + error("raw disk read not sector aligned"); + return -1; + } + secno += bvr->part_boff; - cache_valid = false; + cache_valid = false; - while (len > 0) { - secs = len / BPS; - if (secs > N_CACHE_SECS) secs = N_CACHE_SECS; - copy_len = secs * BPS; + while (len > 0) + { + secs = len / BPS; + if (secs > N_CACHE_SECS) + { + secs = N_CACHE_SECS; + } + copy_len = secs * BPS; - //printf("rdr: ebiosread(%d, %d, %d)\n", bvr->biosdev, secno, secs); - 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); - return rc; - } - } - bcopy( trackbuf, cbuf, copy_len ); - len -= copy_len; - cbuf += copy_len; - secno += secs; - spinActivityIndicator(secs); - } + //printf("rdr: ebiosread(%d, %d, %d)\n", bvr->biosdev, secno, secs); + 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); + return rc; + } + } + bcopy( trackbuf, cbuf, copy_len ); + len -= copy_len; + cbuf += copy_len; + secno += secs; + spinActivityIndicator(secs); + } - return 0; + return 0; } +//============================================================================== + int rawDiskWrite( BVRef bvr, unsigned int secno, void *buffer, unsigned int len ) { int secs; @@ -2073,52 +2262,64 @@ unsigned int copy_len; int rc; - if ((len & (BPS-1)) != 0) { - error("raw disk write not sector aligned"); - return -1; - } - secno += bvr->part_boff; + if ((len & (BPS-1)) != 0) + { + error("raw disk write not sector aligned"); + return -1; + } + secno += bvr->part_boff; - cache_valid = false; + cache_valid = false; - while (len > 0) { - secs = len / BPS; - if (secs > N_CACHE_SECS) secs = N_CACHE_SECS; - copy_len = secs * BPS; + while (len > 0) + { + secs = len / BPS; + if (secs > N_CACHE_SECS) + { + secs = N_CACHE_SECS; + } + copy_len = secs * BPS; - 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); - return rc; - } - len -= copy_len; - cbuf += copy_len; - secno += secs; - spinActivityIndicator(secs); - } + 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); + return rc; + } - return 0; + len -= copy_len; + cbuf += copy_len; + secno += secs; + spinActivityIndicator(secs); + } + + return 0; } +//============================================================================== + int diskIsCDROM(BVRef bvr) { - struct driveInfo di; + struct driveInfo di; - if (getDriveInfo(bvr->biosdev, &di) == 0 && di.no_emulation) { - return 1; - } - return 0; + if (getDriveInfo(bvr->biosdev, &di) == 0 && di.no_emulation) + { + return 1; + } + return 0; } +//============================================================================== + int biosDevIsCDROM(int biosdev) { - struct driveInfo di; + struct driveInfo di; - if (getDriveInfo(biosdev, &di) == 0 && di.no_emulation) - { - return 1; - } - return 0; + if (getDriveInfo(biosdev, &di) == 0 && di.no_emulation) + { + return 1; + } + return 0; } Index: branches/chucko/i386/libsaio/smbios.c =================================================================== --- branches/chucko/i386/libsaio/smbios.c (revision 2328) +++ branches/chucko/i386/libsaio/smbios.c (revision 2329) @@ -118,91 +118,8 @@ =================================================== */ #define kSMBOemProcessorBusSpeedKey "SMoemcpubusspeed" // Bungo: renamed from SMbusspeed -//------------------------------------------------------------------------------------------------------------------------- -// Default SMBIOS Data -//------------------------------------------------------------------------------------------------------------------------- -/* Rewrite: use a struct */ -#define kDefaultVendorManufacturer "Apple Inc." -#define kDefaultBIOSReleaseDate "11/06/2009" -#define kDefaultSerialNumber "SOMESRLNMBR" -#define kDefaultskuNumber "Default System SKU#" -#define kDefaultBoardProduct "Mac-F4208DC8" -#define kDefaultBoardType "10" // 0xA -#define kDefaultSystemVersion "1.0" - -//Bungo -/* 256 = 0x0100 -> swap bytes: 0x0001 -> Release: 0.1 (see SMBIOS spec. table Type 0) */ -#define kDefaultBIOSRelease 256 - -#define KDefaultBoardSerialNumber "C02140302D5DMT31M" // new C07019501PLDCVHAD - C02032101R5DC771H -#define KDefaultBoardAssetTagNumber "Pro-Enclosure" // ErmaC -#define kDefaultLocatioInChassis "Part Component" // ErmaC - -//=========== Mac mini =========== -#define kDefaultMacminiFamily "Macmini" -#define kDefaultMacmini "Macmini1,1" -#define kDefaultMacminiBIOSVersion " MM21.88Z.009A.B00.0903051113" -// MacMini5,1 Mac-8ED6AF5B48C039E1 - MM51.88Z.0077.B0F.1110201309 -// MacMini5,2 Mac-4BC72D62AD45599E -// MacMini5,3 - -// MacMini 6,1 - Mac-F65AE981FFA204ED -// MacMini 6,2 -//#define kDefaultMacmini62 "Macmini6,2" -//#define kDefaultMacmini62BIOSVersion " MM61.88Z.0106.B00.1208091121" -//#define kDefaultMacmini62BoardProduct "Mac-F65AE981FFA204ED" -//#define kDefaultMacmini62BIOSReleaseDate "10/14/2012" - -//=========== MacBook =========== -#define kDefaultMacBookFamily "MacBook" -#define kDefaultMacBook "MacBook4,1" -#define kDefaultMacBookBIOSVersion " MB41.88Z.0073.B00.0903051113" -//=========== MacBookAir =========== -// MacBookAir4,1 - Mac-C08A6BB70A942AC2 -// MacBookAir4,2 - Mac-742912EFDBEE19B3 -// MacBookAir6,1 - Mac-35C1E88140C3E6CF - MBA61.88Z.0099.B04.1309271229 -// MacBookAir6,2 - Mac-7DF21CB3ED6977E5 - MBA62.88Z.00EF.B00.1205221442 -//=========== MacBookPro =========== -#define kDefaultMacBookProFamily "MacBookPro" -#define kDefaultMacBookPro "MacBookPro4,1" -#define kDefaultMacBookProBIOSVersion " MBP41.88Z.0073.B00.0903051113" -// MacBookPro8,1 - Mac-94245B3640C91C81 - MBP81.88Z.0047.B24.1110141131 -// MacBookPro8,2 - Mac_94245A3940C91C80 -// MacBookPro8,3 - Mac-942459F5819B171B -// MacBookPro11,2 - Mac-3CBD00234E554E41 - MBP112.88Z.0138.B02.1310181745 -// MacBookPro11,3 - Mac-2BD1B31983FE1663 - MBP112.88Z.0138.B02.1310181745 - -//=========== iMac =========== -#define kDefaultiMacFamily "iMac" -#define kDefaultiMac "iMac8,1" -#define kDefaultiMacBIOSVersion " IM81.88Z.00C1.B00.0903051113" -// iMac10,1 -// iMac11,1 core i3/i5/i7 -#define kDefaultiMacNehalem "iMac11,1" -#define kDefaultiMacNehalemBIOSVersion " IM111.88Z.0034.B00.0903051113" -// iMac11,2 -// iMac11,3 -// defaults for an iMac12,1 -#define kDefaultiMacSandy "iMac12,1" -#define kDefaultiMacSandyBIOSVersion " IM121.88Z.0047.B00.1102091756" - -//=========== MacPro =========== -#define kDefaultMacProFamily "MacPro" -#define kDefaultMacPro "MacPro3,1" -#define kDefaultMacProBIOSVersion " MP31.88Z.006C.B05.0903051113" -// defaults for a Mac Pro 4,1 core i7/Xeon -#define kDefaultMacProNehalem "MacPro4,1" -#define kDefaultMacProNehalemBIOSVersion " MP41.88Z.0081.B08.1001221313" -// defaults for a Mac Pro 5,1 core i7/Xeon -#define kDefaultMacProWestmere "MacPro5,1" -#define kDefaultMacProWestmereBIOSVersion " MP51.88Z.007F.B03.1010071432" -#define kDefaultMacProWestmereBIOSReleaseDate "10/07/2010" -// defaults for a Mac Pro 6,1 -// MacPro6,1 - Mac-F60DEB81FF30ACF6 - MP61.88Z.0116.B00.1311020956 -//------------------------------------------------------------------------------------------------------------------------- - - +/* ==================================================*/ #define getFieldOffset(struct, field) ((uint8_t)(uint32_t)&(((struct *)0)->field)) typedef struct @@ -246,15 +163,26 @@ { char *manufacturer; char *product; - char *productName; // ErmaC + char *version; // Bungo char *serialNumber; // ErmaC char *assetTagNumber; // ErmaC char *locationInChassis; // ErmaC - char *boardType; // ErmaC + uint8_t boardType; // ErmaC } defaultBaseBoard_t; defaultBaseBoard_t defaultBaseBoard; +// Bungo +typedef struct { + char *manufacturer; + uint8_t chassisType; + char *version; + char *serialNumber; + char *assetTagNumber; +} defaultChassis_t; + +defaultChassis_t defaultChassis; + typedef struct { uint8_t type; @@ -262,9 +190,7 @@ uint8_t fieldOffset; char *keyString; bool (*getSMBValue)(returnType *); - // Bungo - // char **defaultValue; - void *defaultValue; + char **defaultValue; } SMBValueSetter; SMBValueSetter SMBSetters[] = @@ -283,8 +209,7 @@ // Bungo { kSMBTypeBIOSInformation, kSMBWord, getFieldOffset(SMBBIOSInformation, releaseMajor), - kSMBBIOSInformationReleaseKey, NULL, &defaultBIOSInfo.release }, // SMbiosrelease - 256 - // + kSMBBIOSInformationReleaseKey, NULL, (char **)&defaultBIOSInfo.release }, // SMbiosrelease - 0.1 (256) /* ========================= System Information (Type 1) @@ -301,12 +226,17 @@ {kSMBTypeSystemInformation, kSMBString, getFieldOffset(SMBSystemInformation, serialNumber), kSMBSystemInformationSerialNumberKey, NULL, &defaultSystemInfo.serialNumber }, // SMserial - Serial number +/* {kSMBTypeSystemInformation, kSMBByte, getFieldOffset(SMBSystemInformation, uuid[16]), + NULL, NULL, NULL}, // SmUUID/ + + {kSMBTypeSystemInformation, kSMBByte, getFieldOffset(SMBSystemInformation, wakeupReason), + NULL, NULL, NULL}, // reason for system wakeup +*/ + // Bungo {kSMBTypeSystemInformation, kSMBString, getFieldOffset(SMBSystemInformation, skuNumber), kSMBSystemInformationSKUNumberKey, NULL, &defaultSystemInfo.skuNumber}, // SMskunumber - System SKU# - // - {kSMBTypeSystemInformation, kSMBString, getFieldOffset(SMBSystemInformation, family), kSMBSystemInformationFamilyKey, NULL, &defaultSystemInfo.family}, // SMfamily - MacPro @@ -318,11 +248,11 @@ kSMBBaseBoardManufacturerKey, NULL, &defaultBaseBoard.manufacturer }, // SMboardmanufacturer - Apple Inc. {kSMBTypeBaseBoard, kSMBString, getFieldOffset(SMBBaseBoard, product), - kSMBBaseBoardProductKey, NULL, &defaultBaseBoard.product}, // SMboardproduct - Mac-F2268DC8 + kSMBBaseBoardProductKey, NULL, &defaultBaseBoard.product }, // SMboardproduct - Mac-F2268DC8 // Bungo {kSMBTypeBaseBoard, kSMBString, getFieldOffset(SMBBaseBoard, version), - kSMBBaseBoardVersionKey, NULL, &defaultBaseBoard.productName}, // SMboardproductname - MacPro3,1 + kSMBBaseBoardVersionKey, NULL, &defaultBaseBoard.version }, // SMboardversion - MacPro3,1 {kSMBTypeBaseBoard, kSMBString, getFieldOffset(SMBBaseBoard, serialNumber), kSMBBaseBoardSerialNumberKey, NULL, &defaultBaseBoard.serialNumber }, // SMboardserial - C02140302D5DMT31M @@ -333,30 +263,33 @@ {kSMBTypeBaseBoard, kSMBString, getFieldOffset(SMBBaseBoard, locationInChassis), kSMBBaseBoardLocationInChassisKey, NULL, &defaultBaseBoard.locationInChassis }, // SMboardlocation - Part Component - {kSMBTypeBaseBoard, kSMBByte, getFieldOffset(SMBBaseBoard, boardType), - kSMBBaseBoardTypeKey,NULL, &defaultBaseBoard.boardType }, // SMboardtype - 10 (Motherboard) all model, 11 (Processor+Memory Module) MacPro + {kSMBTypeBaseBoard, kSMBByte, getFieldOffset(SMBBaseBoard, boardType), + kSMBBaseBoardTypeKey, NULL, (char **)&defaultBaseBoard.boardType }, // SMboardtype - 10 (Motherboard) all model, 11 (Processor+Memory Module) MacPro + +/* {kSMBTypeBaseBoard, kSMBByte, getFieldOffset(SMBBaseBoard, numberOfContainedHandles), + NULL , NULL, NULL }, // numberOfContainedHandles = 0 +*/ // - // Bungo + // Bungo /* ======================= System Enclosure (Type 3) ========================= */ {kSMBTypeSystemEnclosure, kSMBString, getFieldOffset(SMBSystemEnclosure, manufacturer), - kSMBSystemEnclosureManufacturerKey, NULL, &defaultBaseBoard.manufacturer }, // SMchassismanufacturer - Apple Inc. + kSMBSystemEnclosureManufacturerKey, NULL, &defaultChassis.manufacturer }, // SMchassismanufacturer - Apple Inc. - {kSMBTypeSystemEnclosure, kSMBByte, getFieldOffset(SMBSystemEnclosure, type), - kSMBSystemEnclosureTypeKey, NULL, &defaultBaseBoard.boardType }, // SMchassistype - 7 + {kSMBTypeSystemEnclosure, kSMBByte, getFieldOffset(SMBSystemEnclosure, chassisType), + kSMBSystemEnclosureTypeKey, NULL, (char **)&defaultChassis.chassisType }, // SMchassistype - 7 {kSMBTypeSystemEnclosure, kSMBString, getFieldOffset(SMBSystemEnclosure, version), kSMBSystemEnclosureVersionKey, NULL, &defaultBaseBoard.product }, // SMchassisversion - Mac-F42C88C8 {kSMBTypeSystemEnclosure, kSMBString, getFieldOffset(SMBSystemEnclosure, serialNumber), - kSMBSystemEnclosureSerialNumberKey, NULL, &defaultSystemInfo.serialNumber }, // SMchassisserial + kSMBSystemEnclosureSerialNumberKey, NULL, &defaultChassis.serialNumber }, // SMchassisserial {kSMBTypeSystemEnclosure, kSMBString, getFieldOffset(SMBSystemEnclosure, assetTagNumber), - kSMBSystemEnclosureAssetTagNumberKey, NULL, &defaultBaseBoard.assetTagNumber }, // SMchassisassettag - Pro Enclosure + kSMBSystemEnclosureAssetTagNumberKey, NULL, &defaultChassis.assetTagNumber }, // SMchassisassettag - Pro Enclosure - /* ============================ Processor Information (Type 4) ============================== */ @@ -386,7 +319,7 @@ {kSMBTypeProcessorInformation, kSMBString, getFieldOffset(SMBProcessorInformation, serialNumber), NULL, NULL, NULL}, - // Bungo + // Bungo {kSMBTypeProcessorInformation, kSMBString, getFieldOffset(SMBProcessorInformation, assetTag), kSMBProcessorInformationAssetTagNumberKey, NULL, NULL}, // SMcpuassettag @@ -441,8 +374,8 @@ int numOfSetters = sizeof(SMBSetters) / sizeof(SMBValueSetter); -SMBEntryPoint *origeps = 0; -SMBEntryPoint *neweps = 0; +SMBEntryPoint *origeps = 0; +SMBEntryPoint *neweps = 0; static uint8_t stringIndex; // increament when a string is added and set the field value accordingly static uint8_t stringsSize; // add string size @@ -452,41 +385,227 @@ static SMBWord maxStructSize = 0; static SMBWord structureCount = 0; +//------------------------------------------------------------------------------------------------------------------------- +// Default SMBIOS Data +//------------------------------------------------------------------------------------------------------------------------- +/* Rewrite: use a struct */ + +// Bungo: suggest to not mixing data from different Mac models, use real Mac SMBIOS dumps + +#define kDefaultVendorManufacturer "Apple Inc." +//#define kDefaultBIOSReleaseDate "11/06/2009" +#define kDefaultSerialNumber "SOMESRLNMBR" +//Bungo +#define kDefaultSkuNumber "Default SKU#" +#define kDefaultAssetTagNumber "Default Asset Tag#" +//#define kDefaultBoardType "10" // 0xA +//#define kDefaultBoardProcessorType "11" // 0xB +#define kDefaultSystemVersion "1.0" +#define kDefaultBIOSRelease 256 // 256 = 0x0100 -> swap bytes: 0x0001 -> Release: 0.1 (see SMBIOS spec. table Type 0) +//#define kDefaultLocatioInChassis "Part Component" +//#define KDefaultBoardSerialNumber "C02140302D5DMT31M" // new C07019501PLDCVHAD - C02032101R5DC771H + +//=========== Mac mini =========== +#define kDefaultMacMiniFamily "Mac mini" +//#define kDefaultMacMiniBoardAssetTagNumber "Mini-Aluminum" + +#define kDefaultMacMini "Macmini2,1" +#define kDefaultMacMiniBIOSVersion " MM21.88Z.009A.B00.0706281359" +#define kDefaultMacMiniBIOSReleaseDate "06/28/07" +#define kDefaultMacMiniBoardProduct "Mac-F4208EAA" + +// MacMini5,1 Mac-8ED6AF5B48C039E1 - MM51.88Z.0077.B0F.1110201309 +// MacMini5,2 Mac-4BC72D62AD45599E +// MacMini5,3 +//#define kDefaultMacMini "Macmini5,3" +//#define kDefaultMacMiniBIOSVersion " MM51.88Z.0077.B10.1201241549" +//#define kDefaultMacMiniBoardProduct "Mac-F65AE981FFA204ED" +//#define kDefaultMacMiniBIOSReleaseDate "01/24/2012" + +// MacMini 6,1 - Mac-F65AE981FFA204ED +// MacMini 6,2 +//#define kDefaultMacMini62 "Macmini6,2" +//#define kDefaultMacMini62BIOSVersion " MM61.88Z.0106.B00.1208091121" +//#define kDefaultMacMini62BoardProduct "Mac-F65AE981FFA204ED" +//#define kDefaultMacMini62BIOSReleaseDate "10/14/2012" + +//=========== MacBook =========== +#define kDefaultMacBookFamily "MacBook" +//#define kDefaultMacBookBoardAssetTagNumber "MacBook-Black" + +#define kDefaultMacBook "MacBook4,1" +#define kDefaultMacBookBIOSVersion " MB41.88Z.00C1.B00.0802091535" +#define kDefaultMacBookBIOSReleaseDate "02/09/08" +#define kDefaultMacBookBoardProduct "Mac-F22788A9" + +//=========== MacBookAir =========== +#define kDefaultMacBookAirFamily "MacBook Air" + +// MacBookAir4,1 - Mac-C08A6BB70A942AC2 +// MacBookAir4,2 - Mac-742912EFDBEE19B3 +#define kDefaultMacBookAir "MacBookAir5,2" +#define kDefaultMacBookAirBIOSVersion " MBA51.88Z.00EF.B00.1205221442" +#define kDefaultMacBookAirBIOSReleaseDate "05/10/12" +#define kDefaultMacBookBoardAirProduct "Mac-2E6FAB96566FE58C" + +// MacBookAir6,1 - Mac-35C1E88140C3E6CF - MBA61.88Z.0099.B04.1309271229 +// MacBookAir6,2 - Mac-7DF21CB3ED6977E5 - MBA62.88Z.00EF.B00.1205221442 + +//=========== MacBookPro =========== +#define kDefaultMacBookProFamily "MacBook Pro" +//#define kDefaultMacBookProBoardAssetTagNumber "MacBook-Aluminum" + +#define kDefaultMacBookPro "MacBookPro4,1" +#define kDefaultMacBookProBIOSVersion " MBP41.88Z.0073.B00.0903051113" +#define kDefaultMacBookProBIOSReleaseDate "02/27/08" +#define kDefaultMacBookProBoardProduct "Mac-F42C89C8" + +//#define kDefaultMacBookPro "MacBookPro8,1" +//#define kDefaultMacBookProBIOSVersion " MBP81.88Z.0047.B24.1110141131" +//#define kDefaultMacBookProBoardProduct "Mac-94245B3640C91C81" +//#define kDefaultMacBookProBIOSReleaseDate "10/14/11" + +// MacBookPro8,2 - Mac_94245A3940C91C80 +// MacBookPro8,3 - Mac-942459F5819B171B + +// MacBookPro10,2 +//#define kDefaultMacBookProIvy "MacBookPro10,2" +//#define kDefaultMacBookProIvyBIOSVersion " MBP102.88Z.0106.B01.1208311637" +//#define kDefaultMacBookProIvyBoardProduct "Mac-AFD8A9D944EA4843" +//#define kDefaultMacBookProIvyBIOSReleaseDate "10/02/2012" + +// MacBookPro11,2 - Mac-3CBD00234E554E41 - MBP112.88Z.0138.B02.1310181745 +// MacBookPro11,3 - Mac-2BD1B31983FE1663 - MBP112.88Z.0138.B02.1310181745 + +//=========== iMac =========== +#define kDefaultiMacFamily "iMac" +//#define kDefaultiMacBoardAssetTagNumber "iMac-Aluminum" + +#define kDefaultiMac "iMac8,1" +#define kDefaultiMacBIOSVersion " IM81.88Z.00C1.B00.0903051113" +#define kDefaultiMacBIOSReleaseDate "02/09/08" +#define kDefaultiMacBoardProduct "Mac-F227BEC8" + +// iMac10,1 +// iMac11,1 core i3/i5/i7 +#define kDefaultiMacNehalem "iMac11,1" +#define kDefaultiMacNehalemBIOSVersion " IM111.88Z.0034.B02.1003171314" +#define kDefaultiMacNehalemBIOSReleaseDate "10/30/09" +#define kDefaultiMacNehalemBoardProduct "Mac-F2268DAE" +// iMac11,2 +// iMac11,3 + +// iMac12,1 +#define kDefaultiMacSandy "iMac12,1" +#define kDefaultiMacSandyBIOSVersion " IM121.88Z.0047.B00.1102091756" +#define kDefaultiMacSandyBIOSReleaseDate "01/02/08" +#define kDefaultiMacSandyBoardProduct "Mac-942B5BF58194151B" +// iMac12,2 Mac-942B59F58194171B +//#define kDefaultiMacSandy "iMac12,2" +//#define kDefaultiMacSandyBIOSVersion " IM121.88Z.0047.B1D.1110171110" +//#define kDefaultiMacSandyBIOSReleaseDate "10/17/2011" +//#define kDefaultiMacSandyBoardProduct "Mac-942B59F58194171B" + +// iMac13,2 +//#define kDefaultiMacIvy "iMac13,2" +//#define kDefaultiMacIvyBIOSVersion " IM131.88Z.00CE.B00.1203281326" +//#define kDefaultiMacIvyBIOSReleaseDate "03/28/2012" +//#define kDefaultiMacIvyBoardProduct "Mac-FC02E91DDD3FA6A4" + +//=========== MacPro =========== +#define kDefaultMacProFamily "Mac Pro" +//#define KDefauktMacProBoardAssetTagNumber "Pro-Enclosure" +//#define kDefaultMacProBoardType "0xB" // 11 + +#define kDefaultMacPro "MacPro3,1" +#define kDefaultMacProBIOSVersion " MP31.88Z.006C.B05.0903051113" +#define kDefaultMacProBIOSReleaseDate "08/03/2010" +//#define kDefaultMacProSystemVersion "1.3" +#define kDefaultMacProBoardProduct "Mac-F2268DC8" +//#define KDefaultMacProBoardSerialNumber "J593902RA4MFE" + +// Mac Pro 4,1 core i7/Xeon +#define kDefaultMacProNehalem "MacPro4,1" +#define kDefaultMacProNehalemBIOSVersion " MP41.88Z.0081.B04.0903051113" +#define kDefaultMacProNehalemBIOSReleaseDate "11/06/2009" +//#define kDefaultMacProNehalemSystemVersion "1.4" +#define kDefaultMacProNehalemBoardProduct "Mac-F4238CC8" +//#define KDefaultMacProNehalemBoardSerialNumber "J593004RB1LUE" + +// Mac Pro 5,1 core i7/Xeon +#define kDefaultMacProWestmere "MacPro5,1" +#define kDefaultMacProWestmereBIOSVersion " MP51.88Z.007F.B03.1010071432" +#define kDefaultMacProWestmereBIOSReleaseDate "10/07/10" +//#define kDefaultMacProWestmereSystemVersion "1.2" +#define kDefaultMacProWestmereBoardProduct "Mac-F221BEC8" +//#define KDefaultMacProWestmereBoardSerialNumber "J522700H7BH8C" + +// Mac Pro 6,1 +#define kDefaultMacProHaswell "MacPro6,1" +#define kDefaultMacProHaswellBIOSVersion " MP61.88Z.0116.B00.1311020956" +#define kDefaultMacProHaswellBIOSReleaseDate "06/12/13" +//#define kDefaultMacProHaswellSystemVersion "1.?" +#define kDefaultMacProHaswellBoardProduct "Mac-F60DEB81FF30ACF6" +//#define KDefaultMacProHaswellBoardSerialNumber "?????????????" + +//#define KDefaultBoardSerialNumber "C02140302D5DMT31M" // new C07019501PLDCVHAD - C02032101R5DC771H +// J593902RA4MFE 3,1 +// J5031046RCZJA 5,1 +// J521101A5CZJC 3,1 +// J593004RB1LUE MacPro4,1 +// J513401PZBH8C 5,1 +// J590802LC4ACB 3,1 +// J594900AH1LUE 4,1 +// J512500HZBH8C 5,1 +// J522700H7BH8C MacPro5,1 + +/* ============================================ */ + bool useSMBIOSdefaults = true; // Bungo +SMBByte PlatformType = 3; // Bungo: same as Platfom.Type in platform.h + /* Rewrite this function */ -void setDefaultSMBData(void) +void setDefaultSMBData(void) // Bungo: setting data from real Macs { defaultBIOSInfo.vendor = kDefaultVendorManufacturer; - defaultBIOSInfo.releaseDate = kDefaultBIOSReleaseDate; - defaultBIOSInfo.release = kDefaultBIOSRelease; // Bungo defaultSystemInfo.manufacturer = kDefaultVendorManufacturer; defaultSystemInfo.version = kDefaultSystemVersion; defaultSystemInfo.serialNumber = kDefaultSerialNumber; - defaultSystemInfo.skuNumber = kDefaultskuNumber; // Bungo + defaultSystemInfo.skuNumber = kDefaultSkuNumber; // Bungo defaultBaseBoard.manufacturer = kDefaultVendorManufacturer; - defaultBaseBoard.product = kDefaultBoardProduct; - defaultBaseBoard.boardType = kDefaultBoardType; // ErmaC - defaultBaseBoard.serialNumber = KDefaultBoardSerialNumber; // ErmaC - defaultBaseBoard.assetTagNumber = KDefaultBoardAssetTagNumber; // ErmaC - defaultBaseBoard.locationInChassis = kDefaultLocatioInChassis; // ErmaC + defaultBaseBoard.serialNumber = kDefaultSerialNumber; + defaultBaseBoard.assetTagNumber = kDefaultAssetTagNumber; - if (platformCPUFeature(CPU_FEATURE_MOBILE)) + defaultChassis.manufacturer = kDefaultVendorManufacturer; + defaultChassis.serialNumber = kDefaultSerialNumber; + defaultChassis.assetTagNumber = kDefaultAssetTagNumber; + + // if (platformCPUFeature(CPU_FEATURE_MOBILE)) Bungo: doesn't recognise correctly + if (PlatformType == 2) // this method works { if (Platform.CPU.NoCores > 1) { - defaultBIOSInfo.version = kDefaultMacBookProBIOSVersion; defaultSystemInfo.productName = kDefaultMacBookPro; - defaultSystemInfo.family = kDefaultMacBookProFamily; + defaultBIOSInfo.version = kDefaultMacBookProBIOSVersion; + defaultBIOSInfo.releaseDate = kDefaultMacBookProBIOSReleaseDate; + defaultSystemInfo.family = kDefaultMacBookProFamily; + defaultBaseBoard.product = kDefaultMacBookProBoardProduct; + defaultBaseBoard.boardType = kSMBBaseBoardMotherboard; + defaultChassis.chassisType = kSMBchassisUnknown; } else { - defaultBIOSInfo.version = kDefaultMacBookBIOSVersion; defaultSystemInfo.productName = kDefaultMacBook; - defaultSystemInfo.family = kDefaultMacBookFamily; + defaultBIOSInfo.version = kDefaultMacBookBIOSVersion; + defaultBIOSInfo.releaseDate = kDefaultMacBookBIOSReleaseDate; + defaultSystemInfo.family = kDefaultMacBookFamily; + defaultBaseBoard.product = kDefaultMacBookBoardProduct; + defaultBaseBoard.boardType = kSMBBaseBoardMotherboard; + defaultChassis.chassisType = kSMBchassisUnknown; } } else @@ -494,15 +613,23 @@ switch (Platform.CPU.NoCores) { case 1: - defaultBIOSInfo.version = kDefaultMacminiBIOSVersion; - defaultSystemInfo.productName = kDefaultMacmini; - defaultSystemInfo.family = kDefaultMacminiFamily; + defaultBIOSInfo.version = kDefaultMacMiniBIOSVersion; + defaultBIOSInfo.releaseDate = kDefaultMacMiniBIOSReleaseDate; + defaultSystemInfo.productName = kDefaultMacMini; + defaultSystemInfo.family = kDefaultMacMiniFamily; + defaultBaseBoard.product = kDefaultMacMiniBoardProduct; + defaultBaseBoard.boardType = kSMBBaseBoardUnknown; + defaultChassis.chassisType = kSMBchassisLPDesktop; break; case 2: - defaultBIOSInfo.version = kDefaultiMacBIOSVersion; - defaultSystemInfo.productName = kDefaultiMac; - defaultSystemInfo.family = kDefaultiMacFamily; + defaultBIOSInfo.version = kDefaultiMacBIOSVersion; + defaultBIOSInfo.releaseDate = kDefaultiMacBIOSReleaseDate; + defaultSystemInfo.productName = kDefaultiMac; + defaultSystemInfo.family = kDefaultiMacFamily; + defaultBaseBoard.product = kDefaultiMacBoardProduct; + defaultBaseBoard.boardType = kSMBBaseBoardMotherboard; + defaultChassis.chassisType = kSMBchassisAllInOne; break; default: { @@ -516,44 +643,69 @@ case CPU_MODEL_DALES: case CPU_MODEL_DALES_32NM: // Intel Core i3, i5 LGA1156 (32nm) defaultBIOSInfo.version = kDefaultiMacNehalemBIOSVersion; + defaultBIOSInfo.releaseDate = kDefaultiMacNehalemBIOSReleaseDate; defaultSystemInfo.productName = kDefaultiMacNehalem; defaultSystemInfo.family = kDefaultiMacFamily; + defaultBaseBoard.product = kDefaultiMacNehalemBoardProduct; + defaultBaseBoard.boardType = kSMBBaseBoardMotherboard; + defaultChassis.chassisType = kSMBchassisAllInOne; break; case CPU_MODEL_SANDYBRIDGE: // Intel Core i3, i5, i7 LGA1155 (32nm) case CPU_MODEL_IVYBRIDGE: // Intel Core i3, i5, i7 LGA1155 (22nm) + case CPU_MODEL_IVYBRIDGE_XEON: defaultBIOSInfo.version = kDefaultiMacSandyBIOSVersion; + defaultBIOSInfo.releaseDate = kDefaultiMacSandyBIOSReleaseDate; defaultSystemInfo.productName = kDefaultiMacSandy; - defaultSystemInfo.family = kDefaultiMacFamily; + defaultSystemInfo.family = kDefaultiMacFamily; + defaultBaseBoard.product = kDefaultiMacSandyBoardProduct; + defaultBaseBoard.boardType = kSMBBaseBoardMotherboard; + defaultChassis.chassisType = kSMBchassisAllInOne; break; + case CPU_MODEL_NEHALEM: // Intel Core i7, Xeon W35xx, Xeon X55xx, Xeon E55xx LGA1366 (45nm) case CPU_MODEL_NEHALEM_EX: // Intel Xeon X75xx, Xeon X65xx, Xeon E75xx, Xeon E65x - defaultBIOSInfo.version = kDefaultMacProNehalemBIOSVersion; + defaultBIOSInfo.version = kDefaultMacProNehalemBIOSVersion; + defaultBIOSInfo.releaseDate = kDefaultMacProNehalemBIOSReleaseDate; defaultSystemInfo.productName = kDefaultMacProNehalem; - defaultSystemInfo.family = kDefaultMacProFamily; + defaultSystemInfo.family = kDefaultMacProFamily; + defaultBaseBoard.product = kDefaultMacProNehalemBoardProduct; + defaultBaseBoard.boardType = kSMBBaseBoardProcessorMemoryModule; + defaultChassis.chassisType = kSMBchassisTower; break; case CPU_MODEL_WESTMERE: // Intel Core i7, Xeon X56xx, Xeon E56xx, Xeon W36xx LGA1366 (32nm) 6 Core case CPU_MODEL_WESTMERE_EX: // Intel Xeon E7 case CPU_MODEL_JAKETOWN: // Intel Core i7, Xeon E5 LGA2011 (32nm) - defaultBIOSInfo.version = kDefaultMacProWestmereBIOSVersion; - defaultBIOSInfo.releaseDate = kDefaultMacProWestmereBIOSReleaseDate; + defaultBIOSInfo.version = kDefaultMacProWestmereBIOSVersion; + defaultBIOSInfo.releaseDate = kDefaultMacProWestmereBIOSReleaseDate; defaultSystemInfo.productName = kDefaultMacProWestmere; - defaultSystemInfo.family = kDefaultMacProFamily; + defaultSystemInfo.family = kDefaultMacProFamily; + defaultBaseBoard.product = kDefaultMacProWestmereBoardProduct; + defaultBaseBoard.boardType = kSMBBaseBoardProcessorMemoryModule; + defaultChassis.chassisType = kSMBchassisTower; break; default: - defaultBIOSInfo.version = kDefaultMacProBIOSVersion; + defaultBIOSInfo.version = kDefaultMacProBIOSVersion; + defaultBIOSInfo.releaseDate = kDefaultMacProBIOSReleaseDate; defaultSystemInfo.productName = kDefaultMacPro; - defaultSystemInfo.family = kDefaultMacProFamily; + defaultSystemInfo.family = kDefaultMacProFamily; + defaultBaseBoard.product = kDefaultMacProBoardProduct; + defaultBaseBoard.boardType = kSMBBaseBoardMotherboard; + defaultChassis.chassisType = kSMBchassisUnknown; break; } break; } default: defaultBIOSInfo.version = kDefaultMacProBIOSVersion; + defaultBIOSInfo.releaseDate = kDefaultMacProBIOSReleaseDate; defaultSystemInfo.productName = kDefaultMacPro; defaultSystemInfo.family = kDefaultMacProFamily; + defaultBaseBoard.product = kDefaultMacProBoardProduct; + defaultBaseBoard.boardType = kSMBBaseBoardMotherboard; + defaultChassis.chassisType = kSMBchassisUnknown; break; } break; @@ -685,13 +837,12 @@ if (SMBSetters[idx].getSMBValue((returnType *)&string)) { break; - // if ((SMBSetters[idx].defaultValue) && *(SMBSetters[idx].defaultValue)) Bungo } } - if (useSMBIOSdefaults && (SMBSetters[idx].defaultValue) && *(char *)(SMBSetters[idx].defaultValue)) + // if ((SMBSetters[idx].defaultValue) && *(SMBSetters[idx].defaultValue)) Bungo + if (useSMBIOSdefaults && (SMBSetters[idx].defaultValue)) { - // string = *(SMBSetters[idx].defaultValue); Bungo - string = (char *)(SMBSetters[idx].defaultValue); + string = *(SMBSetters[idx].defaultValue); break; } string = getSMBStringForField(structPtr->orig, *(uint8_t *)value); @@ -762,7 +913,7 @@ } // if (SMBSetters[idx].valueType == kSMBString && string) Bungo: use null string too -> "Not Specified" - if (SMBSetters[idx].valueType == kSMBString) + if ((SMBSetters[idx].valueType == kSMBString) && string) { setSMBStringForField(structPtr->new, string, &value->byte); } @@ -979,7 +1130,7 @@ addSMBEndOfTable(structPtr); } -// Bungo: does fix system uuid in SMBIOS istead of in EFI only +// Bungo: does fix system uuid in SMBIOS (and EFI) instead of in EFI only uint8_t *FixSystemUUID() { uint8_t *ptr = (uint8_t *)neweps->dmi.tableAddress; @@ -1084,8 +1235,8 @@ neweps->anchor[2] = 'M'; neweps->anchor[3] = '_'; neweps->entryPointLength = sizeof(SMBEntryPoint); - neweps->majorVersion = 2; - neweps->minorVersion = 4; + neweps->majorVersion = 2; // Bungo: + neweps->minorVersion = 4; // We're using 2.4 SMBIOS rev. as real Macs neweps->maxStructureSize = maxStructSize; neweps->entryPointRevision = 0; @@ -1109,7 +1260,7 @@ memcpy((void *)neweps->dmi.tableAddress, buffer, tableLength); // Bungo - Platform.UUID = FixSystemUUID(); // Fix System UUID + Platform.UUID = FixSystemUUID(); // Bungo: fix System UUID neweps->dmi.checksum = 0; neweps->dmi.checksum = 0x100 - checksum8(&neweps->dmi, sizeof(DMIEntryPoint)); @@ -1155,12 +1306,32 @@ { switch (structHeader->type) { - /* Bungo + /* Bungo: fixed in smbios now case kSMBTypeSystemInformation: Platform.UUID = ((SMBSystemInformation *)structHeader)->uuid; break; */ - + case kSMBTypeSystemEnclosure: // Bungo: determine platform type + switch (((SMBSystemEnclosure *)structHeader)->chassisType) { + case kSMBchassisDesktop: + case kSMBchassisLPDesktop: + case kSMBchassisAllInOne: + case kSMBchassisLunchBox: + PlatformType = 1; // desktop (iMac, MacMini) + break; + case kSMBchassisPortable: + case kSMBchassisLaptop: + case kSMBchassisNotebook: + case kSMBchassisHandHeld: + case kSMBchassisSubNotebook: + PlatformType = 2; // notebook (Mac Books) + break; + default: + PlatformType = 3; // workstation (Mac Pro, Xserve) + break; + } + break; + // case kSMBTypePhysicalMemoryArray: Platform.DMI.MaxMemorySlots += ((SMBPhysicalMemoryArray *)structHeader)->numMemoryDevices; break; Index: branches/chucko/i386/libsaio/smbios_decode.c =================================================================== --- branches/chucko/i386/libsaio/smbios_decode.c (revision 2328) +++ branches/chucko/i386/libsaio/smbios_decode.c (revision 2329) @@ -22,6 +22,19 @@ extern char *getSMBStringForField(SMBStructHeader *structHeader, uint8_t field); +// Bungo: fixes random string readout if null in smbios to "Not Specified" as dmidecode dispays +#define NotSpecifiedStr "Not Specified" + +char *SMBStringForField(SMBStructHeader *structHeader, uint8_t field) +{ + char *str; + str = getSMBStringForField(structHeader, field); + if (str == 0) + str = NotSpecifiedStr; + + return str; +}; +// static const char * SMBMemoryDeviceTypes[] = { @@ -62,10 +75,10 @@ void decodeBIOSInformation(SMBBIOSInformation *structHeader) { DBG("BIOS Information:\n"); - DBG("\tVendor: %s\n", getSMBStringForField((SMBStructHeader *)structHeader, structHeader->vendor)); - DBG("\tVersion: %s\n", getSMBStringForField((SMBStructHeader *)structHeader, structHeader->version)); + DBG("\tVendor: %s\n", SMBStringForField((SMBStructHeader *)structHeader, structHeader->vendor)); + DBG("\tVersion: %s\n", SMBStringForField((SMBStructHeader *)structHeader, structHeader->version)); // Address Segment - DBG("\tRelease Date: %s\n", getSMBStringForField((SMBStructHeader *)structHeader, structHeader->releaseDate)); + DBG("\tRelease Date: %s\n", SMBStringForField((SMBStructHeader *)structHeader, structHeader->releaseDate)); // ROM Size //DBG("\tSupported BIOS functions: (0x%llX) %s\n", structHeader->characteristics, SMBBIOSInfoChar0[structHeader->characteristics]); // Major Release @@ -83,9 +96,9 @@ void decodeSystemInformation(SMBSystemInformation *structHeader) { DBG("System Information:\n"); - DBG("\tManufacturer: %s\n", getSMBStringForField((SMBStructHeader *)structHeader, structHeader->manufacturer)); - DBG("\tProduct Name: %s\n", getSMBStringForField((SMBStructHeader *)structHeader, structHeader->productName)); - DBG("\tVersion: %s\n", getSMBStringForField((SMBStructHeader *)structHeader, structHeader->version)); + DBG("\tManufacturer: %s\n", SMBStringForField((SMBStructHeader *)structHeader, structHeader->manufacturer)); + DBG("\tProduct Name: %s\n", SMBStringForField((SMBStructHeader *)structHeader, structHeader->productName)); + DBG("\tVersion: %s\n", SMBStringForField((SMBStructHeader *)structHeader, structHeader->version)); DBG("\tSerial Number: ** PRIVATE **\n"); //%s\n", getSMBStringForField((SMBStructHeader *)structHeader, structHeader->serialNumber)); if (minorVersion < 1 || structHeader->header.length < 25) @@ -100,8 +113,8 @@ if (minorVersion < 4 || structHeader->header.length < 27) return; - DBG("\tSKU Number: %s\n", getSMBStringForField((SMBStructHeader *)structHeader, structHeader->skuNumber)); // System SKU# - DBG("\tFamily: %s\n", getSMBStringForField((SMBStructHeader *)structHeader, structHeader->family)); + DBG("\tSKU Number: %s\n", SMBStringForField((SMBStructHeader *)structHeader, structHeader->skuNumber)); // System SKU# + DBG("\tFamily: %s\n", SMBStringForField((SMBStructHeader *)structHeader, structHeader->family)); DBG("\n"); } @@ -111,13 +124,13 @@ void decodeBaseBoard(SMBBaseBoard *structHeader) { DBG("Base Board Information:\n"); - DBG("\tManufacturer: %s\n", getSMBStringForField((SMBStructHeader *)structHeader, structHeader->manufacturer)); - DBG("\tProduct Name: %s\n", getSMBStringForField((SMBStructHeader *)structHeader, structHeader->product)); - DBG("\tVersion: %s\n", getSMBStringForField((SMBStructHeader *)structHeader, structHeader->version)); - DBG("\tSerial Number: %s\n", getSMBStringForField((SMBStructHeader *)structHeader, structHeader->serialNumber)); - DBG("\tAsset Tag: %s\n", getSMBStringForField((SMBStructHeader *)structHeader, structHeader->assetTagNumber)); + DBG("\tManufacturer: %s\n", SMBStringForField((SMBStructHeader *)structHeader, structHeader->manufacturer)); + DBG("\tProduct Name: %s\n", SMBStringForField((SMBStructHeader *)structHeader, structHeader->product)); + DBG("\tVersion: %s\n", SMBStringForField((SMBStructHeader *)structHeader, structHeader->version)); + DBG("\tSerial Number: %s\n", SMBStringForField((SMBStructHeader *)structHeader, structHeader->serialNumber)); + DBG("\tAsset Tag: %s\n", SMBStringForField((SMBStructHeader *)structHeader, structHeader->assetTagNumber)); // Feature Flags (BYTE) - DBG("\tLocation In Chassis: %s\n", getSMBStringForField((SMBStructHeader *)structHeader, structHeader->locationInChassis)); // Part Component + DBG("\tLocation In Chassis: %s\n", SMBStringForField((SMBStructHeader *)structHeader, structHeader->locationInChassis)); // Part Component // Chassis Handle (WORD) DBG("\tType: 0x%X\n", structHeader->boardType); // Number of Contained Object Handles (n) (BYTE) @@ -131,11 +144,11 @@ void decodeSystemEnclosure(SMBSystemEnclosure *structHeader) { DBG("Chassis Information:\n"); - DBG("\tManufacturer: %s\n", getSMBStringForField((SMBStructHeader *)structHeader, structHeader->manufacturer)); - DBG("\tType: %d\n", structHeader->type); - DBG("\tVersion: %s\n", getSMBStringForField((SMBStructHeader *)structHeader, structHeader->version)); - DBG("\tSerial Number: ** PRIVATE **\n"); //%s\n", getSMBStringForField((SMBStructHeader *)structHeader, structHeader->serialNumber)); - DBG("\tAsset Tag Number: %s\n", getSMBStringForField((SMBStructHeader *)structHeader, structHeader->assetTagNumber)); + DBG("\tManufacturer: %s\n", SMBStringForField((SMBStructHeader *)structHeader, structHeader->manufacturer)); + DBG("\tType: 0x%X\n", structHeader->chassisType); + DBG("\tVersion: %s\n", SMBStringForField((SMBStructHeader *)structHeader, structHeader->version)); + DBG("\tSerial Number: ** PRIVATE **\n"); //%s\n", SMBStringForField((SMBStructHeader *)structHeader, structHeader->serialNumber)); + DBG("\tAsset Tag Number: %s\n", SMBStringForField((SMBStructHeader *)structHeader, structHeader->assetTagNumber)); // Boot-up State: // Power Supply State // Thermal State @@ -155,12 +168,12 @@ void decodeProcessorInformation(SMBProcessorInformation *structHeader) { DBG("Processor Information:\n"); - DBG("\tSocket Designation: %s\n", getSMBStringForField((SMBStructHeader *)structHeader, structHeader->socketDesignation)); + DBG("\tSocket Designation: %s\n", SMBStringForField((SMBStructHeader *)structHeader, structHeader->socketDesignation)); DBG("\tType: %d\n", structHeader->processorType); DBG("\tFamily: 0x%X\n", structHeader->processorFamily); - DBG("\tManufacturer: %s\n", getSMBStringForField((SMBStructHeader *)structHeader, structHeader->manufacturer)); + DBG("\tManufacturer: %s\n", SMBStringForField((SMBStructHeader *)structHeader, structHeader->manufacturer)); DBG("\tID: 0x%llX\n", structHeader->processorID); - DBG("\tProcessor Version: %s\n", getSMBStringForField((SMBStructHeader *)structHeader, structHeader->processorVersion)); + DBG("\tProcessor Version: %s\n", SMBStringForField((SMBStructHeader *)structHeader, structHeader->processorVersion)); // DBG("\tVoltage: 0.%xV\n", structHeader->voltage); DBG("\tExternal Clock: %dMHz\n", structHeader->externalClock); DBG("\tMaximum Clock: %dMHz\n", structHeader->maximumClock); @@ -168,9 +181,9 @@ if (minorVersion < 3 || structHeader->header.length < 35) return; - DBG("\tSerial Number: %s\n", getSMBStringForField((SMBStructHeader *)structHeader, structHeader->serialNumber)); - DBG("\tAsset Tag: %s\n", getSMBStringForField((SMBStructHeader *)structHeader, structHeader->assetTag)); - DBG("\tPart Number: %s\n", getSMBStringForField((SMBStructHeader *)structHeader, structHeader->partNumber)); + DBG("\tSerial Number: %s\n", SMBStringForField((SMBStructHeader *)structHeader, structHeader->serialNumber)); + DBG("\tAsset Tag: %s\n", SMBStringForField((SMBStructHeader *)structHeader, structHeader->assetTag)); + DBG("\tPart Number: %s\n", SMBStringForField((SMBStructHeader *)structHeader, structHeader->partNumber)); // DBG("\tProcessor Family 2: %d\n", structHeader->processorFamily2); DBG("\n"); } @@ -178,30 +191,49 @@ //------------------------------------------------------------------------------------------------------------------------- // Memory Module Information (Type 6) //------------------------------------------------------------------------------------------------------------------------- +//void decodeMemoryModule(SMBMemoryModule *structHeader) +//{ +// DBG("Memory Module Information:\n"); +// DBG("\tSocket Designation: %s\n", getSMBStringForField((SMBStructHeader *)structHeader, structHeader->socketDesignation)); +// DBG("\tBank Connections: Type: %d\n", structHeader->bankConnections); +// DBG("\tCurrent Speed: %X\n", structHeader->currentSpeed); +// DBG("\tCurrent Memory Type: %llX\n", structHeader->currentMemoryType); +// DBG("\tInstalled Size: %d\n", structHeader->installedSize); +// DBG("\tEnabled Size: %d\n", structHeader->enabledSize); +// DBG("\tError Status: %x\n", structHeader->errorStatus); +// DBG("\n"); +//} //------------------------------------------------------------------------------------------------------------------------- // OEM Strings (Type 11) //------------------------------------------------------------------------------------------------------------------------- +//void decodeSMBOEMStrings(SMBOEMStrings *structHeader) +//{ +// DBG("OEM Strings:\n"); +// DBG("\tString 1: %d\n"); //, structHeader->string1); +// DBG("\tString 2: %d\n"); //, structHeader->string1); +// DBG("\tString 3: %d\n"); //, structHeader->string1); +// DBG("\n"); +//} - //------------------------------------------------------------------------------------------------------------------------- // MemoryDevice (Type 17) //------------------------------------------------------------------------------------------------------------------------- void decodeMemoryDevice(SMBMemoryDevice *structHeader) { DBG("Memory Device:\n"); - DBG("\tDevice Locator: %s\n", getSMBStringForField((SMBStructHeader *)structHeader, structHeader->deviceLocator)); - DBG("\tBank Locator: %s\n", getSMBStringForField((SMBStructHeader *)structHeader, structHeader->bankLocator)); + DBG("\tDevice Locator: %s\n", SMBStringForField((SMBStructHeader *)structHeader, structHeader->deviceLocator)); + DBG("\tBank Locator: %s\n", SMBStringForField((SMBStructHeader *)structHeader, structHeader->bankLocator)); DBG("\tMemory Type: %s\n", SMBMemoryDeviceTypes[structHeader->memoryType]); if (minorVersion < 3 || structHeader->header.length < 27) return; DBG("\tSpeed: %d MHz\n", structHeader->memorySpeed); DBG("\tError Handle: %x\n", structHeader->errorHandle); - DBG("\tManufacturer: %s\n", getSMBStringForField((SMBStructHeader *)structHeader, structHeader->manufacturer)); - DBG("\tSerial Number: %s\n", getSMBStringForField((SMBStructHeader *)structHeader, structHeader->serialNumber)); - DBG("\tAsset Tag: %s\n", getSMBStringForField((SMBStructHeader *)structHeader, structHeader->assetTag)); - DBG("\tPart Number: %s\n", getSMBStringForField((SMBStructHeader *)structHeader, structHeader->partNumber)); + DBG("\tManufacturer: %s\n", SMBStringForField((SMBStructHeader *)structHeader, structHeader->manufacturer)); + DBG("\tSerial Number: %s\n", SMBStringForField((SMBStructHeader *)structHeader, structHeader->serialNumber)); + DBG("\tAsset Tag: %s\n", SMBStringForField((SMBStructHeader *)structHeader, structHeader->assetTag)); + DBG("\tPart Number: %s\n", SMBStringForField((SMBStructHeader *)structHeader, structHeader->partNumber)); DBG("\n"); } @@ -261,24 +293,32 @@ decodeProcessorInformation((SMBProcessorInformation *)structHeader); break; + //case 6: // kSMBTypeMemoryModule: // Type 6 + // decodeMemoryModule((SMBMemoryModule *)structHeader); + // break; + + //case 11: // kSMBOEMStrings: // Type 11 + // decodeSMBOEMStrings((SMBOEMStrings *)structHeader); + // break; + case kSMBTypeMemoryDevice: // Type 17 decodeMemoryDevice((SMBMemoryDevice *)structHeader); break; /* Skip all Apple Specific Structures */ - case kSMBTypeFirmwareVolume: // Type - case kSMBTypeMemorySPD: // Type + case kSMBTypeFirmwareVolume: // Type 128 + case kSMBTypeMemorySPD: // Type 130 break; - case kSMBTypeOemProcessorType: // Type + case kSMBTypeOemProcessorType: // Type 131 decodeOemProcessorType((SMBOemProcessorType *)structHeader); break; - case kSMBTypeOemProcessorBusSpeed: // Type + case kSMBTypeOemProcessorBusSpeed: // Type 132 decodeOemProcessorBusSpeed((SMBOemProcessorBusSpeed *)structHeader); break; - case kSMBTypeEndOfTable: // Type + case kSMBTypeEndOfTable: // Type 127 /* Skip, to be added at the end */ break; Index: branches/chucko/i386/libsaio/smbios.h =================================================================== --- branches/chucko/i386/libsaio/smbios.h (revision 2328) +++ branches/chucko/i386/libsaio/smbios.h (revision 2329) @@ -23,10 +23,10 @@ #ifndef __LIBSAIO_SMBIOS_H #define __LIBSAIO_SMBIOS_H -// -// Based on System Management BIOS Reference Specification v2.5 -// +/* Based on System Management BIOS Reference Specification v2.5 */ +// http://dmtf.org/sites/default/files/standards/documents/DSP0134_2.8.0.pdf + typedef uint8_t SMBString; typedef uint8_t SMBByte; typedef uint16_t SMBWord; @@ -84,7 +84,7 @@ /* ======================= SMBIOS structure types. - =======================*/ + ======================= */ enum { kSMBTypeBIOSInformation = 0, // BIOS information (Type 0) @@ -134,7 +134,7 @@ // Inactive (Type 126) kSMBTypeEndOfTable = 127, // End-of-Table (Type 127) - /* Apple Specific Structures */ + // Apple Specific Structures kSMBTypeFirmwareVolume = 128, // FirmwareVolume (TYPE 128) kSMBTypeMemorySPD = 130, // MemorySPD (TYPE 130) kSMBTypeOemProcessorType = 131, // Processor Type (Type 131) @@ -231,7 +231,8 @@ { SMB_STRUCT_HEADER // Type 3 SMBString manufacturer; - SMBByte type; // System Enclosure Indicator +// SMBByte type; Bungo: renamed to chassisType - convention + SMBByte chassisType; // System Enclosure Indicator SMBString version; // Board Number? SMBString serialNumber; SMBString assetTagNumber; @@ -248,6 +249,27 @@ // SMBString skuNumber; // Number of null-terminated string describing the chassis or enclosure SKU number (2.7+) } __attribute__((packed)) SMBSystemEnclosure; +// Bungo: values for SMBSystemEnclosure.chassisType +enum { + kSMBchassisOther = 0x01, + kSMBchassisUnknown = 0x02, + kSMBchassisDesktop = 0x03, + kSMBchassisLPDesktop = 0x04, + kSMBchassisPizzaBox = 0x05, + kSMBchassisMiniTower = 0x06, + kSMBchassisTower = 0x07, + kSMBchassisPortable = 0x08, + kSMBchassisLaptop = 0x09, + kSMBchassisNotebook = 0x0A, + kSMBchassisHandHeld = 0x0B, + kSMBchassisDockingStation = 0x0C, + kSMBchassisAllInOne = 0x0D, + kSMBchassisSubNotebook = 0x0E, + // ... + kSMBchassisLunchBox = 0x10 + // fill up if needed ;-) +}; + /* ============================ Processor Information (Type 4) ============================== */ Index: branches/chucko/i386/libsaio/cache.c =================================================================== --- branches/chucko/i386/libsaio/cache.c (revision 2328) +++ branches/chucko/i386/libsaio/cache.c (revision 2329) @@ -31,9 +31,9 @@ // #include struct CacheEntry { - CICell ih; - long time; - long long offset; + CICell ih; + long time; + long long offset; }; typedef struct CacheEntry CacheEntry; @@ -48,128 +48,155 @@ static long gCacheTime; #ifdef __i386__ -static CacheEntry *gCacheEntries; -static char *gCacheBuffer; + static CacheEntry *gCacheEntries; + static char *gCacheBuffer; #else -static CacheEntry gCacheEntries[kCacheMaxEntries]; -static char gCacheBuffer[kCacheSize]; + static CacheEntry gCacheEntries[kCacheMaxEntries]; + static char gCacheBuffer[kCacheSize]; #endif #if CACHE_STATS -unsigned long gCacheHits; -unsigned long gCacheMisses; -unsigned long gCacheEvicts; + unsigned long gCacheHits; + unsigned long gCacheMisses; + unsigned long gCacheEvicts; #endif void CacheReset() { - gCacheIH = NULL; + gCacheIH = NULL; } void CacheInit( CICell ih, long blockSize ) { #ifdef __i386__ - if ((ih == gCacheIH) && (blockSize == gCacheBlockSize)) - return; + if ((ih == gCacheIH) && (blockSize == gCacheBlockSize)) + { + return; + } #endif - if ((blockSize < kCacheMinBlockSize) || - (blockSize > kCacheMaxBlockSize)) - return; + if ((blockSize < kCacheMinBlockSize) || (blockSize > kCacheMaxBlockSize)) + { + return; + } - gCacheBlockSize = blockSize; - gCacheNumEntries = kCacheSize / gCacheBlockSize; - gCacheTime = 0; + gCacheBlockSize = blockSize; + gCacheNumEntries = kCacheSize / gCacheBlockSize; + gCacheTime = 0; #if CACHE_STATS - gCacheHits = 0; - gCacheMisses = 0; - gCacheEvicts = 0; + gCacheHits = 0; + gCacheMisses = 0; + gCacheEvicts = 0; #endif gCacheIH = ih; #ifdef __i386__ - if (!gCacheBuffer) gCacheBuffer = (char *) malloc(kCacheSize); - if (!gCacheEntries) gCacheEntries = (CacheEntry *) malloc(kCacheMaxEntries * sizeof(CacheEntry)); - if ( !gCacheBuffer || !gCacheEntries ) - { - gCacheIH = 0; // invalidate cache - return; - } + if (!gCacheBuffer) + { + gCacheBuffer = (char *) malloc(kCacheSize); + } + + if (!gCacheEntries) + { + gCacheEntries = (CacheEntry *) malloc(kCacheMaxEntries * sizeof(CacheEntry)); + } + + if (!gCacheBuffer || !gCacheEntries) + { + gCacheIH = 0; // invalidate cache + return; + } #endif - bzero(gCacheEntries, kCacheMaxEntries * sizeof(CacheEntry)); + bzero(gCacheEntries, kCacheMaxEntries * sizeof(CacheEntry)); } -long CacheRead( CICell ih, char * buffer, long long offset, - long length, long cache ) +long CacheRead(CICell ih, char * buffer, long long offset, long length, long cache) { - long cnt, oldestEntry = 0, oldestTime, loadCache = 0; - CacheEntry *entry; + long cnt, oldestEntry = 0, oldestTime, loadCache = 0; + CacheEntry *entry; - // See if the data can be cached. - if (cache && (gCacheIH == ih) && (length == gCacheBlockSize)) { - // Look for the data in the cache. - for (cnt = 0; cnt < gCacheNumEntries; cnt++) { - entry = &gCacheEntries[cnt]; - if ((entry->ih == ih) && (entry->offset == offset)) { - entry->time = ++gCacheTime; - break; - } - } + // See if the data can be cached. + if (cache && (gCacheIH == ih) && (length == gCacheBlockSize)) + { + // Look for the data in the cache. + for (cnt = 0; cnt < gCacheNumEntries; cnt++) + { + entry = &gCacheEntries[cnt]; - // If the data was found copy it to the caller. - if (cnt != gCacheNumEntries) { - bcopy(gCacheBuffer + cnt * gCacheBlockSize, buffer, gCacheBlockSize); + if ((entry->ih == ih) && (entry->offset == offset)) + { + entry->time = ++gCacheTime; + break; + } + } + + // If the data was found copy it to the caller. + if (cnt != gCacheNumEntries) + { + bcopy(gCacheBuffer + cnt * gCacheBlockSize, buffer, gCacheBlockSize); #if CACHE_STATS - gCacheHits++; + gCacheHits++; #endif - return gCacheBlockSize; - } + return gCacheBlockSize; + } - // Could not find the data in the cache. - loadCache = 1; - } + // Could not find the data in the cache. + loadCache = 1; + } - // Read the data from the disk. - Seek(ih, offset); - Read(ih, (long)buffer, length); + // Read the data from the disk. + Seek(ih, offset); + Read(ih, (long)buffer, length); + #if CACHE_STATS - if (cache) gCacheMisses++; + if (cache) + { + gCacheMisses++; + } #endif - // Put the data from the disk in the cache if needed. - if (loadCache) { - // Find a free entry. - oldestTime = gCacheTime; - for (cnt = 0; cnt < gCacheNumEntries; cnt++) { - entry = &gCacheEntries[cnt]; + // Put the data from the disk in the cache if needed. + if (loadCache) + { + // Find a free entry. + oldestTime = gCacheTime; - // Found a free entry. - if (entry->ih == 0) break; - - if (entry->time < oldestTime) { - oldestTime = entry->time; - oldestEntry = cnt; - } - } + for (cnt = 0; cnt < gCacheNumEntries; cnt++) + { + entry = &gCacheEntries[cnt]; - // If no free entry was found, use the oldest. - if (cnt == gCacheNumEntries) { - cnt = oldestEntry; + // Found a free entry. + if (entry->ih == 0) + { + break; + } + + if (entry->time < oldestTime) + { + oldestTime = entry->time; + oldestEntry = cnt; + } + } + + // If no free entry was found, use the oldest. + if (cnt == gCacheNumEntries) + { + cnt = oldestEntry; #if CACHE_STATS - gCacheEvicts++; + gCacheEvicts++; #endif - } + } - // Copy the data from disk to the new entry. - entry = &gCacheEntries[cnt]; - entry->ih = ih; - entry->time = ++gCacheTime; - entry->offset = offset; - bcopy(buffer, gCacheBuffer + cnt * gCacheBlockSize, gCacheBlockSize); - } + // Copy the data from disk to the new entry. + entry = &gCacheEntries[cnt]; + entry->ih = ih; + entry->time = ++gCacheTime; + entry->offset = offset; + bcopy(buffer, gCacheBuffer + cnt * gCacheBlockSize, gCacheBlockSize); + } - return length; + return length; } Index: branches/chucko/i386/libsaio/pci.c =================================================================== --- branches/chucko/i386/libsaio/pci.c (revision 2328) +++ branches/chucko/i386/libsaio/pci.c (revision 2329) @@ -83,7 +83,11 @@ continue; } new = (pci_dt_t*)malloc(sizeof(pci_dt_t)); + if (!new) { + continue; + } bzero(new, sizeof(pci_dt_t)); + new->dev.addr = pci_addr; new->vendor_id = id & 0xffff; new->device_id = (id >> 16) & 0xffff; @@ -91,6 +95,7 @@ new->revision_id = pci_config_read8(pci_addr, PCI_CLASS_REVISION); new->subsys_id.subsys_id = pci_config_read32(pci_addr, PCI_SUBSYSTEM_VENDOR_ID); new->class_id = pci_config_read16(pci_addr, PCI_CLASS_DEVICE); + //new->subclass_id = pci_config_read16(pci_addr, PCI_SUBCLASS_DEVICE); new->parent = start; header_type = pci_config_read8(pci_addr, PCI_HEADER_TYPE); @@ -102,6 +107,8 @@ scan_pci_bus(new, secondary_bus); } break; + default: + break; } *current = new; current = &new->next; @@ -124,7 +131,7 @@ { return; } - rcba = pci_config_read32(PCIADDR(0, 0x1f, 0), 0xf0) & ~1; + rcba = pci_config_read32(PCIADDR(0, 0x1f, 0), 0xf0) & ~1; //this is LPC host fd = (uint32_t *)(rcba + 0x3418); /* set SMBus Disable (SD) to 0 */ *fd &= ~0x8; @@ -136,6 +143,11 @@ void build_pci_dt(void) { root_pci_dev = malloc(sizeof(pci_dt_t)); + + if (!root_pci_dev) { + return; + } + bzero(root_pci_dev, sizeof(pci_dt_t)); enable_pci_devs(); scan_pci_bus(root_pci_dev, 0); @@ -151,7 +163,7 @@ { pci_dt_t *current; pci_dt_t *end; - int dev_path_len = 0; + int dev_path_len = 0; dev_path[0] = 0; end = root_pci_dev; @@ -159,19 +171,20 @@ int uid = getPciRootUID(); while (end != pci_dt) { - current = pci_dt; - while (current->parent != end) - current = current->parent; - end = current; - if (current->parent == root_pci_dev) { - dev_path_len += - snprintf(dev_path + dev_path_len, sizeof(dev_path) - dev_path_len, "PciRoot(0x%x)/Pci(0x%x,0x%x)", uid, - current->dev.bits.dev, current->dev.bits.func); - } else { - dev_path_len += - snprintf(dev_path + dev_path_len, sizeof(dev_path) - dev_path_len, "/Pci(0x%x,0x%x)", - current->dev.bits.dev, current->dev.bits.func); - } + current = pci_dt; + while (current->parent != end) + current = current->parent; + end = current; + if (current->parent == root_pci_dev) { + dev_path_len += + snprintf(dev_path + dev_path_len, sizeof(dev_path) - dev_path_len, "PciRoot(0x%x)/Pci(0x%x,0x%x)", uid, + current->dev.bits.dev, current->dev.bits.func); + } else { + dev_path_len += + snprintf(dev_path + dev_path_len, sizeof(dev_path) - dev_path_len, "/Pci(0x%x,0x%x)", + current->dev.bits.dev, current->dev.bits.func); + } + } return dev_path; } @@ -184,8 +197,8 @@ while (current) { printf("%02x:%02x.%x [%04x%02x] [%04x:%04x] (subsys [%04x:%04x]):: %s\n", current->dev.bits.bus, current->dev.bits.dev, current->dev.bits.func, - current->class_id, 0 /* FIXME: what should this be? */, - current->vendor_id, current->device_id, + current->class_id, 0 /* FIXME: what should this be? */, + current->vendor_id, current->device_id, current->subsys_id.subsys.vendor_id, current->subsys_id.subsys.device_id, get_pci_dev_path(current)); dump_pci_dt(current->children); Index: branches/chucko/i386/libsaio/biosfn.c =================================================================== --- branches/chucko/i386/libsaio/biosfn.c (revision 2328) +++ branches/chucko/i386/libsaio/biosfn.c (revision 2329) @@ -48,57 +48,70 @@ static biosBuf_t bb; + +//============================================================================== + int bgetc(void) { - /* Poll for the next character. Most real BIOS do not need this as the - INT 16h,AH=0h function will block until one is received. - Unfortunately, Apple's EFI CSM will never wake up. This idea is lifted - from the grub-a20.patch to GRUB's stage2/asm.S file. - */ - while(!readKeyboardStatus()) - ; - bb.intno = 0x16; - bb.eax.r.h = 0x00; - bios(&bb); - return bb.eax.rr; + /* Poll for the next character. Most real BIOS do not need this as the + INT 16h,AH=0h function will block until one is received. + Unfortunately, Apple's EFI CSM will never wake up. This idea is lifted + from the grub-a20.patch to GRUB's stage2/asm.S file. + */ + while(!readKeyboardStatus()); + + bb.intno = 0x16; + bb.eax.r.h = 0x00; + bios(&bb); + + return bb.eax.rr; } + +//============================================================================== + int readKeyboardStatus(void) { - bb.intno = 0x16; - bb.eax.r.h = 0x01; - bios(&bb); - if (bb.flags.zf) { - return 0; - } else { - return bb.eax.rr; - } + bb.intno = 0x16; + bb.eax.r.h = 0x01; + bios(&bb); + + if (bb.flags.zf) { + return 0; + } else { + return bb.eax.rr; + } } int readKeyboardShiftFlags(void) { - bb.intno = 0x16; - bb.eax.r.h = 0x02; - bios(&bb); - return bb.eax.r.l; + bb.intno = 0x16; + bb.eax.r.h = 0x02; + bios(&bb); + return bb.eax.r.l; } + +//============================================================================== + unsigned int time18(void) { - union { - struct { - unsigned int low:16; - unsigned int high:16; - } s; - unsigned int i; - } time; + union { + struct { + unsigned int low:16; + unsigned int high:16; + } s; + + unsigned int i; + } time; - bb.intno = 0x1a; - bb.eax.r.h = 0x00; - bios(&bb); - time.s.low = bb.edx.rr; - time.s.high = bb.ecx.rr; - return time.i; + bb.intno = 0x1a; + bb.eax.r.h = 0x00; + bios(&bb); + time.s.low = bb.edx.rr; + time.s.high = bb.ecx.rr; + + return time.i; } #if 0 @@ -165,311 +178,349 @@ unsigned long * conMemSizePtr, unsigned long * extMemSizePtr ) { - #define kMemoryMapSignature 'SMAP' - #define kDescriptorSizeMin 20 + #define kMemoryMapSignature 'SMAP' + #define kDescriptorSizeMin 20 - MemoryRange * range = (MemoryRange *)BIOS_ADDR; - unsigned long count = 0; - // unsigned long rerangedCount; - unsigned long long conMemSize = 0; - unsigned long long extMemSize = 0; + MemoryRange * range = (MemoryRange *)BIOS_ADDR; + unsigned long count = 0; + // unsigned long rerangedCount; + unsigned long long conMemSize = 0; + unsigned long long extMemSize = 0; - // Prepare for the INT15 E820h call. Each call returns a single - // memory range. A continuation value is returned that must be - // provided on a subsequent call to fetch the next range. - // - // Certain BIOSes (Award 6.00PG) expect the upper word in EAX - // to be cleared on entry, otherwise only a single range will - // be reported. - // - // Some BIOSes will simply ignore the value of ECX on entry. - // Probably best to keep its value at 20 to avoid surprises. + // Prepare for the INT15 E820h call. Each call returns a single + // memory range. A continuation value is returned that must be + // provided on a subsequent call to fetch the next range. + // + // Certain BIOSes (Award 6.00PG) expect the upper word in EAX + // to be cleared on entry, otherwise only a single range will + // be reported. + // + // Some BIOSes will simply ignore the value of ECX on entry. + // Probably best to keep its value at 20 to avoid surprises. - //printf("Get memory map 0x%x, %d\n", rangeArray); getchar(); - if (maxRangeCount > (BIOS_LEN / sizeof(MemoryRange))) { - maxRangeCount = (BIOS_LEN / sizeof(MemoryRange)); - } - bb.ebx.rx = 0; // Initial continuation value must be zero. + //printf("Get memory map 0x%x, %d\n", rangeArray); getchar(); + if (maxRangeCount > (BIOS_LEN / sizeof(MemoryRange))) { + maxRangeCount = (BIOS_LEN / sizeof(MemoryRange)); + } + bb.ebx.rx = 0; // Initial continuation value must be zero. - while ( count < maxRangeCount ) - { - bb.intno = 0x15; - bb.eax.rx = 0xe820; - bb.ecx.rx = kDescriptorSizeMin; - bb.edx.rx = kMemoryMapSignature; - bb.edi.rr = NORMALIZED_OFFSET( (unsigned long) range ); - bb.es = NORMALIZED_SEGMENT( (unsigned long) range ); - bios(&bb); + while (count < maxRangeCount) + { + bb.intno = 0x15; + bb.eax.rx = 0xe820; + bb.ecx.rx = kDescriptorSizeMin; + bb.edx.rx = kMemoryMapSignature; + bb.edi.rr = NORMALIZED_OFFSET( (unsigned long) range ); + bb.es = NORMALIZED_SEGMENT( (unsigned long) range ); + bios(&bb); - // Check for errors. + // Check for errors. - if ( bb.flags.cf - || bb.eax.rx != kMemoryMapSignature - || bb.ecx.rx != kDescriptorSizeMin ) { - //printf("Got an error %x %x %x\n", bb.flags.cf, - // bb.eax.rx, bb.ecx.rx); - break; - } + if ( bb.flags.cf + || bb.eax.rx != kMemoryMapSignature + || bb.ecx.rx != kDescriptorSizeMin ) { + //printf("Got an error %x %x %x\n", bb.flags.cf, + // bb.eax.rx, bb.ecx.rx); + break; + } - // Tally up the conventional/extended memory sizes. + // Tally up the conventional/extended memory sizes. - if ( range->type == kMemoryRangeUsable || - range->type == kMemoryRangeACPI || - range->type == kMemoryRangeNVS ) - { - // Tally the conventional memory ranges. - if ( range->base + range->length <= 0xa0000 ) { - conMemSize += range->length; - } + if ( range->type == kMemoryRangeUsable || + range->type == kMemoryRangeACPI || + range->type == kMemoryRangeNVS ) { + // Tally the conventional memory ranges. + if ( range->base + range->length <= 0xa0000 ) { + conMemSize += range->length; + } - // Record the top of extended memory. - if ( range->base >= EXTENDED_ADDR ) { - extMemSize += range->length; - } - } + // Record the top of extended memory. + if (range->base >= EXTENDED_ADDR) { + extMemSize += range->length; + } + } - range++; - count++; + range++; + count++; - // Is this the last address range? + // Is this the last address range? - if ( bb.ebx.rx == 0 ) { - //printf("last range\n"); - break; - } - } - *conMemSizePtr = conMemSize / 1024; // size in KB - *extMemSizePtr = extMemSize / 1024; // size in KB + if ( bb.ebx.rx == 0 ) { + //printf("last range\n"); + break; + } + } + *conMemSizePtr = conMemSize / 1024; // size in KB + *extMemSizePtr = extMemSize / 1024; // size in KB #if 0 - rerangedCount = rerangeMemoryMap(count); - range += rerangedCount - count; + rerangedCount = rerangeMemoryMap(count); + range += rerangedCount - count; #endif - // Copy out data - bcopy((char *)BIOS_ADDR, rangeArray, ((char *)range - (char *)BIOS_ADDR)); + // Copy out data + bcopy((char *)BIOS_ADDR, rangeArray, ((char *)range - (char *)BIOS_ADDR)); #if DEBUG - { - int i; - printf("%d total ranges\n", count); getchar(); - for (i=0, range = rangeArray; itype, (unsigned int)range->base, (unsigned int)range->length); getchar(); - } - } + { + int i; + printf("%d total ranges\n", count); + + getchar(); + + for (i = 0, range = rangeArray; itype, (unsigned int)range->base, (unsigned int)range->length); + getchar(); + } + } #endif - return count; + return count; } + +//============================================================================== + + unsigned long getExtendedMemorySize() { - // Get extended memory size for large configurations. Not used unless - // the INT15, E820H call (Get System Address Map) failed. - // - // Input: - // - // AX Function Code E801h - // - // Outputs: - // - // CF Carry Flag Carry cleared indicates no error. - // AX Extended 1 Number of contiguous KB between 1 and 16 MB, - // maximum 0x3C00 = 15 MB. - // BX Extended 2 Number of contiguous 64 KB blocks between - // 16 MB and 4 GB. - // CX Configured 1 Number of contiguous KB between 1 and 16 MB, - // maximum 0x3C00 = 15 MB. - // DX Configured 2 Number of contiguous 64 KB blocks between - // 16 MB and 4 GB. + // Get extended memory size for large configurations. Not used unless + // the INT15, E820H call (Get System Address Map) failed. + // + // Input: + // + // AX Function Code E801h + // + // Outputs: + // + // CF Carry Flag Carry cleared indicates no error. + // AX Extended 1 Number of contiguous KB between 1 and 16 MB, + // maximum 0x3C00 = 15 MB. + // BX Extended 2 Number of contiguous 64 KB blocks between + // 16 MB and 4 GB. + // CX Configured 1 Number of contiguous KB between 1 and 16 MB, + // maximum 0x3C00 = 15 MB. + // DX Configured 2 Number of contiguous 64 KB blocks between + // 16 MB and 4 GB. - bb.intno = 0x15; - bb.eax.rx = 0xe801; - bios(&bb); + bb.intno = 0x15; + bb.eax.rx = 0xe801; + bios(&bb); - // Return the size of memory above 1MB (extended memory) in kilobytes. + // Return the size of memory above 1MB (extended memory) in kilobytes. - if ( bb.flags.cf == 0 ) return (bb.ebx.rr * 64 + bb.eax.rr); + if (bb.flags.cf == 0) { + return (bb.ebx.rr * 64 + bb.eax.rr); + } - // Get Extended memory size. Called on last resort since the return - // value is limited to 16-bits (a little less than 64MB max). May - // not be supported by modern BIOSes. - // - // Input: - // - // AX Function Code E801h - // - // Outputs: - // - // CF Carry Flag Carry cleared indicates no error. - // AX Memory Count Number of contiguous KB above 1MB. + // Get Extended memory size. Called on last resort since the return + // value is limited to 16-bits (a little less than 64MB max). May + // not be supported by modern BIOSes. + // + // Input: + // + // AX Function Code E801h + // + // Outputs: + // + // CF Carry Flag Carry cleared indicates no error. + // AX Memory Count Number of contiguous KB above 1MB. - bb.intno = 0x15; - bb.eax.rx = 0x88; - bios(&bb); + bb.intno = 0x15; + bb.eax.rx = 0x88; + bios(&bb); - // Return the size of memory above 1MB (extended memory) in kilobytes. + // Return the size of memory above 1MB (extended memory) in kilobytes. - return bb.flags.cf ? 0 : bb.eax.rr; + return bb.flags.cf ? 0 : bb.eax.rr; } + +//============================================================================== + + unsigned long getConventionalMemorySize() { - bb.intno = 0x12; - bios(&bb); - return bb.eax.rr; // kilobytes + bb.intno = 0x12; + bios(&bb); + + return bb.eax.rr; // kilobytes } + +//============================================================================== + + void video_mode(int mode) { - bb.intno = 0x10; - bb.eax.r.h = 0x00; - bb.eax.r.l = mode; - bios(&bb); + bb.intno = 0x10; + bb.eax.r.h = 0x00; + bb.eax.r.l = mode; + bios(&bb); } + +//============================================================================== + int biosread(int dev, int cyl, int head, int sec, int num) { - int i; + int i; - bb.intno = 0x13; - sec += 1; /* sector numbers start at 1 */ + bb.intno = 0x13; + sec += 1; // sector numbers start at 1. - for (i=0;;) { - bb.ecx.r.h = cyl; - bb.ecx.r.l = ((cyl & 0x300) >> 2) | (sec & 0x3F); - bb.edx.r.h = head; - bb.edx.r.l = dev; - bb.eax.r.l = num; - bb.ebx.rr = OFFSET(ptov(BIOS_ADDR)); - bb.es = SEGMENT(ptov(BIOS_ADDR)); + for (i = 0; ;) { + bb.ecx.r.h = cyl; + bb.ecx.r.l = ((cyl & 0x300) >> 2) | (sec & 0x3F); + bb.edx.r.h = head; + bb.edx.r.l = dev; + bb.eax.r.l = num; + bb.ebx.rr = OFFSET(ptov(BIOS_ADDR)); + bb.es = SEGMENT(ptov(BIOS_ADDR)); - bb.eax.r.h = 0x02; - bios(&bb); + bb.eax.r.h = 0x02; + bios(&bb); - /* In case of a successful call, make sure we set AH (return code) to zero. */ - if (bb.flags.cf == 0) - bb.eax.r.h = 0; + // In case of a successful call, make sure we set AH (return code) to zero. + if (bb.flags.cf == 0) { + bb.eax.r.h = 0; + } - /* Now we can really check for the return code (AH) value. */ - if ((bb.eax.r.h == 0x00) || (i++ >= 5)) - break; + // Now we can really check for the return code (AH) value. + if ((bb.eax.r.h == 0x00) || (i++ >= 5)) { + break; + } - /* reset disk subsystem and try again */ - bb.eax.r.h = 0x00; - bios(&bb); - } - return bb.eax.r.h; + // Reset disk subsystem and try again. + bb.eax.r.h = 0x00; + bios(&bb); + } + return bb.eax.r.h; } + +//============================================================================== + int ebiosread(int dev, unsigned long long sec, int count) { - int i; - static struct { - unsigned char size; - unsigned char reserved; - unsigned char numblocks; - unsigned char reserved2; - unsigned short bufferOffset; - unsigned short bufferSegment; - unsigned long long startblock; - } addrpacket __attribute__((aligned(16))) = {0}; - addrpacket.size = sizeof(addrpacket); + int i; - for (i=0;;) { - bb.intno = 0x13; - bb.eax.r.h = 0x42; - bb.edx.r.l = dev; - bb.esi.rr = NORMALIZED_OFFSET((unsigned)&addrpacket); - bb.ds = NORMALIZED_SEGMENT((unsigned)&addrpacket); - addrpacket.reserved = addrpacket.reserved2 = 0; - addrpacket.numblocks = count; - addrpacket.bufferOffset = OFFSET(ptov(BIOS_ADDR)); - addrpacket.bufferSegment = SEGMENT(ptov(BIOS_ADDR)); - addrpacket.startblock = sec; - bios(&bb); + static struct { + unsigned char size; + unsigned char reserved; + unsigned char numblocks; + unsigned char reserved2; + unsigned short bufferOffset; + unsigned short bufferSegment; + unsigned long long startblock; + } addrpacket __attribute__((aligned(16))) = {0}; + addrpacket.size = sizeof(addrpacket); - /* In case of a successful call, make sure we set AH (return code) to zero. */ - if (bb.flags.cf == 0) - bb.eax.r.h = 0; + for (i = 0; ;) { + bb.intno = 0x13; + bb.eax.r.h = 0x42; + bb.edx.r.l = dev; + bb.esi.rr = NORMALIZED_OFFSET((unsigned)&addrpacket); + bb.ds = NORMALIZED_SEGMENT((unsigned)&addrpacket); + addrpacket.reserved = addrpacket.reserved2 = 0; + addrpacket.numblocks = count; + addrpacket.bufferOffset = OFFSET(ptov(BIOS_ADDR)); + addrpacket.bufferSegment = SEGMENT(ptov(BIOS_ADDR)); + addrpacket.startblock = sec; + bios(&bb); - /* Now we can really check for the return code (AH) value. */ - if ((bb.eax.r.h == 0x00) || (i++ >= 5)) - break; + // In case of a successful call, make sure we set AH (return code) to zero. + if (bb.flags.cf == 0) { + bb.eax.r.h = 0; + } - /* reset disk subsystem and try again */ - bb.eax.r.h = 0x00; - bios(&bb); - } - return bb.eax.r.h; + // Now we can really check for the return code (AH) value. + if ((bb.eax.r.h == 0x00) || (i++ >= 5)) { + break; + } + + // Reset disk subsystem and try again. + bb.eax.r.h = 0x00; + bios(&bb); + } + + return bb.eax.r.h; } +//============================================================================== + int ebioswrite(int dev, long sec, int count) { - int i; - static struct { - unsigned char size; - unsigned char reserved; - unsigned char numblocks; - unsigned char reserved2; - unsigned short bufferOffset; - unsigned short bufferSegment; - unsigned long long startblock; - } addrpacket __attribute__((aligned(16))) = {0}; - addrpacket.size = sizeof(addrpacket); + int i; + static struct { + unsigned char size; + unsigned char reserved; + unsigned char numblocks; + unsigned char reserved2; + unsigned short bufferOffset; + unsigned short bufferSegment; + unsigned long long startblock; + } addrpacket __attribute__((aligned(16))) = {0}; + addrpacket.size = sizeof(addrpacket); - for (i=0;;) { - bb.intno = 0x13; - bb.eax.r.l = 0; /* Don't verify */ - bb.eax.r.h = 0x43; - bb.edx.r.l = dev; - bb.esi.rr = NORMALIZED_OFFSET((unsigned)&addrpacket); - bb.ds = NORMALIZED_SEGMENT((unsigned)&addrpacket); - addrpacket.reserved = addrpacket.reserved2 = 0; - addrpacket.numblocks = count; - addrpacket.bufferOffset = OFFSET(ptov(BIOS_ADDR)); - addrpacket.bufferSegment = SEGMENT(ptov(BIOS_ADDR)); - addrpacket.startblock = sec; - bios(&bb); + for (i=0;;) { + bb.intno = 0x13; + bb.eax.r.l = 0; /* Don't verify */ + bb.eax.r.h = 0x43; + bb.edx.r.l = dev; + bb.esi.rr = NORMALIZED_OFFSET((unsigned)&addrpacket); + bb.ds = NORMALIZED_SEGMENT((unsigned)&addrpacket); + addrpacket.reserved = addrpacket.reserved2 = 0; + addrpacket.numblocks = count; + addrpacket.bufferOffset = OFFSET(ptov(BIOS_ADDR)); + addrpacket.bufferSegment = SEGMENT(ptov(BIOS_ADDR)); + addrpacket.startblock = sec; + bios(&bb); - /* In case of a successful call, make sure we set AH (return code) to zero. */ - if (bb.flags.cf == 0) - bb.eax.r.h = 0; + /* In case of a successful call, make sure we set AH (return code) to zero. */ + if (bb.flags.cf == 0) + bb.eax.r.h = 0; - /* Now we can really check for the return code (AH) value. */ - if ((bb.eax.r.h == 0x00) || (i++ >= 5)) - break; + /* Now we can really check for the return code (AH) value. */ + if ((bb.eax.r.h == 0x00) || (i++ >= 5)) + break; - /* reset disk subsystem and try again */ - bb.eax.r.h = 0x00; - bios(&bb); - } - return bb.eax.r.h; + /* reset disk subsystem and try again */ + bb.eax.r.h = 0x00; + bios(&bb); + } + return bb.eax.r.h; } void bios_putchar(int ch) { - bb.intno = 0x10; - bb.ebx.r.h = 0x00; /* background black */ - bb.ebx.r.l = 0x0F; /* foreground white */ - bb.eax.r.h = 0x0e; - bb.eax.r.l = ch; - bios(&bb); + bb.intno = 0x10; + bb.ebx.r.h = 0x00; /* background black */ + bb.ebx.r.l = 0x0F; /* foreground white */ + bb.eax.r.h = 0x0e; + bb.eax.r.l = ch; + bios(&bb); } + +//============================================================================== + void putca(int ch, int attr, int repeat) { - bb.intno = 0x10; - bb.ebx.r.h = 0x00; /* page number */ - bb.ebx.r.l = attr; /* attribute */ - bb.eax.r.h = 0x9; - bb.eax.r.l = ch; - bb.ecx.rx = repeat; /* repeat count */ - bios(&bb); + bb.intno = 0x10; + bb.ebx.r.h = 0x00; /* page number */ + bb.ebx.r.l = attr; /* attribute */ + bb.eax.r.h = 0x9; + bb.eax.r.l = ch; + bb.ecx.rx = repeat; /* repeat count */ + bios(&bb); } -/* Check to see if the passed-in drive is in El Torito no-emulation mode. */ + +//============================================================================== +// Check to see if the passed-in drive is in El Torito no-emulation mode. + int is_no_emulation(int drive) { struct packet { @@ -488,30 +539,30 @@ unsigned char reseved; } __attribute__((packed)); static struct packet pkt; - + bzero(&pkt, sizeof(pkt)); pkt.packet_size = 0x13; - - bb.intno = 0x13; - bb.eax.r.h = 0x4b; - bb.eax.r.l = 0x01; // subfunc: get info - bb.edx.r.l = drive; - bb.esi.rr = NORMALIZED_OFFSET((unsigned)&pkt); - bb.ds = NORMALIZED_SEGMENT((unsigned)&pkt); - + + bb.intno = 0x13; + bb.eax.r.h = 0x4b; + bb.eax.r.l = 0x01; // subfunc: get info + bb.edx.r.l = drive; + bb.esi.rr = NORMALIZED_OFFSET((unsigned)&pkt); + bb.ds = NORMALIZED_SEGMENT((unsigned)&pkt); + bios(&bb); + #if DEBUG printf("el_torito info drive %x\n", drive); - printf("--> cf %x, eax %x\n", bb.flags.cf, bb.eax.rr); - printf("pkt_size: %x\n", pkt.packet_size); printf("media_type: %x\n", pkt.media_type); printf("drive_num: %x\n", pkt.drive_num); printf("device_spec: %x\n", pkt.device_spec); + pause(); #endif - + /* Some BIOSes erroneously return cf = 1 */ /* Just check to see if the drive number is the same. */ if (pkt.drive_num == drive) { @@ -568,28 +619,34 @@ #endif +//============================================================================== + int get_drive_info(int drive, struct driveInfo *dp) { + int ret = 0; + boot_drive_info_t *di = &dp->di; - int ret = 0; - + #if UNUSED if (maxhd == 0) { bb.intno = 0x13; bb.eax.r.h = 0x08; bb.edx.r.l = 0x80; bios(&bb); - if (bb.flags.cf == 0) + + if (bb.flags.cf == 0) { maxhd = 0x7f + bb.edx.r.l; + } }; - - if (drive > maxhd) + + if (drive > maxhd) { return 0; + } #endif - + bzero(dp, sizeof(struct driveInfo)); dp->biosdev = drive; - + /* Check for El Torito no-emulation mode. */ dp->no_emulation = is_no_emulation(drive); @@ -620,9 +677,7 @@ if (bb.flags.cf != 0 /* || params.phys_sectors < 2097152 */) { dp->uses_ebios = 0; di->params.buf_size = 1; - } - else - { + } else { bcopy(¶ms, &di->params, sizeof(params)); if (drive >= BASE_HD_DRIVE && @@ -684,101 +739,102 @@ return ret; } +//============================================================================== + int ebiosEjectMedia(int biosdev) { - bb.intno = 0x13; - bb.eax.r.h = 0x46; - bb.eax.r.l = 0; - bb.edx.rx = biosdev; - bios(&bb); - return bb.eax.r.h; + bb.intno = 0x13; + bb.eax.r.h = 0x46; + bb.eax.r.l = 0; + bb.edx.rx = biosdev; + bios(&bb); + return bb.eax.r.h; } void setCursorPosition(int x, int y, int page) { - bb.intno = 0x10; - bb.eax.r.h = 0x02; - bb.ebx.r.h = page; /* page 0 for graphics */ - bb.edx.r.l = x; - bb.edx.r.h = y; - bios(&bb); + bb.intno = 0x10; + bb.eax.r.h = 0x02; + bb.ebx.r.h = page; /* page 0 for graphics */ + bb.edx.r.l = x; + bb.edx.r.h = y; + bios(&bb); } void setCursorType(int type) { - bb.intno = 0x10; - bb.eax.r.h = 0x01; - bb.ecx.rr = type; - bios(&bb); + bb.intno = 0x10; + bb.eax.r.h = 0x01; + bb.ecx.rr = type; + bios(&bb); } void getCursorPositionAndType(int * x, int * y, int * type) { - bb.intno = 0x10; - bb.eax.r.h = 0x03; - bios(&bb); - *x = bb.edx.r.l; - *y = bb.edx.r.h; - *type = bb.ecx.rr; + bb.intno = 0x10; + bb.eax.r.h = 0x03; + bios(&bb); + *x = bb.edx.r.l; + *y = bb.edx.r.h; + *type = bb.ecx.rr; } void scollPage(int x1, int y1, int x2, int y2, int attr, int rows, int dir) { - bb.intno = 0x10; - bb.eax.r.h = (dir > 0) ? 0x06 : 0x07; - bb.eax.r.l = rows; - bb.ebx.r.h = attr; - bb.ecx.r.h = y1; - bb.ecx.r.l = x1; - bb.edx.r.h = y2; - bb.edx.r.l = x2; - bios(&bb); + bb.intno = 0x10; + bb.eax.r.h = (dir > 0) ? 0x06 : 0x07; + bb.eax.r.l = rows; + bb.ebx.r.h = attr; + bb.ecx.r.h = y1; + bb.ecx.r.l = x1; + bb.edx.r.h = y2; + bb.edx.r.l = x2; + bios(&bb); } void clearScreenRows( int y1, int y2 ) { - scollPage( 0, y1, 80 - 1, y2, 0x07, y2 - y1 + 1, 1 ); + scollPage( 0, y1, 80 - 1, y2, 0x07, y2 - y1 + 1, 1 ); } void setActiveDisplayPage( int page ) { - bb.intno = 0x10; - bb.eax.r.h = 5; - bb.eax.r.l = page; - bios(&bb); + bb.intno = 0x10; + bb.eax.r.h = 5; + bb.eax.r.l = page; + bios(&bb); } #if DEBUG int terminateDiskEmulation() { - static char cd_spec[0x13]; + static char cd_spec[0x13]; - bb.intno = 0x13; - bb.eax.r.h = 0x4b; - bb.eax.r.l = 0; // subfunc: terminate emulation - bb.esi.rr = NORMALIZED_OFFSET((unsigned)&cd_spec); - bb.ds = NORMALIZED_SEGMENT((unsigned)&cd_spec); - bios(&bb); - return bb.eax.r.h; + bb.intno = 0x13; + bb.eax.r.h = 0x4b; + bb.eax.r.l = 0; // subfunc: terminate emulation + bb.esi.rr = NORMALIZED_OFFSET((unsigned)&cd_spec); + bb.ds = NORMALIZED_SEGMENT((unsigned)&cd_spec); + bios(&bb); + return bb.eax.r.h; } int readDriveParameters(int drive, struct driveParameters *dp) { - bb.intno = 0x13; - bb.edx.r.l = drive; - bb.eax.r.h = 0x08; - bios(&bb); - if (bb.eax.r.h == 0) { - dp->heads = bb.edx.r.h; - dp->sectors = bb.ecx.r.l & 0x3F; - dp->cylinders = bb.ecx.r.h | ((bb.ecx.r.l & 0xC0) << 2); - dp->totalDrives = bb.edx.r.l; - } else { - bzero(dp, sizeof(*dp)); - } - return bb.eax.r.h; - + bb.intno = 0x13; + bb.edx.r.l = drive; + bb.eax.r.h = 0x08; + bios(&bb); + if (bb.eax.r.h == 0) { + dp->heads = bb.edx.r.h; + dp->sectors = bb.ecx.r.l & 0x3F; + dp->cylinders = bb.ecx.r.h | ((bb.ecx.r.l & 0xC0) << 2); + dp->totalDrives = bb.edx.r.l; + } else { + bzero(dp, sizeof(*dp)); + } + return bb.eax.r.h; } #endif @@ -790,49 +846,46 @@ int APMPresent(void) { - bb.intno = APM_INTNO; - bb.eax.r.h = APM_INTCODE; - bb.eax.r.l = 0x00; - bb.ebx.rr = 0x0000; - bios(&bb); - if ((bb.flags.cf == 0) && - (bb.ebx.r.h == 'P') && - (bb.ebx.r.l == 'M')) { - /* Success */ - bootArgs->apmConfig.major_vers = bb.eax.r.h; - bootArgs->apmConfig.minor_vers = bb.eax.r.l; - bootArgs->apmConfig.flags.data = bb.ecx.rr; - return 1; - } - return 0; + bb.intno = APM_INTNO; + bb.eax.r.h = APM_INTCODE; + bb.eax.r.l = 0x00; + bb.ebx.rr = 0x0000; + bios(&bb); + if ((bb.flags.cf == 0) && (bb.ebx.r.h == 'P') && (bb.ebx.r.l == 'M')) { + /* Success */ + bootArgs->apmConfig.major_vers = bb.eax.r.h; + bootArgs->apmConfig.minor_vers = bb.eax.r.l; + bootArgs->apmConfig.flags.data = bb.ecx.rr; + return 1; + } + return 0; } int APMConnect32(void) { - bb.intno = APM_INTNO; - bb.eax.r.h = APM_INTCODE; - bb.eax.r.l = 0x03; - bb.ebx.rr = 0x0000; - bios(&bb); - if (bb.flags.cf == 0) { - /* Success */ - bootArgs->apmConfig.cs32_base = (bb.eax.rr) << 4; - bootArgs->apmConfig.entry_offset = bb.ebx.rx; - bootArgs->apmConfig.cs16_base = (bb.ecx.rr) << 4; - bootArgs->apmConfig.ds_base = (bb.edx.rr) << 4; - if (bootArgs->apmConfig.major_vers >= 1 && - bootArgs->apmConfig.minor_vers >= 1) { - bootArgs->apmConfig.cs_length = bb.esi.rr; - bootArgs->apmConfig.ds_length = bb.edi.rr; - } else { - bootArgs->apmConfig.cs_length = - bootArgs->apmConfig.ds_length = 64 * 1024; - } - bootArgs->apmConfig.connected = 1; - return 1; - } - return 0; + bb.intno = APM_INTNO; + bb.eax.r.h = APM_INTCODE; + bb.eax.r.l = 0x03; + bb.ebx.rr = 0x0000; + bios(&bb); + if (bb.flags.cf == 0) { + /* Success */ + bootArgs->apmConfig.cs32_base = (bb.eax.rr) << 4; + bootArgs->apmConfig.entry_offset = bb.ebx.rx; + bootArgs->apmConfig.cs16_base = (bb.ecx.rr) << 4; + bootArgs->apmConfig.ds_base = (bb.edx.rr) << 4; + if (bootArgs->apmConfig.major_vers >= 1 && bootArgs->apmConfig.minor_vers >= 1) { + bootArgs->apmConfig.cs_length = bb.esi.rr; + bootArgs->apmConfig.ds_length = bb.edi.rr; + } else { + bootArgs->apmConfig.cs_length = + bootArgs->apmConfig.ds_length = 64 * 1024; + } + bootArgs->apmConfig.connected = 1; + return 1; + } + return 0; } #endif /* APM_SUPPORT */ @@ -840,64 +893,65 @@ #ifdef EISA_SUPPORT bool eisa_present(void) { - static bool checked = false; - static bool isEISA; + static bool checked = false; + static bool isEISA; - if (!checked) { - if (strncmp((char *)0xfffd9, "EISA", 4) == 0) - isEISA = true; - - checked = true; - } - - return (isEISA); + if (!checked) { + if (strncmp((char *)0xfffd9, "EISA", 4) == 0) { + isEISA = true; + } + checked = true; + } + return (isEISA); } int ReadEISASlotInfo(EISA_slot_info_t *ep, int slot) { - union { - struct { - unsigned char char2h :2; - unsigned char char1 :5; - unsigned char char3 :5; - unsigned char char2l :3; - unsigned char d2 :4; - unsigned char d1 :4; - unsigned char d4 :4; - unsigned char d3 :4; - } s; - unsigned char data[4]; - } u; - static char hex[0x10] = "0123456789ABCDEF"; + union + { + struct + { + unsigned char char2h :2; + unsigned char char1 :5; + unsigned char char3 :5; + unsigned char char2l :3; + unsigned char d2 :4; + unsigned char d1 :4; + unsigned char d4 :4; + unsigned char d3 :4; + } s; + unsigned char data[4]; + } u; + static char hex[0x10] = "0123456789ABCDEF"; - - bb.intno = 0x15; - bb.eax.r.h = 0xd8; - bb.eax.r.l = 0x00; - bb.ecx.r.l = slot; - bios(&bb); - if (bb.flags.cf) - return bb.eax.r.h; - ep->u_ID.d = bb.eax.r.l; - ep->configMajor = bb.ebx.r.h; - ep->configMinor = bb.ebx.r.l; - ep->checksum = bb.ecx.rr; - ep->numFunctions = bb.edx.r.h; - ep->u_resources.d = bb.edx.r.l; - u.data[0] = bb.edi.r.l; - u.data[1] = bb.edi.r.h; - u.data[2] = bb.esi.r.l; - u.data[3] = bb.esi.r.h; - ep->id[0] = u.s.char1 + ('A' - 1); - ep->id[1] = (u.s.char2l | (u.s.char2h << 3)) + ('A' - 1); - ep->id[2] = u.s.char3 + ('A' - 1); - ep->id[3] = hex[u.s.d1]; - ep->id[4] = hex[u.s.d2]; - ep->id[5] = hex[u.s.d3]; - ep->id[6] = hex[u.s.d4]; - ep->id[7] = 0; - return 0; + + bb.intno = 0x15; + bb.eax.r.h = 0xd8; + bb.eax.r.l = 0x00; + bb.ecx.r.l = slot; + bios(&bb); + if (bb.flags.cf) + return bb.eax.r.h; + ep->u_ID.d = bb.eax.r.l; + ep->configMajor = bb.ebx.r.h; + ep->configMinor = bb.ebx.r.l; + ep->checksum = bb.ecx.rr; + ep->numFunctions = bb.edx.r.h; + ep->u_resources.d = bb.edx.r.l; + u.data[0] = bb.edi.r.l; + u.data[1] = bb.edi.r.h; + u.data[2] = bb.esi.r.l; + u.data[3] = bb.esi.r.h; + ep->id[0] = u.s.char1 + ('A' - 1); + ep->id[1] = (u.s.char2l | (u.s.char2h << 3)) + ('A' - 1); + ep->id[2] = u.s.char3 + ('A' - 1); + ep->id[3] = hex[u.s.d1]; + ep->id[4] = hex[u.s.d2]; + ep->id[5] = hex[u.s.d3]; + ep->id[6] = hex[u.s.d4]; + ep->id[7] = 0; + return 0; } /* @@ -907,18 +961,19 @@ int ReadEISAFuncInfo(EISA_func_info_t *ep, int slot, int function) { - bb.intno = 0x15; - bb.eax.r.h = 0xd8; - bb.eax.r.l = 0x01; - bb.ecx.r.l = slot; - bb.ecx.r.h = function; - bb.esi.rr = (unsigned int)ep->data; - bios(&bb); - if (bb.eax.r.h == 0) { - ep->slot = slot; - ep->function = function; - } - return bb.eax.r.h; + bb.intno = 0x15; + bb.eax.r.h = 0xd8; + bb.eax.r.l = 0x01; + bb.ecx.r.l = slot; + bb.ecx.r.h = function; + bb.esi.rr = (unsigned int)ep->data; + bios(&bb); + if (bb.eax.r.h == 0) + { + ep->slot = slot; + ep->function = function; + } + return bb.eax.r.h; } #endif /* EISA_SUPPORT */ @@ -927,19 +982,20 @@ int ReadPCIBusInfo(PCI_bus_info_t *pp) { - bb.intno = 0x1a; - bb.eax.r.h = 0xb1; - bb.eax.r.l = 0x01; - bios(&bb); - if ((bb.eax.r.h == 0) && (bb.edx.rx == PCI_SIGNATURE)) { - pp->BIOSPresent = 1; - pp->u_bus.d = bb.eax.r.l; - pp->majorVersion = bb.ebx.r.h; - pp->minorVersion = bb.ebx.r.l; - pp->maxBusNum = bb.ecx.r.l; - return 0; - } - return -1; + bb.intno = 0x1a; + bb.eax.r.h = 0xb1; + bb.eax.r.l = 0x01; + bios(&bb); + if ((bb.eax.r.h == 0) && (bb.edx.rx == PCI_SIGNATURE)) + { + pp->BIOSPresent = 1; + pp->u_bus.d = bb.eax.r.l; + pp->majorVersion = bb.ebx.r.h; + pp->minorVersion = bb.ebx.r.l; + pp->maxBusNum = bb.ecx.r.l; + return 0; + } + return -1; } void sleep(int n) @@ -948,6 +1004,9 @@ while (time18() < endtime); } + +//============================================================================== + void delay(int ms) { bb.intno = 0x15; Index: branches/chucko/i386/libsaio/pci.h =================================================================== --- branches/chucko/i386/libsaio/pci.h (revision 2328) +++ branches/chucko/i386/libsaio/pci.h (revision 2329) @@ -105,7 +105,7 @@ uint32_t signature; // 0x24506E50 '$PnP' uint8_t revision; // 1 uint8_t length; - uint16_t offset; + uint16_t offset; uint8_t checksum; uint32_t identifier; uint16_t manufacturer; Index: branches/chucko/i386/libsaio/saio_types.h =================================================================== --- branches/chucko/i386/libsaio/saio_types.h (revision 2328) +++ branches/chucko/i386/libsaio/saio_types.h (revision 2329) @@ -70,8 +70,8 @@ typedef struct { char plist[IO_CONFIG_DATA_SIZE]; // buffer for plist - TagPtr dictionary; // buffer for xml dictionary - bool canOverride; // flag to mark a dictionary can be overriden + TagPtr dictionary; // buffer for xml dictionary + bool canOverride; // flag to mark a dictionary can be overriden } config_file_t; /* @@ -79,48 +79,50 @@ */ struct boot_drive_info { struct drive_params { - unsigned short buf_size; - unsigned short info_flags; - unsigned long phys_cyls; - unsigned long phys_heads; - unsigned long phys_spt; - unsigned long long phys_sectors; - unsigned short phys_nbps; - unsigned short dpte_offset; - unsigned short dpte_segment; - unsigned short key; - unsigned char path_len; - unsigned char reserved1; - unsigned short reserved2; - unsigned char bus_type[4]; - unsigned char interface_type[8]; - unsigned char interface_path[8]; - unsigned char dev_path[8]; - unsigned char reserved3; - unsigned char checksum; + unsigned short buf_size; + unsigned short info_flags; + unsigned long phys_cyls; + unsigned long phys_heads; + unsigned long phys_spt; + unsigned long long phys_sectors; + unsigned short phys_nbps; + unsigned short dpte_offset; + unsigned short dpte_segment; + unsigned short key; + unsigned char path_len; + unsigned char reserved1; + unsigned short reserved2; + unsigned char bus_type[4]; + unsigned char interface_type[8]; + unsigned char interface_path[8]; + unsigned char dev_path[8]; + unsigned char reserved3; + unsigned char checksum; } params; + struct drive_dpte { - unsigned short io_port_base; - unsigned short control_port_base; - unsigned char head_flags; - unsigned char vendor_info; - unsigned char irq : 4; - unsigned char irq_unused : 4; - unsigned char block_count; - unsigned char dma_channel : 4; - unsigned char dma_type : 4; - unsigned char pio_type : 4; - unsigned char pio_unused : 4; - unsigned short option_flags; - unsigned short reserved; - unsigned char revision; - unsigned char checksum; - } dpte; + unsigned short io_port_base; + unsigned short control_port_base; + unsigned char head_flags; + unsigned char vendor_info; + unsigned char irq : 4; + unsigned char irq_unused : 4; + unsigned char block_count; + unsigned char dma_channel : 4; + unsigned char dma_type : 4; + unsigned char pio_type : 4; + unsigned char pio_unused : 4; + unsigned short option_flags; + unsigned short reserved; + unsigned char revision; + unsigned char checksum; + } dpte; } __attribute__((packed)); typedef struct boot_drive_info boot_drive_info_t; struct driveInfo { boot_drive_info_t di; + int uses_ebios; int no_emulation; int biosdev; @@ -131,7 +133,8 @@ unsigned char data[16]; } FinderInfo; -struct BootVolume; + +struct BootVolume; typedef struct BootVolume * BVRef; typedef struct BootVolume * CICell; @@ -172,33 +175,33 @@ #define BVSTRLEN 32 struct BootVolume { - BVRef next; /* list linkage pointer */ - int biosdev; /* BIOS device number */ - int type; /* device type (floppy, hd, network) */ - unsigned int flags; /* attribute flags */ - BVGetDescription description; /* BVGetDescription function */ - int part_no; /* partition number (1 based) */ - unsigned int part_boff; /* partition block offset */ - unsigned int part_type; /* partition type */ - unsigned int fs_boff; /* 1st block # of next read */ - unsigned int fs_byteoff; /* Byte offset for read within block */ - FSLoadFile fs_loadfile; /* FSLoadFile function */ - FSReadFile fs_readfile; /* FSReadFile function */ - FSGetDirEntry fs_getdirentry; /* FSGetDirEntry function */ - FSGetFileBlock fs_getfileblock; /* FSGetFileBlock function */ - FSGetUUID fs_getuuid; /* FSGetUUID function */ - unsigned int bps; /* bytes per sector for this device */ - char name[BVSTRLEN]; /* (name of partition) */ - char type_name[BVSTRLEN]; /* (type of partition, eg. Apple_HFS) */ - BVFree bv_free; /* BVFree function */ - uint32_t modTime; - char label[BVSTRLEN]; /* partition volume label */ - char altlabel[BVSTRLEN]; /* partition volume label */ - bool filtered; /* newFilteredBVChain() will set to TRUE */ - bool visible; /* will shown in the device list */ - char OSVersion[8]; - bool OSisServer; /* 1 = OS X server , 0 = OS X client */ - bool OSisInstaller; /* 1 = OS X Install partition / recover partition , 0 = OS X Install */ + BVRef next; /* list linkage pointer */ + int biosdev; /* BIOS device number */ + int type; /* device type (floppy, hd, network) */ + unsigned int flags; /* attribute flags */ + BVGetDescription description; /* BVGetDescription function */ + int part_no; /* partition number (1 based) */ + unsigned int part_boff; /* partition block offset */ + unsigned int part_type; /* partition type */ + unsigned int fs_boff; /* 1st block # of next read */ + unsigned int fs_byteoff; /* Byte offset for read within block */ + FSLoadFile fs_loadfile; /* FSLoadFile function */ + FSReadFile fs_readfile; /* FSReadFile function */ + FSGetDirEntry fs_getdirentry; /* FSGetDirEntry function */ + FSGetFileBlock fs_getfileblock; /* FSGetFileBlock function */ + FSGetUUID fs_getuuid; /* FSGetUUID function */ + unsigned int bps; /* bytes per sector for this device */ + char name[BVSTRLEN]; /* (name of partition) */ + char type_name[BVSTRLEN]; /* (type of partition, eg. Apple_HFS) */ + BVFree bv_free; /* BVFree function */ + uint32_t modTime; + char label[BVSTRLEN]; /* partition volume label */ + char altlabel[BVSTRLEN]; /* partition volume label */ + bool filtered; /* newFilteredBVChain() will set to TRUE */ + bool visible; /* will shown in the device list */ + char OSVersion[8]; + bool OSisServer; /* 1 = OS X server , 0 = OS X client */ + bool OSisInstaller; /* 1 = OS X Install partition / recover partition , 0 = OS X Install */ }; Index: branches/chucko/i386/libsaio/msdos.c =================================================================== --- branches/chucko/i386/libsaio/msdos.c (revision 2328) +++ branches/chucko/i386/libsaio/msdos.c (revision 2329) @@ -152,14 +152,20 @@ } buf=malloc (512); + if (!buf) + { + return -1; + } + /* - * Read the boot sector of the filesystem, and then check the - * boot signature. If not a dos boot sector then error out. - * - * NOTE: 2048 is a maximum sector size in current... - */ - Seek(ih, 0); - Read(ih, (long)buf, 512); + * Read the boot sector of the filesystem, and then check the + * boot signature. If not a dos boot sector then error out. + * + * NOTE: 2048 is a maximum sector size in current... + */ + + Seek(ih, 0); + Read(ih, (long)buf, 512); bsp = (union bootsector *)buf; b33 = (struct bpb33 *)bsp->bs33.bsBPB; @@ -167,20 +173,24 @@ b710 = (struct bpb710 *)bsp->bs710.bsBPB; - /* We only work with 512, 1024, and 2048 byte sectors */ - msdosbps = OSSwapLittleToHostInt16(b33->bpbBytesPerSec); - if ((msdosbps < 0x200) || (msdosbps & (msdosbps - 1)) || (msdosbps > 0x800)) + /* We only work with 512, 1024, and 2048 byte sectors */ + msdosbps = OSSwapLittleToHostInt16(b33->bpbBytesPerSec); + if ((msdosbps < 0x200) || (msdosbps & (msdosbps - 1)) || (msdosbps > 0x800)) { free (buf); return -1; } - /* Check to make sure valid sectors per cluster */ - spc = b33->bpbSecPerClust; - if ((spc == 0 ) || (spc & (spc - 1))) + /* Check to make sure valid sectors per cluster */ + spc = b33->bpbSecPerClust; + if ((spc == 0 ) || (spc & (spc - 1))) + { + free (buf); return -1; - - if (OSSwapLittleToHostInt16(b50->bpbRootDirEnts) == 0) { /* It's FAT32 */ + } + if (OSSwapLittleToHostInt16(b50->bpbRootDirEnts) == 0) + { + /* It's FAT32 */ if (memcmp(((struct extboot *)bsp->bs710.bsExt)->exFileSysType, "FAT32 ", 8)) { free (buf); @@ -234,6 +244,10 @@ char *cacheBuffer; cacheBuffer = malloc(MSDOS_CACHE_BLOCKSIZE); + if (!cacheBuffer) + { + return -1; + } CacheRead(ih, cacheBuffer, sectorOffset, MSDOS_CACHE_BLOCKSIZE, true); bcopy(cacheBuffer + relOffset, buf, size); free(cacheBuffer); @@ -294,7 +308,7 @@ readOffset += ((uint64_t)*cluster * (uint64_t)msdosfatbits) / 8; /* Read one sector of the FAT */ - readSector(ih, readOffset, tmpbuf, 4); + if (readSector(ih, readOffset, tmpbuf, 4) != 0) return 0; switch (msdosfatbits) { case 32: @@ -382,14 +396,14 @@ st->vfatchecksum = 0; st->vfatnumber = 0; st->nument++; - if ((!st->root16 &&st->nument * sizeof (struct direntry)>=msdosclustersize) - || (st->root16 &&st->nument * sizeof (struct direntry)>=msdosbps)) + if (((int)(!st->root16 &&st->nument * sizeof (struct direntry))>=msdosclustersize) + || ((int)(st->root16 &&st->nument * sizeof (struct direntry))>=msdosbps)) st->nument = 0; return dirp; } st->nument++; - if ((!st->root16 &&st->nument * sizeof (struct direntry)>=msdosclustersize) - || (st->root16 &&st->nument * sizeof (struct direntry)>=msdosbps)) + if (((int)(!st->root16 &&st->nument * sizeof (struct direntry))>=msdosclustersize) + || ((int)(st->root16 &&st->nument * sizeof (struct direntry))>=msdosbps)) st->nument = 0; } } @@ -649,10 +663,19 @@ st = (struct msdosdirstate *)(long) *dirIndex; if (!st) { - st=malloc (sizeof (*st)); + st=malloc (sizeof (struct msdosdirstate)); + if (!st) + { + return -1; + } if (dirPath[0]) { uint8_t *buf=malloc(msdosclustersize); + if (!buf) + { + free (st); + return -1; + } dirp = getdirpfrompath (ih, dirPath, buf); if (!dirp || !(dirp->deAttributes & ATTR_DIRECTORY)) { @@ -685,6 +708,12 @@ int i; for (i=0;vfatname[i];i++); *name = malloc (256); + if (!*name) + { + free (st->buf); + free (st); + return -1; + } utf_encodestr(vfatname, i, (u_int8_t *)*name, 255, OSLittleEndian ); } else @@ -692,6 +721,12 @@ int i, j, k; uint16_t tmp[13]; *name = malloc (26); + if (!*name) + { + free (st->buf); + free (st); + return -1; + } for (i=7;i>=0;i--) if (dirp->deName[i]!=' ') break; @@ -739,7 +774,7 @@ int toread, wastoread; char *ptr = (char *)base; struct direntry *dirp; - int i; + uint64_t i; char devStr[12]; if (MSDOSInitPartition (ih)<0) @@ -747,6 +782,10 @@ if (filePath[0] == '/') filePath++; buf = malloc(msdosclustersize); + if (!buf) + { + return -1; + } dirp = getdirpfrompath (ih, filePath, buf); if (!dirp || (dirp->deAttributes & ATTR_DIRECTORY)) @@ -759,7 +798,10 @@ cluster |= ((uint32_t)OSReadLittleInt16 ((dirp->deHighClust),0)) <<16; size = (uint32_t)OSReadLittleInt32 ((dirp->deFileSize),0); if (size<=offset) + { + free (buf); return -1; + } nskip=offset/msdosclustersize; for (i=0;isize-offset) toread=size-offset; wastoread=toread; - bcopy (buf+(offset%msdosclustersize),ptr,MIN(msdosclustersize-(offset%msdosclustersize), toread)); + bcopy (buf+(offset%msdosclustersize),ptr,MIN((msdosclustersize-(offset%msdosclustersize)),(unsigned)toread)); ptr+=msdosclustersize-(offset%msdosclustersize); toread-=msdosclustersize-(offset%msdosclustersize); while (toread>0 && msdosreadcluster (ih, (uint8_t *)ptr, MIN(msdosclustersize,toread), &cluster)) @@ -798,6 +840,10 @@ if (filePath[0] == '/') filePath++; buf = malloc(msdosclustersize); + if (!buf) + { + return -1; + } dirp = getdirpfrompath (ih, filePath, buf); if (!dirp || (dirp->deAttributes & ATTR_DIRECTORY)) { @@ -847,21 +893,21 @@ static void fixLabel(uint8_t *label, char *str, long strMaxLen) { - int i, len; - uint16_t labelucs[13]; - //unsigned char labelUTF8[LABEL_LENGTH*3]; + int i, len; + uint16_t labelucs[13]; + //unsigned char labelUTF8[LABEL_LENGTH*3]; - /* Convert leading 0x05 to 0xE5 for multibyte languages like Japanese */ - if (label[0] == 0x05) - label[0] = 0xE5; + /* Convert leading 0x05 to 0xE5 for multibyte languages like Japanese */ + if (label[0] == 0x05) + label[0] = 0xE5; - /* Remove any trailing spaces */ - for (i=LABEL_LENGTH-1; i>=0; --i) { - if (label[i] == ' ') + /* Remove any trailing spaces */ + for (i=LABEL_LENGTH-1; i>=0; --i) { + if (label[i] == ' ') label[i] = 0; - else - break; - } + else + break; + } labelucs[i++]=0; len=i; for (;i>=0;--i) @@ -874,8 +920,8 @@ void MSDOSGetDescription(CICell ih, char *str, long strMaxLen) { - struct direntry *dirp; - uint8_t label[LABEL_LENGTH+1]; + struct direntry *dirp; + uint8_t label[LABEL_LENGTH+1]; uint16_t vfatlabel[WIN_MAXLEN+2*WIN_CHARS]; struct msdosdirstate st; int labelfound = 0; @@ -885,11 +931,15 @@ str[0]=0; return; } - + label[0] = '\0'; initRoot (&st); st.buf = malloc(msdosclustersize); + if (!st.buf) + { + return; + } while ((dirp = getnextdirent (ih, vfatlabel, &st))) if (dirp->deAttributes & ATTR_VOLUME) { strncpy((char *)label, (char *)dirp->deName, LABEL_LENGTH); @@ -908,33 +958,46 @@ else if (labelfound) fixLabel(label, str, strMaxLen); - /* else look in the boot blocks */ - if (!labelfound || str[0] == '\0') { + /* else look in the boot blocks */ + if (!labelfound || str[0] == '\0') + { char *buf = malloc (512); + if (!buf) + { + return; + } union bootsector *bsp = (union bootsector *)buf; Seek(ih, 0); Read(ih, (long)buf, 512); - if (msdosfatbits == 32) { /* It's FAT32 */ - strncpy((char *)label, (char *)((struct extboot *)bsp->bs710.bsExt)->exVolumeLabel, LABEL_LENGTH); - } - else if (msdosfatbits == 16) { - strncpy((char *)label, (char *)((struct extboot *)bsp->bs50.bsExt)->exVolumeLabel, LABEL_LENGTH); - } + if (msdosfatbits == 32) + { + /* It's FAT32 */ + strncpy((char *)label, (char *)((struct extboot *)bsp->bs710.bsExt)->exVolumeLabel, LABEL_LENGTH); + } + else if (msdosfatbits == 16) + { + strncpy((char *)label, (char *)((struct extboot *)bsp->bs50.bsExt)->exVolumeLabel, LABEL_LENGTH); + } free (buf); fixLabel(label, str, strMaxLen); - } + } - return; + return; } long MSDOSGetUUID(CICell ih, char *uuidStr) { char *buf = malloc (512); + if (!buf) + { + return -1; + } union bootsector *bsp = (union bootsector *)buf; - + if (MSDOSInitPartition (ih)<0) { + free (buf); return -1; } bzero (uuidStr, 16); @@ -948,5 +1011,5 @@ } free (buf); return 0; - + } Index: branches/chucko/i386/libsaio/fake_efi.c =================================================================== --- branches/chucko/i386/libsaio/fake_efi.c (revision 2328) +++ branches/chucko/i386/libsaio/fake_efi.c (revision 2329) @@ -550,8 +550,7 @@ void setupEfiDeviceTree(void) { - // Bungo - // EFI_CHAR8* ret = 0; + // EFI_CHAR8* ret = 0; Bungo: not used EFI_CHAR16* ret16 = 0; size_t len = 0; Node *node; @@ -635,10 +634,11 @@ } */ - if (Platform.UUID) - { + // Bungo + //if (Platform.UUID) + //{ DT__AddProperty(efiPlatformNode, SYSTEM_ID_PROP, UUID_LEN, Platform.UUID); - } + //} // // Export SystemSerialNumber if present @@ -790,7 +790,7 @@ } memcpy(tableAddress, (void *)origeps->dmi.tableAddress, origeps->dmi.tableLength); - DT__AddProperty(node, "SMBIOS", origeps->dmi.tableLength, tableAddress); + DT__AddProperty(node, "SMBIOS-ORIG", origeps->dmi.tableLength, tableAddress); // Bungo: changed from SMBIOS to SMBIOS-ORIG to differentiate } /* Index: branches/chucko/i386/libsaio/smbios_getters.c =================================================================== --- branches/chucko/i386/libsaio/smbios_getters.c (revision 2328) +++ branches/chucko/i386/libsaio/smbios_getters.c (revision 2329) @@ -67,10 +67,8 @@ bool getSMBOemProcessorBusSpeed(returnType *value) { - if (Platform.CPU.Vendor == CPUID_VENDOR_INTEL) // Intel - { - switch (Platform.CPU.Family) - { + if (Platform.CPU.Vendor == CPUID_VENDOR_INTEL) { // Intel + switch (Platform.CPU.Family) { case 0x06: { switch (Platform.CPU.Model) @@ -113,7 +111,7 @@ did &= 0xFF00; if(vid == 0x8086 && did >= 0x2C00) - nhm_bus = possible_nhm_bus[i]; + nhm_bus = possible_nhm_bus[i]; } unsigned long qpimult, qpibusspeed; @@ -143,12 +141,10 @@ uint16_t simpleGetSMBOemProcessorType(void) { - if (Platform.CPU.NoCores >= 4) - { + if (Platform.CPU.NoCores >= 4) { return 0x0501; // Quad-Core Xeon } - else if (Platform.CPU.NoCores == 1) - { + else if (Platform.CPU.NoCores == 1) { return 0x0201; // Core Solo }; @@ -157,7 +153,7 @@ bool getSMBOemProcessorType(returnType *value) { - static bool done = false; + static bool done = false; value->word = simpleGetSMBOemProcessorType(); @@ -168,89 +164,192 @@ verbose("CPU is %s, family 0x%x, model 0x%x\n", Platform.CPU.BrandString, (uint32_t)Platform.CPU.Family, (uint32_t)Platform.CPU.Model); done = true; } - - switch (Platform.CPU.Family) - { + // Bungo: fixes Oem Processor Type - better matching IMHO + switch (Platform.CPU.Family) { case 0x06: { switch (Platform.CPU.Model) { - case CPU_MODEL_PENTIUM_M: - case CPU_MODEL_DOTHAN: // Intel Pentium M - case CPU_MODEL_YONAH: // Intel Mobile Core Solo, Duo - case CPU_MODEL_MEROM: // Intel Mobile Core 2 Solo, Duo, Xeon 30xx, Xeon 51xx, Xeon X53xx, Xeon E53xx, Xeon X32xx - case CPU_MODEL_PENRYN: // Intel Core 2 Solo, Duo, Quad, Extreme, Xeon X54xx, Xeon X33xx - case CPU_MODEL_ATOM: // Intel Atom (45nm) + + case CPU_MODEL_DOTHAN: // 0x0D - Intel Pentium M model D + value->word = 0x101; return true; - case CPU_MODEL_NEHALEM: // Intel Core i7, Xeon W35xx, Xeon X55xx, Xeon E55xx LGA1366 (45nm) - case CPU_MODEL_WESTMERE: // Intel Core i7, Xeon X56xx, Xeon E56xx, Xeon W36xx LGA1366 (32nm) 6 Core - case CPU_MODEL_WESTMERE_EX: // Intel Xeon E7 - case CPU_MODEL_JAKETOWN: // Intel Core i7, Xeon E5-xxxx LGA2011 (32nm) + case CPU_MODEL_YONAH: // 0x0E - Intel Mobile Core Solo, Duo + case CPU_MODEL_CELERON: + value->word = 0x201; + return true; + + case CPU_MODEL_XEON_MP: // 0x1D - Six-Core Xeon 7400, "Dunnington", 45nm + value->word = 0x401; + return true; + + case CPU_MODEL_MEROM: // 0x0F - Intel Mobile Core 2 Solo, Duo, Xeon 30xx, Xeon 51xx, Xeon X53xx, Xeon E53xx, Xeon X32xx + case CPU_MODEL_PENRYN: // 0x17 - Intel Core 2 Solo, Duo, Quad, Extreme, Xeon X54xx, Xeon X33xx if (strstr(Platform.CPU.BrandString, "Xeon(R)")) { - value->word = 0x0501; // Xeon + value->word = 0x402; // Xeon } + case CPU_MODEL_PENTIUM_M: // 0x09 - Banias + case CPU_MODEL_LINCROFT: // 0x27 - Intel Atom, "Lincroft", 45nm + case CPU_MODEL_ATOM: // 0x1C - Intel Atom (45nm) + return true; + + case CPU_MODEL_NEHALEM_EX: // 0x2E - Nehalem-ex, "Beckton", 45nm + case CPU_MODEL_NEHALEM: // 0x1A - Intel Core i7, Xeon W35xx, Xeon X55xx, Xeon E55xx LGA1366 (45nm) + if (strstr(Platform.CPU.BrandString, "Xeon(R)")) + { + value->word = 0x501; // Xeon + } if (strstr(Platform.CPU.BrandString, "Core(TM) i7")) { - value->word = 0x0701; // Core i7 + value->word = 0x701; // Core i7 } return true; - case CPU_MODEL_FIELDS: // Intel Core i5, i7, Xeon X34xx LGA1156 (45nm) + case CPU_MODEL_FIELDS: // 0x1E - Intel Core i5, i7, Xeon X34xx LGA1156 (45nm) if (strstr(Platform.CPU.BrandString, "Xeon(R)")) { - value->word = 0x501;// Xeon + value->word = 0x501; // Lynnfiled Quad-Core Xeon } + if (strstr(Platform.CPU.BrandString, "Core(TM) i7")) + { + value->word = 0x701; // Core i7 + } if (strstr(Platform.CPU.BrandString, "Core(TM) i5")) { value->word = 0x601; // Core i5 } + return true; + + case CPU_MODEL_DALES: // 0x1F - Intel Core i5, i7 LGA1156 (45nm) (Havendale, Auburndale) + if (strstr(Platform.CPU.BrandString, "Core(TM) i3")) + { + value->word = 0x901; // Core i3 + } + if (strstr(Platform.CPU.BrandString, "Core(TM) i5")) + { + value->word = 0x602; // Core i5 + } if (strstr(Platform.CPU.BrandString, "Core(TM) i7")) { - value->word = 0x701; // Core i7 + value->word = 0x702; // Core i7 } - + if (Platform.CPU.NoCores <= 2) + { + value->word = 0x602; // Core i5 + } return true; - case CPU_MODEL_DALES: + case CPU_MODEL_DALES_32NM: // 0x25 - Intel Core i3, i5 LGA1156 (32nm) (Clarkdale, Arrandale) + if (strstr(Platform.CPU.BrandString, "Core(TM) i3")) + { + value->word = 0x901; // Core i3 + } if (strstr(Platform.CPU.BrandString, "Core(TM) i5")) { - value->word = 0x601; // Core i5 + value->word = 0x601; // Core i5 } - else + if(strstr(Platform.CPU.BrandString, "Core(TM) i5 CPU M 540")) { - value->word = 0x0701; // Core i7 + value->word = 0x602; // Core i5 } + if (strstr(Platform.CPU.BrandString, "Core(TM) i7")) + { + value->word = 0x701; // Core i7 + } + if (Platform.CPU.NoCores <= 2) + { + value->word = 0x602; // Core i5 + } return true; - case CPU_MODEL_SANDYBRIDGE: // Intel Core i3, i5, i7 LGA1155 (32nm) - case CPU_MODEL_IVYBRIDGE: // Intel Core i3, i5, i7 LGA1155 (22nm) - case CPU_MODEL_IVYBRIDGE_XEON: - case CPU_MODEL_DALES_32NM: // Intel Core i3, i5 LGA1156 (32nm) - case CPU_MODEL_HASWELL: - case CPU_MODEL_HASWELL_MB: - case CPU_MODEL_HASWELL_ULT: - case CPU_MODEL_CRYSTALWELL: + case CPU_MODEL_WESTMERE: // 0x2C - Intel Core i7, Xeon X56xx, Xeon E56xx, Xeon W36xx LGA1366 (32nm) 6 Core + case CPU_MODEL_WESTMERE_EX: // 0x2F - Intel Xeon E7 if (strstr(Platform.CPU.BrandString, "Xeon(R)")) { - value->word = 0x0501; // Xeon + value->word = 0x501; // Xeon } + if (strstr(Platform.CPU.BrandString, "Core(TM) i7")) + { + value->word = 0x701; // Core i7 + } + return true; + + case CPU_MODEL_JAKETOWN: // 0x2D - Intel Core i7, Xeon E5-xxxx LGA2011 (32nm) + case CPU_MODEL_SANDYBRIDGE: // 0x2A - Intel Core i3, i5, i7 LGA1155 (32nm) + if (strstr(Platform.CPU.BrandString, "Xeon(R)")) + { + value->word = 0x501; // Xeon + } if (strstr(Platform.CPU.BrandString, "Core(TM) i3")) { - value->word = 0x901; // Core i3 + value->word = 0x903; // Core i3 } if (strstr(Platform.CPU.BrandString, "Core(TM) i5")) { - value->word = 0x601; // Core i5 + value->word = 0x603; // Core i5 } if (strstr(Platform.CPU.BrandString, "Core(TM) i7")) { - value->word = 0x0701; // Core i7 + value->word = 0x703; // Core i7 } + if (Platform.CPU.NoCores <= 2) + { + value->word = 0x603; // Core i5 + } return true; + case CPU_MODEL_IVYBRIDGE: // 0x3A - Intel Core i3, i5, i7 LGA1155 (22nm) + if (strstr(Platform.CPU.BrandString, "Core(TM) i3")) + { + value->word = 0x903; // Core i3 - Apple doesn't use it + } + if (strstr(Platform.CPU.BrandString, "Core(TM) i5")) + { + value->word = 0x604; // Core i5 + } + if (strstr(Platform.CPU.BrandString, "Core(TM) i7")) + { + value->word = 0x704; // Core i7 + } + if (Platform.CPU.NoCores <= 2) + { + value->word = 0x604; // Core i5 + } + return true; + case CPU_MODEL_IVYBRIDGE_XEON: // 0x3E - + value->word = 0xA01; + return true; + + case CPU_MODEL_HASWELL: // 0x3C - + case CPU_MODEL_HASWELL_MB: // 0x3F - + case CPU_MODEL_HASWELL_ULT: // 0x45 - + case CPU_MODEL_CRYSTALWELL: // 0x46 + if (strstr(Platform.CPU.BrandString, "Core(TM) i3")) + { + value->word = 0x905; // Core i3 - Apple doesn't use it + } + if (strstr(Platform.CPU.BrandString, "Core(TM) i5")) + { + value->word = 0x605; // Core i5 + } + if (strstr(Platform.CPU.BrandString, "Core(TM) i7")) + { + value->word = 0x705; // Core i7 + } + if (Platform.CPU.NoCores <= 2) + { + value->word = 0x605; // Core i5 + } + return true; + + case 0x15: // EP80579 integrated processor + value->word = 0x301; // + return true; + + case 0x13: // Core i5, Xeon MP, "Havendale", "Auburndale", 45nm case 0x19: // Intel Core i5 650 @3.20 Ghz value->word = 0x601; // Core i5 return true; @@ -259,7 +358,7 @@ } } default: - break; + break; } } @@ -403,17 +502,16 @@ SMBEntryPoint *getAddressOfSmbiosTable(void) { SMBEntryPoint *smbios; - /* + /* * The logic is to start at 0xf0000 and end at 0xfffff iterating 16 bytes at a time looking * for the SMBIOS entry-point structure anchor (literal ASCII "_SM_"). */ smbios = (SMBEntryPoint*)SMBIOS_RANGE_START; while (smbios <= (SMBEntryPoint *)SMBIOS_RANGE_END) { - if (COMPARE_DWORD(smbios->anchor, SMTAG) && + if (COMPARE_DWORD(smbios->anchor, SMTAG) && COMPARE_DWORD(smbios->dmi.anchor, DMITAG) && smbios->dmi.anchor[4] == DMITAG[4] && - checksum8(smbios, sizeof(SMBEntryPoint)) == 0) - { + checksum8(smbios, sizeof(SMBEntryPoint)) == 0) { return smbios; } smbios = (SMBEntryPoint*)(((char*)smbios) + 16); Index: branches/chucko/i386/libsaio/saio_internal.h =================================================================== --- branches/chucko/i386/libsaio/saio_internal.h (revision 2328) +++ branches/chucko/i386/libsaio/saio_internal.h (revision 2329) @@ -218,7 +218,7 @@ unsigned int byteoff, unsigned int byteCount, void * buffer ); -/* Base64-decode.c */ +// Base64-decode.c char *BASE64Decode(const char* src, int in_len, int* out_len); #endif /* !__LIBSAIO_SAIO_INTERNAL_H */ Index: branches/chucko/i386/boot2/picopng.c =================================================================== --- branches/chucko/i386/boot2/picopng.c (revision 2328) +++ branches/chucko/i386/boot2/picopng.c (revision 2329) @@ -1104,15 +1104,15 @@ } insize = (uint32_t) statbuf.st_size; inbuf = malloc(insize); - if (!inbuf) { - perror("malloc"); - fclose(infp); - return 1; - } - if (fread(inbuf, 1, insize, infp) != insize) { + if (!inbuf) { + perror("malloc"); + fclose(infp); + return 1; + } + if (fread(inbuf, 1, insize, infp) != insize) { perror("fread"); - free(inbuf); - fclose(infp); + free(inbuf); + fclose(infp); return 1; } fclose(infp); Index: branches/chucko/i386/boot2/graphics.c =================================================================== --- branches/chucko/i386/boot2/graphics.c (revision 2328) +++ branches/chucko/i386/boot2/graphics.c (revision 2329) @@ -84,9 +84,9 @@ return 0; buff = malloc(sizeof(char) * 256); - if (!buff) - return 0; - + if (!buff) { + return 0; + } small = (vbeInfo.TotalMemory < 16); snprintf(buff, 256, @@ -106,107 +106,109 @@ void printVBEModeInfo() { - VBEInfoBlock vbeInfo; - unsigned short * modePtr; - VBEModeInfoBlock modeInfo; - int err; - int line; - char* vbeInfoString = NULL; + VBEInfoBlock vbeInfo; + unsigned short * modePtr; + VBEModeInfoBlock modeInfo; + int err; + int line; + char* vbeInfoString = NULL; bzero( &vbeInfo, sizeof(vbeInfo) ); - strcpy( (char*)&vbeInfo, "VBE2" ); - err = getVBEInfo( &vbeInfo ); - if ( err != errSuccess ) - return; + strcpy( (char*)&vbeInfo, "VBE2" ); + err = getVBEInfo( &vbeInfo ); + if ( err != errSuccess ) { + return; + } - line = 0; + line = 0; - // Activate and clear page 1 - setActiveDisplayPage(1); - clearScreenRows(0, 24); - setCursorPosition( 0, 0, 1 ); + // Activate and clear page 1 + setActiveDisplayPage(1); + clearScreenRows(0, 24); + setCursorPosition( 0, 0, 1 ); - vbeInfoString = getVBEInfoString(); - if (!vbeInfoString) { - printf("Error: getVBEInfoString failed\n"); - return; - } - printf("%s", vbeInfoString); - free(vbeInfoString); - vbeInfoString = NULL; + vbeInfoString = getVBEInfoString(); + if (!vbeInfoString) { + printf("Error: getVBEInfoString failed\n"); + return; + } + printf("%s", vbeInfoString); + free(vbeInfoString); + vbeInfoString = NULL; printf("Video modes supported:\n", VBEDecodeFP(const char *, vbeInfo.OEMStringPtr)); - // Loop through the mode list, and find the matching mode. + // Loop through the mode list, and find the matching mode. - for ( modePtr = VBEDecodeFP( unsigned short *, vbeInfo.VideoModePtr ); + for ( modePtr = VBEDecodeFP( unsigned short *, vbeInfo.VideoModePtr ); *modePtr != modeEndOfList; modePtr++ ) - { - // Get mode information. + { + // Get mode information. - bzero( &modeInfo, sizeof(modeInfo) ); - err = getVBEModeInfo( *modePtr, &modeInfo ); - if ( err != errSuccess ) - { - continue; - } + bzero( &modeInfo, sizeof(modeInfo) ); + err = getVBEModeInfo( *modePtr, &modeInfo ); + if ( err != errSuccess ) + { + continue; + } - printf("Mode %x: %dx%dx%d mm:%d attr:%x\n", - *modePtr, modeInfo.XResolution, modeInfo.YResolution, - modeInfo.BitsPerPixel, modeInfo.MemoryModel, - modeInfo.ModeAttributes); + printf("Mode %x: %dx%dx%d mm:%d attr:%x\n", + *modePtr, modeInfo.XResolution, modeInfo.YResolution, + modeInfo.BitsPerPixel, modeInfo.MemoryModel, + modeInfo.ModeAttributes); - if (line++ >= 20) { - pause(); - line = 0; - clearScreenRows(0, 24); - setCursorPosition( 0, 0, 1 ); - } - } - if (line != 0) { - pause(); - } - setActiveDisplayPage(0); + if (line++ >= 20) { + pause(); + line = 0; + clearScreenRows(0, 24); + setCursorPosition( 0, 0, 1 ); + } + } + if (line != 0) { + pause(); + } + setActiveDisplayPage(0); } char *getVBEModeInfoString() { VBEInfoBlock vbeInfo; - unsigned short * modePtr; - VBEModeInfoBlock modeInfo; - int err; + unsigned short * modePtr; + VBEModeInfoBlock modeInfo; + int err; bzero( &vbeInfo, sizeof(vbeInfo) ); - strcpy( (char*)&vbeInfo, "VBE2" ); - err = getVBEInfo( &vbeInfo ); - if ( err != errSuccess ) - return 0; - + strcpy( (char*)&vbeInfo, "VBE2" ); + err = getVBEInfo( &vbeInfo ); + if ( err != errSuccess ) { + return 0; + } char *buff=malloc(sizeof(char)*3072); - if(!buff) return 0; - int bufflen = 0; + if(!buff) { + return 0; + } + int bufflen = 0; + // Loop through the mode list, and find the matching mode. - for ( modePtr = VBEDecodeFP( unsigned short *, vbeInfo.VideoModePtr ); - (*modePtr != modeEndOfList) && (bufflen < 3072); /* prevent buffer overrun */ - modePtr++ ) - { - // Get mode information. + for ( modePtr = VBEDecodeFP( unsigned short *, vbeInfo.VideoModePtr ); + (*modePtr != modeEndOfList) && (bufflen < 3072); /* prevent buffer overrun */ + modePtr++ ) + { + // Get mode information. - bzero( &modeInfo, sizeof(modeInfo) ); - err = getVBEModeInfo( *modePtr, &modeInfo ); - if ( err != errSuccess ) - { - continue; - } + bzero( &modeInfo, sizeof(modeInfo) ); + err = getVBEModeInfo( *modePtr, &modeInfo ); + if ( err != errSuccess ) { + continue; + } - bufflen += - snprintf(buff+bufflen, 3072-bufflen, "Mode %x: %dx%dx%d mm:%d attr:%x\n", - *modePtr, modeInfo.XResolution, modeInfo.YResolution, - modeInfo.BitsPerPixel, modeInfo.MemoryModel, - modeInfo.ModeAttributes); - - } + bufflen += + snprintf(buff+bufflen, 3072-bufflen, "Mode %x: %dx%dx%d mm:%d attr:%x\n", + *modePtr, modeInfo.XResolution, modeInfo.YResolution, + modeInfo.BitsPerPixel, modeInfo.MemoryModel, + modeInfo.ModeAttributes); + } return buff; } Index: branches/chucko/i386/boot2/drivers.c =================================================================== --- branches/chucko/i386/boot2/drivers.c (revision 2328) +++ branches/chucko/i386/boot2/drivers.c (revision 2329) @@ -43,24 +43,24 @@ //extern char gMacOSVersion[8]; struct Module { - struct Module *nextModule; - long willLoad; - TagPtr dict; - char *plistAddr; - long plistLength; - char *executablePath; - char *bundlePath; - long bundlePathLength; + struct Module *nextModule; + long willLoad; + TagPtr dict; + char *plistAddr; + long plistLength; + char *executablePath; + char *bundlePath; + long bundlePathLength; }; typedef struct Module Module, *ModulePtr; struct DriverInfo { - char *plistAddr; - long plistLength; - void *executableAddr; - long executableLength; - void *bundlePathAddr; - long bundlePathLength; + char *plistAddr; + long plistLength; + void *executableAddr; + long executableLength; + void *bundlePathAddr; + long bundlePathLength; }; typedef struct DriverInfo DriverInfo, *DriverInfoPtr; @@ -80,8 +80,8 @@ typedef struct DriversPackage DriversPackage; enum { - kCFBundleType2, - kCFBundleType3 + kCFBundleType2, + kCFBundleType3 }; long (*LoadExtraDrivers_p)(FileLoadDrivers_t FileLoadDrivers_p); @@ -114,24 +114,24 @@ /*static*/ unsigned long Adler32( unsigned char * buffer, long length ) { - long cnt; - unsigned long result, lowHalf, highHalf; - - lowHalf = 1; - highHalf = 0; - - for ( cnt = 0; cnt < length; cnt++ ) - { - if ((cnt % 5000) == 0) - { - lowHalf %= 65521L; - highHalf %= 65521L; - } - - lowHalf += buffer[cnt]; - highHalf += lowHalf; - } + long cnt; + unsigned long result, lowHalf, highHalf; + lowHalf = 1; + highHalf = 0; + + for (cnt = 0; cnt < length; cnt++) + { + if ((cnt % 5000) == 0) + { + lowHalf %= 65521L; + highHalf %= 65521L; + } + + lowHalf += buffer[cnt]; + highHalf += lowHalf; + } + lowHalf %= 65521L; highHalf %= 65521L; @@ -147,16 +147,17 @@ static long InitDriverSupport( void ) { - gExtensionsSpec = malloc( 4096 ); - gDriverSpec = malloc( 4096 ); - gFileSpec = malloc( 4096 ); - gTempSpec = malloc( 4096 ); - gFileName = malloc( 4096 ); + gExtensionsSpec = malloc( 4096 ); + gDriverSpec = malloc( 4096 ); + gFileSpec = malloc( 4096 ); + gTempSpec = malloc( 4096 ); + gFileName = malloc( 4096 ); - if ( !gExtensionsSpec || !gDriverSpec || !gFileSpec || !gTempSpec || !gFileName ) - stop("InitDriverSupport error"); + if ( !gExtensionsSpec || !gDriverSpec || !gFileSpec || !gTempSpec || !gFileName ) { + stop("InitDriverSupport error"); + } - return 0; + return 0; } //========================================================================== @@ -164,109 +165,98 @@ long LoadDrivers( char * dirSpec ) { - char dirSpecExtra[1024]; + char dirSpecExtra[1024]; - if ( InitDriverSupport() != 0 ) - return 0; + if ( InitDriverSupport() != 0 ) { + return 0; + } - // Load extra drivers if a hook has been installed. - if (LoadExtraDrivers_p != NULL) - { - (*LoadExtraDrivers_p)(&FileLoadDrivers); - } + // Load extra drivers if a hook has been installed. + if (LoadExtraDrivers_p != NULL) + { + (*LoadExtraDrivers_p)(&FileLoadDrivers); + } - if ( gBootFileType == kNetworkDeviceType ) - { - if (NetLoadDrivers(dirSpec) != 0) { - error("Could not load drivers from the network\n"); - return -1; - } - } - else if ( gBootFileType == kBlockDeviceType ) + if ( gBootFileType == kNetworkDeviceType ) { - // First try to load Extra extensions from the ramdisk if isn't aliased as bt(0,0). - if (gRAMDiskVolume && !gRAMDiskBTAliased) - { - strcpy(dirSpecExtra, "rd(0,0)/Extra/"); - FileLoadDrivers(dirSpecExtra, 0); - } + if (NetLoadDrivers(dirSpec) != 0) + { + error("Could not load drivers from the network\n"); + return -1; + } + } + else if ( gBootFileType == kBlockDeviceType ) + { + // First try to load Extra extensions from the ramdisk if isn't aliased as bt(0,0). + if (gRAMDiskVolume && !gRAMDiskBTAliased) + { + strcpy(dirSpecExtra, "rd(0,0)/Extra/"); + FileLoadDrivers(dirSpecExtra, 0); + } - // Next try to load Extra extensions from the selected root partition. - strcpy(dirSpecExtra, "/Extra/"); - if (FileLoadDrivers(dirSpecExtra, 0) != 0) - { - // If failed, then try to load Extra extensions from the boot partition - // in case we have a separate booter partition or a bt(0,0) aliased ramdisk. - if ( !(gBIOSBootVolume->biosdev == gBootVolume->biosdev && gBIOSBootVolume->part_no == gBootVolume->part_no) - || (gRAMDiskVolume && gRAMDiskBTAliased) ) - { - // Next try a specfic OS version folder ie 10.5 - sprintf(dirSpecExtra, "bt(0,0)/Extra/%s/", &gMacOSVersion); - if (FileLoadDrivers(dirSpecExtra, 0) != 0) - { - // Next we'll try the base - strcpy(dirSpecExtra, "bt(0,0)/Extra/"); - FileLoadDrivers(dirSpecExtra, 0); - } - } - } - if(!gHaveKernelCache) - { - // Don't load main driver (from /System/Library/Extentions) if gHaveKernelCache is set. - // since these drivers will already be in the kernel cache. - // NOTE: when gHaveKernelCache, xnu cannot (by default) load *any* extra kexts from the bootloader. - // The /Extra code is not disabled in this case due to a kernel patch that allows for this to happen. - - // Also try to load Extensions from boot helper partitions. - if (gBootVolume->flags & kBVFlagBooter) - { - strcpy(dirSpecExtra, "/com.apple.boot.P/System/Library/"); - if (FileLoadDrivers(dirSpecExtra, 0) != 0) - { - strcpy(dirSpecExtra, "/com.apple.boot.R/System/Library/"); - if (FileLoadDrivers(dirSpecExtra, 0) != 0) - { - strcpy(dirSpecExtra, "/com.apple.boot.S/System/Library/"); - FileLoadDrivers(dirSpecExtra, 0); - } - } - } - - if (gMKextName[0] != '\0') - { - verbose("LoadDrivers: Loading from [%s]\n", gMKextName); - if ( LoadDriverMKext(gMKextName) != 0 ) - { - error("Could not load %s\n", gMKextName); - return -1; - } - } - else - { + // Next try to load Extra extensions from the selected root partition. + strcpy(dirSpecExtra, "/Extra/"); + if (FileLoadDrivers(dirSpecExtra, 0) != 0) { + // If failed, then try to load Extra extensions from the boot partition + // in case we have a separate booter partition or a bt(0,0) aliased ramdisk. + if ( !(gBIOSBootVolume->biosdev == gBootVolume->biosdev && gBIOSBootVolume->part_no == gBootVolume->part_no) + || (gRAMDiskVolume && gRAMDiskBTAliased) ) { + // Next try a specfic OS version folder ie 10.5 + sprintf(dirSpecExtra, "bt(0,0)/Extra/%s/", &gMacOSVersion); + if (FileLoadDrivers(dirSpecExtra, 0) != 0) { + // Next we'll try the base + strcpy(dirSpecExtra, "bt(0,0)/Extra/"); + FileLoadDrivers(dirSpecExtra, 0); + } + } + } + if(!gHaveKernelCache) { + // Don't load main driver (from /System/Library/Extentions) if gHaveKernelCache is set. + // since these drivers will already be in the kernel cache. + // NOTE: when gHaveKernelCache, xnu cannot (by default) load *any* extra kexts from the bootloader. + // The /Extra code is not disabled in this case due to a kernel patch that allows for this to happen. + + // Also try to load Extensions from boot helper partitions. + if (gBootVolume->flags & kBVFlagBooter) { + strcpy(dirSpecExtra, "/com.apple.boot.P/System/Library/"); + if (FileLoadDrivers(dirSpecExtra, 0) != 0) { + strcpy(dirSpecExtra, "/com.apple.boot.R/System/Library/"); + if (FileLoadDrivers(dirSpecExtra, 0) != 0) { + strcpy(dirSpecExtra, "/com.apple.boot.S/System/Library/"); + FileLoadDrivers(dirSpecExtra, 0); + } + } + } + + if (gMKextName[0] != '\0') { + verbose("LoadDrivers: Loading from [%s]\n", gMKextName); + if ( LoadDriverMKext(gMKextName) != 0 ) { + error("Could not load %s\n", gMKextName); + return -1; + } + } else { if (gMacOSVersion[3] == '9') { - strlcpy(gExtensionsSpec, dirSpec, 4087); /* 4096 - sizeof("Library/") */ + strlcpy(gExtensionsSpec, dirSpec, 4087); /* 4096 - sizeof("Library/") */ strcat(gExtensionsSpec, "Library/"); FileLoadDrivers(gExtensionsSpec, 0); } - strlcpy(gExtensionsSpec, dirSpec, 4080); /* 4096 - sizeof("System/Library/") */ - strcat(gExtensionsSpec, "System/Library/"); - FileLoadDrivers(gExtensionsSpec, 0); - } + strlcpy(gExtensionsSpec, dirSpec, 4080); /* 4096 - sizeof("System/Library/") */ + strcat(gExtensionsSpec, "System/Library/"); + FileLoadDrivers(gExtensionsSpec, 0); + } - } - } - else - { - return 0; - } + } + } else { + return 0; + } - MatchPersonalities(); + MatchPersonalities(); - MatchLibraries(); + MatchLibraries(); - LoadMatchedModules(); + LoadMatchedModules(); - return 0; + return 0; } //========================================================================== @@ -289,11 +279,12 @@ || ((flags & kFileTypeMask) != kFileTypeDirectory) || (((gBootMode & kBootModeSafe) == 0) && (time == (time2 + 1)))) { - snprintf(gDriverSpec, sizeof(altDirSpec) + 18, "%sExtensions.mkext", altDirSpec); + snprintf(gDriverSpec, sizeof(altDirSpec) + 18, "%sExtensions.mkext", altDirSpec); verbose("LoadDrivers: Loading from [%s]\n", gDriverSpec); - if (LoadDriverMKext(gDriverSpec) == 0) + if (LoadDriverMKext(gDriverSpec) == 0) { return 0; + } } } return -1; @@ -305,59 +296,73 @@ long FileLoadDrivers( char * dirSpec, long plugin ) { - long ret, length, flags, time, bundleType; - long long index; - long result = -1; - const char * name; - - if ( !plugin ) - { - // First try 10.6's path for loading Extensions.mkext. - if (FileLoadMKext(dirSpec, "Caches/com.apple.kext.caches/Startup/") == 0) - return 0; + long ret, length, flags, time, bundleType; + long long index; + long result = -1; + const char * name; - // Next try the legacy path. - else if (FileLoadMKext(dirSpec, "") == 0) - return 0; + if ( !plugin ) + { + // First try 10.6's path for loading Extensions.mkext. + if (FileLoadMKext(dirSpec, "Caches/com.apple.kext.caches/Startup/") == 0) { + return 0; + } - strcat(dirSpec, "Extensions"); - } + // Next try the legacy path. + else if (FileLoadMKext(dirSpec, "") == 0) { + return 0; + } - index = 0; - while (1) { - ret = GetDirEntry(dirSpec, &index, &name, &flags, &time); - if (ret == -1) break; + strcat(dirSpec, "Extensions"); + } - // Make sure this is a directory. - if ((flags & kFileTypeMask) != kFileTypeDirectory) continue; - - // Make sure this is a kext. - length = strlen(name); - if (strcmp(name + length - 5, ".kext")) continue; + index = 0; + while (1) + { + ret = GetDirEntry(dirSpec, &index, &name, &flags, &time); + if (ret == -1) { + break; + } - // Save the file name. - strlcpy(gFileName, name, 4096); - - // Determine the bundle type. - snprintf(gTempSpec, 4096, "%s/%s", dirSpec, gFileName); - ret = GetFileInfo(gTempSpec, "Contents", &flags, &time); - if (ret == 0) bundleType = kCFBundleType2; - else bundleType = kCFBundleType3; + // Make sure this is a directory. + if ((flags & kFileTypeMask) != kFileTypeDirectory) { + continue; + } - if (!plugin) - snprintf(gDriverSpec, 4096, "%s/%s/%sPlugIns", dirSpec, gFileName, - (bundleType == kCFBundleType2) ? "Contents/" : ""); + // Make sure this is a kext. + length = strlen(name); + if (strcmp(name + length - 5, ".kext")) { + continue; + } - ret = LoadDriverPList(dirSpec, gFileName, bundleType); + // Save the file name. + strlcpy(gFileName, name, 4096); - if (result != 0) - result = ret; + // Determine the bundle type. + snprintf(gTempSpec, 4096, "%s/%s", dirSpec, gFileName); + ret = GetFileInfo(gTempSpec, "Contents", &flags, &time); + if (ret == 0) { + bundleType = kCFBundleType2; + } else { + bundleType = kCFBundleType3; + } - if (!plugin) - FileLoadDrivers(gDriverSpec, 1); - } + if (!plugin) { + snprintf(gDriverSpec, 4096, "%s/%s/%sPlugIns", dirSpec, gFileName, (bundleType == kCFBundleType2) ? "Contents/" : ""); + } - return result; + ret = LoadDriverPList(dirSpec, gFileName, bundleType); + + if (result != 0) { + result = ret; + } + + if (!plugin) { + FileLoadDrivers(gDriverSpec, 1); + } + } + + return result; } @@ -367,32 +372,36 @@ long NetLoadDrivers( char * dirSpec ) { - long tries; + long tries; #if NODEF - long cnt; + long cnt; - // Get the name of the kernel - cnt = strlen(gBootFile); - while (cnt--) { - if ((gBootFile[cnt] == '\\') || (gBootFile[cnt] == ',')) { - cnt++; - break; - } - } + // Get the name of the kernel + cnt = strlen(gBootFile); + while (cnt--) { + if ((gBootFile[cnt] == '\\') || (gBootFile[cnt] == ',')) { + cnt++; + break; + } + } #endif - // INTEL modification - snprintf(gDriverSpec, 4096, "%s%s.mkext", dirSpec, bootInfo->bootFile); + // INTEL modification + snprintf(gDriverSpec, 4096, "%s%s.mkext", dirSpec, bootInfo->bootFile); - verbose("NetLoadDrivers: Loading from [%s]\n", gDriverSpec); + verbose("NetLoadDrivers: Loading from [%s]\n", gDriverSpec); - tries = 3; - while (tries--) - { - if (LoadDriverMKext(gDriverSpec) == 0) break; - } - if (tries == -1) return -1; + tries = 3; + while (tries--) + { + if (LoadDriverMKext(gDriverSpec) == 0) { + break; + } + } + if (tries == -1) { + return -1; + } return 0; } @@ -403,44 +412,45 @@ long LoadDriverMKext( char * fileSpec ) { - unsigned long driversAddr, driversLength; - long length; - char segName[32]; - DriversPackage * package; + unsigned long driversAddr, driversLength; + long length; + char segName[32]; + DriversPackage * package; #define GetPackageElement(e) OSSwapBigToHostInt32(package->e) - // Load the MKext. - length = LoadThinFatFile(fileSpec, (void **)&package); - if (length < sizeof (DriversPackage)) return -1; + // Load the MKext. + length = LoadThinFatFile(fileSpec, (void **)&package); + if (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); - // Verify the MKext. - if (( GetPackageElement(signature1) != kDriverPackageSignature1) || - ( GetPackageElement(signature2) != kDriverPackageSignature2) || - ( GetPackageElement(length) > kLoadSize ) || - ( GetPackageElement(adler32) != - Adler32((unsigned char *)&package->version, GetPackageElement(length) - 0x10) ) ) - { - return -1; - } + // Verify the MKext. + if (( GetPackageElement(signature1) != kDriverPackageSignature1) || + ( GetPackageElement(signature2) != kDriverPackageSignature2) || + ( GetPackageElement(length) > kLoadSize ) || + ( GetPackageElement(adler32) != + Adler32((unsigned char *)&package->version, GetPackageElement(length) - 0x10) ) ) + { + return -1; + } - // Make space for the MKext. - driversLength = GetPackageElement(length); - driversAddr = AllocateKernelMemory(driversLength); + // Make space for the MKext. + driversLength = GetPackageElement(length); + driversAddr = AllocateKernelMemory(driversLength); - // Copy the MKext. - memcpy((void *)driversAddr, (void *)package, driversLength); + // Copy the MKext. + memcpy((void *)driversAddr, (void *)package, driversLength); - // Add the MKext to the memory map. - snprintf(segName, sizeof(segName), "DriversPackage-%lx", driversAddr); - AllocateMemoryRange(segName, driversAddr, driversLength, - kBootDriverTypeMKEXT); + // Add the MKext to the memory map. + snprintf(segName, sizeof(segName), "DriversPackage-%lx", driversAddr); + AllocateMemoryRange(segName, driversAddr, driversLength, kBootDriverTypeMKEXT); - return 0; + return 0; } //========================================================================== @@ -449,110 +459,131 @@ long LoadDriverPList( char * dirSpec, char * name, long bundleType ) { - long length, executablePathLength, bundlePathLength; - ModulePtr module; - TagPtr personalities; - char * buffer = 0; - char * tmpExecutablePath = 0; - char * tmpBundlePath = 0; - long ret = -1; + long length, executablePathLength, bundlePathLength; + ModulePtr module; + TagPtr personalities; + char * buffer = 0; + char * tmpExecutablePath = 0; + char * tmpBundlePath = 0; + long ret = -1; - do { - // Save the driver path. + do{ + // Save the driver path. - if(name) - snprintf(gFileSpec, 4096, "%s/%s/%s", dirSpec, name, - (bundleType == kCFBundleType2) ? "Contents/MacOS/" : ""); - else - snprintf(gFileSpec, 4096, "%s/%s", dirSpec, - (bundleType == kCFBundleType2) ? "Contents/MacOS/" : ""); - executablePathLength = strlen(gFileSpec) + 1; + if(name) { + snprintf(gFileSpec, 4096, "%s/%s/%s", dirSpec, name, (bundleType == kCFBundleType2) ? "Contents/MacOS/" : ""); + } else { + snprintf(gFileSpec, 4096, "%s/%s", dirSpec, (bundleType == kCFBundleType2) ? "Contents/MacOS/" : ""); + } + executablePathLength = strlen(gFileSpec) + 1; - tmpExecutablePath = malloc(executablePathLength); - if (tmpExecutablePath == 0) break; - strcpy(tmpExecutablePath, gFileSpec); - - if(name) - snprintf(gFileSpec, 4096, "%s/%s", dirSpec, name); - else - snprintf(gFileSpec, 4096, "%s", dirSpec); - bundlePathLength = strlen(gFileSpec) + 1; + tmpExecutablePath = malloc(executablePathLength); + if (tmpExecutablePath == 0) { + break; + } + strcpy(tmpExecutablePath, gFileSpec); - tmpBundlePath = malloc(bundlePathLength); - if (tmpBundlePath == 0) break; + if(name) { + snprintf(gFileSpec, 4096, "%s/%s", dirSpec, name); + } else { + snprintf(gFileSpec, 4096, "%s", dirSpec); + } + bundlePathLength = strlen(gFileSpec) + 1; - strcpy(tmpBundlePath, gFileSpec); + tmpBundlePath = malloc(bundlePathLength); + if (tmpBundlePath == 0) { + break; + } - // Construct the file spec to the plist, then load it. + strcpy(tmpBundlePath, gFileSpec); - if(name) - snprintf(gFileSpec, 4096, "%s/%s/%sInfo.plist", dirSpec, name, - (bundleType == kCFBundleType2) ? "Contents/" : ""); - else - snprintf(gFileSpec, 4096, "%s/%sInfo.plist", dirSpec, - (bundleType == kCFBundleType2) ? "Contents/" : ""); + // Construct the file spec to the plist, then load it. - length = LoadFile(gFileSpec); - if (length == -1) break; - length = length + 1; - buffer = malloc(length); - if (buffer == 0) break; - strlcpy(buffer, (char *)kLoadAddr, length); + if(name) { + snprintf(gFileSpec, 4096, "%s/%s/%sInfo.plist", dirSpec, name, (bundleType == kCFBundleType2) ? "Contents/" : ""); + } else { + snprintf(gFileSpec, 4096, "%s/%sInfo.plist", dirSpec, (bundleType == kCFBundleType2) ? "Contents/" : ""); + } - // Parse the plist. + length = LoadFile(gFileSpec); + if (length == -1) { + break; + } + length = length + 1; + buffer = malloc(length); + if (buffer == 0) { + break; + } + strlcpy(buffer, (char *)kLoadAddr, length); - ret = ParseXML(buffer, &module, &personalities); - if (ret != 0) { break; } - // Allocate memory for the driver path and the plist. + // Parse the plist. - module->executablePath = tmpExecutablePath; - module->bundlePath = tmpBundlePath; - module->bundlePathLength = bundlePathLength; - module->plistAddr = malloc(length); - - if ((module->executablePath == 0) || (module->bundlePath == 0) || (module->plistAddr == 0)) - break; - // Save the driver path in the module. - //strcpy(module->driverPath, tmpDriverPath); - tmpExecutablePath = 0; - tmpBundlePath = 0; + ret = ParseXML(buffer, &module, &personalities); - // Add the plist to the module. + if (ret != 0) { + break; + } + // Allocate memory for the driver path and the plist. - strlcpy(module->plistAddr, (char *)kLoadAddr, length); - module->plistLength = length; - - // Add the module to the end of the module list. + module->executablePath = tmpExecutablePath; + module->bundlePath = tmpBundlePath; + module->bundlePathLength = bundlePathLength; + module->plistAddr = malloc(length); + + if ((module->executablePath == 0) || (module->bundlePath == 0) || (module->plistAddr == 0)) { + break; + } + + // Save the driver path in the module. + //strcpy(module->driverPath, tmpDriverPath); + tmpExecutablePath = 0; + tmpBundlePath = 0; + + // Add the plist to the module. + + strlcpy(module->plistAddr, (char *)kLoadAddr, length); + module->plistLength = length; + + // Add the module to the end of the module list. - if (gModuleHead == 0) - gModuleHead = module; - else - gModuleTail->nextModule = module; - gModuleTail = module; - - // Add the persionalities to the personality list. - - if (personalities) personalities = personalities->tag; - while (personalities != 0) - { - if (gPersonalityHead == 0) - gPersonalityHead = personalities->tag; - else - gPersonalityTail->tagNext = personalities->tag; - - gPersonalityTail = personalities->tag; - personalities = personalities->tagNext; - } + if (gModuleHead == 0) { + gModuleHead = module; + } else { + gModuleTail->nextModule = module; + } + gModuleTail = module; + + // Add the persionalities to the personality list. + + if (personalities) { + personalities = personalities->tag; + } + while (personalities != 0) + { + if (gPersonalityHead == 0) { + gPersonalityHead = personalities->tag; + } else { + gPersonalityTail->tagNext = personalities->tag; + } + + gPersonalityTail = personalities->tag; + personalities = personalities->tagNext; + } - ret = 0; - } - while (0); + ret = 0; + } + while (0); - if ( buffer ) free( buffer ); - if ( tmpExecutablePath ) free( tmpExecutablePath ); - if ( tmpBundlePath ) free( tmpBundlePath ); - - return ret; + if ( buffer ) { + free( buffer ); + } + if ( tmpExecutablePath ) { + free( tmpExecutablePath ); + } + if ( tmpBundlePath ) { + free( tmpBundlePath ); + } + return ret; } @@ -652,8 +683,8 @@ static long MatchPersonalities( void ) { - /* IONameMatch support not implemented */ - return 0; + /* IONameMatch support not implemented */ + return 0; } //========================================================================== @@ -662,47 +693,54 @@ static long MatchLibraries( void ) { - TagPtr prop, prop2; - ModulePtr module, module2; - long done; + TagPtr prop, prop2; + ModulePtr module, module2; + long done; - do { - done = 1; - module = gModuleHead; + do { + done = 1; + module = gModuleHead; - while (module != 0) - { - if (module->willLoad == 1) - { - prop = XMLGetProperty(module->dict, kPropOSBundleLibraries); - if (prop != 0) - { - prop = prop->tag; - while (prop != 0) - { - module2 = gModuleHead; - while (module2 != 0) - { - prop2 = XMLGetProperty(module2->dict, kPropCFBundleIdentifier); - if ((prop2 != 0) && (!strcmp(prop->string, prop2->string))) - { - if (module2->willLoad == 0) module2->willLoad = 1; - break; - } - module2 = module2->nextModule; - } - prop = prop->tagNext; - } - } - module->willLoad = 2; - done = 0; - } - module = module->nextModule; - } - } - while (!done); + while (module != 0) + { + if (module->willLoad == 1) + { + prop = XMLGetProperty(module->dict, kPropOSBundleLibraries); - return 0; + if (prop != 0) + { + prop = prop->tag; + + while (prop != 0) + { + module2 = gModuleHead; + + while (module2 != 0) + { + prop2 = XMLGetProperty(module2->dict, kPropCFBundleIdentifier); + + if ((prop2 != 0) && (!strcmp(prop->string, prop2->string))) + { + if (module2->willLoad == 0) + { + module2->willLoad = 1; + } + break; + } + module2 = module2->nextModule; + } + prop = prop->tagNext; + } + } + module->willLoad = 2; + done = 0; + } + module = module->nextModule; + } + } + while (!done); + + return 0; } @@ -713,19 +751,23 @@ static ModulePtr FindModule( char * name ) { - ModulePtr module; - TagPtr prop; + ModulePtr module; + TagPtr prop; + + module = gModuleHead; + + while (module != 0) + { + prop = GetProperty(module->dict, kPropCFBundleIdentifier); + + if ((prop != 0) && !strcmp(name, prop->string)) { + break; + } + + module = module->nextModule; + } - module = gModuleHead; - - while (module != 0) - { - prop = GetProperty(module->dict, kPropCFBundleIdentifier); - if ((prop != 0) && !strcmp(name, prop->string)) break; - module = module->nextModule; - } - - return module; + return module; } #endif /* NOTDEF */ @@ -739,23 +781,30 @@ TagPtr moduleDict, required; ModulePtr tmpModule; - pos = 0; + pos = 0; - while (1) - { - length = XMLParseNextTag(buffer + pos, &moduleDict); - if (length == -1) break; - - pos += length; - - if (moduleDict == 0) continue; - if (moduleDict->type == kTagTypeDict) break; - - XMLFreeTag(moduleDict); - } - - if (length == -1) return -1; + while (1) + { + length = XMLParseNextTag(buffer + pos, &moduleDict); + if (length == -1) { + break; + } + pos += length; + + if (moduleDict == 0) { + continue; + } + if (moduleDict->type == kTagTypeDict) { + break; + } + XMLFreeTag(moduleDict); + } + + if (length == -1) { + return -1; + } + required = XMLGetProperty(moduleDict, kPropOSBundleRequired); if ( (required == 0) || (required->type != kTagTypeString) || !strcmp(required->string, "Safe Boot")) @@ -764,32 +813,31 @@ return -2; } - tmpModule = malloc(sizeof(Module)); - if (tmpModule == 0) - { - XMLFreeTag(moduleDict); - return -1; - } - tmpModule->dict = moduleDict; + tmpModule = malloc(sizeof(Module)); + if (tmpModule == 0) { + XMLFreeTag(moduleDict); + return -1; + } + tmpModule->dict = moduleDict; - // For now, load any module that has OSBundleRequired != "Safe Boot". + // For now, load any module that has OSBundleRequired != "Safe Boot". - tmpModule->willLoad = 1; + tmpModule->willLoad = 1; - *module = tmpModule; + *module = tmpModule; - // Get the personalities. + // Get the personalities. - *personalities = XMLGetProperty(moduleDict, kPropIOKitPersonalities); + *personalities = XMLGetProperty(moduleDict, kPropIOKitPersonalities); - return 0; + return 0; } #if NOTDEF static char gPlatformName[64]; #endif -long +long DecodeKernel(void *binary, entry_t *rentry, char **raddr, int *rsize) { long ret; @@ -845,22 +893,21 @@ } ret = ThinFatFile(&binary, &len); - if (ret == 0 && len == 0 && archCpuType==CPU_TYPE_X86_64) - { - archCpuType=CPU_TYPE_I386; - ret = ThinFatFile(&binary, &len); - } - - // Notify modules that the kernel has been decompressed, thinned and is about to be decoded + if (ret == 0 && len == 0 && archCpuType==CPU_TYPE_X86_64) + { + archCpuType=CPU_TYPE_I386; + ret = ThinFatFile(&binary, &len); + } + + // Notify modules that the kernel has been decompressed, thinned and is about to be decoded execute_hook("DecodeKernel", (void*)binary, NULL, NULL, NULL); - - - ret = DecodeMachO(binary, rentry, raddr, rsize); - if (ret<0 && archCpuType==CPU_TYPE_X86_64) - { - archCpuType=CPU_TYPE_I386; - ret = DecodeMachO(binary, rentry, raddr, rsize); - } - - return ret; + + ret = DecodeMachO(binary, rentry, raddr, rsize); + if (ret<0 && archCpuType==CPU_TYPE_X86_64) + { + archCpuType=CPU_TYPE_I386; + ret = DecodeMachO(binary, rentry, raddr, rsize); + } + + return ret; } Index: branches/chucko/i386/boot2/boot.c =================================================================== --- branches/chucko/i386/boot2/boot.c (revision 2328) +++ branches/chucko/i386/boot2/boot.c (revision 2329) @@ -75,7 +75,7 @@ char gRootDevice[ROOT_DEVICE_SIZE]; char gMKextName[512]; char gMacOSVersion[8]; -int bvCount = 0, gDeviceCount = 0; +int bvCount = 0, gDeviceCount = 0; //int menucount = 0; long gBootMode; /* defaults to 0 == kBootModeNormal */ BVRef bvr, menuBVR, bvChain; @@ -96,13 +96,13 @@ static void zeroBSS(void) { extern char bss_start __asm("section$start$__DATA$__bss"); - extern char bss_end __asm("section$end$__DATA$__bss"); - extern char common_start __asm("section$start$__DATA$__common"); - extern char common_end __asm("section$end$__DATA$__common"); - + extern char bss_end __asm("section$end$__DATA$__bss"); + extern char common_start __asm("section$start$__DATA$__common"); + extern char common_end __asm("section$end$__DATA$__common"); + bzero(&bss_start, (&bss_end - &bss_start)); bzero(&common_start, (&common_end - &common_start)); -} +} //========================================================================== // Malloc error function @@ -129,74 +129,73 @@ { int ret; entry_t kernelEntry; - + bootArgs->kaddr = bootArgs->ksize = 0; execute_hook("ExecKernel", (void*)binary, NULL, NULL, NULL); - + ret = DecodeKernel(binary, &kernelEntry, (char **) &bootArgs->kaddr, (int *)&bootArgs->ksize ); - + if ( ret != 0 ) return ret; - + // Reserve space for boot args reserveKernBootStruct(); - + // Notify modules that the kernel has been decoded execute_hook("DecodedKernel", (void*)binary, (void*)bootArgs->kaddr, (void*)bootArgs->ksize, NULL); - + setupFakeEfi(); - + // Load boot drivers from the specifed root path. //if (!gHaveKernelCache) LoadDrivers("/"); - + execute_hook("DriversLoaded", (void*)binary, NULL, NULL, NULL); - + clearActivityIndicator(); - + if (gErrors) { printf("Errors encountered while starting up the computer.\n"); printf("Pausing %d seconds...\n", kBootErrorTimeout); sleep(kBootErrorTimeout); } - + md0Ramdisk(); - + verbose("Starting Darwin %s\n",( archCpuType == CPU_TYPE_I386 ) ? "x86" : "x86_64"); verbose("Boot Args: %s\n", bootArgs->CommandLine); // Cleanup the PXE base code. - + if ( (gBootFileType == kNetworkDeviceType) && gUnloadPXEOnExit ) { - if ( (ret = nbpUnloadBaseCode()) != nbpStatusSuccess ) - { + if ( (ret = nbpUnloadBaseCode()) != nbpStatusSuccess ) { printf("nbpUnloadBaseCode error %d\n", (int) ret); sleep(2); } } - + bool dummyVal; if (getBoolForKey(kWaitForKeypressKey, &dummyVal, &bootInfo->chameleonConfig) && dummyVal) { showTextBuffer(msgbuf, strlen(msgbuf)); } - + usb_loop(); // If we were in text mode, switch to graphics mode. // This will draw the boot graphics unless we are in // verbose mode. - if (gVerboseMode) + if (gVerboseMode) { setVideoMode( GRAPHICS_MODE, 0 ); - else + } else { drawBootGraphics(); - + } setupBooterLog(); - + finalizeBootStruct(); - + // Jump to kernel's entry point. There's no going back now. if ((checkOSVersion("10.7")) || (checkOSVersion("10.8")) || (checkOSVersion("10.9"))) { @@ -207,16 +206,15 @@ // Masking out so that Lion doesn't doublefault outb(0x21, 0xff); /* Maskout all interrupts Pic1 */ outb(0xa1, 0xff); /* Maskout all interrupts Pic2 */ - + startprog( kernelEntry, bootArgs ); - } - else { + } else { // Notify modules that the kernel is about to be started execute_hook("Kernel Start", (void*)kernelEntry, (void*)bootArgsPreLion, NULL, NULL); startprog( kernelEntry, bootArgsPreLion ); } - + // Not reached return 0; } @@ -225,17 +223,17 @@ //========================================================================== // LoadKernelCache - Try to load Kernel Cache. // return the length of the loaded cache file or -1 on error -long LoadKernelCache(const char* cacheFile, void **binary) { +long LoadKernelCache(const char* cacheFile, void **binary) +{ char kernelCacheFile[512]; char kernelCachePath[512]; long flags, time, cachetime, kerneltime, exttime, ret=-1; - unsigned long adler32; + unsigned long adler32; - if((gBootMode & kBootModeSafe) != 0) - { + if((gBootMode & kBootModeSafe) != 0) { verbose("Kernel Cache ignored.\n"); return -1; - } + } // Use specify kernel cache file if not empty if (cacheFile[0] != 0) @@ -247,39 +245,38 @@ // Lion, Mountain Lion and Mavericks prelink kernel cache file if ((checkOSVersion("10.7")) || (checkOSVersion("10.8")) || (checkOSVersion("10.9"))) { - snprintf(kernelCacheFile, sizeof(kernelCacheFile), "%skernelcache", kDefaultCachePathSnow); + snprintf(kernelCacheFile, sizeof(kernelCacheFile), "%skernelcache", kDefaultCachePathSnow); } // Snow Leopard prelink kernel cache file else if (checkOSVersion("10.6")) { - snprintf(kernelCacheFile, sizeof(kernelCacheFile), "kernelcache_%s", - (archCpuType == CPU_TYPE_I386) ? "i386" : "x86_64"); - int lnam = strlen(kernelCacheFile) + 9; //with adler32 + snprintf(kernelCacheFile, sizeof(kernelCacheFile), "kernelcache_%s", + (archCpuType == CPU_TYPE_I386) ? "i386" : "x86_64"); + int lnam = strlen(kernelCacheFile) + 9; //with adler32 - char* name; - long prev_time = 0; + char* name; + long prev_time = 0; - struct dirstuff* cacheDir = opendir(kDefaultCachePathSnow); - /* TODO: handle error? */ - if (cacheDir) { - while (readdir(cacheDir, (const char**)&name, &flags, &time) >= 0) { - if (((flags & kFileTypeMask) != kFileTypeDirectory) && time > prev_time - && strstr(name, kernelCacheFile) && (name[lnam] != '.')) { - snprintf(kernelCacheFile, sizeof(kernelCacheFile), "%s%s", kDefaultCachePathSnow, name); - prev_time = time; - } - } - } - closedir(cacheDir); + struct dirstuff* cacheDir = opendir(kDefaultCachePathSnow); + /* TODO: handle error? */ + if (cacheDir) { + while(readdir(cacheDir, (const char**)&name, &flags, &time) >= 0) { + if (((flags & kFileTypeMask) != kFileTypeDirectory) && time > prev_time + && strstr(name, kernelCacheFile) && (name[lnam] != '.')) { + snprintf(kernelCacheFile, sizeof(kernelCacheFile), "%s%s", kDefaultCachePathSnow, name); + prev_time = time; + } + } + } + closedir(cacheDir); + } else { + // Reset cache name. + bzero(gCacheNameAdler + 64, sizeof(gCacheNameAdler) - 64); + snprintf(gCacheNameAdler + 64, sizeof(gCacheNameAdler) - 64, + "%s,%s", + gRootDevice, bootInfo->bootFile); + adler32 = Adler32((unsigned char *)gCacheNameAdler, sizeof(gCacheNameAdler)); + snprintf(kernelCacheFile, sizeof(kernelCacheFile), "%s.%08lX", kDefaultCachePathLeo, adler32); } - else { - // Reset cache name. - bzero(gCacheNameAdler + 64, sizeof(gCacheNameAdler) - 64); - snprintf(gCacheNameAdler + 64, sizeof(gCacheNameAdler) - 64, - "%s,%s", - gRootDevice, bootInfo->bootFile); - adler32 = Adler32((unsigned char *)gCacheNameAdler, sizeof(gCacheNameAdler)); - snprintf(kernelCacheFile, sizeof(kernelCacheFile), "%s.%08lX", kDefaultCachePathLeo, adler32); - } } // Check if the kernel cache file exists @@ -287,25 +284,27 @@ // If boot from a boot helper partition check the kernel cache file on it if (gBootVolume->flags & kBVFlagBooter) { - snprintf(kernelCachePath, sizeof(kernelCachePath), "com.apple.boot.P%s", kernelCacheFile); - ret = GetFileInfo(NULL, kernelCachePath, &flags, &cachetime); - if ((ret == -1) || ((flags & kFileTypeMask) != kFileTypeFlat)) { - snprintf(kernelCachePath, sizeof(kernelCachePath), "com.apple.boot.R%s", kernelCacheFile); - ret = GetFileInfo(NULL, kernelCachePath, &flags, &cachetime); - if ((ret == -1) || ((flags & kFileTypeMask) != kFileTypeFlat)) { - snprintf(kernelCachePath, sizeof(kernelCachePath), "com.apple.boot.S%s", kernelCacheFile); - ret = GetFileInfo(NULL, kernelCachePath, &flags, &cachetime); - if ((flags & kFileTypeMask) != kFileTypeFlat) - ret = -1; - } - } + snprintf(kernelCachePath, sizeof(kernelCachePath), "com.apple.boot.P%s", kernelCacheFile); + ret = GetFileInfo(NULL, kernelCachePath, &flags, &cachetime); + if ((ret == -1) || ((flags & kFileTypeMask) != kFileTypeFlat)) { + snprintf(kernelCachePath, sizeof(kernelCachePath), "com.apple.boot.R%s", kernelCacheFile); + ret = GetFileInfo(NULL, kernelCachePath, &flags, &cachetime); + if ((ret == -1) || ((flags & kFileTypeMask) != kFileTypeFlat)) { + snprintf(kernelCachePath, sizeof(kernelCachePath), "com.apple.boot.S%s", kernelCacheFile); + ret = GetFileInfo(NULL, kernelCachePath, &flags, &cachetime); + if ((flags & kFileTypeMask) != kFileTypeFlat) { + ret = -1; + } + } + } } // If not found, use the original kernel cache path. if (ret == -1) { - strlcpy(kernelCachePath, kernelCacheFile, sizeof(kernelCachePath)); - ret = GetFileInfo(NULL, kernelCachePath, &flags, &cachetime); - if ((flags & kFileTypeMask) != kFileTypeFlat) - ret = -1; + strlcpy(kernelCachePath, kernelCacheFile, sizeof(kernelCachePath)); + ret = GetFileInfo(NULL, kernelCachePath, &flags, &cachetime); + if ((flags & kFileTypeMask) != kFileTypeFlat) { + ret = -1; + } } // Exit if kernel cache file wasn't found @@ -373,19 +372,19 @@ int status; unsigned int allowBVFlags = kBVFlagSystemVolume | kBVFlagForeignBoot; unsigned int denyBVFlags = kBVFlagEFISystem; - + // Set reminder to unload the PXE base code. Neglect to unload // the base code will result in a hang or kernel panic. gUnloadPXEOnExit = true; - + // Record the device that the booter was loaded from. gBIOSDev = biosdev & kBIOSDevMask; - + // Initialize boot info structure. initKernBootStruct(); - + initBooterLog(); - + // Setup VGA text mode. // Not sure if it is safe to call setVideoMode() before the // config table has been loaded. Call video_mode() instead. @@ -396,39 +395,39 @@ #if DEBUG printf("after video_mode\n"); #endif - + // Scan and record the system's hardware information. scan_platform(); - + // First get info for boot volume. scanBootVolumes(gBIOSDev, 0); bvChain = getBVChainForBIOSDev(gBIOSDev); setBootGlobals(bvChain); - + // Load boot.plist config file status = loadChameleonConfig(&bootInfo->chameleonConfig); - + if (getBoolForKey(kQuietBootKey, &quiet, &bootInfo->chameleonConfig) && quiet) { gBootMode |= kBootModeQuiet; } - + // Override firstRun to get to the boot menu instantly by setting "Instant Menu"=y in system config if (getBoolForKey(kInstantMenuKey, &instantMenu, &bootInfo->chameleonConfig) && instantMenu) { firstRun = false; } - + // Loading preboot ramdisk if exists. loadPrebootRAMDisk(); - + // Disable rescan option by default gEnableCDROMRescan = false; - + // Enable it with Rescan=y in system config if (getBoolForKey(kRescanKey, &gEnableCDROMRescan, &bootInfo->chameleonConfig) && gEnableCDROMRescan) { gEnableCDROMRescan = true; } - + // Ask the user for Rescan option by setting "Rescan Prompt"=y in system config. rescanPrompt = false; if (getBoolForKey(kRescanPromptKey, &rescanPrompt , &bootInfo->chameleonConfig) @@ -436,28 +435,28 @@ { gEnableCDROMRescan = promptForRescanOption(); } - + // Enable touching a single BIOS device only if "Scan Single Drive"=y is set in system config. if (getBoolForKey(kScanSingleDriveKey, &gScanSingleDrive, &bootInfo->chameleonConfig) && gScanSingleDrive) { gScanSingleDrive = true; } - + // Create a list of partitions on device(s). if (gScanSingleDrive) { scanBootVolumes(gBIOSDev, &bvCount); } else { scanDisks(gBIOSDev, &bvCount); } - + // Create a separated bvr chain using the specified filters. bvChain = newFilteredBVChain(0x80, 0xFF, allowBVFlags, denyBVFlags, &gDeviceCount); - + gBootVolume = selectBootVolume(bvChain); - + // Intialize module system init_module_system(); - + #if DEBUG printf(" Default: %d, ->biosdev: %d, ->part_no: %d ->flags: %d\n", gBootVolume, gBootVolume->biosdev, gBootVolume->part_no, gBootVolume->flags); @@ -474,9 +473,9 @@ // initGUI() returned with an error, disabling GUI. useGUI = false; } - + setBootGlobals(bvChain); - + // Parse args, load and start kernel. while (1) { @@ -486,7 +485,7 @@ int len, ret = -1; long flags, sleeptime, time; void *binary = (void *)kLoadAddr; - + char bootFile[sizeof(bootInfo->bootFile)]; char bootFilePath[512]; char kernelCacheFile[512]; @@ -494,11 +493,11 @@ // Initialize globals. sysConfigValid = false; gErrors = false; - + status = getBootOptions(firstRun); firstRun = false; if (status == -1) continue; - + status = processBootOptions(); // Status == 1 means to chainboot if ( status == 1 ) break; @@ -519,9 +518,9 @@ } continue; } - + // Other status (e.g. 0) means that we should proceed with boot. - + // Turn off any GUI elements if ( bootArgs->Video.v_display == GRAPHICS_MODE ) { @@ -533,74 +532,74 @@ drawBackground(); updateVRAM(); } - + // Find out which version mac os we're booting. getOSVersion(); - + if (platformCPUFeature(CPU_FEATURE_EM64T)) { archCpuType = CPU_TYPE_X86_64; } else { archCpuType = CPU_TYPE_I386; } - + if (getValueForKey(karch, &val, &len, &bootInfo->chameleonConfig)) { if (strncmp(val, "i386", 4) == 0) { archCpuType = CPU_TYPE_I386; } } - + if (getValueForKey(kKernelArchKey, &val, &len, &bootInfo->chameleonConfig)) { if (strncmp(val, "i386", 4) == 0) { archCpuType = CPU_TYPE_I386; } } - + // Notify modules that we are attempting to boot execute_hook("PreBoot", NULL, NULL, NULL, NULL); - + if (!getBoolForKey (kWake, &tryresume, &bootInfo->chameleonConfig)) { tryresume = true; tryresumedefault = true; } else { tryresumedefault = false; } - + if (!getBoolForKey (kForceWake, &forceresume, &bootInfo->chameleonConfig)) { forceresume = false; } - + if (forceresume) { tryresume = true; tryresumedefault = false; } - + while (tryresume) { const char *tmp; BVRef bvr; if (!getValueForKey(kWakeImage, &val, &len, &bootInfo->chameleonConfig)) val = "/private/var/vm/sleepimage"; - + // Do this first to be sure that root volume is mounted ret = GetFileInfo(0, val, &flags, &sleeptime); - + if ((bvr = getBootVolumeRef(val, &tmp)) == NULL) break; - + // Can't check if it was hibernation Wake=y is required if (bvr->modTime == 0 && tryresumedefault) break; - + if ((ret != 0) || ((flags & kFileTypeMask) != kFileTypeFlat)) break; - + if (!forceresume && ((sleeptime+3)modTime)) { -#if DEBUG +#if DEBUG printf ("Hibernate image is too old by %d seconds. Use ForceWake=y to override\n", bvr->modTime-sleeptime); -#endif +#endif break; } - + HibernateBoot((char *)val); break; } @@ -618,7 +617,7 @@ val++; } /* FIXME: check len vs sizeof(kernelCacheFile) */ - strlcpy(kernelCacheFile, val, len + 1); + strlcpy(kernelCacheFile, val, len + 1); } else { kernelCacheFile[0] = 0; // Use default kernel cache file } @@ -639,7 +638,7 @@ useKernelCache = false; } while(0); - + do { if (useKernelCache) { ret = LoadKernelCache(kernelCacheFile, &binary); @@ -680,7 +679,7 @@ // No alternate location found, using the original kernel image path. strlcpy(bootFilePath, bootFile, sizeof(bootFilePath)); } - + verbose("Loading kernel %s\n", bootFilePath); ret = LoadThinFatFile(bootFilePath, &binary); if (ret <= 0 && archCpuType == CPU_TYPE_X86_64) @@ -689,18 +688,18 @@ ret = LoadThinFatFile(bootFilePath, &binary); } } while (0); - + clearActivityIndicator(); - + #if DEBUG printf("Pausing..."); sleep(8); #endif - + if (ret <= 0) { printf("Can't find %s\n", bootFile); sleep(1); - + if (gBootFileType == kNetworkDeviceType) { // Return control back to PXE. Don't unload PXE base code. gUnloadPXEOnExit = false; @@ -775,7 +774,7 @@ unsigned long s2 = 0; // (adler >> 16) & 0xffff; unsigned long result; int k; - + while (len > 0) { k = len < NMAX ? len : NMAX; len -= k; Index: branches/chucko/i386/boot2/boot2.s =================================================================== --- branches/chucko/i386/boot2/boot2.s (revision 2328) +++ branches/chucko/i386/boot2/boot2.s (revision 2329) @@ -64,7 +64,7 @@ # # Returns: # -LABEL(boot2) +LABEL(boot2) # Entry point at 0:BOOTER_ADDR (will be called by boot1) pushl %ecx # Save general purpose registers pushl %ebx pushl %ebp Index: branches/chucko/i386/boot2/boot.h =================================================================== --- branches/chucko/i386/boot2/boot.h (revision 2328) +++ branches/chucko/i386/boot2/boot.h (revision 2329) @@ -193,10 +193,10 @@ * Boot Modes */ enum { - kBootModeNormal = 0, - kBootModeSafe = 1, - kBootModeSecure = 2, - kBootModeQuiet = 4 + kBootModeNormal = 0, + kBootModeSafe = 1, + kBootModeSecure = 2, + kBootModeQuiet = 4 }; extern void initialize_runtime(); @@ -215,16 +215,20 @@ extern int getVideoMode(); extern void spinActivityIndicator(); extern void clearActivityIndicator(); -extern void drawColorRectangle( unsigned short x, - unsigned short y, - unsigned short width, - unsigned short height, - unsigned char colorIndex ); -extern void drawDataRectangle( unsigned short x, - unsigned short y, - unsigned short width, - unsigned short height, - unsigned char * data ); +extern void drawColorRectangle( + unsigned short x, + unsigned short y, + unsigned short width, + unsigned short height, + unsigned char colorIndex + ); +extern void drawDataRectangle( + unsigned short x, + unsigned short y, + unsigned short width, + unsigned short height, + unsigned char * data + ); extern int convertImage( unsigned short width, unsigned short height, @@ -265,8 +269,8 @@ char *getMemoryInfoString(); typedef struct { - char name[80]; - void * param; + char name[80]; + void * param; } MenuItem; /* @@ -275,15 +279,15 @@ extern int decompress_lzss(u_int8_t *dst, u_int8_t *src, u_int32_t srclen); struct compressed_kernel_header { - u_int32_t signature; - u_int32_t compress_type; - u_int32_t adler32; - u_int32_t uncompressed_size; - u_int32_t compressed_size; - u_int32_t reserved[11]; - char platform_name[64]; - char root_path[256]; - u_int8_t data[0]; + u_int32_t signature; + u_int32_t compress_type; + u_int32_t adler32; + u_int32_t uncompressed_size; + u_int32_t compressed_size; + u_int32_t reserved[11]; + char platform_name[64]; + char root_path[256]; + u_int8_t data[0]; }; typedef struct compressed_kernel_header compressed_kernel_header; Index: branches/chucko/i386/boot2/modules.c =================================================================== --- branches/chucko/i386/boot2/modules.c (revision 2328) +++ branches/chucko/i386/boot2/modules.c (revision 2329) @@ -107,13 +107,11 @@ struct dirstuff* moduleDir = opendir("/Extra/modules/"); while (readdir(moduleDir, (const char**)&name, &flags, &time) >= 0) { - if (strcmp(&name[strlen(name) - sizeof("dylib")], ".dylib") == 0) - { + if(strcmp(&name[strlen(name) - sizeof("dylib")], ".dylib") == 0) { char* tmp = malloc(strlen(name) + 1); strcpy(tmp, name); - if (!load_module(tmp)) - { + if(!load_module(tmp)) { // failed to load // free(tmp); } @@ -123,7 +121,7 @@ DBG("Ignoring %s\n", name); } } - closedir(moduleDir); + closedir(moduleDir); } @@ -985,14 +983,14 @@ UInt32 addr = lookup_all_symbols(symbol); if(addr != 0xFFFFFFFF) { - //DBG("Replacing %s to point to 0x%x\n", symbol, newAddress); - UInt32* jumpPointer = malloc(sizeof(UInt32*)); - char* binary = (char*)addr; - *binary++ = 0xFF; // Jump - *binary++ = 0x25; // Long Jump - *((UInt32*)binary) = (UInt32)jumpPointer; - *jumpPointer = (UInt32)newAddress; - return 1; + //DBG("Replacing %s to point to 0x%x\n", symbol, newAddress); + UInt32* jumpPointer = malloc(sizeof(UInt32*)); + char* binary = (char*)addr; + *binary++ = 0xFF; // Jump + *binary++ = 0x25; // Long Jump + *((UInt32*)binary) = (UInt32)jumpPointer; + *jumpPointer = (UInt32)newAddress; + return 1; } return 0; } Index: branches/chucko/i386/boot2/gui.c =================================================================== --- branches/chucko/i386/boot2/gui.c (revision 2328) +++ branches/chucko/i386/boot2/gui.c (revision 2329) @@ -1811,7 +1811,7 @@ currentline = lines - visiblelines; } } - free(text); + free(text); } void animateProgressBar() Index: branches/chucko/i386/boot2/ramdisk.c =================================================================== --- branches/chucko/i386/boot2/ramdisk.c (revision 2328) +++ branches/chucko/i386/boot2/ramdisk.c (revision 2329) @@ -29,17 +29,17 @@ &bootInfo->chameleonConfig)) { // Use user specified md0 file - snprintf(filename, sizeof(filename), "%s", override_filename); + snprintf(filename, sizeof(filename), "%s", override_filename); fh = open(filename, 0); if(fh < 0) { - snprintf(filename, sizeof(filename), "rd(0,0)/Extra/%s", override_filename); + snprintf(filename, sizeof(filename), "rd(0,0)/Extra/%s", override_filename); fh = open(filename, 0); if(fh < 0) { - snprintf(filename, sizeof(filename), "/Extra/%s", override_filename); + snprintf(filename, sizeof(filename), "/Extra/%s", override_filename); fh = open(filename, 0); } } @@ -151,7 +151,7 @@ if (error == 0) { // Save filename in gRAMDiskFile to display information. - strlcpy(gRAMDiskFile, param, sizeof(gRAMDiskFile)); + strlcpy(gRAMDiskFile, param, sizeof(gRAMDiskFile)); // Set gMI as well for the multiboot ramdisk driver hook. gMI = gRAMDiskMI = malloc(sizeof(multiboot_info)); Index: branches/chucko/i386/boot2/options.c =================================================================== --- branches/chucko/i386/boot2/options.c (revision 2328) +++ branches/chucko/i386/boot2/options.c (revision 2329) @@ -641,28 +641,29 @@ char *getMemoryInfoString() { - int i, bufflen; - MemoryRange *mp = bootInfo->memoryMap; - char *buff = malloc(sizeof(char)*1024); - if (!buff) - return 0; - - static const char info[] = "BIOS reported memory ranges:\n"; - bufflen = sprintf(buff, "%s", info); + int i, bufflen; + MemoryRange *mp = bootInfo->memoryMap; + char *buff = malloc(sizeof(char)*1024); + if(!buff) { + return 0; + } - for (i = 0; - (i < bootInfo->memoryMapCount) && (bufflen < 1024); /* prevent buffer overflow */ - i++) { - bufflen += snprintf(buff+bufflen, 1024-bufflen, "Base 0x%08x%08x, ", + static const char info[] = "BIOS reported memory ranges:\n"; + bufflen = sprintf(buff, "%s", info); + + for (i = 0; + (i < bootInfo->memoryMapCount) && (bufflen < 1024); /* prevent buffer overflow */ + i++) { + bufflen += snprintf(buff+bufflen, 1024-bufflen, "Base 0x%08x%08x, ", (unsigned long)(mp->base >> 32), (unsigned long)(mp->base)); - bufflen += snprintf(buff+bufflen, 1024-bufflen, "length 0x%08x%08x, type %d\n", + bufflen += snprintf(buff+bufflen, 1024-bufflen, "length 0x%08x%08x, type %d\n", (unsigned long)(mp->length >> 32), (unsigned long)(mp->length), mp->type); - mp++; - } - return buff; + mp++; + } + return buff; } //========================================================================== Index: branches/chucko/i386/config/symbol.c =================================================================== --- branches/chucko/i386/config/symbol.c (revision 2328) +++ branches/chucko/i386/config/symbol.c (revision 2329) @@ -881,13 +881,13 @@ newlen = strlen(res) + strlen(symval) + strlen(src) + 1; if (newlen > reslen) { - char* newres = NULL; - if (!(newres = realloc(res, newlen))) { - /* TODO: handle error gracefully - for now, punt */ - break; - } - res = newres; - reslen = newlen; + char* newres = NULL; + if (!(newres = realloc(res, newlen))) { + /* TODO: handle error gracefully - for now, punt */ + break; + } + res = newres; + reslen = newlen; } strcat(res, symval); Index: branches/chucko/i386/config/confdata.c =================================================================== --- branches/chucko/i386/config/confdata.c (revision 2328) +++ branches/chucko/i386/config/confdata.c (revision 2329) @@ -902,7 +902,7 @@ } fclose(out); fclose(out_h); - fclose(out_inc); + fclose(out_inc); name = getenv("CCONFIG_AUTOHEADER"); if (!name) name = "autoconf.h"; Index: branches/chucko/i386/libsa/printf.c =================================================================== --- branches/chucko/i386/libsa/printf.c (revision 2328) +++ branches/chucko/i386/libsa/printf.c (revision 2329) @@ -65,16 +65,16 @@ /*VARARGS1*/ int snprintf(char * str, size_t size, const char * fmt, ...) { - va_list ap; - struct putc_info pi; + va_list ap; + struct putc_info pi; - va_start(ap, fmt); - pi.str = str; - pi.last_str = str + size - 1; - prf(fmt, ap, sputc, &pi); - *pi.str = '\0'; - va_end(ap); - return (pi.str - str); + va_start(ap, fmt); + pi.str = str; + pi.last_str = str + size - 1; + prf(fmt, ap, sputc, &pi); + *pi.str = '\0'; + va_end(ap); + return (pi.str - str); } /*VARARGS1*/ Index: branches/chucko/i386/libsa/string.c =================================================================== --- branches/chucko/i386/libsa/string.c (revision 2328) +++ branches/chucko/i386/libsa/string.c (revision 2329) @@ -161,10 +161,11 @@ { register char *ret = s1; while (n && (*s1++ = *s2++)) - --n; - /* while (n--) *s1++ = '\0'; */ - if (n > 0) - bzero(s1, n); + --n; + /* while (n--) *s1++ = '\0'; */ + if (n > 0) { + bzero(s1, n); + } return ret; } @@ -278,7 +279,7 @@ if (*start == '"') { start++; - + end = strchr(start, '"'); if(end) quoted = true; @@ -290,12 +291,12 @@ for ( end = start; *end && !isspace(*end); end++ ) {} } - + *len = end - start; - + if(next) *next = quoted ? end+1 : end; - + return start; } Property changes on: branches/chucko ___________________________________________________________________ Modified: svn:mergeinfo Merged /trunk:r2319-2328