/* * Broadcom BCM570x Ethernet Driver for U-Boot. * Support 5701, 5702, 5703, and 5704. Single instance driver. * Copyright (C) 2002 James F. Dougherty (jfd@broadcom.com) */ #include <common.h> #if defined(CONFIG_CMD_NET) \ && (!defined(CONFIG_NET_MULTI)) && defined(CONFIG_BCM570x) #ifdef CONFIG_BMW #include <mpc824x.h> #endif #include <net.h> #include "bcm570x_mm.h" #include "bcm570x_autoneg.h" #include <pci.h> #include <malloc.h> /* * PCI Registers and definitions. */ #define PCI_CMD_MASK 0xffff0000 /* mask to save status bits */ #define PCI_ANY_ID (~0) /* * PCI memory base for Ethernet device as well as device Interrupt. */ #define BCM570X_MBAR 0x80100000 #define BCM570X_ILINE 1 #define SECOND_USEC 1000000 #define MAX_PACKET_SIZE 1600 #define MAX_UNITS 4 /* Globals to this module */ int initialized = 0; unsigned int ioBase = 0; volatile PLM_DEVICE_BLOCK pDevice = NULL; /* 570x softc */ volatile PUM_DEVICE_BLOCK pUmDevice = NULL; /* Used to pass the full-duplex flag, etc. */ int line_speed[MAX_UNITS] = {0,0,0,0}; static int full_duplex[MAX_UNITS] = {1,1,1,1}; static int rx_flow_control[MAX_UNITS] = {0,0,0,0}; static int tx_flow_control[MAX_UNITS] = {0,0,0,0}; static int auto_flow_control[MAX_UNITS] = {0,0,0,0}; static int tx_checksum[MAX_UNITS] = {1,1,1,1}; static int rx_checksum[MAX_UNITS] = {1,1,1,1}; static int auto_speed[MAX_UNITS] = {1,1,1,1}; #if JUMBO_FRAMES /* Jumbo MTU for interfaces. */ static int mtu[MAX_UNITS] = {0,0,0,0}; #endif /* Turn on Wake-on lan for a device unit */ static int enable_wol[MAX_UNITS] = {0,0,0,0}; #define TX_DESC_CNT DEFAULT_TX_PACKET_DESC_COUNT static unsigned int tx_pkt_desc_cnt[MAX_UNITS] = {TX_DESC_CNT,TX_DESC_CNT,TX_DESC_CNT, TX_DESC_CNT}; #define RX_DESC_CNT DEFAULT_STD_RCV_DESC_COUNT static unsigned int rx_std_desc_cnt[MAX_UNITS] = {RX_DESC_CNT,RX_DESC_CNT,RX_DESC_CNT,RX_DESC_CNT}; static unsigned int rx_adaptive_coalesce[MAX_UNITS] = {1,1,1,1}; #if T3_JUMBO_RCV_RCB_ENTRY_COUNT #define JBO_DESC_CNT DEFAULT_JUMBO_RCV_DESC_COUNT static unsigned int rx_jumbo_desc_cnt[MAX_UNITS] = {JBO_DESC_CNT, JBO_DESC_CNT, JBO_DESC_CNT, JBO_DESC_CNT}; #endif #define RX_COAL_TK DEFAULT_RX_COALESCING_TICKS static unsigned int rx_coalesce_ticks[MAX_UNITS] = {RX_COAL_TK, RX_COAL_TK, RX_COAL_TK, RX_COAL_TK}; #define RX_COAL_FM DEFAULT_RX_MAX_COALESCED_FRAMES static unsigned int rx_max_coalesce_frames[MAX_UNITS] = {RX_COAL_FM, RX_COAL_FM, RX_COAL_FM, RX_COAL_FM}; #define TX_COAL_TK DEFAULT_TX_COALESCING_TICKS static unsigned int tx_coalesce_ticks[MAX_UNITS] = {TX_COAL_TK, TX_COAL_TK, TX_COAL_TK, TX_COAL_TK}; #define TX_COAL_FM DEFAULT_TX_MAX_COALESCED_FRAMES static unsigned int tx_max_coalesce_frames[MAX_UNITS] = {TX_COAL_FM, TX_COAL_FM, TX_COAL_FM, TX_COAL_FM}; #define ST_COAL_TK DEFAULT_STATS_COALESCING_TICKS static unsigned int stats_coalesce_ticks[MAX_UNITS] = {ST_COAL_TK, ST_COAL_TK, ST_COAL_TK, ST_COAL_TK}; /* * Legitimate values for BCM570x device types */ typedef enum { BCM5700VIGIL = 0, BCM5700A6, BCM5700T6, BCM5700A9, BCM5700T9, BCM5700, BCM5701A5, BCM5701T1, BCM5701T8, BCM5701A7, BCM5701A10, BCM5701A12, BCM5701, BCM5702, BCM5703, BCM5703A31, TC996T, TC996ST, TC996SSX, TC996SX, TC996BT, TC997T, TC997SX, TC1000T, TC940BR01, TC942BR01, NC6770, NC7760, NC7770, NC7780 } board_t; /* Chip-Rev names for each device-type */ static struct { char* name; } chip_rev[] = { {"BCM5700VIGIL"}, {"BCM5700A6"}, {"BCM5700T6"}, {"BCM5700A9"}, {"BCM5700T9"}, {"BCM5700"}, {"BCM5701A5"}, {"BCM5701T1"}, {"BCM5701T8"}, {"BCM5701A7"}, {"BCM5701A10"}, {"BCM5701A12"}, {"BCM5701"}, {"BCM5702"}, {"BCM5703"}, {"BCM5703A31"}, {"TC996T"}, {"TC996ST"}, {"TC996SSX"}, {"TC996SX"}, {"TC996BT"}, {"TC997T"}, {"TC997SX"}, {"TC1000T"}, {"TC940BR01"}, {"TC942BR01"}, {"NC6770"}, {"NC7760"}, {"NC7770"}, {"NC7780"}, {0} }; /* indexed by board_t, above */ static struct { char *name; } board_info[] = { { "Broadcom Vigil B5700 1000Base-T" }, { "Broadcom BCM5700 1000Base-T" }, { "Broadcom BCM5700 1000Base-SX" }, { "Broadcom BCM5700 1000Base-SX" }, { "Broadcom BCM5700 1000Base-T" }, { "Broadcom BCM5700" }, { "Broadcom BCM5701 1000Base-T" }, { "Broadcom BCM5701 1000Base-T" }, { "Broadcom BCM5701 1000Base-T" }, { "Broadcom BCM5701 1000Base-SX" }, { "Broadcom BCM5701 1000Base-T" }, { "Broadcom BCM5701 1000Base-T" }, { "Broadcom BCM5701" }, { "Broadcom BCM5702 1000Base-T" }, { "Broadcom BCM5703 1000Base-T" }, { "Broadcom BCM5703 1000Base-SX" }, { "3Com 3C996 10/100/1000 Server NIC" }, { "3Com 3C996 10/100/1000 Server NIC" }, { "3Com 3C996 Gigabit Fiber-SX Server NIC" }, { "3Com 3C996 Gigabit Fiber-SX Server NIC" }, { "3Com 3C996B Gigabit Server NIC" }, { "3Com 3C997 Gigabit Server NIC" }, { "3Com 3C997 Gigabit Fiber-SX Server NIC" }, { "3Com 3C1000 Gigabit NIC" }, { "3Com 3C940 Gigabit LOM (21X21)" }, { "3Com 3C942 Gigabit LOM (31X31)" }, { "Compaq NC6770 Gigabit Server Adapter" }, { "Compaq NC7760 Gigabit Server Adapter" }, { "Compaq NC7770 Gigabit Server Adapter" }, { "Compaq NC7780 Gigabit Server Adapter" }, { 0 }, }; /* PCI Devices which use the 570x chipset */ struct pci_device_table { unsigned short vendor_id, device_id; /* Vendor/DeviceID */ unsigned short subvendor, subdevice; /* Subsystem ID's or PCI_ANY_ID */ unsigned int class, class_mask; /* (class,subclass,prog-if) triplet */ unsigned long board_id; /* Data private to the driver */ int io_size, min_latency; } bcm570xDevices[] = { {0x14e4, 0x1644, 0x1014, 0x0277, 0, 0, BCM5700VIGIL ,128,32}, {0x14e4, 0x1644, 0x14e4, 0x1644, 0, 0, BCM5700A6 ,128,32}, {0x14e4, 0x1644, 0x14e4, 0x2, 0, 0, BCM5700T6 ,128,32}, {0x14e4, 0x1644, 0x14e4, 0x3, 0, 0, BCM5700A9 ,128,32}, {0x14e4, 0x1644, 0x14e4, 0x4, 0, 0, BCM5700T9 ,128,32}, {0x14e4, 0x1644, 0x1028, 0xd1, 0, 0, BCM5700 ,128,32}, {0x14e4, 0x1644, 0x1028, 0x0106, 0, 0, BCM5700 ,128,32}, {0x14e4, 0x1644, 0x1028, 0x0109, 0, 0, BCM5700 ,128,32}, {0x14e4, 0x1644, 0x1028, 0x010a, 0, 0, BCM5700 ,128,32}, {0x14e4, 0x1644, 0x10b7, 0x1000, 0, 0, TC996T ,128,32}, {0x14e4, 0x1644, 0x10b7, 0x1001, 0, 0, TC996ST ,128,32}, {0x14e4, 0x1644, 0x10b7, 0x1002, 0, 0, TC996SSX ,128,32}, {0x14e4, 0x1644, 0x10b7, 0x1003, 0, 0, TC997T ,128,32}, {0x14e4, 0x1644, 0x10b7, 0x1005, 0, 0, TC997SX ,128,32}, {0x14e4, 0x1644, 0x10b7, 0x1008, 0, 0, TC942BR01 ,128,32}, {0x14e4, 0x1644, PCI_ANY_ID, PCI_ANY_ID, 0, 0, BCM5700 ,128,32}, {0x14e4, 0x1645, 0x14e4, 1, 0, 0, BCM5701A5 ,128,32}, {0x14e4, 0x1645, 0x14e4, 5, 0, 0, BCM5701T1 ,128,32}, {0x14e4, 0x1645, 0x14e4, 6, 0, 0, BCM5701T8 ,128,32}, {0x14e4, 0x1645, 0x14e4, 7, 0, 0, BCM5701A7 ,128,32}, {0x14e4, 0x1645, 0x14e4, 8, 0, 0, BCM5701A10 ,128,32}, {0x14e4, 0x1645, 0x14e4, 0x8008, 0, 0, BCM5701A12 ,128,32}, {0x14e4, 0x1645, 0x0e11, 0xc1, 0, 0, NC6770 ,128,32}, {0x14e4, 0x1645, 0x0e11, 0x7c, 0, 0, NC7770 ,128,32}, {0x14e4, 0x1645, 0x0e11, 0x85, 0, 0, NC7780 ,128,32}, {0x14e4, 0x1645, 0x1028, 0x0121, 0, 0, BCM5701 ,128,32}, {0x14e4, 0x1645, 0x10b7, 0x1004, 0, 0, TC996SX ,128,32}, {0x14e4, 0x1645, 0x10b7, 0x1006, 0, 0, TC996BT ,128,32}, {0x14e4, 0x1645, 0x10b7, 0x1007, 0, 0, TC1000T ,128,32}, {0x14e4, 0x1645, 0x10b7, 0x1008, 0, 0, TC940BR01 ,128,32}, {0x14e4, 0x1645, PCI_ANY_ID, PCI_ANY_ID, 0, 0, BCM5701 ,128,32}, {0x14e4, 0x1646, 0x14e4, 0x8009, 0, 0, BCM5702 ,128,32}, {0x14e4, 0x1646, 0x0e11, 0xbb, 0, 0, NC7760 ,128,32}, {0x14e4, 0x1646, PCI_ANY_ID, PCI_ANY_ID, 0, 0, BCM5702 ,128,32}, {0x14e4, 0x16a6, 0x14e4, 0x8009, 0, 0, BCM5702 ,128,32}, {0x14e4, 0x16a6, 0x0e11, 0xbb, 0, 0, NC7760 ,128,32}, {0x14e4, 0x16a6, PCI_ANY_ID, PCI_ANY_ID, 0, 0, BCM5702 ,128,32}, {0x14e4, 0x1647, 0x14e4, 0x0009, 0, 0, BCM5703 ,128,32}, {0x14e4, 0x1647, 0x14e4, 0x000a, 0, 0, BCM5703A31 ,128,32}, {0x14e4, 0x1647, 0x14e4, 0x000b, 0, 0, BCM5703 ,128,32}, {0x14e4, 0x1647, 0x14e4, 0x800a, 0, 0, BCM5703 ,128,32}, {0x14e4, 0x1647, 0x0e11, 0x9a, 0, 0, NC7770 ,128,32}, {0x14e4, 0x1647, 0x0e11, 0x99, 0, 0, NC7780 ,128,32}, {0x14e4, 0x1647, PCI_ANY_ID, PCI_ANY_ID, 0, 0, BCM5703 ,128,32}, {0x14e4, 0x16a7, 0x14e4, 0x0009, 0, 0, BCM5703 ,128,32}, {0x14e4, 0x16a7, 0x14e4, 0x000a, 0, 0, BCM5703A31 ,128,32}, {0x14e4, 0x16a7, 0x14e4, 0x000b, 0, 0, BCM5703 ,128,32}, {0x14e4, 0x16a7, 0x14e4, 0x800a, 0, 0, BCM5703 ,128,32}, {0x14e4, 0x16a7, 0x0e11, 0x9a, 0, 0, NC7770 ,128,32}, {0x14e4, 0x16a7, 0x0e11, 0x99, 0, 0, NC7780 ,128,32}, {0x14e4, 0x16a7, PCI_ANY_ID, PCI_ANY_ID, 0, 0, BCM5703 ,128,32} }; #define n570xDevices (sizeof(bcm570xDevices)/sizeof(bcm570xDevices[0])) /* * Allocate a packet buffer from the bcm570x packet pool. */ void * bcm570xPktAlloc(int u, int pksize) { return malloc(pksize); } /* * Free a packet previously allocated from the bcm570x packet * buffer pool. */ void bcm570xPktFree(int u, void *p) { free(p); } int bcm570xReplenishRxBuffers(PUM_DEVICE_BLOCK pUmDevice) { PLM_PACKET pPacket; PUM_PACKET pUmPacket; void *skb; int queue_rx = 0; int ret = 0; while ((pUmPacket = (PUM_PACKET) QQ_PopHead(&pUmDevice->rx_out_of_buf_q.Container)) != 0) { pPacket = (PLM_PACKET) pUmPacket; /* reuse an old skb */ if (pUmPacket->skbuff) { QQ_PushTail(&pDevice->RxPacketFreeQ.Container, pPacket); queue_rx = 1; continue; } if ( ( skb = bcm570xPktAlloc(pUmDevice->index, pPacket->u.Rx.RxBufferSize + 2)) == 0) { QQ_PushHead(&pUmDevice->rx_out_of_buf_q.Container,pPacket); printf("NOTICE: Out of RX memory.\n"); ret = 1; break; } pUmPacket->skbuff = skb; QQ_PushTail(&pDevice->RxPacketFreeQ.Container, pPacket); queue_rx = 1; } if (queue_rx) { LM_QueueRxPackets(pDevice); } return ret; } /* * Probe, Map, and Init 570x device. */ int eth_init(bd_t *bis) { int i, rv, devFound = FALSE; pci_dev_t devbusfn; unsigned short status; /* Find PCI device, if it exists, configure ... */ for( i = 0; i < n570xDevices; i++){ devbusfn = pci_find_device(bcm570xDevices[i].vendor_id, bcm570xDevices[i].device_id, 0); if(devbusfn == -1) { continue; /* No device of that vendor/device ID */ } else { /* Set ILINE */ pci_write_config_byte(devbusfn, PCI_INTERRUPT_LINE, BCM570X_ILINE); /* * 0x10 - 0x14 define one 64-bit MBAR. * 0x14 is the higher-order address bits of the BAR. */ pci_write_config_dword(devbusfn, PCI_BASE_ADDRESS_1, 0); ioBase = BCM570X_MBAR; pci_write_config_dword(devbusfn, PCI_BASE_ADDRESS_0, ioBase); /* * Enable PCI memory, IO, and Master -- don't * reset any status bits in doing so. */ pci_read_config_word(devbusfn, PCI_COMMAND, &status); status |= PCI_COMMAND_MEMORY|PCI_COMMAND_MASTER; pci_write_config_word(devbusfn, PCI_COMMAND, status); printf("\n%s: bus %d, device %d, function %d: MBAR=0x%x\n", board_info[bcm570xDevices[i].board_id].name, PCI_BUS(devbusfn), PCI_DEV(devbusfn), PCI_FUNC(devbusfn), ioBase); /* Allocate once, but always clear on init */ if (!pDevice) { pDevice = malloc(sizeof(UM_DEVICE_BLOCK)); pUmDevice = (PUM_DEVICE_BLOCK)pDevice; memset(pDevice, 0x0, sizeof(UM_DEVICE_BLOCK)); } /* Configure pci dev structure */ pUmDevice->pdev = devbusfn; pUmDevice->index = 0; pUmDevice->tx_pkt = 0; pUmDevice->rx_pkt = 0; devFound = TRUE; break; } } if(!devFound){ printf("eth_init: FAILURE: no BCM570x Ethernet devices found.\n"); return -1; } /* Setup defaults for chip */ pDevice->TaskToOffload = LM_TASK_OFFLOAD_NONE; if (pDevice->ChipRevId == T3_CHIP_ID_5700_B0) { pDevice->TaskToOffload = LM_TASK_OFFLOAD_NONE; } else { if (rx_checksum[i]) { pDevice->TaskToOffload |= LM_TASK_OFFLOAD_RX_TCP_CHECKSUM | LM_TASK_OFFLOAD_RX_UDP_CHECKSUM; } if (tx_checksum[i]) { pDevice->TaskToOffload |= LM_TASK_OFFLOAD_TX_TCP_CHECKSUM | LM_TASK_OFFLOAD_TX_UDP_CHECKSUM; pDevice->NoTxPseudoHdrChksum = TRUE; } } /* Set Device PCI Memory base address */ pDevice->pMappedMemBase = (PLM_UINT8) ioBase; /* Pull down adapter info */ if ((rv = LM_GetAdapterInfo(pDevice)) != LM_STATUS_SUCCESS) { printf("bcm570xEnd: LM_GetAdapterInfo failed: rv=%d!\n", rv ); return -2; } /* Lock not needed */ pUmDevice->do_global_lock = 0; if (T3_ASIC_REV(pUmDevice->lm_dev.ChipRevId) == T3_ASIC_REV_5700) { /* The 5700 chip works best without interleaved register */ /* accesses on certain machines. */ pUmDevice->do_global_lock = 1; } /* Setup timer delays */ if (T3_ASIC_REV(pDevice->ChipRevId) == T3_ASIC_REV_5701) { pDevice->UseTaggedStatus = TRUE; pUmDevice->timer_interval = CFG_HZ; } else { pUmDevice->timer_interval = CFG_HZ / 50; } /* Grab name .... */ pUmDevice->name = (char*)malloc(strlen(board_info[bcm570xDevices[i].board_id].name)+1); strcpy(pUmDevice->name,board_info[bcm570xDevices[i].board_id].name); memcpy(pDevice->NodeAddress, bis->bi_enetaddr, 6); LM_SetMacAddress(pDevice, bis->bi_enetaddr); /* Init queues .. */ QQ_InitQueue(&pUmDevice->rx_out_of_buf_q.Container, MAX_RX_PACKET_DESC_COUNT); pUmDevice->rx_last_cnt = pUmDevice->tx_last_cnt = 0; /* delay for 4 seconds */ pUmDevice->delayed_link_ind = (4 * CFG_HZ) / pUmDevice->timer_interval; pUmDevice->adaptive_expiry = CFG_HZ / pUmDevice->timer_interval; /* Sometimes we get spurious ints. after reset when link is down. */ /* This field tells the isr to service the int. even if there is */ /* no status block update. */ pUmDevice->adapter_just_inited = (3 * CFG_HZ) / pUmDevice->timer_interval; /* Initialize 570x */ if (LM_InitializeAdapter(pDevice) != LM_STATUS_SUCCESS) { printf("ERROR: Adapter initialization failed.\n"); return ERROR; } /* Enable chip ISR */ LM_EnableInterrupt(pDevice); /* Clear MC table */ LM_MulticastClear(pDevice); /* Enable Multicast */ LM_SetReceiveMask(pDevice, pDevice->ReceiveMask | LM_ACCEPT_ALL_MULTICAST); pUmDevice->opened = 1; pUmDevice->tx_full = 0; pUmDevice->tx_pkt = 0; pUmDevice->rx_pkt = 0; printf("eth%d: %s @0x%lx,", pDevice->index, pUmDevice->name, (unsigned long)ioBase); printf( "node addr "); for (i = 0; i < 6; i++) { printf("%2.2x", pDevice->NodeAddress[i]); } printf("\n"); printf("eth%d: ", pDevice->index); printf("%s with ", chip_rev[bcm570xDevices[i].board_id].name); if ((pDevice->PhyId & PHY_ID_MASK) == PHY_BCM5400_PHY_ID) printf("Broadcom BCM5400 Copper "); else if ((pDevice->PhyId & PHY_ID_MASK) == PHY_BCM5401_PHY_ID) printf("Broadcom BCM5401 Copper "); else if ((pDevice->PhyId & PHY_ID_MASK) == PHY_BCM5411_PHY_ID) printf("Broadcom BCM5411 Copper "); else if ((pDevice->PhyId & PHY_ID_MASK) == PHY_BCM5701_PHY_ID) printf("Broadcom BCM5701 Integrated Copper "); else if ((pDevice->PhyId & PHY_ID_MASK) == PHY_BCM5703_PHY_ID) printf("Broadcom BCM5703 Integrated Copper "); else if ((pDevice->PhyId & PHY_ID_MASK) == PHY_BCM8002_PHY_ID) printf("Broadcom BCM8002 SerDes "); else if (pDevice->EnableTbi) printf("Agilent HDMP-1636 SerDes "); else printf("Unknown "); printf("transceiver found\n"); printf("eth%d: %s, MTU: %d,", pDevice->index, pDevice->BusSpeedStr, 1500); if ((pDevice->ChipRevId != T3_CHIP_ID_5700_B0) && rx_checksum[i]) printf("Rx Checksum ON\n"); else printf("Rx Checksum OFF\n"); initialized++; return 0; } /* Ethernet Interrupt service routine */ void eth_isr(void) { LM_UINT32 oldtag, newtag; int i; pUmDevice->interrupt = 1; if (pDevice->UseTaggedStatus) { if ((pDevice->pStatusBlkVirt->Status & STATUS_BLOCK_UPDATED) || pUmDevice->adapter_just_inited) { MB_REG_WR(pDevice, Mailbox.Interrupt[0].Low, 1); oldtag = pDevice->pStatusBlkVirt->StatusTag; for (i = 0; ; i++) { pDevice->pStatusBlkVirt->Status &= ~STATUS_BLOCK_UPDATED; LM_ServiceInterrupts(pDevice); newtag = pDevice->pStatusBlkVirt->StatusTag; if ((newtag == oldtag) || (i > 50)) { MB_REG_WR(pDevice, Mailbox.Interrupt[0].Low, newtag << 24); if (pDevice->UndiFix) { REG_WR(pDevice, Grc.LocalCtrl, pDevice->GrcLocalCtrl | 0x2); } break; } oldtag = newtag; } } } else { while (pDevice->pStatusBlkVirt->Status & STATUS_BLOCK_UPDATED) { unsigned int dummy; pDevice->pMemView->Mailbox.Interrupt[0].Low = 1; pDevice->pStatusBlkVirt->Status &= ~STATUS_BLOCK_UPDATED; LM_ServiceInterrupts(pDevice); pDevice->pMemView->Mailbox.Interrupt[0].Low = 0; dummy = pDevice->pMemView->Mailbox.Interrupt[0].Low; } } /* Allocate new RX buffers */ if (QQ_GetEntryCnt(&pUmDevice->rx_out_of_buf_q.Container)) { bcm570xReplenishRxBuffers(pUmDevice); } /* Queue packets */ if (QQ_GetEntryCnt(&pDevice->RxPacketFreeQ.Container)) { LM_QueueRxPackets(pDevice); } if (pUmDevice->tx_queued) { pUmDevice->tx_queued = 0; } if(pUmDevice->tx_full){ if(pDevice->LinkStatus != LM_STATUS_LINK_DOWN){ printf("NOTICE: tx was previously blocked, restarting MUX\n"); pUmDevice->tx_full = 0; } } pUmDevice->interrupt = 0; } int eth_send(volatile void *packet, int length) { int status = 0; #if ET_DEBUG unsigned char* ptr = (unsigned char*)packet; #endif PLM_PACKET pPacket; PUM_PACKET pUmPacket; /* Link down, return */ while(pDevice->LinkStatus == LM_STATUS_LINK_DOWN) { #if 0 printf("eth%d: link down - check cable or link partner.\n", pUmDevice->index); #endif eth_isr(); /* Wait to see link for one-half a second before sending ... */ udelay(1500000); } /* Clear sent flag */ pUmDevice->tx_pkt = 0; /* Previously blocked */ if(pUmDevice->tx_full){ printf("eth%d: tx blocked.\n", pUmDevice->index); return 0; } pPacket = (PLM_PACKET) QQ_PopHead(&pDevice->TxPacketFreeQ.Container); if (pPacket == 0) { pUmDevice->tx_full = 1; printf("bcm570xEndSend: TX full!\n"); return 0; } if (pDevice->SendBdLeft.counter == 0) { pUmDevice->tx_full = 1; printf("bcm570xEndSend: no more TX descriptors!\n"); QQ_PushHead(&pDevice->TxPacketFreeQ.Container, pPacket); return 0; } if (length <= 0){ printf("eth: bad packet size: %d\n", length); goto out; } /* Get packet buffers and fragment list */ pUmPacket = (PUM_PACKET) pPacket; /* Single DMA Descriptor transmit. * Fragments may be provided, but one DMA descriptor max is * used to send the packet. */ if (MM_CoalesceTxBuffer (pDevice, pPacket) != LM_STATUS_SUCCESS) { if (pUmPacket->skbuff == NULL){ /* Packet was discarded */ printf("TX: failed (1)\n"); status = 1; } else{ printf("TX: failed (2)\n"); status = 2; } QQ_PushHead (&pDevice->TxPacketFreeQ.Container, pPacket); return status; } /* Copy packet to DMA buffer */ memset(pUmPacket->skbuff, 0x0, MAX_PACKET_SIZE); memcpy((void*)pUmPacket->skbuff, (void*)packet, length); pPacket->PacketSize = length; pPacket->Flags |= SND_BD_FLAG_END|SND_BD_FLAG_COAL_NOW; pPacket->u.Tx.FragCount = 1; /* We've already provided a frame ready for transmission */ pPacket->Flags &= ~SND_BD_FLAG_TCP_UDP_CKSUM; if ( LM_SendPacket(pDevice, pPacket) == LM_STATUS_FAILURE){ /* * A lower level send failure will push the packet descriptor back * in the free queue, so just deal with the VxWorks clusters. */ if (pUmPacket->skbuff == NULL){ printf("TX failed (1)!\n"); /* Packet was discarded */ status = 3; } else { /* A resource problem ... */ printf("TX failed (2)!\n"); status = 4; } if (QQ_GetEntryCnt(&pDevice->TxPacketFreeQ.Container) == 0) { printf("TX: emptyQ!\n"); pUmDevice->tx_full = 1; } } while(pUmDevice->tx_pkt == 0){ /* Service TX */ eth_isr(); } #if ET_DEBUG printf("eth_send: 0x%x, %d bytes\n" "[%x %x %x %x %x %x %x %x %x %x %x %x %x %x %x %x] ...\n", (int)pPacket, length, ptr[0],ptr[1],ptr[2],ptr[3],ptr[4],ptr[5], ptr[6],ptr[7],ptr[8],ptr[9],ptr[10],ptr[11],ptr[12], ptr[13],ptr[14],ptr[15]); #endif pUmDevice->tx_pkt = 0; QQ_PushHead(&pDevice->TxPacketFreeQ.Container, pPacket); /* Done with send */ out: return status; } /* Ethernet receive */ int eth_rx(void) { PLM_PACKET pPacket = NULL; PUM_PACKET pUmPacket = NULL; void *skb; int size=0; while(TRUE) { bcm570x_service_isr: /* Pull down packet if it is there */ eth_isr(); /* Indicate RX packets called */ if(pUmDevice->rx_pkt){ /* printf("eth_rx: got a packet...\n"); */ pUmDevice->rx_pkt = 0; } else { /* printf("eth_rx: waiting for packet...\n"); */ goto bcm570x_service_isr; } pPacket = (PLM_PACKET) QQ_PopHead(&pDevice->RxPacketReceivedQ.Container); if (pPacket == 0){ printf("eth_rx: empty packet!\n"); goto bcm570x_service_isr; } pUmPacket = (PUM_PACKET) pPacket; #if ET_DEBUG printf("eth_rx: packet @0x%x\n", (int)pPacket); #endif /* If the packet generated an error, reuse buffer */ if ((pPacket->PacketStatus != LM_STATUS_SUCCESS) || ((size = pPacket->PacketSize) > pDevice->RxMtu)) { /* reuse skb */ QQ_PushTail(&pDevice->RxPacketFreeQ.Container, pPacket); printf("eth_rx: error in packet dma!\n"); goto bcm570x_service_isr; } /* Set size and address */ skb = pUmPacket->skbuff; size = pPacket->PacketSize; /* Pass the packet up to the protocol * layers. */ NetReceive(skb, size); /* Free packet buffer */ bcm570xPktFree (pUmDevice->index, skb); pUmPacket->skbuff = NULL; /* Reuse SKB */ QQ_PushTail(&pDevice->RxPacketFreeQ.Container, pPacket); return 0; /* Got a packet, bail ... */ } return size; } /* Shut down device */ void eth_halt(void) { int i; if ( initialized) if (pDevice && pUmDevice && pUmDevice->opened){ printf("\neth%d:%s,", pUmDevice->index, pUmDevice->name); printf("HALT,"); /* stop device */ LM_Halt(pDevice); printf("POWER DOWN,"); LM_SetPowerState(pDevice, LM_POWER_STATE_D3); /* Free the memory allocated by the device in tigon3 */ for (i = 0; i < pUmDevice->mem_list_num; i++) { if (pUmDevice->mem_list[i]) { /* sanity check */ if (pUmDevice->dma_list[i]) { /* cache-safe memory */ free(pUmDevice->mem_list[i]); } else { free(pUmDevice->mem_list[i]); /* normal memory */ } } } pUmDevice->opened = 0; free(pDevice); pDevice = NULL; pUmDevice = NULL; initialized = 0; printf("done - offline.\n"); } } /* * * Middle Module: Interface between the HW driver (tigon3 modules) and * the native (SENS) driver. These routines implement the system * interface for tigon3 on VxWorks. */ /* Middle module dependency - size of a packet descriptor */ int MM_Packet_Desc_Size = sizeof(UM_PACKET); LM_STATUS MM_ReadConfig32(PLM_DEVICE_BLOCK pDevice, LM_UINT32 Offset, LM_UINT32 *pValue32) { UM_DEVICE_BLOCK *pUmDevice; pUmDevice = (UM_DEVICE_BLOCK *) pDevice; pci_read_config_dword(pUmDevice->pdev, Offset, (u32 *) pValue32); return LM_STATUS_SUCCESS; } LM_STATUS MM_WriteConfig32(PLM_DEVICE_BLOCK pDevice, LM_UINT32 Offset, LM_UINT32 Value32) { UM_DEVICE_BLOCK *pUmDevice; pUmDevice = (UM_DEVICE_BLOCK *) pDevice; pci_write_config_dword(pUmDevice->pdev, Offset, Value32); return LM_STATUS_SUCCESS; } LM_STATUS MM_ReadConfig16(PLM_DEVICE_BLOCK pDevice, LM_UINT32 Offset, LM_UINT16 *pValue16) { UM_DEVICE_BLOCK *pUmDevice; pUmDevice = (UM_DEVICE_BLOCK *) pDevice; pci_read_config_word(pUmDevice->pdev, Offset, (u16*) pValue16); return LM_STATUS_SUCCESS; } LM_STATUS MM_WriteConfig16(PLM_DEVICE_BLOCK pDevice, LM_UINT32 Offset, LM_UINT16 Value16) { UM_DEVICE_BLOCK *pUmDevice; pUmDevice = (UM_DEVICE_BLOCK *) pDevice; pci_write_config_word(pUmDevice->pdev, Offset, Value16); return LM_STATUS_SUCCESS; } LM_STATUS MM_AllocateSharedMemory(PLM_DEVICE_BLOCK pDevice, LM_UINT32 BlockSize, PLM_VOID *pMemoryBlockVirt, PLM_PHYSICAL_ADDRESS pMemoryBlockPhy, LM_BOOL Cached) { PLM_VOID pvirt; PUM_DEVICE_BLOCK pUmDevice = (PUM_DEVICE_BLOCK) pDevice; dma_addr_t mapping; pvirt = malloc(BlockSize); mapping = (dma_addr_t)(pvirt); if (!pvirt) return LM_STATUS_FAILURE; pUmDevice->mem_list[pUmDevice->mem_list_num] = pvirt; pUmDevice->dma_list[pUmDevice->mem_list_num] = mapping; pUmDevice->mem_size_list[pUmDevice->mem_list_num++] = BlockSize; memset(pvirt, 0, BlockSize); *pMemoryBlockVirt = (PLM_VOID) pvirt; MM_SetAddr (pMemoryBlockPhy, (dma_addr_t) mapping); return LM_STATUS_SUCCESS; } LM_STATUS MM_AllocateMemory(PLM_DEVICE_BLOCK pDevice, LM_UINT32 BlockSize, PLM_VOID *pMemoryBlockVirt) { PLM_VOID pvirt; PUM_DEVICE_BLOCK pUmDevice = (PUM_DEVICE_BLOCK) pDevice; pvirt = malloc(BlockSize); if (!pvirt) return LM_STATUS_FAILURE; pUmDevice->mem_list[pUmDevice->mem_list_num] = pvirt; pUmDevice->dma_list[pUmDevice->mem_list_num] = 0; pUmDevice->mem_size_list[pUmDevice->mem_list_num++] = BlockSize; memset(pvirt, 0, BlockSize); *pMemoryBlockVirt = pvirt; return LM_STATUS_SUCCESS; } LM_STATUS MM_MapMemBase(PLM_DEVICE_BLOCK pDevice) { printf("BCM570x PCI Memory base address @0x%x\n", (unsigned int)pDevice->pMappedMemBase); return LM_STATUS_SUCCESS; } LM_STATUS MM_InitializeUmPackets(PLM_DEVICE_BLOCK pDevice) { int i; void* skb; PUM_DEVICE_BLOCK pUmDevice = (PUM_DEVICE_BLOCK) pDevice; PUM_PACKET pUmPacket = NULL; PLM_PACKET pPacket = NULL; for (i = 0; i < pDevice->RxPacketDescCnt; i++) { pPacket = QQ_PopHead(&pDevice->RxPacketFreeQ.Container); pUmPacket = (PUM_PACKET) pPacket; if (pPacket == 0) { printf("MM_InitializeUmPackets: Bad RxPacketFreeQ\n"); } skb = bcm570xPktAlloc(pUmDevice->index, pPacket->u.Rx.RxBufferSize + 2); if (skb == 0) { pUmPacket->skbuff = 0; QQ_PushTail(&pUmDevice->rx_out_of_buf_q.Container, pPacket); printf("MM_InitializeUmPackets: out of buffer.\n"); continue; } pUmPacket->skbuff = skb; QQ_PushTail(&pDevice->RxPacketFreeQ.Container, pPacket); } pUmDevice->rx_low_buf_thresh = pDevice->RxPacketDescCnt / 8; return LM_STATUS_SUCCESS; } LM_STATUS MM_GetConfig(PLM_DEVICE_BLOCK pDevice) { PUM_DEVICE_BLOCK pUmDevice = (PUM_DEVICE_BLOCK) pDevice; int index = pDevice->index; if (auto_speed[index] == 0) pDevice->DisableAutoNeg = TRUE; else pDevice->DisableAutoNeg = FALSE; if (line_speed[index] == 0) { pDevice->RequestedMediaType = LM_REQUESTED_MEDIA_TYPE_AUTO; pDevice->DisableAutoNeg = FALSE; } else { if (line_speed[index] == 1000) { if (pDevice->EnableTbi) { pDevice->RequestedMediaType = LM_REQUESTED_MEDIA_TYPE_FIBER_1000MBPS_FULL_DUPLEX; } else if (full_duplex[index]) { pDevice->RequestedMediaType = LM_REQUESTED_MEDIA_TYPE_UTP_1000MBPS_FULL_DUPLEX; } else { pDevice->RequestedMediaType = LM_REQUESTED_MEDIA_TYPE_UTP_1000MBPS; } if (!pDevice->EnableTbi) pDevice->DisableAutoNeg = FALSE; } else if (line_speed[index] == 100) { if (full_duplex[index]) { pDevice->RequestedMediaType = LM_REQUESTED_MEDIA_TYPE_UTP_100MBPS_FULL_DUPLEX; } else { pDevice->RequestedMediaType = LM_REQUESTED_MEDIA_TYPE_UTP_100MBPS; } } else if (line_speed[index] == 10) { if (full_duplex[index]) { pDevice->RequestedMediaType = LM_REQUESTED_MEDIA_TYPE_UTP_10MBPS_FULL_DUPLEX; } else { pDevice->RequestedMediaType = LM_REQUESTED_MEDIA_TYPE_UTP_10MBPS; } } else { pDevice->RequestedMediaType = LM_REQUESTED_MEDIA_TYPE_AUTO; pDevice->DisableAutoNeg = FALSE; } } pDevice->FlowControlCap = 0; if (rx_flow_control[index] != 0) { pDevice->FlowControlCap |= LM_FLOW_CONTROL_RECEIVE_PAUSE; } if (tx_flow_control[index] != 0) { pDevice->FlowControlCap |= LM_FLOW_CONTROL_TRANSMIT_PAUSE; } if ((auto_flow_control[index] != 0) && (pDevice->DisableAutoNeg == FALSE)) { pDevice->FlowControlCap |= LM_FLOW_CONTROL_AUTO_PAUSE; if ((tx_flow_control[index] == 0) && (rx_flow_control[index] == 0)) { pDevice->FlowControlCap |= LM_FLOW_CONTROL_TRANSMIT_PAUSE | LM_FLOW_CONTROL_RECEIVE_PAUSE; } } /* Default MTU for now */ pUmDevice->mtu = 1500; #if T3_JUMBO_RCV_RCB_ENTRY_COUNT if (pUmDevice->mtu > 1500) { pDevice->RxMtu = pUmDevice->mtu; pDevice->RxJumboDescCnt = DEFAULT_JUMBO_RCV_DESC_COUNT; } else { pDevice->RxJumboDescCnt = 0; } pDevice->RxJumboDescCnt = rx_jumbo_desc_cnt[index]; #else pDevice->RxMtu = pUmDevice->mtu; #endif if (T3_ASIC_REV(pDevice->ChipRevId) == T3_ASIC_REV_5701) { pDevice->UseTaggedStatus = TRUE; pUmDevice->timer_interval = CFG_HZ; } else { pUmDevice->timer_interval = CFG_HZ/50; } pDevice->TxPacketDescCnt = tx_pkt_desc_cnt[index]; pDevice->RxStdDescCnt = rx_std_desc_cnt[index]; /* Note: adaptive coalescence really isn't adaptive in this driver */ pUmDevice->rx_adaptive_coalesce = rx_adaptive_coalesce[index]; if (!pUmDevice->rx_adaptive_coalesce) { pDevice->RxCoalescingTicks = rx_coalesce_ticks[index]; if (pDevice->RxCoalescingTicks > MAX_RX_COALESCING_TICKS) pDevice->RxCoalescingTicks = MAX_RX_COALESCING_TICKS; pUmDevice->rx_curr_coalesce_ticks =pDevice->RxCoalescingTicks; pDevice->RxMaxCoalescedFrames = rx_max_coalesce_frames[index]; if (pDevice->RxMaxCoalescedFrames>MAX_RX_MAX_COALESCED_FRAMES) pDevice->RxMaxCoalescedFrames = MAX_RX_MAX_COALESCED_FRAMES; pUmDevice->rx_curr_coalesce_frames = pDevice->RxMaxCoalescedFrames; pDevice->StatsCoalescingTicks = stats_coalesce_ticks[index]; if (pDevice->StatsCoalescingTicks>MAX_STATS_COALESCING_TICKS) pDevice->StatsCoalescingTicks= MAX_STATS_COALESCING_TICKS; } else { pUmDevice->rx_curr_coalesce_frames = DEFAULT_RX_MAX_COALESCED_FRAMES; pUmDevice->rx_curr_coalesce_ticks = DEFAULT_RX_COALESCING_TICKS; } pDevice->TxCoalescingTicks = tx_coalesce_ticks[index]; if (pDevice->TxCoalescingTicks > MAX_TX_COALESCING_TICKS) pDevice->TxCoalescingTicks = MAX_TX_COALESCING_TICKS; pDevice->TxMaxCoalescedFrames = tx_max_coalesce_frames[index]; if (pDevice->TxMaxCoalescedFrames > MAX_TX_MAX_COALESCED_FRAMES) pDevice->TxMaxCoalescedFrames = MAX_TX_MAX_COALESCED_FRAMES; if (enable_wol[index]) { pDevice->WakeUpModeCap = LM_WAKE_UP_MODE_MAGIC_PACKET; pDevice->WakeUpMode = LM_WAKE_UP_MODE_MAGIC_PACKET; } pDevice->NicSendBd = TRUE; /* Don't update status blocks during interrupt */ pDevice->RxCoalescingTicksDuringInt = 0; pDevice->TxCoalescingTicksDuringInt = 0; return LM_STATUS_SUCCESS; } LM_STATUS MM_StartTxDma(PLM_DEVICE_BLOCK pDevice, PLM_PACKET pPacket) { PUM_DEVICE_BLOCK pUmDevice = (PUM_DEVICE_BLOCK) pDevice; printf("Start TX DMA: dev=%d packet @0x%x\n", (int)pUmDevice->index, (unsigned int)pPacket); return LM_STATUS_SUCCESS; } LM_STATUS MM_CompleteTxDma(PLM_DEVICE_BLOCK pDevice, PLM_PACKET pPacket) { PUM_DEVICE_BLOCK pUmDevice = (PUM_DEVICE_BLOCK) pDevice; printf("Complete TX DMA: dev=%d packet @0x%x\n", (int)pUmDevice->index, (unsigned int)pPacket); return LM_STATUS_SUCCESS; } LM_STATUS MM_IndicateStatus(PLM_DEVICE_BLOCK pDevice, LM_STATUS Status) { char buf[128]; char lcd[4]; PUM_DEVICE_BLOCK pUmDevice = (PUM_DEVICE_BLOCK) pDevice; LM_FLOW_CONTROL flow_control; pUmDevice->delayed_link_ind = 0; memset(lcd, 0x0, 4); if (Status == LM_STATUS_LINK_DOWN) { sprintf(buf,"eth%d: %s: NIC Link is down\n", pUmDevice->index,pUmDevice->name); lcd[0] = 'L';lcd[1]='N';lcd[2]='K';lcd[3] = '?'; } else if (Status == LM_STATUS_LINK_ACTIVE) { sprintf(buf,"eth%d:%s: ", pUmDevice->index, pUmDevice->name); if (pDevice->LineSpeed == LM_LINE_SPEED_1000MBPS){ strcat(buf,"1000 Mbps "); lcd[0] = '1';lcd[1]='G';lcd[2]='B'; } else if (pDevice->LineSpeed == LM_LINE_SPEED_100MBPS){ strcat(buf,"100 Mbps "); lcd[0] = '1';lcd[1]='0';lcd[2]='0'; } else if (pDevice->LineSpeed == LM_LINE_SPEED_10MBPS){ strcat(buf,"10 Mbps "); lcd[0] = '1';lcd[1]='0';lcd[2]=' '; } if (pDevice->DuplexMode == LM_DUPLEX_MODE_FULL){ strcat(buf, "full duplex"); lcd[3] = 'F'; } else { strcat(buf, "half duplex"); lcd[3] = 'H'; } strcat(buf, " link up"); flow_control = pDevice->FlowControl & (LM_FLOW_CONTROL_RECEIVE_PAUSE | LM_FLOW_CONTROL_TRANSMIT_PAUSE); if (flow_control) { if (flow_control & LM_FLOW_CONTROL_RECEIVE_PAUSE) { strcat(buf,", receive "); if (flow_control & LM_FLOW_CONTROL_TRANSMIT_PAUSE) strcat(buf," & transmit "); } else { strcat(buf,", transmit "); } strcat(buf,"flow control ON"); } else { strcat(buf, ", flow control OFF"); } strcat(buf,"\n"); printf("%s",buf); } #if 0 sysLedDsply(lcd[0],lcd[1],lcd[2],lcd[3]); #endif return LM_STATUS_SUCCESS; } LM_STATUS MM_FreeRxBuffer(PLM_DEVICE_BLOCK pDevice, PLM_PACKET pPacket) { PUM_DEVICE_BLOCK pUmDevice = (PUM_DEVICE_BLOCK) pDevice; PUM_PACKET pUmPacket; void *skb; pUmPacket = (PUM_PACKET) pPacket; if ((skb = pUmPacket->skbuff)) bcm570xPktFree(pUmDevice->index, skb); pUmPacket->skbuff = 0; return LM_STATUS_SUCCESS; } unsigned long MM_AnGetCurrentTime_us(PAN_STATE_INFO pAnInfo) { return get_timer(0); } /* * Transform an MBUF chain into a single MBUF. * This routine will fail if the amount of data in the * chain overflows a transmit buffer. In that case, * the incoming MBUF chain will be freed. This routine can * also fail by not being able to allocate a new MBUF (including * cluster and mbuf headers). In that case the failure is * non-fatal. The incoming cluster chain is not freed, giving * the caller the choice of whether to try a retransmit later. */ LM_STATUS MM_CoalesceTxBuffer(PLM_DEVICE_BLOCK pDevice, PLM_PACKET pPacket) { PUM_PACKET pUmPacket = (PUM_PACKET) pPacket; PUM_DEVICE_BLOCK pUmDevice = (PUM_DEVICE_BLOCK) pDevice; void *skbnew; int len = 0; if (len == 0) return (LM_STATUS_SUCCESS); if (len > MAX_PACKET_SIZE){ printf ("eth%d: xmit frame discarded, too big!, size = %d\n", pUmDevice->index, len); return (LM_STATUS_FAILURE); } skbnew = bcm570xPktAlloc(pUmDevice->index, MAX_PACKET_SIZE); if (skbnew == NULL) { pUmDevice->tx_full = 1; printf ("eth%d: out of transmit buffers", pUmDevice->index); return (LM_STATUS_FAILURE); } /* New packet values */ pUmPacket->skbuff = skbnew; pUmPacket->lm_packet.u.Tx.FragCount = 1; return (LM_STATUS_SUCCESS); } LM_STATUS MM_IndicateRxPackets(PLM_DEVICE_BLOCK pDevice) { PUM_DEVICE_BLOCK pUmDevice = (PUM_DEVICE_BLOCK) pDevice; pUmDevice->rx_pkt = 1; return LM_STATUS_SUCCESS; } LM_STATUS MM_IndicateTxPackets(PLM_DEVICE_BLOCK pDevice) { PUM_DEVICE_BLOCK pUmDevice = (PUM_DEVICE_BLOCK) pDevice; PLM_PACKET pPacket; PUM_PACKET pUmPacket; void *skb; while ( TRUE ) { pPacket = (PLM_PACKET) QQ_PopHead(&pDevice->TxPacketXmittedQ.Container); if (pPacket == 0) break; pUmPacket = (PUM_PACKET) pPacket; skb = (void*)pUmPacket->skbuff; /* * Free MBLK if we transmitted a fragmented packet or a * non-fragmented packet straight from the VxWorks * buffer pool. If packet was copied to a local transmit * buffer, then there's no MBUF to free, just free * the transmit buffer back to the cluster pool. */ if (skb) bcm570xPktFree (pUmDevice->index, skb); pUmPacket->skbuff = 0; QQ_PushTail(&pDevice->TxPacketFreeQ.Container, pPacket); pUmDevice->tx_pkt = 1; } if (pUmDevice->tx_full) { if (QQ_GetEntryCnt(&pDevice->TxPacketFreeQ.Container) >= (QQ_GetSize(&pDevice->TxPacketFreeQ.Container) >> 1)) pUmDevice->tx_full = 0; } return LM_STATUS_SUCCESS; } /* * Scan an MBUF chain until we reach fragment number "frag" * Return its length and physical address. */ void MM_MapTxDma ( PLM_DEVICE_BLOCK pDevice, struct _LM_PACKET *pPacket, T3_64BIT_HOST_ADDR *paddr, LM_UINT32 *len, int frag) { PUM_PACKET pUmPacket = (PUM_PACKET) pPacket; *len = pPacket->PacketSize; MM_SetT3Addr(paddr, (dma_addr_t) pUmPacket->skbuff); } /* * Convert an mbuf address, a CPU local virtual address, * to a physical address as seen from a PCI device. Store the * result at paddr. */ void MM_MapRxDma( PLM_DEVICE_BLOCK pDevice, struct _LM_PACKET *pPacket, T3_64BIT_HOST_ADDR *paddr) { PUM_PACKET pUmPacket = (PUM_PACKET) pPacket; MM_SetT3Addr(paddr, (dma_addr_t) pUmPacket->skbuff); } void MM_SetAddr (LM_PHYSICAL_ADDRESS *paddr, dma_addr_t addr) { #if (BITS_PER_LONG == 64) paddr->High = ((unsigned long) addr) >> 32; paddr->Low = ((unsigned long) addr) & 0xffffffff; #else paddr->High = 0; paddr->Low = (unsigned long) addr; #endif } void MM_SetT3Addr(T3_64BIT_HOST_ADDR *paddr, dma_addr_t addr) { unsigned long baddr = (unsigned long) addr; #if (BITS_PER_LONG == 64) set_64bit_addr(paddr, baddr & 0xffffffff, baddr >> 32); #else set_64bit_addr(paddr, baddr, 0); #endif } /* * This combination of `inline' and `extern' has almost the effect of a * macro. The way to use it is to put a function definition in a header * file with these keywords, and put another copy of the definition * (lacking `inline' and `extern') in a library file. The definition in * the header file will cause most calls to the function to be inlined. * If any uses of the function remain, they will refer to the single copy * in the library. */ void atomic_set(atomic_t* entry, int val) { entry->counter = val; } int atomic_read(atomic_t* entry) { return entry->counter; } void atomic_inc(atomic_t* entry) { if(entry) entry->counter++; } void atomic_dec(atomic_t* entry) { if(entry) entry->counter--; } void atomic_sub(int a, atomic_t* entry) { if(entry) entry->counter -= a; } void atomic_add(int a, atomic_t* entry) { if(entry) entry->counter += a; } /******************************************************************************/ /* Description: */ /* */ /* Return: */ /******************************************************************************/ void QQ_InitQueue( PQQ_CONTAINER pQueue, unsigned int QueueSize) { pQueue->Head = 0; pQueue->Tail = 0; pQueue->Size = QueueSize+1; atomic_set(&pQueue->EntryCnt, 0); } /* QQ_InitQueue */ /******************************************************************************/ /* Description: */ /* */ /* Return: */ /******************************************************************************/ char QQ_Full( PQQ_CONTAINER pQueue) { unsigned int NewHead; NewHead = (pQueue->Head + 1) % pQueue->Size; return(NewHead == pQueue->Tail); } /* QQ_Full */ /******************************************************************************/ /* Description: */ /* */ /* Return: */ /******************************************************************************/ char QQ_Empty( PQQ_CONTAINER pQueue) { return(pQueue->Head == pQueue->Tail); } /* QQ_Empty */ /******************************************************************************/ /* Description: */ /* */ /* Return: */ /******************************************************************************/ unsigned int QQ_GetSize( PQQ_CONTAINER pQueue) { return pQueue->Size; } /* QQ_GetSize */ /******************************************************************************/ /* Description: */ /* */ /* Return: */ /******************************************************************************/ unsigned int QQ_GetEntryCnt( PQQ_CONTAINER pQueue) { return atomic_read(&pQueue->EntryCnt); } /* QQ_GetEntryCnt */ /******************************************************************************/ /* Description: */ /* */ /* Return: */ /* TRUE entry was added successfully. */ /* FALSE queue is full. */ /******************************************************************************/ char QQ_PushHead( PQQ_CONTAINER pQueue, PQQ_ENTRY pEntry) { unsigned int Head; Head = (pQueue->Head + 1) % pQueue->Size; #if !defined(QQ_NO_OVERFLOW_CHECK) if(Head == pQueue->Tail) { return 0; } /* if */ #endif /* QQ_NO_OVERFLOW_CHECK */ pQueue->Array[pQueue->Head] = pEntry; wmb(); pQueue->Head = Head; atomic_inc(&pQueue->EntryCnt); return -1; } /* QQ_PushHead */ /******************************************************************************/ /* Description: */ /* */ /* Return: */ /* TRUE entry was added successfully. */ /* FALSE queue is full. */ /******************************************************************************/ char QQ_PushTail( PQQ_CONTAINER pQueue, PQQ_ENTRY pEntry) { unsigned int Tail; Tail = pQueue->Tail; if(Tail == 0) { Tail = pQueue->Size; } /* if */ Tail--; #if !defined(QQ_NO_OVERFLOW_CHECK) if(Tail == pQueue->Head) { return 0; } /* if */ #endif /* QQ_NO_OVERFLOW_CHECK */ pQueue->Array[Tail] = pEntry; wmb(); pQueue->Tail = Tail; atomic_inc(&pQueue->EntryCnt); return -1; } /* QQ_PushTail */ /******************************************************************************/ /* Description: */ /* */ /* Return: */ /******************************************************************************/ PQQ_ENTRY QQ_PopHead( PQQ_CONTAINER pQueue) { unsigned int Head; PQQ_ENTRY Entry; Head = pQueue->Head; #if !defined(QQ_NO_UNDERFLOW_CHECK) if(Head == pQueue->Tail) { return (PQQ_ENTRY) 0; } /* if */ #endif /* QQ_NO_UNDERFLOW_CHECK */ if(Head == 0) { Head = pQueue->Size; } /* if */ Head--; Entry = pQueue->Array[Head]; membar(); pQueue->Head = Head; atomic_dec(&pQueue->EntryCnt); return Entry; } /* QQ_PopHead */ /******************************************************************************/ /* Description: */ /* */ /* Return: */ /******************************************************************************/ PQQ_ENTRY QQ_PopTail( PQQ_CONTAINER pQueue) { unsigned int Tail; PQQ_ENTRY Entry; Tail = pQueue->Tail; #if !defined(QQ_NO_UNDERFLOW_CHECK) if(Tail == pQueue->Head) { return (PQQ_ENTRY) 0; } /* if */ #endif /* QQ_NO_UNDERFLOW_CHECK */ Entry = pQueue->Array[Tail]; membar(); pQueue->Tail = (Tail + 1) % pQueue->Size; atomic_dec(&pQueue->EntryCnt); return Entry; } /* QQ_PopTail */ /******************************************************************************/ /* Description: */ /* */ /* Return: */ /******************************************************************************/ PQQ_ENTRY QQ_GetHead( PQQ_CONTAINER pQueue, unsigned int Idx) { if(Idx >= atomic_read(&pQueue->EntryCnt)) { return (PQQ_ENTRY) 0; } if(pQueue->Head > Idx) { Idx = pQueue->Head - Idx; } else { Idx = pQueue->Size - (Idx - pQueue->Head); } Idx--; return pQueue->Array[Idx]; } /******************************************************************************/ /* Description: */ /* */ /* Return: */ /******************************************************************************/ PQQ_ENTRY QQ_GetTail( PQQ_CONTAINER pQueue, unsigned int Idx) { if(Idx >= atomic_read(&pQueue->EntryCnt)) { return (PQQ_ENTRY) 0; } Idx += pQueue->Tail; if(Idx >= pQueue->Size) { Idx = Idx - pQueue->Size; } return pQueue->Array[Idx]; } #endif