// SPDX-License-Identifier: GPL-2.0-or-later /* * acenic.c: Linux driver for the Alteon AceNIC Gigabit Ethernet card * and other Tigon based cards. * * Copyright 1998-2002 by Jes Sorensen, <[email protected]>. * * Thanks to Alteon and 3Com for providing hardware and documentation * enabling me to write this driver. * * A mailing list for discussing the use of this driver has been * setup, please subscribe to the lists if you have any questions * about the driver. Send mail to [email protected] to * see how to subscribe. * * Additional credits: * Pete Wyckoff <[email protected]>: Initial Linux/Alpha and trace * dump support. The trace dump support has not been * integrated yet however. * Troy Benjegerdes: Big Endian (PPC) patches. * Nate Stahl: Better out of memory handling and stats support. * Aman Singla: Nasty race between interrupt handler and tx code dealing * with 'testing the tx_ret_csm and setting tx_full' * David S. Miller <[email protected]>: conversion to new PCI dma mapping * infrastructure and Sparc support * Pierrick Pinasseau (CERN): For lending me an Ultra 5 to test the * driver under Linux/Sparc64 * Matt Domsch <[email protected]>: Detect Alteon 1000baseT cards * ETHTOOL_GDRVINFO support * Chip Salzenberg <[email protected]>: Fix race condition between tx * handler and close() cleanup. * Ken Aaker <[email protected]>: Correct check for whether * memory mapped IO is enabled to * make the driver work on RS/6000. * Takayoshi Kouchi <[email protected]>: Identifying problem * where the driver would disable * bus master mode if it had to disable * write and invalidate. * Stephen Hack <[email protected]>: Fixed ace_set_mac_addr for little * endian systems. * Val Henson <[email protected]>: Reset Jumbo skb producer and * rx producer index when * flushing the Jumbo ring. * Hans Grobler <[email protected]>: Memory leak fixes in the * driver init path. * Grant Grundler <[email protected]>: PCI write posting fixes. */ #include <linux/module.h> #include <linux/moduleparam.h> #include <linux/types.h> #include <linux/errno.h> #include <linux/ioport.h> #include <linux/pci.h> #include <linux/dma-mapping.h> #include <linux/kernel.h> #include <linux/netdevice.h> #include <linux/etherdevice.h> #include <linux/skbuff.h> #include <linux/delay.h> #include <linux/mm.h> #include <linux/highmem.h> #include <linux/sockios.h> #include <linux/firmware.h> #include <linux/slab.h> #include <linux/prefetch.h> #include <linux/if_vlan.h> #ifdef SIOCETHTOOL #include <linux/ethtool.h> #endif #include <net/sock.h> #include <net/ip.h> #include <asm/io.h> #include <asm/irq.h> #include <asm/byteorder.h> #include <linux/uaccess.h> #define DRV_NAME … #undef INDEX_DEBUG #ifdef CONFIG_ACENIC_OMIT_TIGON_I #define ACE_IS_TIGON_I(ap) … #define ACE_TX_RING_ENTRIES(ap) … #else #define ACE_IS_TIGON_I … #define ACE_TX_RING_ENTRIES … #endif #ifndef PCI_VENDOR_ID_ALTEON #define PCI_VENDOR_ID_ALTEON … #endif #ifndef PCI_DEVICE_ID_ALTEON_ACENIC_FIBRE #define PCI_DEVICE_ID_ALTEON_ACENIC_FIBRE … #define PCI_DEVICE_ID_ALTEON_ACENIC_COPPER … #endif #ifndef PCI_DEVICE_ID_3COM_3C985 #define PCI_DEVICE_ID_3COM_3C985 … #endif #ifndef PCI_VENDOR_ID_NETGEAR #define PCI_VENDOR_ID_NETGEAR … #define PCI_DEVICE_ID_NETGEAR_GA620 … #endif #ifndef PCI_DEVICE_ID_NETGEAR_GA620T #define PCI_DEVICE_ID_NETGEAR_GA620T … #endif /* * Farallon used the DEC vendor ID by mistake and they seem not * to care - stinky! */ #ifndef PCI_DEVICE_ID_FARALLON_PN9000SX #define PCI_DEVICE_ID_FARALLON_PN9000SX … #endif #ifndef PCI_DEVICE_ID_FARALLON_PN9100T #define PCI_DEVICE_ID_FARALLON_PN9100T … #endif #ifndef PCI_VENDOR_ID_SGI #define PCI_VENDOR_ID_SGI … #endif #ifndef PCI_DEVICE_ID_SGI_ACENIC #define PCI_DEVICE_ID_SGI_ACENIC … #endif static const struct pci_device_id acenic_pci_tbl[] = …; MODULE_DEVICE_TABLE(pci, acenic_pci_tbl); #define ace_sync_irq(irq) … #ifndef offset_in_page #define offset_in_page … #endif #define ACE_MAX_MOD_PARMS … #define BOARD_IDX_STATIC … #define BOARD_IDX_OVERFLOW … #include "acenic.h" /* * These must be defined before the firmware is included. */ #define MAX_TEXT_LEN … #define MAX_RODATA_LEN … #define MAX_DATA_LEN … #ifndef tigon2FwReleaseLocal #define tigon2FwReleaseLocal … #endif /* * This driver currently supports Tigon I and Tigon II based cards * including the Alteon AceNIC, the 3Com 3C985[B] and NetGear * GA620. The driver should also work on the SGI, DEC and Farallon * versions of the card, however I have not been able to test that * myself. * * This card is really neat, it supports receive hardware checksumming * and jumbo frames (up to 9000 bytes) and does a lot of work in the * firmware. Also the programming interface is quite neat, except for * the parts dealing with the i2c eeprom on the card ;-) * * Using jumbo frames: * * To enable jumbo frames, simply specify an mtu between 1500 and 9000 * bytes to ifconfig. Jumbo frames can be enabled or disabled at any time * by running `ifconfig eth<X> mtu <MTU>' with <X> being the Ethernet * interface number and <MTU> being the MTU value. * * Module parameters: * * When compiled as a loadable module, the driver allows for a number * of module parameters to be specified. The driver supports the * following module parameters: * * trace=<val> - Firmware trace level. This requires special traced * firmware to replace the firmware supplied with * the driver - for debugging purposes only. * * link=<val> - Link state. Normally you want to use the default link * parameters set by the driver. This can be used to * override these in case your switch doesn't negotiate * the link properly. Valid values are: * 0x0001 - Force half duplex link. * 0x0002 - Do not negotiate line speed with the other end. * 0x0010 - 10Mbit/sec link. * 0x0020 - 100Mbit/sec link. * 0x0040 - 1000Mbit/sec link. * 0x0100 - Do not negotiate flow control. * 0x0200 - Enable RX flow control Y * 0x0400 - Enable TX flow control Y (Tigon II NICs only). * Default value is 0x0270, ie. enable link+flow * control negotiation. Negotiating the highest * possible link speed with RX flow control enabled. * * When disabling link speed negotiation, only one link * speed is allowed to be specified! * * tx_coal_tick=<val> - number of coalescing clock ticks (us) allowed * to wait for more packets to arive before * interrupting the host, from the time the first * packet arrives. * * rx_coal_tick=<val> - number of coalescing clock ticks (us) allowed * to wait for more packets to arive in the transmit ring, * before interrupting the host, after transmitting the * first packet in the ring. * * max_tx_desc=<val> - maximum number of transmit descriptors * (packets) transmitted before interrupting the host. * * max_rx_desc=<val> - maximum number of receive descriptors * (packets) received before interrupting the host. * * tx_ratio=<val> - 7 bit value (0 - 63) specifying the split in 64th * increments of the NIC's on board memory to be used for * transmit and receive buffers. For the 1MB NIC app. 800KB * is available, on the 1/2MB NIC app. 300KB is available. * 68KB will always be available as a minimum for both * directions. The default value is a 50/50 split. * dis_pci_mem_inval=<val> - disable PCI memory write and invalidate * operations, default (1) is to always disable this as * that is what Alteon does on NT. I have not been able * to measure any real performance differences with * this on my systems. Set <val>=0 if you want to * enable these operations. * * If you use more than one NIC, specify the parameters for the * individual NICs with a comma, ie. trace=0,0x00001fff,0 you want to * run tracing on NIC #2 but not on NIC #1 and #3. * * TODO: * * - Proper multicast support. * - NIC dump support. * - More tuning parameters. * * The mini ring is not used under Linux and I am not sure it makes sense * to actually use it. * * New interrupt handler strategy: * * The old interrupt handler worked using the traditional method of * replacing an skbuff with a new one when a packet arrives. However * the rx rings do not need to contain a static number of buffer * descriptors, thus it makes sense to move the memory allocation out * of the main interrupt handler and do it in a bottom half handler * and only allocate new buffers when the number of buffers in the * ring is below a certain threshold. In order to avoid starving the * NIC under heavy load it is however necessary to force allocation * when hitting a minimum threshold. The strategy for alloction is as * follows: * * RX_LOW_BUF_THRES - allocate buffers in the bottom half * RX_PANIC_LOW_THRES - we are very low on buffers, allocate * the buffers in the interrupt handler * RX_RING_THRES - maximum number of buffers in the rx ring * RX_MINI_THRES - maximum number of buffers in the mini ring * RX_JUMBO_THRES - maximum number of buffers in the jumbo ring * * One advantagous side effect of this allocation approach is that the * entire rx processing can be done without holding any spin lock * since the rx rings and registers are totally independent of the tx * ring and its registers. This of course includes the kmalloc's of * new skb's. Thus start_xmit can run in parallel with rx processing * and the memory allocation on SMP systems. * * Note that running the skb reallocation in a bottom half opens up * another can of races which needs to be handled properly. In * particular it can happen that the interrupt handler tries to run * the reallocation while the bottom half is either running on another * CPU or was interrupted on the same CPU. To get around this the * driver uses bitops to prevent the reallocation routines from being * reentered. * * TX handling can also be done without holding any spin lock, wheee * this is fun! since tx_ret_csm is only written to by the interrupt * handler. The case to be aware of is when shutting down the device * and cleaning up where it is necessary to make sure that * start_xmit() is not running while this is happening. Well DaveM * informs me that this case is already protected against ... bye bye * Mr. Spin Lock, it was nice to know you. * * TX interrupts are now partly disabled so the NIC will only generate * TX interrupts for the number of coal ticks, not for the number of * TX packets in the queue. This should reduce the number of TX only, * ie. when no RX processing is done, interrupts seen. */ /* * Threshold values for RX buffer allocation - the low water marks for * when to start refilling the rings are set to 75% of the ring * sizes. It seems to make sense to refill the rings entirely from the * intrrupt handler once it gets below the panic threshold, that way * we don't risk that the refilling is moved to another CPU when the * one running the interrupt handler just got the slab code hot in its * cache. */ #define RX_RING_SIZE … #define RX_MINI_SIZE … #define RX_JUMBO_SIZE … #define RX_PANIC_STD_THRES … #define RX_PANIC_STD_REFILL … #define RX_LOW_STD_THRES … #define RX_PANIC_MINI_THRES … #define RX_PANIC_MINI_REFILL … #define RX_LOW_MINI_THRES … #define RX_PANIC_JUMBO_THRES … #define RX_PANIC_JUMBO_REFILL … #define RX_LOW_JUMBO_THRES … /* * Size of the mini ring entries, basically these just should be big * enough to take TCP ACKs */ #define ACE_MINI_SIZE … #define ACE_MINI_BUFSIZE … #define ACE_STD_BUFSIZE … #define ACE_JUMBO_BUFSIZE … /* * There seems to be a magic difference in the effect between 995 and 996 * but little difference between 900 and 995 ... no idea why. * * There is now a default set of tuning parameters which is set, depending * on whether or not the user enables Jumbo frames. It's assumed that if * Jumbo frames are enabled, the user wants optimal tuning for that case. */ #define DEF_TX_COAL … #define DEF_TX_MAX_DESC … #define DEF_RX_COAL … #define DEF_RX_MAX_DESC … #define DEF_TX_RATIO … #define DEF_JUMBO_TX_COAL … #define DEF_JUMBO_TX_MAX_DESC … #define DEF_JUMBO_RX_COAL … #define DEF_JUMBO_RX_MAX_DESC … #define DEF_JUMBO_TX_RATIO … #if tigon2FwReleaseLocal < 20001118 /* * Standard firmware and early modifications duplicate * IRQ load without this flag (coal timer is never reset). * Note that with this flag tx_coal should be less than * time to xmit full tx ring. * 400usec is not so bad for tx ring size of 128. */ #define TX_COAL_INTS_ONLY … #else /* * With modified firmware, this is not necessary, but still useful. */ #define TX_COAL_INTS_ONLY … #endif #define DEF_TRACE … #define DEF_STAT … static int link_state[ACE_MAX_MOD_PARMS]; static int trace[ACE_MAX_MOD_PARMS]; static int tx_coal_tick[ACE_MAX_MOD_PARMS]; static int rx_coal_tick[ACE_MAX_MOD_PARMS]; static int max_tx_desc[ACE_MAX_MOD_PARMS]; static int max_rx_desc[ACE_MAX_MOD_PARMS]; static int tx_ratio[ACE_MAX_MOD_PARMS]; static int dis_pci_mem_inval[ACE_MAX_MOD_PARMS] = …; MODULE_AUTHOR(…) …; MODULE_LICENSE(…) …; MODULE_DESCRIPTION(…) …; #ifndef CONFIG_ACENIC_OMIT_TIGON_I MODULE_FIRMWARE("acenic/tg1.bin"); #endif MODULE_FIRMWARE(…) …; module_param_array_named(…); module_param_array(…); module_param_array(…); module_param_array(…); module_param_array(…); module_param_array(…); module_param_array(…); MODULE_PARM_DESC(…) …; MODULE_PARM_DESC(…) …; MODULE_PARM_DESC(…) …; MODULE_PARM_DESC(…) …; MODULE_PARM_DESC(…) …; MODULE_PARM_DESC(…) …; MODULE_PARM_DESC(…) …; static const char version[] = …; static int ace_get_link_ksettings(struct net_device *, struct ethtool_link_ksettings *); static int ace_set_link_ksettings(struct net_device *, const struct ethtool_link_ksettings *); static void ace_get_drvinfo(struct net_device *, struct ethtool_drvinfo *); static const struct ethtool_ops ace_ethtool_ops = …; static void ace_watchdog(struct net_device *dev, unsigned int txqueue); static const struct net_device_ops ace_netdev_ops = …; static int acenic_probe_one(struct pci_dev *pdev, const struct pci_device_id *id) { … } static void acenic_remove_one(struct pci_dev *pdev) { … } static struct pci_driver acenic_pci_driver = …; static void ace_free_descriptors(struct net_device *dev) { … } static int ace_allocate_descriptors(struct net_device *dev) { … } /* * Generic cleanup handling data allocated during init. Used when the * module is unloaded or if an error occurs during initialization */ static void ace_init_cleanup(struct net_device *dev) { … } /* * Commands are considered to be slow. */ static inline void ace_issue_cmd(struct ace_regs __iomem *regs, struct cmd *cmd) { … } static int ace_init(struct net_device *dev) { … } static void ace_set_rxtx_parms(struct net_device *dev, int jumbo) { … } static void ace_watchdog(struct net_device *data, unsigned int txqueue) { … } static void ace_bh_work(struct work_struct *work) { … } /* * Copy the contents of the NIC's trace buffer to kernel memory. */ static void ace_dump_trace(struct ace_private *ap) { … } /* * Load the standard rx ring. * * Loading rings is safe without holding the spin lock since this is * done only before the device is enabled, thus no interrupts are * generated and by the interrupt handler/bh handler. */ static void ace_load_std_rx_ring(struct net_device *dev, int nr_bufs) { … } static void ace_load_mini_rx_ring(struct net_device *dev, int nr_bufs) { … } /* * Load the jumbo rx ring, this may happen at any time if the MTU * is changed to a value > 1500. */ static void ace_load_jumbo_rx_ring(struct net_device *dev, int nr_bufs) { … } /* * All events are considered to be slow (RX/TX ints do not generate * events) and are handled here, outside the main interrupt handler, * to reduce the size of the handler. */ static u32 ace_handle_event(struct net_device *dev, u32 evtcsm, u32 evtprd) { … } static void ace_rx_int(struct net_device *dev, u32 rxretprd, u32 rxretcsm) { … } static inline void ace_tx_int(struct net_device *dev, u32 txcsm, u32 idx) { … } static irqreturn_t ace_interrupt(int irq, void *dev_id) { … } static int ace_open(struct net_device *dev) { … } static int ace_close(struct net_device *dev) { … } static inline dma_addr_t ace_map_tx_skb(struct ace_private *ap, struct sk_buff *skb, struct sk_buff *tail, u32 idx) { … } static inline void ace_load_tx_bd(struct ace_private *ap, struct tx_desc *desc, u64 addr, u32 flagsize, u32 vlan_tag) { … } static netdev_tx_t ace_start_xmit(struct sk_buff *skb, struct net_device *dev) { … } static int ace_change_mtu(struct net_device *dev, int new_mtu) { … } static int ace_get_link_ksettings(struct net_device *dev, struct ethtool_link_ksettings *cmd) { … } static int ace_set_link_ksettings(struct net_device *dev, const struct ethtool_link_ksettings *cmd) { … } static void ace_get_drvinfo(struct net_device *dev, struct ethtool_drvinfo *info) { … } /* * Set the hardware MAC address. */ static int ace_set_mac_addr(struct net_device *dev, void *p) { … } static void ace_set_multicast_list(struct net_device *dev) { … } static struct net_device_stats *ace_get_stats(struct net_device *dev) { … } static void ace_copy(struct ace_regs __iomem *regs, const __be32 *src, u32 dest, int size) { … } static void ace_clear(struct ace_regs __iomem *regs, u32 dest, int size) { … } /* * Download the firmware into the SRAM on the NIC * * This operation requires the NIC to be halted and is performed with * interrupts disabled and with the spinlock hold. */ static int ace_load_firmware(struct net_device *dev) { … } /* * The eeprom on the AceNIC is an Atmel i2c EEPROM. * * Accessing the EEPROM is `interesting' to say the least - don't read * this code right after dinner. * * This is all about black magic and bit-banging the device .... I * wonder in what hospital they have put the guy who designed the i2c * specs. * * Oh yes, this is only the beginning! * * Thanks to Stevarino Webinski for helping tracking down the bugs in the * code i2c readout code by beta testing all my hacks. */ static void eeprom_start(struct ace_regs __iomem *regs) { … } static void eeprom_prep(struct ace_regs __iomem *regs, u8 magic) { … } static int eeprom_check_ack(struct ace_regs __iomem *regs) { … } static void eeprom_stop(struct ace_regs __iomem *regs) { … } /* * Read a whole byte from the EEPROM. */ static int read_eeprom_byte(struct net_device *dev, unsigned long offset) { … } module_pci_driver(…) …;
Codebase Browser
linux