generate_memory_map.command

#!/bin/bash
# GenCustomMemory — CustomMemory.plist generator for OpenCore (MacPro7,1)
# https://dortania.github.io/OpenCore-Post-Install/universal/memory.html
# https://github.com/Olegovich17/GenCustomMemory

set -u

SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
DMIDECODE_BIN="$SCRIPT_DIR/dmidecode"
OUTPUT_FILE="$SCRIPT_DIR/custom_memory.plist"

# ─── Colors ───────────────────────────────────────────────────────────────────
RED='\033[0;31m'
GREEN='\033[0;32m'
CYAN='\033[0;36m'
BOLD='\033[1m'
NC='\033[0m'

info()  { echo -e "${CYAN}[i]${NC} $*"; }
ok()    { echo -e "${GREEN}[✓]${NC} $*"; }
err()   { echo -e "${RED}[✗]${NC} $*"; }

# ─── Helpers ──────────────────────────────────────────────────────────────────
parse_block() {
    echo "$1" | grep -i "^[[:space:]]*$2:" | head -1 | sed 's/^[^:]*: *//' || true
}

extract_num() {
    echo "$1" | grep -o '[0-9]*' | head -1
}

clean_val() {
    case "$1" in
        "Not Specified"|"Unknown"|"0x0000"|"NO DIMM"|"No Asset Information"|"") echo "";;
        *) echo "$1";;
    esac
}

# ─── Ensure dmidecode ─────────────────────────────────────────────────────────
ensure_dmidecode() {
    if command -v dmidecode &>/dev/null; then
        DMIDECODE_BIN="$(command -v dmidecode)"
        info "System dmidecode found: $DMIDECODE_BIN"
        return
    fi

    [[ -x "$DMIDECODE_BIN" ]] && return

    info "dmidecode not found. Downloading from GitHub Acidanthera..."

    local api_url="https://api.github.com/repos/acidanthera/dmidecode/releases/latest"
    local release_json
    release_json=$(curl -fsSL "$api_url" 2>/dev/null) || { err "Failed to fetch release info"; return 1; }

    local zip_url
    zip_url=$(echo "$release_json" | grep -o '"browser_download_url": *"[^"]*\.zip"' | head -1 | cut -d'"' -f4)

    [[ -z "$zip_url" ]] && { err "No zip archive found in releases"; return 1; }

    info "Downloading: $zip_url"
    local zip_path="$SCRIPT_DIR/dmidecode.zip"
    curl -fsSL -o "$zip_path" "$zip_url" || { err "Download failed"; return 1; }

    unzip -oq "$zip_path" -d "$SCRIPT_DIR/_dmidecode_extract" 2>/dev/null
    find "$SCRIPT_DIR/_dmidecode_extract" -name "dmidecode" -type f -exec mv {} "$DMIDECODE_BIN" \;
    rm -rf "$SCRIPT_DIR/_dmidecode_extract" "$zip_path"

    chmod +x "$DMIDECODE_BIN"
    ok "dmidecode ready"
}

# ─── Parse dmidecode ─────────────────────────────────────────────────────────
parse_dmidecode() {
    local dmi_output
    dmi_output=$("$DMIDECODE_BIN" -t memory 2>/dev/null) || { err "dmidecode failed"; exit 1; }

    G_DATA_WIDTH=64
    G_TOTAL_WIDTH=64
    G_ERROR_CORRECTION=3
    G_FORM_FACTOR=9
    G_MAX_CAPACITY=0
    G_TYPE=26
    G_TYPE_DETAIL=128
    G_NUM_DEVICES=12

    MOD_DEVICE_LOCATOR=()
    MOD_BANK_LOCATOR=()
    MOD_MANUFACTURER=()
    MOD_PART_NUMBER=()
    MOD_SERIAL_NUMBER=()
    MOD_ASSET_TAG=()
    MOD_SIZE=()
    MOD_SPEED=()

    # MaxCapacity
    local mc_raw
    mc_raw=$(echo "$dmi_output" | sed -n '/Physical Memory Array/,/^$/p' | grep -i "^[[:space:]]*Maximum Capacity:" | head -1 | sed 's/^[^:]*: *//')
    if [[ -n "$mc_raw" ]]; then
        if echo "$mc_raw" | grep -qi "No Limit"; then
            G_MAX_CAPACITY=274877906944
        else
            local val
            val=$(extract_num "$mc_raw")
            if echo "$mc_raw" | grep -qi "GB"; then
                G_MAX_CAPACITY=$((val * 1024 * 1024 * 1024))
            elif echo "$mc_raw" | grep -qi "MB"; then
                G_MAX_CAPACITY=$((val * 1024 * 1024))
            fi
        fi
    fi

    # Number of devices
    local num_dev_raw
    num_dev_raw=$(echo "$dmi_output" | sed -n '/Physical Memory Array/,/^$/p' | grep -i "^[[:space:]]*Number Of Devices:" | head -1 | sed 's/^[^:]*: *//')
    G_NUM_DEVICES=$(extract_num "$num_dev_raw")
    [[ -z "$G_NUM_DEVICES" || "$G_NUM_DEVICES" -eq 0 ]] && G_NUM_DEVICES=12

    # Memory Device blocks
    local in_block=0 block=""

    while IFS= read -r line; do
        if [[ "$line" == "Memory Device"* ]]; then
            [[ $in_block -eq 1 && -n "$block" ]] && process_device_block "$block"
            in_block=1
            block="$line"
            continue
        fi
        [[ $in_block -eq 1 ]] && block+=$'\n'"$line"
    done <<< "$dmi_output"

    [[ $in_block -eq 1 && -n "$block" ]] && process_device_block "$block"
}

process_device_block() {
    local block="$1"

    local size_raw
    size_raw=$(parse_block "$block" "Size")
    [[ -z "$size_raw" ]] && return
    echo "$size_raw" | grep -q "No Module Installed" && return

    # Size to MB
    local size_mb=0
    local val
    val=$(extract_num "$size_raw")
    if echo "$size_raw" | grep -qi "GB"; then
        size_mb=$((val * 1024))
    elif echo "$size_raw" | grep -qi "MB"; then
        size_mb=$val
    elif echo "$size_raw" | grep -qi "TB"; then
        size_mb=$((val * 1024 * 1024))
    fi

    # Speed
    local speed_raw speed_mhz=0
    speed_raw=$(parse_block "$block" "Speed")
    [[ -n "$speed_raw" ]] && speed_mhz=$(extract_num "$speed_raw")
    [[ -z "$speed_mhz" ]] && speed_mhz=0

    # Fields
    local device_locator bank_locator manufacturer part_number serial_number asset_tag
    device_locator=$(clean_val "$(parse_block "$block" "Device Locator")")
    bank_locator=$(clean_val "$(parse_block "$block" "Bank Locator")")
    manufacturer=$(clean_val "$(parse_block "$block" "Manufacturer")")
    part_number=$(clean_val "$(parse_block "$block" "Part Number")")
    serial_number=$(clean_val "$(parse_block "$block" "Serial Number")")
    asset_tag=$(clean_val "$(parse_block "$block" "Asset Tag")")

    # Global properties from first populated module
    if [[ ${#MOD_SIZE[@]} -eq 0 ]]; then
        local dw tw ec ff tp td
        dw=$(extract_num "$(parse_block "$block" "Data Width")")
        tw=$(extract_num "$(parse_block "$block" "Total Width")")
        ec=$(parse_block "$block" "Error Correction Type")
        ff=$(parse_block "$block" "Form Factor")
        tp=$(parse_block "$block" "Type")
        td=$(parse_block "$block" "Type Detail")

        [[ -n "$dw" ]] && G_DATA_WIDTH=$dw
        [[ -n "$tw" ]] && G_TOTAL_WIDTH=$tw

        case "$ec" in
            "None") G_ERROR_CORRECTION=3;;
            "Parity") G_ERROR_CORRECTION=4;;
            "Single-bit ECC") G_ERROR_CORRECTION=5;;
            "Multi-bit ECC") G_ERROR_CORRECTION=6;;
        esac

        case "$ff" in
            "DIMM") G_FORM_FACTOR=9;;
            "SODIMM") G_FORM_FACTOR=13;;
            "FB-DIMM") G_FORM_FACTOR=15;;
        esac

        case "$tp" in
            "DDR3") G_TYPE=24;;
            "DDR4") G_TYPE=26;;
            "DDR5"|"LPDDR") G_TYPE=27;;
            "LPDDR2") G_TYPE=28;;
            "LPDDR3") G_TYPE=29;;
            "LPDDR4") G_TYPE=30;;
        esac

        # TypeDetail bitmask — one grep call
        local td_val=0
        echo "$td" | grep -qiE "Synchronous|Registered|Unbuffered|LRDIMM" && {
            echo "$td" | grep -qi "Synchronous" && td_val=$((td_val | 0x0080))
            echo "$td" | grep -qi "Registered" && td_val=$((td_val | 0x2000))
            echo "$td" | grep -qi "Unbuffered" && td_val=$((td_val | 0x4000))
            echo "$td" | grep -qi "LRDIMM" && td_val=$((td_val | 0x1000))
        }
        [[ $td_val -ne 0 ]] && G_TYPE_DETAIL=$td_val
    fi

    MOD_DEVICE_LOCATOR+=("$device_locator")
    MOD_BANK_LOCATOR+=("$bank_locator")
    MOD_MANUFACTURER+=("$manufacturer")
    MOD_PART_NUMBER+=("$part_number")
    MOD_SERIAL_NUMBER+=("$serial_number")
    MOD_ASSET_TAG+=("$asset_tag")
    MOD_SIZE+=("$size_mb")
    MOD_SPEED+=("$speed_mhz")
}

# ─── Interactive menu ─────────────────────────────────────────────────────────
interactive_menu() {
    local detected=$1

    local current_type_name="DDR4"
    case $G_TYPE in
        24) current_type_name="DDR3";;
        26) current_type_name="DDR4";;
        27) current_type_name="DDR5";;
    esac

    local current_ff_name="DIMM"
    case $G_FORM_FACTOR in
        13) current_ff_name="SODIMM";;
        15) current_ff_name="FB-DIMM";;
    esac

    local max_gb=$((G_MAX_CAPACITY / 1024 / 1024 / 1024))
    [[ $max_gb -eq 0 ]] && max_gb=128

    echo ""
    echo -e "${BOLD}============================================================${NC}"
    echo -e "${BOLD} OPENCORE MEMORY MAP GENERATOR (MacPro7,1)                  ${NC}"
    echo -e "${BOLD}============================================================${NC}"
    echo -e "Detected installed modules: ${GREEN}$detected${NC}"
    echo ""

    info "Auto-detected from dmidecode:"
    echo "    DataWidth:       $G_DATA_WIDTH"
    echo "    TotalWidth:      $G_TOTAL_WIDTH"
    echo "    ErrorCorrection: $G_ERROR_CORRECTION"
    echo "    FormFactor:      $G_FORM_FACTOR ($current_ff_name)"
    echo "    Type:            $G_TYPE ($current_type_name)"
    echo "    TypeDetail:      $G_TYPE_DETAIL"
    [[ $G_MAX_CAPACITY -gt 0 ]] && echo "    MaxCapacity:     $max_gb GB"
    echo ""

    echo "Press Enter to accept auto-values, or choose from the list:"
    echo ""

    echo "1. RAM Type:"
    echo "   [1] DDR3"
    echo "   [2] DDR4"
    echo "   [3] DDR5"
    echo ""
    local ram_choice
    read -rp "   Choice [$current_type_name]: " ram_choice
    case "$ram_choice" in
        1) G_TYPE=24;;
        2) G_TYPE=26;;
        3) G_TYPE=27;;
    esac

    echo ""

    echo "2. Form Factor:"
    echo "   [1] DIMM"
    echo "   [2] SODIMM"
    echo "   [3] FB-DIMM"
    echo ""
    local ff_choice
    read -rp "   Choice [$current_ff_name]: " ff_choice
    case "$ff_choice" in
        1) G_FORM_FACTOR=9;;
        2) G_FORM_FACTOR=13;;
        3) G_FORM_FACTOR=15;;
    esac

    echo ""

    local max_input
    read -rp "3. Max memory capacity in GB [$max_gb]: " max_input
    if [[ -n "$max_input" ]] && [[ "$max_input" =~ ^[0-9]+$ ]]; then
        G_MAX_CAPACITY=$((max_input * 1024 * 1024 * 1024))
    elif [[ $G_MAX_CAPACITY -eq 0 ]]; then
        G_MAX_CAPACITY=$((max_gb * 1024 * 1024 * 1024))
    fi
}

# ─── Generate plist ──────────────────────────────────────────────────────────
generate_plist() {
    local real_speed=0
    [[ ${#MOD_SPEED[@]} -gt 0 ]] && real_speed="${MOD_SPEED[0]}"

    rm -f "$OUTPUT_FILE"

    /usr/libexec/PlistBuddy -c "Add :PlatformInfo dict" "$OUTPUT_FILE"
    /usr/libexec/PlistBuddy -c "Add :PlatformInfo:Memory dict" "$OUTPUT_FILE"

    /usr/libexec/PlistBuddy -c "Add :PlatformInfo:Memory:DataWidth integer $G_DATA_WIDTH" "$OUTPUT_FILE"
    /usr/libexec/PlistBuddy -c "Add :PlatformInfo:Memory:ErrorCorrection integer $G_ERROR_CORRECTION" "$OUTPUT_FILE"
    /usr/libexec/PlistBuddy -c "Add :PlatformInfo:Memory:FormFactor integer $G_FORM_FACTOR" "$OUTPUT_FILE"
    /usr/libexec/PlistBuddy -c "Add :PlatformInfo:Memory:MaxCapacity integer $G_MAX_CAPACITY" "$OUTPUT_FILE"
    /usr/libexec/PlistBuddy -c "Add :PlatformInfo:Memory:TotalWidth integer $G_TOTAL_WIDTH" "$OUTPUT_FILE"
    /usr/libexec/PlistBuddy -c "Add :PlatformInfo:Memory:Type integer $G_TYPE" "$OUTPUT_FILE"
    /usr/libexec/PlistBuddy -c "Add :PlatformInfo:Memory:TypeDetail integer $G_TYPE_DETAIL" "$OUTPUT_FILE"
    /usr/libexec/PlistBuddy -c "Add :PlatformInfo:Memory:Devices array" "$OUTPUT_FILE"

    local real_count=${#MOD_SIZE[@]}

    for ((i=0; i<G_NUM_DEVICES; i++)); do
        /usr/libexec/PlistBuddy -c "Add :PlatformInfo:Memory:Devices:$i dict" "$OUTPUT_FILE"

        local dl bl mf pn sn at sz sp
        if [[ $i -lt $real_count ]]; then
            dl="${MOD_DEVICE_LOCATOR[$i]}"
            bl="${MOD_BANK_LOCATOR[$i]}"
            mf="${MOD_MANUFACTURER[$i]}"
            pn="${MOD_PART_NUMBER[$i]}"
            sn="${MOD_SERIAL_NUMBER[$i]}"
            at="${MOD_ASSET_TAG[$i]}"
            sz="${MOD_SIZE[$i]}"
            sp="${MOD_SPEED[$i]}"
            [[ -z "$dl" ]] && dl="Slot $((i + 1))"
            [[ -z "$mf" ]] && mf="Acidanthera"
        else
            dl="DIMM_EMPTY"
            bl=""
            mf=""
            pn="EmptyDIMM"
            sn="EmptyDIMM"
            at=""
            sz=1
            sp=$real_speed
        fi

        /usr/libexec/PlistBuddy -c "Add :PlatformInfo:Memory:Devices:$i:AssetTag string $at" "$OUTPUT_FILE"
        /usr/libexec/PlistBuddy -c "Add :PlatformInfo:Memory:Devices:$i:BankLocator string $bl" "$OUTPUT_FILE"
        /usr/libexec/PlistBuddy -c "Add :PlatformInfo:Memory:Devices:$i:DeviceLocator string $dl" "$OUTPUT_FILE"
        /usr/libexec/PlistBuddy -c "Add :PlatformInfo:Memory:Devices:$i:Manufacturer string $mf" "$OUTPUT_FILE"
        /usr/libexec/PlistBuddy -c "Add :PlatformInfo:Memory:Devices:$i:PartNumber string $pn" "$OUTPUT_FILE"
        /usr/libexec/PlistBuddy -c "Add :PlatformInfo:Memory:Devices:$i:SerialNumber string $sn" "$OUTPUT_FILE"
        /usr/libexec/PlistBuddy -c "Add :PlatformInfo:Memory:Devices:$i:Size integer $sz" "$OUTPUT_FILE"
        /usr/libexec/PlistBuddy -c "Add :PlatformInfo:Memory:Devices:$i:Speed integer $sp" "$OUTPUT_FILE"
    done

    ok "Configuration saved to '$OUTPUT_FILE'"
    echo ""
    echo "Next steps:"
    echo "  1. Enable PlatformInfo → CustomMemory = true in config.plist"
    echo "  2. Copy the Memory section from custom_memory.plist to your config.plist"
    echo "  3. Reboot"
}

# ─── Main ─────────────────────────────────────────────────────────────────────
main() {
    if [[ $EUID -ne 0 ]]; then
        err "Script must be run as root."
        echo "    Restart with: sudo \"$0\""
        exit 1
    fi

    ensure_dmidecode
    parse_dmidecode
    interactive_menu "${#MOD_SIZE[@]}"
    generate_plist
}

main "$@"