A_STATUS CF_UnMaskInterrupt(CF_DEVICE_HANDLE cfHandle) { CF_DEVICE *cfDevice; #ifndef POLL NDIS_STATUS ndisStatus; #endif HIF_DEBUG_PRINTF(ATH_LOG_TRC, "CF_UnMaskInterrupt \n"); cfDevice = (CF_DEVICE *)cfHandle; #ifdef POLL startPollThread(cfDevice); #else #ifdef SHARED_INTERRUPTS isrHandler = LoadIntChainHandler(TEXT("giisr.dll"),TEXT("ISRHandler"),(BYTE)cfDevice->interruptNumber); if (!isrHandler) { HIF_DEBUG_PRINTF(ATH_LOG_ERR,"CF_UnMaskInterrupt: Load int chain handler failed \n"); return A_ERROR; } memset (&Info,0,sizeof(Info)); Info.SysIntr = cfDevice->sysIntr; Info.CheckPort = TRUE; Info.PortIsIO = FALSE; Info.UseMaskReg = TRUE; Info.PortSize = sizeof(BYTE); Info.PortAddr = (DWORD)giisrMappedAddress + 0x00000400; Info.MaskAddr = (DWORD)giisrMappedAddress + 0x00000418; if (!KernelLibIoControl(isrHandler,IOCTL_GIISR_INFO,&Info,sizeof(Info),NULL,0,NULL)) { HIF_DEBUG_PRINTF(ATH_LOG_ERR,"CF_UnMaskInterrupt: KernelLibIoControl failed \n"); return A_ERROR; } #endif // SHARED_INTERRUPTS ndisStatus = NdisMRegisterInterrupt(&cfDevice->interruptObject, cfDevice->miniportHandle, cfDevice->interruptNumber, 0, TRUE, TRUE, 0); if (ndisStatus != NDIS_STATUS_SUCCESS) { return A_ERROR; } #endif cfDevice->interruptRegistered= TRUE; return A_OK; }
NDIS_STATUS shared_interrupt_register(OUT PNDIS_MINIPORT_INTERRUPT Interrupt, NDIS_HANDLE MiniportAdapterHandle, UINT InterruptVector, UINT InterruptLevel, BOOLEAN RequestIsr, BOOLEAN SharedInterrupt, NDIS_INTERRUPT_MODE InterruptMode, shared_info_t *sh, void (*isr_cb)(PBOOLEAN, PBOOLEAN, NDIS_HANDLE), void *isr_arg, void (*dpc_cb)(NDIS_HANDLE), void *dpc_arg) { if (sh->BusType == NdisInterfacePci || sh->BusType == NdisInterfacePcMcia) { return NdisMRegisterInterrupt(Interrupt, MiniportAdapterHandle, InterruptVector, InterruptLevel, RequestIsr, SharedInterrupt, InterruptMode); } else if (sh->BusType == NdisInterfaceSDIO) { sh->isr_cb = isr_cb; sh->isr_arg = isr_arg; NdisInitializeEvent(&sh->dpc_event); NdisResetEvent(&sh->dpc_event); sh->dpc_handle = CreateThread(NULL, /* security atributes */ 0, /* initial stack size */ (LPTHREAD_START_ROUTINE)shared_dpc_thread, /* Main() function */ sh, /* arg to reader thread */ 0, /* creation flags */ &sh->dpc_thread_id); /* returned thread id */ if (!sh->dpc_handle) return NDIS_STATUS_FAILURE; if (bcmsdh_intr_reg(sh->sdh, shared_isr, sh)) return NDIS_STATUS_FAILURE; } sh->dpc_cb = dpc_cb; sh->dpc_arg = dpc_arg; /* Initilize the timer required to reschdule the DPC, if necessary */ NdisInitializeTimer(&sh->dpc_reshed_timer, shared_dpc_reschedule, (PVOID)sh); return NDIS_STATUS_SUCCESS; }
NDIS_STATUS NTAPI MiniportInitialize ( OUT PNDIS_STATUS OpenErrorStatus, OUT PUINT SelectedMediumIndex, IN PNDIS_MEDIUM MediumArray, IN UINT MediumArraySize, IN NDIS_HANDLE MiniportAdapterHandle, IN NDIS_HANDLE WrapperConfigurationContext ) { PRTL_ADAPTER adapter; NDIS_STATUS status; UINT i; PNDIS_RESOURCE_LIST resourceList; UINT resourceListSize; // // Make sure the medium is supported // for (i = 0; i < MediumArraySize; i++) { if (MediumArray[i] == NdisMedium802_3) { *SelectedMediumIndex = i; break; } } if (i == MediumArraySize) { NDIS_DbgPrint(MIN_TRACE, ("802.3 medium was not found in the medium array\n")); return NDIS_STATUS_UNSUPPORTED_MEDIA; } // // Allocate our adapter context // status = NdisAllocateMemoryWithTag((PVOID*)&adapter, sizeof(*adapter), ADAPTER_TAG); if (status != NDIS_STATUS_SUCCESS) { NDIS_DbgPrint(MIN_TRACE, ("Failed to allocate adapter context\n")); return NDIS_STATUS_RESOURCES; } RtlZeroMemory(adapter, sizeof(*adapter)); adapter->MiniportAdapterHandle = MiniportAdapterHandle; NdisAllocateSpinLock(&adapter->Lock); // // Notify NDIS of some characteristics of our NIC // NdisMSetAttributesEx(MiniportAdapterHandle, adapter, 0, NDIS_ATTRIBUTE_BUS_MASTER, NdisInterfacePci); // // Get our resources for IRQ and IO base information // resourceList = NULL; resourceListSize = 0; NdisMQueryAdapterResources(&status, WrapperConfigurationContext, resourceList, &resourceListSize); if (status != NDIS_STATUS_RESOURCES) { NDIS_DbgPrint(MIN_TRACE, ("Unexpected failure of NdisMQueryAdapterResources #1\n")); status = NDIS_STATUS_FAILURE; goto Cleanup; } status = NdisAllocateMemoryWithTag((PVOID*)&resourceList, resourceListSize, RESOURCE_LIST_TAG); if (status != NDIS_STATUS_SUCCESS) { NDIS_DbgPrint(MIN_TRACE, ("Failed to allocate resource list\n")); goto Cleanup; } NdisMQueryAdapterResources(&status, WrapperConfigurationContext, resourceList, &resourceListSize); if (status != NDIS_STATUS_SUCCESS) { NDIS_DbgPrint(MIN_TRACE, ("Unexpected failure of NdisMQueryAdapterResources #2\n")); goto Cleanup; } ASSERT(resourceList->Version == 1); ASSERT(resourceList->Revision == 1); for (i = 0; i < resourceList->Count; i++) { switch (resourceList->PartialDescriptors[i].Type) { case CmResourceTypePort: ASSERT(adapter->IoRangeStart == 0); ASSERT(resourceList->PartialDescriptors[i].u.Port.Start.HighPart == 0); adapter->IoRangeStart = resourceList->PartialDescriptors[i].u.Port.Start.LowPart; adapter->IoRangeLength = resourceList->PartialDescriptors[i].u.Port.Length; NDIS_DbgPrint(MID_TRACE, ("I/O port range is %p to %p\n", adapter->IoRangeStart, adapter->IoRangeStart + adapter->IoRangeLength)); break; case CmResourceTypeInterrupt: ASSERT(adapter->InterruptVector == 0); ASSERT(adapter->InterruptLevel == 0); adapter->InterruptVector = resourceList->PartialDescriptors[i].u.Interrupt.Vector; adapter->InterruptLevel = resourceList->PartialDescriptors[i].u.Interrupt.Level; adapter->InterruptShared = (resourceList->PartialDescriptors[i].ShareDisposition == CmResourceShareShared); adapter->InterruptFlags = resourceList->PartialDescriptors[i].Flags; NDIS_DbgPrint(MID_TRACE, ("IRQ vector is %d\n", adapter->InterruptVector)); break; default: NDIS_DbgPrint(MIN_TRACE, ("Unrecognized resource type: 0x%x\n", resourceList->PartialDescriptors[i].Type)); break; } } NdisFreeMemory(resourceList, resourceListSize, 0); resourceList = NULL; if (adapter->IoRangeStart == 0 || adapter->InterruptVector == 0) { NDIS_DbgPrint(MIN_TRACE, ("Adapter didn't receive enough resources\n")); goto Cleanup; } // // Allocate the DMA resources // status = NdisMInitializeScatterGatherDma(MiniportAdapterHandle, FALSE, // RTL8139 only supports 32-bit addresses MAXIMUM_FRAME_SIZE); if (status != NDIS_STATUS_SUCCESS) { NDIS_DbgPrint(MIN_TRACE, ("Unable to configure DMA\n")); goto Cleanup; } adapter->ReceiveBufferLength = FULL_RECEIVE_BUFFER_SIZE; NdisMAllocateSharedMemory(MiniportAdapterHandle, adapter->ReceiveBufferLength, FALSE, (PVOID*)&adapter->ReceiveBuffer, &adapter->ReceiveBufferPa); if (adapter->ReceiveBuffer == NULL) { NDIS_DbgPrint(MIN_TRACE, ("Unable to allocate receive buffer\n")); status = NDIS_STATUS_RESOURCES; goto Cleanup; } NdisMAllocateSharedMemory(MiniportAdapterHandle, MINIMUM_FRAME_SIZE * TX_DESC_COUNT, FALSE, (PVOID*)&adapter->RuntTxBuffers, &adapter->RuntTxBuffersPa); if (adapter->RuntTxBuffers == NULL) { NDIS_DbgPrint(MIN_TRACE, ("Unable to allocate runt TX buffer\n")); status = NDIS_STATUS_RESOURCES; goto Cleanup; } // // Register the I/O port range and configure the NIC // status = NdisMRegisterIoPortRange((PVOID*)&adapter->IoBase, MiniportAdapterHandle, adapter->IoRangeStart, adapter->IoRangeLength); if (status != NDIS_STATUS_SUCCESS) { NDIS_DbgPrint(MIN_TRACE, ("Unable to register IO port range (0x%x)\n", status)); goto Cleanup; } // // Adapter setup // status = NICPowerOn(adapter); if (status != NDIS_STATUS_SUCCESS) { NDIS_DbgPrint(MIN_TRACE, ("Unable to power on NIC (0x%x)\n", status)); goto Cleanup; } status = NICSoftReset(adapter); if (status != NDIS_STATUS_SUCCESS) { NDIS_DbgPrint(MIN_TRACE, ("Unable to reset the NIC (0x%x)\n", status)); goto Cleanup; } status = NICGetPermanentMacAddress(adapter, adapter->PermanentMacAddress); if (status != NDIS_STATUS_SUCCESS) { NDIS_DbgPrint(MIN_TRACE, ("Unable to get the fixed MAC address (0x%x)\n", status)); goto Cleanup; } RtlCopyMemory(adapter->CurrentMacAddress, adapter->PermanentMacAddress, IEEE_802_ADDR_LENGTH); // // Update link state and speed // NICUpdateLinkStatus(adapter); status = NICRegisterReceiveBuffer(adapter); if (status != NDIS_STATUS_SUCCESS) { NDIS_DbgPrint(MIN_TRACE, ("Unable to setup receive buffer (0x%x)\n", status)); goto Cleanup; } // // We're ready to handle interrupts now // status = NdisMRegisterInterrupt(&adapter->Interrupt, MiniportAdapterHandle, adapter->InterruptVector, adapter->InterruptLevel, TRUE, // We always want ISR calls adapter->InterruptShared, (adapter->InterruptFlags & CM_RESOURCE_INTERRUPT_LATCHED) ? NdisInterruptLatched : NdisInterruptLevelSensitive); if (status != NDIS_STATUS_SUCCESS) { NDIS_DbgPrint(MIN_TRACE, ("Unable to register interrupt (0x%x)\n", status)); goto Cleanup; } adapter->InterruptRegistered = TRUE; // // Enable interrupts on the NIC // adapter->InterruptMask = DEFAULT_INTERRUPT_MASK; status = NICApplyInterruptMask(adapter); if (status != NDIS_STATUS_SUCCESS) { NDIS_DbgPrint(MIN_TRACE, ("Unable to apply interrupt mask (0x%x)\n", status)); goto Cleanup; } // // Turn on TX and RX now // status = NICEnableTxRx(adapter); if (status != NDIS_STATUS_SUCCESS) { NDIS_DbgPrint(MIN_TRACE, ("Unable to enable TX and RX (0x%x)\n", status)); goto Cleanup; } return NDIS_STATUS_SUCCESS; Cleanup: if (resourceList != NULL) { NdisFreeMemory(resourceList, resourceListSize, 0); } if (adapter != NULL) { MiniportHalt(adapter); } return status; }
BOOLEAN TOK162InitialInit( IN PTOK162_ADAPTER Adapter ) /*++ Routine Description: This routine sets up the initial init of the driver. Arguments: Adapter - The adapter structure for the hardware. Return Value: TRUE if successful, FALSE if not. --*/ { // // Holds status returned from NDIS calls. // NDIS_STATUS Status; // // First we make sure that the device is stopped. // TOK162DisableInterrupt(Adapter); // // Set flags indicating we are doing the initial init // Adapter->InitialInit = TRUE; Adapter->ResetState = InitialInit; Adapter->InitialOpenComplete = FALSE; Adapter->InitialReceiveSent = FALSE; Adapter->ResetInProgress = TRUE; // // Initialize the interrupt. // Status = NdisMRegisterInterrupt( &Adapter->Interrupt, Adapter->MiniportAdapterHandle, Adapter->InterruptLevel, Adapter->InterruptLevel, FALSE, FALSE, NdisInterruptLatched ); // // Report the status of the interrupt registering to the debugger // VERY_LOUD_DEBUG(DbgPrint( "IBMTOK2I!Status from Registering Interrupt -%u was %u\n", Adapter->InterruptLevel, Status);) // // If the interrupt register failed, mark the interrupt level at 0 so // we know not to do a deregister. // if (Status != NDIS_STATUS_SUCCESS) {
/* ************************************************************************* * MiniportInitialize ************************************************************************* * * * Initializes the network interface card. * * * */ NDIS_STATUS MiniportInitialize ( PNDIS_STATUS OpenErrorStatus, PUINT SelectedMediumIndex, PNDIS_MEDIUM MediumArray, UINT MediumArraySize, NDIS_HANDLE NdisAdapterHandle, NDIS_HANDLE WrapperConfigurationContext ) { UINT mediumIndex; IrDevice *thisDev = NULL; NDIS_STATUS retStat, result = NDIS_STATUS_SUCCESS; DBGOUT(("MiniportInitialize()")); /* * Search the passed-in array of supported media for the IrDA medium. */ for (mediumIndex = 0; mediumIndex < MediumArraySize; mediumIndex++){ if (MediumArray[mediumIndex] == NdisMediumIrda){ break; } } if (mediumIndex < MediumArraySize){ *SelectedMediumIndex = mediumIndex; } else { /* * Didn't see the IrDA medium */ DBGERR(("Didn't see the IRDA medium in MiniportInitialize")); result = NDIS_STATUS_UNSUPPORTED_MEDIA; goto _initDone; } /* * Allocate a new device object to represent this connection. */ thisDev = NewDevice(); if (!thisDev){ return NDIS_STATUS_NOT_ACCEPTED; } /* * Allocate resources for this connection. */ if (!OpenDevice(thisDev)){ DBGERR(("OpenDevice failed")); result = NDIS_STATUS_FAILURE; goto _initDone; } /* * Read the system registry to get parameters like COM port number, etc. */ if (!Configure(thisDev, WrapperConfigurationContext)){ result = NDIS_STATUS_FAILURE; goto _initDone; } /* * This call will associate our adapter handle with the wrapper's * adapter handle. The wrapper will then always use our handle * when calling us. We use a pointer to the device object as the context. */ NdisMSetAttributes ( NdisAdapterHandle, (NDIS_HANDLE)thisDev, FALSE, NdisInterfaceInternal ); /* * Tell NDIS about the range of IO space that we'll be using. */ retStat = NdisMRegisterIoPortRange( (PVOID)thisDev->mappedPortRange, NdisAdapterHandle, thisDev->portInfo.ioBase, 8); if (retStat != NDIS_STATUS_SUCCESS){ DBGERR(("NdisMRegisterIoPortRange failed")); result = NDIS_STATUS_FAILURE; goto _initDone; } /* * Record the NDIS wrapper's handle for this adapter, which we use * when we call up to the wrapper. * (This miniport's adapter handle is just thisDev, the pointer to the device object.). */ DBGOUT(("NDIS handle: %xh <-> IRMINI handle: %xh", (UINT)NdisAdapterHandle, (UINT)thisDev)); thisDev->ndisAdapterHandle = NdisAdapterHandle; /* * Open COMM communication channel. * This will let the dongle driver update its capabilities from their default values. */ if (!DoOpen(thisDev)){ DBGERR(("DoOpen failed")); result = NDIS_STATUS_FAILURE; goto _initDone; } /* * Register an interrupt with NDIS. */ retStat = NdisMRegisterInterrupt( (PNDIS_MINIPORT_INTERRUPT)&thisDev->interruptObj, NdisAdapterHandle, thisDev->portInfo.irq, thisDev->portInfo.irq, TRUE, // want ISR TRUE, // MUST share interrupts NdisInterruptLevelSensitive ); if (retStat != NDIS_STATUS_SUCCESS){ DBGERR(("NdisMRegisterInterrupt failed")); result = NDIS_STATUS_FAILURE; goto _initDone; } _initDone: if (result == NDIS_STATUS_SUCCESS){ /* * Add this device object to the beginning of our global list. */ thisDev->next = firstIrDevice; firstIrDevice = thisDev; DBGOUT(("MiniportInitialize succeeded")); } else { if (thisDev){ FreeDevice(thisDev); } DBGOUT(("MiniportInitialize failed")); } return result; }
BOOLEAN NE3200InitialInit( IN PNE3200_ADAPTER Adapter, IN UINT NE3200InterruptVector, IN NDIS_INTERRUPT_MODE NE3200InterruptMode ) /*++ Routine Description: This routine sets up the initial init of the driver, by stopping the adapter, connecting the interrupt and initializing the adapter. Arguments: Adapter - The adapter for the hardware. Return Value: TRUE if the initialization succeeds, else FALSE. --*/ { // // Status of NDIS calls // NDIS_STATUS Status; // // First we make sure that the device is stopped. // NE3200StopChip(Adapter); // // The ISR will set this to FALSE if we get an interrupt // Adapter->InitialInit = TRUE; // // Initialize the interrupt. // Status = NdisMRegisterInterrupt( &Adapter->Interrupt, Adapter->MiniportAdapterHandle, NE3200InterruptVector, NE3200InterruptVector, FALSE, FALSE, NE3200InterruptMode ); // // So far so good // if (Status == NDIS_STATUS_SUCCESS) { // // Now try to initialize the adapter // if (!NE3200SetConfigurationBlockAndInit(Adapter)) { // // Failed. Write out an error log entry. // NdisWriteErrorLogEntry( Adapter->MiniportAdapterHandle, NDIS_ERROR_CODE_TIMEOUT, 2, initialInit, NE3200_ERRMSG_NO_DELAY ); // // Unhook the interrupt // NdisMDeregisterInterrupt(&Adapter->Interrupt); Adapter->InitialInit = FALSE; return FALSE; } // // Get hardware assigned network address. // NE3200GetStationAddress( Adapter ); // // We can start the chip. We may not // have any bindings to indicate to but this // is unimportant. // Status = NE3200ChangeCurrentAddress(Adapter); Adapter->InitialInit = FALSE; return(Status == NDIS_STATUS_SUCCESS); } else { // // Interrupt line appears to be taken. Notify user. // NdisWriteErrorLogEntry( Adapter->MiniportAdapterHandle, NDIS_ERROR_CODE_INTERRUPT_CONNECT, 2, initialInit, NE3200_ERRMSG_INIT_INTERRUPT ); Adapter->InitialInit = FALSE; return(FALSE); } }
/* Function Name : LPC3xxx_MiniportInitialize Description : Called by the NDIS Wrapper to initialize the adapter. 0. Verify the Adapter v/s the driver 1. Create and initilize the adapter structure 2. Read and load the registry settings 3. Initialize the chip 4. Establish the link Parameters : PNDIS_STATUS OpenErrorStatus - Additional error status, if return value is error PUINT MediumIndex - specifies the medium type the driver or its network adapter uses PNDIS_MEDIUM MediumArray - Specifies an array of NdisMediumXXX values from which MiniportInitialize selects one that its network adapter supports or that the driver supports as an interface to higher-level drivers. UINT MediumArraySize - Specifies the number of elements at MediumArray NDIS_HANDLE AdapterHandle - Specifies a handle identifying the miniport’s network adapter, which is assigned by the NDIS library NDIS_HANDLE ConfigurationContext - Specifies a handle used only during initialization for calls to NdisXXX configuration and initialization functions Return Value : NDIS_STATUS Status */ NDIS_STATUS LPC3xxx_MiniportInitialize( PNDIS_STATUS pOpenErrorStatus, PUINT pMediumIndex, PNDIS_MEDIUM pMediumArray, UINT nMediumArraySize, NDIS_HANDLE hAdapterHandle, NDIS_HANDLE hConfigurationContext) { NDIS_STATUS Status = NDIS_STATUS_SUCCESS; UINT nArrayIndex; PMINIPORT_ADAPTER pAdapter; PHYSICAL_ADDRESS pa; DEBUGMSG(ZONE_INIT, (TEXT("LPC3xxx NDIS ==> MiniportInitialize\r\n"))); //Check for the supported 802.3 media for(nArrayIndex = 0; nArrayIndex < nMediumArraySize; nArrayIndex++) { if(NdisMedium802_3 == pMediumArray[nArrayIndex]) break; } if(nArrayIndex == nMediumArraySize) { DEBUGMSG(ZONE_INIT | ZONE_ERROR, (TEXT("LPC3xxx NDIS : ERROR - No Supported Media types \r\n"))); DEBUGMSG(ZONE_INIT | ZONE_ERROR, (TEXT("LPC3xxx NDIS <== MiniportInitialize \r\n"))); return(NDIS_STATUS_UNSUPPORTED_MEDIA); } *pMediumIndex = nArrayIndex; //Allocate memory for the adapter structure Status = NdisAllocateMemory((PVOID *) &pAdapter, MINIPORT_ADAPTER_SIZE, 0, HighestAcceptedMax); if(Status != NDIS_STATUS_SUCCESS) { DEBUGMSG(ZONE_INIT | ZONE_ERROR, (TEXT("LPC3xxx NDIS: ERROR - No Memory for Adapter Structure!\r\n"))); DEBUGMSG(ZONE_INIT | ZONE_ERROR, (TEXT("LPC3xxx NDIS <== MiniPort Initialize\r\n"))); return(NDIS_STATUS_RESOURCES); } NdisZeroMemory(pAdapter, MINIPORT_ADAPTER_SIZE); //Clean it up //Set up the default values pAdapter->hAdapter = hAdapterHandle; pAdapter->eState = INITIALIZING_STATE; pAdapter->IsInterruptSet = FALSE; pAdapter->IsPortRegistered = FALSE; pAdapter->dwIRQNumber = -1; pAdapter->bMediaConnected = FALSE; pAdapter->bAutoNeg = TRUE; // Autoneg per default (overriden by registry settings) pAdapter->bFullDuplex = TRUE; // Full duplex per default pAdapter->b100Mbps = TRUE; // 100 Mbps per default pAdapter->bRMII = TRUE; // RMII interface per default //Setup Receive control Register pAdapter->bPerfectMatch = TRUE; // We want to receive the frames for this station pAdapter->bPromiscuous = FALSE; // Not in Promescuous mode per default pAdapter->bRxBroadcast = TRUE; // We do forward the broadcasted frames (DHCP required at least) pAdapter->bRxMulticastHash = TRUE; // We forward matched multicast frames pAdapter->bRxMulticastAll = FALSE; // We do not forward all multicast frames pAdapter->bRxUnicastHash = TRUE; // We do not forward matched unicast frames pAdapter->bRxUnicastAll = TRUE; // We do not forward all unicast frames pAdapter->dwBufferPhyAddr = 0; pAdapter->dwTxStrides = 0; pAdapter->dwRxStrides = 0; pAdapter->dwControllerAddress = 0; pAdapter->pEMACRegs = NULL; pAdapter->dwEMACBuffersSize = 0; pAdapter->pPATXDesc = 0; pAdapter->pPARXDesc = 0; pAdapter->pPATXBuffer = 0; pAdapter->pPARXBuffer = 0; pAdapter->pPATXStatus = 0; pAdapter->pPARXStatus = 0; pAdapter->pVAEMACBuffers= NULL; pAdapter->pVATXDesc = NULL; pAdapter->pVARXDesc = NULL; pAdapter->pVATXStatus = NULL; pAdapter->pVARXStatus = NULL; //Allocate memory for the LookAhead buffer pAdapter->dwLookAheadBufferSize = MAX_FRAME_SIZE; Status = NdisAllocateMemory((PVOID *) &pAdapter->pVALookAheadBuffer, pAdapter->dwLookAheadBufferSize, 0, HighestAcceptedMax); if(Status != NDIS_STATUS_SUCCESS) { DEBUGMSG(ZONE_INIT, (TEXT("LPC3xxx NDIS: ERROR - No Memory for LookAhead buffer!\r\n"))); DEBUGMSG(ZONE_INIT, (TEXT("LPC3xxx NDIS <== MiniPort Initialize\r\n"))); BackOut(pAdapter); return(NDIS_STATUS_RESOURCES); } NdisZeroMemory(pAdapter->pVALookAheadBuffer, pAdapter->dwLookAheadBufferSize); //Clean it up pAdapter->MACAddress[0] = 0x02; pAdapter->MACAddress[1] = 0x03; pAdapter->MACAddress[2] = 0x04; pAdapter->MACAddress[3] = 0x06; pAdapter->MACAddress[4] = 0x06; pAdapter->MACAddress[5] = 0x08; //Get the adapter information from the registry Status = GetRegistrySettings(pAdapter, hConfigurationContext); if(Status != NDIS_STATUS_SUCCESS) { DEBUGMSG(ZONE_INIT, (TEXT("LPC3xxx NDIS: ERROR - Configure Adapter failed!\r\n"))); DEBUGMSG(ZONE_INIT, (TEXT("LPC3xxx NDIS <== MiniPort Initialize\r\n"))); BackOut(pAdapter); return(NDIS_STATUS_FAILURE); } // Allocate the memory for Buffers // Computing required space pAdapter->dwEMACBuffersSize = pAdapter->dwRxStrides * ( sizeof(LPCS_ETH_DESC) + sizeof(LPCS_ETH_RX_STATUS) + MAX_FRAME_SIZE) + pAdapter->dwTxStrides * ( sizeof(LPCS_ETH_DESC) + sizeof(LPCS_ETH_TX_STATUS) + MAX_FRAME_SIZE); // Allocating space pAdapter->pVAEMACBuffers = MapRegisters (pAdapter->dwBufferPhyAddr, pAdapter->dwEMACBuffersSize); if(pAdapter->pVAEMACBuffers == NULL) { RETAILMSG(1, (TEXT("LPC3xxx NDIS:ERROR : Can't Allocate Buffer!\r\n"))); BackOut(pAdapter); DEBUGMSG(ZONE_INIT, (TEXT("LPC3xxx NDIS:<== MiniPort Initialize FAILED !!\r\n"))); return(NDIS_STATUS_RESOURCES); } DEBUGMSG(ZONE_INIT, (TEXT("LPC3xxx NDIS:Allocated DMA Buffers Successfully!\r\n"))); // Splitting allocated buffers into smaller areas // Physical Addresses pAdapter->pPARXDesc = pAdapter->dwBufferPhyAddr; pAdapter->pPARXStatus = pAdapter->pPARXDesc + pAdapter->dwRxStrides * sizeof(LPCS_ETH_DESC); pAdapter->pPATXDesc = pAdapter->pPARXStatus + pAdapter->dwRxStrides * sizeof(LPCS_ETH_RX_STATUS); pAdapter->pPATXStatus = pAdapter->pPATXDesc + pAdapter->dwTxStrides * sizeof(LPCS_ETH_DESC); pAdapter->pPARXBuffer = pAdapter->pPATXStatus + pAdapter->dwTxStrides * sizeof(LPCS_ETH_TX_STATUS); pAdapter->pPATXBuffer = pAdapter->pPARXBuffer + pAdapter->dwRxStrides * MAX_FRAME_SIZE; // Virtual Addresses pAdapter->pVARXDesc = pAdapter->pVAEMACBuffers; pAdapter->pVARXStatus = (PVOID)((DWORD)pAdapter->pVARXDesc + pAdapter->dwRxStrides * sizeof(LPCS_ETH_DESC)); pAdapter->pVATXDesc = (PVOID)((DWORD)pAdapter->pVARXStatus + pAdapter->dwRxStrides * sizeof(LPCS_ETH_RX_STATUS)); pAdapter->pVATXStatus = (PVOID)((DWORD)pAdapter->pVATXDesc + pAdapter->dwTxStrides * sizeof(LPCS_ETH_DESC)); pAdapter->pVARXBuffer = (PVOID)((DWORD)pAdapter->pVATXStatus + pAdapter->dwTxStrides * sizeof(LPCS_ETH_TX_STATUS)); pAdapter->pVATXBuffer = (PVOID)((DWORD)pAdapter->pVARXBuffer + pAdapter->dwRxStrides * MAX_FRAME_SIZE); // Allocating the TX Packet buffer Status = NdisAllocateMemory((PVOID *) &pAdapter->pTXPackets, sizeof(TX_PACKET) * pAdapter->dwTxStrides, 0, HighestAcceptedMax); if(Status != NDIS_STATUS_SUCCESS) { DEBUGMSG(ZONE_INIT, (TEXT("LPC3xxx NDIS: ERROR - No Memory for TXBuffers buffer!\r\n"))); DEBUGMSG(ZONE_INIT, (TEXT("LPC3xxx NDIS <== MiniPort Initialize\r\n"))); BackOut(pAdapter); return(NDIS_STATUS_RESOURCES); } NdisZeroMemory(pAdapter->pTXPackets, sizeof(TX_PACKET) * pAdapter->dwTxStrides); //Clean it up //Register the interrupt NdisMSetAttributes(pAdapter->hAdapter, (NDIS_HANDLE) pAdapter, TRUE, NdisInterfaceInternal); Status = NdisMRegisterInterrupt(&pAdapter->InterruptInfo, pAdapter->hAdapter, pAdapter->dwIRQNumber, 0, TRUE, FALSE, NdisInterruptLatched); if(Status != NDIS_STATUS_SUCCESS) { DEBUGMSG(ZONE_INIT, (TEXT("LPC3xxx NDIS : ERROR - Can't Attach to Interrupt!\r\n"))); BackOut(pAdapter); DEBUGMSG(ZONE_INIT, (TEXT("LPC3xxx NDIS:<== MiniPort Initialize\r\n"))); return(Status); } else DEBUGMSG(ZONE_INIT, (TEXT("LPC3xxx NDIS: Interrupt Registered !!! \r\n"))); pAdapter->IsInterruptSet = TRUE; //Register the IOBase address. Modify this code according to the platform Status = NdisMRegisterIoPortRange((PVOID *) &(pAdapter->pEMACRegs), pAdapter->hAdapter, pAdapter->dwControllerAddress, sizeof(ETHERNET_REGS_T)); if(Status != NDIS_STATUS_SUCCESS) { RETAILMSG(1, (TEXT("LAN91C9111 : ERROR - Can't Register I/O Port Range!\r\n"))); DEBUGMSG(ZONE_INIT, (TEXT("LAN91C9111 <== MiniPort Initialize\r\n"))); BackOut(pAdapter); return(NDIS_STATUS_RESOURCES); } pAdapter->IsPortRegistered = TRUE; //EnablePeriphClock(ETHERNET); pa.QuadPart = CLK_PM_BASE; n_pCLKPWRRegs = (CLKPWR_REGS_T *) MmMapIoSpace(pa, sizeof (CLKPWR_REGS_T), FALSE); if (n_pCLKPWRRegs == NULL) { RETAILMSG(1, (_T("LCD: lpc32xx_hw_init: Critcal error: cannot map registers!\r\n"))); MmUnmapIoSpace(n_pCLKPWRRegs, sizeof(CLKPWR_REGS_T)); return; } n_pCLKPWRRegs->clkpwr_macclk_ctrl = CLKPWR_MACCTRL_HRCCLK_EN| CLKPWR_MACCTRL_MMIOCLK_EN| CLKPWR_MACCTRL_DMACLK_EN| CLKPWR_MACCTRL_USE_RMII_PINS; // // Initialize Tx and Rx DMA Descriptors //DEBUGMSG(ZONE_INIT, (L"LPC_EthInit: Initializing Descriptor engine\r\n")); //EMAC_InitEngine(pAdapter); if(!HardReset(pAdapter)) { return NDIS_STATUS_FAILURE; } DEBUGMSG(ZONE_INIT, (TEXT("LPC3xxx NDIS <== MiniportInitialize \r\n"))); //Ready return NDIS_STATUS_SUCCESS; }
/*----------------------------------------------------------------------------*/ NDIS_STATUS windowsRegisterIsrt ( IN P_GLUE_INFO_T prGlueInfo ) { NDIS_STATUS rStatus; P_GL_HIF_INFO_T prHifInfo; DEBUGFUNC("windowsRegisterIsrt"); ASSERT(prGlueInfo); prHifInfo = &prGlueInfo->rHifInfo; /* Next we'll register our interrupt with the NDIS wrapper. */ /* Hook our interrupt vector. We used level-triggered, shared interrupts with our PCI adapters. */ INITLOG(("Register IRQ: handle=0x%x, irq=0x%x, level-triggered\n", prGlueInfo->rMiniportAdapterHandle, prHifInfo->u4InterruptLevel)); rStatus = NdisMRegisterInterrupt(&prHifInfo->rInterrupt, prGlueInfo->rMiniportAdapterHandle, (UINT) prHifInfo->u4InterruptVector, (UINT) prHifInfo->u4InterruptLevel, TRUE, /* RequestIsr */ FALSE, /* SharedInterrupt */ NIC_INTERRUPT_MODE); if (rStatus != NDIS_STATUS_SUCCESS) { ERRORLOG(("Interrupt conflict: status=0x%08x, IRQ=%d, level-sensitive\n", rStatus, prHifInfo->u4InterruptLevel)); NdisWriteErrorLogEntry(prGlueInfo->rMiniportAdapterHandle, NDIS_ERROR_CODE_INTERRUPT_CONNECT, 1, (UINT_32) prHifInfo->u4InterruptLevel); } GLUE_SET_FLAG(prGlueInfo, GLUE_FLAG_INTERRUPT_IN_USE); INITLOG(("Register interrupt -- OK\n")); #if SC32442_SPI { UINT_32 g_SysIntr; prHifInfo->gWaitEvent = CreateEvent(NULL, FALSE, FALSE, NULL); if (!KernelIoControl(IOCTL_HAL_REQUEST_SYSINTR, &prHifInfo->u4InterruptLevel, sizeof(UINT32), &g_SysIntr, sizeof(UINT32), NULL)) { INITLOG(("ERROR:Failed to request sysintr value for Timer1 inturrupt!/n")); } else { INITLOG(("Request sysintr value %d!/r/n", g_SysIntr)); prHifInfo->u4sysIntr = g_SysIntr; } if (!(InterruptInitialize(g_SysIntr, prHifInfo->gWaitEvent, 0, 0))) { INITLOG(("ERROR: Interrupt initialize failed.\n")); } } #endif return rStatus; } /* windowsRegisterIsrt */