#include <common.h> #include <malloc.h> #include <galileo/gt64260R.h> #include <galileo/core.h> #include <asm/cache.h> #include "eth.h" #include "eth_addrtbl.h" #define TRUE 1 #define FALSE 0 #define PRINTF printf #ifdef CONFIG_GT_USE_MAC_HASH_TABLE static u32 addressTableHashMode[GAL_ETH_DEVS] = { 0, }; static u32 addressTableHashSize[GAL_ETH_DEVS] = { 0, }; static addrTblEntry *addressTableBase[GAL_ETH_DEVS] = { 0, }; static void *realAddrTableBase[GAL_ETH_DEVS] = { 0, }; static const u32 hashLength[2] = { (0x8000), /* 8K * 4 entries */ (0x8000 / 16), /* 512 * 4 entries */ }; /* Initialize the address table for a port, if needed */ unsigned int initAddressTable (u32 port, u32 hashMode, u32 hashSizeSelector) { unsigned int tableBase; if (port < 0 || port >= GAL_ETH_DEVS) { printf ("%s: Invalid port number %d\n", __FUNCTION__, port); return 0; } if (hashMode > 1) { printf ("%s: Invalid Hash Mode %d\n", __FUNCTION__, port); return 0; } if (realAddrTableBase[port] && (addressTableHashSize[port] != hashSizeSelector)) { /* we have been here before, * but now we want a different sized table */ free (realAddrTableBase[port]); realAddrTableBase[port] = 0; addressTableBase[port] = 0; } tableBase = (unsigned int) addressTableBase[port]; /* we get called for every probe, so only do this once */ if (!tableBase) { int bytes = hashLength[hashSizeSelector] * sizeof (addrTblEntry); realAddrTableBase[port] = malloc (bytes + 64); tableBase = (unsigned int)realAddrTableBase; if (!tableBase) { printf ("%s: alloc memory failed \n", __FUNCTION__); return 0; } /* align to octal byte */ if (tableBase & 63) tableBase = (tableBase + 63) & ~63; addressTableHashMode[port] = hashMode; addressTableHashSize[port] = hashSizeSelector; addressTableBase[port] = (addrTblEntry *) tableBase; memset ((void *) tableBase, 0, bytes); } return tableBase; } /* * ---------------------------------------------------------------------------- * This function will calculate the hash function of the address. * depends on the hash mode and hash size. * Inputs * macH - the 2 most significant bytes of the MAC address. * macL - the 4 least significant bytes of the MAC address. * hashMode - hash mode 0 or hash mode 1. * hashSizeSelector - indicates number of hash table entries (0=0x8000,1=0x800) * Outputs * return the calculated entry. */ u32 hashTableFunction (u32 macH, u32 macL, u32 HashSize, u32 hash_mode) { u32 hashResult; u32 addrH; u32 addrL; u32 addr0; u32 addr1; u32 addr2; u32 addr3; u32 addrHSwapped; u32 addrLSwapped; addrH = NIBBLE_SWAPPING_16_BIT (macH); addrL = NIBBLE_SWAPPING_32_BIT (macL); addrHSwapped = FLIP_4_BITS (addrH & 0xf) + ((FLIP_4_BITS ((addrH >> 4) & 0xf)) << 4) + ((FLIP_4_BITS ((addrH >> 8) & 0xf)) << 8) + ((FLIP_4_BITS ((addrH >> 12) & 0xf)) << 12); addrLSwapped = FLIP_4_BITS (addrL & 0xf) + ((FLIP_4_BITS ((addrL >> 4) & 0xf)) << 4) + ((FLIP_4_BITS ((addrL >> 8) & 0xf)) << 8) + ((FLIP_4_BITS ((addrL >> 12) & 0xf)) << 12) + ((FLIP_4_BITS ((addrL >> 16) & 0xf)) << 16) + ((FLIP_4_BITS ((addrL >> 20) & 0xf)) << 20) + ((FLIP_4_BITS ((addrL >> 24) & 0xf)) << 24) + ((FLIP_4_BITS ((addrL >> 28) & 0xf)) << 28); addrH = addrHSwapped; addrL = addrLSwapped; if (hash_mode == 0) { addr0 = (addrL >> 2) & 0x03f; addr1 = (addrL & 0x003) | ((addrL >> 8) & 0x7f) << 2; addr2 = (addrL >> 15) & 0x1ff; addr3 = ((addrL >> 24) & 0x0ff) | ((addrH & 1) << 8); } else { addr0 = FLIP_6_BITS (addrL & 0x03f); addr1 = FLIP_9_BITS (((addrL >> 6) & 0x1ff)); addr2 = FLIP_9_BITS ((addrL >> 15) & 0x1ff); addr3 = FLIP_9_BITS ((((addrL >> 24) & 0x0ff) | ((addrH & 0x1) << 8))); } hashResult = (addr0 << 9) | (addr1 ^ addr2 ^ addr3); if (HashSize == _8K_TABLE) { hashResult = hashResult & 0xffff; } else { hashResult = hashResult & 0x07ff; } return (hashResult); } /* * ---------------------------------------------------------------------------- * This function will add an entry to the address table. * depends on the hash mode and hash size that was initialized. * Inputs * port - ETHERNET port number. * macH - the 2 most significant bytes of the MAC address. * macL - the 4 least significant bytes of the MAC address. * skip - if 1, skip this address. * rd - the RD field in the address table. * Outputs * address table entry is added. * TRUE if success. * FALSE if table full */ int addAddressTableEntry (u32 port, u32 macH, u32 macL, u32 rd, u32 skip) { addrTblEntry *entry; u32 newHi; u32 newLo; u32 i; newLo = (((macH >> 4) & 0xf) << 15) | (((macH >> 0) & 0xf) << 11) | (((macH >> 12) & 0xf) << 7) | (((macH >> 8) & 0xf) << 3) | (((macL >> 20) & 0x1) << 31) | (((macL >> 16) & 0xf) << 27) | (((macL >> 28) & 0xf) << 23) | (((macL >> 24) & 0xf) << 19) | (skip << SKIP_BIT) | (rd << 2) | VALID; newHi = (((macL >> 4) & 0xf) << 15) | (((macL >> 0) & 0xf) << 11) | (((macL >> 12) & 0xf) << 7) | (((macL >> 8) & 0xf) << 3) | (((macL >> 21) & 0x7) << 0); /* * Pick the appropriate table, start scanning for free/reusable * entries at the index obtained by hashing the specified MAC address */ entry = addressTableBase[port]; entry += hashTableFunction (macH, macL, addressTableHashSize[port], addressTableHashMode[port]); for (i = 0; i < HOP_NUMBER; i++, entry++) { if (!(entry->lo & VALID) /*|| (entry->lo & SKIP) */ ) { break; } else { /* if same address put in same position */ if (((entry->lo & 0xfffffff8) == (newLo & 0xfffffff8)) && (entry->hi == newHi)) { break; } } } if (i == HOP_NUMBER) { PRINTF ("addGT64260addressTableEntry: table section is full\n"); return (FALSE); } /* * Update the selected entry */ entry->hi = newHi; entry->lo = newLo; DCACHE_FLUSH_N_SYNC ((u32) entry, MAC_ENTRY_SIZE); return (TRUE); } #endif /* CONFIG_GT_USE_MAC_HASH_TABLE */