# Speichere diese Datei als:
# /home/mf/Yocto/DCM/layers/meta-dcm/recipes-kernel/linux/linux-stm32mp-dcm_6.6.bb

# Basiert auf dem ST-Kernel-Rezept
require recipes-kernel/linux/linux-stm32mp_6.6.bb

# Ändern Sie den Rezeptnamen, um Konflikte zu vermeiden
PN = "linux-stm32mp-dcm"

# Deaktiviere die separate Kernel-Module-Kompilierung
do_compile_kernelmodules[noexec] = "1"

# Deaktiviere Standard-Kernel-Install-Tasks die Probleme verursachen
do_install_append[noexec] = "1"
do_kernel_link_images[noexec] = "1"

# DCM-spezifische Anpassungen
# Pfad zu den Fragmenten und Patches
FILESEXTRAPATHS:prepend := "${THISDIR}/linux-stm32mp:"
SRC_URI += "file://fragment-01-dcm.config"
SRC_URI += "file://0002-fix-stm32-rifsc-debugfs.patch"

# Verwenden Sie die Standard-STM32-Konfiguration mit Ihrem Fragment
KERNEL_DEFCONFIG = "stm32_defconfig"
KERNEL_CONFIG_FRAGMENTS:append = " ${WORKDIR}/fragment-01-dcm.config"

# Deaktiviere den separaten DTB-Build, der Probleme verursacht
KERNEL_DTB_LINK_NAME = ""

# Komplett deaktiviere die post-compile DTB-Verarbeitung
KERNEL_DEVICETREE = ""
KERNEL_DEVICETREE_BUNDLE = ""
STM32_KERNEL_DEVICETREE = ""

# Definiere beide Image-Typen für U-Boot-Kompatibilität
KERNEL_IMAGETYPE = "uImage"
KERNEL_IMAGETYPES = "zImage uImage"

# U-Boot-spezifische Parameter für uImage-Erstellung
UBOOT_ENTRYPOINT = "0xC2000040"
UBOOT_LOADADDRESS = "0xC2000040"

# Stelle sicher, dass U-Boot-Tools verfügbar sind
DEPENDS += "u-boot-tools-native"

# Überschreibe die problematische normalize_dtb-Funktion
normalize_dtb() {
    bbplain "Überspringe normalize_dtb für DCM - DTB bereits erstellt"
    # Tue nichts - DTB ist bereits von unserem do_compile erstellt
}

# Funktion zum Hinzufügen unserer DTS und aller benötigten DTSIs zum Kernel-Quellverzeichnis
do_prepare_dts() {
    # Bestimme Kernel-Quellverzeichnis
    KERNEL_SRC="${S}"
    
    # Überprüfe die Verzeichnisstruktur
    bbplain "Kernel-Quellverzeichnis: ${KERNEL_SRC}"
    
    # Erstelle das ST-Verzeichnis im Kernel-Quellverzeichnis, falls es nicht existiert
    mkdir -p ${KERNEL_SRC}/arch/arm/boot/dts/st
    
    # Kopiere unsere DTS-Datei in das Kernel-Quellverzeichnis
    if [ -f ${THISDIR}/linux-stm32mp/stm32mp157c-dcm.dts ]; then
        bbplain "Kopiere DTS-Datei ins Kernel-Quellverzeichnis"
        cp -f ${THISDIR}/linux-stm32mp/stm32mp157c-dcm.dts ${KERNEL_SRC}/arch/arm/boot/dts/st/
        
        # Überprüfe, ob die DTS-Datei korrekt kopiert wurde
        if [ -f "${KERNEL_SRC}/arch/arm/boot/dts/st/stm32mp157c-dcm.dts" ]; then
            bbplain "DTS-Datei erfolgreich kopiert"
        else
            bbfatal "Fehler beim Kopieren der DTS-Datei"
        fi
    else
        bbfatal "DTS-Datei nicht gefunden: ${THISDIR}/linux-stm32mp/stm32mp157c-dcm.dts"
    fi
    
    # Aktualisiere die Makefile, um unsere DTB-Datei einzuschließen
    if [ -f ${KERNEL_SRC}/arch/arm/boot/dts/st/Makefile ]; then
        if ! grep -q "stm32mp157c-dcm.dtb" ${KERNEL_SRC}/arch/arm/boot/dts/st/Makefile; then
            bbplain "Füge stm32mp157c-dcm.dtb zur Makefile hinzu"
            sed -i 's/stm32mp157c-dk2.dtb \\/stm32mp157c-dk2.dtb \\\n\tstm32mp157c-dcm.dtb \\/g' ${KERNEL_SRC}/arch/arm/boot/dts/st/Makefile
        else
            bbplain "stm32mp157c-dcm.dtb ist bereits in der Makefile enthalten"
        fi
    else
        bbwarn "Makefile nicht gefunden im ST-Verzeichnis"
    fi
}

# Führe die DTS-Vorbereitung nach dem Patchen aber vor der Konfiguration aus
addtask prepare_dts after do_patch before do_configure

# Explizite Abhängigkeiten definieren, um korrekte Ausführungsreihenfolge zu gewährleisten
do_configure[depends] += "${PN}:do_prepare_dts"
do_compile[depends] += "${PN}:do_configure"
do_compile[depends] += "${PN}:do_prepare_dts"
do_compile[depends] += "${PN}:do_patch"

# Korrigierte Python-Funktion
python () {
    # Hier keine appendVarFlag für deps mehr verwenden - da es bereits eine Liste ist
    bb.debug(2, "Sicherstellen, dass do_compile nach do_patch ausgeführt wird")
}

# Überschreibe die problematische do_compile-Funktion
do_compile() {
    bbplain "Verwende angepasstes do_compile für DCM-Board"
    
    # Verwende Standard-Build-Verzeichnis
    BUILD_DIR="${B}"
    KERNEL_SRC="${S}"
    
    # Ermittle Anzahl der Kerne für parallele Kompilierung
    PARALLEL_JOBS="${@oe.utils.cpu_count()}"
    
    # Baue Kernel (zImage + uImage), DTBs in einem Schritt
    cd ${KERNEL_SRC}
    bbplain "Baue Kernel (zImage + uImage), DTBs parallel mit ${PARALLEL_JOBS} Jobs..."
    
    # Baue zuerst zImage und DTBs
    make O=${BUILD_DIR} ARCH=arm CROSS_COMPILE=${TARGET_PREFIX} -j ${PARALLEL_JOBS} zImage dtbs
    
    # Überprüfe zImage
    if [ -f "${BUILD_DIR}/arch/arm/boot/zImage" ]; then
        bbplain "Kernel zImage erfolgreich erstellt!"
    else
        bbfatal "Fehler beim Erstellen des Kernel zImages!"
    fi
    
    # Erstelle uImage mit expliziten Parametern
    bbplain "Erstelle uImage aus zImage..."
    mkimage -A arm -O linux -T kernel -C none \
            -a ${UBOOT_LOADADDRESS} -e ${UBOOT_ENTRYPOINT} \
            -n "Linux Kernel ${KERNEL_VERSION}" \
            -d ${BUILD_DIR}/arch/arm/boot/zImage \
            ${BUILD_DIR}/arch/arm/boot/uImage
    
    # Überprüfe uImage
    if [ -f "${BUILD_DIR}/arch/arm/boot/uImage" ]; then
        bbplain "Kernel uImage erfolgreich erstellt!"
    else
        bbfatal "Fehler beim Erstellen des Kernel uImages!"
    fi
    
    # Überprüfe DTB
    if [ -f "${BUILD_DIR}/arch/arm/boot/dts/st/stm32mp157c-dcm.dtb" ]; then
        bbplain "DTB erfolgreich erstellt!"
        
        # Erstelle den erwarteten Symlink für den separaten DTB-Build
        mkdir -p ${BUILD_DIR}/dts
        ln -sf ../arch/arm/boot/dts/st/stm32mp157c-dcm.dtb ${BUILD_DIR}/dts/stm32mp157c-dcm.dtb
        bbplain "Link zu DTB erfolgreich erstellt!"
    else
        bbwarn "DTB wurde nicht erstellt. Prüfe, ob deine DTS-Datei korrekt ist."
    fi
    
    # Debug: Zeige erstellte Dateien
    bbplain "Erstellte Dateien im Build-Verzeichnis:"
    ls -la ${BUILD_DIR}/arch/arm/boot/ | grep -E "(zImage|uImage)"
    ls -la ${BUILD_DIR}/arch/arm/boot/dts/st/ | grep "dcm"
}
do_compile:append() {
    # Entferne alle DTB-bezogenen Variablen nach dem Build
    unset KERNEL_DEVICETREE 2>/dev/null || true
    unset STM32_KERNEL_DEVICETREE 2>/dev/null || true
    bbplain "DTB-Variablen nach Build entfernt"
}

# Überschreibe do_install komplett statt nur zu erweitern
do_install() {
    bbplain "Verwende angepasstes do_install für DCM-Board"
    
    # Erstelle notwendige Verzeichnisse
    install -d ${D}/${KERNEL_IMAGEDEST}
    install -d ${D}/boot
    
    # Installiere zImage
    if [ -f "${B}/arch/arm/boot/zImage" ]; then
        bbplain "Installiere zImage"
        install -m 0644 ${B}/arch/arm/boot/zImage ${D}/${KERNEL_IMAGEDEST}/zImage-${KERNEL_VERSION}
        ln -sf zImage-${KERNEL_VERSION} ${D}/${KERNEL_IMAGEDEST}/zImage
    else
        bbfatal "zImage nicht gefunden: ${B}/arch/arm/boot/zImage"
    fi
    
    # Installiere uImage
    if [ -f "${B}/arch/arm/boot/uImage" ]; then
        bbplain "Installiere uImage"
        install -m 0644 ${B}/arch/arm/boot/uImage ${D}/${KERNEL_IMAGEDEST}/uImage-${KERNEL_VERSION}
        ln -sf uImage-${KERNEL_VERSION} ${D}/${KERNEL_IMAGEDEST}/uImage
    else
        bbfatal "uImage nicht gefunden: ${B}/arch/arm/boot/uImage"
    fi
    
    # Installiere DTB
    DTB="${B}/arch/arm/boot/dts/st/stm32mp157c-dcm.dtb"
    if [ -f "$DTB" ]; then
        bbplain "Installiere DTB: $DTB"
        install -m 0644 $DTB ${D}/${KERNEL_IMAGEDEST}/stm32mp157c-dcm-${KERNEL_VERSION}.dtb
        ln -sf stm32mp157c-dcm-${KERNEL_VERSION}.dtb ${D}/${KERNEL_IMAGEDEST}/stm32mp157c-dcm.dtb
    else
        bbwarn "DTB nicht gefunden: $DTB"
    fi
    
    # Installiere System.map falls vorhanden
    if [ -f "${B}/System.map" ]; then
        bbplain "Installiere System.map"
        install -m 0644 ${B}/System.map ${D}/${KERNEL_IMAGEDEST}/System.map-${KERNEL_VERSION}
        ln -sf System.map-${KERNEL_VERSION} ${D}/${KERNEL_IMAGEDEST}/System.map
    fi
    
    # Installiere config falls vorhanden
    if [ -f "${B}/.config" ]; then
        bbplain "Installiere Kernel-Konfiguration"
        install -m 0644 ${B}/.config ${D}/${KERNEL_IMAGEDEST}/config-${KERNEL_VERSION}
        ln -sf config-${KERNEL_VERSION} ${D}/${KERNEL_IMAGEDEST}/config
    fi
}

# Unterdrücke QA-Warnung für buildpaths
INSANE_SKIP:${PN}-src += "buildpaths"

# Unterdrücke QA-Warnung für packages-list (mehrere Image-Typen)
INSANE_SKIP:${PN} += "packages-list"
INSANE_SKIP:kernel-image-zimage += "packages-list"
INSANE_SKIP:kernel-image-uimage += "packages-list"

# Löse das Packaging-Problem mit mehreren Kernel-Image-Typen
KERNEL_PACKAGE_NAME = "kernel"
KERNEL_OUTPUT_DIR = "${KERNEL_IMAGEDEST}"

# Verhindere doppelte Paket-Einträge für verschiedene Image-Typen
python __anonymous() {
    # Stelle sicher, dass Pakete nicht doppelt aufgeführt werden
    packages = d.getVar('PACKAGES') or ""
    if packages:
        # Entferne Duplikate aus der PACKAGES-Liste
        packages_list = packages.split()
        unique_packages = []
        for pkg in packages_list:
            if pkg not in unique_packages:
                unique_packages.append(pkg)
        d.setVar('PACKAGES', ' '.join(unique_packages))
}