#include "QualcommWifi.hpp"
#include <IOKit/IOLib.h>
#include <libkern/OSByteOrder.h>
#include <kern/task.h>
#include <string.h>

#define super IO80211Controller
OSDefineMetaClassAndStructors(QualcommWifi, IO80211Controller)

bool QualcommWifi::init(OSDictionary *dictionary) {
    if (!super::init(dictionary)) {
        return false;
    }
    fPciDevice = nullptr;
    fBar0Map = nullptr;
    fBar0Virt = nullptr;
    fCurrWindow = 0xFFFFFFFF;
    fInterruptSource = nullptr;
    fNetif = nullptr;
    bzero(&fMacAddress, sizeof(fMacAddress));
    fLinkActive = false;
    fCurrentChannel = 1;
    fLastRssi = -50;
    fSsidLen = 0;
    bzero(fSsid, sizeof(fSsid));
    bzero(fBssid, sizeof(fBssid));
    fScanInProgress = false;
    fDmaBuf = nullptr;
    fDmaPhysAddr = 0;
    fDmaVirtAddr = nullptr;
    fDmaPrepared = false;
    return true;
}

void QualcommWifi::free(void) {
    super::free();
}

IOService *QualcommWifi::probe(IOService *provider, SInt32 *score) {
    if (!super::probe(provider, score)) {
        return nullptr;
    }

    IOPCIDevice *pciDev = OSDynamicCast(IOPCIDevice, provider);
    if (!pciDev) {
        return nullptr;
    }

    UInt16 vendorId = pciDev->configRead16(kIOPCIConfigVendorID);
    UInt16 deviceId = pciDev->configRead16(kIOPCIConfigDeviceID);

    if (vendorId == 0x17cb && deviceId == 0x1107) {
        IOLog("QualcommWifi: Controleur Wi-Fi 7 Qualcomm WCN7850 detecte (0x%04x:0x%04x) !\n", vendorId, deviceId);
        *score += 20000;
        return this;
    }

    return nullptr;
}

UInt32 QualcommWifi::read32(UInt32 offset) {
    if (!fBar0Virt || offset >= 0x200000) {
        return 0xFFFFFFFF;
    }
    return OSReadLittleInt32(fBar0Virt, offset);
}

void QualcommWifi::write32(UInt32 offset, UInt32 value) {
    if (!fBar0Virt || offset >= 0x200000) {
        return;
    }
    OSWriteLittleInt32(fBar0Virt, offset, value);
}

void QualcommWifi::selectWindow(UInt32 offset) {
    UInt32 window = (offset >> ATH12K_PCI_WINDOW_SHIFT) & ATH12K_PCI_WINDOW_VALUE_MASK;
    if (window != fCurrWindow) {
        write32(ATH12K_PCI_WINDOW_REG_ADDRESS, ATH12K_PCI_WINDOW_ENABLE_BIT | window);
        (void)read32(ATH12K_PCI_WINDOW_REG_ADDRESS);
        fCurrWindow = window;
    }
}

UInt32 QualcommWifi::socRead32(UInt32 offset) {
    if (offset < ATH12K_PCI_WINDOW_START) {
        return read32(offset);
    }
    selectWindow(offset);
    return read32(ATH12K_PCI_WINDOW_START + (offset & ATH12K_PCI_WINDOW_RANGE_MASK));
}

void QualcommWifi::socWrite32(UInt32 offset, UInt32 value) {
    if (offset < ATH12K_PCI_WINDOW_START) {
        write32(offset, value);
        return;
    }
    selectWindow(offset);
    write32(ATH12K_PCI_WINDOW_START + (offset & ATH12K_PCI_WINDOW_RANGE_MASK), value);
}

// Équivalent de dma_alloc_coherent() avec DMA_BIT_MASK(36) sous Linux
bool QualcommWifi::allocDmaContext(IOByteCount size) {
    fDmaBuf = IOBufferMemoryDescriptor::inTaskWithPhysicalMask(
            kernel_task,
            static_cast<IOOptionBits>(kIODirectionInOut) | static_cast<IOOptionBits>(kIOMemoryPhysicallyContiguous),
            size,
            ATH12K_DMA_MASK_36BIT_PAGE
        );

    if (!fDmaBuf) {
        IOLog("QualcommWifi: Erreur - Impossible d'allouer le descripteur DMA 36-bit.\n");
        return false;
    }

    if (fDmaBuf->prepare(kIODirectionInOut) != kIOReturnSuccess) {
        IOLog("QualcommWifi: Erreur - Impossible de verrouiller (prepare) les pages DMA.\n");
        OSSafeReleaseNULL(fDmaBuf);
        return false;
    }
    fDmaPrepared = true;

    fDmaVirtAddr = fDmaBuf->getBytesNoCopy();
    IOByteCount segLen = 0;
    fDmaPhysAddr = fDmaBuf->getPhysicalSegment(0, &segLen);

    if (!fDmaVirtAddr || !fDmaPhysAddr || segLen < size) {
        IOLog("QualcommWifi: Erreur - Segment physique DMA invalide (segLen=%llu).\n", (uint64_t)segLen);
        freeDmaContext();
        return false;
    }

    // Remise à zéro de la zone DMA (comme kzalloc / dma_alloc_coherent)
    bzero(fDmaVirtAddr, size);

    IOLog("QualcommWifi: Tampon DMA 36-bit pret ! Phys: 0x%llx, Taille: %llu octets (Contigu: %llu)\n",
          (uint64_t)fDmaPhysAddr, (uint64_t)size, (uint64_t)segLen);
    return true;
}

void QualcommWifi::freeDmaContext(void) {
    if (fDmaBuf) {
        if (fDmaPrepared) {
            fDmaBuf->complete(kIODirectionInOut);
            fDmaPrepared = false;
        }
        OSSafeReleaseNULL(fDmaBuf);
    }
    fDmaVirtAddr = nullptr;
    fDmaPhysAddr = 0;
}

void QualcommWifi::interruptOccurred(OSObject *owner, IOInterruptEventSource *src, int count) {
    IOLog("QualcommWifi: Interruption materielle MSI recue (count=%d) !\n", count);
}

bool QualcommWifi::loadBhiFirmware(void) {
    if (!fBar0Virt || !fPciDevice) {
        return false;
    }

    UInt32 bhiOff = read32(ATH12K_MHI_BHIOFF);
    UInt32 bhieOff = read32(ATH12K_MHI_BHIEOFF);
    if (bhiOff == 0xFFFFFFFF || bhiOff >= 0x200000 || bhieOff == 0xFFFFFFFF || bhieOff >= 0x200000) {
        IOLog("QualcommWifi: Erreur - BHI/BHIe Offsets invalides (BHI: 0x%08x, BHIe: 0x%08x)\n", bhiOff, bhieOff);
        setProperty("BHI_Load_Error", "Invalid_Offsets");
        return false;
    }

    // Désactivation d'ASPM PCIe pour stabiliser le transfert firmware (recommandation ath12k)
    UInt8 pciCapOffset = 0;
    if (fPciDevice->findPCICapability(kIOPCIPCIExpressCapability, &pciCapOffset) && pciCapOffset != 0) {
        UInt16 linkCtrl = fPciDevice->configRead16(pciCapOffset + 0x10);
        linkCtrl &= ~0x3; // Désactive ASPM L0s / L1
        fPciDevice->configWrite16(pciCapOffset + 0x10, linkCtrl);
        IOLog("QualcommWifi: ASPM PCIe désactivé pour stabilité du transfert firmware (LinkCtrl: 0x%04x)\n", linkCtrl);
    }

    // Étape 1 : Réinitialisation MHI et effacement des vecteurs BHIe (ath12k_mhi_clear_vector)
    write32(bhieOff + ATH12K_BHIE_TXVECDB, 0);
    write32(bhieOff + ATH12K_BHIE_TXVECSTATUS, 0);
    write32(bhieOff + ATH12K_BHIE_RXVECDB, 0);
    write32(bhieOff + ATH12K_BHIE_RXVECSTATUS, 0);

    write32(ATH12K_MHI_MHICTRL, ATH12K_MHICTRL_RESET_MASK); // MHICTRL_RESET
    IODelay(10000); // 10 ms

    size_t fwSize = get_wcn7850_amss_size();
    size_t sblSize = 0x80000; // 512 Ko pour le Secondary Boot Loader (SBL)
    if (fwSize < sblSize) {
        IOLog("QualcommWifi: Erreur - Taille AMSS trop petite (%lu < 512 Ko)\n", fwSize);
        return false;
    }

    IOLog("QualcommWifi: Initialisation du chargeur FBC 2-étapes (SBL: 512 Ko, Image totale: %lu octets)...\n", fwSize);

    // Étape 2 : Allocation DMA contigu pour l'image AMSS complète
    IOBufferMemoryDescriptor *fwDma = IOBufferMemoryDescriptor::inTaskWithPhysicalMask(
        kernel_task,
        static_cast<IOOptionBits>(kIODirectionInOut) | static_cast<IOOptionBits>(kIOMemoryPhysicallyContiguous),
        fwSize,
        ATH12K_DMA_MASK_36BIT_PAGE
    );

    if (!fwDma || fwDma->prepare(kIODirectionInOut) != kIOReturnSuccess) {
        IOLog("QualcommWifi: Erreur - Echec allocation/prepare DMA AMSS\n");
        setProperty("BHI_Load_Error", "DMA_Alloc_Failed");
        if (fwDma) OSSafeReleaseNULL(fwDma);
        return false;
    }

    void *virt = fwDma->getBytesNoCopy();
    IOByteCount segLen = 0;
    IOPhysicalAddress phys = fwDma->getPhysicalSegment(0, &segLen);

    if (!virt || !phys || segLen < fwSize) {
        IOLog("QualcommWifi: Erreur - Segment DMA AMSS incomplet\n");
        fwDma->complete(kIODirectionInOut);
        OSSafeReleaseNULL(fwDma);
        return false;
    }

    memcpy(virt, wcn7850_amss_bin, fwSize);
    setProperty("AMSS_DMA_Phys", (uint64_t)phys, 64);

    // Étape 3 : Chargement du SBL (512 Ko) via BHI en mode PBL
    write32(bhiOff + ATH12K_BHI_STATUS, 0);
    write32(bhiOff + ATH12K_BHI_IMGADDR_LOW, (UInt32)(phys & 0xFFFFFFFF));
    write32(bhiOff + ATH12K_BHI_IMGADDR_HIGH, (UInt32)((phys >> 32) & 0xFFFFFFFF));
    write32(bhiOff + ATH12K_BHI_IMGSIZE, (UInt32)sblSize);

    // Déclenchement de la sonnette PBL avec Session ID = 1 (NON-NUL exigé par PBL)
    write32(bhiOff + ATH12K_BHI_IMGTXDB, 0x1);
    IOLog("QualcommWifi: Sonnette BHI_IMGTXDB déclenchée (Session ID = 1, SBL 512 Ko)...\n");

    UInt32 bhiStatus = 0;
    UInt32 timeoutMs = 3000;
    bool sblSuccess = false;

    while (timeoutMs > 0) {
        bhiStatus = read32(bhiOff + ATH12K_BHI_STATUS);
        UInt32 state = (bhiStatus & ATH12K_BHI_STATUS_MASK) >> ATH12K_BHI_STATUS_SHIFT;
        if (state == ATH12K_BHI_STATUS_SUCCESS) {
            sblSuccess = true;
            break;
        } else if (state == ATH12K_BHI_STATUS_ERROR) {
            UInt32 err = read32(bhiOff + ATH12K_BHI_ERRCODE);
            IOLog("QualcommWifi: Erreur BHI SBL (code=0x%08x)\n", err);
            setProperty("BHI_ErrorCode", err, 32);
            break;
        }
        IODelay(1000); // 1 ms
        timeoutMs--;
    }

    setProperty("BHI_FinalStatus", bhiStatus, 32);
    setProperty("BHI_Status_Raw", bhiStatus, 32);
    setProperty("BHI_Status_State", (bhiStatus & ATH12K_BHI_STATUS_MASK) >> ATH12K_BHI_STATUS_SHIFT, 32);

    // Attente de l'exécution du SBL (BHI_EXECENV == 1) et de la disponibilité MHI (READY)
    timeoutMs = 2000;
    UInt32 ee = 0;
    while (timeoutMs > 0) {
        ee = read32(bhiOff + ATH12K_BHI_EXECENV);
        UInt32 mhiStat = read32(ATH12K_MHI_MHISTATUS);
        if (ee == ATH12K_MHI_EE_SBL || ee == ATH12K_MHI_EE_AMSS || (mhiStat & ATH12K_MHISTATUS_READY_MASK)) {
            break;
        }
        IODelay(1000);
        timeoutMs--;
    }

    setProperty("BHI_ExecEnv_AfterLoad", ee, 32);
    setProperty("MHI_Status_After_SBL", read32(ATH12K_MHI_MHISTATUS), 32);
    setProperty("MHI_Ctrl_After_SBL", read32(ATH12K_MHI_MHICTRL), 32);
    IOLog("QualcommWifi: SBL BHI terminé (Status=0x%08x, State=%u, ExecEnv=0x%x, SBL_Succes=%d)\n",
          bhiStatus, (bhiStatus & ATH12K_BHI_STATUS_MASK) >> ATH12K_BHI_STATUS_SHIFT, ee, sblSuccess);

    // Étape 4 : Configuration des contextes MHI MMIO et transition vers M0 (mhi_ready_state_transition selon Linux ath12k)
    bool inM0 = false;
    bool amssSuccess = false;
    uint32_t processedEvents = 0;

    if (sblSuccess && fDmaPhysAddr != 0) {
        // Attente de la confirmation READY dans MHISTATUS
        timeoutMs = 3000;
        while (timeoutMs > 0) {
            UInt32 mstat = read32(ATH12K_MHI_MHISTATUS);
            if (mstat & ATH12K_MHISTATUS_READY_MASK) {
                break;
            }
            IODelay(1000);
            timeoutMs--;
        }

        uint64_t chan_ctxt_phys = fDmaPhysAddr + 0x0000;
        uint64_t er_ctxt_phys   = fDmaPhysAddr + 0x1000;
        uint64_t cmd_ctxt_phys  = fDmaPhysAddr + 0x2000;
        uint64_t cmd_ring_phys  = fDmaPhysAddr + 0x3000;
        uint64_t er0_ring_phys  = fDmaPhysAddr + 0x4000;
        uint64_t er1_ring_phys  = fDmaPhysAddr + 0x5000;

        uint32_t cmd_ring_len = 64 * sizeof(struct mhi_ring_element);  // 1024 octets (64 TREs)
        uint32_t er0_ring_len = 32 * sizeof(struct mhi_ring_element);  // 512 octets (32 TREs) selon ath12k WCN7850
        uint32_t er1_ring_len = 256 * sizeof(struct mhi_ring_element); // 4096 octets (256 TREs)

        // 1. Initialisation des 64 contextes de canaux (désactivés au départ)
        struct mhi_chan_ctxt *chan_ctxt = (struct mhi_chan_ctxt *)((uint8_t *)fDmaVirtAddr + 0x0000);
        bzero(chan_ctxt, 64 * sizeof(struct mhi_chan_ctxt));

        // 2. Initialisation du contexte d'anneau de commandes
        struct mhi_cmd_ctxt *cmd_ctxt = (struct mhi_cmd_ctxt *)((uint8_t *)fDmaVirtAddr + 0x2000);
        bzero(cmd_ctxt, sizeof(struct mhi_cmd_ctxt));
        cmd_ctxt[0].rbase = OSSwapHostToLittleInt64(cmd_ring_phys);
        cmd_ctxt[0].rlen  = OSSwapHostToLittleInt64(cmd_ring_len);
        cmd_ctxt[0].rp    = OSSwapHostToLittleInt64(cmd_ring_phys);
        cmd_ctxt[0].wp    = OSSwapHostToLittleInt64(cmd_ring_phys);

        // 3. Initialisation des contextes d'anneau d'événements (2 anneaux selon WCN7850 ath12k)
        struct mhi_event_ctxt *evCtxt = (struct mhi_event_ctxt *)((uint8_t *)fDmaVirtAddr + 0x1000);
        bzero(evCtxt, 2 * sizeof(struct mhi_event_ctxt));

        // Event Ring 0: CTRL ring, 32 TREs
        evCtxt[0].intmod = 0;
        evCtxt[0].ertype = OSSwapHostToLittleInt32(1); // MHI_ER_TYPE_VALID
        evCtxt[0].msivec = 0;
        evCtxt[0].rbase  = OSSwapHostToLittleInt64(er0_ring_phys);
        evCtxt[0].rlen   = OSSwapHostToLittleInt64(er0_ring_len);
        evCtxt[0].rp     = OSSwapHostToLittleInt64(er0_ring_phys);
        evCtxt[0].wp     = OSSwapHostToLittleInt64(er0_ring_phys);

        // Event Ring 1: DATA ring, 256 TREs
        evCtxt[1].intmod = OSSwapHostToLittleInt32(1);
        evCtxt[1].ertype = OSSwapHostToLittleInt32(1); // MHI_ER_TYPE_VALID
        evCtxt[1].msivec = 0;
        evCtxt[1].rbase  = OSSwapHostToLittleInt64(er1_ring_phys);
        evCtxt[1].rlen   = OSSwapHostToLittleInt64(er1_ring_len);
        evCtxt[1].rp     = OSSwapHostToLittleInt64(er1_ring_phys);
        evCtxt[1].wp     = OSSwapHostToLittleInt64(er1_ring_phys);

        bzero((uint8_t *)fDmaVirtAddr + 0x3000, cmd_ring_len);
        bzero((uint8_t *)fDmaVirtAddr + 0x4000, er0_ring_len);
        bzero((uint8_t *)fDmaVirtAddr + 0x5000, er1_ring_len);

        // 4. Programmation des registres MMIO MHI
        write32(ATH12K_MHI_CCABAP_HIGHER, (UInt32)((chan_ctxt_phys >> 32) & 0xFFFFFFFF));
        write32(ATH12K_MHI_CCABAP_LOWER, (UInt32)(chan_ctxt_phys & 0xFFFFFFFF));
        write32(ATH12K_MHI_ECABAP_HIGHER, (UInt32)((er_ctxt_phys >> 32) & 0xFFFFFFFF));
        write32(ATH12K_MHI_ECABAP_LOWER, (UInt32)(er_ctxt_phys & 0xFFFFFFFF));
        write32(ATH12K_MHI_CRCBAP_HIGHER, (UInt32)((cmd_ctxt_phys >> 32) & 0xFFFFFFFF));
        write32(ATH12K_MHI_CRCBAP_LOWER, (UInt32)(cmd_ctxt_phys & 0xFFFFFFFF));

        // MHICFG (0x10): total_ev_rings = 2, hw_ev_rings = 0 (tous logiciels pour WCN7850)
        write32(ATH12K_MHI_MHICFG, (2 << 16) | (0 << 24));

        write32(ATH12K_MHI_MHICTRLBASE_HIGHER, 0);
        write32(ATH12K_MHI_MHICTRLBASE_LOWER, 0);
        write32(ATH12K_MHI_MHIDATABASE_HIGHER, 0);
        write32(ATH12K_MHI_MHIDATABASE_LOWER, 0);

        write32(ATH12K_MHI_MHICTRLLIMIT_HIGHER, 0x0F);
        write32(ATH12K_MHI_MHICTRLLIMIT_LOWER, 0xFFFFFFFF);
        write32(ATH12K_MHI_MHIDATALIMIT_HIGHER, 0x0F);
        write32(ATH12K_MHI_MHIDATALIMIT_LOWER, 0xFFFFFFFF);

        // 5. Armement des Event Ring Doorbells (ERDB)
        // Linux mhi_write_db : écrit d'abord les bits de poids fort (+4), puis les bits de poids faible (+0) !
        uint64_t er0_armed_wp = er0_ring_phys + er0_ring_len - sizeof(struct mhi_ring_element);
        evCtxt[0].wp = OSSwapHostToLittleInt64(er0_armed_wp);

        uint64_t er1_armed_wp = er1_ring_phys + er1_ring_len - sizeof(struct mhi_ring_element);
        evCtxt[1].wp = OSSwapHostToLittleInt64(er1_armed_wp);

        UInt32 erdbOff = read32(ATH12K_MHI_ERDBOFF);
        if (erdbOff != 0 && erdbOff < 0x200000) {
            // Sonnette ER0 (erdbOff + 0)
            write32(erdbOff + 4, (UInt32)((er0_armed_wp >> 32) & 0xFFFFFFFF));
            write32(erdbOff + 0, (UInt32)(er0_armed_wp & 0xFFFFFFFF));

            // Sonnette ER1 (erdbOff + 8)
            write32(erdbOff + 8 + 4, (UInt32)((er1_armed_wp >> 32) & 0xFFFFFFFF));
            write32(erdbOff + 8 + 0, (UInt32)(er1_armed_wp & 0xFFFFFFFF));

            IOLog("QualcommWifi: Event Ring Doorbells armées (ER0 @ 0x%08x WP=0x%llx, ER1 @ 0x%08x WP=0x%llx) !\n",
                  erdbOff, er0_armed_wp, erdbOff + 8, er1_armed_wp);
            setProperty("ERDB_Offset", erdbOff, 32);
        }

        // 6. Bascule vers l'état M0
        UInt32 mhiCtrlVal = read32(ATH12K_MHI_MHICTRL);
        mhiCtrlVal &= ~ATH12K_MHICTRL_MHISTATE_MASK;
        mhiCtrlVal |= (ATH12K_MHI_STATE_M0 << ATH12K_MHICTRL_MHISTATE_SHIFT);
        write32(ATH12K_MHI_MHICTRL, mhiCtrlVal);
        IOLog("QualcommWifi: Transition MHI vers M0 demandée (MHICTRL: 0x%08x)...\n", mhiCtrlVal);
    }

    // Étape 5 : Téléversement FBC complet du firmware via BHIe (mhi_download_amss_image sous SBL actif)
    const size_t segSize = 0x80000;    // Segments de 512 Ko (SZ_512K exigé par ath12k)
    int numVecEntries = (int)((fwSize + segSize - 1) / segSize); // 12 segments pour l'image complète

    IOBufferMemoryDescriptor *vecDma = IOBufferMemoryDescriptor::inTaskWithPhysicalMask(
        kernel_task,
        static_cast<IOOptionBits>(kIODirectionInOut) | static_cast<IOOptionBits>(kIOMemoryPhysicallyContiguous),
        numVecEntries * sizeof(struct bhi_vec_entry),
        ATH12K_DMA_MASK_36BIT_PAGE
    );

    if (vecDma) {
        if (vecDma->prepare(kIODirectionInOut) == kIOReturnSuccess) {
            struct bhi_vec_entry *vecTable = (struct bhi_vec_entry *)vecDma->getBytesNoCopy();
            IOByteCount vecLen = 0;
            IOPhysicalAddress vecPhys = vecDma->getPhysicalSegment(0, &vecLen);

            if (vecTable && vecPhys) {
                size_t curRem = fwSize;

                for (int i = 0; i < numVecEntries; i++) {
                    size_t chunk = (curRem > segSize) ? segSize : curRem;
                    vecTable[i].dma_addr = OSSwapHostToLittleInt64((uint64_t)phys + (uint64_t)i * segSize);
                    vecTable[i].size = OSSwapHostToLittleInt64(chunk);
                    curRem -= chunk;
                }

                IOLog("QualcommWifi: Table vectorielle BHIe FBC prête (%d segments, Phys: 0x%llx). Programmation BHIe...\n",
                      numVecEntries, (uint64_t)vecPhys);

                write32(bhieOff + ATH12K_BHIE_TXVECADDR_LOW, (UInt32)(vecPhys & 0xFFFFFFFF));
                write32(bhieOff + ATH12K_BHIE_TXVECADDR_HIGH, (UInt32)((vecPhys >> 32) & 0xFFFFFFFF));
                write32(bhieOff + ATH12K_BHIE_TXVECSIZE, (UInt32)(numVecEntries * sizeof(struct bhi_vec_entry)));
                write32(bhieOff + ATH12K_BHIE_TXVECSTATUS, 0);

                // Sonnette BHIe avec Sequence ID = 1
                write32(bhieOff + ATH12K_BHIE_TXVECDB, 0x1);

                UInt32 bhieStatus = 0;
                timeoutMs = 10000; // 10 secondes pour le transfert DMA complet de 6 Mo
                while (timeoutMs > 0) {
                    bhieStatus = read32(bhieOff + ATH12K_BHIE_TXVECSTATUS);
                    UInt32 bhieState = (bhieStatus & ATH12K_BHIE_TXVECSTATUS_STATUS_MASK) >> ATH12K_BHIE_TXVECSTATUS_STATUS_SHIFT;
                    if (bhieState == ATH12K_BHIE_TXVECSTATUS_XFER_COMPL) {
                        amssSuccess = true;
                        break;
                    }
                    IODelay(1000);
                    timeoutMs--;
                }

                setProperty("BHIE_FinalStatus", bhieStatus, 32);
                setProperty("BHIE_Status_Raw", bhieStatus, 32);
                setProperty("BHIE_Status_State", (bhieStatus & ATH12K_BHIE_TXVECSTATUS_STATUS_MASK) >> ATH12K_BHIE_TXVECSTATUS_STATUS_SHIFT, 32);
                IOLog("QualcommWifi: BHIe DMA terminé (Status=0x%08x) ! Dépouillement des événements MHI...\n", bhieStatus);

                // Étape 6 : Dépouillement des événements MHI émis par SBL / AMSS sur l'anneau 0
                struct mhi_ring_element *erElements = (struct mhi_ring_element *)((uint8_t *)fDmaVirtAddr + 0x4000);

                timeoutMs = 5000;
                while (timeoutMs > 0) {
                    UInt32 mstat = read32(ATH12K_MHI_MHISTATUS);
                    UInt32 mstate = (mstat & ATH12K_MHISTATUS_MHISTATE_MASK) >> ATH12K_MHISTATUS_MHISTATE_SHIFT;

                    while (processedEvents < 32) {
                        struct mhi_ring_element *el = &erElements[processedEvents];
                        UInt32 dw1 = OSSwapLittleToHostInt32(el->dword[1]);
                        UInt32 dw0 = OSSwapLittleToHostInt32(el->dword[0]);
                        if (dw1 == 0 && dw0 == 0) {
                            break;
                        }

                        UInt8 evType = (dw1 >> 16) & 0xFF;
                        UInt8 evCode = (dw0 >> 24) & 0xFF;
                        IOLog("QualcommWifi: Événement MHI reçu #%u: Type=0x%02x, Code=0x%02x, PTR=0x%llx\n",
                              processedEvents, evType, evCode, OSSwapLittleToHostInt64(el->ptr));

                        char evKey[32];
                        snprintf(evKey, sizeof(evKey), "MHI_Event_%u_Type", processedEvents);
                        setProperty(evKey, evType, 8);
                        snprintf(evKey, sizeof(evKey), "MHI_Event_%u_Code", processedEvents);
                        setProperty(evKey, evCode, 8);
                        snprintf(evKey, sizeof(evKey), "MHI_Event_%u_PTR", processedEvents);
                        setProperty(evKey, OSSwapLittleToHostInt64(el->ptr), 64);

                        if (evType == ATH12K_MHI_PKT_TYPE_STATE_CHANGE_EVENT) {
                            IOLog("QualcommWifi: -> Notification changement d'état MHI: State=%u\n", evCode);
                            if (evCode == ATH12K_MHI_STATE_M0) {
                                inM0 = true;
                            }
                        } else if (evType == ATH12K_MHI_PKT_TYPE_EE_EVENT) {
                            IOLog("QualcommWifi: -> Notification environnement d'exécution (EE): 0x%x\n", evCode);
                            ee = evCode;
                            if (ee == ATH12K_MHI_EE_AMSS || ee == ATH12K_MHI_EE_WFW) {
                                amssSuccess = true;
                            }
                        }
                        processedEvents++;
                    }

                    if (mstate == ATH12K_MHI_STATE_M0 || inM0 || ee == ATH12K_MHI_EE_AMSS || ee == ATH12K_MHI_EE_WFW) {
                        inM0 = true;
                        IOLog("QualcommWifi: MHI en mode Mission M0 (MHISTATUS: 0x%08x, EE: 0x%x) !\n", mstat, ee);
                        break;
                    }

                    IODelay(1000);
                    timeoutMs--;
                }

                setProperty("MHI_Events_Processed", processedEvents, 32);
                setProperty("MHI_Status_In_M0", read32(ATH12K_MHI_MHISTATUS), 32);
                setProperty("MHI_In_M0", inM0);
                setProperty("BHI_ExecEnv_Final", ee, 32);
            }

            vecDma->complete(kIODirectionInOut);
        }
        OSSafeReleaseNULL(vecDma);
    }

    if (inM0 || ee == ATH12K_MHI_EE_AMSS || ee == ATH12K_MHI_EE_WFW) {
        IOLog("QualcommWifi: SUCCÈS MAJEUR ! Firmware WCN7850 actif en mode Mission (ExecEnv=0x%x, M0=%d) !\n", ee, inM0);
        setProperty("Driver_Status", "AMSS_Loaded_Success");
    } else if (sblSuccess) {
        IOLog("QualcommWifi: SBL actif (ExecEnv=0x%x, BHIe=0x%x)\n", ee, read32(bhieOff + ATH12K_BHIE_TXVECSTATUS));
        setProperty("Driver_Status", "SBL_Loaded_Success");
    } else {
        IOLog("QualcommWifi: Échec chargement complet (BHI=0x%x, ExecEnv=0x%x)\n", bhiStatus, ee);
        setProperty("Driver_Status", "AMSS_Load_Timeout_Or_Error");
    }

    fwDma->complete(kIODirectionInOut);
    OSSafeReleaseNULL(fwDma);

    return (sblSuccess || amssSuccess);
}

bool QualcommWifi::start(IOService *provider) {
    if (!super::start(provider)) {
        return false;
    }

    fPciDevice = OSDynamicCast(IOPCIDevice, provider);
    if (!fPciDevice) {
        return false;
    }
    fPciDevice->retain();

    if (!fPciDevice->open(this)) {
        OSSafeReleaseNULL(fPciDevice);
        return false;
    }

    UInt16 pciCommand = fPciDevice->configRead16(kIOPCIConfigCommand);
    pciCommand |= (kIOPCICommandMemorySpace | kIOPCICommandBusMaster);
    fPciDevice->configWrite16(kIOPCIConfigCommand, pciCommand);

    fBar0Map = fPciDevice->mapDeviceMemoryWithRegister(kIOPCIConfigBaseAddress0);
    if (!fBar0Map) {
        fPciDevice->close(this);
        OSSafeReleaseNULL(fPciDevice);
        return false;
    }
    fBar0Virt = (volatile void *)fBar0Map->getVirtualAddress();

    UInt32 socHwVer = socRead32(TCSR_SOC_HW_VERSION);
    UInt32 major = (socHwVer & TCSR_SOC_HW_VERSION_MAJOR_MASK) >> TCSR_SOC_HW_VERSION_MAJOR_SHIFT;
    UInt32 minor = (socHwVer & TCSR_SOC_HW_VERSION_MINOR_MASK);
    IOLog("QualcommWifi: WCN7850 HW v%u.%u detecte (0x%08x)\n", major, minor, socHwVer);

    setProperty("SoC_Version", socHwVer, 32);
    setProperty("SoC_Major", major, 32);
    setProperty("SoC_Minor", minor, 32);

    // Lecture des registres de contrôle MHI et pointeurs BHI
    UInt32 mhiStatus = read32(ATH12K_MHI_MHISTATUS);
    UInt32 mhiCtrl = read32(ATH12K_MHI_MHICTRL);
    UInt32 bhiOff = read32(ATH12K_MHI_BHIOFF);
    UInt32 bhieOff = read32(ATH12K_MHI_BHIEOFF);
    IOLog("QualcommWifi: MHI STATUS=0x%08x, CTRL=0x%08x, BHIOFF=0x%08x, BHIEOFF=0x%08x\n",
          mhiStatus, mhiCtrl, bhiOff, bhieOff);

    setProperty("MHI_Status", mhiStatus, 32);
    setProperty("MHI_Ctrl", mhiCtrl, 32);
    setProperty("BHI_Offset", bhiOff, 32);
    setProperty("BHIE_Offset", bhieOff, 32);

    if (bhiOff != 0xFFFFFFFF && bhiOff < 0x200000) {
        UInt32 bhiMajor = read32(bhiOff + ATH12K_BHI_BHIVERSION_MAJOR);
        UInt32 bhiMinor = read32(bhiOff + ATH12K_BHI_BHIVERSION_MINOR);
        UInt32 bhiEe = read32(bhiOff + ATH12K_BHI_EXECENV);
        UInt32 bhiStat = read32(bhiOff + ATH12K_BHI_STATUS);
        UInt32 bhiSerial = read32(bhiOff + ATH12K_BHI_SERIALNU);
        IOLog("QualcommWifi: BHI v%u.%u: ExecEnv=0x%x, Status=0x%x, Serial=0x%08x\n",
              bhiMajor, bhiMinor, bhiEe, bhiStat, bhiSerial);

        setProperty("BHI_Major", bhiMajor, 32);
        setProperty("BHI_Minor", bhiMinor, 32);
        setProperty("BHI_ExecEnv", bhiEe, 32);
        setProperty("BHI_Status", bhiStat, 32);
        setProperty("BHI_Serial", bhiSerial, 32);
    }

    // Allocation du tampon DMA 36-bit pour les anneaux MHI / BHI
    if (!allocDmaContext(ATH12K_DMA_TEST_RING_SIZE)) {
        OSSafeReleaseNULL(fBar0Map);
        fPciDevice->close(this);
        OSSafeReleaseNULL(fPciDevice);
        return false;
    }

    setProperty("DMA_PhysAddr", (uint64_t)fDmaPhysAddr, 64);
    setProperty("Driver_Status", "Hardware_Initialized");

    int msiIndex = -1;
    for (int i = 0; ; i++) {
        int intrType = 0;
        if (fPciDevice->getInterruptType(i, &intrType) != kIOReturnSuccess) {
            break;
        }
        if (intrType & kIOInterruptTypePCIMessaged) {
            msiIndex = i;
            break;
        }
    }

    IOWorkLoop *workLoop = getWorkLoop();
    if (msiIndex >= 0 && workLoop) {
        fInterruptSource = IOInterruptEventSource::interruptEventSource(
            this, &QualcommWifi::interruptOccurred, fPciDevice, msiIndex);
        if (fInterruptSource && workLoop->addEventSource(fInterruptSource) == kIOReturnSuccess) {
            fInterruptSource->enable();
            IOLog("QualcommWifi: MSI index %d actif.\n", msiIndex);
        }
    }

    // Chargement du firmware radio AMSS via le protocole BHI
    (void)loadBhiFirmware();

    // Configuration de l'adresse MAC (OUI Qualcomm 00:03:7F + BHI serial)
    UInt32 bhiSerial = read32(bhiOff + ATH12K_BHI_SERIALNU);
    fMacAddress.bytes[0] = 0x00;
    fMacAddress.bytes[1] = 0x03;
    fMacAddress.bytes[2] = 0x7F;
    fMacAddress.bytes[3] = (bhiSerial >> 16) & 0xFF;
    fMacAddress.bytes[4] = (bhiSerial >> 8) & 0xFF;
    fMacAddress.bytes[5] = (bhiSerial) & 0xFF;

    IOLog("QualcommWifi: Adresse MAC physique : %02x:%02x:%02x:%02x:%02x:%02x\n",
          fMacAddress.bytes[0], fMacAddress.bytes[1], fMacAddress.bytes[2],
          fMacAddress.bytes[3], fMacAddress.bytes[4], fMacAddress.bytes[5]);

    // Configuration des propriétés Wi-Fi AirPort pour macOS et airportd
    setProperty("IO80211AirPort", true);
    setProperty("AirPort", true);
    setProperty("IO80211Locale", "ETSI");
    setProperty("IO80211CountryCode", "FR");
    setProperty("IO80211ScanCache", true);
    setProperty("IO80211RadioState", (UInt64)1, 32);

    // Configuration et publication des médias supportés (Auto / 1Gbps)
    OSDictionary *mediumDict = OSDictionary::withCapacity(1);
    if (mediumDict) {
        IONetworkMedium *medium = IONetworkMedium::medium(kIOMediumEthernetAuto, 1000000000ULL);
        if (medium) {
            IONetworkMedium::addMedium(mediumDict, medium);
            publishMediumDictionary(mediumDict);
            setSelectedMedium(medium);
            medium->release();
        }
        mediumDict->release();
    }

    // Attachement de l'interface Wi-Fi native (IO80211Interface)
    if (attachInterface((IONetworkInterface **)&fNetif, true)) {
        IOLog("QualcommWifi: Interface Wi-Fi native (IO80211Interface) attachee avec succes !\n");
        setProperty("Network_Interface_Attached", true);
    } else {
        IOLog("QualcommWifi: Echec de attachInterface IO80211.\n");
        setProperty("Network_Interface_Attached", false);
    }

    registerService();
    return true;
}

void QualcommWifi::stop(IOService *provider) {
    IOLog("QualcommWifi: Arret du pilote, liberation interface reseau, MSI, DMA et BAR0.\n");

    if (fNetif) {
        detachInterface(fNetif);
        OSSafeReleaseNULL(fNetif);
    }

    IOWorkLoop *workLoop = getWorkLoop();
    if (fInterruptSource) {
        fInterruptSource->disable();
        if (workLoop) {
            workLoop->removeEventSource(fInterruptSource);
        }
        OSSafeReleaseNULL(fInterruptSource);
    }

    // Déverrouillage et libération du tampon DMA avant la fermeture PCIe
    freeDmaContext();

    fBar0Virt = nullptr;
    if (fBar0Map) {
        OSSafeReleaseNULL(fBar0Map);
    }

    if (fPciDevice) {
        fPciDevice->close(this);
        OSSafeReleaseNULL(fPciDevice);
    }

    super::stop(provider);
}

IOReturn QualcommWifi::getHardwareAddress(IOEthernetAddress *addrP) {
    if (!addrP) return kIOReturnBadArgument;
    bcopy(&fMacAddress, addrP, sizeof(IOEthernetAddress));
    return kIOReturnSuccess;
}

IOReturn QualcommWifi::enable(IONetworkInterface *netif) {
    IOLog("QualcommWifi: Interface reseau activee par macOS.\n");
    const IONetworkMedium *medium = getSelectedMedium();
    setLinkStatus(kIONetworkLinkValid | kIONetworkLinkActive, medium);
    return kIOReturnSuccess;
}

IOReturn QualcommWifi::disable(IONetworkInterface *netif) {
    IOLog("QualcommWifi: Interface reseau desactivee par macOS.\n");
    setLinkStatus(kIONetworkLinkValid, nullptr);
    return kIOReturnSuccess;
}

UInt32 QualcommWifi::outputPacket(mbuf_t m, void *param) {
    if (m) {
        freePacket(m);
    }
    return kIOReturnOutputDropped;
}

SInt32 QualcommWifi::handleApple80211Request(unsigned int req_type, int req_val, void* req_data) {
    switch (req_type) {
        case APPLE80211_IOC_CARD_CAPABILITIES: {
            apple80211_capability_data *cap = (apple80211_capability_data *)req_data;
            if (cap) {
                bzero(cap, sizeof(*cap));
                cap->version = APPLE80211_VERSION;
                #define SET_CAP(c) (cap->capabilities[(c) / 8] |= (1 << ((c) % 8)))
                SET_CAP(APPLE80211_CAP_WEP);
                SET_CAP(APPLE80211_CAP_TKIP);
                SET_CAP(APPLE80211_CAP_AES_CCM);
                SET_CAP(APPLE80211_CAP_WPA1);
                SET_CAP(APPLE80211_CAP_WPA2);
                SET_CAP(APPLE80211_CAP_WPA);
                SET_CAP(APPLE80211_CAP_SHORT_GI_20MHZ);
                SET_CAP(APPLE80211_CAP_SHORT_GI_40MHZ);
                SET_CAP(APPLE80211_CAP_BURST);
                SET_CAP(APPLE80211_CAP_WME);
                SET_CAP(APPLE80211_CAP_PMGT);
                SET_CAP(APPLE80211_CAP_SHPREAMBLE);
                SET_CAP(APPLE80211_CAP_SHSLOT);
                #undef SET_CAP
                return 0;
            }
            break;
        }
        case APPLE80211_IOC_STATE: {
            apple80211_state_data *state = (apple80211_state_data *)req_data;
            if (state) {
                state->version = APPLE80211_VERSION;
                state->state = fLinkActive ? APPLE80211_S_RUN : APPLE80211_S_INIT;
                return 0;
            }
            break;
        }
        case APPLE80211_IOC_PHY_MODE: {
            apple80211_phymode_data *pm = (apple80211_phymode_data *)req_data;
            if (pm) {
                pm->version = APPLE80211_VERSION;
                pm->phy_mode = APPLE80211_MODE_11AX;
                pm->active_phy_mode = APPLE80211_MODE_11AX;
                return 0;
            }
            break;
        }
        case APPLE80211_IOC_OP_MODE: {
            apple80211_opmode_data *om = (apple80211_opmode_data *)req_data;
            if (om) {
                om->version = APPLE80211_VERSION;
                om->op_mode = APPLE80211_M_STA;
                return 0;
            }
            break;
        }
        case APPLE80211_IOC_CHANNEL: {
            apple80211_channel_data *cd = (apple80211_channel_data *)req_data;
            if (cd) {
                if (req_val == 1 && cd->channel.channel > 0) {
                    fCurrentChannel = cd->channel.channel;
                    IOLog("QualcommWifi: Changement de canal Wi-Fi vers %u\n", fCurrentChannel);
                }
                cd->version = APPLE80211_VERSION;
                cd->channel.version = APPLE80211_VERSION;
                cd->channel.channel = fCurrentChannel > 0 ? fCurrentChannel : 1;
                cd->channel.flags = (cd->channel.channel <= 14) ? (APPLE80211_C_FLAG_2GHZ | APPLE80211_C_FLAG_20MHZ) : (APPLE80211_C_FLAG_5GHZ | APPLE80211_C_FLAG_80MHZ);
                return 0;
            }
            break;
        }
        case APPLE80211_IOC_TXPOWER: {
            apple80211_txpower_data *tx = (apple80211_txpower_data *)req_data;
            if (tx) {
                tx->version = APPLE80211_VERSION;
                tx->txpower_unit = APPLE80211_UNIT_DBM;
                tx->txpower = 20; // 20 dBm (100 mW)
                return 0;
            }
            break;
        }
        case APPLE80211_IOC_PROTMODE:
        case APPLE80211_IOC_POWERSAVE:
        case APPLE80211_IOC_SCANCACHE_CLEAR: {
            return 0;
        }
        case APPLE80211_IOC_RSSI: {
            apple80211_rssi_data *rd = (apple80211_rssi_data *)req_data;
            if (rd) {
                rd->version = APPLE80211_VERSION;
                rd->num_radios = 1;
                rd->rssi_unit = APPLE80211_UNIT_DBM;
                rd->rssi[0] = fLastRssi ? fLastRssi : -50;
                rd->aggregate_rssi = rd->rssi[0];
                return 0;
            }
            break;
        }
        case APPLE80211_IOC_NOISE: {
            apple80211_noise_data *nd = (apple80211_noise_data *)req_data;
            if (nd) {
                nd->version = APPLE80211_VERSION;
                nd->num_radios = 1;
                nd->noise_unit = APPLE80211_UNIT_DBM;
                nd->noise[0] = -95;
                nd->aggregate_noise = -95;
                return 0;
            }
            break;
        }
        case APPLE80211_IOC_SSID: {
            apple80211_ssid_data *sd = (apple80211_ssid_data *)req_data;
            if (sd) {
                sd->version = APPLE80211_VERSION;
                sd->ssid_len = fSsidLen;
                memcpy(sd->ssid_bytes, fSsid, fSsidLen);
                return 0;
            }
            break;
        }
        case APPLE80211_IOC_BSSID: {
            apple80211_bssid_data *bd = (apple80211_bssid_data *)req_data;
            if (bd) {
                bd->version = APPLE80211_VERSION;
                memcpy(bd->bssid.octet, fBssid, 6);
                return 0;
            }
            break;
        }
        case APPLE80211_IOC_RATE: {
            apple80211_rate_data *rate = (apple80211_rate_data *)req_data;
            if (rate) {
                rate->version = APPLE80211_VERSION;
                rate->num_radios = 1;
                rate->rate[0] = 1200;
                return 0;
            }
            break;
        }
        case APPLE80211_IOC_SUPPORTED_CHANNELS: {
            apple80211_sup_channel_data *sc = (apple80211_sup_channel_data *)req_data;
            if (sc) {
                sc->version = APPLE80211_VERSION;
                static const UInt16 chs[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13,
                                              36, 40, 44, 48, 52, 56, 60, 64, 100, 104, 108, 112, 116, 120, 124, 128, 132, 136, 140, 144, 149, 153, 157, 161, 165 };
                sc->num_channels = sizeof(chs)/sizeof(chs[0]);
                for (int i = 0; i < sc->num_channels; i++) {
                    sc->supported_channels[i].version = APPLE80211_VERSION;
                    sc->supported_channels[i].channel = chs[i];
                    sc->supported_channels[i].flags = (chs[i] <= 14) ? (APPLE80211_C_FLAG_2GHZ | APPLE80211_C_FLAG_20MHZ) : (APPLE80211_C_FLAG_5GHZ | APPLE80211_C_FLAG_80MHZ);
                }
                return 0;
            }
            break;
        }
        case APPLE80211_IOC_SCAN_REQ: {
            IOLog("QualcommWifi: Requete de scan Wi-Fi recue depuis airportd !\n");
            fScanInProgress = true;
            return 0;
        }
        case APPLE80211_IOC_SCAN_RESULT: {
            return 0;
        }
        case APPLE80211_IOC_POWER: {
            apple80211_power_data *pwr = (apple80211_power_data *)req_data;
            if (pwr) {
                pwr->version = APPLE80211_VERSION;
                pwr->num_radios = 1;
                if (req_val == 0 || req_val == 1) {
                    fLinkActive = (req_val == 1);
                    IOLog("QualcommWifi: Bascule alimentation radio Wi-Fi demandee : %s\n", fLinkActive ? "ACTIVE" : "COUPEE");
                }
                pwr->power_state[0] = fLinkActive ? 1 : 0;
                return 0;
            }
            break;
        }
        case APPLE80211_IOC_SCAN_REQ_MULTIPLE: {
            IOLog("QualcommWifi: Requete de scan multi-SSID (SCAN_REQ_MULTIPLE) recue depuis airportd !\n");
            fScanInProgress = true;
            return 0;
        }
        case APPLE80211_IOC_COUNTRY_CODE: {
            apple80211_country_code_data *cc = (apple80211_country_code_data *)req_data;
            if (cc) {
                cc->version = APPLE80211_VERSION;
                cc->cc[0] = 'F';
                cc->cc[1] = 'R';
                cc->cc[2] = 0;
                return 0;
            }
            break;
        }
        case APPLE80211_IOC_LOCALE: {
            apple80211_locale_data *loc = (apple80211_locale_data *)req_data;
            if (loc) {
                loc->version = APPLE80211_VERSION;
                loc->locale = APPLE80211_LOCALE_ETSI;
                return 0;
            }
            break;
        }
        case APPLE80211_IOC_DRIVER_VERSION:
        case APPLE80211_IOC_HARDWARE_VERSION: {
            apple80211_version_data *vd = (apple80211_version_data *)req_data;
            if (vd) {
                vd->version = APPLE80211_VERSION;
                const char *verStr = "Qualcomm FastConnect 7800 Wi-Fi 7 (v1.1.0)";
                vd->string_len = (u_int16_t)strlen(verStr);
                strlcpy(vd->string, verStr, sizeof(vd->string));
                return 0;
            }
            break;
        }
        case APPLE80211_IOC_ASSOCIATE: {
            apple80211_assoc_data *assoc = (apple80211_assoc_data *)req_data;
            if (assoc) {
                IOLog("QualcommWifi: Demande d'association au reseau Wi-Fi : %.*s\n", assoc->ad_ssid_len, assoc->ad_ssid);
                fSsidLen = (assoc->ad_ssid_len < APPLE80211_MAX_SSID_LEN) ? assoc->ad_ssid_len : APPLE80211_MAX_SSID_LEN;
                memcpy(fSsid, assoc->ad_ssid, fSsidLen);
                memcpy(fBssid, assoc->ad_bssid.octet, 6);
                fLinkActive = true;
                return 0;
            }
            break;
        }
        case APPLE80211_IOC_DISASSOCIATE: {
            IOLog("QualcommWifi: Deconnexion Wi-Fi demandee par macOS.\n");
            fLinkActive = false;
            fSsidLen = 0;
            return 0;
        }
        default:
            break;
    }
    return 0;
}

#if __IO80211_TARGET >= 260000
bool QualcommWifi::isCommandProhibited(int command) {
    return false;
}

IOReturn QualcommWifi::handleCardSpecific(IO80211SkywalkInterface *iface, unsigned long req_type, void *req_data, bool isSet) {
    return (IOReturn)handleApple80211Request((unsigned int)req_type, isSet ? 1 : 0, req_data);
}

UInt32 QualcommWifi::hardwareOutputQueueDepth(void) {
    return 0;
}

SInt32 QualcommWifi::performCountryCodeOperation(IO80211CountryCodeOp op) {
    IOLog("QualcommWifi: performCountryCodeOperation op=%d.\n", op);
    return 0;
}

void QualcommWifi::dataLinkLayerAttachComplete(void) {
    IOLog("QualcommWifi: dataLinkLayerAttachComplete (Skywalk Tahoe).\n");
}

SInt32 QualcommWifi::enableFeature(IO80211FeatureCode code, void *arg) {
    IOLog("QualcommWifi: enableFeature code=%d.\n", code);
    return 0;
}

IOReturn QualcommWifi::getDRIVER_VERSION(IO80211SkywalkInterface *iface, apple80211_version_data *vd) {
    return (IOReturn)handleApple80211Request(APPLE80211_IOC_DRIVER_VERSION, 0, vd);
}

IOReturn QualcommWifi::getHARDWARE_VERSION(IO80211SkywalkInterface *iface, apple80211_version_data *vd) {
    return (IOReturn)handleApple80211Request(APPLE80211_IOC_HARDWARE_VERSION, 0, vd);
}

IOReturn QualcommWifi::getCARD_CAPABILITIES(IO80211SkywalkInterface *iface, apple80211_capability_data *cap) {
    return (IOReturn)handleApple80211Request(APPLE80211_IOC_CARD_CAPABILITIES, 0, cap);
}

IOReturn QualcommWifi::getPOWER(IO80211SkywalkInterface *iface, apple80211_power_data *pwr) {
    return (IOReturn)handleApple80211Request(APPLE80211_IOC_POWER, -1, pwr);
}

IOReturn QualcommWifi::setPOWER(IO80211SkywalkInterface *iface, apple80211_power_data *pwr) {
    int val = (pwr && pwr->power_state[0]) ? 1 : 0;
    return (IOReturn)handleApple80211Request(APPLE80211_IOC_POWER, val, pwr);
}

IOReturn QualcommWifi::getCOUNTRY_CODE(IO80211SkywalkInterface *iface, apple80211_country_code_data *cc) {
    return (IOReturn)handleApple80211Request(APPLE80211_IOC_COUNTRY_CODE, 0, cc);
}

IOReturn QualcommWifi::setCOUNTRY_CODE(IO80211SkywalkInterface *iface, apple80211_country_code_data *cc) {
    return kIOReturnSuccess;
}

IOReturn QualcommWifi::setGET_DEBUG_INFO(IO80211SkywalkInterface *iface, apple80211_debug_command *dbg) {
    return kIOReturnSuccess;
}

void* QualcommWifi::getLogger(void) const {
    return nullptr;
}

void* QualcommWifi::getFaultReporterFromDriver(void) {
    return nullptr;
}
#else
SInt32 QualcommWifi::apple80211Request(unsigned int req_type, int req_val, IO80211Interface* iface, void* req_data) {
    return handleApple80211Request(req_type, req_val, req_data);
}

SInt32 QualcommWifi::apple80211SkywalkRequest(UInt req_type, int req_val, IO80211SkywalkInterface *iface, void *req_data) {
    return handleApple80211Request(req_type, req_val, req_data);
}

SInt32 QualcommWifi::stopDMA() {
    IOLog("QualcommWifi: stopDMA appele.\n");
    return 0;
}

UInt32 QualcommWifi::hardwareOutputQueueDepth(IO80211Interface *iface) {
    return 0;
}

SInt32 QualcommWifi::performCountryCodeOperation(IO80211Interface *iface, IO80211CountryCodeOp op) {
    IOLog("QualcommWifi: performCountryCodeOperation op=%d.\n", op);
    return 0;
}

SInt32 QualcommWifi::enableFeature(IO80211FeatureCode code, void *arg) {
    IOLog("QualcommWifi: enableFeature code=%d.\n", code);
    return 0;
}

IOReturn QualcommWifi::enable(IO80211SkywalkInterface *netif) {
    IOLog("QualcommWifi: Skywalk Interface activee par macOS.\n");
    fLinkActive = true;
    return kIOReturnSuccess;
}

IOReturn QualcommWifi::disable(IO80211SkywalkInterface *netif) {
    IOLog("QualcommWifi: Skywalk Interface desactivee par macOS.\n");
    fLinkActive = false;
    return kIOReturnSuccess;
}
#endif