/******************************************************************************/ /* */ /* Broadcom BCM5700 Linux Network Driver, Copyright (c) 2000 Broadcom */ /* Corporation. */ /* All rights reserved. */ /* */ /* This program is free software; you can redistribute it and/or modify */ /* it under the terms of the GNU General Public License as published by */ /* the Free Software Foundation, located in the file LICENSE. */ /* */ /* History: */ /******************************************************************************/ #include <common.h> #include <asm/types.h> #ifdef CONFIG_BMW #include <mpc824x.h> #endif #include <malloc.h> #include <linux/byteorder/big_endian.h> #include "bcm570x_mm.h" #define EMBEDDED 1 /******************************************************************************/ /* Local functions. */ /******************************************************************************/ LM_STATUS LM_Abort (PLM_DEVICE_BLOCK pDevice); LM_STATUS LM_QueueRxPackets (PLM_DEVICE_BLOCK pDevice); static LM_STATUS LM_TranslateRequestedMediaType (LM_REQUESTED_MEDIA_TYPE RequestedMediaType, PLM_MEDIA_TYPE pMediaType, PLM_LINE_SPEED pLineSpeed, PLM_DUPLEX_MODE pDuplexMode); static LM_STATUS LM_InitBcm540xPhy (PLM_DEVICE_BLOCK pDevice); __inline static LM_VOID LM_ServiceRxInterrupt (PLM_DEVICE_BLOCK pDevice); __inline static LM_VOID LM_ServiceTxInterrupt (PLM_DEVICE_BLOCK pDevice); static LM_STATUS LM_ForceAutoNegBcm540xPhy (PLM_DEVICE_BLOCK pDevice, LM_REQUESTED_MEDIA_TYPE RequestedMediaType); static LM_STATUS LM_ForceAutoNeg (PLM_DEVICE_BLOCK pDevice, LM_REQUESTED_MEDIA_TYPE RequestedMediaType); static LM_UINT32 GetPhyAdFlowCntrlSettings (PLM_DEVICE_BLOCK pDevice); STATIC LM_STATUS LM_SetFlowControl (PLM_DEVICE_BLOCK pDevice, LM_UINT32 LocalPhyAd, LM_UINT32 RemotePhyAd); #if INCLUDE_TBI_SUPPORT STATIC LM_STATUS LM_SetupFiberPhy (PLM_DEVICE_BLOCK pDevice); STATIC LM_STATUS LM_InitBcm800xPhy (PLM_DEVICE_BLOCK pDevice); #endif STATIC LM_STATUS LM_SetupCopperPhy (PLM_DEVICE_BLOCK pDevice); STATIC PLM_ADAPTER_INFO LM_GetAdapterInfoBySsid (LM_UINT16 Svid, LM_UINT16 Ssid); STATIC LM_STATUS LM_DmaTest (PLM_DEVICE_BLOCK pDevice, PLM_UINT8 pBufferVirt, LM_PHYSICAL_ADDRESS BufferPhy, LM_UINT32 BufferSize); STATIC LM_STATUS LM_HaltCpu (PLM_DEVICE_BLOCK pDevice, LM_UINT32 cpu_number); STATIC LM_STATUS LM_ResetChip (PLM_DEVICE_BLOCK pDevice); STATIC LM_STATUS LM_Test4GBoundary (PLM_DEVICE_BLOCK pDevice, PLM_PACKET pPacket, PT3_SND_BD pSendBd); /******************************************************************************/ /* External functions. */ /******************************************************************************/ LM_STATUS LM_LoadRlsFirmware (PLM_DEVICE_BLOCK pDevice); /******************************************************************************/ /* Description: */ /* */ /* Return: */ /******************************************************************************/ LM_UINT32 LM_RegRdInd (PLM_DEVICE_BLOCK pDevice, LM_UINT32 Register) { LM_UINT32 Value32; #if PCIX_TARGET_WORKAROUND MM_ACQUIRE_UNDI_LOCK (pDevice); #endif MM_WriteConfig32 (pDevice, T3_PCI_REG_ADDR_REG, Register); MM_ReadConfig32 (pDevice, T3_PCI_REG_DATA_REG, &Value32); #if PCIX_TARGET_WORKAROUND MM_RELEASE_UNDI_LOCK (pDevice); #endif return Value32; } /* LM_RegRdInd */ /******************************************************************************/ /* Description: */ /* */ /* Return: */ /******************************************************************************/ LM_VOID LM_RegWrInd (PLM_DEVICE_BLOCK pDevice, LM_UINT32 Register, LM_UINT32 Value32) { #if PCIX_TARGET_WORKAROUND MM_ACQUIRE_UNDI_LOCK (pDevice); #endif MM_WriteConfig32 (pDevice, T3_PCI_REG_ADDR_REG, Register); MM_WriteConfig32 (pDevice, T3_PCI_REG_DATA_REG, Value32); #if PCIX_TARGET_WORKAROUND MM_RELEASE_UNDI_LOCK (pDevice); #endif } /* LM_RegWrInd */ /******************************************************************************/ /* Description: */ /* */ /* Return: */ /******************************************************************************/ LM_UINT32 LM_MemRdInd (PLM_DEVICE_BLOCK pDevice, LM_UINT32 MemAddr) { LM_UINT32 Value32; MM_ACQUIRE_UNDI_LOCK (pDevice); #ifdef BIG_ENDIAN_HOST MM_WriteConfig32 (pDevice, T3_PCI_MEM_WIN_ADDR_REG, MemAddr); Value32 = REG_RD (pDevice, PciCfg.MemWindowData); /* Value32 = REG_RD(pDevice,uIntMem.Mbuf[(MemAddr & 0x7fff)/4]); */ #else MM_WriteConfig32 (pDevice, T3_PCI_MEM_WIN_ADDR_REG, MemAddr); MM_ReadConfig32 (pDevice, T3_PCI_MEM_WIN_DATA_REG, &Value32); #endif MM_RELEASE_UNDI_LOCK (pDevice); return Value32; } /* LM_MemRdInd */ /******************************************************************************/ /* Description: */ /* */ /* Return: */ /******************************************************************************/ LM_VOID LM_MemWrInd (PLM_DEVICE_BLOCK pDevice, LM_UINT32 MemAddr, LM_UINT32 Value32) { MM_ACQUIRE_UNDI_LOCK (pDevice); #ifdef BIG_ENDIAN_HOST REG_WR (pDevice, PciCfg.MemWindowBaseAddr, MemAddr); REG_WR (pDevice, uIntMem.Mbuf[(MemAddr & 0x7fff) / 4], Value32); #else MM_WriteConfig32 (pDevice, T3_PCI_MEM_WIN_ADDR_REG, MemAddr); MM_WriteConfig32 (pDevice, T3_PCI_MEM_WIN_DATA_REG, Value32); #endif MM_RELEASE_UNDI_LOCK (pDevice); } /* LM_MemWrInd */ /******************************************************************************/ /* Description: */ /* */ /* Return: */ /******************************************************************************/ LM_STATUS LM_QueueRxPackets (PLM_DEVICE_BLOCK pDevice) { LM_STATUS Lmstatus; PLM_PACKET pPacket; PT3_RCV_BD pRcvBd; LM_UINT32 StdBdAdded = 0; #if T3_JUMBO_RCV_RCB_ENTRY_COUNT LM_UINT32 JumboBdAdded = 0; #endif /* T3_JUMBO_RCV_RCB_ENTRY_COUNT */ Lmstatus = LM_STATUS_SUCCESS; pPacket = (PLM_PACKET) QQ_PopHead (&pDevice->RxPacketFreeQ.Container); while (pPacket) { switch (pPacket->u.Rx.RcvProdRing) { #if T3_JUMBO_RCV_RCB_ENTRY_COUNT case T3_JUMBO_RCV_PROD_RING: /* Jumbo Receive Ring. */ /* Initialize the buffer descriptor. */ pRcvBd = &pDevice->pRxJumboBdVirt[pDevice->RxJumboProdIdx]; pRcvBd->Flags = RCV_BD_FLAG_END | RCV_BD_FLAG_JUMBO_RING; pRcvBd->Len = (LM_UINT16) pDevice->RxJumboBufferSize; /* Initialize the receive buffer pointer */ #if 0 /* Jimmy, deleted in new */ pRcvBd->HostAddr.Low = pPacket->u.Rx.RxBufferPhy.Low; pRcvBd->HostAddr.High = pPacket->u.Rx.RxBufferPhy.High; #endif MM_MapRxDma (pDevice, pPacket, &pRcvBd->HostAddr); /* The opaque field may point to an offset from a fix addr. */ pRcvBd->Opaque = (LM_UINT32) (MM_UINT_PTR (pPacket) - MM_UINT_PTR (pDevice-> pPacketDescBase)); /* Update the producer index. */ pDevice->RxJumboProdIdx = (pDevice->RxJumboProdIdx + 1) & T3_JUMBO_RCV_RCB_ENTRY_COUNT_MASK; JumboBdAdded++; break; #endif /* T3_JUMBO_RCV_RCB_ENTRY_COUNT */ case T3_STD_RCV_PROD_RING: /* Standard Receive Ring. */ /* Initialize the buffer descriptor. */ pRcvBd = &pDevice->pRxStdBdVirt[pDevice->RxStdProdIdx]; pRcvBd->Flags = RCV_BD_FLAG_END; pRcvBd->Len = MAX_STD_RCV_BUFFER_SIZE; /* Initialize the receive buffer pointer */ #if 0 /* Jimmy, deleted in new replaced with MM_MapRxDma */ pRcvBd->HostAddr.Low = pPacket->u.Rx.RxBufferPhy.Low; pRcvBd->HostAddr.High = pPacket->u.Rx.RxBufferPhy.High; #endif MM_MapRxDma (pDevice, pPacket, &pRcvBd->HostAddr); /* The opaque field may point to an offset from a fix addr. */ pRcvBd->Opaque = (LM_UINT32) (MM_UINT_PTR (pPacket) - MM_UINT_PTR (pDevice-> pPacketDescBase)); /* Update the producer index. */ pDevice->RxStdProdIdx = (pDevice->RxStdProdIdx + 1) & T3_STD_RCV_RCB_ENTRY_COUNT_MASK; StdBdAdded++; break; case T3_UNKNOWN_RCV_PROD_RING: default: Lmstatus = LM_STATUS_FAILURE; break; } /* switch */ /* Bail out if there is any error. */ if (Lmstatus != LM_STATUS_SUCCESS) { break; } pPacket = (PLM_PACKET) QQ_PopHead (&pDevice->RxPacketFreeQ.Container); } /* while */ wmb (); /* Update the procedure index. */ if (StdBdAdded) { MB_REG_WR (pDevice, Mailbox.RcvStdProdIdx.Low, pDevice->RxStdProdIdx); } #if T3_JUMBO_RCV_RCB_ENTRY_COUNT if (JumboBdAdded) { MB_REG_WR (pDevice, Mailbox.RcvJumboProdIdx.Low, pDevice->RxJumboProdIdx); } #endif /* T3_JUMBO_RCV_RCB_ENTRY_COUNT */ return Lmstatus; } /* LM_QueueRxPackets */ /******************************************************************************/ /* Description: */ /* */ /* Return: */ /******************************************************************************/ STATIC LM_VOID LM_NvramInit (PLM_DEVICE_BLOCK pDevice) { LM_UINT32 Value32; LM_UINT32 j; /* Intialize clock period and state machine. */ Value32 = SEEPROM_ADDR_CLK_PERD (SEEPROM_CLOCK_PERIOD) | SEEPROM_ADDR_FSM_RESET; REG_WR (pDevice, Grc.EepromAddr, Value32); for (j = 0; j < 100; j++) { MM_Wait (10); } /* Serial eeprom access using the Grc.EepromAddr/EepromData registers. */ Value32 = REG_RD (pDevice, Grc.LocalCtrl); REG_WR (pDevice, Grc.LocalCtrl, Value32 | GRC_MISC_LOCAL_CTRL_AUTO_SEEPROM); /* Set the 5701 compatibility mode if we are using EEPROM. */ if (T3_ASIC_REV (pDevice->ChipRevId) != T3_ASIC_REV_5700 && T3_ASIC_REV (pDevice->ChipRevId) != T3_ASIC_REV_5701) { Value32 = REG_RD (pDevice, Nvram.Config1); if ((Value32 & FLASH_INTERFACE_ENABLE) == 0) { /* Use the new interface to read EEPROM. */ Value32 &= ~FLASH_COMPAT_BYPASS; REG_WR (pDevice, Nvram.Config1, Value32); } } } /* LM_NvRamInit */ /******************************************************************************/ /* Description: */ /* */ /* Return: */ /******************************************************************************/ STATIC LM_STATUS LM_EepromRead (PLM_DEVICE_BLOCK pDevice, LM_UINT32 Offset, LM_UINT32 * pData) { LM_UINT32 Value32; LM_UINT32 Addr; LM_UINT32 Dev; LM_UINT32 j; if (Offset > SEEPROM_CHIP_SIZE) { return LM_STATUS_FAILURE; } Dev = Offset / SEEPROM_CHIP_SIZE; Addr = Offset % SEEPROM_CHIP_SIZE; Value32 = REG_RD (pDevice, Grc.EepromAddr); Value32 &= ~(SEEPROM_ADDR_ADDRESS_MASK | SEEPROM_ADDR_DEV_ID_MASK | SEEPROM_ADDR_RW_MASK); REG_WR (pDevice, Grc.EepromAddr, Value32 | SEEPROM_ADDR_DEV_ID (Dev) | SEEPROM_ADDR_ADDRESS (Addr) | SEEPROM_ADDR_START | SEEPROM_ADDR_READ); for (j = 0; j < 1000; j++) { Value32 = REG_RD (pDevice, Grc.EepromAddr); if (Value32 & SEEPROM_ADDR_COMPLETE) { break; } MM_Wait (10); } if (Value32 & SEEPROM_ADDR_COMPLETE) { Value32 = REG_RD (pDevice, Grc.EepromData); *pData = Value32; return LM_STATUS_SUCCESS; } return LM_STATUS_FAILURE; } /* LM_EepromRead */ /******************************************************************************/ /* Description: */ /* */ /* Return: */ /******************************************************************************/ STATIC LM_STATUS LM_NvramRead (PLM_DEVICE_BLOCK pDevice, LM_UINT32 Offset, LM_UINT32 * pData) { LM_UINT32 Value32; LM_STATUS Status; LM_UINT32 j; if (T3_ASIC_REV (pDevice->ChipRevId) == T3_ASIC_REV_5700 || T3_ASIC_REV (pDevice->ChipRevId) == T3_ASIC_REV_5701) { Status = LM_EepromRead (pDevice, Offset, pData); } else { /* Determine if we have flash or EEPROM. */ Value32 = REG_RD (pDevice, Nvram.Config1); if (Value32 & FLASH_INTERFACE_ENABLE) { if (Value32 & FLASH_SSRAM_BUFFERRED_MODE) { Offset = ((Offset / BUFFERED_FLASH_PAGE_SIZE) << BUFFERED_FLASH_PAGE_POS) + (Offset % BUFFERED_FLASH_PAGE_SIZE); } } REG_WR (pDevice, Nvram.SwArb, SW_ARB_REQ_SET1); for (j = 0; j < 1000; j++) { if (REG_RD (pDevice, Nvram.SwArb) & SW_ARB_GNT1) { break; } MM_Wait (20); } if (j == 1000) { return LM_STATUS_FAILURE; } /* Read from flash or EEPROM with the new 5703/02 interface. */ REG_WR (pDevice, Nvram.Addr, Offset & NVRAM_ADDRESS_MASK); REG_WR (pDevice, Nvram.Cmd, NVRAM_CMD_RD | NVRAM_CMD_DO_IT | NVRAM_CMD_FIRST | NVRAM_CMD_LAST | NVRAM_CMD_DONE); /* Wait for the done bit to clear. */ for (j = 0; j < 500; j++) { MM_Wait (10); Value32 = REG_RD (pDevice, Nvram.Cmd); if (!(Value32 & NVRAM_CMD_DONE)) { break; } } /* Wait for the done bit. */ if (!(Value32 & NVRAM_CMD_DONE)) { for (j = 0; j < 500; j++) { MM_Wait (10); Value32 = REG_RD (pDevice, Nvram.Cmd); if (Value32 & NVRAM_CMD_DONE) { MM_Wait (10); *pData = REG_RD (pDevice, Nvram.ReadData); /* Change the endianess. */ *pData = ((*pData & 0xff) << 24) | ((*pData & 0xff00) << 8) | ((*pData & 0xff0000) >> 8) | ((*pData >> 24) & 0xff); break; } } } REG_WR (pDevice, Nvram.SwArb, SW_ARB_REQ_CLR1); if (Value32 & NVRAM_CMD_DONE) { Status = LM_STATUS_SUCCESS; } else { Status = LM_STATUS_FAILURE; } } return Status; } /* LM_NvramRead */ STATIC void LM_ReadVPD (PLM_DEVICE_BLOCK pDevice) { LM_UINT32 Vpd_arr[256 / 4]; LM_UINT8 *Vpd = (LM_UINT8 *) & Vpd_arr[0]; LM_UINT32 *Vpd_dptr = &Vpd_arr[0]; LM_UINT32 Value32; unsigned int j; /* Read PN from VPD */ for (j = 0; j < 256; j += 4, Vpd_dptr++) { if (LM_NvramRead (pDevice, 0x100 + j, &Value32) != LM_STATUS_SUCCESS) { printf ("BCM570x: LM_ReadVPD: VPD read failed" " (no EEPROM onboard)\n"); return; } *Vpd_dptr = cpu_to_le32 (Value32); } for (j = 0; j < 256;) { unsigned int Vpd_r_len; unsigned int Vpd_r_end; if ((Vpd[j] == 0x82) || (Vpd[j] == 0x91)) { j = j + 3 + Vpd[j + 1] + (Vpd[j + 2] << 8); } else if (Vpd[j] == 0x90) { Vpd_r_len = Vpd[j + 1] + (Vpd[j + 2] << 8); j += 3; Vpd_r_end = Vpd_r_len + j; while (j < Vpd_r_end) { if ((Vpd[j] == 'P') && (Vpd[j + 1] == 'N')) { unsigned int len = Vpd[j + 2]; if (len <= 24) { memcpy (pDevice->PartNo, &Vpd[j + 3], len); } break; } else { if (Vpd[j + 2] == 0) { break; } j = j + Vpd[j + 2]; } } break; } else { break; } } } STATIC void LM_ReadBootCodeVersion (PLM_DEVICE_BLOCK pDevice) { LM_UINT32 Value32, offset, ver_offset; int i; if (LM_NvramRead (pDevice, 0x0, &Value32) != LM_STATUS_SUCCESS) return; if (Value32 != 0xaa559966) return; if (LM_NvramRead (pDevice, 0xc, &offset) != LM_STATUS_SUCCESS) return; offset = ((offset & 0xff) << 24) | ((offset & 0xff00) << 8) | ((offset & 0xff0000) >> 8) | ((offset >> 24) & 0xff); if (LM_NvramRead (pDevice, offset, &Value32) != LM_STATUS_SUCCESS) return; if ((Value32 == 0x0300000e) && (LM_NvramRead (pDevice, offset + 4, &Value32) == LM_STATUS_SUCCESS) && (Value32 == 0)) { if (LM_NvramRead (pDevice, offset + 8, &ver_offset) != LM_STATUS_SUCCESS) return; ver_offset = ((ver_offset & 0xff0000) >> 8) | ((ver_offset >> 24) & 0xff); for (i = 0; i < 16; i += 4) { if (LM_NvramRead (pDevice, offset + ver_offset + i, &Value32) != LM_STATUS_SUCCESS) { return; } *((LM_UINT32 *) & pDevice->BootCodeVer[i]) = cpu_to_le32 (Value32); } } else { char c; if (LM_NvramRead (pDevice, 0x94, &Value32) != LM_STATUS_SUCCESS) return; i = 0; c = ((Value32 & 0xff0000) >> 16); if (c < 10) { pDevice->BootCodeVer[i++] = c + '0'; } else { pDevice->BootCodeVer[i++] = (c / 10) + '0'; pDevice->BootCodeVer[i++] = (c % 10) + '0'; } pDevice->BootCodeVer[i++] = '.'; c = (Value32 & 0xff000000) >> 24; if (c < 10) { pDevice->BootCodeVer[i++] = c + '0'; } else { pDevice->BootCodeVer[i++] = (c / 10) + '0'; pDevice->BootCodeVer[i++] = (c % 10) + '0'; } pDevice->BootCodeVer[i] = 0; } } STATIC void LM_GetBusSpeed (PLM_DEVICE_BLOCK pDevice) { LM_UINT32 PciState = pDevice->PciState; LM_UINT32 ClockCtrl; char *SpeedStr = ""; if (PciState & T3_PCI_STATE_32BIT_PCI_BUS) { strcpy (pDevice->BusSpeedStr, "32-bit "); } else { strcpy (pDevice->BusSpeedStr, "64-bit "); } if (PciState & T3_PCI_STATE_CONVENTIONAL_PCI_MODE) { strcat (pDevice->BusSpeedStr, "PCI "); if (PciState & T3_PCI_STATE_HIGH_BUS_SPEED) { SpeedStr = "66MHz"; } else { SpeedStr = "33MHz"; } } else { strcat (pDevice->BusSpeedStr, "PCIX "); if (pDevice->BondId == GRC_MISC_BD_ID_5704CIOBE) { SpeedStr = "133MHz"; } else { ClockCtrl = REG_RD (pDevice, PciCfg.ClockCtrl) & 0x1f; switch (ClockCtrl) { case 0: SpeedStr = "33MHz"; break; case 2: SpeedStr = "50MHz"; break; case 4: SpeedStr = "66MHz"; break; case 6: SpeedStr = "100MHz"; break; case 7: SpeedStr = "133MHz"; break; } } } strcat (pDevice->BusSpeedStr, SpeedStr); } /******************************************************************************/ /* Description: */ /* This routine initializes default parameters and reads the PCI */ /* configurations. */ /* */ /* Return: */ /* LM_STATUS_SUCCESS */ /******************************************************************************/ LM_STATUS LM_GetAdapterInfo (PLM_DEVICE_BLOCK pDevice) { PLM_ADAPTER_INFO pAdapterInfo; LM_UINT32 Value32; LM_STATUS Status; LM_UINT32 j; LM_UINT32 EeSigFound; LM_UINT32 EePhyTypeSerdes = 0; LM_UINT32 EePhyLedMode = 0; LM_UINT32 EePhyId = 0; /* Get Device Id and Vendor Id */ Status = MM_ReadConfig32 (pDevice, PCI_VENDOR_ID_REG, &Value32); if (Status != LM_STATUS_SUCCESS) { return Status; } pDevice->PciVendorId = (LM_UINT16) Value32; pDevice->PciDeviceId = (LM_UINT16) (Value32 >> 16); /* If we are not getting the write adapter, exit. */ if ((Value32 != T3_PCI_ID_BCM5700) && (Value32 != T3_PCI_ID_BCM5701) && (Value32 != T3_PCI_ID_BCM5702) && (Value32 != T3_PCI_ID_BCM5702x) && (Value32 != T3_PCI_ID_BCM5702FE) && (Value32 != T3_PCI_ID_BCM5703) && (Value32 != T3_PCI_ID_BCM5703x) && (Value32 != T3_PCI_ID_BCM5704)) { return LM_STATUS_FAILURE; } Status = MM_ReadConfig32 (pDevice, PCI_REV_ID_REG, &Value32); if (Status != LM_STATUS_SUCCESS) { return Status; } pDevice->PciRevId = (LM_UINT8) Value32; /* Get IRQ. */ Status = MM_ReadConfig32 (pDevice, PCI_INT_LINE_REG, &Value32); if (Status != LM_STATUS_SUCCESS) { return Status; } pDevice->Irq = (LM_UINT8) Value32; /* Get interrupt pin. */ pDevice->IntPin = (LM_UINT8) (Value32 >> 8); /* Get chip revision id. */ Status = MM_ReadConfig32 (pDevice, T3_PCI_MISC_HOST_CTRL_REG, &Value32); pDevice->ChipRevId = Value32 >> 16; /* Get subsystem vendor. */ Status = MM_ReadConfig32 (pDevice, PCI_SUBSYSTEM_VENDOR_ID_REG, &Value32); if (Status != LM_STATUS_SUCCESS) { return Status; } pDevice->SubsystemVendorId = (LM_UINT16) Value32; /* Get PCI subsystem id. */ pDevice->SubsystemId = (LM_UINT16) (Value32 >> 16); /* Get the cache line size. */ MM_ReadConfig32 (pDevice, PCI_CACHE_LINE_SIZE_REG, &Value32); pDevice->CacheLineSize = (LM_UINT8) Value32; pDevice->SavedCacheLineReg = Value32; if (pDevice->ChipRevId != T3_CHIP_ID_5703_A1 && pDevice->ChipRevId != T3_CHIP_ID_5703_A2 && pDevice->ChipRevId != T3_CHIP_ID_5704_A0) { pDevice->UndiFix = FALSE; } #if !PCIX_TARGET_WORKAROUND pDevice->UndiFix = FALSE; #endif /* Map the memory base to system address space. */ if (!pDevice->UndiFix) { Status = MM_MapMemBase (pDevice); if (Status != LM_STATUS_SUCCESS) { return Status; } /* Initialize the memory view pointer. */ pDevice->pMemView = (PT3_STD_MEM_MAP) pDevice->pMappedMemBase; } #if PCIX_TARGET_WORKAROUND /* store whether we are in PCI are PCI-X mode */ pDevice->EnablePciXFix = FALSE; MM_ReadConfig32 (pDevice, T3_PCI_STATE_REG, &Value32); if ((Value32 & T3_PCI_STATE_CONVENTIONAL_PCI_MODE) == 0) { /* Enable PCI-X workaround only if we are running on 5700 BX. */ if (T3_CHIP_REV (pDevice->ChipRevId) == T3_CHIP_REV_5700_BX) { pDevice->EnablePciXFix = TRUE; } } if (pDevice->UndiFix) { pDevice->EnablePciXFix = TRUE; } #endif /* Bx bug: due to the "byte_enable bug" in PCI-X mode, the power */ /* management register may be clobbered which may cause the */ /* BCM5700 to go into D3 state. While in this state, we will */ /* not have memory mapped register access. As a workaround, we */ /* need to restore the device to D0 state. */ MM_ReadConfig32 (pDevice, T3_PCI_PM_STATUS_CTRL_REG, &Value32); Value32 |= T3_PM_PME_ASSERTED; Value32 &= ~T3_PM_POWER_STATE_MASK; Value32 |= T3_PM_POWER_STATE_D0; MM_WriteConfig32 (pDevice, T3_PCI_PM_STATUS_CTRL_REG, Value32); /* read the current PCI command word */ MM_ReadConfig32 (pDevice, PCI_COMMAND_REG, &Value32); /* Make sure bus-mastering is enabled. */ Value32 |= PCI_BUSMASTER_ENABLE; #if PCIX_TARGET_WORKAROUND /* if we are in PCI-X mode, also make sure mem-mapping and SERR#/PERR# are enabled */ if (pDevice->EnablePciXFix == TRUE) { Value32 |= (PCI_MEM_SPACE_ENABLE | PCI_SYSTEM_ERROR_ENABLE | PCI_PARITY_ERROR_ENABLE); } if (pDevice->UndiFix) { Value32 &= ~PCI_MEM_SPACE_ENABLE; } #endif if (pDevice->EnableMWI) { Value32 |= PCI_MEMORY_WRITE_INVALIDATE; } else { Value32 &= (~PCI_MEMORY_WRITE_INVALIDATE); } /* Error out if mem-mapping is NOT enabled for PCI systems */ if (!(Value32 | PCI_MEM_SPACE_ENABLE)) { return LM_STATUS_FAILURE; } /* save the value we are going to write into the PCI command word */ pDevice->PciCommandStatusWords = Value32; Status = MM_WriteConfig32 (pDevice, PCI_COMMAND_REG, Value32); if (Status != LM_STATUS_SUCCESS) { return Status; } /* Set power state to D0. */ LM_SetPowerState (pDevice, LM_POWER_STATE_D0); #ifdef BIG_ENDIAN_PCI pDevice->MiscHostCtrl = MISC_HOST_CTRL_MASK_PCI_INT | MISC_HOST_CTRL_ENABLE_INDIRECT_ACCESS | MISC_HOST_CTRL_ENABLE_ENDIAN_WORD_SWAP | MISC_HOST_CTRL_ENABLE_PCI_STATE_REG_RW; #else /* No CPU Swap modes for PCI IO */ /* Setup the mode registers. */ pDevice->MiscHostCtrl = MISC_HOST_CTRL_MASK_PCI_INT | MISC_HOST_CTRL_ENABLE_ENDIAN_WORD_SWAP | #ifdef BIG_ENDIAN_HOST MISC_HOST_CTRL_ENABLE_ENDIAN_BYTE_SWAP | #endif /* BIG_ENDIAN_HOST */ MISC_HOST_CTRL_ENABLE_INDIRECT_ACCESS | MISC_HOST_CTRL_ENABLE_PCI_STATE_REG_RW; #endif /* !BIG_ENDIAN_PCI */ /* write to PCI misc host ctr first in order to enable indirect accesses */ MM_WriteConfig32 (pDevice, T3_PCI_MISC_HOST_CTRL_REG, pDevice->MiscHostCtrl); REG_WR (pDevice, PciCfg.MiscHostCtrl, pDevice->MiscHostCtrl); #ifdef BIG_ENDIAN_PCI Value32 = GRC_MODE_WORD_SWAP_DATA | GRC_MODE_WORD_SWAP_NON_FRAME_DATA; #else /* No CPU Swap modes for PCI IO */ #ifdef BIG_ENDIAN_HOST Value32 = GRC_MODE_BYTE_SWAP_NON_FRAME_DATA | GRC_MODE_WORD_SWAP_NON_FRAME_DATA; #else Value32 = GRC_MODE_BYTE_SWAP_NON_FRAME_DATA | GRC_MODE_BYTE_SWAP_DATA; #endif #endif /* !BIG_ENDIAN_PCI */ REG_WR (pDevice, Grc.Mode, Value32); if (T3_ASIC_REV (pDevice->ChipRevId) == T3_ASIC_REV_5700) { REG_WR (pDevice, Grc.LocalCtrl, GRC_MISC_LOCAL_CTRL_GPIO_OUTPUT1 | GRC_MISC_LOCAL_CTRL_GPIO_OE1); } MM_Wait (40); /* Enable indirect memory access */ REG_WR (pDevice, MemArbiter.Mode, T3_MEM_ARBITER_MODE_ENABLE); if (REG_RD (pDevice, PciCfg.ClockCtrl) & T3_PCI_44MHZ_CORE_CLOCK) { REG_WR (pDevice, PciCfg.ClockCtrl, T3_PCI_44MHZ_CORE_CLOCK | T3_PCI_SELECT_ALTERNATE_CLOCK); REG_WR (pDevice, PciCfg.ClockCtrl, T3_PCI_SELECT_ALTERNATE_CLOCK); MM_Wait (40); /* required delay is 27usec */ } REG_WR (pDevice, PciCfg.ClockCtrl, 0); REG_WR (pDevice, PciCfg.MemWindowBaseAddr, 0); #if PCIX_TARGET_WORKAROUND MM_ReadConfig32 (pDevice, T3_PCI_STATE_REG, &Value32); if ((pDevice->EnablePciXFix == FALSE) && ((Value32 & T3_PCI_STATE_CONVENTIONAL_PCI_MODE) == 0)) { if (pDevice->ChipRevId == T3_CHIP_ID_5701_A0 || pDevice->ChipRevId == T3_CHIP_ID_5701_B0 || pDevice->ChipRevId == T3_CHIP_ID_5701_B2 || pDevice->ChipRevId == T3_CHIP_ID_5701_B5) { __raw_writel (0, &(pDevice->pMemView->uIntMem. MemBlock32K[0x300])); __raw_writel (0, &(pDevice->pMemView->uIntMem. MemBlock32K[0x301])); __raw_writel (0xffffffff, &(pDevice->pMemView->uIntMem. MemBlock32K[0x301])); if (__raw_readl (&(pDevice->pMemView->uIntMem.MemBlock32K[0x300]))) { pDevice->EnablePciXFix = TRUE; } } } #endif #if 1 /* * This code was at the beginning of else block below, but that's * a bug if node address in shared memory. */ MM_Wait (50); LM_NvramInit (pDevice); #endif /* Get the node address. First try to get in from the shared memory. */ /* If the signature is not present, then get it from the NVRAM. */ Value32 = MEM_RD_OFFSET (pDevice, T3_MAC_ADDR_HIGH_MAILBOX); if ((Value32 >> 16) == 0x484b) { pDevice->NodeAddress[0] = (LM_UINT8) (Value32 >> 8); pDevice->NodeAddress[1] = (LM_UINT8) Value32; Value32 = MEM_RD_OFFSET (pDevice, T3_MAC_ADDR_LOW_MAILBOX); pDevice->NodeAddress[2] = (LM_UINT8) (Value32 >> 24); pDevice->NodeAddress[3] = (LM_UINT8) (Value32 >> 16); pDevice->NodeAddress[4] = (LM_UINT8) (Value32 >> 8); pDevice->NodeAddress[5] = (LM_UINT8) Value32; Status = LM_STATUS_SUCCESS; } else { Status = LM_NvramRead (pDevice, 0x7c, &Value32); if (Status == LM_STATUS_SUCCESS) { pDevice->NodeAddress[0] = (LM_UINT8) (Value32 >> 16); pDevice->NodeAddress[1] = (LM_UINT8) (Value32 >> 24); Status = LM_NvramRead (pDevice, 0x80, &Value32); pDevice->NodeAddress[2] = (LM_UINT8) Value32; pDevice->NodeAddress[3] = (LM_UINT8) (Value32 >> 8); pDevice->NodeAddress[4] = (LM_UINT8) (Value32 >> 16); pDevice->NodeAddress[5] = (LM_UINT8) (Value32 >> 24); } } /* Assign a default address. */ if (Status != LM_STATUS_SUCCESS) { #ifndef EMBEDDED printk (KERN_ERR "Cannot get MAC addr from NVRAM. Using default.\n"); #endif pDevice->NodeAddress[0] = 0x00; pDevice->NodeAddress[1] = 0x10; pDevice->NodeAddress[2] = 0x18; pDevice->NodeAddress[3] = 0x68; pDevice->NodeAddress[4] = 0x61; pDevice->NodeAddress[5] = 0x76; } pDevice->PermanentNodeAddress[0] = pDevice->NodeAddress[0]; pDevice->PermanentNodeAddress[1] = pDevice->NodeAddress[1]; pDevice->PermanentNodeAddress[2] = pDevice->NodeAddress[2]; pDevice->PermanentNodeAddress[3] = pDevice->NodeAddress[3]; pDevice->PermanentNodeAddress[4] = pDevice->NodeAddress[4]; pDevice->PermanentNodeAddress[5] = pDevice->NodeAddress[5]; /* Initialize the default values. */ pDevice->NoTxPseudoHdrChksum = FALSE; pDevice->NoRxPseudoHdrChksum = FALSE; pDevice->NicSendBd = FALSE; pDevice->TxPacketDescCnt = DEFAULT_TX_PACKET_DESC_COUNT; pDevice->RxStdDescCnt = DEFAULT_STD_RCV_DESC_COUNT; pDevice->RxCoalescingTicks = DEFAULT_RX_COALESCING_TICKS; pDevice->TxCoalescingTicks = DEFAULT_TX_COALESCING_TICKS; pDevice->RxMaxCoalescedFrames = DEFAULT_RX_MAX_COALESCED_FRAMES; pDevice->TxMaxCoalescedFrames = DEFAULT_TX_MAX_COALESCED_FRAMES; pDevice->RxCoalescingTicksDuringInt = BAD_DEFAULT_VALUE; pDevice->TxCoalescingTicksDuringInt = BAD_DEFAULT_VALUE; pDevice->RxMaxCoalescedFramesDuringInt = BAD_DEFAULT_VALUE; pDevice->TxMaxCoalescedFramesDuringInt = BAD_DEFAULT_VALUE; pDevice->StatsCoalescingTicks = DEFAULT_STATS_COALESCING_TICKS; pDevice->EnableMWI = FALSE; pDevice->TxMtu = MAX_ETHERNET_PACKET_SIZE_NO_CRC; pDevice->RxMtu = MAX_ETHERNET_PACKET_SIZE_NO_CRC; pDevice->DisableAutoNeg = FALSE; pDevice->PhyIntMode = T3_PHY_INT_MODE_AUTO; pDevice->LinkChngMode = T3_LINK_CHNG_MODE_AUTO; pDevice->LedMode = LED_MODE_AUTO; pDevice->ResetPhyOnInit = TRUE; pDevice->DelayPciGrant = TRUE; pDevice->UseTaggedStatus = FALSE; pDevice->OneDmaAtOnce = BAD_DEFAULT_VALUE; pDevice->DmaMbufLowMark = T3_DEF_DMA_MBUF_LOW_WMARK_JUMBO; pDevice->RxMacMbufLowMark = T3_DEF_RX_MAC_MBUF_LOW_WMARK_JUMBO; pDevice->MbufHighMark = T3_DEF_MBUF_HIGH_WMARK_JUMBO; pDevice->RequestedMediaType = LM_REQUESTED_MEDIA_TYPE_AUTO; pDevice->TaskOffloadCap = LM_TASK_OFFLOAD_NONE; pDevice->FlowControlCap = LM_FLOW_CONTROL_AUTO_PAUSE; pDevice->EnableTbi = FALSE; #if INCLUDE_TBI_SUPPORT pDevice->PollTbiLink = BAD_DEFAULT_VALUE; #endif switch (T3_ASIC_REV (pDevice->ChipRevId)) { case T3_ASIC_REV_5704: pDevice->MbufBase = T3_NIC_MBUF_POOL_ADDR; pDevice->MbufSize = T3_NIC_MBUF_POOL_SIZE64; break; default: pDevice->MbufBase = T3_NIC_MBUF_POOL_ADDR; pDevice->MbufSize = T3_NIC_MBUF_POOL_SIZE96; break; } pDevice->LinkStatus = LM_STATUS_LINK_DOWN; pDevice->QueueRxPackets = TRUE; pDevice->EnableWireSpeed = TRUE; #if T3_JUMBO_RCV_RCB_ENTRY_COUNT pDevice->RxJumboDescCnt = DEFAULT_JUMBO_RCV_DESC_COUNT; #endif /* T3_JUMBO_RCV_RCB_ENTRY_COUNT */ /* Make this is a known adapter. */ pAdapterInfo = LM_GetAdapterInfoBySsid (pDevice->SubsystemVendorId, pDevice->SubsystemId); pDevice->BondId = REG_RD (pDevice, Grc.MiscCfg) & GRC_MISC_BD_ID_MASK; if (pDevice->BondId != GRC_MISC_BD_ID_5700 && pDevice->BondId != GRC_MISC_BD_ID_5701 && pDevice->BondId != GRC_MISC_BD_ID_5702FE && pDevice->BondId != GRC_MISC_BD_ID_5703 && pDevice->BondId != GRC_MISC_BD_ID_5703S && pDevice->BondId != GRC_MISC_BD_ID_5704 && pDevice->BondId != GRC_MISC_BD_ID_5704CIOBE) { return LM_STATUS_UNKNOWN_ADAPTER; } pDevice->SplitModeEnable = SPLIT_MODE_DISABLE; if ((pDevice->ChipRevId == T3_CHIP_ID_5704_A0) && (pDevice->BondId == GRC_MISC_BD_ID_5704CIOBE)) { pDevice->SplitModeEnable = SPLIT_MODE_ENABLE; pDevice->SplitModeMaxReq = SPLIT_MODE_5704_MAX_REQ; } /* Get Eeprom info. */ Value32 = MEM_RD_OFFSET (pDevice, T3_NIC_DATA_SIG_ADDR); if (Value32 == T3_NIC_DATA_SIG) { EeSigFound = TRUE; Value32 = MEM_RD_OFFSET (pDevice, T3_NIC_DATA_NIC_CFG_ADDR); /* Determine PHY type. */ switch (Value32 & T3_NIC_CFG_PHY_TYPE_MASK) { case T3_NIC_CFG_PHY_TYPE_COPPER: EePhyTypeSerdes = FALSE; break; case T3_NIC_CFG_PHY_TYPE_FIBER: EePhyTypeSerdes = TRUE; break; default: EePhyTypeSerdes = FALSE; break; } /* Determine PHY led mode. */ if (T3_ASIC_REV (pDevice->ChipRevId) == T3_ASIC_REV_5700 || T3_ASIC_REV (pDevice->ChipRevId) == T3_ASIC_REV_5701) { switch (Value32 & T3_NIC_CFG_LED_MODE_MASK) { case T3_NIC_CFG_LED_MODE_TRIPLE_SPEED: EePhyLedMode = LED_MODE_THREE_LINK; break; case T3_NIC_CFG_LED_MODE_LINK_SPEED: EePhyLedMode = LED_MODE_LINK10; break; default: EePhyLedMode = LED_MODE_AUTO; break; } } else { switch (Value32 & T3_NIC_CFG_LED_MODE_MASK) { case T3_NIC_CFG_LED_MODE_OPEN_DRAIN: EePhyLedMode = LED_MODE_OPEN_DRAIN; break; case T3_NIC_CFG_LED_MODE_OUTPUT: EePhyLedMode = LED_MODE_OUTPUT; break; default: EePhyLedMode = LED_MODE_AUTO; break; } } if (pDevice->ChipRevId == T3_CHIP_ID_5703_A1 || pDevice->ChipRevId == T3_CHIP_ID_5703_A2) { /* Enable EEPROM write protection. */ if (Value32 & T3_NIC_EEPROM_WP) { pDevice->EepromWp = TRUE; } } /* Get the PHY Id. */ Value32 = MEM_RD_OFFSET (pDevice, T3_NIC_DATA_PHY_ID_ADDR); if (Value32) { EePhyId = (((Value32 & T3_NIC_PHY_ID1_MASK) >> 16) & PHY_ID1_OUI_MASK) << 10; Value32 = Value32 & T3_NIC_PHY_ID2_MASK; EePhyId |= ((Value32 & PHY_ID2_OUI_MASK) << 16) | (Value32 & PHY_ID2_MODEL_MASK) | (Value32 & PHY_ID2_REV_MASK); } else { EePhyId = 0; } } else { EeSigFound = FALSE; } /* Set the PHY address. */ pDevice->PhyAddr = PHY_DEVICE_ID; /* Disable auto polling. */ pDevice->MiMode = 0xc0000; REG_WR (pDevice, MacCtrl.MiMode, pDevice->MiMode); MM_Wait (40); /* Get the PHY id. */ LM_ReadPhy (pDevice, PHY_ID1_REG, &Value32); pDevice->PhyId = (Value32 & PHY_ID1_OUI_MASK) << 10; LM_ReadPhy (pDevice, PHY_ID2_REG, &Value32); pDevice->PhyId |= ((Value32 & PHY_ID2_OUI_MASK) << 16) | (Value32 & PHY_ID2_MODEL_MASK) | (Value32 & PHY_ID2_REV_MASK); /* Set the EnableTbi flag to false if we have a copper PHY. */ switch (pDevice->PhyId & PHY_ID_MASK) { case PHY_BCM5400_PHY_ID: pDevice->EnableTbi = FALSE; break; case PHY_BCM5401_PHY_ID: pDevice->EnableTbi = FALSE; break; case PHY_BCM5411_PHY_ID: pDevice->EnableTbi = FALSE; break; case PHY_BCM5701_PHY_ID: pDevice->EnableTbi = FALSE; break; case PHY_BCM5703_PHY_ID: pDevice->EnableTbi = FALSE; break; case PHY_BCM5704_PHY_ID: pDevice->EnableTbi = FALSE; break; case PHY_BCM8002_PHY_ID: pDevice->EnableTbi = TRUE; break; default: if (pAdapterInfo) { pDevice->PhyId = pAdapterInfo->PhyId; pDevice->EnableTbi = pAdapterInfo->Serdes; } else if (EeSigFound) { pDevice->PhyId = EePhyId; pDevice->EnableTbi = EePhyTypeSerdes; } break; } /* Bail out if we don't know the copper PHY id. */ if (UNKNOWN_PHY_ID (pDevice->PhyId) && !pDevice->EnableTbi) { return LM_STATUS_FAILURE; } if (T3_ASIC_REV (pDevice->ChipRevId) == T3_ASIC_REV_5703) { if ((pDevice->SavedCacheLineReg & 0xff00) < 0x4000) { pDevice->SavedCacheLineReg &= 0xffff00ff; pDevice->SavedCacheLineReg |= 0x4000; } } /* Change driver parameters. */ Status = MM_GetConfig (pDevice); if (Status != LM_STATUS_SUCCESS) { return Status; } #if INCLUDE_5701_AX_FIX if (pDevice->ChipRevId == T3_CHIP_ID_5701_A0 || pDevice->ChipRevId == T3_CHIP_ID_5701_B0) { pDevice->ResetPhyOnInit = TRUE; } #endif /* Save the current phy link status. */ if (!pDevice->EnableTbi) { LM_ReadPhy (pDevice, PHY_STATUS_REG, &Value32); LM_ReadPhy (pDevice, PHY_STATUS_REG, &Value32); /* If we don't have link reset the PHY. */ if (!(Value32 & PHY_STATUS_LINK_PASS) || pDevice->ResetPhyOnInit) { LM_WritePhy (pDevice, PHY_CTRL_REG, PHY_CTRL_PHY_RESET); for (j = 0; j < 100; j++) { MM_Wait (10); LM_ReadPhy (pDevice, PHY_CTRL_REG, &Value32); if (Value32 && !(Value32 & PHY_CTRL_PHY_RESET)) { MM_Wait (40); break; } } #if INCLUDE_5701_AX_FIX /* 5701_AX_BX bug: only advertises 10mb speed. */ if (pDevice->ChipRevId == T3_CHIP_ID_5701_A0 || pDevice->ChipRevId == T3_CHIP_ID_5701_B0) { Value32 = PHY_AN_AD_PROTOCOL_802_3_CSMA_CD | PHY_AN_AD_10BASET_HALF | PHY_AN_AD_10BASET_FULL | PHY_AN_AD_100BASETX_FULL | PHY_AN_AD_100BASETX_HALF; Value32 |= GetPhyAdFlowCntrlSettings (pDevice); LM_WritePhy (pDevice, PHY_AN_AD_REG, Value32); pDevice->advertising = Value32; Value32 = BCM540X_AN_AD_1000BASET_HALF | BCM540X_AN_AD_1000BASET_FULL | BCM540X_CONFIG_AS_MASTER | BCM540X_ENABLE_CONFIG_AS_MASTER; LM_WritePhy (pDevice, BCM540X_1000BASET_CTRL_REG, Value32); pDevice->advertising1000 = Value32; LM_WritePhy (pDevice, PHY_CTRL_REG, PHY_CTRL_AUTO_NEG_ENABLE | PHY_CTRL_RESTART_AUTO_NEG); } #endif if (T3_ASIC_REV (pDevice->ChipRevId) == T3_ASIC_REV_5703) { LM_WritePhy (pDevice, 0x18, 0x0c00); LM_WritePhy (pDevice, 0x17, 0x201f); LM_WritePhy (pDevice, 0x15, 0x2aaa); } if (pDevice->ChipRevId == T3_CHIP_ID_5704_A0) { LM_WritePhy (pDevice, 0x1c, 0x8d68); LM_WritePhy (pDevice, 0x1c, 0x8d68); } /* Enable Ethernet@WireSpeed. */ if (pDevice->EnableWireSpeed) { LM_WritePhy (pDevice, 0x18, 0x7007); LM_ReadPhy (pDevice, 0x18, &Value32); LM_WritePhy (pDevice, 0x18, Value32 | BIT_15 | BIT_4); } } } /* Turn off tap power management. */ if ((pDevice->PhyId & PHY_ID_MASK) == PHY_BCM5401_PHY_ID) { LM_WritePhy (pDevice, BCM5401_AUX_CTRL, 0x0c20); LM_WritePhy (pDevice, BCM540X_DSP_ADDRESS_REG, 0x0012); LM_WritePhy (pDevice, BCM540X_DSP_RW_PORT, 0x1804); LM_WritePhy (pDevice, BCM540X_DSP_ADDRESS_REG, 0x0013); LM_WritePhy (pDevice, BCM540X_DSP_RW_PORT, 0x1204); LM_WritePhy (pDevice, BCM540X_DSP_ADDRESS_REG, 0x8006); LM_WritePhy (pDevice, BCM540X_DSP_RW_PORT, 0x0132); LM_WritePhy (pDevice, BCM540X_DSP_ADDRESS_REG, 0x8006); LM_WritePhy (pDevice, BCM540X_DSP_RW_PORT, 0x0232); LM_WritePhy (pDevice, BCM540X_DSP_ADDRESS_REG, 0x201f); LM_WritePhy (pDevice, BCM540X_DSP_RW_PORT, 0x0a20); MM_Wait (40); } #if INCLUDE_TBI_SUPPORT pDevice->IgnoreTbiLinkChange = FALSE; if (pDevice->EnableTbi) { pDevice->WakeUpModeCap = LM_WAKE_UP_MODE_NONE; pDevice->PhyIntMode = T3_PHY_INT_MODE_LINK_READY; if ((pDevice->PollTbiLink == BAD_DEFAULT_VALUE) || pDevice->DisableAutoNeg) { pDevice->PollTbiLink = FALSE; } } else { pDevice->PollTbiLink = FALSE; } #endif /* INCLUDE_TBI_SUPPORT */ /* UseTaggedStatus is only valid for 5701 and later. */ if (T3_ASIC_REV (pDevice->ChipRevId) == T3_ASIC_REV_5700) { pDevice->UseTaggedStatus = FALSE; pDevice->CoalesceMode = 0; } else { pDevice->CoalesceMode = HOST_COALESCE_CLEAR_TICKS_ON_RX_BD_EVENT | HOST_COALESCE_CLEAR_TICKS_ON_TX_BD_EVENT; } /* Set the status block size. */ if (T3_CHIP_REV (pDevice->ChipRevId) != T3_CHIP_REV_5700_AX && T3_CHIP_REV (pDevice->ChipRevId) != T3_CHIP_REV_5700_BX) { pDevice->CoalesceMode |= HOST_COALESCE_32_BYTE_STATUS_MODE; } /* Check the DURING_INT coalescing ticks parameters. */ if (pDevice->UseTaggedStatus) { if (pDevice->RxCoalescingTicksDuringInt == BAD_DEFAULT_VALUE) { pDevice->RxCoalescingTicksDuringInt = DEFAULT_RX_COALESCING_TICKS_DURING_INT; } if (pDevice->TxCoalescingTicksDuringInt == BAD_DEFAULT_VALUE) { pDevice->TxCoalescingTicksDuringInt = DEFAULT_TX_COALESCING_TICKS_DURING_INT; } if (pDevice->RxMaxCoalescedFramesDuringInt == BAD_DEFAULT_VALUE) { pDevice->RxMaxCoalescedFramesDuringInt = DEFAULT_RX_MAX_COALESCED_FRAMES_DURING_INT; } if (pDevice->TxMaxCoalescedFramesDuringInt == BAD_DEFAULT_VALUE) { pDevice->TxMaxCoalescedFramesDuringInt = DEFAULT_TX_MAX_COALESCED_FRAMES_DURING_INT; } } else { if (pDevice->RxCoalescingTicksDuringInt == BAD_DEFAULT_VALUE) { pDevice->RxCoalescingTicksDuringInt = 0; } if (pDevice->TxCoalescingTicksDuringInt == BAD_DEFAULT_VALUE) { pDevice->TxCoalescingTicksDuringInt = 0; } if (pDevice->RxMaxCoalescedFramesDuringInt == BAD_DEFAULT_VALUE) { pDevice->RxMaxCoalescedFramesDuringInt = 0; } if (pDevice->TxMaxCoalescedFramesDuringInt == BAD_DEFAULT_VALUE) { pDevice->TxMaxCoalescedFramesDuringInt = 0; } } #if T3_JUMBO_RCV_RCB_ENTRY_COUNT if (pDevice->RxMtu <= (MAX_STD_RCV_BUFFER_SIZE - 8 /* CRC */ )) { pDevice->RxJumboDescCnt = 0; if (pDevice->RxMtu <= MAX_ETHERNET_PACKET_SIZE_NO_CRC) { pDevice->RxMtu = MAX_ETHERNET_PACKET_SIZE_NO_CRC; } } else { pDevice->RxJumboBufferSize = (pDevice->RxMtu + 8 /* CRC + VLAN */ + COMMON_CACHE_LINE_SIZE - 1) & ~COMMON_CACHE_LINE_MASK; if (pDevice->RxJumboBufferSize > MAX_JUMBO_RCV_BUFFER_SIZE) { pDevice->RxJumboBufferSize = DEFAULT_JUMBO_RCV_BUFFER_SIZE; pDevice->RxMtu = pDevice->RxJumboBufferSize - 8 /* CRC + VLAN */ ; } pDevice->TxMtu = pDevice->RxMtu; } #else pDevice->RxMtu = MAX_ETHERNET_PACKET_SIZE_NO_CRC; #endif /* T3_JUMBO_RCV_RCB_ENTRY_COUNT */ pDevice->RxPacketDescCnt = #if T3_JUMBO_RCV_RCB_ENTRY_COUNT pDevice->RxJumboDescCnt + #endif /* T3_JUMBO_RCV_RCB_ENTRY_COUNT */ pDevice->RxStdDescCnt; if (pDevice->TxMtu < MAX_ETHERNET_PACKET_SIZE_NO_CRC) { pDevice->TxMtu = MAX_ETHERNET_PACKET_SIZE_NO_CRC; } if (pDevice->TxMtu > MAX_JUMBO_TX_BUFFER_SIZE) { pDevice->TxMtu = MAX_JUMBO_TX_BUFFER_SIZE; } /* Configure the proper ways to get link change interrupt. */ if (pDevice->PhyIntMode == T3_PHY_INT_MODE_AUTO) { if (T3_ASIC_REV (pDevice->ChipRevId) == T3_ASIC_REV_5700) { pDevice->PhyIntMode = T3_PHY_INT_MODE_MI_INTERRUPT; } else { pDevice->PhyIntMode = T3_PHY_INT_MODE_LINK_READY; } } else if (pDevice->PhyIntMode == T3_PHY_INT_MODE_AUTO_POLLING) { /* Auto-polling does not work on 5700_AX and 5700_BX. */ if (T3_ASIC_REV (pDevice->ChipRevId) == T3_ASIC_REV_5700) { pDevice->PhyIntMode = T3_PHY_INT_MODE_MI_INTERRUPT; } } /* Determine the method to get link change status. */ if (pDevice->LinkChngMode == T3_LINK_CHNG_MODE_AUTO) { /* The link status bit in the status block does not work on 5700_AX */ /* and 5700_BX chips. */ if (T3_ASIC_REV (pDevice->ChipRevId) == T3_ASIC_REV_5700) { pDevice->LinkChngMode = T3_LINK_CHNG_MODE_USE_STATUS_REG; } else { pDevice->LinkChngMode = T3_LINK_CHNG_MODE_USE_STATUS_BLOCK; } } if (pDevice->PhyIntMode == T3_PHY_INT_MODE_MI_INTERRUPT || T3_ASIC_REV (pDevice->ChipRevId) == T3_ASIC_REV_5700) { pDevice->LinkChngMode = T3_LINK_CHNG_MODE_USE_STATUS_REG; } /* Configure PHY led mode. */ if (pDevice->LedMode == LED_MODE_AUTO) { if (T3_ASIC_REV (pDevice->ChipRevId) == T3_ASIC_REV_5700 || T3_ASIC_REV (pDevice->ChipRevId) == T3_ASIC_REV_5701) { if (pDevice->SubsystemVendorId == T3_SVID_DELL) { pDevice->LedMode = LED_MODE_LINK10; } else { pDevice->LedMode = LED_MODE_THREE_LINK; if (EeSigFound && EePhyLedMode != LED_MODE_AUTO) { pDevice->LedMode = EePhyLedMode; } } /* bug? 5701 in LINK10 mode does not seem to work when */ /* PhyIntMode is LINK_READY. */ if (T3_ASIC_REV (pDevice->ChipRevId) != T3_ASIC_REV_5700 && #if INCLUDE_TBI_SUPPORT pDevice->EnableTbi == FALSE && #endif pDevice->LedMode == LED_MODE_LINK10) { pDevice->PhyIntMode = T3_PHY_INT_MODE_MI_INTERRUPT; pDevice->LinkChngMode = T3_LINK_CHNG_MODE_USE_STATUS_REG; } if (pDevice->EnableTbi) { pDevice->LedMode = LED_MODE_THREE_LINK; } } else { if (EeSigFound && EePhyLedMode != LED_MODE_AUTO) { pDevice->LedMode = EePhyLedMode; } else { pDevice->LedMode = LED_MODE_OPEN_DRAIN; } } } /* Enable OneDmaAtOnce. */ if (pDevice->OneDmaAtOnce == BAD_DEFAULT_VALUE) { pDevice->OneDmaAtOnce = FALSE; } if (T3_ASIC_REV (pDevice->ChipRevId) == T3_ASIC_REV_5700 || pDevice->ChipRevId == T3_CHIP_ID_5701_A0 || pDevice->ChipRevId == T3_CHIP_ID_5701_B0 || pDevice->ChipRevId == T3_CHIP_ID_5701_B2) { pDevice->WolSpeed = WOL_SPEED_10MB; } else { pDevice->WolSpeed = WOL_SPEED_100MB; } /* Offloadings. */ pDevice->TaskToOffload = LM_TASK_OFFLOAD_NONE; /* Turn off task offloading on Ax. */ if (pDevice->ChipRevId == T3_CHIP_ID_5700_B0) { pDevice->TaskOffloadCap &= ~(LM_TASK_OFFLOAD_TX_TCP_CHECKSUM | LM_TASK_OFFLOAD_TX_UDP_CHECKSUM); } pDevice->PciState = REG_RD (pDevice, PciCfg.PciState); LM_ReadVPD (pDevice); LM_ReadBootCodeVersion (pDevice); LM_GetBusSpeed (pDevice); return LM_STATUS_SUCCESS; } /* LM_GetAdapterInfo */ STATIC PLM_ADAPTER_INFO LM_GetAdapterInfoBySsid (LM_UINT16 Svid, LM_UINT16 Ssid) { static LM_ADAPTER_INFO AdapterArr[] = { {T3_SVID_BROADCOM, T3_SSID_BROADCOM_BCM95700A6, PHY_BCM5401_PHY_ID, 0}, {T3_SVID_BROADCOM, T3_SSID_BROADCOM_BCM95701A5, PHY_BCM5701_PHY_ID, 0}, {T3_SVID_BROADCOM, T3_SSID_BROADCOM_BCM95700T6, PHY_BCM8002_PHY_ID, 1}, {T3_SVID_BROADCOM, T3_SSID_BROADCOM_BCM95700A9, 0, 1}, {T3_SVID_BROADCOM, T3_SSID_BROADCOM_BCM95701T1, PHY_BCM5701_PHY_ID, 0}, {T3_SVID_BROADCOM, T3_SSID_BROADCOM_BCM95701T8, PHY_BCM5701_PHY_ID, 0}, {T3_SVID_BROADCOM, T3_SSID_BROADCOM_BCM95701A7, 0, 1}, {T3_SVID_BROADCOM, T3_SSID_BROADCOM_BCM95701A10, PHY_BCM5701_PHY_ID, 0}, {T3_SVID_BROADCOM, T3_SSID_BROADCOM_BCM95701A12, PHY_BCM5701_PHY_ID, 0}, {T3_SVID_BROADCOM, T3_SSID_BROADCOM_BCM95703Ax1, PHY_BCM5701_PHY_ID, 0}, {T3_SVID_BROADCOM, T3_SSID_BROADCOM_BCM95703Ax2, PHY_BCM5701_PHY_ID, 0}, {T3_SVID_3COM, T3_SSID_3COM_3C996T, PHY_BCM5401_PHY_ID, 0}, {T3_SVID_3COM, T3_SSID_3COM_3C996BT, PHY_BCM5701_PHY_ID, 0}, {T3_SVID_3COM, T3_SSID_3COM_3C996SX, 0, 1}, {T3_SVID_3COM, T3_SSID_3COM_3C1000T, PHY_BCM5701_PHY_ID, 0}, {T3_SVID_3COM, T3_SSID_3COM_3C940BR01, PHY_BCM5701_PHY_ID, 0}, {T3_SVID_DELL, T3_SSID_DELL_VIPER, PHY_BCM5401_PHY_ID, 0}, {T3_SVID_DELL, T3_SSID_DELL_JAGUAR, PHY_BCM5401_PHY_ID, 0}, {T3_SVID_DELL, T3_SSID_DELL_MERLOT, PHY_BCM5411_PHY_ID, 0}, {T3_SVID_DELL, T3_SSID_DELL_SLIM_MERLOT, PHY_BCM5411_PHY_ID, 0}, {T3_SVID_COMPAQ, T3_SSID_COMPAQ_BANSHEE, PHY_BCM5701_PHY_ID, 0}, {T3_SVID_COMPAQ, T3_SSID_COMPAQ_BANSHEE_2, PHY_BCM5701_PHY_ID, 0}, {T3_SVID_COMPAQ, T3_SSID_COMPAQ_CHANGELING, 0, 1}, {T3_SVID_COMPAQ, T3_SSID_COMPAQ_NC7780, PHY_BCM5701_PHY_ID, 0}, {T3_SVID_COMPAQ, T3_SSID_COMPAQ_NC7780_2, PHY_BCM5701_PHY_ID, 0}, }; LM_UINT32 j; for (j = 0; j < sizeof (AdapterArr) / sizeof (LM_ADAPTER_INFO); j++) { if (AdapterArr[j].Svid == Svid && AdapterArr[j].Ssid == Ssid) { return &AdapterArr[j]; } } return NULL; } /******************************************************************************/ /* Description: */ /* This routine sets up receive/transmit buffer descriptions queues. */ /* */ /* Return: */ /* LM_STATUS_SUCCESS */ /******************************************************************************/ LM_STATUS LM_InitializeAdapter (PLM_DEVICE_BLOCK pDevice) { LM_PHYSICAL_ADDRESS MemPhy; PLM_UINT8 pMemVirt; PLM_PACKET pPacket; LM_STATUS Status; LM_UINT32 Size; LM_UINT32 j; /* Set power state to D0. */ LM_SetPowerState (pDevice, LM_POWER_STATE_D0); /* Intialize the queues. */ QQ_InitQueue (&pDevice->RxPacketReceivedQ.Container, MAX_RX_PACKET_DESC_COUNT); QQ_InitQueue (&pDevice->RxPacketFreeQ.Container, MAX_RX_PACKET_DESC_COUNT); QQ_InitQueue (&pDevice->TxPacketFreeQ.Container, MAX_TX_PACKET_DESC_COUNT); QQ_InitQueue (&pDevice->TxPacketActiveQ.Container, MAX_TX_PACKET_DESC_COUNT); QQ_InitQueue (&pDevice->TxPacketXmittedQ.Container, MAX_TX_PACKET_DESC_COUNT); /* Allocate shared memory for: status block, the buffers for receive */ /* rings -- standard, mini, jumbo, and return rings. */ Size = T3_STATUS_BLOCK_SIZE + sizeof (T3_STATS_BLOCK) + T3_STD_RCV_RCB_ENTRY_COUNT * sizeof (T3_RCV_BD) + #if T3_JUMBO_RCV_RCB_ENTRY_COUNT T3_JUMBO_RCV_RCB_ENTRY_COUNT * sizeof (T3_RCV_BD) + #endif /* T3_JUMBO_RCV_RCB_ENTRY_COUNT */ T3_RCV_RETURN_RCB_ENTRY_COUNT * sizeof (T3_RCV_BD); /* Memory for host based Send BD. */ if (pDevice->NicSendBd == FALSE) { Size += sizeof (T3_SND_BD) * T3_SEND_RCB_ENTRY_COUNT; } /* Allocate the memory block. */ Status = MM_AllocateSharedMemory (pDevice, Size, (PLM_VOID) & pMemVirt, &MemPhy, FALSE); if (Status != LM_STATUS_SUCCESS) { return Status; } /* Program DMA Read/Write */ if (pDevice->PciState & T3_PCI_STATE_NOT_PCI_X_BUS) { pDevice->DmaReadWriteCtrl = 0x763f000f; } else { if (T3_ASIC_REV (pDevice->ChipRevId) == T3_ASIC_REV_5704) { pDevice->DmaReadWriteCtrl = 0x761f0000; } else { pDevice->DmaReadWriteCtrl = 0x761b000f; } if (pDevice->ChipRevId == T3_CHIP_ID_5703_A1 || pDevice->ChipRevId == T3_CHIP_ID_5703_A2) { pDevice->OneDmaAtOnce = TRUE; } } if (T3_ASIC_REV (pDevice->ChipRevId) == T3_ASIC_REV_5703) { pDevice->DmaReadWriteCtrl &= 0xfffffff0; } if (pDevice->OneDmaAtOnce) { pDevice->DmaReadWriteCtrl |= DMA_CTRL_WRITE_ONE_DMA_AT_ONCE; } REG_WR (pDevice, PciCfg.DmaReadWriteCtrl, pDevice->DmaReadWriteCtrl); if (LM_DmaTest (pDevice, pMemVirt, MemPhy, 0x400) != LM_STATUS_SUCCESS) { return LM_STATUS_FAILURE; } /* Status block. */ pDevice->pStatusBlkVirt = (PT3_STATUS_BLOCK) pMemVirt; pDevice->StatusBlkPhy = MemPhy; pMemVirt += T3_STATUS_BLOCK_SIZE; LM_INC_PHYSICAL_ADDRESS (&MemPhy, T3_STATUS_BLOCK_SIZE); /* Statistics block. */ pDevice->pStatsBlkVirt = (PT3_STATS_BLOCK) pMemVirt; pDevice->StatsBlkPhy = MemPhy; pMemVirt += sizeof (T3_STATS_BLOCK); LM_INC_PHYSICAL_ADDRESS (&MemPhy, sizeof (T3_STATS_BLOCK)); /* Receive standard BD buffer. */ pDevice->pRxStdBdVirt = (PT3_RCV_BD) pMemVirt; pDevice->RxStdBdPhy = MemPhy; pMemVirt += T3_STD_RCV_RCB_ENTRY_COUNT * sizeof (T3_RCV_BD); LM_INC_PHYSICAL_ADDRESS (&MemPhy, T3_STD_RCV_RCB_ENTRY_COUNT * sizeof (T3_RCV_BD)); #if T3_JUMBO_RCV_RCB_ENTRY_COUNT /* Receive jumbo BD buffer. */ pDevice->pRxJumboBdVirt = (PT3_RCV_BD) pMemVirt; pDevice->RxJumboBdPhy = MemPhy; pMemVirt += T3_JUMBO_RCV_RCB_ENTRY_COUNT * sizeof (T3_RCV_BD); LM_INC_PHYSICAL_ADDRESS (&MemPhy, T3_JUMBO_RCV_RCB_ENTRY_COUNT * sizeof (T3_RCV_BD)); #endif /* T3_JUMBO_RCV_RCB_ENTRY_COUNT */ /* Receive return BD buffer. */ pDevice->pRcvRetBdVirt = (PT3_RCV_BD) pMemVirt; pDevice->RcvRetBdPhy = MemPhy; pMemVirt += T3_RCV_RETURN_RCB_ENTRY_COUNT * sizeof (T3_RCV_BD); LM_INC_PHYSICAL_ADDRESS (&MemPhy, T3_RCV_RETURN_RCB_ENTRY_COUNT * sizeof (T3_RCV_BD)); /* Set up Send BD. */ if (pDevice->NicSendBd == FALSE) { pDevice->pSendBdVirt = (PT3_SND_BD) pMemVirt; pDevice->SendBdPhy = MemPhy; pMemVirt += sizeof (T3_SND_BD) * T3_SEND_RCB_ENTRY_COUNT; LM_INC_PHYSICAL_ADDRESS (&MemPhy, sizeof (T3_SND_BD) * T3_SEND_RCB_ENTRY_COUNT); } else { pDevice->pSendBdVirt = (PT3_SND_BD) pDevice->pMemView->uIntMem.First32k.BufferDesc; pDevice->SendBdPhy.High = 0; pDevice->SendBdPhy.Low = T3_NIC_SND_BUFFER_DESC_ADDR; } /* Allocate memory for packet descriptors. */ Size = (pDevice->RxPacketDescCnt + pDevice->TxPacketDescCnt) * MM_PACKET_DESC_SIZE; Status = MM_AllocateMemory (pDevice, Size, (PLM_VOID *) & pPacket); if (Status != LM_STATUS_SUCCESS) { return Status; } pDevice->pPacketDescBase = (PLM_VOID) pPacket; /* Create transmit packet descriptors from the memory block and add them */ /* to the TxPacketFreeQ for each send ring. */ for (j = 0; j < pDevice->TxPacketDescCnt; j++) { /* Ring index. */ pPacket->Flags = 0; /* Queue the descriptor in the TxPacketFreeQ of the 'k' ring. */ QQ_PushTail (&pDevice->TxPacketFreeQ.Container, pPacket); /* Get the pointer to the next descriptor. MM_PACKET_DESC_SIZE */ /* is the total size of the packet descriptor including the */ /* os-specific extensions in the UM_PACKET structure. */ pPacket = (PLM_PACKET) ((PLM_UINT8) pPacket + MM_PACKET_DESC_SIZE); } /* for(j.. */ /* Create receive packet descriptors from the memory block and add them */ /* to the RxPacketFreeQ. Create the Standard packet descriptors. */ for (j = 0; j < pDevice->RxStdDescCnt; j++) { /* Receive producer ring. */ pPacket->u.Rx.RcvProdRing = T3_STD_RCV_PROD_RING; /* Receive buffer size. */ pPacket->u.Rx.RxBufferSize = MAX_STD_RCV_BUFFER_SIZE; /* Add the descriptor to RxPacketFreeQ. */ QQ_PushTail (&pDevice->RxPacketFreeQ.Container, pPacket); /* Get the pointer to the next descriptor. MM_PACKET_DESC_SIZE */ /* is the total size of the packet descriptor including the */ /* os-specific extensions in the UM_PACKET structure. */ pPacket = (PLM_PACKET) ((PLM_UINT8) pPacket + MM_PACKET_DESC_SIZE); } /* for */ #if T3_JUMBO_RCV_RCB_ENTRY_COUNT /* Create the Jumbo packet descriptors. */ for (j = 0; j < pDevice->RxJumboDescCnt; j++) { /* Receive producer ring. */ pPacket->u.Rx.RcvProdRing = T3_JUMBO_RCV_PROD_RING; /* Receive buffer size. */ pPacket->u.Rx.RxBufferSize = pDevice->RxJumboBufferSize; /* Add the descriptor to RxPacketFreeQ. */ QQ_PushTail (&pDevice->RxPacketFreeQ.Container, pPacket); /* Get the pointer to the next descriptor. MM_PACKET_DESC_SIZE */ /* is the total size of the packet descriptor including the */ /* os-specific extensions in the UM_PACKET structure. */ pPacket = (PLM_PACKET) ((PLM_UINT8) pPacket + MM_PACKET_DESC_SIZE); } /* for */ #endif /* T3_JUMBO_RCV_RCB_ENTRY_COUNT */ /* Initialize the rest of the packet descriptors. */ Status = MM_InitializeUmPackets (pDevice); if (Status != LM_STATUS_SUCCESS) { return Status; } /* if */ /* Default receive mask. */ pDevice->ReceiveMask = LM_ACCEPT_MULTICAST | LM_ACCEPT_BROADCAST | LM_ACCEPT_UNICAST; /* Make sure we are in the first 32k memory window or NicSendBd. */ REG_WR (pDevice, PciCfg.MemWindowBaseAddr, 0); /* Initialize the hardware. */ Status = LM_ResetAdapter (pDevice); if (Status != LM_STATUS_SUCCESS) { return Status; } /* We are done with initialization. */ pDevice->InitDone = TRUE; return LM_STATUS_SUCCESS; } /* LM_InitializeAdapter */ /******************************************************************************/ /* Description: */ /* This function Enables/Disables a given block. */ /* */ /* Return: */ /* LM_STATUS_SUCCESS */ /******************************************************************************/ LM_STATUS LM_CntrlBlock (PLM_DEVICE_BLOCK pDevice, LM_UINT32 mask, LM_UINT32 cntrl) { LM_UINT32 j, i, data; LM_UINT32 MaxWaitCnt; MaxWaitCnt = 2; j = 0; for (i = 0; i < 32; i++) { if (!(mask & (1 << i))) continue; switch (1 << i) { case T3_BLOCK_DMA_RD: data = REG_RD (pDevice, DmaRead.Mode); if (cntrl == LM_DISABLE) { data &= ~DMA_READ_MODE_ENABLE; REG_WR (pDevice, DmaRead.Mode, data); for (j = 0; j < MaxWaitCnt; j++) { if (! (REG_RD (pDevice, DmaRead.Mode) & DMA_READ_MODE_ENABLE)) break; MM_Wait (10); } } else REG_WR (pDevice, DmaRead.Mode, data | DMA_READ_MODE_ENABLE); break; case T3_BLOCK_DMA_COMP: data = REG_RD (pDevice, DmaComp.Mode); if (cntrl == LM_DISABLE) { data &= ~DMA_COMP_MODE_ENABLE; REG_WR (pDevice, DmaComp.Mode, data); for (j = 0; j < MaxWaitCnt; j++) { if (! (REG_RD (pDevice, DmaComp.Mode) & DMA_COMP_MODE_ENABLE)) break; MM_Wait (10); } } else REG_WR (pDevice, DmaComp.Mode, data | DMA_COMP_MODE_ENABLE); break; case T3_BLOCK_RX_BD_INITIATOR: data = REG_RD (pDevice, RcvBdIn.Mode); if (cntrl == LM_DISABLE) { data &= ~RCV_BD_IN_MODE_ENABLE; REG_WR (pDevice, RcvBdIn.Mode, data); for (j = 0; j < MaxWaitCnt; j++) { if (! (REG_RD (pDevice, RcvBdIn.Mode) & RCV_BD_IN_MODE_ENABLE)) break; MM_Wait (10); } } else REG_WR (pDevice, RcvBdIn.Mode, data | RCV_BD_IN_MODE_ENABLE); break; case T3_BLOCK_RX_BD_COMP: data = REG_RD (pDevice, RcvBdComp.Mode); if (cntrl == LM_DISABLE) { data &= ~RCV_BD_COMP_MODE_ENABLE; REG_WR (pDevice, RcvBdComp.Mode, data); for (j = 0; j < MaxWaitCnt; j++) { if (! (REG_RD (pDevice, RcvBdComp.Mode) & RCV_BD_COMP_MODE_ENABLE)) break; MM_Wait (10); } } else REG_WR (pDevice, RcvBdComp.Mode, data | RCV_BD_COMP_MODE_ENABLE); break; case T3_BLOCK_DMA_WR: data = REG_RD (pDevice, DmaWrite.Mode); if (cntrl == LM_DISABLE) { data &= ~DMA_WRITE_MODE_ENABLE; REG_WR (pDevice, DmaWrite.Mode, data); for (j = 0; j < MaxWaitCnt; j++) { if (! (REG_RD (pDevice, DmaWrite.Mode) & DMA_WRITE_MODE_ENABLE)) break; MM_Wait (10); } } else REG_WR (pDevice, DmaWrite.Mode, data | DMA_WRITE_MODE_ENABLE); break; case T3_BLOCK_MSI_HANDLER: data = REG_RD (pDevice, Msi.Mode); if (cntrl == LM_DISABLE) { data &= ~MSI_MODE_ENABLE; REG_WR (pDevice, Msi.Mode, data); for (j = 0; j < MaxWaitCnt; j++) { if (! (REG_RD (pDevice, Msi.Mode) & MSI_MODE_ENABLE)) break; MM_Wait (10); } } else REG_WR (pDevice, Msi.Mode, data | MSI_MODE_ENABLE); break; case T3_BLOCK_RX_LIST_PLMT: data = REG_RD (pDevice, RcvListPlmt.Mode); if (cntrl == LM_DISABLE) { data &= ~RCV_LIST_PLMT_MODE_ENABLE; REG_WR (pDevice, RcvListPlmt.Mode, data); for (j = 0; j < MaxWaitCnt; j++) { if (! (REG_RD (pDevice, RcvListPlmt.Mode) & RCV_LIST_PLMT_MODE_ENABLE)) break; MM_Wait (10); } } else REG_WR (pDevice, RcvListPlmt.Mode, data | RCV_LIST_PLMT_MODE_ENABLE); break; case T3_BLOCK_RX_LIST_SELECTOR: data = REG_RD (pDevice, RcvListSel.Mode); if (cntrl == LM_DISABLE) { data &= ~RCV_LIST_SEL_MODE_ENABLE; REG_WR (pDevice, RcvListSel.Mode, data); for (j = 0; j < MaxWaitCnt; j++) { if (! (REG_RD (pDevice, RcvListSel.Mode) & RCV_LIST_SEL_MODE_ENABLE)) break; MM_Wait (10); } } else REG_WR (pDevice, RcvListSel.Mode, data | RCV_LIST_SEL_MODE_ENABLE); break; case T3_BLOCK_RX_DATA_INITIATOR: data = REG_RD (pDevice, RcvDataBdIn.Mode); if (cntrl == LM_DISABLE) { data &= ~RCV_DATA_BD_IN_MODE_ENABLE; REG_WR (pDevice, RcvDataBdIn.Mode, data); for (j = 0; j < MaxWaitCnt; j++) { if (! (REG_RD (pDevice, RcvDataBdIn.Mode) & RCV_DATA_BD_IN_MODE_ENABLE)) break; MM_Wait (10); } } else REG_WR (pDevice, RcvDataBdIn.Mode, data | RCV_DATA_BD_IN_MODE_ENABLE); break; case T3_BLOCK_RX_DATA_COMP: data = REG_RD (pDevice, RcvDataComp.Mode); if (cntrl == LM_DISABLE) { data &= ~RCV_DATA_COMP_MODE_ENABLE; REG_WR (pDevice, RcvDataComp.Mode, data); for (j = 0; j < MaxWaitCnt; j++) { if (! (REG_RD (pDevice, RcvDataBdIn.Mode) & RCV_DATA_COMP_MODE_ENABLE)) break; MM_Wait (10); } } else REG_WR (pDevice, RcvDataComp.Mode, data | RCV_DATA_COMP_MODE_ENABLE); break; case T3_BLOCK_HOST_COALESING: data = REG_RD (pDevice, HostCoalesce.Mode); if (cntrl == LM_DISABLE) { data &= ~HOST_COALESCE_ENABLE; REG_WR (pDevice, HostCoalesce.Mode, data); for (j = 0; j < MaxWaitCnt; j++) { if (! (REG_RD (pDevice, SndBdIn.Mode) & HOST_COALESCE_ENABLE)) break; MM_Wait (10); } } else REG_WR (pDevice, HostCoalesce.Mode, data | HOST_COALESCE_ENABLE); break; case T3_BLOCK_MAC_RX_ENGINE: if (cntrl == LM_DISABLE) { pDevice->RxMode &= ~RX_MODE_ENABLE; REG_WR (pDevice, MacCtrl.RxMode, pDevice->RxMode); for (j = 0; j < MaxWaitCnt; j++) { if (! (REG_RD (pDevice, MacCtrl.RxMode) & RX_MODE_ENABLE)) { break; } MM_Wait (10); } } else { pDevice->RxMode |= RX_MODE_ENABLE; REG_WR (pDevice, MacCtrl.RxMode, pDevice->RxMode); } break; case T3_BLOCK_MBUF_CLUSTER_FREE: data = REG_RD (pDevice, MbufClusterFree.Mode); if (cntrl == LM_DISABLE) { data &= ~MBUF_CLUSTER_FREE_MODE_ENABLE; REG_WR (pDevice, MbufClusterFree.Mode, data); for (j = 0; j < MaxWaitCnt; j++) { if (! (REG_RD (pDevice, MbufClusterFree. Mode) & MBUF_CLUSTER_FREE_MODE_ENABLE)) break; MM_Wait (10); } } else REG_WR (pDevice, MbufClusterFree.Mode, data | MBUF_CLUSTER_FREE_MODE_ENABLE); break; case T3_BLOCK_SEND_BD_INITIATOR: data = REG_RD (pDevice, SndBdIn.Mode); if (cntrl == LM_DISABLE) { data &= ~SND_BD_IN_MODE_ENABLE; REG_WR (pDevice, SndBdIn.Mode, data); for (j = 0; j < MaxWaitCnt; j++) { if (! (REG_RD (pDevice, SndBdIn.Mode) & SND_BD_IN_MODE_ENABLE)) break; MM_Wait (10); } } else REG_WR (pDevice, SndBdIn.Mode, data | SND_BD_IN_MODE_ENABLE); break; case T3_BLOCK_SEND_BD_COMP: data = REG_RD (pDevice, SndBdComp.Mode); if (cntrl == LM_DISABLE) { data &= ~SND_BD_COMP_MODE_ENABLE; REG_WR (pDevice, SndBdComp.Mode, data); for (j = 0; j < MaxWaitCnt; j++) { if (! (REG_RD (pDevice, SndBdComp.Mode) & SND_BD_COMP_MODE_ENABLE)) break; MM_Wait (10); } } else REG_WR (pDevice, SndBdComp.Mode, data | SND_BD_COMP_MODE_ENABLE); break; case T3_BLOCK_SEND_BD_SELECTOR: data = REG_RD (pDevice, SndBdSel.Mode); if (cntrl == LM_DISABLE) { data &= ~SND_BD_SEL_MODE_ENABLE; REG_WR (pDevice, SndBdSel.Mode, data); for (j = 0; j < MaxWaitCnt; j++) { if (! (REG_RD (pDevice, SndBdSel.Mode) & SND_BD_SEL_MODE_ENABLE)) break; MM_Wait (10); } } else REG_WR (pDevice, SndBdSel.Mode, data | SND_BD_SEL_MODE_ENABLE); break; case T3_BLOCK_SEND_DATA_INITIATOR: data = REG_RD (pDevice, SndDataIn.Mode); if (cntrl == LM_DISABLE) { data &= ~T3_SND_DATA_IN_MODE_ENABLE; REG_WR (pDevice, SndDataIn.Mode, data); for (j = 0; j < MaxWaitCnt; j++) { if (! (REG_RD (pDevice, SndDataIn.Mode) & T3_SND_DATA_IN_MODE_ENABLE)) break; MM_Wait (10); } } else REG_WR (pDevice, SndDataIn.Mode, data | T3_SND_DATA_IN_MODE_ENABLE); break; case T3_BLOCK_SEND_DATA_COMP: data = REG_RD (pDevice, SndDataComp.Mode); if (cntrl == LM_DISABLE) { data &= ~SND_DATA_COMP_MODE_ENABLE; REG_WR (pDevice, SndDataComp.Mode, data); for (j = 0; j < MaxWaitCnt; j++) { if (! (REG_RD (pDevice, SndDataComp.Mode) & SND_DATA_COMP_MODE_ENABLE)) break; MM_Wait (10); } } else REG_WR (pDevice, SndDataComp.Mode, data | SND_DATA_COMP_MODE_ENABLE); break; case T3_BLOCK_MAC_TX_ENGINE: if (cntrl == LM_DISABLE) { pDevice->TxMode &= ~TX_MODE_ENABLE; REG_WR (pDevice, MacCtrl.TxMode, pDevice->TxMode); for (j = 0; j < MaxWaitCnt; j++) { if (! (REG_RD (pDevice, MacCtrl.TxMode) & TX_MODE_ENABLE)) break; MM_Wait (10); } } else { pDevice->TxMode |= TX_MODE_ENABLE; REG_WR (pDevice, MacCtrl.TxMode, pDevice->TxMode); } break; case T3_BLOCK_MEM_ARBITOR: data = REG_RD (pDevice, MemArbiter.Mode); if (cntrl == LM_DISABLE) { data &= ~T3_MEM_ARBITER_MODE_ENABLE; REG_WR (pDevice, MemArbiter.Mode, data); for (j = 0; j < MaxWaitCnt; j++) { if (! (REG_RD (pDevice, MemArbiter.Mode) & T3_MEM_ARBITER_MODE_ENABLE)) break; MM_Wait (10); } } else REG_WR (pDevice, MemArbiter.Mode, data | T3_MEM_ARBITER_MODE_ENABLE); break; case T3_BLOCK_MBUF_MANAGER: data = REG_RD (pDevice, BufMgr.Mode); if (cntrl == LM_DISABLE) { data &= ~BUFMGR_MODE_ENABLE; REG_WR (pDevice, BufMgr.Mode, data); for (j = 0; j < MaxWaitCnt; j++) { if (! (REG_RD (pDevice, BufMgr.Mode) & BUFMGR_MODE_ENABLE)) break; MM_Wait (10); } } else REG_WR (pDevice, BufMgr.Mode, data | BUFMGR_MODE_ENABLE); break; case T3_BLOCK_MAC_GLOBAL: if (cntrl == LM_DISABLE) { pDevice->MacMode &= ~(MAC_MODE_ENABLE_TDE | MAC_MODE_ENABLE_RDE | MAC_MODE_ENABLE_FHDE); } else { pDevice->MacMode |= (MAC_MODE_ENABLE_TDE | MAC_MODE_ENABLE_RDE | MAC_MODE_ENABLE_FHDE); } REG_WR (pDevice, MacCtrl.Mode, pDevice->MacMode); break; default: return LM_STATUS_FAILURE; } /* switch */ if (j >= MaxWaitCnt) { return LM_STATUS_FAILURE; } } return LM_STATUS_SUCCESS; } /******************************************************************************/ /* Description: */ /* This function reinitializes the adapter. */ /* */ /* Return: */ /* LM_STATUS_SUCCESS */ /******************************************************************************/ LM_STATUS LM_ResetAdapter (PLM_DEVICE_BLOCK pDevice) { LM_UINT32 Value32; LM_UINT16 Value16; LM_UINT32 j, k; /* Disable interrupt. */ LM_DisableInterrupt (pDevice); /* May get a spurious interrupt */ pDevice->pStatusBlkVirt->Status = STATUS_BLOCK_UPDATED; /* Disable transmit and receive DMA engines. Abort all pending requests. */ if (pDevice->InitDone) { LM_Abort (pDevice); } pDevice->ShuttingDown = FALSE; LM_ResetChip (pDevice); /* Bug: Athlon fix for B3 silicon only. This bit does not do anything */ /* in other chip revisions. */ if (pDevice->DelayPciGrant) { Value32 = REG_RD (pDevice, PciCfg.ClockCtrl); REG_WR (pDevice, PciCfg.ClockCtrl, Value32 | BIT_31); } if (pDevice->ChipRevId == T3_CHIP_ID_5704_A0) { if (!(pDevice->PciState & T3_PCI_STATE_CONVENTIONAL_PCI_MODE)) { Value32 = REG_RD (pDevice, PciCfg.PciState); Value32 |= T3_PCI_STATE_RETRY_SAME_DMA; REG_WR (pDevice, PciCfg.PciState, Value32); } } /* Enable TaggedStatus mode. */ if (pDevice->UseTaggedStatus) { pDevice->MiscHostCtrl |= MISC_HOST_CTRL_ENABLE_TAGGED_STATUS_MODE; } /* Restore PCI configuration registers. */ MM_WriteConfig32 (pDevice, PCI_CACHE_LINE_SIZE_REG, pDevice->SavedCacheLineReg); MM_WriteConfig32 (pDevice, PCI_SUBSYSTEM_VENDOR_ID_REG, (pDevice->SubsystemId << 16) | pDevice-> SubsystemVendorId); /* Clear the statistics block. */ for (j = 0x0300; j < 0x0b00; j++) { MEM_WR_OFFSET (pDevice, j, 0); } /* Initialize the statistis Block */ pDevice->pStatusBlkVirt->Status = 0; pDevice->pStatusBlkVirt->RcvStdConIdx = 0; pDevice->pStatusBlkVirt->RcvJumboConIdx = 0; pDevice->pStatusBlkVirt->RcvMiniConIdx = 0; for (j = 0; j < 16; j++) { pDevice->pStatusBlkVirt->Idx[j].RcvProdIdx = 0; pDevice->pStatusBlkVirt->Idx[j].SendConIdx = 0; } for (k = 0; k < T3_STD_RCV_RCB_ENTRY_COUNT; k++) { pDevice->pRxStdBdVirt[k].HostAddr.High = 0; pDevice->pRxStdBdVirt[k].HostAddr.Low = 0; } #if T3_JUMBO_RCV_RCB_ENTRY_COUNT /* Receive jumbo BD buffer. */ for (k = 0; k < T3_JUMBO_RCV_RCB_ENTRY_COUNT; k++) { pDevice->pRxJumboBdVirt[k].HostAddr.High = 0; pDevice->pRxJumboBdVirt[k].HostAddr.Low = 0; } #endif REG_WR (pDevice, PciCfg.DmaReadWriteCtrl, pDevice->DmaReadWriteCtrl); /* GRC mode control register. */ #ifdef BIG_ENDIAN_PCI /* Jimmy, this ifdef block deleted in new code! */ Value32 = GRC_MODE_WORD_SWAP_DATA | GRC_MODE_WORD_SWAP_NON_FRAME_DATA | GRC_MODE_INT_ON_MAC_ATTN | GRC_MODE_HOST_STACK_UP; #else /* No CPU Swap modes for PCI IO */ Value32 = #ifdef BIG_ENDIAN_HOST GRC_MODE_BYTE_SWAP_NON_FRAME_DATA | GRC_MODE_WORD_SWAP_NON_FRAME_DATA | GRC_MODE_BYTE_SWAP_DATA | GRC_MODE_WORD_SWAP_DATA | #else GRC_MODE_WORD_SWAP_NON_FRAME_DATA | GRC_MODE_BYTE_SWAP_DATA | GRC_MODE_WORD_SWAP_DATA | #endif GRC_MODE_INT_ON_MAC_ATTN | GRC_MODE_HOST_STACK_UP; #endif /* !BIG_ENDIAN_PCI */ /* Configure send BD mode. */ if (pDevice->NicSendBd == FALSE) { Value32 |= GRC_MODE_HOST_SEND_BDS; } else { Value32 |= GRC_MODE_4X_NIC_BASED_SEND_RINGS; } /* Configure pseudo checksum mode. */ if (pDevice->NoTxPseudoHdrChksum) { Value32 |= GRC_MODE_TX_NO_PSEUDO_HEADER_CHKSUM; } if (pDevice->NoRxPseudoHdrChksum) { Value32 |= GRC_MODE_RX_NO_PSEUDO_HEADER_CHKSUM; } REG_WR (pDevice, Grc.Mode, Value32); /* Setup the timer prescalar register. */ REG_WR (pDevice, Grc.MiscCfg, 65 << 1); /* Clock is alwasy 66MHz. */ /* Set up the MBUF pool base address and size. */ REG_WR (pDevice, BufMgr.MbufPoolAddr, pDevice->MbufBase); REG_WR (pDevice, BufMgr.MbufPoolSize, pDevice->MbufSize); /* Set up the DMA descriptor pool base address and size. */ REG_WR (pDevice, BufMgr.DmaDescPoolAddr, T3_NIC_DMA_DESC_POOL_ADDR); REG_WR (pDevice, BufMgr.DmaDescPoolSize, T3_NIC_DMA_DESC_POOL_SIZE); /* Configure MBUF and Threshold watermarks */ /* Configure the DMA read MBUF low water mark. */ if (pDevice->DmaMbufLowMark) { REG_WR (pDevice, BufMgr.MbufReadDmaLowWaterMark, pDevice->DmaMbufLowMark); } else { if (pDevice->TxMtu < MAX_ETHERNET_PACKET_BUFFER_SIZE) { REG_WR (pDevice, BufMgr.MbufReadDmaLowWaterMark, T3_DEF_DMA_MBUF_LOW_WMARK); } else { REG_WR (pDevice, BufMgr.MbufReadDmaLowWaterMark, T3_DEF_DMA_MBUF_LOW_WMARK_JUMBO); } } /* Configure the MAC Rx MBUF low water mark. */ if (pDevice->RxMacMbufLowMark) { REG_WR (pDevice, BufMgr.MbufMacRxLowWaterMark, pDevice->RxMacMbufLowMark); } else { if (pDevice->TxMtu < MAX_ETHERNET_PACKET_BUFFER_SIZE) { REG_WR (pDevice, BufMgr.MbufMacRxLowWaterMark, T3_DEF_RX_MAC_MBUF_LOW_WMARK); } else { REG_WR (pDevice, BufMgr.MbufMacRxLowWaterMark, T3_DEF_RX_MAC_MBUF_LOW_WMARK_JUMBO); } } /* Configure the MBUF high water mark. */ if (pDevice->MbufHighMark) { REG_WR (pDevice, BufMgr.MbufHighWaterMark, pDevice->MbufHighMark); } else { if (pDevice->TxMtu < MAX_ETHERNET_PACKET_BUFFER_SIZE) { REG_WR (pDevice, BufMgr.MbufHighWaterMark, T3_DEF_MBUF_HIGH_WMARK); } else { REG_WR (pDevice, BufMgr.MbufHighWaterMark, T3_DEF_MBUF_HIGH_WMARK_JUMBO); } } REG_WR (pDevice, BufMgr.DmaLowWaterMark, T3_DEF_DMA_DESC_LOW_WMARK); REG_WR (pDevice, BufMgr.DmaHighWaterMark, T3_DEF_DMA_DESC_HIGH_WMARK); /* Enable buffer manager. */ REG_WR (pDevice, BufMgr.Mode, BUFMGR_MODE_ENABLE | BUFMGR_MODE_ATTN_ENABLE); for (j = 0; j < 2000; j++) { if (REG_RD (pDevice, BufMgr.Mode) & BUFMGR_MODE_ENABLE) break; MM_Wait (10); } if (j >= 2000) { return LM_STATUS_FAILURE; } /* Enable the FTQs. */ REG_WR (pDevice, Ftq.Reset, 0xffffffff); REG_WR (pDevice, Ftq.Reset, 0); /* Wait until FTQ is ready */ for (j = 0; j < 2000; j++) { if (REG_RD (pDevice, Ftq.Reset) == 0) break; MM_Wait (10); } if (j >= 2000) { return LM_STATUS_FAILURE; } /* Initialize the Standard Receive RCB. */ REG_WR (pDevice, RcvDataBdIn.StdRcvRcb.HostRingAddr.High, pDevice->RxStdBdPhy.High); REG_WR (pDevice, RcvDataBdIn.StdRcvRcb.HostRingAddr.Low, pDevice->RxStdBdPhy.Low); REG_WR (pDevice, RcvDataBdIn.StdRcvRcb.u.MaxLen_Flags, MAX_STD_RCV_BUFFER_SIZE << 16); /* Initialize the Jumbo Receive RCB. */ REG_WR (pDevice, RcvDataBdIn.JumboRcvRcb.u.MaxLen_Flags, T3_RCB_FLAG_RING_DISABLED); #if T3_JUMBO_RCV_RCB_ENTRY_COUNT REG_WR (pDevice, RcvDataBdIn.JumboRcvRcb.HostRingAddr.High, pDevice->RxJumboBdPhy.High); REG_WR (pDevice, RcvDataBdIn.JumboRcvRcb.HostRingAddr.Low, pDevice->RxJumboBdPhy.Low); REG_WR (pDevice, RcvDataBdIn.JumboRcvRcb.u.MaxLen_Flags, 0); #endif /* T3_JUMBO_RCV_RCB_ENTRY_COUNT */ /* Initialize the Mini Receive RCB. */ REG_WR (pDevice, RcvDataBdIn.MiniRcvRcb.u.MaxLen_Flags, T3_RCB_FLAG_RING_DISABLED); { REG_WR (pDevice, RcvDataBdIn.StdRcvRcb.NicRingAddr, (LM_UINT32) T3_NIC_STD_RCV_BUFFER_DESC_ADDR); REG_WR (pDevice, RcvDataBdIn.JumboRcvRcb.NicRingAddr, (LM_UINT32) T3_NIC_JUMBO_RCV_BUFFER_DESC_ADDR); } /* Receive BD Ring replenish threshold. */ REG_WR (pDevice, RcvBdIn.StdRcvThreshold, pDevice->RxStdDescCnt / 8); #if T3_JUMBO_RCV_RCB_ENTRY_COUNT REG_WR (pDevice, RcvBdIn.JumboRcvThreshold, pDevice->RxJumboDescCnt / 8); #endif /* T3_JUMBO_RCV_RCB_ENTRY_COUNT */ /* Disable all the unused rings. */ for (j = 0; j < T3_MAX_SEND_RCB_COUNT; j++) { MEM_WR (pDevice, SendRcb[j].u.MaxLen_Flags, T3_RCB_FLAG_RING_DISABLED); } /* for */ /* Initialize the indices. */ pDevice->SendProdIdx = 0; pDevice->SendConIdx = 0; MB_REG_WR (pDevice, Mailbox.SendHostProdIdx[0].Low, 0); MB_REG_WR (pDevice, Mailbox.SendNicProdIdx[0].Low, 0); /* Set up host or NIC based send RCB. */ if (pDevice->NicSendBd == FALSE) { MEM_WR (pDevice, SendRcb[0].HostRingAddr.High, pDevice->SendBdPhy.High); MEM_WR (pDevice, SendRcb[0].HostRingAddr.Low, pDevice->SendBdPhy.Low); /* Set up the NIC ring address in the RCB. */ MEM_WR (pDevice, SendRcb[0].NicRingAddr, T3_NIC_SND_BUFFER_DESC_ADDR); /* Setup the RCB. */ MEM_WR (pDevice, SendRcb[0].u.MaxLen_Flags, T3_SEND_RCB_ENTRY_COUNT << 16); for (k = 0; k < T3_SEND_RCB_ENTRY_COUNT; k++) { pDevice->pSendBdVirt[k].HostAddr.High = 0; pDevice->pSendBdVirt[k].HostAddr.Low = 0; } } else { MEM_WR (pDevice, SendRcb[0].HostRingAddr.High, 0); MEM_WR (pDevice, SendRcb[0].HostRingAddr.Low, 0); MEM_WR (pDevice, SendRcb[0].NicRingAddr, pDevice->SendBdPhy.Low); for (k = 0; k < T3_SEND_RCB_ENTRY_COUNT; k++) { __raw_writel (0, &(pDevice->pSendBdVirt[k].HostAddr.High)); __raw_writel (0, &(pDevice->pSendBdVirt[k].HostAddr.Low)); __raw_writel (0, &(pDevice->pSendBdVirt[k].u1.Len_Flags)); pDevice->ShadowSendBd[k].HostAddr.High = 0; pDevice->ShadowSendBd[k].u1.Len_Flags = 0; } } atomic_set (&pDevice->SendBdLeft, T3_SEND_RCB_ENTRY_COUNT - 1); /* Configure the receive return rings. */ for (j = 0; j < T3_MAX_RCV_RETURN_RCB_COUNT; j++) { MEM_WR (pDevice, RcvRetRcb[j].u.MaxLen_Flags, T3_RCB_FLAG_RING_DISABLED); } pDevice->RcvRetConIdx = 0; MEM_WR (pDevice, RcvRetRcb[0].HostRingAddr.High, pDevice->RcvRetBdPhy.High); MEM_WR (pDevice, RcvRetRcb[0].HostRingAddr.Low, pDevice->RcvRetBdPhy.Low); /* Set up the NIC ring address in the RCB. */ /* Not very clear from the spec. I am guessing that for Receive */ /* Return Ring, NicRingAddr is not used. */ MEM_WR (pDevice, RcvRetRcb[0].NicRingAddr, 0); /* Setup the RCB. */ MEM_WR (pDevice, RcvRetRcb[0].u.MaxLen_Flags, T3_RCV_RETURN_RCB_ENTRY_COUNT << 16); /* Reinitialize RX ring producer index */ MB_REG_WR (pDevice, Mailbox.RcvStdProdIdx.Low, 0); MB_REG_WR (pDevice, Mailbox.RcvJumboProdIdx.Low, 0); MB_REG_WR (pDevice, Mailbox.RcvMiniProdIdx.Low, 0); #if T3_JUMBO_RCV_RCB_ENTRY_COUNT pDevice->RxJumboProdIdx = 0; pDevice->RxJumboQueuedCnt = 0; #endif /* Reinitialize our copy of the indices. */ pDevice->RxStdProdIdx = 0; pDevice->RxStdQueuedCnt = 0; #if T3_JUMBO_RCV_ENTRY_COUNT pDevice->RxJumboProdIdx = 0; #endif /* T3_JUMBO_RCV_ENTRY_COUNT */ /* Configure the MAC address. */ LM_SetMacAddress (pDevice); /* Initialize the transmit random backoff seed. */ Value32 = (pDevice->NodeAddress[0] + pDevice->NodeAddress[1] + pDevice->NodeAddress[2] + pDevice->NodeAddress[3] + pDevice->NodeAddress[4] + pDevice->NodeAddress[5]) & MAC_TX_BACKOFF_SEED_MASK; REG_WR (pDevice, MacCtrl.TxBackoffSeed, Value32); /* Receive MTU. Frames larger than the MTU is marked as oversized. */ REG_WR (pDevice, MacCtrl.MtuSize, pDevice->RxMtu + 8); /* CRC + VLAN. */ /* Configure Time slot/IPG per 802.3 */ REG_WR (pDevice, MacCtrl.TxLengths, 0x2620); /* * Configure Receive Rules so that packets don't match * Programmble rule will be queued to Return Ring 1 */ REG_WR (pDevice, MacCtrl.RcvRuleCfg, RX_RULE_DEFAULT_CLASS); /* * Configure to have 16 Classes of Services (COS) and one * queue per class. Bad frames are queued to RRR#1. * And frames don't match rules are also queued to COS#1. */ REG_WR (pDevice, RcvListPlmt.Config, 0x181); /* Enable Receive Placement Statistics */ REG_WR (pDevice, RcvListPlmt.StatsEnableMask, 0xffffff); REG_WR (pDevice, RcvListPlmt.StatsCtrl, RCV_LIST_STATS_ENABLE); /* Enable Send Data Initator Statistics */ REG_WR (pDevice, SndDataIn.StatsEnableMask, 0xffffff); REG_WR (pDevice, SndDataIn.StatsCtrl, T3_SND_DATA_IN_STATS_CTRL_ENABLE | T3_SND_DATA_IN_STATS_CTRL_FASTER_UPDATE); /* Disable the host coalescing state machine before configuring it's */ /* parameters. */ REG_WR (pDevice, HostCoalesce.Mode, 0); for (j = 0; j < 2000; j++) { Value32 = REG_RD (pDevice, HostCoalesce.Mode); if (!(Value32 & HOST_COALESCE_ENABLE)) { break; } MM_Wait (10); } /* Host coalescing configurations. */ REG_WR (pDevice, HostCoalesce.RxCoalescingTicks, pDevice->RxCoalescingTicks); REG_WR (pDevice, HostCoalesce.TxCoalescingTicks, pDevice->TxCoalescingTicks); REG_WR (pDevice, HostCoalesce.RxMaxCoalescedFrames, pDevice->RxMaxCoalescedFrames); REG_WR (pDevice, HostCoalesce.TxMaxCoalescedFrames, pDevice->TxMaxCoalescedFrames); REG_WR (pDevice, HostCoalesce.RxCoalescedTickDuringInt, pDevice->RxCoalescingTicksDuringInt); REG_WR (pDevice, HostCoalesce.TxCoalescedTickDuringInt, pDevice->TxCoalescingTicksDuringInt); REG_WR (pDevice, HostCoalesce.RxMaxCoalescedFramesDuringInt, pDevice->RxMaxCoalescedFramesDuringInt); REG_WR (pDevice, HostCoalesce.TxMaxCoalescedFramesDuringInt, pDevice->TxMaxCoalescedFramesDuringInt); /* Initialize the address of the status block. The NIC will DMA */ /* the status block to this memory which resides on the host. */ REG_WR (pDevice, HostCoalesce.StatusBlkHostAddr.High, pDevice->StatusBlkPhy.High); REG_WR (pDevice, HostCoalesce.StatusBlkHostAddr.Low, pDevice->StatusBlkPhy.Low); /* Initialize the address of the statistics block. The NIC will DMA */ /* the statistics to this block of memory. */ REG_WR (pDevice, HostCoalesce.StatsBlkHostAddr.High, pDevice->StatsBlkPhy.High); REG_WR (pDevice, HostCoalesce.StatsBlkHostAddr.Low, pDevice->StatsBlkPhy.Low); REG_WR (pDevice, HostCoalesce.StatsCoalescingTicks, pDevice->StatsCoalescingTicks); REG_WR (pDevice, HostCoalesce.StatsBlkNicAddr, 0x300); REG_WR (pDevice, HostCoalesce.StatusBlkNicAddr, 0xb00); /* Enable Host Coalesing state machine */ REG_WR (pDevice, HostCoalesce.Mode, HOST_COALESCE_ENABLE | pDevice->CoalesceMode); /* Enable the Receive BD Completion state machine. */ REG_WR (pDevice, RcvBdComp.Mode, RCV_BD_COMP_MODE_ENABLE | RCV_BD_COMP_MODE_ATTN_ENABLE); /* Enable the Receive List Placement state machine. */ REG_WR (pDevice, RcvListPlmt.Mode, RCV_LIST_PLMT_MODE_ENABLE); /* Enable the Receive List Selector state machine. */ REG_WR (pDevice, RcvListSel.Mode, RCV_LIST_SEL_MODE_ENABLE | RCV_LIST_SEL_MODE_ATTN_ENABLE); /* Enable transmit DMA, clear statistics. */ pDevice->MacMode = MAC_MODE_ENABLE_TX_STATISTICS | MAC_MODE_ENABLE_RX_STATISTICS | MAC_MODE_ENABLE_TDE | MAC_MODE_ENABLE_RDE | MAC_MODE_ENABLE_FHDE; REG_WR (pDevice, MacCtrl.Mode, pDevice->MacMode | MAC_MODE_CLEAR_RX_STATISTICS | MAC_MODE_CLEAR_TX_STATISTICS); /* GRC miscellaneous local control register. */ pDevice->GrcLocalCtrl = GRC_MISC_LOCAL_CTRL_INT_ON_ATTN | GRC_MISC_LOCAL_CTRL_AUTO_SEEPROM; if (T3_ASIC_REV (pDevice->ChipRevId) == T3_ASIC_REV_5700) { pDevice->GrcLocalCtrl |= GRC_MISC_LOCAL_CTRL_GPIO_OE1 | GRC_MISC_LOCAL_CTRL_GPIO_OUTPUT1; } REG_WR (pDevice, Grc.LocalCtrl, pDevice->GrcLocalCtrl); MM_Wait (40); /* Reset RX counters. */ for (j = 0; j < sizeof (LM_RX_COUNTERS); j++) { ((PLM_UINT8) & pDevice->RxCounters)[j] = 0; } /* Reset TX counters. */ for (j = 0; j < sizeof (LM_TX_COUNTERS); j++) { ((PLM_UINT8) & pDevice->TxCounters)[j] = 0; } MB_REG_WR (pDevice, Mailbox.Interrupt[0].Low, 0); /* Enable the DMA Completion state machine. */ REG_WR (pDevice, DmaComp.Mode, DMA_COMP_MODE_ENABLE); /* Enable the DMA Write state machine. */ Value32 = DMA_WRITE_MODE_ENABLE | DMA_WRITE_MODE_TARGET_ABORT_ATTN_ENABLE | DMA_WRITE_MODE_MASTER_ABORT_ATTN_ENABLE | DMA_WRITE_MODE_PARITY_ERROR_ATTN_ENABLE | DMA_WRITE_MODE_ADDR_OVERFLOW_ATTN_ENABLE | DMA_WRITE_MODE_FIFO_OVERRUN_ATTN_ENABLE | DMA_WRITE_MODE_FIFO_UNDERRUN_ATTN_ENABLE | DMA_WRITE_MODE_FIFO_OVERREAD_ATTN_ENABLE | DMA_WRITE_MODE_LONG_READ_ATTN_ENABLE; REG_WR (pDevice, DmaWrite.Mode, Value32); if (!(pDevice->PciState & T3_PCI_STATE_CONVENTIONAL_PCI_MODE)) { if (pDevice->ChipRevId == T3_CHIP_ID_5704_A0) { Value16 = REG_RD (pDevice, PciCfg.PciXCommand); Value16 &= ~(PCIX_CMD_MAX_SPLIT_MASK | PCIX_CMD_MAX_BURST_MASK); Value16 |= ((PCIX_CMD_MAX_BURST_CPIOB << PCIX_CMD_MAX_BURST_SHL) & PCIX_CMD_MAX_BURST_MASK); if (pDevice->SplitModeEnable == SPLIT_MODE_ENABLE) { Value16 |= (pDevice-> SplitModeMaxReq << PCIX_CMD_MAX_SPLIT_SHL) & PCIX_CMD_MAX_SPLIT_MASK; } REG_WR (pDevice, PciCfg.PciXCommand, Value16); } } /* Enable the Read DMA state machine. */ Value32 = DMA_READ_MODE_ENABLE | DMA_READ_MODE_TARGET_ABORT_ATTN_ENABLE | DMA_READ_MODE_MASTER_ABORT_ATTN_ENABLE | DMA_READ_MODE_PARITY_ERROR_ATTN_ENABLE | DMA_READ_MODE_ADDR_OVERFLOW_ATTN_ENABLE | DMA_READ_MODE_FIFO_OVERRUN_ATTN_ENABLE | DMA_READ_MODE_FIFO_UNDERRUN_ATTN_ENABLE | DMA_READ_MODE_FIFO_OVERREAD_ATTN_ENABLE | DMA_READ_MODE_LONG_READ_ATTN_ENABLE; if (pDevice->SplitModeEnable == SPLIT_MODE_ENABLE) { Value32 |= DMA_READ_MODE_SPLIT_ENABLE; } REG_WR (pDevice, DmaRead.Mode, Value32); /* Enable the Receive Data Completion state machine. */ REG_WR (pDevice, RcvDataComp.Mode, RCV_DATA_COMP_MODE_ENABLE | RCV_DATA_COMP_MODE_ATTN_ENABLE); /* Enable the Mbuf Cluster Free state machine. */ REG_WR (pDevice, MbufClusterFree.Mode, MBUF_CLUSTER_FREE_MODE_ENABLE); /* Enable the Send Data Completion state machine. */ REG_WR (pDevice, SndDataComp.Mode, SND_DATA_COMP_MODE_ENABLE); /* Enable the Send BD Completion state machine. */ REG_WR (pDevice, SndBdComp.Mode, SND_BD_COMP_MODE_ENABLE | SND_BD_COMP_MODE_ATTN_ENABLE); /* Enable the Receive BD Initiator state machine. */ REG_WR (pDevice, RcvBdIn.Mode, RCV_BD_IN_MODE_ENABLE | RCV_BD_IN_MODE_BD_IN_DIABLED_RCB_ATTN_ENABLE); /* Enable the Receive Data and Receive BD Initiator state machine. */ REG_WR (pDevice, RcvDataBdIn.Mode, RCV_DATA_BD_IN_MODE_ENABLE | RCV_DATA_BD_IN_MODE_INVALID_RING_SIZE); /* Enable the Send Data Initiator state machine. */ REG_WR (pDevice, SndDataIn.Mode, T3_SND_DATA_IN_MODE_ENABLE); /* Enable the Send BD Initiator state machine. */ REG_WR (pDevice, SndBdIn.Mode, SND_BD_IN_MODE_ENABLE | SND_BD_IN_MODE_ATTN_ENABLE); /* Enable the Send BD Selector state machine. */ REG_WR (pDevice, SndBdSel.Mode, SND_BD_SEL_MODE_ENABLE | SND_BD_SEL_MODE_ATTN_ENABLE); #if INCLUDE_5701_AX_FIX /* Load the firmware for the 5701_A0 workaround. */ if (pDevice->ChipRevId == T3_CHIP_ID_5701_A0) { LM_LoadRlsFirmware (pDevice); } #endif /* Enable the transmitter. */ pDevice->TxMode = TX_MODE_ENABLE; REG_WR (pDevice, MacCtrl.TxMode, pDevice->TxMode); /* Enable the receiver. */ pDevice->RxMode = RX_MODE_ENABLE; REG_WR (pDevice, MacCtrl.RxMode, pDevice->RxMode); if (pDevice->RestoreOnWakeUp) { pDevice->RestoreOnWakeUp = FALSE; pDevice->DisableAutoNeg = pDevice->WakeUpDisableAutoNeg; pDevice->RequestedMediaType = pDevice->WakeUpRequestedMediaType; } /* Disable auto polling. */ pDevice->MiMode = 0xc0000; REG_WR (pDevice, MacCtrl.MiMode, pDevice->MiMode); if (T3_ASIC_REV (pDevice->ChipRevId) == T3_ASIC_REV_5700 || T3_ASIC_REV (pDevice->ChipRevId) == T3_ASIC_REV_5701) { Value32 = LED_CTRL_PHY_MODE_1; } else { if (pDevice->LedMode == LED_MODE_OUTPUT) { Value32 = LED_CTRL_PHY_MODE_2; } else { Value32 = LED_CTRL_PHY_MODE_1; } } REG_WR (pDevice, MacCtrl.LedCtrl, Value32); /* Activate Link to enable MAC state machine */ REG_WR (pDevice, MacCtrl.MiStatus, MI_STATUS_ENABLE_LINK_STATUS_ATTN); if (pDevice->EnableTbi) { REG_WR (pDevice, MacCtrl.RxMode, RX_MODE_RESET); MM_Wait (10); REG_WR (pDevice, MacCtrl.RxMode, pDevice->RxMode); if (pDevice->ChipRevId == T3_CHIP_ID_5703_A1) { REG_WR (pDevice, MacCtrl.SerdesCfg, 0x616000); } } /* Setup the phy chip. */ LM_SetupPhy (pDevice); if (!pDevice->EnableTbi) { /* Clear CRC stats */ LM_ReadPhy (pDevice, 0x1e, &Value32); LM_WritePhy (pDevice, 0x1e, Value32 | 0x8000); LM_ReadPhy (pDevice, 0x14, &Value32); } /* Set up the receive mask. */ LM_SetReceiveMask (pDevice, pDevice->ReceiveMask); /* Queue Rx packet buffers. */ if (pDevice->QueueRxPackets) { LM_QueueRxPackets (pDevice); } /* Enable interrupt to the host. */ if (pDevice->InitDone) { LM_EnableInterrupt (pDevice); } return LM_STATUS_SUCCESS; } /* LM_ResetAdapter */ /******************************************************************************/ /* Description: */ /* This routine disables the adapter from generating interrupts. */ /* */ /* Return: */ /* LM_STATUS_SUCCESS */ /******************************************************************************/ LM_STATUS LM_DisableInterrupt (PLM_DEVICE_BLOCK pDevice) { REG_WR (pDevice, PciCfg.MiscHostCtrl, pDevice->MiscHostCtrl | MISC_HOST_CTRL_MASK_PCI_INT); MB_REG_WR (pDevice, Mailbox.Interrupt[0].Low, 1); return LM_STATUS_SUCCESS; } /******************************************************************************/ /* Description: */ /* This routine enables the adapter to generate interrupts. */ /* */ /* Return: */ /* LM_STATUS_SUCCESS */ /******************************************************************************/ LM_STATUS LM_EnableInterrupt (PLM_DEVICE_BLOCK pDevice) { REG_WR (pDevice, PciCfg.MiscHostCtrl, pDevice->MiscHostCtrl & ~MISC_HOST_CTRL_MASK_PCI_INT); MB_REG_WR (pDevice, Mailbox.Interrupt[0].Low, 0); if (pDevice->pStatusBlkVirt->Status & STATUS_BLOCK_UPDATED) { REG_WR (pDevice, Grc.LocalCtrl, pDevice->GrcLocalCtrl | GRC_MISC_LOCAL_CTRL_SET_INT); } return LM_STATUS_SUCCESS; } /******************************************************************************/ /* Description: */ /* This routine puts a packet on the wire if there is a transmit DMA */ /* descriptor available; otherwise the packet is queued for later */ /* transmission. If the second argue is NULL, this routine will put */ /* the queued packet on the wire if possible. */ /* */ /* Return: */ /* LM_STATUS_SUCCESS */ /******************************************************************************/ #if 0 LM_STATUS LM_SendPacket (PLM_DEVICE_BLOCK pDevice, PLM_PACKET pPacket) { LM_UINT32 FragCount; PT3_SND_BD pSendBd; PT3_SND_BD pShadowSendBd; LM_UINT32 Value32, Len; LM_UINT32 Idx; if (T3_ASIC_REV (pDevice->ChipRevId) == T3_ASIC_REV_5700) { return LM_5700SendPacket (pDevice, pPacket); } /* Update the SendBdLeft count. */ atomic_sub (pPacket->u.Tx.FragCount, &pDevice->SendBdLeft); /* Initalize the send buffer descriptors. */ Idx = pDevice->SendProdIdx; pSendBd = &pDevice->pSendBdVirt[Idx]; /* Next producer index. */ if (pDevice->NicSendBd == TRUE) { T3_64BIT_HOST_ADDR paddr; pShadowSendBd = &pDevice->ShadowSendBd[Idx]; for (FragCount = 0;;) { MM_MapTxDma (pDevice, pPacket, &paddr, &Len, FragCount); /* Initialize the pointer to the send buffer fragment. */ if (paddr.High != pShadowSendBd->HostAddr.High) { __raw_writel (paddr.High, &(pSendBd->HostAddr.High)); pShadowSendBd->HostAddr.High = paddr.High; } __raw_writel (paddr.Low, &(pSendBd->HostAddr.Low)); /* Setup the control flags and send buffer size. */ Value32 = (Len << 16) | pPacket->Flags; Idx = (Idx + 1) & T3_SEND_RCB_ENTRY_COUNT_MASK; FragCount++; if (FragCount >= pPacket->u.Tx.FragCount) { Value32 |= SND_BD_FLAG_END; if (Value32 != pShadowSendBd->u1.Len_Flags) { __raw_writel (Value32, &(pSendBd->u1.Len_Flags)); pShadowSendBd->u1.Len_Flags = Value32; } if (pPacket->Flags & SND_BD_FLAG_VLAN_TAG) { __raw_writel (pPacket->VlanTag, &(pSendBd->u2.VlanTag)); } break; } else { if (Value32 != pShadowSendBd->u1.Len_Flags) { __raw_writel (Value32, &(pSendBd->u1.Len_Flags)); pShadowSendBd->u1.Len_Flags = Value32; } if (pPacket->Flags & SND_BD_FLAG_VLAN_TAG) { __raw_writel (pPacket->VlanTag, &(pSendBd->u2.VlanTag)); } } pSendBd++; pShadowSendBd++; if (Idx == 0) { pSendBd = &pDevice->pSendBdVirt[0]; pShadowSendBd = &pDevice->ShadowSendBd[0]; } } /* for */ /* Put the packet descriptor in the ActiveQ. */ QQ_PushTail (&pDevice->TxPacketActiveQ.Container, pPacket); wmb (); MB_REG_WR (pDevice, Mailbox.SendNicProdIdx[0].Low, Idx); } else { for (FragCount = 0;;) { /* Initialize the pointer to the send buffer fragment. */ MM_MapTxDma (pDevice, pPacket, &pSendBd->HostAddr, &Len, FragCount); pSendBd->u2.VlanTag = pPacket->VlanTag; /* Setup the control flags and send buffer size. */ Value32 = (Len << 16) | pPacket->Flags; Idx = (Idx + 1) & T3_SEND_RCB_ENTRY_COUNT_MASK; FragCount++; if (FragCount >= pPacket->u.Tx.FragCount) { pSendBd->u1.Len_Flags = Value32 | SND_BD_FLAG_END; break; } else { pSendBd->u1.Len_Flags = Value32; } pSendBd++; if (Idx == 0) { pSendBd = &pDevice->pSendBdVirt[0]; } } /* for */ /* Put the packet descriptor in the ActiveQ. */ QQ_PushTail (&pDevice->TxPacketActiveQ.Container, pPacket); wmb (); MB_REG_WR (pDevice, Mailbox.SendHostProdIdx[0].Low, Idx); } /* Update the producer index. */ pDevice->SendProdIdx = Idx; return LM_STATUS_SUCCESS; } #endif LM_STATUS LM_SendPacket (PLM_DEVICE_BLOCK pDevice, PLM_PACKET pPacket) { LM_UINT32 FragCount; PT3_SND_BD pSendBd, pTmpSendBd, pShadowSendBd; T3_SND_BD NicSendBdArr[MAX_FRAGMENT_COUNT]; LM_UINT32 StartIdx, Idx; while (1) { /* Initalize the send buffer descriptors. */ StartIdx = Idx = pDevice->SendProdIdx; if (pDevice->NicSendBd) { pTmpSendBd = pSendBd = &NicSendBdArr[0]; } else { pTmpSendBd = pSendBd = &pDevice->pSendBdVirt[Idx]; } /* Next producer index. */ for (FragCount = 0;;) { LM_UINT32 Value32, Len; /* Initialize the pointer to the send buffer fragment. */ MM_MapTxDma (pDevice, pPacket, &pSendBd->HostAddr, &Len, FragCount); pSendBd->u2.VlanTag = pPacket->VlanTag; /* Setup the control flags and send buffer size. */ Value32 = (Len << 16) | pPacket->Flags; Idx = (Idx + 1) & T3_SEND_RCB_ENTRY_COUNT_MASK; FragCount++; if (FragCount >= pPacket->u.Tx.FragCount) { pSendBd->u1.Len_Flags = Value32 | SND_BD_FLAG_END; break; } else { pSendBd->u1.Len_Flags = Value32; } pSendBd++; if ((Idx == 0) && !pDevice->NicSendBd) { pSendBd = &pDevice->pSendBdVirt[0]; } } /* for */ if (T3_ASIC_REV (pDevice->ChipRevId) == T3_ASIC_REV_5700) { if (LM_Test4GBoundary (pDevice, pPacket, pTmpSendBd) == LM_STATUS_SUCCESS) { if (MM_CoalesceTxBuffer (pDevice, pPacket) != LM_STATUS_SUCCESS) { QQ_PushHead (&pDevice->TxPacketFreeQ. Container, pPacket); return LM_STATUS_FAILURE; } continue; } } break; } /* Put the packet descriptor in the ActiveQ. */ QQ_PushTail (&pDevice->TxPacketActiveQ.Container, pPacket); if (pDevice->NicSendBd) { pSendBd = &pDevice->pSendBdVirt[StartIdx]; pShadowSendBd = &pDevice->ShadowSendBd[StartIdx]; while (StartIdx != Idx) { LM_UINT32 Value32; if ((Value32 = pTmpSendBd->HostAddr.High) != pShadowSendBd->HostAddr.High) { __raw_writel (Value32, &(pSendBd->HostAddr.High)); pShadowSendBd->HostAddr.High = Value32; } __raw_writel (pTmpSendBd->HostAddr.Low, &(pSendBd->HostAddr.Low)); if ((Value32 = pTmpSendBd->u1.Len_Flags) != pShadowSendBd->u1.Len_Flags) { __raw_writel (Value32, &(pSendBd->u1.Len_Flags)); pShadowSendBd->u1.Len_Flags = Value32; } if (pPacket->Flags & SND_BD_FLAG_VLAN_TAG) { __raw_writel (pTmpSendBd->u2.VlanTag, &(pSendBd->u2.VlanTag)); } StartIdx = (StartIdx + 1) & T3_SEND_RCB_ENTRY_COUNT_MASK; if (StartIdx == 0) pSendBd = &pDevice->pSendBdVirt[0]; else pSendBd++; pTmpSendBd++; } wmb (); MB_REG_WR (pDevice, Mailbox.SendNicProdIdx[0].Low, Idx); if (T3_CHIP_REV (pDevice->ChipRevId) == T3_CHIP_REV_5700_BX) { MB_REG_WR (pDevice, Mailbox.SendNicProdIdx[0].Low, Idx); } } else { wmb (); MB_REG_WR (pDevice, Mailbox.SendHostProdIdx[0].Low, Idx); if (T3_CHIP_REV (pDevice->ChipRevId) == T3_CHIP_REV_5700_BX) { MB_REG_WR (pDevice, Mailbox.SendHostProdIdx[0].Low, Idx); } } /* Update the SendBdLeft count. */ atomic_sub (pPacket->u.Tx.FragCount, &pDevice->SendBdLeft); /* Update the producer index. */ pDevice->SendProdIdx = Idx; return LM_STATUS_SUCCESS; } STATIC LM_STATUS LM_Test4GBoundary (PLM_DEVICE_BLOCK pDevice, PLM_PACKET pPacket, PT3_SND_BD pSendBd) { int FragCount; LM_UINT32 Idx, Base, Len; Idx = pDevice->SendProdIdx; for (FragCount = 0;;) { Len = pSendBd->u1.Len_Flags >> 16; if (((Base = pSendBd->HostAddr.Low) > 0xffffdcc0) && (pSendBd->HostAddr.High == 0) && ((Base + 8 + Len) < Base)) { return LM_STATUS_SUCCESS; } FragCount++; if (FragCount >= pPacket->u.Tx.FragCount) { break; } pSendBd++; if (!pDevice->NicSendBd) { Idx = (Idx + 1) & T3_SEND_RCB_ENTRY_COUNT_MASK; if (Idx == 0) { pSendBd = &pDevice->pSendBdVirt[0]; } } } return LM_STATUS_FAILURE; } /******************************************************************************/ /* Description: */ /* */ /* Return: */ /******************************************************************************/ __inline static unsigned long ComputeCrc32 (unsigned char *pBuffer, unsigned long BufferSize) { unsigned long Reg; unsigned long Tmp; unsigned long j, k; Reg = 0xffffffff; for (j = 0; j < BufferSize; j++) { Reg ^= pBuffer[j]; for (k = 0; k < 8; k++) { Tmp = Reg & 0x01; Reg >>= 1; if (Tmp) { Reg ^= 0xedb88320; } } } return ~Reg; } /* ComputeCrc32 */ /******************************************************************************/ /* Description: */ /* This routine sets the receive control register according to ReceiveMask */ /* */ /* Return: */ /* LM_STATUS_SUCCESS */ /******************************************************************************/ LM_STATUS LM_SetReceiveMask (PLM_DEVICE_BLOCK pDevice, LM_UINT32 Mask) { LM_UINT32 ReceiveMask; LM_UINT32 RxMode; LM_UINT32 j, k; ReceiveMask = Mask; RxMode = pDevice->RxMode; if (Mask & LM_ACCEPT_UNICAST) { Mask &= ~LM_ACCEPT_UNICAST; } if (Mask & LM_ACCEPT_MULTICAST) { Mask &= ~LM_ACCEPT_MULTICAST; } if (Mask & LM_ACCEPT_ALL_MULTICAST) { Mask &= ~LM_ACCEPT_ALL_MULTICAST; } if (Mask & LM_ACCEPT_BROADCAST) { Mask &= ~LM_ACCEPT_BROADCAST; } RxMode &= ~RX_MODE_PROMISCUOUS_MODE; if (Mask & LM_PROMISCUOUS_MODE) { RxMode |= RX_MODE_PROMISCUOUS_MODE; Mask &= ~LM_PROMISCUOUS_MODE; } RxMode &= ~(RX_MODE_ACCEPT_RUNTS | RX_MODE_ACCEPT_OVERSIZED); if (Mask & LM_ACCEPT_ERROR_PACKET) { RxMode |= RX_MODE_ACCEPT_RUNTS | RX_MODE_ACCEPT_OVERSIZED; Mask &= ~LM_ACCEPT_ERROR_PACKET; } /* Make sure all the bits are valid before committing changes. */ if (Mask) { return LM_STATUS_FAILURE; } /* Commit the new filter. */ pDevice->RxMode = RxMode; REG_WR (pDevice, MacCtrl.RxMode, RxMode); pDevice->ReceiveMask = ReceiveMask; /* Set up the MC hash table. */ if (ReceiveMask & LM_ACCEPT_ALL_MULTICAST) { for (k = 0; k < 4; k++) { REG_WR (pDevice, MacCtrl.HashReg[k], 0xffffffff); } } else if (ReceiveMask & LM_ACCEPT_MULTICAST) { LM_UINT32 HashReg[4]; HashReg[0] = 0; HashReg[1] = 0; HashReg[2] = 0; HashReg[3] = 0; for (j = 0; j < pDevice->McEntryCount; j++) { LM_UINT32 RegIndex; LM_UINT32 Bitpos; LM_UINT32 Crc32; Crc32 = ComputeCrc32 (pDevice->McTable[j], ETHERNET_ADDRESS_SIZE); /* The most significant 7 bits of the CRC32 (no inversion), */ /* are used to index into one of the possible 128 bit positions. */ Bitpos = ~Crc32 & 0x7f; /* Hash register index. */ RegIndex = (Bitpos & 0x60) >> 5; /* Bit to turn on within a hash register. */ Bitpos &= 0x1f; /* Enable the multicast bit. */ HashReg[RegIndex] |= (1 << Bitpos); } /* REV_AX has problem with multicast filtering where it uses both */ /* DA and SA to perform hashing. */ for (k = 0; k < 4; k++) { REG_WR (pDevice, MacCtrl.HashReg[k], HashReg[k]); } } else { /* Reject all multicast frames. */ for (j = 0; j < 4; j++) { REG_WR (pDevice, MacCtrl.HashReg[j], 0); } } /* By default, Tigon3 will accept broadcast frames. We need to setup */ if (ReceiveMask & LM_ACCEPT_BROADCAST) { REG_WR (pDevice, MacCtrl.RcvRules[RCV_RULE1_REJECT_BROADCAST_IDX].Rule, REJECT_BROADCAST_RULE1_RULE & RCV_DISABLE_RULE_MASK); REG_WR (pDevice, MacCtrl.RcvRules[RCV_RULE1_REJECT_BROADCAST_IDX].Value, REJECT_BROADCAST_RULE1_VALUE & RCV_DISABLE_RULE_MASK); REG_WR (pDevice, MacCtrl.RcvRules[RCV_RULE2_REJECT_BROADCAST_IDX].Rule, REJECT_BROADCAST_RULE1_RULE & RCV_DISABLE_RULE_MASK); REG_WR (pDevice, MacCtrl.RcvRules[RCV_RULE2_REJECT_BROADCAST_IDX].Value, REJECT_BROADCAST_RULE1_VALUE & RCV_DISABLE_RULE_MASK); } else { REG_WR (pDevice, MacCtrl.RcvRules[RCV_RULE1_REJECT_BROADCAST_IDX].Rule, REJECT_BROADCAST_RULE1_RULE); REG_WR (pDevice, MacCtrl.RcvRules[RCV_RULE1_REJECT_BROADCAST_IDX].Value, REJECT_BROADCAST_RULE1_VALUE); REG_WR (pDevice, MacCtrl.RcvRules[RCV_RULE2_REJECT_BROADCAST_IDX].Rule, REJECT_BROADCAST_RULE2_RULE); REG_WR (pDevice, MacCtrl.RcvRules[RCV_RULE2_REJECT_BROADCAST_IDX].Value, REJECT_BROADCAST_RULE2_VALUE); } /* disable the rest of the rules. */ for (j = RCV_LAST_RULE_IDX; j < 16; j++) { REG_WR (pDevice, MacCtrl.RcvRules[j].Rule, 0); REG_WR (pDevice, MacCtrl.RcvRules[j].Value, 0); } return LM_STATUS_SUCCESS; } /* LM_SetReceiveMask */ /******************************************************************************/ /* Description: */ /* Disable the interrupt and put the transmitter and receiver engines in */ /* an idle state. Also aborts all pending send requests and receive */ /* buffers. */ /* */ /* Return: */ /* LM_STATUS_SUCCESS */ /******************************************************************************/ LM_STATUS LM_Abort (PLM_DEVICE_BLOCK pDevice) { PLM_PACKET pPacket; LM_UINT Idx; LM_DisableInterrupt (pDevice); /* Disable all the state machines. */ LM_CntrlBlock (pDevice, T3_BLOCK_MAC_RX_ENGINE, LM_DISABLE); LM_CntrlBlock (pDevice, T3_BLOCK_RX_BD_INITIATOR, LM_DISABLE); LM_CntrlBlock (pDevice, T3_BLOCK_RX_LIST_PLMT, LM_DISABLE); LM_CntrlBlock (pDevice, T3_BLOCK_RX_LIST_SELECTOR, LM_DISABLE); LM_CntrlBlock (pDevice, T3_BLOCK_RX_DATA_INITIATOR, LM_DISABLE); LM_CntrlBlock (pDevice, T3_BLOCK_RX_DATA_COMP, LM_DISABLE); LM_CntrlBlock (pDevice, T3_BLOCK_RX_BD_COMP, LM_DISABLE); LM_CntrlBlock (pDevice, T3_BLOCK_SEND_BD_SELECTOR, LM_DISABLE); LM_CntrlBlock (pDevice, T3_BLOCK_SEND_BD_INITIATOR, LM_DISABLE); LM_CntrlBlock (pDevice, T3_BLOCK_SEND_DATA_INITIATOR, LM_DISABLE); LM_CntrlBlock (pDevice, T3_BLOCK_DMA_RD, LM_DISABLE); LM_CntrlBlock (pDevice, T3_BLOCK_SEND_DATA_COMP, LM_DISABLE); LM_CntrlBlock (pDevice, T3_BLOCK_DMA_COMP, LM_DISABLE); LM_CntrlBlock (pDevice, T3_BLOCK_SEND_BD_COMP, LM_DISABLE); /* Clear TDE bit */ pDevice->MacMode &= ~MAC_MODE_ENABLE_TDE; REG_WR (pDevice, MacCtrl.Mode, pDevice->MacMode); LM_CntrlBlock (pDevice, T3_BLOCK_MAC_TX_ENGINE, LM_DISABLE); LM_CntrlBlock (pDevice, T3_BLOCK_HOST_COALESING, LM_DISABLE); LM_CntrlBlock (pDevice, T3_BLOCK_DMA_WR, LM_DISABLE); LM_CntrlBlock (pDevice, T3_BLOCK_MBUF_CLUSTER_FREE, LM_DISABLE); /* Reset all FTQs */ REG_WR (pDevice, Ftq.Reset, 0xffffffff); REG_WR (pDevice, Ftq.Reset, 0x0); LM_CntrlBlock (pDevice, T3_BLOCK_MBUF_MANAGER, LM_DISABLE); LM_CntrlBlock (pDevice, T3_BLOCK_MEM_ARBITOR, LM_DISABLE); MM_ACQUIRE_INT_LOCK (pDevice); /* Abort packets that have already queued to go out. */ pPacket = (PLM_PACKET) QQ_PopHead (&pDevice->TxPacketActiveQ.Container); while (pPacket) { pPacket->PacketStatus = LM_STATUS_TRANSMIT_ABORTED; pDevice->TxCounters.TxPacketAbortedCnt++; atomic_add (pPacket->u.Tx.FragCount, &pDevice->SendBdLeft); QQ_PushTail (&pDevice->TxPacketXmittedQ.Container, pPacket); pPacket = (PLM_PACKET) QQ_PopHead (&pDevice->TxPacketActiveQ.Container); } /* Cleanup the receive return rings. */ LM_ServiceRxInterrupt (pDevice); /* Don't want to indicate rx packets in Ndis miniport shutdown context. */ /* Doing so may cause system crash. */ if (!pDevice->ShuttingDown) { /* Indicate packets to the protocol. */ MM_IndicateTxPackets (pDevice); /* Indicate received packets to the protocols. */ MM_IndicateRxPackets (pDevice); } else { /* Move the receive packet descriptors in the ReceivedQ to the */ /* free queue. */ for (;;) { pPacket = (PLM_PACKET) QQ_PopHead (&pDevice-> RxPacketReceivedQ. Container); if (pPacket == NULL) { break; } QQ_PushTail (&pDevice->RxPacketFreeQ.Container, pPacket); } } /* Clean up the Std Receive Producer ring. */ Idx = pDevice->pStatusBlkVirt->RcvStdConIdx; while (Idx != pDevice->RxStdProdIdx) { pPacket = (PLM_PACKET) (MM_UINT_PTR (pDevice->pPacketDescBase) + MM_UINT_PTR (pDevice->pRxStdBdVirt[Idx]. Opaque)); QQ_PushTail (&pDevice->RxPacketFreeQ.Container, pPacket); Idx = (Idx + 1) & T3_STD_RCV_RCB_ENTRY_COUNT_MASK; } /* while */ /* Reinitialize our copy of the indices. */ pDevice->RxStdProdIdx = 0; #if T3_JUMBO_RCV_RCB_ENTRY_COUNT /* Clean up the Jumbo Receive Producer ring. */ Idx = pDevice->pStatusBlkVirt->RcvJumboConIdx; while (Idx != pDevice->RxJumboProdIdx) { pPacket = (PLM_PACKET) (MM_UINT_PTR (pDevice->pPacketDescBase) + MM_UINT_PTR (pDevice-> pRxJumboBdVirt[Idx]. Opaque)); QQ_PushTail (&pDevice->RxPacketFreeQ.Container, pPacket); Idx = (Idx + 1) & T3_JUMBO_RCV_RCB_ENTRY_COUNT_MASK; } /* while */ /* Reinitialize our copy of the indices. */ pDevice->RxJumboProdIdx = 0; #endif /* T3_JUMBO_RCV_RCB_ENTRY_COUNT */ MM_RELEASE_INT_LOCK (pDevice); /* Initialize the statistis Block */ pDevice->pStatusBlkVirt->Status = 0; pDevice->pStatusBlkVirt->RcvStdConIdx = 0; pDevice->pStatusBlkVirt->RcvJumboConIdx = 0; pDevice->pStatusBlkVirt->RcvMiniConIdx = 0; return LM_STATUS_SUCCESS; } /* LM_Abort */ /******************************************************************************/ /* Description: */ /* Disable the interrupt and put the transmitter and receiver engines in */ /* an idle state. Aborts all pending send requests and receive buffers. */ /* Also free all the receive buffers. */ /* */ /* Return: */ /* LM_STATUS_SUCCESS */ /******************************************************************************/ LM_STATUS LM_Halt (PLM_DEVICE_BLOCK pDevice) { PLM_PACKET pPacket; LM_UINT32 EntryCnt; LM_Abort (pDevice); /* Get the number of entries in the queue. */ EntryCnt = QQ_GetEntryCnt (&pDevice->RxPacketFreeQ.Container); /* Make sure all the packets have been accounted for. */ for (EntryCnt = 0; EntryCnt < pDevice->RxPacketDescCnt; EntryCnt++) { pPacket = (PLM_PACKET) QQ_PopHead (&pDevice->RxPacketFreeQ.Container); if (pPacket == 0) break; MM_FreeRxBuffer (pDevice, pPacket); QQ_PushTail (&pDevice->RxPacketFreeQ.Container, pPacket); } LM_ResetChip (pDevice); /* Restore PCI configuration registers. */ MM_WriteConfig32 (pDevice, PCI_CACHE_LINE_SIZE_REG, pDevice->SavedCacheLineReg); LM_RegWrInd (pDevice, PCI_SUBSYSTEM_VENDOR_ID_REG, (pDevice->SubsystemId << 16) | pDevice->SubsystemVendorId); /* Reprogram the MAC address. */ LM_SetMacAddress (pDevice); return LM_STATUS_SUCCESS; } /* LM_Halt */ STATIC LM_STATUS LM_ResetChip (PLM_DEVICE_BLOCK pDevice) { LM_UINT32 Value32; LM_UINT32 j; /* Wait for access to the nvram interface before resetting. This is */ /* a workaround to prevent EEPROM corruption. */ if (T3_ASIC_REV (pDevice->ChipRevId) != T3_ASIC_REV_5700 && T3_ASIC_REV (pDevice->ChipRevId) != T3_ASIC_REV_5701) { /* Request access to the flash interface. */ REG_WR (pDevice, Nvram.SwArb, SW_ARB_REQ_SET1); for (j = 0; j < 100000; j++) { Value32 = REG_RD (pDevice, Nvram.SwArb); if (Value32 & SW_ARB_GNT1) { break; } MM_Wait (10); } } /* Global reset. */ REG_WR (pDevice, Grc.MiscCfg, GRC_MISC_CFG_CORE_CLOCK_RESET); MM_Wait (40); MM_Wait (40); MM_Wait (40); /* make sure we re-enable indirect accesses */ MM_WriteConfig32 (pDevice, T3_PCI_MISC_HOST_CTRL_REG, pDevice->MiscHostCtrl); /* Set MAX PCI retry to zero. */ Value32 = T3_PCI_STATE_PCI_ROM_ENABLE | T3_PCI_STATE_PCI_ROM_RETRY_ENABLE; if (pDevice->ChipRevId == T3_CHIP_ID_5704_A0) { if (!(pDevice->PciState & T3_PCI_STATE_CONVENTIONAL_PCI_MODE)) { Value32 |= T3_PCI_STATE_RETRY_SAME_DMA; } } MM_WriteConfig32 (pDevice, T3_PCI_STATE_REG, Value32); /* Restore PCI command register. */ MM_WriteConfig32 (pDevice, PCI_COMMAND_REG, pDevice->PciCommandStatusWords); /* Disable PCI-X relaxed ordering bit. */ MM_ReadConfig32 (pDevice, PCIX_CAP_REG, &Value32); Value32 &= ~PCIX_ENABLE_RELAXED_ORDERING; MM_WriteConfig32 (pDevice, PCIX_CAP_REG, Value32); /* Enable memory arbiter. */ REG_WR (pDevice, MemArbiter.Mode, T3_MEM_ARBITER_MODE_ENABLE); #ifdef BIG_ENDIAN_PCI /* This from jfd */ Value32 = GRC_MODE_WORD_SWAP_DATA | GRC_MODE_WORD_SWAP_NON_FRAME_DATA; #else #ifdef BIG_ENDIAN_HOST /* Reconfigure the mode register. */ Value32 = GRC_MODE_BYTE_SWAP_NON_FRAME_DATA | GRC_MODE_WORD_SWAP_NON_FRAME_DATA | GRC_MODE_BYTE_SWAP_DATA | GRC_MODE_WORD_SWAP_DATA; #else /* Reconfigure the mode register. */ Value32 = GRC_MODE_BYTE_SWAP_NON_FRAME_DATA | GRC_MODE_BYTE_SWAP_DATA; #endif #endif REG_WR (pDevice, Grc.Mode, Value32); /* Prevent PXE from restarting. */ MEM_WR_OFFSET (pDevice, 0x0b50, T3_MAGIC_NUM); if (pDevice->EnableTbi) { pDevice->MacMode = MAC_MODE_PORT_MODE_TBI; REG_WR (pDevice, MacCtrl.Mode, MAC_MODE_PORT_MODE_TBI); } else { REG_WR (pDevice, MacCtrl.Mode, 0); } /* Wait for the firmware to finish initialization. */ for (j = 0; j < 100000; j++) { MM_Wait (10); Value32 = MEM_RD_OFFSET (pDevice, 0x0b50); if (Value32 == ~T3_MAGIC_NUM) { break; } } return LM_STATUS_SUCCESS; } /******************************************************************************/ /* Description: */ /* */ /* Return: */ /******************************************************************************/ __inline static void LM_ServiceTxInterrupt (PLM_DEVICE_BLOCK pDevice) { PLM_PACKET pPacket; LM_UINT32 HwConIdx; LM_UINT32 SwConIdx; HwConIdx = pDevice->pStatusBlkVirt->Idx[0].SendConIdx; /* Get our copy of the consumer index. The buffer descriptors */ /* that are in between the consumer indices are freed. */ SwConIdx = pDevice->SendConIdx; /* Move the packets from the TxPacketActiveQ that are sent out to */ /* the TxPacketXmittedQ. Packets that are sent use the */ /* descriptors that are between SwConIdx and HwConIdx. */ while (SwConIdx != HwConIdx) { /* Get the packet that was sent from the TxPacketActiveQ. */ pPacket = (PLM_PACKET) QQ_PopHead (&pDevice->TxPacketActiveQ. Container); /* Set the return status. */ pPacket->PacketStatus = LM_STATUS_SUCCESS; /* Put the packet in the TxPacketXmittedQ for indication later. */ QQ_PushTail (&pDevice->TxPacketXmittedQ.Container, pPacket); /* Move to the next packet's BD. */ SwConIdx = (SwConIdx + pPacket->u.Tx.FragCount) & T3_SEND_RCB_ENTRY_COUNT_MASK; /* Update the number of unused BDs. */ atomic_add (pPacket->u.Tx.FragCount, &pDevice->SendBdLeft); /* Get the new updated HwConIdx. */ HwConIdx = pDevice->pStatusBlkVirt->Idx[0].SendConIdx; } /* while */ /* Save the new SwConIdx. */ pDevice->SendConIdx = SwConIdx; } /* LM_ServiceTxInterrupt */ /******************************************************************************/ /* Description: */ /* */ /* Return: */ /******************************************************************************/ __inline static void LM_ServiceRxInterrupt (PLM_DEVICE_BLOCK pDevice) { PLM_PACKET pPacket; PT3_RCV_BD pRcvBd; LM_UINT32 HwRcvRetProdIdx; LM_UINT32 SwRcvRetConIdx; /* Loop thru the receive return rings for received packets. */ HwRcvRetProdIdx = pDevice->pStatusBlkVirt->Idx[0].RcvProdIdx; SwRcvRetConIdx = pDevice->RcvRetConIdx; while (SwRcvRetConIdx != HwRcvRetProdIdx) { pRcvBd = &pDevice->pRcvRetBdVirt[SwRcvRetConIdx]; /* Get the received packet descriptor. */ pPacket = (PLM_PACKET) (MM_UINT_PTR (pDevice->pPacketDescBase) + MM_UINT_PTR (pRcvBd->Opaque)); /* Check the error flag. */ if (pRcvBd->ErrorFlag && pRcvBd->ErrorFlag != RCV_BD_ERR_ODD_NIBBLED_RCVD_MII) { pPacket->PacketStatus = LM_STATUS_FAILURE; pDevice->RxCounters.RxPacketErrCnt++; if (pRcvBd->ErrorFlag & RCV_BD_ERR_BAD_CRC) { pDevice->RxCounters.RxErrCrcCnt++; } if (pRcvBd->ErrorFlag & RCV_BD_ERR_COLL_DETECT) { pDevice->RxCounters.RxErrCollCnt++; } if (pRcvBd->ErrorFlag & RCV_BD_ERR_LINK_LOST_DURING_PKT) { pDevice->RxCounters.RxErrLinkLostCnt++; } if (pRcvBd->ErrorFlag & RCV_BD_ERR_PHY_DECODE_ERR) { pDevice->RxCounters.RxErrPhyDecodeCnt++; } if (pRcvBd->ErrorFlag & RCV_BD_ERR_ODD_NIBBLED_RCVD_MII) { pDevice->RxCounters.RxErrOddNibbleCnt++; } if (pRcvBd->ErrorFlag & RCV_BD_ERR_MAC_ABORT) { pDevice->RxCounters.RxErrMacAbortCnt++; } if (pRcvBd->ErrorFlag & RCV_BD_ERR_LEN_LT_64) { pDevice->RxCounters.RxErrShortPacketCnt++; } if (pRcvBd->ErrorFlag & RCV_BD_ERR_TRUNC_NO_RESOURCES) { pDevice->RxCounters.RxErrNoResourceCnt++; } if (pRcvBd->ErrorFlag & RCV_BD_ERR_GIANT_FRAME_RCVD) { pDevice->RxCounters.RxErrLargePacketCnt++; } } else { pPacket->PacketStatus = LM_STATUS_SUCCESS; pPacket->PacketSize = pRcvBd->Len - 4; pPacket->Flags = pRcvBd->Flags; if (pRcvBd->Flags & RCV_BD_FLAG_VLAN_TAG) { pPacket->VlanTag = pRcvBd->VlanTag; } pPacket->u.Rx.TcpUdpChecksum = pRcvBd->TcpUdpCksum; } /* Put the packet descriptor containing the received packet */ /* buffer in the RxPacketReceivedQ for indication later. */ QQ_PushTail (&pDevice->RxPacketReceivedQ.Container, pPacket); /* Go to the next buffer descriptor. */ SwRcvRetConIdx = (SwRcvRetConIdx + 1) & T3_RCV_RETURN_RCB_ENTRY_COUNT_MASK; /* Get the updated HwRcvRetProdIdx. */ HwRcvRetProdIdx = pDevice->pStatusBlkVirt->Idx[0].RcvProdIdx; } /* while */ pDevice->RcvRetConIdx = SwRcvRetConIdx; /* Update the receive return ring consumer index. */ MB_REG_WR (pDevice, Mailbox.RcvRetConIdx[0].Low, SwRcvRetConIdx); } /* LM_ServiceRxInterrupt */ /******************************************************************************/ /* Description: */ /* This is the interrupt event handler routine. It acknowledges all */ /* pending interrupts and process all pending events. */ /* */ /* Return: */ /* LM_STATUS_SUCCESS */ /******************************************************************************/ LM_STATUS LM_ServiceInterrupts (PLM_DEVICE_BLOCK pDevice) { LM_UINT32 Value32; int ServicePhyInt = FALSE; /* Setup the phy chip whenever the link status changes. */ if (pDevice->LinkChngMode == T3_LINK_CHNG_MODE_USE_STATUS_REG) { Value32 = REG_RD (pDevice, MacCtrl.Status); if (pDevice->PhyIntMode == T3_PHY_INT_MODE_MI_INTERRUPT) { if (Value32 & MAC_STATUS_MI_INTERRUPT) { ServicePhyInt = TRUE; } } else if (Value32 & MAC_STATUS_LINK_STATE_CHANGED) { ServicePhyInt = TRUE; } } else { if (pDevice->pStatusBlkVirt-> Status & STATUS_BLOCK_LINK_CHANGED_STATUS) { pDevice->pStatusBlkVirt->Status = STATUS_BLOCK_UPDATED | (pDevice->pStatusBlkVirt-> Status & ~STATUS_BLOCK_LINK_CHANGED_STATUS); ServicePhyInt = TRUE; } } #if INCLUDE_TBI_SUPPORT if (pDevice->IgnoreTbiLinkChange == TRUE) { ServicePhyInt = FALSE; } #endif if (ServicePhyInt == TRUE) { LM_SetupPhy (pDevice); } /* Service receive and transmit interrupts. */ LM_ServiceRxInterrupt (pDevice); LM_ServiceTxInterrupt (pDevice); /* No spinlock for this queue since this routine is serialized. */ if (!QQ_Empty (&pDevice->RxPacketReceivedQ.Container)) { /* Indicate receive packets. */ MM_IndicateRxPackets (pDevice); /* LM_QueueRxPackets(pDevice); */ } /* No spinlock for this queue since this routine is serialized. */ if (!QQ_Empty (&pDevice->TxPacketXmittedQ.Container)) { MM_IndicateTxPackets (pDevice); } return LM_STATUS_SUCCESS; } /* LM_ServiceInterrupts */ /******************************************************************************/ /* Description: */ /* */ /* Return: */ /******************************************************************************/ LM_STATUS LM_MulticastAdd (PLM_DEVICE_BLOCK pDevice, PLM_UINT8 pMcAddress) { PLM_UINT8 pEntry; LM_UINT32 j; pEntry = pDevice->McTable[0]; for (j = 0; j < pDevice->McEntryCount; j++) { if (IS_ETH_ADDRESS_EQUAL (pEntry, pMcAddress)) { /* Found a match, increment the instance count. */ pEntry[LM_MC_INSTANCE_COUNT_INDEX] += 1; return LM_STATUS_SUCCESS; } pEntry += LM_MC_ENTRY_SIZE; } if (pDevice->McEntryCount >= LM_MAX_MC_TABLE_SIZE) { return LM_STATUS_FAILURE; } pEntry = pDevice->McTable[pDevice->McEntryCount]; COPY_ETH_ADDRESS (pMcAddress, pEntry); pEntry[LM_MC_INSTANCE_COUNT_INDEX] = 1; pDevice->McEntryCount++; LM_SetReceiveMask (pDevice, pDevice->ReceiveMask | LM_ACCEPT_MULTICAST); return LM_STATUS_SUCCESS; } /* LM_MulticastAdd */ /******************************************************************************/ /* Description: */ /* */ /* Return: */ /******************************************************************************/ LM_STATUS LM_MulticastDel (PLM_DEVICE_BLOCK pDevice, PLM_UINT8 pMcAddress) { PLM_UINT8 pEntry; LM_UINT32 j; pEntry = pDevice->McTable[0]; for (j = 0; j < pDevice->McEntryCount; j++) { if (IS_ETH_ADDRESS_EQUAL (pEntry, pMcAddress)) { /* Found a match, decrement the instance count. */ pEntry[LM_MC_INSTANCE_COUNT_INDEX] -= 1; /* No more instance left, remove the address from the table. */ /* Move the last entry in the table to the delete slot. */ if (pEntry[LM_MC_INSTANCE_COUNT_INDEX] == 0 && pDevice->McEntryCount > 1) { COPY_ETH_ADDRESS (pDevice-> McTable[pDevice-> McEntryCount - 1], pEntry); pEntry[LM_MC_INSTANCE_COUNT_INDEX] = pDevice->McTable[pDevice->McEntryCount - 1] [LM_MC_INSTANCE_COUNT_INDEX]; } pDevice->McEntryCount--; /* Update the receive mask if the table is empty. */ if (pDevice->McEntryCount == 0) { LM_SetReceiveMask (pDevice, pDevice-> ReceiveMask & ~LM_ACCEPT_MULTICAST); } return LM_STATUS_SUCCESS; } pEntry += LM_MC_ENTRY_SIZE; } return LM_STATUS_FAILURE; } /* LM_MulticastDel */ /******************************************************************************/ /* Description: */ /* */ /* Return: */ /******************************************************************************/ LM_STATUS LM_MulticastClear (PLM_DEVICE_BLOCK pDevice) { pDevice->McEntryCount = 0; LM_SetReceiveMask (pDevice, pDevice->ReceiveMask & ~LM_ACCEPT_MULTICAST); return LM_STATUS_SUCCESS; } /* LM_MulticastClear */ /******************************************************************************/ /* Description: */ /* */ /* Return: */ /******************************************************************************/ LM_STATUS LM_SetMacAddress (PLM_DEVICE_BLOCK pDevice) { LM_UINT32 j; PLM_UINT8 pMacAddress = pDevice->NodeAddress; for (j = 0; j < 4; j++) { REG_WR (pDevice, MacCtrl.MacAddr[j].High, (pMacAddress[0] << 8) | pMacAddress[1]); REG_WR (pDevice, MacCtrl.MacAddr[j].Low, (pMacAddress[2] << 24) | (pMacAddress[3] << 16) | (pMacAddress[4] << 8) | pMacAddress[5]); } return LM_STATUS_SUCCESS; } /******************************************************************************/ /* Description: */ /* Sets up the default line speed, and duplex modes based on the requested */ /* media type. */ /* */ /* Return: */ /* None. */ /******************************************************************************/ static LM_STATUS LM_TranslateRequestedMediaType (LM_REQUESTED_MEDIA_TYPE RequestedMediaType, PLM_MEDIA_TYPE pMediaType, PLM_LINE_SPEED pLineSpeed, PLM_DUPLEX_MODE pDuplexMode) { *pMediaType = LM_MEDIA_TYPE_AUTO; *pLineSpeed = LM_LINE_SPEED_UNKNOWN; *pDuplexMode = LM_DUPLEX_MODE_UNKNOWN; /* determine media type */ switch (RequestedMediaType) { case LM_REQUESTED_MEDIA_TYPE_BNC: *pMediaType = LM_MEDIA_TYPE_BNC; *pLineSpeed = LM_LINE_SPEED_10MBPS; *pDuplexMode = LM_DUPLEX_MODE_HALF; break; case LM_REQUESTED_MEDIA_TYPE_UTP_AUTO: *pMediaType = LM_MEDIA_TYPE_UTP; break; case LM_REQUESTED_MEDIA_TYPE_UTP_10MBPS: *pMediaType = LM_MEDIA_TYPE_UTP; *pLineSpeed = LM_LINE_SPEED_10MBPS; *pDuplexMode = LM_DUPLEX_MODE_HALF; break; case LM_REQUESTED_MEDIA_TYPE_UTP_10MBPS_FULL_DUPLEX: *pMediaType = LM_MEDIA_TYPE_UTP; *pLineSpeed = LM_LINE_SPEED_10MBPS; *pDuplexMode = LM_DUPLEX_MODE_FULL; break; case LM_REQUESTED_MEDIA_TYPE_UTP_100MBPS: *pMediaType = LM_MEDIA_TYPE_UTP; *pLineSpeed = LM_LINE_SPEED_100MBPS; *pDuplexMode = LM_DUPLEX_MODE_HALF; break; case LM_REQUESTED_MEDIA_TYPE_UTP_100MBPS_FULL_DUPLEX: *pMediaType = LM_MEDIA_TYPE_UTP; *pLineSpeed = LM_LINE_SPEED_100MBPS; *pDuplexMode = LM_DUPLEX_MODE_FULL; break; case LM_REQUESTED_MEDIA_TYPE_UTP_1000MBPS: *pMediaType = LM_MEDIA_TYPE_UTP; *pLineSpeed = LM_LINE_SPEED_1000MBPS; *pDuplexMode = LM_DUPLEX_MODE_HALF; break; case LM_REQUESTED_MEDIA_TYPE_UTP_1000MBPS_FULL_DUPLEX: *pMediaType = LM_MEDIA_TYPE_UTP; *pLineSpeed = LM_LINE_SPEED_1000MBPS; *pDuplexMode = LM_DUPLEX_MODE_FULL; break; case LM_REQUESTED_MEDIA_TYPE_FIBER_100MBPS: *pMediaType = LM_MEDIA_TYPE_FIBER; *pLineSpeed = LM_LINE_SPEED_100MBPS; *pDuplexMode = LM_DUPLEX_MODE_HALF; break; case LM_REQUESTED_MEDIA_TYPE_FIBER_100MBPS_FULL_DUPLEX: *pMediaType = LM_MEDIA_TYPE_FIBER; *pLineSpeed = LM_LINE_SPEED_100MBPS; *pDuplexMode = LM_DUPLEX_MODE_FULL; break; case LM_REQUESTED_MEDIA_TYPE_FIBER_1000MBPS: *pMediaType = LM_MEDIA_TYPE_FIBER; *pLineSpeed = LM_LINE_SPEED_1000MBPS; *pDuplexMode = LM_DUPLEX_MODE_HALF; break; case LM_REQUESTED_MEDIA_TYPE_FIBER_1000MBPS_FULL_DUPLEX: *pMediaType = LM_MEDIA_TYPE_FIBER; *pLineSpeed = LM_LINE_SPEED_1000MBPS; *pDuplexMode = LM_DUPLEX_MODE_FULL; break; default: break; } /* switch */ return LM_STATUS_SUCCESS; } /* LM_TranslateRequestedMediaType */ /******************************************************************************/ /* Description: */ /* */ /* Return: */ /* LM_STATUS_LINK_ACTIVE */ /* LM_STATUS_LINK_DOWN */ /******************************************************************************/ static LM_STATUS LM_InitBcm540xPhy (PLM_DEVICE_BLOCK pDevice) { LM_LINE_SPEED CurrentLineSpeed; LM_DUPLEX_MODE CurrentDuplexMode; LM_STATUS CurrentLinkStatus; LM_UINT32 Value32; LM_UINT32 j; #if 1 /* jmb: bugfix -- moved here, out of code that sets initial pwr state */ LM_WritePhy (pDevice, BCM5401_AUX_CTRL, 0x2); #endif if ((pDevice->PhyId & PHY_ID_MASK) == PHY_BCM5401_PHY_ID) { LM_ReadPhy (pDevice, PHY_STATUS_REG, &Value32); LM_ReadPhy (pDevice, PHY_STATUS_REG, &Value32); if (!pDevice->InitDone) { Value32 = 0; } if (!(Value32 & PHY_STATUS_LINK_PASS)) { LM_WritePhy (pDevice, BCM5401_AUX_CTRL, 0x0c20); LM_WritePhy (pDevice, BCM540X_DSP_ADDRESS_REG, 0x0012); LM_WritePhy (pDevice, BCM540X_DSP_RW_PORT, 0x1804); LM_WritePhy (pDevice, BCM540X_DSP_ADDRESS_REG, 0x0013); LM_WritePhy (pDevice, BCM540X_DSP_RW_PORT, 0x1204); LM_WritePhy (pDevice, BCM540X_DSP_ADDRESS_REG, 0x8006); LM_WritePhy (pDevice, BCM540X_DSP_RW_PORT, 0x0132); LM_WritePhy (pDevice, BCM540X_DSP_ADDRESS_REG, 0x8006); LM_WritePhy (pDevice, BCM540X_DSP_RW_PORT, 0x0232); LM_WritePhy (pDevice, BCM540X_DSP_ADDRESS_REG, 0x201f); LM_WritePhy (pDevice, BCM540X_DSP_RW_PORT, 0x0a20); LM_ReadPhy (pDevice, PHY_STATUS_REG, &Value32); for (j = 0; j < 1000; j++) { MM_Wait (10); LM_ReadPhy (pDevice, PHY_STATUS_REG, &Value32); if (Value32 & PHY_STATUS_LINK_PASS) { MM_Wait (40); break; } } if ((pDevice->PhyId & PHY_ID_REV_MASK) == PHY_BCM5401_B0_REV) { if (!(Value32 & PHY_STATUS_LINK_PASS) && (pDevice->OldLineSpeed == LM_LINE_SPEED_1000MBPS)) { LM_WritePhy (pDevice, PHY_CTRL_REG, PHY_CTRL_PHY_RESET); for (j = 0; j < 100; j++) { MM_Wait (10); LM_ReadPhy (pDevice, PHY_CTRL_REG, &Value32); if (! (Value32 & PHY_CTRL_PHY_RESET)) { MM_Wait (40); break; } } LM_WritePhy (pDevice, BCM5401_AUX_CTRL, 0x0c20); LM_WritePhy (pDevice, BCM540X_DSP_ADDRESS_REG, 0x0012); LM_WritePhy (pDevice, BCM540X_DSP_RW_PORT, 0x1804); LM_WritePhy (pDevice, BCM540X_DSP_ADDRESS_REG, 0x0013); LM_WritePhy (pDevice, BCM540X_DSP_RW_PORT, 0x1204); LM_WritePhy (pDevice, BCM540X_DSP_ADDRESS_REG, 0x8006); LM_WritePhy (pDevice, BCM540X_DSP_RW_PORT, 0x0132); LM_WritePhy (pDevice, BCM540X_DSP_ADDRESS_REG, 0x8006); LM_WritePhy (pDevice, BCM540X_DSP_RW_PORT, 0x0232); LM_WritePhy (pDevice, BCM540X_DSP_ADDRESS_REG, 0x201f); LM_WritePhy (pDevice, BCM540X_DSP_RW_PORT, 0x0a20); } } } } else if (pDevice->ChipRevId == T3_CHIP_ID_5701_A0 || pDevice->ChipRevId == T3_CHIP_ID_5701_B0) { /* Bug: 5701 A0, B0 TX CRC workaround. */ LM_WritePhy (pDevice, 0x15, 0x0a75); LM_WritePhy (pDevice, 0x1c, 0x8c68); LM_WritePhy (pDevice, 0x1c, 0x8d68); LM_WritePhy (pDevice, 0x1c, 0x8c68); } /* Acknowledge interrupts. */ LM_ReadPhy (pDevice, BCM540X_INT_STATUS_REG, &Value32); LM_ReadPhy (pDevice, BCM540X_INT_STATUS_REG, &Value32); /* Configure the interrupt mask. */ if (pDevice->PhyIntMode == T3_PHY_INT_MODE_MI_INTERRUPT) { LM_WritePhy (pDevice, BCM540X_INT_MASK_REG, ~BCM540X_INT_LINK_CHANGE); } /* Configure PHY led mode. */ if (T3_ASIC_REV (pDevice->ChipRevId) == T3_ASIC_REV_5701 || (T3_ASIC_REV (pDevice->ChipRevId) == T3_ASIC_REV_5700)) { if (pDevice->LedMode == LED_MODE_THREE_LINK) { LM_WritePhy (pDevice, BCM540X_EXT_CTRL_REG, BCM540X_EXT_CTRL_LINK3_LED_MODE); } else { LM_WritePhy (pDevice, BCM540X_EXT_CTRL_REG, 0); } } CurrentLinkStatus = LM_STATUS_LINK_DOWN; /* Get current link and duplex mode. */ for (j = 0; j < 100; j++) { LM_ReadPhy (pDevice, PHY_STATUS_REG, &Value32); LM_ReadPhy (pDevice, PHY_STATUS_REG, &Value32); if (Value32 & PHY_STATUS_LINK_PASS) { break; } MM_Wait (40); } if (Value32 & PHY_STATUS_LINK_PASS) { /* Determine the current line and duplex settings. */ LM_ReadPhy (pDevice, BCM540X_AUX_STATUS_REG, &Value32); for (j = 0; j < 2000; j++) { MM_Wait (10); LM_ReadPhy (pDevice, BCM540X_AUX_STATUS_REG, &Value32); if (Value32) { break; } } switch (Value32 & BCM540X_AUX_SPEED_MASK) { case BCM540X_AUX_10BASET_HD: CurrentLineSpeed = LM_LINE_SPEED_10MBPS; CurrentDuplexMode = LM_DUPLEX_MODE_HALF; break; case BCM540X_AUX_10BASET_FD: CurrentLineSpeed = LM_LINE_SPEED_10MBPS; CurrentDuplexMode = LM_DUPLEX_MODE_FULL; break; case BCM540X_AUX_100BASETX_HD: CurrentLineSpeed = LM_LINE_SPEED_100MBPS; CurrentDuplexMode = LM_DUPLEX_MODE_HALF; break; case BCM540X_AUX_100BASETX_FD: CurrentLineSpeed = LM_LINE_SPEED_100MBPS; CurrentDuplexMode = LM_DUPLEX_MODE_FULL; break; case BCM540X_AUX_100BASET_HD: CurrentLineSpeed = LM_LINE_SPEED_1000MBPS; CurrentDuplexMode = LM_DUPLEX_MODE_HALF; break; case BCM540X_AUX_100BASET_FD: CurrentLineSpeed = LM_LINE_SPEED_1000MBPS; CurrentDuplexMode = LM_DUPLEX_MODE_FULL; break; default: CurrentLineSpeed = LM_LINE_SPEED_UNKNOWN; CurrentDuplexMode = LM_DUPLEX_MODE_UNKNOWN; break; } /* Make sure we are in auto-neg mode. */ for (j = 0; j < 200; j++) { LM_ReadPhy (pDevice, PHY_CTRL_REG, &Value32); if (Value32 && Value32 != 0x7fff) { break; } if (Value32 == 0 && pDevice->RequestedMediaType == LM_REQUESTED_MEDIA_TYPE_UTP_10MBPS) { break; } MM_Wait (10); } /* Use the current line settings for "auto" mode. */ if (pDevice->RequestedMediaType == LM_REQUESTED_MEDIA_TYPE_AUTO || pDevice->RequestedMediaType == LM_REQUESTED_MEDIA_TYPE_UTP_AUTO) { if (Value32 & PHY_CTRL_AUTO_NEG_ENABLE) { CurrentLinkStatus = LM_STATUS_LINK_ACTIVE; /* We may be exiting low power mode and the link is in */ /* 10mb. In this case, we need to restart autoneg. */ LM_ReadPhy (pDevice, BCM540X_1000BASET_CTRL_REG, &Value32); pDevice->advertising1000 = Value32; /* 5702FE supports 10/100Mb only. */ if (T3_ASIC_REV (pDevice->ChipRevId) != T3_ASIC_REV_5703 || pDevice->BondId != GRC_MISC_BD_ID_5702FE) { if (! (Value32 & (BCM540X_AN_AD_1000BASET_HALF | BCM540X_AN_AD_1000BASET_FULL))) { CurrentLinkStatus = LM_STATUS_LINK_SETTING_MISMATCH; } } } else { CurrentLinkStatus = LM_STATUS_LINK_SETTING_MISMATCH; } } else { /* Force line settings. */ /* Use the current setting if it matches the user's requested */ /* setting. */ LM_ReadPhy (pDevice, PHY_CTRL_REG, &Value32); if ((pDevice->LineSpeed == CurrentLineSpeed) && (pDevice->DuplexMode == CurrentDuplexMode)) { if ((pDevice->DisableAutoNeg && !(Value32 & PHY_CTRL_AUTO_NEG_ENABLE)) || (!pDevice->DisableAutoNeg && (Value32 & PHY_CTRL_AUTO_NEG_ENABLE))) { CurrentLinkStatus = LM_STATUS_LINK_ACTIVE; } else { CurrentLinkStatus = LM_STATUS_LINK_SETTING_MISMATCH; } } else { CurrentLinkStatus = LM_STATUS_LINK_SETTING_MISMATCH; } } /* Save line settings. */ pDevice->LineSpeed = CurrentLineSpeed; pDevice->DuplexMode = CurrentDuplexMode; pDevice->MediaType = LM_MEDIA_TYPE_UTP; } return CurrentLinkStatus; } /* LM_InitBcm540xPhy */ /******************************************************************************/ /* Description: */ /* */ /* Return: */ /******************************************************************************/ LM_STATUS LM_SetFlowControl (PLM_DEVICE_BLOCK pDevice, LM_UINT32 LocalPhyAd, LM_UINT32 RemotePhyAd) { LM_FLOW_CONTROL FlowCap; /* Resolve flow control. */ FlowCap = LM_FLOW_CONTROL_NONE; /* See Table 28B-3 of 802.3ab-1999 spec. */ if (pDevice->FlowControlCap & LM_FLOW_CONTROL_AUTO_PAUSE) { if (LocalPhyAd & PHY_AN_AD_PAUSE_CAPABLE) { if (LocalPhyAd & PHY_AN_AD_ASYM_PAUSE) { if (RemotePhyAd & PHY_LINK_PARTNER_PAUSE_CAPABLE) { FlowCap = LM_FLOW_CONTROL_TRANSMIT_PAUSE | LM_FLOW_CONTROL_RECEIVE_PAUSE; } else if (RemotePhyAd & PHY_LINK_PARTNER_ASYM_PAUSE) { FlowCap = LM_FLOW_CONTROL_RECEIVE_PAUSE; } } else { if (RemotePhyAd & PHY_LINK_PARTNER_PAUSE_CAPABLE) { FlowCap = LM_FLOW_CONTROL_TRANSMIT_PAUSE | LM_FLOW_CONTROL_RECEIVE_PAUSE; } } } else if (LocalPhyAd & PHY_AN_AD_ASYM_PAUSE) { if ((RemotePhyAd & PHY_LINK_PARTNER_PAUSE_CAPABLE) && (RemotePhyAd & PHY_LINK_PARTNER_ASYM_PAUSE)) { FlowCap = LM_FLOW_CONTROL_TRANSMIT_PAUSE; } } } else { FlowCap = pDevice->FlowControlCap; } /* Enable/disable rx PAUSE. */ pDevice->RxMode &= ~RX_MODE_ENABLE_FLOW_CONTROL; if (FlowCap & LM_FLOW_CONTROL_RECEIVE_PAUSE && (pDevice->FlowControlCap == LM_FLOW_CONTROL_AUTO_PAUSE || pDevice->FlowControlCap & LM_FLOW_CONTROL_RECEIVE_PAUSE)) { pDevice->FlowControl |= LM_FLOW_CONTROL_RECEIVE_PAUSE; pDevice->RxMode |= RX_MODE_ENABLE_FLOW_CONTROL; } REG_WR (pDevice, MacCtrl.RxMode, pDevice->RxMode); /* Enable/disable tx PAUSE. */ pDevice->TxMode &= ~TX_MODE_ENABLE_FLOW_CONTROL; if (FlowCap & LM_FLOW_CONTROL_TRANSMIT_PAUSE && (pDevice->FlowControlCap == LM_FLOW_CONTROL_AUTO_PAUSE || pDevice->FlowControlCap & LM_FLOW_CONTROL_TRANSMIT_PAUSE)) { pDevice->FlowControl |= LM_FLOW_CONTROL_TRANSMIT_PAUSE; pDevice->TxMode |= TX_MODE_ENABLE_FLOW_CONTROL; } REG_WR (pDevice, MacCtrl.TxMode, pDevice->TxMode); return LM_STATUS_SUCCESS; } #if INCLUDE_TBI_SUPPORT /******************************************************************************/ /* Description: */ /* */ /* Return: */ /******************************************************************************/ STATIC LM_STATUS LM_InitBcm800xPhy (PLM_DEVICE_BLOCK pDevice) { LM_UINT32 Value32; LM_UINT32 j; Value32 = REG_RD (pDevice, MacCtrl.Status); /* Reset the SERDES during init and when we have link. */ if (!pDevice->InitDone || Value32 & MAC_STATUS_PCS_SYNCED) { /* Set PLL lock range. */ LM_WritePhy (pDevice, 0x16, 0x8007); /* Software reset. */ LM_WritePhy (pDevice, 0x00, 0x8000); /* Wait for reset to complete. */ for (j = 0; j < 500; j++) { MM_Wait (10); } /* Config mode; seletct PMA/Ch 1 regs. */ LM_WritePhy (pDevice, 0x10, 0x8411); /* Enable auto-lock and comdet, select txclk for tx. */ LM_WritePhy (pDevice, 0x11, 0x0a10); LM_WritePhy (pDevice, 0x18, 0x00a0); LM_WritePhy (pDevice, 0x16, 0x41ff); /* Assert and deassert POR. */ LM_WritePhy (pDevice, 0x13, 0x0400); MM_Wait (40); LM_WritePhy (pDevice, 0x13, 0x0000); LM_WritePhy (pDevice, 0x11, 0x0a50); MM_Wait (40); LM_WritePhy (pDevice, 0x11, 0x0a10); /* Delay for signal to stabilize. */ for (j = 0; j < 15000; j++) { MM_Wait (10); } /* Deselect the channel register so we can read the PHY id later. */ LM_WritePhy (pDevice, 0x10, 0x8011); } return LM_STATUS_SUCCESS; } /******************************************************************************/ /* Description: */ /* */ /* Return: */ /******************************************************************************/ STATIC LM_STATUS LM_SetupFiberPhy (PLM_DEVICE_BLOCK pDevice) { LM_STATUS CurrentLinkStatus; AUTONEG_STATUS AnStatus = 0; LM_UINT32 Value32; LM_UINT32 Cnt; LM_UINT32 j, k; pDevice->MacMode &= ~(MAC_MODE_HALF_DUPLEX | MAC_MODE_PORT_MODE_MASK); /* Initialize the send_config register. */ REG_WR (pDevice, MacCtrl.TxAutoNeg, 0); /* Enable TBI and full duplex mode. */ pDevice->MacMode |= MAC_MODE_PORT_MODE_TBI; REG_WR (pDevice, MacCtrl.Mode, pDevice->MacMode); /* Initialize the BCM8002 SERDES PHY. */ switch (pDevice->PhyId & PHY_ID_MASK) { case PHY_BCM8002_PHY_ID: LM_InitBcm800xPhy (pDevice); break; default: break; } /* Enable link change interrupt. */ REG_WR (pDevice, MacCtrl.MacEvent, MAC_EVENT_ENABLE_LINK_STATE_CHANGED_ATTN); /* Default to link down. */ CurrentLinkStatus = LM_STATUS_LINK_DOWN; /* Get the link status. */ Value32 = REG_RD (pDevice, MacCtrl.Status); if (Value32 & MAC_STATUS_PCS_SYNCED) { if ((pDevice->RequestedMediaType == LM_REQUESTED_MEDIA_TYPE_AUTO) || (pDevice->DisableAutoNeg == FALSE)) { /* auto-negotiation mode. */ /* Initialize the autoneg default capaiblities. */ AutonegInit (&pDevice->AnInfo); /* Set the context pointer to point to the main device structure. */ pDevice->AnInfo.pContext = pDevice; /* Setup flow control advertisement register. */ Value32 = GetPhyAdFlowCntrlSettings (pDevice); if (Value32 & PHY_AN_AD_PAUSE_CAPABLE) { pDevice->AnInfo.mr_adv_sym_pause = 1; } else { pDevice->AnInfo.mr_adv_sym_pause = 0; } if (Value32 & PHY_AN_AD_ASYM_PAUSE) { pDevice->AnInfo.mr_adv_asym_pause = 1; } else { pDevice->AnInfo.mr_adv_asym_pause = 0; } /* Try to autoneg up to six times. */ if (pDevice->IgnoreTbiLinkChange) { Cnt = 1; } else { Cnt = 6; } for (j = 0; j < Cnt; j++) { REG_WR (pDevice, MacCtrl.TxAutoNeg, 0); Value32 = pDevice->MacMode & ~MAC_MODE_PORT_MODE_MASK; REG_WR (pDevice, MacCtrl.Mode, Value32); MM_Wait (20); REG_WR (pDevice, MacCtrl.Mode, pDevice-> MacMode | MAC_MODE_SEND_CONFIGS); MM_Wait (20); pDevice->AnInfo.State = AN_STATE_UNKNOWN; pDevice->AnInfo.CurrentTime_us = 0; REG_WR (pDevice, Grc.Timer, 0); for (k = 0; (pDevice->AnInfo.CurrentTime_us < 75000) && (k < 75000); k++) { AnStatus = Autoneg8023z (&pDevice->AnInfo); if ((AnStatus == AUTONEG_STATUS_DONE) || (AnStatus == AUTONEG_STATUS_FAILED)) { break; } pDevice->AnInfo.CurrentTime_us = REG_RD (pDevice, Grc.Timer); } if ((AnStatus == AUTONEG_STATUS_DONE) || (AnStatus == AUTONEG_STATUS_FAILED)) { break; } if (j >= 1) { if (!(REG_RD (pDevice, MacCtrl.Status) & MAC_STATUS_PCS_SYNCED)) { break; } } } /* Stop sending configs. */ MM_AnTxIdle (&pDevice->AnInfo); /* Resolve flow control settings. */ if ((AnStatus == AUTONEG_STATUS_DONE) && pDevice->AnInfo.mr_an_complete && pDevice->AnInfo.mr_link_ok && pDevice->AnInfo.mr_lp_adv_full_duplex) { LM_UINT32 RemotePhyAd; LM_UINT32 LocalPhyAd; LocalPhyAd = 0; if (pDevice->AnInfo.mr_adv_sym_pause) { LocalPhyAd |= PHY_AN_AD_PAUSE_CAPABLE; } if (pDevice->AnInfo.mr_adv_asym_pause) { LocalPhyAd |= PHY_AN_AD_ASYM_PAUSE; } RemotePhyAd = 0; if (pDevice->AnInfo.mr_lp_adv_sym_pause) { RemotePhyAd |= PHY_LINK_PARTNER_PAUSE_CAPABLE; } if (pDevice->AnInfo.mr_lp_adv_asym_pause) { RemotePhyAd |= PHY_LINK_PARTNER_ASYM_PAUSE; } LM_SetFlowControl (pDevice, LocalPhyAd, RemotePhyAd); CurrentLinkStatus = LM_STATUS_LINK_ACTIVE; } for (j = 0; j < 30; j++) { MM_Wait (20); REG_WR (pDevice, MacCtrl.Status, MAC_STATUS_SYNC_CHANGED | MAC_STATUS_CFG_CHANGED); MM_Wait (20); if ((REG_RD (pDevice, MacCtrl.Status) & (MAC_STATUS_SYNC_CHANGED | MAC_STATUS_CFG_CHANGED)) == 0) break; } if (pDevice->PollTbiLink) { Value32 = REG_RD (pDevice, MacCtrl.Status); if (Value32 & MAC_STATUS_RECEIVING_CFG) { pDevice->IgnoreTbiLinkChange = TRUE; } else { pDevice->IgnoreTbiLinkChange = FALSE; } } Value32 = REG_RD (pDevice, MacCtrl.Status); if (CurrentLinkStatus == LM_STATUS_LINK_DOWN && (Value32 & MAC_STATUS_PCS_SYNCED) && ((Value32 & MAC_STATUS_RECEIVING_CFG) == 0)) { CurrentLinkStatus = LM_STATUS_LINK_ACTIVE; } } else { /* We are forcing line speed. */ pDevice->FlowControlCap &= ~LM_FLOW_CONTROL_AUTO_PAUSE; LM_SetFlowControl (pDevice, 0, 0); CurrentLinkStatus = LM_STATUS_LINK_ACTIVE; REG_WR (pDevice, MacCtrl.Mode, pDevice->MacMode | MAC_MODE_SEND_CONFIGS); } } /* Set the link polarity bit. */ pDevice->MacMode &= ~MAC_MODE_LINK_POLARITY; REG_WR (pDevice, MacCtrl.Mode, pDevice->MacMode); pDevice->pStatusBlkVirt->Status = STATUS_BLOCK_UPDATED | (pDevice->pStatusBlkVirt-> Status & ~STATUS_BLOCK_LINK_CHANGED_STATUS); for (j = 0; j < 100; j++) { REG_WR (pDevice, MacCtrl.Status, MAC_STATUS_SYNC_CHANGED | MAC_STATUS_CFG_CHANGED); MM_Wait (5); if ((REG_RD (pDevice, MacCtrl.Status) & (MAC_STATUS_SYNC_CHANGED | MAC_STATUS_CFG_CHANGED)) == 0) break; } Value32 = REG_RD (pDevice, MacCtrl.Status); if ((Value32 & MAC_STATUS_PCS_SYNCED) == 0) { CurrentLinkStatus = LM_STATUS_LINK_DOWN; if (pDevice->DisableAutoNeg == FALSE) { REG_WR (pDevice, MacCtrl.Mode, pDevice->MacMode | MAC_MODE_SEND_CONFIGS); MM_Wait (1); REG_WR (pDevice, MacCtrl.Mode, pDevice->MacMode); } } /* Initialize the current link status. */ if (CurrentLinkStatus == LM_STATUS_LINK_ACTIVE) { pDevice->LineSpeed = LM_LINE_SPEED_1000MBPS; pDevice->DuplexMode = LM_DUPLEX_MODE_FULL; REG_WR (pDevice, MacCtrl.LedCtrl, LED_CTRL_OVERRIDE_LINK_LED | LED_CTRL_1000MBPS_LED_ON); } else { pDevice->LineSpeed = LM_LINE_SPEED_UNKNOWN; pDevice->DuplexMode = LM_DUPLEX_MODE_UNKNOWN; REG_WR (pDevice, MacCtrl.LedCtrl, LED_CTRL_OVERRIDE_LINK_LED | LED_CTRL_OVERRIDE_TRAFFIC_LED); } /* Indicate link status. */ if (pDevice->LinkStatus != CurrentLinkStatus) { pDevice->LinkStatus = CurrentLinkStatus; MM_IndicateStatus (pDevice, CurrentLinkStatus); } return LM_STATUS_SUCCESS; } #endif /* INCLUDE_TBI_SUPPORT */ /******************************************************************************/ /* Description: */ /* */ /* Return: */ /******************************************************************************/ LM_STATUS LM_SetupCopperPhy (PLM_DEVICE_BLOCK pDevice) { LM_STATUS CurrentLinkStatus; LM_UINT32 Value32; /* Assume there is not link first. */ CurrentLinkStatus = LM_STATUS_LINK_DOWN; /* Disable phy link change attention. */ REG_WR (pDevice, MacCtrl.MacEvent, 0); /* Clear link change attention. */ REG_WR (pDevice, MacCtrl.Status, MAC_STATUS_SYNC_CHANGED | MAC_STATUS_CFG_CHANGED); /* Disable auto-polling for the moment. */ pDevice->MiMode = 0xc0000; REG_WR (pDevice, MacCtrl.MiMode, pDevice->MiMode); MM_Wait (40); /* Determine the requested line speed and duplex. */ pDevice->OldLineSpeed = pDevice->LineSpeed; LM_TranslateRequestedMediaType (pDevice->RequestedMediaType, &pDevice->MediaType, &pDevice->LineSpeed, &pDevice->DuplexMode); /* Initialize the phy chip. */ switch (pDevice->PhyId & PHY_ID_MASK) { case PHY_BCM5400_PHY_ID: case PHY_BCM5401_PHY_ID: case PHY_BCM5411_PHY_ID: case PHY_BCM5701_PHY_ID: case PHY_BCM5703_PHY_ID: case PHY_BCM5704_PHY_ID: CurrentLinkStatus = LM_InitBcm540xPhy (pDevice); break; default: break; } if (CurrentLinkStatus == LM_STATUS_LINK_SETTING_MISMATCH) { CurrentLinkStatus = LM_STATUS_LINK_DOWN; } /* Setup flow control. */ pDevice->FlowControl = LM_FLOW_CONTROL_NONE; if (CurrentLinkStatus == LM_STATUS_LINK_ACTIVE) { LM_FLOW_CONTROL FlowCap; /* Flow control capability. */ FlowCap = LM_FLOW_CONTROL_NONE; if (pDevice->DuplexMode == LM_DUPLEX_MODE_FULL) { if (pDevice->DisableAutoNeg == FALSE || pDevice->RequestedMediaType == LM_REQUESTED_MEDIA_TYPE_AUTO || pDevice->RequestedMediaType == LM_REQUESTED_MEDIA_TYPE_UTP_AUTO) { LM_UINT32 ExpectedPhyAd; LM_UINT32 LocalPhyAd; LM_UINT32 RemotePhyAd; LM_ReadPhy (pDevice, PHY_AN_AD_REG, &LocalPhyAd); pDevice->advertising = LocalPhyAd; LocalPhyAd &= (PHY_AN_AD_ASYM_PAUSE | PHY_AN_AD_PAUSE_CAPABLE); ExpectedPhyAd = GetPhyAdFlowCntrlSettings (pDevice); if (LocalPhyAd != ExpectedPhyAd) { CurrentLinkStatus = LM_STATUS_LINK_DOWN; } else { LM_ReadPhy (pDevice, PHY_LINK_PARTNER_ABILITY_REG, &RemotePhyAd); LM_SetFlowControl (pDevice, LocalPhyAd, RemotePhyAd); } } else { pDevice->FlowControlCap &= ~LM_FLOW_CONTROL_AUTO_PAUSE; LM_SetFlowControl (pDevice, 0, 0); } } } if (CurrentLinkStatus == LM_STATUS_LINK_DOWN) { LM_ForceAutoNeg (pDevice, pDevice->RequestedMediaType); /* If we force line speed, we make get link right away. */ LM_ReadPhy (pDevice, PHY_STATUS_REG, &Value32); LM_ReadPhy (pDevice, PHY_STATUS_REG, &Value32); if (Value32 & PHY_STATUS_LINK_PASS) { CurrentLinkStatus = LM_STATUS_LINK_ACTIVE; } } /* GMII interface. */ pDevice->MacMode &= ~MAC_MODE_PORT_MODE_MASK; if (CurrentLinkStatus == LM_STATUS_LINK_ACTIVE) { if (pDevice->LineSpeed == LM_LINE_SPEED_100MBPS || pDevice->LineSpeed == LM_LINE_SPEED_10MBPS) { pDevice->MacMode |= MAC_MODE_PORT_MODE_MII; } else { pDevice->MacMode |= MAC_MODE_PORT_MODE_GMII; } } else { pDevice->MacMode |= MAC_MODE_PORT_MODE_GMII; } /* Set the MAC to operate in the appropriate duplex mode. */ pDevice->MacMode &= ~MAC_MODE_HALF_DUPLEX; if (pDevice->DuplexMode == LM_DUPLEX_MODE_HALF) { pDevice->MacMode |= MAC_MODE_HALF_DUPLEX; } /* Set the link polarity bit. */ pDevice->MacMode &= ~MAC_MODE_LINK_POLARITY; if (T3_ASIC_REV (pDevice->ChipRevId) == T3_ASIC_REV_5700) { if ((pDevice->LedMode == LED_MODE_LINK10) || (CurrentLinkStatus == LM_STATUS_LINK_ACTIVE && pDevice->LineSpeed == LM_LINE_SPEED_10MBPS)) { pDevice->MacMode |= MAC_MODE_LINK_POLARITY; } } else { if (CurrentLinkStatus == LM_STATUS_LINK_ACTIVE) { pDevice->MacMode |= MAC_MODE_LINK_POLARITY; } /* Set LED mode. */ if (T3_ASIC_REV (pDevice->ChipRevId) == T3_ASIC_REV_5700 || T3_ASIC_REV (pDevice->ChipRevId) == T3_ASIC_REV_5701) { Value32 = LED_CTRL_PHY_MODE_1; } else { if (pDevice->LedMode == LED_MODE_OUTPUT) { Value32 = LED_CTRL_PHY_MODE_2; } else { Value32 = LED_CTRL_PHY_MODE_1; } } REG_WR (pDevice, MacCtrl.LedCtrl, Value32); } REG_WR (pDevice, MacCtrl.Mode, pDevice->MacMode); /* Enable auto polling. */ if (pDevice->PhyIntMode == T3_PHY_INT_MODE_AUTO_POLLING) { pDevice->MiMode |= MI_MODE_AUTO_POLLING_ENABLE; REG_WR (pDevice, MacCtrl.MiMode, pDevice->MiMode); } /* Enable phy link change attention. */ if (pDevice->PhyIntMode == T3_PHY_INT_MODE_MI_INTERRUPT) { REG_WR (pDevice, MacCtrl.MacEvent, MAC_EVENT_ENABLE_MI_INTERRUPT); } else { REG_WR (pDevice, MacCtrl.MacEvent, MAC_EVENT_ENABLE_LINK_STATE_CHANGED_ATTN); } if ((T3_ASIC_REV (pDevice->ChipRevId) == T3_ASIC_REV_5700) && (CurrentLinkStatus == LM_STATUS_LINK_ACTIVE) && (pDevice->LineSpeed == LM_LINE_SPEED_1000MBPS) && (((pDevice->PciState & T3_PCI_STATE_CONVENTIONAL_PCI_MODE) && (pDevice->PciState & T3_PCI_STATE_BUS_SPEED_HIGH)) || !(pDevice->PciState & T3_PCI_STATE_CONVENTIONAL_PCI_MODE))) { MM_Wait (120); REG_WR (pDevice, MacCtrl.Status, MAC_STATUS_SYNC_CHANGED | MAC_STATUS_CFG_CHANGED); MEM_WR_OFFSET (pDevice, T3_FIRMWARE_MAILBOX, T3_MAGIC_NUM_DISABLE_DMAW_ON_LINK_CHANGE); } /* Indicate link status. */ if (pDevice->LinkStatus != CurrentLinkStatus) { pDevice->LinkStatus = CurrentLinkStatus; MM_IndicateStatus (pDevice, CurrentLinkStatus); } return LM_STATUS_SUCCESS; } /* LM_SetupCopperPhy */ /******************************************************************************/ /* Description: */ /* */ /* Return: */ /******************************************************************************/ LM_STATUS LM_SetupPhy (PLM_DEVICE_BLOCK pDevice) { LM_STATUS LmStatus; LM_UINT32 Value32; #if INCLUDE_TBI_SUPPORT if (pDevice->EnableTbi) { LmStatus = LM_SetupFiberPhy (pDevice); } else #endif /* INCLUDE_TBI_SUPPORT */ { LmStatus = LM_SetupCopperPhy (pDevice); } if (pDevice->ChipRevId == T3_CHIP_ID_5704_A0) { if (!(pDevice->PciState & T3_PCI_STATE_CONVENTIONAL_PCI_MODE)) { Value32 = REG_RD (pDevice, PciCfg.PciState); REG_WR (pDevice, PciCfg.PciState, Value32 | T3_PCI_STATE_RETRY_SAME_DMA); } } if ((pDevice->LineSpeed == LM_LINE_SPEED_1000MBPS) && (pDevice->DuplexMode == LM_DUPLEX_MODE_HALF)) { REG_WR (pDevice, MacCtrl.TxLengths, 0x26ff); } else { REG_WR (pDevice, MacCtrl.TxLengths, 0x2620); } return LmStatus; } /******************************************************************************/ /* Description: */ /* */ /* Return: */ /******************************************************************************/ LM_VOID LM_ReadPhy (PLM_DEVICE_BLOCK pDevice, LM_UINT32 PhyReg, PLM_UINT32 pData32) { LM_UINT32 Value32; LM_UINT32 j; if (pDevice->PhyIntMode == T3_PHY_INT_MODE_AUTO_POLLING) { REG_WR (pDevice, MacCtrl.MiMode, pDevice->MiMode & ~MI_MODE_AUTO_POLLING_ENABLE); MM_Wait (40); } Value32 = (pDevice->PhyAddr << MI_COM_FIRST_PHY_ADDR_BIT) | ((PhyReg & MI_COM_PHY_REG_ADDR_MASK) << MI_COM_FIRST_PHY_REG_ADDR_BIT) | MI_COM_CMD_READ | MI_COM_START; REG_WR (pDevice, MacCtrl.MiCom, Value32); for (j = 0; j < 20; j++) { MM_Wait (25); Value32 = REG_RD (pDevice, MacCtrl.MiCom); if (!(Value32 & MI_COM_BUSY)) { MM_Wait (5); Value32 = REG_RD (pDevice, MacCtrl.MiCom); Value32 &= MI_COM_PHY_DATA_MASK; break; } } if (Value32 & MI_COM_BUSY) { Value32 = 0; } *pData32 = Value32; if (pDevice->PhyIntMode == T3_PHY_INT_MODE_AUTO_POLLING) { REG_WR (pDevice, MacCtrl.MiMode, pDevice->MiMode); MM_Wait (40); } } /* LM_ReadPhy */ /******************************************************************************/ /* Description: */ /* */ /* Return: */ /******************************************************************************/ LM_VOID LM_WritePhy (PLM_DEVICE_BLOCK pDevice, LM_UINT32 PhyReg, LM_UINT32 Data32) { LM_UINT32 Value32; LM_UINT32 j; if (pDevice->PhyIntMode == T3_PHY_INT_MODE_AUTO_POLLING) { REG_WR (pDevice, MacCtrl.MiMode, pDevice->MiMode & ~MI_MODE_AUTO_POLLING_ENABLE); MM_Wait (40); } Value32 = (pDevice->PhyAddr << MI_COM_FIRST_PHY_ADDR_BIT) | ((PhyReg & MI_COM_PHY_REG_ADDR_MASK) << MI_COM_FIRST_PHY_REG_ADDR_BIT) | (Data32 & MI_COM_PHY_DATA_MASK) | MI_COM_CMD_WRITE | MI_COM_START; REG_WR (pDevice, MacCtrl.MiCom, Value32); for (j = 0; j < 20; j++) { MM_Wait (25); Value32 = REG_RD (pDevice, MacCtrl.MiCom); if (!(Value32 & MI_COM_BUSY)) { MM_Wait (5); break; } } if (pDevice->PhyIntMode == T3_PHY_INT_MODE_AUTO_POLLING) { REG_WR (pDevice, MacCtrl.MiMode, pDevice->MiMode); MM_Wait (40); } } /* LM_WritePhy */ /******************************************************************************/ /* Description: */ /* */ /* Return: */ /******************************************************************************/ LM_STATUS LM_SetPowerState (PLM_DEVICE_BLOCK pDevice, LM_POWER_STATE PowerLevel) { LM_UINT32 PmeSupport; LM_UINT32 Value32; LM_UINT32 PmCtrl; /* make sureindirect accesses are enabled */ MM_WriteConfig32 (pDevice, T3_PCI_MISC_HOST_CTRL_REG, pDevice->MiscHostCtrl); /* Clear the PME_ASSERT bit and the power state bits. Also enable */ /* the PME bit. */ MM_ReadConfig32 (pDevice, T3_PCI_PM_STATUS_CTRL_REG, &PmCtrl); PmCtrl |= T3_PM_PME_ASSERTED; PmCtrl &= ~T3_PM_POWER_STATE_MASK; /* Set the appropriate power state. */ if (PowerLevel == LM_POWER_STATE_D0) { /* Bring the card out of low power mode. */ PmCtrl |= T3_PM_POWER_STATE_D0; MM_WriteConfig32 (pDevice, T3_PCI_PM_STATUS_CTRL_REG, PmCtrl); REG_WR (pDevice, Grc.LocalCtrl, pDevice->GrcLocalCtrl); MM_Wait (40); #if 0 /* Bugfix by jmb...can't call WritePhy here because pDevice not fully initialized */ LM_WritePhy (pDevice, BCM5401_AUX_CTRL, 0x02); #endif return LM_STATUS_SUCCESS; } else if (PowerLevel == LM_POWER_STATE_D1) { PmCtrl |= T3_PM_POWER_STATE_D1; } else if (PowerLevel == LM_POWER_STATE_D2) { PmCtrl |= T3_PM_POWER_STATE_D2; } else if (PowerLevel == LM_POWER_STATE_D3) { PmCtrl |= T3_PM_POWER_STATE_D3; } else { return LM_STATUS_FAILURE; } PmCtrl |= T3_PM_PME_ENABLE; /* Mask out all interrupts so LM_SetupPhy won't be called while we are */ /* setting new line speed. */ Value32 = REG_RD (pDevice, PciCfg.MiscHostCtrl); REG_WR (pDevice, PciCfg.MiscHostCtrl, Value32 | MISC_HOST_CTRL_MASK_PCI_INT); if (!pDevice->RestoreOnWakeUp) { pDevice->RestoreOnWakeUp = TRUE; pDevice->WakeUpDisableAutoNeg = pDevice->DisableAutoNeg; pDevice->WakeUpRequestedMediaType = pDevice->RequestedMediaType; } /* Force auto-negotiation to 10 line speed. */ pDevice->DisableAutoNeg = FALSE; pDevice->RequestedMediaType = LM_REQUESTED_MEDIA_TYPE_UTP_10MBPS; LM_SetupPhy (pDevice); /* Put the driver in the initial state, and go through the power down */ /* sequence. */ LM_Halt (pDevice); MM_ReadConfig32 (pDevice, T3_PCI_PM_CAP_REG, &PmeSupport); if (pDevice->WakeUpModeCap != LM_WAKE_UP_MODE_NONE) { /* Enable WOL. */ LM_WritePhy (pDevice, BCM5401_AUX_CTRL, 0x5a); MM_Wait (40); /* Set LED mode. */ if (T3_ASIC_REV (pDevice->ChipRevId) == T3_ASIC_REV_5700 || T3_ASIC_REV (pDevice->ChipRevId) == T3_ASIC_REV_5701) { Value32 = LED_CTRL_PHY_MODE_1; } else { if (pDevice->LedMode == LED_MODE_OUTPUT) { Value32 = LED_CTRL_PHY_MODE_2; } else { Value32 = LED_CTRL_PHY_MODE_1; } } Value32 = MAC_MODE_PORT_MODE_MII; if (T3_ASIC_REV (pDevice->ChipRevId) == T3_ASIC_REV_5700) { if (pDevice->LedMode == LED_MODE_LINK10 || pDevice->WolSpeed == WOL_SPEED_10MB) { Value32 |= MAC_MODE_LINK_POLARITY; } } else { Value32 |= MAC_MODE_LINK_POLARITY; } REG_WR (pDevice, MacCtrl.Mode, Value32); MM_Wait (40); MM_Wait (40); MM_Wait (40); /* Always enable magic packet wake-up if we have vaux. */ if ((PmeSupport & T3_PCI_PM_CAP_PME_D3COLD) && (pDevice->WakeUpModeCap & LM_WAKE_UP_MODE_MAGIC_PACKET)) { Value32 |= MAC_MODE_DETECT_MAGIC_PACKET_ENABLE; } REG_WR (pDevice, MacCtrl.Mode, Value32); /* Enable the receiver. */ REG_WR (pDevice, MacCtrl.RxMode, RX_MODE_ENABLE); } /* Disable tx/rx clocks, and seletect an alternate clock. */ if (pDevice->WolSpeed == WOL_SPEED_100MB) { if (T3_ASIC_REV (pDevice->ChipRevId) == T3_ASIC_REV_5700 || T3_ASIC_REV (pDevice->ChipRevId) == T3_ASIC_REV_5701) { Value32 = T3_PCI_DISABLE_RX_CLOCK | T3_PCI_DISABLE_TX_CLOCK | T3_PCI_SELECT_ALTERNATE_CLOCK; } else { Value32 = T3_PCI_SELECT_ALTERNATE_CLOCK; } REG_WR (pDevice, PciCfg.ClockCtrl, Value32); MM_Wait (40); if (T3_ASIC_REV (pDevice->ChipRevId) == T3_ASIC_REV_5700 || T3_ASIC_REV (pDevice->ChipRevId) == T3_ASIC_REV_5701) { Value32 = T3_PCI_DISABLE_RX_CLOCK | T3_PCI_DISABLE_TX_CLOCK | T3_PCI_SELECT_ALTERNATE_CLOCK | T3_PCI_44MHZ_CORE_CLOCK; } else { Value32 = T3_PCI_SELECT_ALTERNATE_CLOCK | T3_PCI_44MHZ_CORE_CLOCK; } REG_WR (pDevice, PciCfg.ClockCtrl, Value32); MM_Wait (40); if (T3_ASIC_REV (pDevice->ChipRevId) == T3_ASIC_REV_5700 || T3_ASIC_REV (pDevice->ChipRevId) == T3_ASIC_REV_5701) { Value32 = T3_PCI_DISABLE_RX_CLOCK | T3_PCI_DISABLE_TX_CLOCK | T3_PCI_44MHZ_CORE_CLOCK; } else { Value32 = T3_PCI_44MHZ_CORE_CLOCK; } REG_WR (pDevice, PciCfg.ClockCtrl, Value32); } else { if (T3_ASIC_REV (pDevice->ChipRevId) == T3_ASIC_REV_5700 || T3_ASIC_REV (pDevice->ChipRevId) == T3_ASIC_REV_5701) { Value32 = T3_PCI_DISABLE_RX_CLOCK | T3_PCI_DISABLE_TX_CLOCK | T3_PCI_SELECT_ALTERNATE_CLOCK | T3_PCI_POWER_DOWN_PCI_PLL133; } else { Value32 = T3_PCI_SELECT_ALTERNATE_CLOCK | T3_PCI_POWER_DOWN_PCI_PLL133; } REG_WR (pDevice, PciCfg.ClockCtrl, Value32); } MM_Wait (40); if (!pDevice->EepromWp && (pDevice->WakeUpModeCap != LM_WAKE_UP_MODE_NONE)) { /* Switch adapter to auxilliary power. */ if (T3_ASIC_REV (pDevice->ChipRevId) == T3_ASIC_REV_5700 || T3_ASIC_REV (pDevice->ChipRevId) == T3_ASIC_REV_5701) { /* GPIO0 = 1, GPIO1 = 1, GPIO2 = 0. */ REG_WR (pDevice, Grc.LocalCtrl, pDevice->GrcLocalCtrl | GRC_MISC_LOCAL_CTRL_GPIO_OE0 | GRC_MISC_LOCAL_CTRL_GPIO_OE1 | GRC_MISC_LOCAL_CTRL_GPIO_OE2 | GRC_MISC_LOCAL_CTRL_GPIO_OUTPUT0 | GRC_MISC_LOCAL_CTRL_GPIO_OUTPUT1); MM_Wait (40); } else { /* GPIO0 = 0, GPIO1 = 1, GPIO2 = 1. */ REG_WR (pDevice, Grc.LocalCtrl, pDevice->GrcLocalCtrl | GRC_MISC_LOCAL_CTRL_GPIO_OE0 | GRC_MISC_LOCAL_CTRL_GPIO_OE1 | GRC_MISC_LOCAL_CTRL_GPIO_OE2 | GRC_MISC_LOCAL_CTRL_GPIO_OUTPUT1 | GRC_MISC_LOCAL_CTRL_GPIO_OUTPUT2); MM_Wait (40); /* GPIO0 = 1, GPIO1 = 1, GPIO2 = 1. */ REG_WR (pDevice, Grc.LocalCtrl, pDevice->GrcLocalCtrl | GRC_MISC_LOCAL_CTRL_GPIO_OE0 | GRC_MISC_LOCAL_CTRL_GPIO_OE1 | GRC_MISC_LOCAL_CTRL_GPIO_OE2 | GRC_MISC_LOCAL_CTRL_GPIO_OUTPUT0 | GRC_MISC_LOCAL_CTRL_GPIO_OUTPUT1 | GRC_MISC_LOCAL_CTRL_GPIO_OUTPUT2); MM_Wait (40); /* GPIO0 = 1, GPIO1 = 1, GPIO2 = 0. */ REG_WR (pDevice, Grc.LocalCtrl, pDevice->GrcLocalCtrl | GRC_MISC_LOCAL_CTRL_GPIO_OE0 | GRC_MISC_LOCAL_CTRL_GPIO_OE1 | GRC_MISC_LOCAL_CTRL_GPIO_OE2 | GRC_MISC_LOCAL_CTRL_GPIO_OUTPUT0 | GRC_MISC_LOCAL_CTRL_GPIO_OUTPUT1); MM_Wait (40); } } /* Set the phy to low power mode. */ /* Put the the hardware in low power mode. */ MM_WriteConfig32 (pDevice, T3_PCI_PM_STATUS_CTRL_REG, PmCtrl); return LM_STATUS_SUCCESS; } /* LM_SetPowerState */ /******************************************************************************/ /* Description: */ /* */ /* Return: */ /******************************************************************************/ static LM_UINT32 GetPhyAdFlowCntrlSettings (PLM_DEVICE_BLOCK pDevice) { LM_UINT32 Value32; Value32 = 0; /* Auto negotiation flow control only when autonegotiation is enabled. */ if (pDevice->DisableAutoNeg == FALSE || pDevice->RequestedMediaType == LM_REQUESTED_MEDIA_TYPE_AUTO || pDevice->RequestedMediaType == LM_REQUESTED_MEDIA_TYPE_UTP_AUTO) { /* Please refer to Table 28B-3 of the 802.3ab-1999 spec. */ if ((pDevice->FlowControlCap == LM_FLOW_CONTROL_AUTO_PAUSE) || ((pDevice->FlowControlCap & LM_FLOW_CONTROL_RECEIVE_PAUSE) && (pDevice-> FlowControlCap & LM_FLOW_CONTROL_TRANSMIT_PAUSE))) { Value32 |= PHY_AN_AD_PAUSE_CAPABLE; } else if (pDevice-> FlowControlCap & LM_FLOW_CONTROL_TRANSMIT_PAUSE) { Value32 |= PHY_AN_AD_ASYM_PAUSE; } else if (pDevice-> FlowControlCap & LM_FLOW_CONTROL_RECEIVE_PAUSE) { Value32 |= PHY_AN_AD_PAUSE_CAPABLE | PHY_AN_AD_ASYM_PAUSE; } } return Value32; } /******************************************************************************/ /* Description: */ /* */ /* Return: */ /* LM_STATUS_FAILURE */ /* LM_STATUS_SUCCESS */ /* */ /******************************************************************************/ static LM_STATUS LM_ForceAutoNegBcm540xPhy (PLM_DEVICE_BLOCK pDevice, LM_REQUESTED_MEDIA_TYPE RequestedMediaType) { LM_MEDIA_TYPE MediaType; LM_LINE_SPEED LineSpeed; LM_DUPLEX_MODE DuplexMode; LM_UINT32 NewPhyCtrl; LM_UINT32 Value32; LM_UINT32 Cnt; /* Get the interface type, line speed, and duplex mode. */ LM_TranslateRequestedMediaType (RequestedMediaType, &MediaType, &LineSpeed, &DuplexMode); if (pDevice->RestoreOnWakeUp) { LM_WritePhy (pDevice, BCM540X_1000BASET_CTRL_REG, 0); pDevice->advertising1000 = 0; Value32 = PHY_AN_AD_10BASET_FULL | PHY_AN_AD_10BASET_HALF; if (pDevice->WolSpeed == WOL_SPEED_100MB) { Value32 |= PHY_AN_AD_100BASETX_FULL | PHY_AN_AD_100BASETX_HALF; } Value32 |= PHY_AN_AD_PROTOCOL_802_3_CSMA_CD; Value32 |= GetPhyAdFlowCntrlSettings (pDevice); LM_WritePhy (pDevice, PHY_AN_AD_REG, Value32); pDevice->advertising = Value32; } /* Setup the auto-negotiation advertisement register. */ else if (LineSpeed == LM_LINE_SPEED_UNKNOWN) { /* Setup the 10/100 Mbps auto-negotiation advertisement register. */ Value32 = PHY_AN_AD_PROTOCOL_802_3_CSMA_CD | PHY_AN_AD_10BASET_HALF | PHY_AN_AD_10BASET_FULL | PHY_AN_AD_100BASETX_FULL | PHY_AN_AD_100BASETX_HALF; Value32 |= GetPhyAdFlowCntrlSettings (pDevice); LM_WritePhy (pDevice, PHY_AN_AD_REG, Value32); pDevice->advertising = Value32; /* Advertise 1000Mbps */ Value32 = BCM540X_AN_AD_1000BASET_HALF | BCM540X_AN_AD_1000BASET_FULL; #if INCLUDE_5701_AX_FIX /* Bug: workaround for CRC error in gigabit mode when we are in */ /* slave mode. This will force the PHY to operate in */ /* master mode. */ if (pDevice->ChipRevId == T3_CHIP_ID_5701_A0 || pDevice->ChipRevId == T3_CHIP_ID_5701_B0) { Value32 |= BCM540X_CONFIG_AS_MASTER | BCM540X_ENABLE_CONFIG_AS_MASTER; } #endif LM_WritePhy (pDevice, BCM540X_1000BASET_CTRL_REG, Value32); pDevice->advertising1000 = Value32; } else { if (LineSpeed == LM_LINE_SPEED_1000MBPS) { Value32 = PHY_AN_AD_PROTOCOL_802_3_CSMA_CD; Value32 |= GetPhyAdFlowCntrlSettings (pDevice); LM_WritePhy (pDevice, PHY_AN_AD_REG, Value32); pDevice->advertising = Value32; if (DuplexMode != LM_DUPLEX_MODE_FULL) { Value32 = BCM540X_AN_AD_1000BASET_HALF; } else { Value32 = BCM540X_AN_AD_1000BASET_FULL; } LM_WritePhy (pDevice, BCM540X_1000BASET_CTRL_REG, Value32); pDevice->advertising1000 = Value32; } else if (LineSpeed == LM_LINE_SPEED_100MBPS) { LM_WritePhy (pDevice, BCM540X_1000BASET_CTRL_REG, 0); pDevice->advertising1000 = 0; if (DuplexMode != LM_DUPLEX_MODE_FULL) { Value32 = PHY_AN_AD_100BASETX_HALF; } else { Value32 = PHY_AN_AD_100BASETX_FULL; } Value32 |= PHY_AN_AD_PROTOCOL_802_3_CSMA_CD; Value32 |= GetPhyAdFlowCntrlSettings (pDevice); LM_WritePhy (pDevice, PHY_AN_AD_REG, Value32); pDevice->advertising = Value32; } else if (LineSpeed == LM_LINE_SPEED_10MBPS) { LM_WritePhy (pDevice, BCM540X_1000BASET_CTRL_REG, 0); pDevice->advertising1000 = 0; if (DuplexMode != LM_DUPLEX_MODE_FULL) { Value32 = PHY_AN_AD_10BASET_HALF; } else { Value32 = PHY_AN_AD_10BASET_FULL; } Value32 |= PHY_AN_AD_PROTOCOL_802_3_CSMA_CD; Value32 |= GetPhyAdFlowCntrlSettings (pDevice); LM_WritePhy (pDevice, PHY_AN_AD_REG, Value32); pDevice->advertising = Value32; } } /* Force line speed if auto-negotiation is disabled. */ if (pDevice->DisableAutoNeg && LineSpeed != LM_LINE_SPEED_UNKNOWN) { /* This code path is executed only when there is link. */ pDevice->MediaType = MediaType; pDevice->LineSpeed = LineSpeed; pDevice->DuplexMode = DuplexMode; /* Force line seepd. */ NewPhyCtrl = 0; switch (LineSpeed) { case LM_LINE_SPEED_10MBPS: NewPhyCtrl |= PHY_CTRL_SPEED_SELECT_10MBPS; break; case LM_LINE_SPEED_100MBPS: NewPhyCtrl |= PHY_CTRL_SPEED_SELECT_100MBPS; break; case LM_LINE_SPEED_1000MBPS: NewPhyCtrl |= PHY_CTRL_SPEED_SELECT_1000MBPS; break; default: NewPhyCtrl |= PHY_CTRL_SPEED_SELECT_1000MBPS; break; } if (DuplexMode == LM_DUPLEX_MODE_FULL) { NewPhyCtrl |= PHY_CTRL_FULL_DUPLEX_MODE; } /* Don't do anything if the PHY_CTRL is already what we wanted. */ LM_ReadPhy (pDevice, PHY_CTRL_REG, &Value32); if (Value32 != NewPhyCtrl) { /* Temporary bring the link down before forcing line speed. */ LM_WritePhy (pDevice, PHY_CTRL_REG, PHY_CTRL_LOOPBACK_MODE); /* Wait for link to go down. */ for (Cnt = 0; Cnt < 15000; Cnt++) { MM_Wait (10); LM_ReadPhy (pDevice, PHY_STATUS_REG, &Value32); LM_ReadPhy (pDevice, PHY_STATUS_REG, &Value32); if (!(Value32 & PHY_STATUS_LINK_PASS)) { MM_Wait (40); break; } } LM_WritePhy (pDevice, PHY_CTRL_REG, NewPhyCtrl); MM_Wait (40); } } else { LM_WritePhy (pDevice, PHY_CTRL_REG, PHY_CTRL_AUTO_NEG_ENABLE | PHY_CTRL_RESTART_AUTO_NEG); } return LM_STATUS_SUCCESS; } /* LM_ForceAutoNegBcm540xPhy */ /******************************************************************************/ /* Description: */ /* */ /* Return: */ /******************************************************************************/ static LM_STATUS LM_ForceAutoNeg (PLM_DEVICE_BLOCK pDevice, LM_REQUESTED_MEDIA_TYPE RequestedMediaType) { LM_STATUS LmStatus; /* Initialize the phy chip. */ switch (pDevice->PhyId & PHY_ID_MASK) { case PHY_BCM5400_PHY_ID: case PHY_BCM5401_PHY_ID: case PHY_BCM5411_PHY_ID: case PHY_BCM5701_PHY_ID: case PHY_BCM5703_PHY_ID: case PHY_BCM5704_PHY_ID: LmStatus = LM_ForceAutoNegBcm540xPhy (pDevice, RequestedMediaType); break; default: LmStatus = LM_STATUS_FAILURE; break; } return LmStatus; } /* LM_ForceAutoNeg */ /******************************************************************************/ /* Description: */ /* */ /* Return: */ /******************************************************************************/ LM_STATUS LM_LoadFirmware (PLM_DEVICE_BLOCK pDevice, PT3_FWIMG_INFO pFwImg, LM_UINT32 LoadCpu, LM_UINT32 StartCpu) { LM_UINT32 i; LM_UINT32 address; if (LoadCpu & T3_RX_CPU_ID) { if (LM_HaltCpu (pDevice, T3_RX_CPU_ID) != LM_STATUS_SUCCESS) { return LM_STATUS_FAILURE; } /* First of all clear scrach pad memory */ for (i = 0; i < T3_RX_CPU_SPAD_SIZE; i += 4) { LM_RegWrInd (pDevice, T3_RX_CPU_SPAD_ADDR + i, 0); } /* Copy code first */ address = T3_RX_CPU_SPAD_ADDR + (pFwImg->Text.Offset & 0xffff); for (i = 0; i <= pFwImg->Text.Length; i += 4) { LM_RegWrInd (pDevice, address + i, ((LM_UINT32 *) pFwImg->Text.Buffer)[i / 4]); } address = T3_RX_CPU_SPAD_ADDR + (pFwImg->ROnlyData.Offset & 0xffff); for (i = 0; i <= pFwImg->ROnlyData.Length; i += 4) { LM_RegWrInd (pDevice, address + i, ((LM_UINT32 *) pFwImg->ROnlyData. Buffer)[i / 4]); } address = T3_RX_CPU_SPAD_ADDR + (pFwImg->Data.Offset & 0xffff); for (i = 0; i <= pFwImg->Data.Length; i += 4) { LM_RegWrInd (pDevice, address + i, ((LM_UINT32 *) pFwImg->Data.Buffer)[i / 4]); } } if (LoadCpu & T3_TX_CPU_ID) { if (LM_HaltCpu (pDevice, T3_TX_CPU_ID) != LM_STATUS_SUCCESS) { return LM_STATUS_FAILURE; } /* First of all clear scrach pad memory */ for (i = 0; i < T3_TX_CPU_SPAD_SIZE; i += 4) { LM_RegWrInd (pDevice, T3_TX_CPU_SPAD_ADDR + i, 0); } /* Copy code first */ address = T3_TX_CPU_SPAD_ADDR + (pFwImg->Text.Offset & 0xffff); for (i = 0; i <= pFwImg->Text.Length; i += 4) { LM_RegWrInd (pDevice, address + i, ((LM_UINT32 *) pFwImg->Text.Buffer)[i / 4]); } address = T3_TX_CPU_SPAD_ADDR + (pFwImg->ROnlyData.Offset & 0xffff); for (i = 0; i <= pFwImg->ROnlyData.Length; i += 4) { LM_RegWrInd (pDevice, address + i, ((LM_UINT32 *) pFwImg->ROnlyData. Buffer)[i / 4]); } address = T3_TX_CPU_SPAD_ADDR + (pFwImg->Data.Offset & 0xffff); for (i = 0; i <= pFwImg->Data.Length; i += 4) { LM_RegWrInd (pDevice, address + i, ((LM_UINT32 *) pFwImg->Data.Buffer)[i / 4]); } } if (StartCpu & T3_RX_CPU_ID) { /* Start Rx CPU */ REG_WR (pDevice, rxCpu.reg.state, 0xffffffff); REG_WR (pDevice, rxCpu.reg.PC, pFwImg->StartAddress); for (i = 0; i < 5; i++) { if (pFwImg->StartAddress == REG_RD (pDevice, rxCpu.reg.PC)) break; REG_WR (pDevice, rxCpu.reg.state, 0xffffffff); REG_WR (pDevice, rxCpu.reg.mode, CPU_MODE_HALT); REG_WR (pDevice, rxCpu.reg.PC, pFwImg->StartAddress); MM_Wait (1000); } REG_WR (pDevice, rxCpu.reg.state, 0xffffffff); REG_WR (pDevice, rxCpu.reg.mode, 0); } if (StartCpu & T3_TX_CPU_ID) { /* Start Tx CPU */ REG_WR (pDevice, txCpu.reg.state, 0xffffffff); REG_WR (pDevice, txCpu.reg.PC, pFwImg->StartAddress); for (i = 0; i < 5; i++) { if (pFwImg->StartAddress == REG_RD (pDevice, txCpu.reg.PC)) break; REG_WR (pDevice, txCpu.reg.state, 0xffffffff); REG_WR (pDevice, txCpu.reg.mode, CPU_MODE_HALT); REG_WR (pDevice, txCpu.reg.PC, pFwImg->StartAddress); MM_Wait (1000); } REG_WR (pDevice, txCpu.reg.state, 0xffffffff); REG_WR (pDevice, txCpu.reg.mode, 0); } return LM_STATUS_SUCCESS; } STATIC LM_STATUS LM_HaltCpu (PLM_DEVICE_BLOCK pDevice, LM_UINT32 cpu_number) { LM_UINT32 i; if (cpu_number == T3_RX_CPU_ID) { for (i = 0; i < 10000; i++) { REG_WR (pDevice, rxCpu.reg.state, 0xffffffff); REG_WR (pDevice, rxCpu.reg.mode, CPU_MODE_HALT); if (REG_RD (pDevice, rxCpu.reg.mode) & CPU_MODE_HALT) break; } REG_WR (pDevice, rxCpu.reg.state, 0xffffffff); REG_WR (pDevice, rxCpu.reg.mode, CPU_MODE_HALT); MM_Wait (10); } else { for (i = 0; i < 10000; i++) { REG_WR (pDevice, txCpu.reg.state, 0xffffffff); REG_WR (pDevice, txCpu.reg.mode, CPU_MODE_HALT); if (REG_RD (pDevice, txCpu.reg.mode) & CPU_MODE_HALT) break; } } return ((i == 10000) ? LM_STATUS_FAILURE : LM_STATUS_SUCCESS); } int LM_BlinkLED (PLM_DEVICE_BLOCK pDevice, LM_UINT32 BlinkDurationSec) { LM_UINT32 Oldcfg; int j; int ret = 0; if (BlinkDurationSec == 0) { return 0; } if (BlinkDurationSec > 120) { BlinkDurationSec = 120; } Oldcfg = REG_RD (pDevice, MacCtrl.LedCtrl); for (j = 0; j < BlinkDurationSec * 2; j++) { if (j % 2) { /* Turn on the LEDs. */ REG_WR (pDevice, MacCtrl.LedCtrl, LED_CTRL_OVERRIDE_LINK_LED | LED_CTRL_1000MBPS_LED_ON | LED_CTRL_100MBPS_LED_ON | LED_CTRL_10MBPS_LED_ON | LED_CTRL_OVERRIDE_TRAFFIC_LED | LED_CTRL_BLINK_TRAFFIC_LED | LED_CTRL_TRAFFIC_LED); } else { /* Turn off the LEDs. */ REG_WR (pDevice, MacCtrl.LedCtrl, LED_CTRL_OVERRIDE_LINK_LED | LED_CTRL_OVERRIDE_TRAFFIC_LED); } #ifndef EMBEDDED current->state = TASK_INTERRUPTIBLE; if (schedule_timeout (HZ / 2) != 0) { ret = -EINTR; break; } #else udelay (100000); /* 1s sleep */ #endif } REG_WR (pDevice, MacCtrl.LedCtrl, Oldcfg); return ret; } int t3_do_dma (PLM_DEVICE_BLOCK pDevice, LM_PHYSICAL_ADDRESS host_addr_phy, int length, int dma_read) { T3_DMA_DESC dma_desc; int i; LM_UINT32 dma_desc_addr; LM_UINT32 value32; REG_WR (pDevice, BufMgr.Mode, 0); REG_WR (pDevice, Ftq.Reset, 0); dma_desc.host_addr.High = host_addr_phy.High; dma_desc.host_addr.Low = host_addr_phy.Low; dma_desc.nic_mbuf = 0x2100; dma_desc.len = length; dma_desc.flags = 0x00000004; /* Generate Rx-CPU event */ if (dma_read) { dma_desc.cqid_sqid = (T3_QID_RX_BD_COMP << 8) | T3_QID_DMA_HIGH_PRI_READ; REG_WR (pDevice, DmaRead.Mode, DMA_READ_MODE_ENABLE); } else { dma_desc.cqid_sqid = (T3_QID_RX_DATA_COMP << 8) | T3_QID_DMA_HIGH_PRI_WRITE; REG_WR (pDevice, DmaWrite.Mode, DMA_WRITE_MODE_ENABLE); } dma_desc_addr = T3_NIC_DMA_DESC_POOL_ADDR; /* Writing this DMA descriptor to DMA memory */ for (i = 0; i < sizeof (T3_DMA_DESC); i += 4) { value32 = *((PLM_UINT32) (((PLM_UINT8) & dma_desc) + i)); MM_WriteConfig32 (pDevice, T3_PCI_MEM_WIN_ADDR_REG, dma_desc_addr + i); MM_WriteConfig32 (pDevice, T3_PCI_MEM_WIN_DATA_REG, cpu_to_le32 (value32)); } MM_WriteConfig32 (pDevice, T3_PCI_MEM_WIN_ADDR_REG, 0); if (dma_read) REG_WR (pDevice, Ftq.DmaHighReadFtqFifoEnqueueDequeue, dma_desc_addr); else REG_WR (pDevice, Ftq.DmaHighWriteFtqFifoEnqueueDequeue, dma_desc_addr); for (i = 0; i < 40; i++) { if (dma_read) value32 = REG_RD (pDevice, Ftq.RcvBdCompFtqFifoEnqueueDequeue); else value32 = REG_RD (pDevice, Ftq.RcvDataCompFtqFifoEnqueueDequeue); if ((value32 & 0xffff) == dma_desc_addr) break; MM_Wait (10); } return LM_STATUS_SUCCESS; } STATIC LM_STATUS LM_DmaTest (PLM_DEVICE_BLOCK pDevice, PLM_UINT8 pBufferVirt, LM_PHYSICAL_ADDRESS BufferPhy, LM_UINT32 BufferSize) { int j; LM_UINT32 *ptr; int dma_success = 0; if (T3_ASIC_REV (pDevice->ChipRevId) != T3_ASIC_REV_5700 && T3_ASIC_REV (pDevice->ChipRevId) != T3_ASIC_REV_5701) { return LM_STATUS_SUCCESS; } while (!dma_success) { /* Fill data with incremental patterns */ ptr = (LM_UINT32 *) pBufferVirt; for (j = 0; j < BufferSize / 4; j++) *ptr++ = j; if (t3_do_dma (pDevice, BufferPhy, BufferSize, 1) == LM_STATUS_FAILURE) { return LM_STATUS_FAILURE; } MM_Wait (40); ptr = (LM_UINT32 *) pBufferVirt; /* Fill data with zero */ for (j = 0; j < BufferSize / 4; j++) *ptr++ = 0; if (t3_do_dma (pDevice, BufferPhy, BufferSize, 0) == LM_STATUS_FAILURE) { return LM_STATUS_FAILURE; } MM_Wait (40); /* Check for data */ ptr = (LM_UINT32 *) pBufferVirt; for (j = 0; j < BufferSize / 4; j++) { if (*ptr++ != j) { if ((pDevice-> DmaReadWriteCtrl & DMA_CTRL_WRITE_BOUNDARY_MASK) == DMA_CTRL_WRITE_BOUNDARY_DISABLE) { pDevice->DmaReadWriteCtrl = (pDevice-> DmaReadWriteCtrl & ~DMA_CTRL_WRITE_BOUNDARY_MASK) | DMA_CTRL_WRITE_BOUNDARY_16; REG_WR (pDevice, PciCfg.DmaReadWriteCtrl, pDevice->DmaReadWriteCtrl); break; } else { return LM_STATUS_FAILURE; } } } if (j == (BufferSize / 4)) dma_success = 1; } return LM_STATUS_SUCCESS; }