litmus-rt.git - The LITMUS^RT kernel.

	Commit message (Expand)	Author	Age
*	[PATCH] complete message queue auditing	Amy Griffis	2007-05-11
*	fs: use path_walk in do_path_lookup	Josef 'Jeff' Sipek	2007-05-09
*	fs: fix indentation in do_path_lookup	Josef 'Jeff' Sipek	2007-05-09
*	header cleaning: don't include smp_lock.h when not used	Randy Dunlap	2007-05-08
*	namei.c: remove utterly outdated comment	Christoph Hellwig	2007-05-08
*	mm: make read_cache_page synchronous	Nick Piggin	2007-05-07
*	security: prevent permission checking of file removal via sysfs_remove_group()	James Morris	2007-04-27
*	[PATCH] __page_symlink retry loop error code fix	Dmitriy Monakhov	2007-02-16
*	[PATCH] mark struct inode_operations const 2	Arjan van de Ven	2007-02-12
*	[PATCH] VFS: change struct file to use struct path	Josef "Jeff" Sipek	2006-12-08
*	[PATCH] struct path: move struct path from fs/namei.c into include/linux	Josef "Jeff" Sipek	2006-12-08
*	[PATCH] VFS: extra check inside dentry_unhash()	Vasily Averin	2006-12-07
*	[PATCH] honour MNT_NOEXEC for access()	Stas Sergeev	2006-12-07
*	[PATCH] r/o bind mount prepwork: move open_namei()'s vfs_create()	Dave Hansen	2006-10-01
*	[PATCH] r/o bind mounts: prepare for write access checks: collapse if()	Dave Hansen	2006-10-01
*	[PATCH] fs/namei.c: replace multiple current->fs by shortcut variable	Andreas Mohr	2006-09-29
*	[PATCH] autofs4 needs to force fail return revalidate	Ian Kent	2006-09-27
*	[PATCH] Allow file systems to manually d_move() inside of ->rename()	Mark Fasheh	2006-09-24
*	VFS: Fix access("file", X_OK) in the presence of ACLs	Trond Myklebust	2006-08-24
*	VFS: add lookup hint for network file systems	ASANO Masahiro	2006-08-24
*	[PATCH] don't bother with aux entires for dummy context	Al Viro	2006-08-03
*	[PATCH] fix missed create event for directory audit	Amy Griffis	2006-08-03
*	[PATCH] fix faulty inode data collection for open() with O_CREAT	Amy Griffis	2006-08-03
*	[PATCH] struct file leakage	Kirill Korotaev	2006-07-15
*	[PATCH] lockdep: annotate i_mutex	Ingo Molnar	2006-07-03
*	[PATCH] Implement AT_SYMLINK_FOLLOW flag for linkat	Ulrich Drepper	2006-06-25
*	[PATCH] read_mapping_page for address space	Pekka Enberg	2006-06-23
*	[PATCH] log more info for directory entry change events	Amy Griffis	2006-06-20
*	[PATCH] fs/namei.c: Call to file_permission() under a spinlock in do_lookup_p...	Trond Myklebust	2006-06-05
*	[PATCH] fs/namei.c: make lookup_hash() static	Adrian Bunk	2006-03-31
*	[PATCH] autofs4: nameidata needs to be up to date for follow_link	Ian Kent	2006-03-27
*	Merge branch 'audit.b3' of git://git.kernel.org/pub/scm/linux/kernel/git/viro...	Linus Torvalds	2006-03-25
\|\
\| *	[PATCH] Collect more inode information during syscall processing.	Amy Griffis	2006-03-20
\| *	[PATCH] Pass dentry, not just name, in fsnotify creation hooks.	Amy Griffis	2006-03-20
* \|	[PATCH] Honour AOP_TRUNCATE_PAGE returns in page_symlink	NeilBrown	2006-03-25
* \|	[PATCH] Missed error checking for intent's filp in open_namei().	Oleg Drokin	2006-03-25
* \|	[PATCH] sem2mutex: vfs_rename_mutex	Arjan van de Ven	2006-03-23
\|/
*	[PATCH] ext3: ext3_symlink should use GFP_NOFS allocations inside	Kirill Korotaev	2006-03-11
*	[PATCH] flags parameter for linkat	Ulrich Drepper	2006-02-24
*	[PATCH] Fix do_path_lookup() to add the check for error in link_path_walk()	Suzuki	2006-02-07
*	[PATCH] namei.c: unlock missing in error case	Ulrich Drepper	2006-02-05
*	[PATCH] VFS: Ensure LOOKUP_CONTINUE flag is preserved by link_path_walk()	Trond Myklebust	2006-02-05
*	[PATCH] DocBook: fix some kernel-doc comments in fs and block	Martin Waitz	2006-02-01
*	[PATCH] vfs: *at functions: core	Ulrich Drepper	2006-01-18
*	[PATCH] Mark some key VFS functions as __always_inline	Arjan van de Ven	2006-01-14
*	[PATCH] Unlinline a bunch of other functions	Arjan van de Ven	2006-01-14
*	[PATCH] capable/capability.h (fs/)	Randy Dunlap	2006-01-11
*	[PATCH] mutex subsystem, semaphore to mutex: VFS, ->i_sem	Jes Sorensen	2006-01-09
*	[PATCH] Fix some problems with truncate and mtime semantics.	NeilBrown	2006-01-08
*	[PATCH] fs/namei.c: make path_lookup_create() static	Adrian Bunk	2005-11-09

/****************************************************************************** * * Name: skge.c * Project: GEnesis, PCI Gigabit Ethernet Adapter * Version: $Revision: 1.45 $ * Date: $Date: 2004/02/12 14:41:02 $ * Purpose: The main driver source module * ******************************************************************************/ /****************************************************************************** * * (C)Copyright 1998-2002 SysKonnect GmbH. * (C)Copyright 2002-2003 Marvell. * * Driver for Marvell Yukon chipset and SysKonnect Gigabit Ethernet * Server Adapters. * * Created 10-Feb-1999, based on Linux' acenic.c, 3c59x.c and * SysKonnects GEnesis Solaris driver * Author: Christoph Goos (cgoos@syskonnect.de) * Mirko Lindner (mlindner@syskonnect.de) * * Address all question to: linux@syskonnect.de * * The technical manual for the adapters is available from SysKonnect's * web pages: www.syskonnect.com * Goto "Support" and search Knowledge Base for "manual". * * 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; either version 2 of the License, or * (at your option) any later version. * * The information in this file is provided "AS IS" without warranty. * ******************************************************************************/ /****************************************************************************** * * Possible compiler options (#define xxx / -Dxxx): * * debugging can be enable by changing SK_DEBUG_CHKMOD and * SK_DEBUG_CHKCAT in makefile (described there). * ******************************************************************************/ /****************************************************************************** * * Description: * * This is the main module of the Linux GE driver. * * All source files except skge.c, skdrv1st.h, skdrv2nd.h and sktypes.h * are part of SysKonnect's COMMON MODULES for the SK-98xx adapters. * Those are used for drivers on multiple OS', so some thing may seem * unnecessary complicated on Linux. Please do not try to 'clean up' * them without VERY good reasons, because this will make it more * difficult to keep the Linux driver in synchronisation with the * other versions. * * Include file hierarchy: * * <linux/module.h> * * "h/skdrv1st.h" * <linux/types.h> * <linux/kernel.h> * <linux/string.h> * <linux/errno.h> * <linux/ioport.h> * <linux/slab.h> * <linux/interrupt.h> * <linux/pci.h> * <linux/bitops.h> * <asm/byteorder.h> * <asm/io.h> * <linux/netdevice.h> * <linux/etherdevice.h> * <linux/skbuff.h> * those three depending on kernel version used: * <linux/bios32.h> * <linux/init.h> * <asm/uaccess.h> * <net/checksum.h> * * "h/skerror.h" * "h/skdebug.h" * "h/sktypes.h" * "h/lm80.h" * "h/xmac_ii.h" * * "h/skdrv2nd.h" * "h/skqueue.h" * "h/skgehwt.h" * "h/sktimer.h" * "h/ski2c.h" * "h/skgepnmi.h" * "h/skvpd.h" * "h/skgehw.h" * "h/skgeinit.h" * "h/skaddr.h" * "h/skgesirq.h" * "h/skrlmt.h" * ******************************************************************************/ #include "h/skversion.h" #include <linux/in.h> #include <linux/module.h> #include <linux/moduleparam.h> #include <linux/init.h> #include <linux/dma-mapping.h> #include <linux/ip.h> #include "h/skdrv1st.h" #include "h/skdrv2nd.h" /******************************************************************************* * * Defines * ******************************************************************************/ /* for debuging on x86 only */ /* #define BREAKPOINT() asm(" int $3"); */ /* use the transmit hw checksum driver functionality */ #define USE_SK_TX_CHECKSUM /* use the receive hw checksum driver functionality */ #define USE_SK_RX_CHECKSUM /* use the scatter-gather functionality with sendfile() */ #define SK_ZEROCOPY /* use of a transmit complete interrupt */ #define USE_TX_COMPLETE /* * threshold for copying small receive frames * set to 0 to avoid copying, set to 9001 to copy all frames */ #define SK_COPY_THRESHOLD 50 /* number of adapters that can be configured via command line params */ #define SK_MAX_CARD_PARAM 16 /* * use those defines for a compile-in version of the driver instead * of command line parameters */ // #define LINK_SPEED_A {"Auto", } // #define LINK_SPEED_B {"Auto", } // #define AUTO_NEG_A {"Sense", } // #define AUTO_NEG_B {"Sense", } // #define DUP_CAP_A {"Both", } // #define DUP_CAP_B {"Both", } // #define FLOW_CTRL_A {"SymOrRem", } // #define FLOW_CTRL_B {"SymOrRem", } // #define ROLE_A {"Auto", } // #define ROLE_B {"Auto", } // #define PREF_PORT {"A", } // #define CON_TYPE {"Auto", } // #define RLMT_MODE {"CheckLinkState", } #define DEV_KFREE_SKB(skb) dev_kfree_skb(skb) #define DEV_KFREE_SKB_IRQ(skb) dev_kfree_skb_irq(skb) #define DEV_KFREE_SKB_ANY(skb) dev_kfree_skb_any(skb) /* Set blink mode*/ #define OEM_CONFIG_VALUE ( SK_ACT_LED_BLINK | \ SK_DUP_LED_NORMAL | \ SK_LED_LINK100_ON) /* Isr return value */ #define SkIsrRetVar irqreturn_t #define SkIsrRetNone IRQ_NONE #define SkIsrRetHandled IRQ_HANDLED /******************************************************************************* * * Local Function Prototypes * ******************************************************************************/ static void FreeResources(struct SK_NET_DEVICE *dev); static int SkGeBoardInit(struct SK_NET_DEVICE *dev, SK_AC *pAC); static SK_BOOL BoardAllocMem(SK_AC *pAC); static void BoardFreeMem(SK_AC *pAC); static void BoardInitMem(SK_AC *pAC); static void SetupRing(SK_AC*, void*, uintptr_t, RXD**, RXD**, RXD**, int*, SK_BOOL); static SkIsrRetVar SkGeIsr(int irq, void *dev_id, struct pt_regs *ptregs); static SkIsrRetVar SkGeIsrOnePort(int irq, void *dev_id, struct pt_regs *ptregs); static int SkGeOpen(struct SK_NET_DEVICE *dev); static int SkGeClose(struct SK_NET_DEVICE *dev); static int SkGeXmit(struct sk_buff *skb, struct SK_NET_DEVICE *dev); static int SkGeSetMacAddr(struct SK_NET_DEVICE *dev, void *p); static void SkGeSetRxMode(struct SK_NET_DEVICE *dev); static struct net_device_stats *SkGeStats(struct SK_NET_DEVICE *dev); static int SkGeIoctl(struct SK_NET_DEVICE *dev, struct ifreq *rq, int cmd); static void GetConfiguration(SK_AC*); static int XmitFrame(SK_AC*, TX_PORT*, struct sk_buff*); static void FreeTxDescriptors(SK_AC*pAC, TX_PORT*); static void FillRxRing(SK_AC*, RX_PORT*); static SK_BOOL FillRxDescriptor(SK_AC*, RX_PORT*); static void ReceiveIrq(SK_AC*, RX_PORT*, SK_BOOL); static void ClearAndStartRx(SK_AC*, int); static void ClearTxIrq(SK_AC*, int, int); static void ClearRxRing(SK_AC*, RX_PORT*); static void ClearTxRing(SK_AC*, TX_PORT*); static int SkGeChangeMtu(struct SK_NET_DEVICE *dev, int new_mtu); static void PortReInitBmu(SK_AC*, int); static int SkGeIocMib(DEV_NET*, unsigned int, int); static int SkGeInitPCI(SK_AC *pAC); static void StartDrvCleanupTimer(SK_AC *pAC); static void StopDrvCleanupTimer(SK_AC *pAC); static int XmitFrameSG(SK_AC*, TX_PORT*, struct sk_buff*); #ifdef SK_DIAG_SUPPORT static SK_U32 ParseDeviceNbrFromSlotName(const char *SlotName); static int SkDrvInitAdapter(SK_AC *pAC, int devNbr); static int SkDrvDeInitAdapter(SK_AC *pAC, int devNbr); #endif /******************************************************************************* * * Extern Function Prototypes * ******************************************************************************/ extern void SkDimEnableModerationIfNeeded(SK_AC *pAC); extern void SkDimDisplayModerationSettings(SK_AC *pAC); extern void SkDimStartModerationTimer(SK_AC *pAC); extern void SkDimModerate(SK_AC *pAC); extern void SkGeBlinkTimer(unsigned long data); #ifdef DEBUG static void DumpMsg(struct sk_buff*, char*); static void DumpData(char*, int); static void DumpLong(char*, int); #endif /* global variables *********************************************************/ static SK_BOOL DoPrintInterfaceChange = SK_TRUE; extern struct ethtool_ops SkGeEthtoolOps; /* local variables **********************************************************/ static uintptr_t TxQueueAddr[SK_MAX_MACS][2] = {{0x680, 0x600},{0x780, 0x700}}; static uintptr_t RxQueueAddr[SK_MAX_MACS] = {0x400, 0x480}; /***************************************************************************** * * SkPciWriteCfgDWord - write a 32 bit value to pci config space * * Description: * This routine writes a 32 bit value to the pci configuration * space. * * Returns: * 0 - indicate everything worked ok. * != 0 - error indication */ static inline int SkPciWriteCfgDWord( SK_AC *pAC, /* Adapter Control structure pointer */ int PciAddr, /* PCI register address */ SK_U32 Val) /* pointer to store the read value */ { pci_write_config_dword(pAC->PciDev, PciAddr, Val); return(0); } /* SkPciWriteCfgDWord */ /***************************************************************************** * * SkGeInitPCI - Init the PCI resources * * Description: * This function initialize the PCI resources and IO * * Returns: * 0 - indicate everything worked ok. * != 0 - error indication */ static __devinit int SkGeInitPCI(SK_AC *pAC) { struct SK_NET_DEVICE *dev = pAC->dev[0]; struct pci_dev *pdev = pAC->PciDev; int retval; dev->mem_start = pci_resource_start (pdev, 0); pci_set_master(pdev); retval = pci_request_regions(pdev, "sk98lin"); if (retval) goto out; #ifdef SK_BIG_ENDIAN /* * On big endian machines, we use the adapter's aibility of * reading the descriptors as big endian. */ { SK_U32 our2; SkPciReadCfgDWord(pAC, PCI_OUR_REG_2, &our2); our2 |= PCI_REV_DESC; SkPciWriteCfgDWord(pAC, PCI_OUR_REG_2, our2); } #endif /* * Remap the regs into kernel space. */ pAC->IoBase = ioremap_nocache(dev->mem_start, 0x4000); if (!pAC->IoBase) { retval = -EIO; goto out_release; } return 0; out_release: pci_release_regions(pdev); out: return retval; } /***************************************************************************** * * FreeResources - release resources allocated for adapter * * Description: * This function releases the IRQ, unmaps the IO and * frees the desriptor ring. * * Returns: N/A * */ static void FreeResources(struct SK_NET_DEVICE *dev) { SK_U32 AllocFlag; DEV_NET *pNet; SK_AC *pAC; pNet = netdev_priv(dev); pAC = pNet->pAC; AllocFlag = pAC->AllocFlag; if (pAC->PciDev) { pci_release_regions(pAC->PciDev); } if (AllocFlag & SK_ALLOC_IRQ) { free_irq(dev->irq, dev); } if (pAC->IoBase) { iounmap(pAC->IoBase); } if (pAC->pDescrMem) { BoardFreeMem(pAC); } } /* FreeResources */ MODULE_AUTHOR("Mirko Lindner <mlindner@syskonnect.de>"); MODULE_DESCRIPTION("SysKonnect SK-NET Gigabit Ethernet SK-98xx driver"); MODULE_LICENSE("GPL"); #ifdef LINK_SPEED_A static char *Speed_A[SK_MAX_CARD_PARAM] = LINK_SPEED; #else static char *Speed_A[SK_MAX_CARD_PARAM] = {"", }; #endif #ifdef LINK_SPEED_B static char *Speed_B[SK_MAX_CARD_PARAM] = LINK_SPEED; #else static char *Speed_B[SK_MAX_CARD_PARAM] = {"", }; #endif #ifdef AUTO_NEG_A static char *AutoNeg_A[SK_MAX_CARD_PARAM] = AUTO_NEG_A; #else static char *AutoNeg_A[SK_MAX_CARD_PARAM] = {"", }; #endif #ifdef DUP_CAP_A static char *DupCap_A[SK_MAX_CARD_PARAM] = DUP_CAP_A; #else static char *DupCap_A[SK_MAX_CARD_PARAM] = {"", }; #endif #ifdef FLOW_CTRL_A static char *FlowCtrl_A[SK_MAX_CARD_PARAM] = FLOW_CTRL_A; #else static char *FlowCtrl_A[SK_MAX_CARD_PARAM] = {"", }; #endif #ifdef ROLE_A static char *Role_A[SK_MAX_CARD_PARAM] = ROLE_A; #else static char *Role_A[SK_MAX_CARD_PARAM] = {"", }; #endif #ifdef AUTO_NEG_B static char *AutoNeg_B[SK_MAX_CARD_PARAM] = AUTO_NEG_B; #else static char *AutoNeg_B[SK_MAX_CARD_PARAM] = {"", }; #endif #ifdef DUP_CAP_B static char *DupCap_B[SK_MAX_CARD_PARAM] = DUP_CAP_B; #else static char *DupCap_B[SK_MAX_CARD_PARAM] = {"", }; #endif #ifdef FLOW_CTRL_B static char *FlowCtrl_B[SK_MAX_CARD_PARAM] = FLOW_CTRL_B; #else static char *FlowCtrl_B[SK_MAX_CARD_PARAM] = {"", }; #endif #ifdef ROLE_B static char *Role_B[SK_MAX_CARD_PARAM] = ROLE_B; #else static char *Role_B[SK_MAX_CARD_PARAM] = {"", }; #endif #ifdef CON_TYPE static char *ConType[SK_MAX_CARD_PARAM] = CON_TYPE; #else static char *ConType[SK_MAX_CARD_PARAM] = {"", }; #endif #ifdef PREF_PORT static char *PrefPort[SK_MAX_CARD_PARAM] = PREF_PORT; #else static char *PrefPort[SK_MAX_CARD_PARAM] = {"", }; #endif #ifdef RLMT_MODE static char *RlmtMode[SK_MAX_CARD_PARAM] = RLMT_MODE; #else static char *RlmtMode[SK_MAX_CARD_PARAM] = {"", }; #endif static int IntsPerSec[SK_MAX_CARD_PARAM]; static char *Moderation[SK_MAX_CARD_PARAM]; static char *ModerationMask[SK_MAX_CARD_PARAM]; static char *AutoSizing[SK_MAX_CARD_PARAM]; static char *Stats[SK_MAX_CARD_PARAM]; module_param_array(Speed_A, charp, NULL, 0); module_param_array(Speed_B, charp, NULL, 0); module_param_array(AutoNeg_A, charp, NULL, 0); module_param_array(AutoNeg_B, charp, NULL, 0); module_param_array(DupCap_A, charp, NULL, 0); module_param_array(DupCap_B, charp, NULL, 0); module_param_array(FlowCtrl_A, charp, NULL, 0); module_param_array(FlowCtrl_B, charp, NULL, 0); module_param_array(Role_A, charp, NULL, 0); module_param_array(Role_B, charp, NULL, 0); module_param_array(ConType, charp, NULL, 0); module_param_array(PrefPort, charp, NULL, 0); module_param_array(RlmtMode, charp, NULL, 0); /* used for interrupt moderation */ module_param_array(IntsPerSec, int, NULL, 0); module_param_array(Moderation, charp, NULL, 0); module_param_array(Stats, charp, NULL, 0); module_param_array(ModerationMask, charp, NULL, 0); module_param_array(AutoSizing, charp, NULL, 0); /***************************************************************************** * * SkGeBoardInit - do level 0 and 1 initialization * * Description: * This function prepares the board hardware for running. The desriptor * ring is set up, the IRQ is allocated and the configuration settings * are examined. * * Returns: * 0, if everything is ok * !=0, on error */ static int __devinit SkGeBoardInit(struct SK_NET_DEVICE *dev, SK_AC *pAC) { short i; unsigned long Flags; char *DescrString = "sk98lin: Driver for Linux"; /* this is given to PNMI */ char *VerStr = VER_STRING; int Ret; /* return code of request_irq */ SK_BOOL DualNet; SK_DBG_MSG(NULL, SK_DBGMOD_DRV, SK_DBGCAT_DRV_ENTRY, ("IoBase: %08lX\n", (unsigned long)pAC->IoBase)); for (i=0; i<SK_MAX_MACS; i++) { pAC->TxPort[i][0].HwAddr = pAC->IoBase + TxQueueAddr[i][0]; pAC->TxPort[i][0].PortIndex = i; pAC->RxPort[i].HwAddr = pAC->IoBase + RxQueueAddr[i]; pAC->RxPort[i].PortIndex = i; } /* Initialize the mutexes */ for (i=0; i<SK_MAX_MACS; i++) { spin_lock_init(&pAC->TxPort[i][0].TxDesRingLock); spin_lock_init(&pAC->RxPort[i].RxDesRingLock); } spin_lock_init(&pAC->SlowPathLock); /* setup phy_id blink timer */ pAC->BlinkTimer.function = SkGeBlinkTimer; pAC->BlinkTimer.data = (unsigned long) dev; init_timer(&pAC->BlinkTimer); /* level 0 init common modules here */ spin_lock_irqsave(&pAC->SlowPathLock, Flags); /* Does a RESET on board ...*/ if (SkGeInit(pAC, pAC->IoBase, SK_INIT_DATA) != 0) { printk("HWInit (0) failed.\n"); spin_unlock_irqrestore(&pAC->SlowPathLock, Flags); return -EIO; } SkI2cInit( pAC, pAC->IoBase, SK_INIT_DATA); SkEventInit(pAC, pAC->IoBase, SK_INIT_DATA); SkPnmiInit( pAC, pAC->IoBase, SK_INIT_DATA); SkAddrInit( pAC, pAC->IoBase, SK_INIT_DATA); SkRlmtInit( pAC, pAC->IoBase, SK_INIT_DATA); SkTimerInit(pAC, pAC->IoBase, SK_INIT_DATA); pAC->BoardLevel = SK_INIT_DATA; pAC->RxBufSize = ETH_BUF_SIZE; SK_PNMI_SET_DRIVER_DESCR(pAC, DescrString); SK_PNMI_SET_DRIVER_VER(pAC, VerStr); spin_unlock_irqrestore(&pAC->SlowPathLock, Flags); /* level 1 init common modules here (HW init) */ spin_lock_irqsave(&pAC->SlowPathLock, Flags); if (SkGeInit(pAC, pAC->IoBase, SK_INIT_IO) != 0) { printk("sk98lin: HWInit (1) failed.\n"); spin_unlock_irqrestore(&pAC->SlowPathLock, Flags); return -EIO; } SkI2cInit( pAC, pAC->IoBase, SK_INIT_IO); SkEventInit(pAC, pAC->IoBase, SK_INIT_IO); SkPnmiInit( pAC, pAC->IoBase, SK_INIT_IO); SkAddrInit( pAC, pAC->IoBase, SK_INIT_IO); SkRlmtInit( pAC, pAC->IoBase, SK_INIT_IO); SkTimerInit(pAC, pAC->IoBase, SK_INIT_IO); /* Set chipset type support */ pAC->ChipsetType = 0; if ((pAC->GIni.GIChipId == CHIP_ID_YUKON) || (pAC->GIni.GIChipId == CHIP_ID_YUKON_LITE)) { pAC->ChipsetType = 1; } GetConfiguration(pAC); if (pAC->RlmtNets == 2) { pAC->GIni.GIPortUsage = SK_MUL_LINK; } pAC->BoardLevel = SK_INIT_IO; spin_unlock_irqrestore(&pAC->SlowPathLock, Flags); if (pAC->GIni.GIMacsFound == 2) { Ret = request_irq(dev->irq, SkGeIsr, SA_SHIRQ, "sk98lin", dev); } else if (pAC->GIni.GIMacsFound == 1) { Ret = request_irq(dev->irq, SkGeIsrOnePort, SA_SHIRQ, "sk98lin", dev); } else { printk(KERN_WARNING "sk98lin: Illegal number of ports: %d\n", pAC->GIni.GIMacsFound); return -EIO; } if (Ret) { printk(KERN_WARNING "sk98lin: Requested IRQ %d is busy.\n", dev->irq); return Ret; } pAC->AllocFlag |= SK_ALLOC_IRQ; /* Alloc memory for this board (Mem for RxD/TxD) : */ if(!BoardAllocMem(pAC)) { printk("No memory for descriptor rings.\n"); return -ENOMEM; } BoardInitMem(pAC); /* tschilling: New common function with minimum size check. */ DualNet = SK_FALSE; if (pAC->RlmtNets == 2) { DualNet = SK_TRUE; } if (SkGeInitAssignRamToQueues( pAC, pAC->ActivePort, DualNet)) { BoardFreeMem(pAC); printk("sk98lin: SkGeInitAssignRamToQueues failed.\n"); return -EIO; } return (0); } /* SkGeBoardInit */ /***************************************************************************** * * BoardAllocMem - allocate the memory for the descriptor rings * * Description: * This function allocates the memory for all descriptor rings. * Each ring is aligned for the desriptor alignment and no ring * has a 4 GByte boundary in it (because the upper 32 bit must * be constant for all descriptiors in one rings). * * Returns: * SK_TRUE, if all memory could be allocated * SK_FALSE, if not */ static __devinit SK_BOOL BoardAllocMem(SK_AC *pAC) { caddr_t pDescrMem; /* pointer to descriptor memory area */ size_t AllocLength; /* length of complete descriptor area */ int i; /* loop counter */ unsigned long BusAddr; /* rings plus one for alignment (do not cross 4 GB boundary) */ /* RX_RING_SIZE is assumed bigger than TX_RING_SIZE */ #if (BITS_PER_LONG == 32) AllocLength = (RX_RING_SIZE + TX_RING_SIZE) * pAC->GIni.GIMacsFound + 8; #else AllocLength = (RX_RING_SIZE + TX_RING_SIZE) * pAC->GIni.GIMacsFound + RX_RING_SIZE + 8; #endif pDescrMem = pci_alloc_consistent(pAC->PciDev, AllocLength, &pAC->pDescrMemDMA); if (pDescrMem == NULL) { return (SK_FALSE); } pAC->pDescrMem = pDescrMem; BusAddr = (unsigned long) pAC->pDescrMemDMA; /* Descriptors need 8 byte alignment, and this is ensured * by pci_alloc_consistent. */ for (i=0; i<pAC->GIni.GIMacsFound; i++) { SK_DBG_MSG(NULL, SK_DBGMOD_DRV, SK_DBGCAT_DRV_TX_PROGRESS, ("TX%d/A: pDescrMem: %lX, PhysDescrMem: %lX\n", i, (unsigned long) pDescrMem, BusAddr)); pAC->TxPort[i][0].pTxDescrRing = pDescrMem; pAC->TxPort[i][0].VTxDescrRing = BusAddr; pDescrMem += TX_RING_SIZE; BusAddr += TX_RING_SIZE; SK_DBG_MSG(NULL, SK_DBGMOD_DRV, SK_DBGCAT_DRV_TX_PROGRESS, ("RX%d: pDescrMem: %lX, PhysDescrMem: %lX\n", i, (unsigned long) pDescrMem, (unsigned long)BusAddr)); pAC->RxPort[i].pRxDescrRing = pDescrMem; pAC->RxPort[i].VRxDescrRing = BusAddr; pDescrMem += RX_RING_SIZE; BusAddr += RX_RING_SIZE; } /* for */ return (SK_TRUE); } /* BoardAllocMem */ /**************************************************************************** * * BoardFreeMem - reverse of BoardAllocMem * * Description: * Free all memory allocated in BoardAllocMem: adapter context, * descriptor rings, locks. * * Returns: N/A */ static void BoardFreeMem( SK_AC *pAC) { size_t AllocLength; /* length of complete descriptor area */ SK_DBG_MSG(NULL, SK_DBGMOD_DRV, SK_DBGCAT_DRV_ENTRY, ("BoardFreeMem\n")); #if (BITS_PER_LONG == 32) AllocLength = (RX_RING_SIZE + TX_RING_SIZE) * pAC->GIni.GIMacsFound + 8; #else AllocLength = (RX_RING_SIZE + TX_RING_SIZE) * pAC->GIni.GIMacsFound + RX_RING_SIZE + 8; #endif pci_free_consistent(pAC->PciDev, AllocLength, pAC->pDescrMem, pAC->pDescrMemDMA); pAC->pDescrMem = NULL; } /* BoardFreeMem */ /***************************************************************************** * * BoardInitMem - initiate the descriptor rings * * Description: * This function sets the descriptor rings up in memory. * The adapter is initialized with the descriptor start addresses. * * Returns: N/A */ static __devinit void BoardInitMem(SK_AC *pAC) { int i; /* loop counter */ int RxDescrSize; /* the size of a rx descriptor rounded up to alignment*/ int TxDescrSize; /* the size of a tx descriptor rounded up to alignment*/ SK_DBG_MSG(NULL, SK_DBGMOD_DRV, SK_DBGCAT_DRV_ENTRY, ("BoardInitMem\n")); RxDescrSize = (((sizeof(RXD) - 1) / DESCR_ALIGN) + 1) * DESCR_ALIGN; pAC->RxDescrPerRing = RX_RING_SIZE / RxDescrSize; TxDescrSize = (((sizeof(TXD) - 1) / DESCR_ALIGN) + 1) * DESCR_ALIGN; pAC->TxDescrPerRing = TX_RING_SIZE / RxDescrSize; for (i=0; i<pAC->GIni.GIMacsFound; i++) { SetupRing( pAC, pAC->TxPort[i][0].pTxDescrRing, pAC->TxPort[i][0].VTxDescrRing, (RXD**)&pAC->TxPort[i][0].pTxdRingHead, (RXD**)&pAC->TxPort[i][0].pTxdRingTail, (RXD**)&pAC->TxPort[i][0].pTxdRingPrev, &pAC->TxPort[i][0].TxdRingFree, SK_TRUE); SetupRing( pAC, pAC->RxPort[i].pRxDescrRing, pAC->RxPort[i].VRxDescrRing, &pAC->RxPort[i].pRxdRingHead, &pAC->RxPort[i].pRxdRingTail, &pAC->RxPort[i].pRxdRingPrev, &pAC->RxPort[i].RxdRingFree, SK_FALSE); } } /* BoardInitMem */ /***************************************************************************** * * SetupRing - create one descriptor ring * * Description: * This function creates one descriptor ring in the given memory area. * The head, tail and number of free descriptors in the ring are set. * * Returns: * none */ static void SetupRing( SK_AC *pAC, void *pMemArea, /* a pointer to the memory area for the ring */ uintptr_t VMemArea, /* the virtual bus address of the memory area */ RXD **ppRingHead, /* address where the head should be written */ RXD **ppRingTail, /* address where the tail should be written */ RXD **ppRingPrev, /* address where the tail should be written */ int *pRingFree, /* address where the # of free descr. goes */ SK_BOOL IsTx) /* flag: is this a tx ring */ { int i; /* loop counter */ int DescrSize; /* the size of a descriptor rounded up to alignment*/ int DescrNum; /* number of descriptors per ring */ RXD *pDescr; /* pointer to a descriptor (receive or transmit) */ RXD *pNextDescr; /* pointer to the next descriptor */ RXD *pPrevDescr; /* pointer to the previous descriptor */ uintptr_t VNextDescr; /* the virtual bus address of the next descriptor */ if (IsTx == SK_TRUE) { DescrSize = (((sizeof(TXD) - 1) / DESCR_ALIGN) + 1) * DESCR_ALIGN; DescrNum = TX_RING_SIZE / DescrSize; } else { DescrSize = (((sizeof(RXD) - 1) / DESCR_ALIGN) + 1) * DESCR_ALIGN; DescrNum = RX_RING_SIZE / DescrSize; } SK_DBG_MSG(NULL, SK_DBGMOD_DRV, SK_DBGCAT_DRV_TX_PROGRESS, ("Descriptor size: %d Descriptor Number: %d\n", DescrSize,DescrNum)); pDescr = (RXD*) pMemArea; pPrevDescr = NULL; pNextDescr = (RXD*) (((char*)pDescr) + DescrSize); VNextDescr = VMemArea + DescrSize; for(i=0; i<DescrNum; i++) { /* set the pointers right */ pDescr->VNextRxd = VNextDescr & 0xffffffffULL; pDescr->pNextRxd = pNextDescr; if (!IsTx) pDescr->TcpSumStarts = ETH_HLEN << 16 | ETH_HLEN; /* advance one step */ pPrevDescr = pDescr; pDescr = pNextDescr; pNextDescr = (RXD*) (((char*)pDescr) + DescrSize); VNextDescr += DescrSize; } pPrevDescr->pNextRxd = (RXD*) pMemArea; pPrevDescr->VNextRxd = VMemArea; pDescr = (RXD*) pMemArea; *ppRingHead = (RXD*) pMemArea; *ppRingTail = *ppRingHead; *ppRingPrev = pPrevDescr; *pRingFree = DescrNum; } /* SetupRing */ /***************************************************************************** * * PortReInitBmu - re-initiate the descriptor rings for one port * * Description: * This function reinitializes the descriptor rings of one port * in memory. The port must be stopped before. * The HW is initialized with the descriptor start addresses. * * Returns: * none */ static void PortReInitBmu( SK_AC *pAC, /* pointer to adapter context */ int PortIndex) /* index of the port for which to re-init */ { SK_DBG_MSG(NULL, SK_DBGMOD_DRV, SK_DBGCAT_DRV_ENTRY, ("PortReInitBmu ")); /* set address of first descriptor of ring in BMU */ SK_OUT32(pAC->IoBase, TxQueueAddr[PortIndex][TX_PRIO_LOW]+ Q_DA_L, (uint32_t)(((caddr_t) (pAC->TxPort[PortIndex][TX_PRIO_LOW].pTxdRingHead) - pAC->TxPort[PortIndex][TX_PRIO_LOW].pTxDescrRing + pAC->TxPort[PortIndex][TX_PRIO_LOW].VTxDescrRing) & 0xFFFFFFFF)); SK_OUT32(pAC->IoBase, TxQueueAddr[PortIndex][TX_PRIO_LOW]+ Q_DA_H, (uint32_t)(((caddr_t) (pAC->TxPort[PortIndex][TX_PRIO_LOW].pTxdRingHead) - pAC->TxPort[PortIndex][TX_PRIO_LOW].pTxDescrRing + pAC->TxPort[PortIndex][TX_PRIO_LOW].VTxDescrRing) >> 32)); SK_OUT32(pAC->IoBase, RxQueueAddr[PortIndex]+Q_DA_L, (uint32_t)(((caddr_t)(pAC->RxPort[PortIndex].pRxdRingHead) - pAC->RxPort[PortIndex].pRxDescrRing + pAC->RxPort[PortIndex].VRxDescrRing) & 0xFFFFFFFF)); SK_OUT32(pAC->IoBase, RxQueueAddr[PortIndex]+Q_DA_H, (uint32_t)(((caddr_t)(pAC->RxPort[PortIndex].pRxdRingHead) - pAC->RxPort[PortIndex].pRxDescrRing + pAC->RxPort[PortIndex].VRxDescrRing) >> 32)); } /* PortReInitBmu */ /**************************************************************************** * * SkGeIsr - handle adapter interrupts * * Description: * The interrupt routine is called when the network adapter * generates an interrupt. It may also be called if another device * shares this interrupt vector with the driver. * * Returns: N/A * */ static SkIsrRetVar SkGeIsr(int irq, void *dev_id, struct pt_regs *ptregs) { struct SK_NET_DEVICE *dev = (struct SK_NET_DEVICE *)dev_id; DEV_NET *pNet; SK_AC *pAC; SK_U32 IntSrc; /* interrupts source register contents */ pNet = netdev_priv(dev); pAC = pNet->pAC; /* * Check and process if its our interrupt */ SK_IN32(pAC->IoBase, B0_SP_ISRC, &IntSrc); if (IntSrc == 0) { return SkIsrRetNone; } while (((IntSrc & IRQ_MASK) & ~SPECIAL_IRQS) != 0) { #if 0 /* software irq currently not used */ if (IntSrc & IS_IRQ_SW) { SK_DBG_MSG(NULL, SK_DBGMOD_DRV, SK_DBGCAT_DRV_INT_SRC, ("Software IRQ\n")); } #endif if (IntSrc & IS_R1_F) { SK_DBG_MSG(NULL, SK_DBGMOD_DRV, SK_DBGCAT_DRV_INT_SRC, ("EOF RX1 IRQ\n")); ReceiveIrq(pAC, &pAC->RxPort[0], SK_TRUE); SK_PNMI_CNT_RX_INTR(pAC, 0); } if (IntSrc & IS_R2_F) { SK_DBG_MSG(NULL, SK_DBGMOD_DRV, SK_DBGCAT_DRV_INT_SRC, ("EOF RX2 IRQ\n")); ReceiveIrq(pAC, &pAC->RxPort[1], SK_TRUE); SK_PNMI_CNT_RX_INTR(pAC, 1); } #ifdef USE_TX_COMPLETE /* only if tx complete interrupt used */ if (IntSrc & IS_XA1_F) { SK_DBG_MSG(NULL, SK_DBGMOD_DRV, SK_DBGCAT_DRV_INT_SRC, ("EOF AS TX1 IRQ\n")); SK_PNMI_CNT_TX_INTR(pAC, 0); spin_lock(&pAC->TxPort[0][TX_PRIO_LOW].TxDesRingLock); FreeTxDescriptors(pAC, &pAC->TxPort[0][TX_PRIO_LOW]); spin_unlock(&pAC->TxPort[0][TX_PRIO_LOW].TxDesRingLock); } if (IntSrc & IS_XA2_F) { SK_DBG_MSG(NULL, SK_DBGMOD_DRV, SK_DBGCAT_DRV_INT_SRC, ("EOF AS TX2 IRQ\n")); SK_PNMI_CNT_TX_INTR(pAC, 1); spin_lock(&pAC->TxPort[1][TX_PRIO_LOW].TxDesRingLock); FreeTxDescriptors(pAC, &pAC->TxPort[1][TX_PRIO_LOW]); spin_unlock(&pAC->TxPort[1][TX_PRIO_LOW].TxDesRingLock); } #if 0 /* only if sync. queues used */ if (IntSrc & IS_XS1_F) { SK_DBG_MSG(NULL, SK_DBGMOD_DRV, SK_DBGCAT_DRV_INT_SRC, ("EOF SY TX1 IRQ\n")); SK_PNMI_CNT_TX_INTR(pAC, 1); spin_lock(&pAC->TxPort[0][TX_PRIO_HIGH].TxDesRingLock); FreeTxDescriptors(pAC, 0, TX_PRIO_HIGH); spin_unlock(&pAC->TxPort[0][TX_PRIO_HIGH].TxDesRingLock); ClearTxIrq(pAC, 0, TX_PRIO_HIGH); } if (IntSrc & IS_XS2_F) { SK_DBG_MSG(NULL, SK_DBGMOD_DRV, SK_DBGCAT_DRV_INT_SRC, ("EOF SY TX2 IRQ\n")); SK_PNMI_CNT_TX_INTR(pAC, 1); spin_lock(&pAC->TxPort[1][TX_PRIO_HIGH].TxDesRingLock); FreeTxDescriptors(pAC, 1, TX_PRIO_HIGH); spin_unlock(&pAC->TxPort[1][TX_PRIO_HIGH].TxDesRingLock); ClearTxIrq(pAC, 1, TX_PRIO_HIGH); } #endif #endif /* do all IO at once */ if (IntSrc & IS_R1_F) ClearAndStartRx(pAC, 0); if (IntSrc & IS_R2_F) ClearAndStartRx(pAC, 1); #ifdef USE_TX_COMPLETE /* only if tx complete interrupt used */ if (IntSrc & IS_XA1_F) ClearTxIrq(pAC, 0, TX_PRIO_LOW); if (IntSrc & IS_XA2_F) ClearTxIrq(pAC, 1, TX_PRIO_LOW); #endif SK_IN32(pAC->IoBase, B0_ISRC, &IntSrc); } /* while (IntSrc & IRQ_MASK != 0) */ IntSrc &= pAC->GIni.GIValIrqMask; if ((IntSrc & SPECIAL_IRQS) || pAC->CheckQueue) { SK_DBG_MSG(NULL, SK_DBGMOD_DRV, SK_DBGCAT_DRV_INT_SRC, ("SPECIAL IRQ DP-Cards => %x\n", IntSrc)); pAC->CheckQueue = SK_FALSE; spin_lock(&pAC->SlowPathLock); if (IntSrc & SPECIAL_IRQS) SkGeSirqIsr(pAC, pAC->IoBase, IntSrc); SkEventDispatcher(pAC, pAC->IoBase); spin_unlock(&pAC->SlowPathLock); } /* * do it all again is case we cleared an interrupt that * came in after handling the ring (OUTs may be delayed * in hardware buffers, but are through after IN) * * rroesler: has been commented out and shifted to * SkGeDrvEvent(), because it is timer * guarded now * ReceiveIrq(pAC, &pAC->RxPort[0], SK_TRUE); ReceiveIrq(pAC, &pAC->RxPort[1], SK_TRUE); */ if (pAC->CheckQueue) { pAC->CheckQueue = SK_FALSE; spin_lock(&pAC->SlowPathLock); SkEventDispatcher(pAC, pAC->IoBase); spin_unlock(&pAC->SlowPathLock); } /* IRQ is processed - Enable IRQs again*/ SK_OUT32(pAC->IoBase, B0_IMSK, pAC->GIni.GIValIrqMask); return SkIsrRetHandled; } /* SkGeIsr */ /**************************************************************************** * * SkGeIsrOnePort - handle adapter interrupts for single port adapter * * Description: * The interrupt routine is called when the network adapter * generates an interrupt. It may also be called if another device * shares this interrupt vector with the driver. * This is the same as above, but handles only one port. * * Returns: N/A * */ static SkIsrRetVar SkGeIsrOnePort(int irq, void *dev_id, struct pt_regs *ptregs) { struct SK_NET_DEVICE *dev = (struct SK_NET_DEVICE *)dev_id; DEV_NET *pNet; SK_AC *pAC; SK_U32 IntSrc; /* interrupts source register contents */ pNet = netdev_priv(dev); pAC = pNet->pAC; /* * Check and process if its our interrupt */ SK_IN32(pAC->IoBase, B0_SP_ISRC, &IntSrc); if (IntSrc == 0) { return SkIsrRetNone; } while (((IntSrc & IRQ_MASK) & ~SPECIAL_IRQS) != 0) { #if 0 /* software irq currently not used */ if (IntSrc & IS_IRQ_SW) { SK_DBG_MSG(NULL, SK_DBGMOD_DRV, SK_DBGCAT_DRV_INT_SRC, ("Software IRQ\n")); } #endif if (IntSrc & IS_R1_F) { SK_DBG_MSG(NULL, SK_DBGMOD_DRV, SK_DBGCAT_DRV_INT_SRC, ("EOF RX1 IRQ\n")); ReceiveIrq(pAC, &pAC->RxPort[0], SK_TRUE); SK_PNMI_CNT_RX_INTR(pAC, 0); } #ifdef USE_TX_COMPLETE /* only if tx complete interrupt used */ if (IntSrc & IS_XA1_F) { SK_DBG_MSG(NULL, SK_DBGMOD_DRV, SK_DBGCAT_DRV_INT_SRC, ("EOF AS TX1 IRQ\n")); SK_PNMI_CNT_TX_INTR(pAC, 0); spin_lock(&pAC->TxPort[0][TX_PRIO_LOW].TxDesRingLock); FreeTxDescriptors(pAC, &pAC->TxPort[0][TX_PRIO_LOW]); spin_unlock(&pAC->TxPort[0][TX_PRIO_LOW].TxDesRingLock); } #if 0 /* only if sync. queues used */ if (IntSrc & IS_XS1_F) { SK_DBG_MSG(NULL, SK_DBGMOD_DRV, SK_DBGCAT_DRV_INT_SRC, ("EOF SY TX1 IRQ\n")); SK_PNMI_CNT_TX_INTR(pAC, 0); spin_lock(&pAC->TxPort[0][TX_PRIO_HIGH].TxDesRingLock); FreeTxDescriptors(pAC, 0, TX_PRIO_HIGH); spin_unlock(&pAC->TxPort[0][TX_PRIO_HIGH].TxDesRingLock); ClearTxIrq(pAC, 0, TX_PRIO_HIGH); } #endif #endif /* do all IO at once */ if (IntSrc & IS_R1_F) ClearAndStartRx(pAC, 0); #ifdef USE_TX_COMPLETE /* only if tx complete interrupt used */ if (IntSrc & IS_XA1_F) ClearTxIrq(pAC, 0, TX_PRIO_LOW); #endif SK_IN32(pAC->IoBase, B0_ISRC, &IntSrc); } /* while (IntSrc & IRQ_MASK != 0) */ IntSrc &= pAC->GIni.GIValIrqMask; if ((IntSrc & SPECIAL_IRQS) || pAC->CheckQueue) { SK_DBG_MSG(NULL, SK_DBGMOD_DRV, SK_DBGCAT_DRV_INT_SRC, ("SPECIAL IRQ SP-Cards => %x\n", IntSrc)); pAC->CheckQueue = SK_FALSE; spin_lock(&pAC->SlowPathLock); if (IntSrc & SPECIAL_IRQS) SkGeSirqIsr(pAC, pAC->IoBase, IntSrc); SkEventDispatcher(pAC, pAC->IoBase); spin_unlock(&pAC->SlowPathLock); } /* * do it all again is case we cleared an interrupt that * came in after handling the ring (OUTs may be delayed * in hardware buffers, but are through after IN) * * rroesler: has been commented out and shifted to * SkGeDrvEvent(), because it is timer * guarded now * ReceiveIrq(pAC, &pAC->RxPort[0], SK_TRUE); */ /* IRQ is processed - Enable IRQs again*/ SK_OUT32(pAC->IoBase, B0_IMSK, pAC->GIni.GIValIrqMask); return SkIsrRetHandled; } /* SkGeIsrOnePort */ #ifdef CONFIG_NET_POLL_CONTROLLER /**************************************************************************** * * SkGePollController - polling receive, for netconsole * * Description: * Polling receive - used by netconsole and other diagnostic tools * to allow network i/o with interrupts disabled. * * Returns: N/A */ static void SkGePollController(struct net_device *dev) { disable_irq(dev->irq); SkGeIsr(dev->irq, dev, NULL); enable_irq(dev->irq); } #endif /**************************************************************************** * * SkGeOpen - handle start of initialized adapter * * Description: * This function starts the initialized adapter. * The board level variable is set and the adapter is * brought to full functionality. * The device flags are set for operation. * Do all necessary level 2 initialization, enable interrupts and * give start command to RLMT. * * Returns: * 0 on success * != 0 on error */ static int SkGeOpen( struct SK_NET_DEVICE *dev) { DEV_NET *pNet; SK_AC *pAC; unsigned long Flags; /* for spin lock */ int i; SK_EVPARA EvPara; /* an event parameter union */ pNet = netdev_priv(dev); pAC = pNet->pAC; SK_DBG_MSG(NULL, SK_DBGMOD_DRV, SK_DBGCAT_DRV_ENTRY, ("SkGeOpen: pAC=0x%lX:\n", (unsigned long)pAC)); #ifdef SK_DIAG_SUPPORT if (pAC->DiagModeActive == DIAG_ACTIVE) { if (pAC->Pnmi.DiagAttached == SK_DIAG_RUNNING) { return (-1); /* still in use by diag; deny actions */ } } #endif /* Set blink mode */ if ((pAC->PciDev->vendor == 0x1186) || (pAC->PciDev->vendor == 0x11ab )) pAC->GIni.GILedBlinkCtrl = OEM_CONFIG_VALUE; if (pAC->BoardLevel == SK_INIT_DATA) { /* level 1 init common modules here */ if (SkGeInit(pAC, pAC->IoBase, SK_INIT_IO) != 0) { printk("%s: HWInit (1) failed.\n", pAC->dev[pNet->PortNr]->name); return (-1); } SkI2cInit (pAC, pAC->IoBase, SK_INIT_IO); SkEventInit (pAC, pAC->IoBase, SK_INIT_IO); SkPnmiInit (pAC, pAC->IoBase, SK_INIT_IO); SkAddrInit (pAC, pAC->IoBase, SK_INIT_IO); SkRlmtInit (pAC, pAC->IoBase, SK_INIT_IO); SkTimerInit (pAC, pAC->IoBase, SK_INIT_IO); pAC->BoardLevel = SK_INIT_IO; } if (pAC->BoardLevel != SK_INIT_RUN) { /* tschilling: Level 2 init modules here, check return value. */ if (SkGeInit(pAC, pAC->IoBase, SK_INIT_RUN) != 0) { printk("%s: HWInit (2) failed.\n", pAC->dev[pNet->PortNr]->name); return (-1); } SkI2cInit (pAC, pAC->IoBase, SK_INIT_RUN); SkEventInit (pAC, pAC->IoBase, SK_INIT_RUN); SkPnmiInit (pAC, pAC->IoBase, SK_INIT_RUN); SkAddrInit (pAC, pAC->IoBase, SK_INIT_RUN); SkRlmtInit (pAC, pAC->IoBase, SK_INIT_RUN); SkTimerInit (pAC, pAC->IoBase, SK_INIT_RUN); pAC->BoardLevel = SK_INIT_RUN; } for (i=0; i<pAC->GIni.GIMacsFound; i++) { /* Enable transmit descriptor polling. */ SkGePollTxD(pAC, pAC->IoBase, i, SK_TRUE); FillRxRing(pAC, &pAC->RxPort[i]); } SkGeYellowLED(pAC, pAC->IoBase, 1); StartDrvCleanupTimer(pAC); SkDimEnableModerationIfNeeded(pAC); SkDimDisplayModerationSettings(pAC); pAC->GIni.GIValIrqMask &= IRQ_MASK; /* enable Interrupts */ SK_OUT32(pAC->IoBase, B0_IMSK, pAC->GIni.GIValIrqMask); SK_OUT32(pAC->IoBase, B0_HWE_IMSK, IRQ_HWE_MASK); spin_lock_irqsave(&pAC->SlowPathLock, Flags); if ((pAC->RlmtMode != 0) && (pAC->MaxPorts == 0)) { EvPara.Para32[0] = pAC->RlmtNets; EvPara.Para32[1] = -1; SkEventQueue(pAC, SKGE_RLMT, SK_RLMT_SET_NETS, EvPara); EvPara.Para32[0] = pAC->RlmtMode; EvPara.Para32[1] = 0; SkEventQueue(pAC, SKGE_RLMT, SK_RLMT_MODE_CHANGE, EvPara); } EvPara.Para32[0] = pNet->NetNr; EvPara.Para32[1] = -1; SkEventQueue(pAC, SKGE_RLMT, SK_RLMT_START, EvPara); SkEventDispatcher(pAC, pAC->IoBase); spin_unlock_irqrestore(&pAC->SlowPathLock, Flags); pAC->MaxPorts++; SK_DBG_MSG(NULL, SK_DBGMOD_DRV, SK_DBGCAT_DRV_ENTRY, ("SkGeOpen suceeded\n")); return (0); } /* SkGeOpen */ /**************************************************************************** * * SkGeClose - Stop initialized adapter * * Description: * Close initialized adapter. * * Returns: * 0 - on success * error code - on error */ static int SkGeClose( struct SK_NET_DEVICE *dev) { DEV_NET *pNet; DEV_NET *newPtrNet; SK_AC *pAC; unsigned long Flags; /* for spin lock */ int i; int PortIdx; SK_EVPARA EvPara; SK_DBG_MSG(NULL, SK_DBGMOD_DRV, SK_DBGCAT_DRV_ENTRY, ("SkGeClose: pAC=0x%lX ", (unsigned long)pAC)); pNet = netdev_priv(dev); pAC = pNet->pAC; #ifdef SK_DIAG_SUPPORT if (pAC->DiagModeActive == DIAG_ACTIVE) { if (pAC->DiagFlowCtrl == SK_FALSE) { /* ** notify that the interface which has been closed ** by operator interaction must not be started up ** again when the DIAG has finished. */ newPtrNet = netdev_priv(pAC->dev[0]); if (newPtrNet == pNet) { pAC->WasIfUp[0] = SK_FALSE; } else { pAC->WasIfUp[1] = SK_FALSE; } return 0; /* return to system everything is fine... */ } else { pAC->DiagFlowCtrl = SK_FALSE; } } #endif netif_stop_queue(dev); if (pAC->RlmtNets == 1) PortIdx = pAC->ActivePort; else PortIdx = pNet->NetNr; StopDrvCleanupTimer(pAC); /* * Clear multicast table, promiscuous mode .... */ SkAddrMcClear(pAC, pAC->IoBase, PortIdx, 0); SkAddrPromiscuousChange(pAC, pAC->IoBase, PortIdx, SK_PROM_MODE_NONE); if (pAC->MaxPorts == 1) { spin_lock_irqsave(&pAC->SlowPathLock, Flags); /* disable interrupts */ SK_OUT32(pAC->IoBase, B0_IMSK, 0); EvPara.Para32[0] = pNet->NetNr; EvPara.Para32[1] = -1; SkEventQueue(pAC, SKGE_RLMT, SK_RLMT_STOP, EvPara); SkEventDispatcher(pAC, pAC->IoBase); SK_OUT32(pAC->IoBase, B0_IMSK, 0); /* stop the hardware */ SkGeDeInit(pAC, pAC->IoBase); pAC->BoardLevel = SK_INIT_DATA; spin_unlock_irqrestore(&pAC->SlowPathLock, Flags); } else { spin_lock_irqsave(&pAC->SlowPathLock, Flags); EvPara.Para32[0] = pNet->NetNr; EvPara.Para32[1] = -1; SkEventQueue(pAC, SKGE_RLMT, SK_RLMT_STOP, EvPara); SkPnmiEvent(pAC, pAC->IoBase, SK_PNMI_EVT_XMAC_RESET, EvPara); SkEventDispatcher(pAC, pAC->IoBase); spin_unlock_irqrestore(&pAC->SlowPathLock, Flags); /* Stop port */ spin_lock_irqsave(&pAC->TxPort[pNet->PortNr] [TX_PRIO_LOW].TxDesRingLock, Flags); SkGeStopPort(pAC, pAC->IoBase, pNet->PortNr, SK_STOP_ALL, SK_HARD_RST); spin_unlock_irqrestore(&pAC->TxPort[pNet->PortNr] [TX_PRIO_LOW].TxDesRingLock, Flags); } if (pAC->RlmtNets == 1) { /* clear all descriptor rings */ for (i=0; i<pAC->GIni.GIMacsFound; i++) { ReceiveIrq(pAC, &pAC->RxPort[i], SK_TRUE); ClearRxRing(pAC, &pAC->RxPort[i]); ClearTxRing(pAC, &pAC->TxPort[i][TX_PRIO_LOW]); } } else { /* clear port descriptor rings */ ReceiveIrq(pAC, &pAC->RxPort[pNet->PortNr], SK_TRUE); ClearRxRing(pAC, &pAC->RxPort[pNet->PortNr]); ClearTxRing(pAC, &pAC->TxPort[pNet->PortNr][TX_PRIO_LOW]); } SK_DBG_MSG(NULL, SK_DBGMOD_DRV, SK_DBGCAT_DRV_ENTRY, ("SkGeClose: done ")); SK_MEMSET(&(pAC->PnmiBackup), 0, sizeof(SK_PNMI_STRUCT_DATA)); SK_MEMCPY(&(pAC->PnmiBackup), &(pAC->PnmiStruct), sizeof(SK_PNMI_STRUCT_DATA)); pAC->MaxPorts--; return (0); } /* SkGeClose */ /***************************************************************************** * * SkGeXmit - Linux frame transmit function * * Description: * The system calls this function to send frames onto the wire. * It puts the frame in the tx descriptor ring. If the ring is * full then, the 'tbusy' flag is set. * * Returns: * 0, if everything is ok * !=0, on error * WARNING: returning 1 in 'tbusy' case caused system crashes (double * allocated skb's) !!! */ static int SkGeXmit(struct sk_buff *skb, struct SK_NET_DEVICE *dev) { DEV_NET *pNet; SK_AC *pAC; int Rc; /* return code of XmitFrame */ pNet = netdev_priv(dev); pAC = pNet->pAC; if ((!skb_shinfo(skb)->nr_frags) || (pAC->GIni.GIChipId == CHIP_ID_GENESIS)) { /* Don't activate scatter-gather and hardware checksum */ if (pAC->RlmtNets == 2) Rc = XmitFrame( pAC, &pAC->TxPort[pNet->PortNr][TX_PRIO_LOW], skb); else Rc = XmitFrame( pAC, &pAC->TxPort[pAC->ActivePort][TX_PRIO_LOW], skb); } else { /* scatter-gather and hardware TCP checksumming anabled*/ if (pAC->RlmtNets == 2) Rc = XmitFrameSG( pAC, &pAC->TxPort[pNet->PortNr][TX_PRIO_LOW], skb); else Rc = XmitFrameSG( pAC, &pAC->TxPort[pAC->ActivePort][TX_PRIO_LOW], skb); } /* Transmitter out of resources? */ if (Rc <= 0) { netif_stop_queue(dev); } /* If not taken, give buffer ownership back to the * queueing layer. */ if (Rc < 0) return (1); dev->trans_start = jiffies; return (0); } /* SkGeXmit */ /***************************************************************************** * * XmitFrame - fill one socket buffer into the transmit ring * * Description: * This function puts a message into the transmit descriptor ring * if there is a descriptors left. * Linux skb's consist of only one continuous buffer. * The first step locks the ring. It is held locked * all time to avoid problems with SWITCH_../PORT_RESET. * Then the descriptoris allocated. * The second part is linking the buffer to the descriptor. * At the very last, the Control field of the descriptor * is made valid for the BMU and a start TX command is given * if necessary. * * Returns: * > 0 - on succes: the number of bytes in the message * = 0 - on resource shortage: this frame sent or dropped, now * the ring is full ( -> set tbusy) * < 0 - on failure: other problems ( -> return failure to upper layers) */ static int XmitFrame( SK_AC *pAC, /* pointer to adapter context */ TX_PORT *pTxPort, /* pointer to struct of port to send to */ struct sk_buff *pMessage) /* pointer to send-message */ { TXD *pTxd; /* the rxd to fill */ TXD *pOldTxd; unsigned long Flags; SK_U64 PhysAddr; int BytesSend = pMessage->len; SK_DBG_MSG(NULL, SK_DBGMOD_DRV, SK_DBGCAT_DRV_TX_PROGRESS, ("X")); spin_lock_irqsave(&pTxPort->TxDesRingLock, Flags); #ifndef USE_TX_COMPLETE FreeTxDescriptors(pAC, pTxPort); #endif if (pTxPort->TxdRingFree == 0) { /* ** no enough free descriptors in ring at the moment. ** Maybe free'ing some old one help? */ FreeTxDescriptors(pAC, pTxPort); if (pTxPort->TxdRingFree == 0) { spin_unlock_irqrestore(&pTxPort->TxDesRingLock, Flags); SK_PNMI_CNT_NO_TX_BUF(pAC, pTxPort->PortIndex); SK_DBG_MSG(NULL, SK_DBGMOD_DRV, SK_DBGCAT_DRV_TX_PROGRESS, ("XmitFrame failed\n")); /* ** the desired message can not be sent ** Because tbusy seems to be set, the message ** should not be freed here. It will be used ** by the scheduler of the ethernet handler */ return (-1); } } /* ** If the passed socket buffer is of smaller MTU-size than 60, ** copy everything into new buffer and fill all bytes between ** the original packet end and the new packet end of 60 with 0x00. ** This is to resolve faulty padding by the HW with 0xaa bytes. */ if (BytesSend < C_LEN_ETHERNET_MINSIZE) { if ((pMessage = skb_padto(pMessage, C_LEN_ETHERNET_MINSIZE)) == NULL) { spin_unlock_irqrestore(&pTxPort->TxDesRingLock, Flags); return 0; } pMessage->len = C_LEN_ETHERNET_MINSIZE; } /* ** advance head counter behind descriptor needed for this frame, ** so that needed descriptor is reserved from that on. The next ** action will be to add the passed buffer to the TX-descriptor */ pTxd = pTxPort->pTxdRingHead; pTxPort->pTxdRingHead = pTxd->pNextTxd; pTxPort->TxdRingFree--; #ifdef SK_DUMP_TX DumpMsg(pMessage, "XmitFrame"); #endif /* ** First step is to map the data to be sent via the adapter onto ** the DMA memory. Kernel 2.2 uses virt_to_bus(), but kernels 2.4 ** and 2.6 need to use pci_map_page() for that mapping. */ PhysAddr = (SK_U64) pci_map_page(pAC->PciDev, virt_to_page(pMessage->data), ((unsigned long) pMessage->data & ~PAGE_MASK), pMessage->len, PCI_DMA_TODEVICE); pTxd->VDataLow = (SK_U32) (PhysAddr & 0xffffffff); pTxd->VDataHigh = (SK_U32) (PhysAddr >> 32); pTxd->pMBuf = pMessage; if (pMessage->ip_summed == CHECKSUM_HW) { u16 hdrlen = pMessage->h.raw - pMessage->data; u16 offset = hdrlen + pMessage->csum; if ((pMessage->h.ipiph->protocol == IPPROTO_UDP ) && (pAC->GIni.GIChipRev == 0) && (pAC->GIni.GIChipId == CHIP_ID_YUKON)) { pTxd->TBControl = BMU_TCP_CHECK; } else { pTxd->TBControl = BMU_UDP_CHECK; } pTxd->TcpSumOfs = 0; pTxd->TcpSumSt = hdrlen; pTxd->TcpSumWr = offset; pTxd->TBControl |= BMU_OWN | BMU_STF | BMU_SW | BMU_EOF | #ifdef USE_TX_COMPLETE BMU_IRQ_EOF | #endif pMessage->len; } else { pTxd->TBControl = BMU_OWN | BMU_STF | BMU_CHECK | BMU_SW | BMU_EOF | #ifdef USE_TX_COMPLETE BMU_IRQ_EOF | #endif pMessage->len; } /* ** If previous descriptor already done, give TX start cmd */ pOldTxd = xchg(&pTxPort->pTxdRingPrev, pTxd); if ((pOldTxd->TBControl & BMU_OWN) == 0) { SK_OUT8(pTxPort->HwAddr, Q_CSR, CSR_START); } /* ** after releasing the lock, the skb may immediately be free'd */ spin_unlock_irqrestore(&pTxPort->TxDesRingLock, Flags); if (pTxPort->TxdRingFree != 0) { return (BytesSend); } else { return (0); } } /* XmitFrame */ /***************************************************************************** * * XmitFrameSG - fill one socket buffer into the transmit ring * (use SG and TCP/UDP hardware checksumming) * * Description: * This function puts a message into the transmit descriptor ring * if there is a descriptors left. * * Returns: * > 0 - on succes: the number of bytes in the message * = 0 - on resource shortage: this frame sent or dropped, now * the ring is full ( -> set tbusy) * < 0 - on failure: other problems ( -> return failure to upper layers) */ static int XmitFrameSG( SK_AC *pAC, /* pointer to adapter context */ TX_PORT *pTxPort, /* pointer to struct of port to send to */ struct sk_buff *pMessage) /* pointer to send-message */ { TXD *pTxd; TXD *pTxdFst; TXD *pTxdLst; int CurrFrag; int BytesSend; skb_frag_t *sk_frag; SK_U64 PhysAddr; unsigned long Flags; SK_U32 Control; spin_lock_irqsave(&pTxPort->TxDesRingLock, Flags); #ifndef USE_TX_COMPLETE FreeTxDescriptors(pAC, pTxPort); #endif if ((skb_shinfo(pMessage)->nr_frags +1) > pTxPort->TxdRingFree) { FreeTxDescriptors(pAC, pTxPort); if ((skb_shinfo(pMessage)->nr_frags + 1) > pTxPort->TxdRingFree) { spin_unlock_irqrestore(&pTxPort->TxDesRingLock, Flags); SK_PNMI_CNT_NO_TX_BUF(pAC, pTxPort->PortIndex); SK_DBG_MSG(NULL, SK_DBGMOD_DRV, SK_DBGCAT_DRV_TX_PROGRESS, ("XmitFrameSG failed - Ring full\n")); /* this message can not be sent now */ return(-1); } } pTxd = pTxPort->pTxdRingHead; pTxdFst = pTxd; pTxdLst = pTxd; BytesSend = 0; /* ** Map the first fragment (header) into the DMA-space */ PhysAddr = (SK_U64) pci_map_page(pAC->PciDev, virt_to_page(pMessage->data), ((unsigned long) pMessage->data & ~PAGE_MASK), skb_headlen(pMessage), PCI_DMA_TODEVICE); pTxd->VDataLow = (SK_U32) (PhysAddr & 0xffffffff); pTxd->VDataHigh = (SK_U32) (PhysAddr >> 32); /* ** Does the HW need to evaluate checksum for TCP or UDP packets? */ if (pMessage->ip_summed == CHECKSUM_HW) { u16 hdrlen = pMessage->h.raw - pMessage->data; u16 offset = hdrlen + pMessage->csum; Control = BMU_STFWD; /* ** We have to use the opcode for tcp here, because the ** opcode for udp is not working in the hardware yet ** (Revision 2.0) */ if ((pMessage->h.ipiph->protocol == IPPROTO_UDP ) && (pAC->GIni.GIChipRev == 0) && (pAC->GIni.GIChipId == CHIP_ID_YUKON)) { Control |= BMU_TCP_CHECK; } else { Control |= BMU_UDP_CHECK; } pTxd->TcpSumOfs = 0; pTxd->TcpSumSt = hdrlen; pTxd->TcpSumWr = offset; } else Control = BMU_CHECK | BMU_SW; pTxd->TBControl = BMU_STF | Control | skb_headlen(pMessage); pTxd = pTxd->pNextTxd; pTxPort->TxdRingFree--; BytesSend += skb_headlen(pMessage); /* ** Browse over all SG fragments and map each of them into the DMA space */ for (CurrFrag = 0; CurrFrag < skb_shinfo(pMessage)->nr_frags; CurrFrag++) { sk_frag = &skb_shinfo(pMessage)->frags[CurrFrag]; /* ** we already have the proper value in entry */ PhysAddr = (SK_U64) pci_map_page(pAC->PciDev, sk_frag->page, sk_frag->page_offset, sk_frag->size, PCI_DMA_TODEVICE); pTxd->VDataLow = (SK_U32) (PhysAddr & 0xffffffff); pTxd->VDataHigh = (SK_U32) (PhysAddr >> 32); pTxd->pMBuf = pMessage; pTxd->TBControl = Control | BMU_OWN | sk_frag->size;; /* ** Do we have the last fragment? */ if( (CurrFrag+1) == skb_shinfo(pMessage)->nr_frags ) { #ifdef USE_TX_COMPLETE pTxd->TBControl |= BMU_EOF | BMU_IRQ_EOF; #else pTxd->TBControl |= BMU_EOF; #endif pTxdFst->TBControl |= BMU_OWN | BMU_SW; } pTxdLst = pTxd; pTxd = pTxd->pNextTxd; pTxPort->TxdRingFree--; BytesSend += sk_frag->size; } /* ** If previous descriptor already done, give TX start cmd */ if ((pTxPort->pTxdRingPrev->TBControl & BMU_OWN) == 0) { SK_OUT8(pTxPort->HwAddr, Q_CSR, CSR_START); } pTxPort->pTxdRingPrev = pTxdLst; pTxPort->pTxdRingHead = pTxd; spin_unlock_irqrestore(&pTxPort->TxDesRingLock, Flags); if (pTxPort->TxdRingFree > 0) { return (BytesSend); } else { return (0); } } /***************************************************************************** * * FreeTxDescriptors - release descriptors from the descriptor ring * * Description: * This function releases descriptors from a transmit ring if they * have been sent by the BMU. * If a descriptors is sent, it can be freed and the message can * be freed, too. * The SOFTWARE controllable bit is used to prevent running around a * completely free ring for ever. If this bit is no set in the * frame (by XmitFrame), this frame has never been sent or is * already freed. * The Tx descriptor ring lock must be held while calling this function !!! * * Returns: * none */ static void FreeTxDescriptors( SK_AC *pAC, /* pointer to the adapter context */ TX_PORT *pTxPort) /* pointer to destination port structure */ { TXD *pTxd; /* pointer to the checked descriptor */ TXD *pNewTail; /* pointer to 'end' of the ring */ SK_U32 Control; /* TBControl field of descriptor */ SK_U64 PhysAddr; /* address of DMA mapping */ pNewTail = pTxPort->pTxdRingTail; pTxd = pNewTail; /* ** loop forever; exits if BMU_SW bit not set in start frame ** or BMU_OWN bit set in any frame */ while (1) { Control = pTxd->TBControl; if ((Control & BMU_SW) == 0) { /* ** software controllable bit is set in first ** fragment when given to BMU. Not set means that ** this fragment was never sent or is already ** freed ( -> ring completely free now). */ pTxPort->pTxdRingTail = pTxd; netif_wake_queue(pAC->dev[pTxPort->PortIndex]); return; } if (Control & BMU_OWN) { pTxPort->pTxdRingTail = pTxd; if (pTxPort->TxdRingFree > 0) { netif_wake_queue(pAC->dev[pTxPort->PortIndex]); } return; } /* ** release the DMA mapping, because until not unmapped ** this buffer is considered being under control of the ** adapter card! */ PhysAddr = ((SK_U64) pTxd->VDataHigh) << (SK_U64) 32; PhysAddr |= (SK_U64) pTxd->VDataLow; pci_unmap_page(pAC->PciDev, PhysAddr, pTxd->pMBuf->len, PCI_DMA_TODEVICE); if (Control & BMU_EOF) DEV_KFREE_SKB_ANY(pTxd->pMBuf); /* free message */ pTxPort->TxdRingFree++; pTxd->TBControl &= ~BMU_SW; pTxd = pTxd->pNextTxd; /* point behind fragment with EOF */ } /* while(forever) */ } /* FreeTxDescriptors */ /***************************************************************************** * * FillRxRing - fill the receive ring with valid descriptors * * Description: * This function fills the receive ring descriptors with data * segments and makes them valid for the BMU. * The active ring is filled completely, if possible. * The non-active ring is filled only partial to save memory. * * Description of rx ring structure: * head - points to the descriptor which will be used next by the BMU * tail - points to the next descriptor to give to the BMU * * Returns: N/A */ static void FillRxRing( SK_AC *pAC, /* pointer to the adapter context */ RX_PORT *pRxPort) /* ptr to port struct for which the ring should be filled */ { unsigned long Flags; spin_lock_irqsave(&pRxPort->RxDesRingLock, Flags); while (pRxPort->RxdRingFree > pRxPort->RxFillLimit) { if(!FillRxDescriptor(pAC, pRxPort)) break; } spin_unlock_irqrestore(&pRxPort->RxDesRingLock, Flags); } /* FillRxRing */ /***************************************************************************** * * FillRxDescriptor - fill one buffer into the receive ring * * Description: * The function allocates a new receive buffer and * puts it into the next descriptor. * * Returns: * SK_TRUE - a buffer was added to the ring * SK_FALSE - a buffer could not be added */ static SK_BOOL FillRxDescriptor( SK_AC *pAC, /* pointer to the adapter context struct */ RX_PORT *pRxPort) /* ptr to port struct of ring to fill */ { struct sk_buff *pMsgBlock; /* pointer to a new message block */ RXD *pRxd; /* the rxd to fill */ SK_U16 Length; /* data fragment length */ SK_U64 PhysAddr; /* physical address of a rx buffer */ pMsgBlock = alloc_skb(pAC->RxBufSize, GFP_ATOMIC); if (pMsgBlock == NULL) { SK_DBG_MSG(NULL, SK_DBGMOD_DRV, SK_DBGCAT_DRV_ENTRY, ("%s: Allocation of rx buffer failed !\n", pAC->dev[pRxPort->PortIndex]->name)); SK_PNMI_CNT_NO_RX_BUF(pAC, pRxPort->PortIndex); return(SK_FALSE); } skb_reserve(pMsgBlock, 2); /* to align IP frames */ /* skb allocated ok, so add buffer */ pRxd = pRxPort->pRxdRingTail; pRxPort->pRxdRingTail = pRxd->pNextRxd; pRxPort->RxdRingFree--; Length = pAC->RxBufSize; PhysAddr = (SK_U64) pci_map_page(pAC->PciDev, virt_to_page(pMsgBlock->data), ((unsigned long) pMsgBlock->data & ~PAGE_MASK), pAC->RxBufSize - 2, PCI_DMA_FROMDEVICE); pRxd->VDataLow = (SK_U32) (PhysAddr & 0xffffffff); pRxd->VDataHigh = (SK_U32) (PhysAddr >> 32); pRxd->pMBuf = pMsgBlock; pRxd->RBControl = BMU_OWN | BMU_STF | BMU_IRQ_EOF | BMU_TCP_CHECK | Length; return (SK_TRUE); } /* FillRxDescriptor */ /***************************************************************************** * * ReQueueRxBuffer - fill one buffer back into the receive ring * * Description: * Fill a given buffer back into the rx ring. The buffer * has been previously allocated and aligned, and its phys. * address calculated, so this is no more necessary. * * Returns: N/A */ static void ReQueueRxBuffer( SK_AC *pAC, /* pointer to the adapter context struct */ RX_PORT *pRxPort, /* ptr to port struct of ring to fill */ struct sk_buff *pMsg, /* pointer to the buffer */ SK_U32 PhysHigh, /* phys address high dword */ SK_U32 PhysLow) /* phys address low dword */ { RXD *pRxd; /* the rxd to fill */ SK_U16 Length; /* data fragment length */ pRxd = pRxPort->pRxdRingTail; pRxPort->pRxdRingTail = pRxd->pNextRxd; pRxPort->RxdRingFree--; Length = pAC->RxBufSize; pRxd->VDataLow = PhysLow; pRxd->VDataHigh = PhysHigh; pRxd->pMBuf = pMsg; pRxd->RBControl = BMU_OWN | BMU_STF | BMU_IRQ_EOF | BMU_TCP_CHECK | Length; return; } /* ReQueueRxBuffer */ /***************************************************************************** * * ReceiveIrq - handle a receive IRQ * * Description: * This function is called when a receive IRQ is set. * It walks the receive descriptor ring and sends up all * frames that are complete. * * Returns: N/A */ static void ReceiveIrq( SK_AC *pAC, /* pointer to adapter context */ RX_PORT *pRxPort, /* pointer to receive port struct */ SK_BOOL SlowPathLock) /* indicates if SlowPathLock is needed */ { RXD *pRxd; /* pointer to receive descriptors */ SK_U32 Control; /* control field of descriptor */ struct sk_buff *pMsg; /* pointer to message holding frame */ struct sk_buff *pNewMsg; /* pointer to a new message for copying frame */ int FrameLength; /* total length of received frame */ SK_MBUF *pRlmtMbuf; /* ptr to a buffer for giving a frame to rlmt */ SK_EVPARA EvPara; /* an event parameter union */ unsigned long Flags; /* for spin lock */ int PortIndex = pRxPort->PortIndex; unsigned int Offset; unsigned int NumBytes; unsigned int ForRlmt; SK_BOOL IsBc; SK_BOOL IsMc; SK_BOOL IsBadFrame; /* Bad frame */ SK_U32 FrameStat; SK_U64 PhysAddr; rx_start: /* do forever; exit if BMU_OWN found */ for ( pRxd = pRxPort->pRxdRingHead ; pRxPort->RxdRingFree < pAC->RxDescrPerRing ; pRxd = pRxd->pNextRxd, pRxPort->pRxdRingHead = pRxd, pRxPort->RxdRingFree ++) { /* * For a better understanding of this loop * Go through every descriptor beginning at the head * Please note: the ring might be completely received so the OWN bit * set is not a good crirteria to leave that loop. * Therefore the RingFree counter is used. * On entry of this loop pRxd is a pointer to the Rxd that needs * to be checked next. */ Control = pRxd->RBControl; /* check if this descriptor is ready */ if ((Control & BMU_OWN) != 0) { /* this descriptor is not yet ready */ /* This is the usual end of the loop */ /* We don't need to start the ring again */ FillRxRing(pAC, pRxPort); return; } pAC->DynIrqModInfo.NbrProcessedDescr++; /* get length of frame and check it */ FrameLength = Control & BMU_BBC; if (FrameLength > pAC->RxBufSize) { goto rx_failed; } /* check for STF and EOF */ if ((Control & (BMU_STF | BMU_EOF)) != (BMU_STF | BMU_EOF)) { goto rx_failed; } /* here we have a complete frame in the ring */ pMsg = pRxd->pMBuf; FrameStat = pRxd->FrameStat; /* check for frame length mismatch */ #define XMR_FS_LEN_SHIFT 18 #define GMR_FS_LEN_SHIFT 16 if (pAC->GIni.GIChipId == CHIP_ID_GENESIS) { if (FrameLength != (SK_U32) (FrameStat >> XMR_FS_LEN_SHIFT)) { SK_DBG_MSG(NULL, SK_DBGMOD_DRV, SK_DBGCAT_DRV_RX_PROGRESS, ("skge: Frame length mismatch (%u/%u).\n", FrameLength, (SK_U32) (FrameStat >> XMR_FS_LEN_SHIFT))); goto rx_failed; } } else { if (FrameLength != (SK_U32) (FrameStat >> GMR_FS_LEN_SHIFT)) { SK_DBG_MSG(NULL, SK_DBGMOD_DRV, SK_DBGCAT_DRV_RX_PROGRESS, ("skge: Frame length mismatch (%u/%u).\n", FrameLength, (SK_U32) (FrameStat >> XMR_FS_LEN_SHIFT))); goto rx_failed; } } /* Set Rx Status */ if (pAC->GIni.GIChipId == CHIP_ID_GENESIS) { IsBc = (FrameStat & XMR_FS_BC) != 0; IsMc = (FrameStat & XMR_FS_MC) != 0; IsBadFrame = (FrameStat & (XMR_FS_ANY_ERR | XMR_FS_2L_VLAN)) != 0; } else { IsBc = (FrameStat & GMR_FS_BC) != 0; IsMc = (FrameStat & GMR_FS_MC) != 0; IsBadFrame = (((FrameStat & GMR_FS_ANY_ERR) != 0) || ((FrameStat & GMR_FS_RX_OK) == 0)); } SK_DBG_MSG(NULL, SK_DBGMOD_DRV, 0, ("Received frame of length %d on port %d\n", FrameLength, PortIndex)); SK_DBG_MSG(NULL, SK_DBGMOD_DRV, 0, ("Number of free rx descriptors: %d\n", pRxPort->RxdRingFree)); /* DumpMsg(pMsg, "Rx"); */ if ((Control & BMU_STAT_VAL) != BMU_STAT_VAL || (IsBadFrame)) { #if 0 (FrameStat & (XMR_FS_ANY_ERR | XMR_FS_2L_VLAN)) != 0) { #endif /* there is a receive error in this frame */ SK_DBG_MSG(NULL, SK_DBGMOD_DRV, SK_DBGCAT_DRV_RX_PROGRESS, ("skge: Error in received frame, dropped!\n" "Control: %x\nRxStat: %x\n", Control, FrameStat)); ReQueueRxBuffer(pAC, pRxPort, pMsg, pRxd->VDataHigh, pRxd->VDataLow); continue; } /* * if short frame then copy data to reduce memory waste */ if ((FrameLength < SK_COPY_THRESHOLD) && ((pNewMsg = alloc_skb(FrameLength+2, GFP_ATOMIC)) != NULL)) { /* * Short frame detected and allocation successfull */ /* use new skb and copy data */ skb_reserve(pNewMsg, 2); skb_put(pNewMsg, FrameLength); PhysAddr = ((SK_U64) pRxd->VDataHigh) << (SK_U64)32; PhysAddr |= (SK_U64) pRxd->VDataLow; pci_dma_sync_single_for_cpu(pAC->PciDev, (dma_addr_t) PhysAddr, FrameLength, PCI_DMA_FROMDEVICE); memcpy(pNewMsg->data, pMsg, FrameLength); pci_dma_sync_single_for_device(pAC->PciDev, (dma_addr_t) PhysAddr, FrameLength, PCI_DMA_FROMDEVICE); ReQueueRxBuffer(pAC, pRxPort, pMsg, pRxd->VDataHigh, pRxd->VDataLow); pMsg = pNewMsg; } else { /* * if large frame, or SKB allocation failed, pass * the SKB directly to the networking */ PhysAddr = ((SK_U64) pRxd->VDataHigh) << (SK_U64)32; PhysAddr |= (SK_U64) pRxd->VDataLow; /* release the DMA mapping */ pci_unmap_single(pAC->PciDev, PhysAddr, pAC->RxBufSize - 2, PCI_DMA_FROMDEVICE); /* set length in message */ skb_put(pMsg, FrameLength); } /* frame > SK_COPY_TRESHOLD */ #ifdef USE_SK_RX_CHECKSUM pMsg->csum = pRxd->TcpSums & 0xffff; pMsg->ip_summed = CHECKSUM_HW; #else pMsg->ip_summed = CHECKSUM_NONE; #endif SK_DBG_MSG(NULL, SK_DBGMOD_DRV, 1,("V")); ForRlmt = SK_RLMT_RX_PROTOCOL; #if 0 IsBc = (FrameStat & XMR_FS_BC)==XMR_FS_BC; #endif SK_RLMT_PRE_LOOKAHEAD(pAC, PortIndex, FrameLength, IsBc, &Offset, &NumBytes); if (NumBytes != 0) { #if 0 IsMc = (FrameStat & XMR_FS_MC)==XMR_FS_MC; #endif SK_RLMT_LOOKAHEAD(pAC, PortIndex, &pMsg->data[Offset], IsBc, IsMc, &ForRlmt); } if (ForRlmt == SK_RLMT_RX_PROTOCOL) { SK_DBG_MSG(NULL, SK_DBGMOD_DRV, 1,("W")); /* send up only frames from active port */ if ((PortIndex == pAC->ActivePort) || (pAC->RlmtNets == 2)) { /* frame for upper layer */ SK_DBG_MSG(NULL, SK_DBGMOD_DRV, 1,("U")); #ifdef xDEBUG DumpMsg(pMsg, "Rx"); #endif SK_PNMI_CNT_RX_OCTETS_DELIVERED(pAC, FrameLength, pRxPort->PortIndex); pMsg->dev = pAC->dev[pRxPort->PortIndex]; pMsg->protocol = eth_type_trans(pMsg, pAC->dev[pRxPort->PortIndex]); netif_rx(pMsg); pAC->dev[pRxPort->PortIndex]->last_rx = jiffies; } else { /* drop frame */ SK_DBG_MSG(NULL, SK_DBGMOD_DRV, SK_DBGCAT_DRV_RX_PROGRESS, ("D")); DEV_KFREE_SKB(pMsg); } } /* if not for rlmt */ else { /* packet for rlmt */ SK_DBG_MSG(NULL, SK_DBGMOD_DRV, SK_DBGCAT_DRV_RX_PROGRESS, ("R")); pRlmtMbuf = SkDrvAllocRlmtMbuf(pAC, pAC->IoBase, FrameLength); if (pRlmtMbuf != NULL) { pRlmtMbuf->pNext = NULL; pRlmtMbuf->Length = FrameLength; pRlmtMbuf->PortIdx = PortIndex; EvPara.pParaPtr = pRlmtMbuf; memcpy((char*)(pRlmtMbuf->pData), (char*)(pMsg->data), FrameLength); /* SlowPathLock needed? */ if (SlowPathLock == SK_TRUE) { spin_lock_irqsave(&pAC->SlowPathLock, Flags); SkEventQueue(pAC, SKGE_RLMT, SK_RLMT_PACKET_RECEIVED, EvPara); pAC->CheckQueue = SK_TRUE; spin_unlock_irqrestore(&pAC->SlowPathLock, Flags); } else { SkEventQueue(pAC, SKGE_RLMT, SK_RLMT_PACKET_RECEIVED, EvPara); pAC->CheckQueue = SK_TRUE; } SK_DBG_MSG(NULL, SK_DBGMOD_DRV, SK_DBGCAT_DRV_RX_PROGRESS, ("Q")); } if ((pAC->dev[pRxPort->PortIndex]->flags & (IFF_PROMISC | IFF_ALLMULTI)) != 0 || (ForRlmt & SK_RLMT_RX_PROTOCOL) == SK_RLMT_RX_PROTOCOL) { pMsg->dev = pAC->dev[pRxPort->PortIndex]; pMsg->protocol = eth_type_trans(pMsg, pAC->dev[pRxPort->PortIndex]); netif_rx(pMsg); pAC->dev[pRxPort->PortIndex]->last_rx = jiffies; } else { DEV_KFREE_SKB(pMsg); } } /* if packet for rlmt */ } /* for ... scanning the RXD ring */ /* RXD ring is empty -> fill and restart */ FillRxRing(pAC, pRxPort); /* do not start if called from Close */ if (pAC->BoardLevel > SK_INIT_DATA) { ClearAndStartRx(pAC, PortIndex); } return; rx_failed: /* remove error frame */ SK_DBG_MSG(NULL, SK_DBGMOD_DRV, SK_DBGCAT_DRV_ERROR, ("Schrottdescriptor, length: 0x%x\n", FrameLength)); /* release the DMA mapping */ PhysAddr = ((SK_U64) pRxd->VDataHigh) << (SK_U64)32; PhysAddr |= (SK_U64) pRxd->VDataLow; pci_unmap_page(pAC->PciDev, PhysAddr, pAC->RxBufSize - 2, PCI_DMA_FROMDEVICE); DEV_KFREE_SKB_IRQ(pRxd->pMBuf); pRxd->pMBuf = NULL; pRxPort->RxdRingFree++; pRxPort->pRxdRingHead = pRxd->pNextRxd; goto rx_start; } /* ReceiveIrq */ /***************************************************************************** * * ClearAndStartRx - give a start receive command to BMU, clear IRQ * * Description: * This function sends a start command and a clear interrupt * command for one receive queue to the BMU. * * Returns: N/A * none */ static void ClearAndStartRx( SK_AC *pAC, /* pointer to the adapter context */ int PortIndex) /* index of the receive port (XMAC) */ { SK_OUT8(pAC->IoBase, RxQueueAddr[PortIndex]+Q_CSR, CSR_START | CSR_IRQ_CL_F); } /* ClearAndStartRx */ /***************************************************************************** * * ClearTxIrq - give a clear transmit IRQ command to BMU * * Description: * This function sends a clear tx IRQ command for one * transmit queue to the BMU. * * Returns: N/A */ static void ClearTxIrq( SK_AC *pAC, /* pointer to the adapter context */ int PortIndex, /* index of the transmit port (XMAC) */ int Prio) /* priority or normal queue */ { SK_OUT8(pAC->IoBase, TxQueueAddr[PortIndex][Prio]+Q_CSR, CSR_IRQ_CL_F); } /* ClearTxIrq */ /***************************************************************************** * * ClearRxRing - remove all buffers from the receive ring * * Description: * This function removes all receive buffers from the ring. * The receive BMU must be stopped before calling this function. * * Returns: N/A */ static void ClearRxRing( SK_AC *pAC, /* pointer to adapter context */ RX_PORT *pRxPort) /* pointer to rx port struct */ { RXD *pRxd; /* pointer to the current descriptor */ unsigned long Flags; SK_U64 PhysAddr; if (pRxPort->RxdRingFree == pAC->RxDescrPerRing) { return; } spin_lock_irqsave(&pRxPort->RxDesRingLock, Flags); pRxd = pRxPort->pRxdRingHead; do { if (pRxd->pMBuf != NULL) { PhysAddr = ((SK_U64) pRxd->VDataHigh) << (SK_U64)32; PhysAddr |= (SK_U64) pRxd->VDataLow; pci_unmap_page(pAC->PciDev, PhysAddr, pAC->RxBufSize - 2, PCI_DMA_FROMDEVICE); DEV_KFREE_SKB(pRxd->pMBuf); pRxd->pMBuf = NULL; } pRxd->RBControl &= BMU_OWN; pRxd = pRxd->pNextRxd; pRxPort->RxdRingFree++; } while (pRxd != pRxPort->pRxdRingTail); pRxPort->pRxdRingTail = pRxPort->pRxdRingHead; spin_unlock_irqrestore(&pRxPort->RxDesRingLock, Flags); } /* ClearRxRing */ /***************************************************************************** * * ClearTxRing - remove all buffers from the transmit ring * * Description: * This function removes all transmit buffers from the ring. * The transmit BMU must be stopped before calling this function * and transmitting at the upper level must be disabled. * The BMU own bit of all descriptors is cleared, the rest is * done by calling FreeTxDescriptors. * * Returns: N/A */ static void ClearTxRing( SK_AC *pAC, /* pointer to adapter context */ TX_PORT *pTxPort) /* pointer to tx prt struct */ { TXD *pTxd; /* pointer to the current descriptor */ int i; unsigned long Flags; spin_lock_irqsave(&pTxPort->TxDesRingLock, Flags); pTxd = pTxPort->pTxdRingHead; for (i=0; i<pAC->TxDescrPerRing; i++) { pTxd->TBControl &= ~BMU_OWN; pTxd = pTxd->pNextTxd; } FreeTxDescriptors(pAC, pTxPort); spin_unlock_irqrestore(&pTxPort->TxDesRingLock, Flags); } /* ClearTxRing */ /***************************************************************************** * * SkGeSetMacAddr - Set the hardware MAC address * * Description: * This function sets the MAC address used by the adapter. * * Returns: * 0, if everything is ok * !=0, on error */ static int SkGeSetMacAddr(struct SK_NET_DEVICE *dev, void *p) { DEV_NET *pNet = netdev_priv(dev); SK_AC *pAC = pNet->pAC; struct sockaddr *addr = p; unsigned long Flags; SK_DBG_MSG(NULL, SK_DBGMOD_DRV, SK_DBGCAT_DRV_ENTRY, ("SkGeSetMacAddr starts now...\n")); if(netif_running(dev)) return -EBUSY; memcpy(dev->dev_addr, addr->sa_data,dev->addr_len); spin_lock_irqsave(&pAC->SlowPathLock, Flags); if (pAC->RlmtNets == 2) SkAddrOverride(pAC, pAC->IoBase, pNet->NetNr, (SK_MAC_ADDR*)dev->dev_addr, SK_ADDR_VIRTUAL_ADDRESS); else SkAddrOverride(pAC, pAC->IoBase, pAC->ActivePort, (SK_MAC_ADDR*)dev->dev_addr, SK_ADDR_VIRTUAL_ADDRESS); spin_unlock_irqrestore(&pAC->SlowPathLock, Flags); return 0; } /* SkGeSetMacAddr */ /***************************************************************************** * * SkGeSetRxMode - set receive mode * * Description: * This function sets the receive mode of an adapter. The adapter * supports promiscuous mode, allmulticast mode and a number of * multicast addresses. If more multicast addresses the available * are selected, a hash function in the hardware is used. * * Returns: * 0, if everything is ok * !=0, on error */ static void SkGeSetRxMode(struct SK_NET_DEVICE *dev) { DEV_NET *pNet; SK_AC *pAC; struct dev_mc_list *pMcList; int i; int PortIdx; unsigned long Flags; SK_DBG_MSG(NULL, SK_DBGMOD_DRV, SK_DBGCAT_DRV_ENTRY, ("SkGeSetRxMode starts now... ")); pNet = netdev_priv(dev); pAC = pNet->pAC; if (pAC->RlmtNets == 1) PortIdx = pAC->ActivePort; else PortIdx = pNet->NetNr; spin_lock_irqsave(&pAC->SlowPathLock, Flags); if (dev->flags & IFF_PROMISC) { SK_DBG_MSG(NULL, SK_DBGMOD_DRV, SK_DBGCAT_DRV_ENTRY, ("PROMISCUOUS mode\n")); SkAddrPromiscuousChange(pAC, pAC->IoBase, PortIdx, SK_PROM_MODE_LLC); } else if (dev->flags & IFF_ALLMULTI) { SK_DBG_MSG(NULL, SK_DBGMOD_DRV, SK_DBGCAT_DRV_ENTRY, ("ALLMULTI mode\n")); SkAddrPromiscuousChange(pAC, pAC->IoBase, PortIdx, SK_PROM_MODE_ALL_MC); } else { SkAddrPromiscuousChange(pAC, pAC->IoBase, PortIdx, SK_PROM_MODE_NONE); SkAddrMcClear(pAC, pAC->IoBase, PortIdx, 0); SK_DBG_MSG(NULL, SK_DBGMOD_DRV, SK_DBGCAT_DRV_ENTRY, ("Number of MC entries: %d ", dev->mc_count)); pMcList = dev->mc_list; for (i=0; i<dev->mc_count; i++, pMcList = pMcList->next) { SkAddrMcAdd(pAC, pAC->IoBase, PortIdx, (SK_MAC_ADDR*)pMcList->dmi_addr, 0); SK_DBG_MSG(NULL, SK_DBGMOD_DRV, SK_DBGCAT_DRV_MCA, ("%02x:%02x:%02x:%02x:%02x:%02x\n", pMcList->dmi_addr[0], pMcList->dmi_addr[1], pMcList->dmi_addr[2], pMcList->dmi_addr[3], pMcList->dmi_addr[4], pMcList->dmi_addr[5])); } SkAddrMcUpdate(pAC, pAC->IoBase, PortIdx); } spin_unlock_irqrestore(&pAC->SlowPathLock, Flags); return; } /* SkGeSetRxMode */ /***************************************************************************** * * SkGeChangeMtu - set the MTU to another value * * Description: * This function sets is called whenever the MTU size is changed * (ifconfig mtu xxx dev ethX). If the MTU is bigger than standard * ethernet MTU size, long frame support is activated. * * Returns: * 0, if everything is ok * !=0, on error */ static int SkGeChangeMtu(struct SK_NET_DEVICE *dev, int NewMtu) { DEV_NET *pNet; struct net_device *pOtherDev; SK_AC *pAC; unsigned long Flags; int i; SK_EVPARA EvPara; SK_DBG_MSG(NULL, SK_DBGMOD_DRV, SK_DBGCAT_DRV_ENTRY, ("SkGeChangeMtu starts now...\n")); pNet = netdev_priv(dev); pAC = pNet->pAC; if ((NewMtu < 68) || (NewMtu > SK_JUMBO_MTU)) { return -EINVAL; } if(pAC->BoardLevel != SK_INIT_RUN) { return -EINVAL; } #ifdef SK_DIAG_SUPPORT if (pAC->DiagModeActive == DIAG_ACTIVE) { if (pAC->DiagFlowCtrl == SK_FALSE) { return -1; /* still in use, deny any actions of MTU */ } else { pAC->DiagFlowCtrl = SK_FALSE; } } #endif pOtherDev = pAC->dev[1 - pNet->NetNr]; if ( netif_running(pOtherDev) && (pOtherDev->mtu > 1500) && (NewMtu <= 1500)) return 0; pAC->RxBufSize = NewMtu + 32; dev->mtu = NewMtu; SK_DBG_MSG(NULL, SK_DBGMOD_DRV, SK_DBGCAT_DRV_ENTRY, ("New MTU: %d\n", NewMtu)); /* ** Prevent any reconfiguration while changing the MTU ** by disabling any interrupts */ SK_OUT32(pAC->IoBase, B0_IMSK, 0); spin_lock_irqsave(&pAC->SlowPathLock, Flags); /* ** Notify RLMT that any ports are to be stopped */ EvPara.Para32[0] = 0; EvPara.Para32[1] = -1; if ((pAC->GIni.GIMacsFound == 2 ) && (pAC->RlmtNets == 2)) { SkEventQueue(pAC, SKGE_RLMT, SK_RLMT_STOP, EvPara); EvPara.Para32[0] = 1; SkEventQueue(pAC, SKGE_RLMT, SK_RLMT_STOP, EvPara); } else { SkEventQueue(pAC, SKGE_RLMT, SK_RLMT_STOP, EvPara); } /* ** After calling the SkEventDispatcher(), RLMT is aware about ** the stopped ports -> configuration can take place! */ SkEventDispatcher(pAC, pAC->IoBase); for (i=0; i<pAC->GIni.GIMacsFound; i++) { spin_lock(&pAC->TxPort[i][TX_PRIO_LOW].TxDesRingLock); netif_stop_queue(pAC->dev[i]); } /* ** Depending on the desired MTU size change, a different number of ** RX buffers need to be allocated */ if (NewMtu > 1500) { /* ** Use less rx buffers */ for (i=0; i<pAC->GIni.GIMacsFound; i++) { if ((pAC->GIni.GIMacsFound == 2 ) && (pAC->RlmtNets == 2)) { pAC->RxPort[i].RxFillLimit = pAC->RxDescrPerRing - (pAC->RxDescrPerRing / 4); } else { if (i == pAC->ActivePort) { pAC->RxPort[i].RxFillLimit = pAC->RxDescrPerRing - (pAC->RxDescrPerRing / 4); } else { pAC->RxPort[i].RxFillLimit = pAC->RxDescrPerRing - (pAC->RxDescrPerRing / 10); } } } } else { /* ** Use the normal amount of rx buffers */ for (i=0; i<pAC->GIni.GIMacsFound; i++) { if ((pAC->GIni.GIMacsFound == 2 ) && (pAC->RlmtNets == 2)) { pAC->RxPort[i].RxFillLimit = 1; } else { if (i == pAC->ActivePort) { pAC->RxPort[i].RxFillLimit = 1; } else { pAC->RxPort[i].RxFillLimit = pAC->RxDescrPerRing - (pAC->RxDescrPerRing / 4); } } } } SkGeDeInit(pAC, pAC->IoBase); /* ** enable/disable hardware support for long frames */ if (NewMtu > 1500) { // pAC->JumboActivated = SK_TRUE; /* is never set back !!! */ pAC->GIni.GIPortUsage = SK_JUMBO_LINK; } else { if ((pAC->GIni.GIMacsFound == 2 ) && (pAC->RlmtNets == 2)) { pAC->GIni.GIPortUsage = SK_MUL_LINK; } else { pAC->GIni.GIPortUsage = SK_RED_LINK; } } SkGeInit( pAC, pAC->IoBase, SK_INIT_IO); SkI2cInit( pAC, pAC->IoBase, SK_INIT_IO); SkEventInit(pAC, pAC->IoBase, SK_INIT_IO); SkPnmiInit( pAC, pAC->IoBase, SK_INIT_IO); SkAddrInit( pAC, pAC->IoBase, SK_INIT_IO); SkRlmtInit( pAC, pAC->IoBase, SK_INIT_IO); SkTimerInit(pAC, pAC->IoBase, SK_INIT_IO); /* ** tschilling: ** Speed and others are set back to default in level 1 init! */ GetConfiguration(pAC); SkGeInit( pAC, pAC->IoBase, SK_INIT_RUN); SkI2cInit( pAC, pAC->IoBase, SK_INIT_RUN); SkEventInit(pAC, pAC->IoBase, SK_INIT_RUN); SkPnmiInit( pAC, pAC->IoBase, SK_INIT_RUN); SkAddrInit( pAC, pAC->IoBase, SK_INIT_RUN); SkRlmtInit( pAC, pAC->IoBase, SK_INIT_RUN); SkTimerInit(pAC, pAC->IoBase, SK_INIT_RUN); /* ** clear and reinit the rx rings here */ for (i=0; i<pAC->GIni.GIMacsFound; i++) { ReceiveIrq(pAC, &pAC->RxPort[i], SK_TRUE); ClearRxRing(pAC, &pAC->RxPort[i]); FillRxRing(pAC, &pAC->RxPort[i]); /* ** Enable transmit descriptor polling */ SkGePollTxD(pAC, pAC->IoBase, i, SK_TRUE); FillRxRing(pAC, &pAC->RxPort[i]); }; SkGeYellowLED(pAC, pAC->IoBase, 1); SkDimEnableModerationIfNeeded(pAC); SkDimDisplayModerationSettings(pAC); netif_start_queue(pAC->dev[pNet->PortNr]); for (i=pAC->GIni.GIMacsFound-1; i>=0; i--) { spin_unlock(&pAC->TxPort[i][TX_PRIO_LOW].TxDesRingLock); } /* ** Enable Interrupts again */ SK_OUT32(pAC->IoBase, B0_IMSK, pAC->GIni.GIValIrqMask); SK_OUT32(pAC->IoBase, B0_HWE_IMSK, IRQ_HWE_MASK); SkEventQueue(pAC, SKGE_RLMT, SK_RLMT_START, EvPara); SkEventDispatcher(pAC, pAC->IoBase); /* ** Notify RLMT about the changing and restarting one (or more) ports */ if ((pAC->GIni.GIMacsFound == 2 ) && (pAC->RlmtNets == 2)) { EvPara.Para32[0] = pAC->RlmtNets; EvPara.Para32[1] = -1; SkEventQueue(pAC, SKGE_RLMT, SK_RLMT_SET_NETS, EvPara); EvPara.Para32[0] = pNet->PortNr; EvPara.Para32[1] = -1; SkEventQueue(pAC, SKGE_RLMT, SK_RLMT_START, EvPara); if (netif_running(pOtherDev)) { DEV_NET *pOtherNet = netdev_priv(pOtherDev); EvPara.Para32[0] = pOtherNet->PortNr; SkEventQueue(pAC, SKGE_RLMT, SK_RLMT_START, EvPara); } } else { SkEventQueue(pAC, SKGE_RLMT, SK_RLMT_START, EvPara); } SkEventDispatcher(pAC, pAC->IoBase); spin_unlock_irqrestore(&pAC->SlowPathLock, Flags); /* ** While testing this driver with latest kernel 2.5 (2.5.70), it ** seems as if upper layers have a problem to handle a successful ** return value of '0'. If such a zero is returned, the complete ** system hangs for several minutes (!), which is in acceptable. ** ** Currently it is not clear, what the exact reason for this problem ** is. The implemented workaround for 2.5 is to return the desired ** new MTU size if all needed changes for the new MTU size where ** performed. In kernels 2.2 and 2.4, a zero value is returned, ** which indicates the successful change of the mtu-size. */ return NewMtu; } /* SkGeChangeMtu */ /***************************************************************************** * * SkGeStats - return ethernet device statistics * * Description: * This function return statistic data about the ethernet device * to the operating system. * * Returns: * pointer to the statistic structure. */ static struct net_device_stats *SkGeStats(struct SK_NET_DEVICE *dev) { DEV_NET *pNet = netdev_priv(dev); SK_AC *pAC = pNet->pAC; SK_PNMI_STRUCT_DATA *pPnmiStruct; /* structure for all Pnmi-Data */ SK_PNMI_STAT *pPnmiStat; /* pointer to virtual XMAC stat. data */ SK_PNMI_CONF *pPnmiConf; /* pointer to virtual link config. */ unsigned int Size; /* size of pnmi struct */ unsigned long Flags; /* for spin lock */ SK_DBG_MSG(NULL, SK_DBGMOD_DRV, SK_DBGCAT_DRV_ENTRY, ("SkGeStats starts now...\n")); pPnmiStruct = &pAC->PnmiStruct; #ifdef SK_DIAG_SUPPORT if ((pAC->DiagModeActive == DIAG_NOTACTIVE) && (pAC->BoardLevel == SK_INIT_RUN)) { #endif SK_MEMSET(pPnmiStruct, 0, sizeof(SK_PNMI_STRUCT_DATA)); spin_lock_irqsave(&pAC->SlowPathLock, Flags); Size = SK_PNMI_STRUCT_SIZE; SkPnmiGetStruct(pAC, pAC->IoBase, pPnmiStruct, &Size, pNet->NetNr); spin_unlock_irqrestore(&pAC->SlowPathLock, Flags); #ifdef SK_DIAG_SUPPORT } #endif pPnmiStat = &pPnmiStruct->Stat[0]; pPnmiConf = &pPnmiStruct->Conf[0]; pAC->stats.rx_packets = (SK_U32) pPnmiStruct->RxDeliveredCts & 0xFFFFFFFF; pAC->stats.tx_packets = (SK_U32) pPnmiStat->StatTxOkCts & 0xFFFFFFFF; pAC->stats.rx_bytes = (SK_U32) pPnmiStruct->RxOctetsDeliveredCts; pAC->stats.tx_bytes = (SK_U32) pPnmiStat->StatTxOctetsOkCts; if (dev->mtu <= 1500) { pAC->stats.rx_errors = (SK_U32) pPnmiStruct->InErrorsCts & 0xFFFFFFFF; } else { pAC->stats.rx_errors = (SK_U32) ((pPnmiStruct->InErrorsCts - pPnmiStat->StatRxTooLongCts) & 0xFFFFFFFF); } if (pAC->GIni.GP[0].PhyType == SK_PHY_XMAC && pAC->HWRevision < 12) pAC->stats.rx_errors = pAC->stats.rx_errors - pPnmiStat->StatRxShortsCts; pAC->stats.tx_errors = (SK_U32) pPnmiStat->StatTxSingleCollisionCts & 0xFFFFFFFF; pAC->stats.rx_dropped = (SK_U32) pPnmiStruct->RxNoBufCts & 0xFFFFFFFF; pAC->stats.tx_dropped = (SK_U32) pPnmiStruct->TxNoBufCts & 0xFFFFFFFF; pAC->stats.multicast = (SK_U32) pPnmiStat->StatRxMulticastOkCts & 0xFFFFFFFF; pAC->stats.collisions = (SK_U32) pPnmiStat->StatTxSingleCollisionCts & 0xFFFFFFFF; /* detailed rx_errors: */ pAC->stats.rx_length_errors = (SK_U32) pPnmiStat->StatRxRuntCts & 0xFFFFFFFF; pAC->stats.rx_over_errors = (SK_U32) pPnmiStat->StatRxFifoOverflowCts & 0xFFFFFFFF; pAC->stats.rx_crc_errors = (SK_U32) pPnmiStat->StatRxFcsCts & 0xFFFFFFFF; pAC->stats.rx_frame_errors = (SK_U32) pPnmiStat->StatRxFramingCts & 0xFFFFFFFF; pAC->stats.rx_fifo_errors = (SK_U32) pPnmiStat->StatRxFifoOverflowCts & 0xFFFFFFFF; pAC->stats.rx_missed_errors = (SK_U32) pPnmiStat->StatRxMissedCts & 0xFFFFFFFF; /* detailed tx_errors */ pAC->stats.tx_aborted_errors = (SK_U32) 0; pAC->stats.tx_carrier_errors = (SK_U32) pPnmiStat->StatTxCarrierCts & 0xFFFFFFFF; pAC->stats.tx_fifo_errors = (SK_U32) pPnmiStat->StatTxFifoUnderrunCts & 0xFFFFFFFF; pAC->stats.tx_heartbeat_errors = (SK_U32) pPnmiStat->StatTxCarrierCts & 0xFFFFFFFF; pAC->stats.tx_window_errors = (SK_U32) 0; return(&pAC->stats); } /* SkGeStats */ /***************************************************************************** * * SkGeIoctl - IO-control function * * Description: * This function is called if an ioctl is issued on the device. * There are three subfunction for reading, writing and test-writing * the private MIB data structure (useful for SysKonnect-internal tools). * * Returns: * 0, if everything is ok * !=0, on error */ static int SkGeIoctl(struct SK_NET_DEVICE *dev, struct ifreq *rq, int cmd) { DEV_NET *pNet; SK_AC *pAC; void *pMemBuf; struct pci_dev *pdev = NULL; SK_GE_IOCTL Ioctl; unsigned int Err = 0; int Size = 0; int Ret = 0; unsigned int Length = 0; int HeaderLength = sizeof(SK_U32) + sizeof(SK_U32); SK_DBG_MSG(NULL, SK_DBGMOD_DRV, SK_DBGCAT_DRV_ENTRY, ("SkGeIoctl starts now...\n")); pNet = netdev_priv(dev); pAC = pNet->pAC; if(copy_from_user(&Ioctl, rq->ifr_data, sizeof(SK_GE_IOCTL))) { return -EFAULT; } switch(cmd) { case SK_IOCTL_SETMIB: case SK_IOCTL_PRESETMIB: if (!capable(CAP_NET_ADMIN)) return -EPERM; case SK_IOCTL_GETMIB: if(copy_from_user(&pAC->PnmiStruct, Ioctl.pData, Ioctl.Len<sizeof(pAC->PnmiStruct)? Ioctl.Len : sizeof(pAC->PnmiStruct))) { return -EFAULT; } Size = SkGeIocMib(pNet, Ioctl.Len, cmd); if(copy_to_user(Ioctl.pData, &pAC->PnmiStruct, Ioctl.Len<Size? Ioctl.Len : Size)) { return -EFAULT; } Ioctl.Len = Size; if(copy_to_user(rq->ifr_data, &Ioctl, sizeof(SK_GE_IOCTL))) { return -EFAULT; } break; case SK_IOCTL_GEN: if (Ioctl.Len < (sizeof(pAC->PnmiStruct) + HeaderLength)) { Length = Ioctl.Len; } else { Length = sizeof(pAC->PnmiStruct) + HeaderLength; } if (NULL == (pMemBuf = kmalloc(Length, GFP_KERNEL))) { return -ENOMEM; } if(copy_from_user(pMemBuf, Ioctl.pData, Length)) { Err = -EFAULT; goto fault_gen; } if ((Ret = SkPnmiGenIoctl(pAC, pAC->IoBase, pMemBuf, &Length, 0)) < 0) { Err = -EFAULT; goto fault_gen; } if(copy_to_user(Ioctl.pData, pMemBuf, Length) ) { Err = -EFAULT; goto fault_gen; } Ioctl.Len = Length; if(copy_to_user(rq->ifr_data, &Ioctl, sizeof(SK_GE_IOCTL))) { Err = -EFAULT; goto fault_gen; } fault_gen: kfree(pMemBuf); /* cleanup everything */ break; #ifdef SK_DIAG_SUPPORT case SK_IOCTL_DIAG: if (!capable(CAP_NET_ADMIN)) return -EPERM; if (Ioctl.Len < (sizeof(pAC->PnmiStruct) + HeaderLength)) { Length = Ioctl.Len; } else { Length = sizeof(pAC->PnmiStruct) + HeaderLength; } if (NULL == (pMemBuf = kmalloc(Length, GFP_KERNEL))) { return -ENOMEM; } if(copy_from_user(pMemBuf, Ioctl.pData, Length)) { Err = -EFAULT; goto fault_diag; } pdev = pAC->PciDev; Length = 3 * sizeof(SK_U32); /* Error, Bus and Device */ /* ** While coding this new IOCTL interface, only a few lines of code ** are to to be added. Therefore no dedicated function has been ** added. If more functionality is added, a separate function ** should be used... */ * ((SK_U32 *)pMemBuf) = 0; * ((SK_U32 *)pMemBuf + 1) = pdev->bus->number; * ((SK_U32 *)pMemBuf + 2) = ParseDeviceNbrFromSlotName(pci_name(pdev)); if(copy_to_user(Ioctl.pData, pMemBuf, Length) ) { Err = -EFAULT; goto fault_diag; } Ioctl.Len = Length; if(copy_to_user(rq->ifr_data, &Ioctl, sizeof(SK_GE_IOCTL))) { Err = -EFAULT; goto fault_diag; } fault_diag: kfree(pMemBuf); /* cleanup everything */ break; #endif default: Err = -EOPNOTSUPP; } return(Err); } /* SkGeIoctl */ /***************************************************************************** * * SkGeIocMib - handle a GetMib, SetMib- or PresetMib-ioctl message * * Description: * This function reads/writes the MIB data using PNMI (Private Network * Management Interface). * The destination for the data must be provided with the * ioctl call and is given to the driver in the form of * a user space address. * Copying from the user-provided data area into kernel messages * and back is done by copy_from_user and copy_to_user calls in * SkGeIoctl. * * Returns: * returned size from PNMI call */ static int SkGeIocMib( DEV_NET *pNet, /* pointer to the adapter context */ unsigned int Size, /* length of ioctl data */ int mode) /* flag for set/preset */ { unsigned long Flags; /* for spin lock */ SK_AC *pAC; SK_DBG_MSG(NULL, SK_DBGMOD_DRV, SK_DBGCAT_DRV_ENTRY, ("SkGeIocMib starts now...\n")); pAC = pNet->pAC; /* access MIB */ spin_lock_irqsave(&pAC->SlowPathLock, Flags); switch(mode) { case SK_IOCTL_GETMIB: SkPnmiGetStruct(pAC, pAC->IoBase, &pAC->PnmiStruct, &Size, pNet->NetNr); break; case SK_IOCTL_PRESETMIB: SkPnmiPreSetStruct(pAC, pAC->IoBase, &pAC->PnmiStruct, &Size, pNet->NetNr); break; case SK_IOCTL_SETMIB: SkPnmiSetStruct(pAC, pAC->IoBase, &pAC->PnmiStruct, &Size, pNet->NetNr); break; default: break; } spin_unlock_irqrestore(&pAC->SlowPathLock, Flags); SK_DBG_MSG(NULL, SK_DBGMOD_DRV, SK_DBGCAT_DRV_ENTRY, ("MIB data access succeeded\n")); return (Size); } /* SkGeIocMib */ /***************************************************************************** * * GetConfiguration - read configuration information * * Description: * This function reads per-adapter configuration information from * the options provided on the command line. * * Returns: * none */ static void GetConfiguration( SK_AC *pAC) /* pointer to the adapter context structure */ { SK_I32 Port; /* preferred port */ SK_BOOL AutoSet; SK_BOOL DupSet; int LinkSpeed = SK_LSPEED_AUTO; /* Link speed */ int AutoNeg = 1; /* autoneg off (0) or on (1) */ int DuplexCap = 0; /* 0=both,1=full,2=half */ int FlowCtrl = SK_FLOW_MODE_SYM_OR_REM; /* FlowControl */ int MSMode = SK_MS_MODE_AUTO; /* master/slave mode */ SK_BOOL IsConTypeDefined = SK_TRUE; SK_BOOL IsLinkSpeedDefined = SK_TRUE; SK_BOOL IsFlowCtrlDefined = SK_TRUE; SK_BOOL IsRoleDefined = SK_TRUE; SK_BOOL IsModeDefined = SK_TRUE; /* * The two parameters AutoNeg. and DuplexCap. map to one configuration * parameter. The mapping is described by this table: * DuplexCap -> | both | full | half | * AutoNeg | | | | * ----------------------------------------------------------------- * Off | illegal | Full | Half | * ----------------------------------------------------------------- * On | AutoBoth | AutoFull | AutoHalf | * ----------------------------------------------------------------- * Sense | AutoSense | AutoSense | AutoSense | */ int Capabilities[3][3] = { { -1, SK_LMODE_FULL , SK_LMODE_HALF }, {SK_LMODE_AUTOBOTH , SK_LMODE_AUTOFULL , SK_LMODE_AUTOHALF }, {SK_LMODE_AUTOSENSE, SK_LMODE_AUTOSENSE, SK_LMODE_AUTOSENSE} }; #define DC_BOTH 0 #define DC_FULL 1 #define DC_HALF 2 #define AN_OFF 0 #define AN_ON 1 #define AN_SENS 2 #define M_CurrPort pAC->GIni.GP[Port] /* ** Set the default values first for both ports! */ for (Port = 0; Port < SK_MAX_MACS; Port++) { M_CurrPort.PLinkModeConf = Capabilities[AN_ON][DC_BOTH]; M_CurrPort.PFlowCtrlMode = SK_FLOW_MODE_SYM_OR_REM; M_CurrPort.PMSMode = SK_MS_MODE_AUTO; M_CurrPort.PLinkSpeed = SK_LSPEED_AUTO; } /* ** Check merged parameter ConType. If it has not been used, ** verify any other parameter (e.g. AutoNeg) and use default values. ** ** Stating both ConType and other lowlevel link parameters is also ** possible. If this is the case, the passed ConType-parameter is ** overwritten by the lowlevel link parameter. ** ** The following settings are used for a merged ConType-parameter: ** ** ConType DupCap AutoNeg FlowCtrl Role Speed ** ------- ------ ------- -------- ---------- ----- ** Auto Both On SymOrRem Auto Auto ** 100FD Full Off None <ignored> 100 ** 100HD Half Off None <ignored> 100 ** 10FD Full Off None <ignored> 10 ** 10HD Half Off None <ignored> 10 ** ** This ConType parameter is used for all ports of the adapter! */ if ( (ConType != NULL) && (pAC->Index < SK_MAX_CARD_PARAM) && (ConType[pAC->Index] != NULL) ) { /* Check chipset family */ if ((!pAC->ChipsetType) && (strcmp(ConType[pAC->Index],"Auto")!=0) && (strcmp(ConType[pAC->Index],"")!=0)) { /* Set the speed parameter back */ printk("sk98lin: Illegal value \"%s\" " "for ConType." " Using Auto.\n", ConType[pAC->Index]); sprintf(ConType[pAC->Index], "Auto"); } if (strcmp(ConType[pAC->Index],"")==0) { IsConTypeDefined = SK_FALSE; /* No ConType defined */ } else if (strcmp(ConType[pAC->Index],"Auto")==0) { for (Port = 0; Port < SK_MAX_MACS; Port++) { M_CurrPort.PLinkModeConf = Capabilities[AN_ON][DC_BOTH]; M_CurrPort.PFlowCtrlMode = SK_FLOW_MODE_SYM_OR_REM; M_CurrPort.PMSMode = SK_MS_MODE_AUTO; M_CurrPort.PLinkSpeed = SK_LSPEED_AUTO; } } else if (strcmp(ConType[pAC->Index],"100FD")==0) { for (Port = 0; Port < SK_MAX_MACS; Port++) { M_CurrPort.PLinkModeConf = Capabilities[AN_OFF][DC_FULL]; M_CurrPort.PFlowCtrlMode = SK_FLOW_MODE_NONE; M_CurrPort.PMSMode = SK_MS_MODE_AUTO; M_CurrPort.PLinkSpeed = SK_LSPEED_100MBPS; } } else if (strcmp(ConType[pAC->Index],"100HD")==0) { for (Port = 0; Port < SK_MAX_MACS; Port++) { M_CurrPort.PLinkModeConf = Capabilities[AN_OFF][DC_HALF]; M_CurrPort.PFlowCtrlMode = SK_FLOW_MODE_NONE; M_CurrPort.PMSMode = SK_MS_MODE_AUTO; M_CurrPort.PLinkSpeed = SK_LSPEED_100MBPS; } } else if (strcmp(ConType[pAC->Index],"10FD")==0) { for (Port = 0; Port < SK_MAX_MACS; Port++) { M_CurrPort.PLinkModeConf = Capabilities[AN_OFF][DC_FULL]; M_CurrPort.PFlowCtrlMode = SK_FLOW_MODE_NONE; M_CurrPort.PMSMode = SK_MS_MODE_AUTO; M_CurrPort.PLinkSpeed = SK_LSPEED_10MBPS; } } else if (strcmp(ConType[pAC->Index],"10HD")==0) { for (Port = 0; Port < SK_MAX_MACS; Port++) { M_CurrPort.PLinkModeConf = Capabilities[AN_OFF][DC_HALF]; M_CurrPort.PFlowCtrlMode = SK_FLOW_MODE_NONE; M_CurrPort.PMSMode = SK_MS_MODE_AUTO; M_CurrPort.PLinkSpeed = SK_LSPEED_10MBPS; } } else { printk("sk98lin: Illegal value \"%s\" for ConType\n", ConType[pAC->Index]); IsConTypeDefined = SK_FALSE; /* Wrong ConType defined */ } } else { IsConTypeDefined = SK_FALSE; /* No ConType defined */ } /* ** Parse any parameter settings for port A: ** a) any LinkSpeed stated? */ if (Speed_A != NULL && pAC->Index<SK_MAX_CARD_PARAM && Speed_A[pAC->Index] != NULL) { if (strcmp(Speed_A[pAC->Index],"")==0) { IsLinkSpeedDefined = SK_FALSE; } else if (strcmp(Speed_A[pAC->Index],"Auto")==0) { LinkSpeed = SK_LSPEED_AUTO; } else if (strcmp(Speed_A[pAC->Index],"10")==0) { LinkSpeed = SK_LSPEED_10MBPS; } else if (strcmp(Speed_A[pAC->Index],"100")==0) { LinkSpeed = SK_LSPEED_100MBPS; } else if (strcmp(Speed_A[pAC->Index],"1000")==0) { LinkSpeed = SK_LSPEED_1000MBPS; } else { printk("sk98lin: Illegal value \"%s\" for Speed_A\n", Speed_A[pAC->Index]); IsLinkSpeedDefined = SK_FALSE; } } else { IsLinkSpeedDefined = SK_FALSE; } /* ** Check speed parameter: ** Only copper type adapter and GE V2 cards */ if (((!pAC->ChipsetType) || (pAC->GIni.GICopperType != SK_TRUE)) && ((LinkSpeed != SK_LSPEED_AUTO) && (LinkSpeed != SK_LSPEED_1000MBPS))) { printk("sk98lin: Illegal value for Speed_A. " "Not a copper card or GE V2 card\n Using " "speed 1000\n"); LinkSpeed = SK_LSPEED_1000MBPS; } /* ** Decide whether to set new config value if somethig valid has ** been received. */ if (IsLinkSpeedDefined) { pAC->GIni.GP[0].PLinkSpeed = LinkSpeed; } /* ** b) Any Autonegotiation and DuplexCapabilities set? ** Please note that both belong together... */ AutoNeg = AN_ON; /* tschilling: Default: Autonegotiation on! */ AutoSet = SK_FALSE; if (AutoNeg_A != NULL && pAC->Index<SK_MAX_CARD_PARAM && AutoNeg_A[pAC->Index] != NULL) { AutoSet = SK_TRUE; if (strcmp(AutoNeg_A[pAC->Index],"")==0) { AutoSet = SK_FALSE; } else if (strcmp(AutoNeg_A[pAC->Index],"On")==0) { AutoNeg = AN_ON; } else if (strcmp(AutoNeg_A[pAC->Index],"Off")==0) { AutoNeg = AN_OFF; } else if (strcmp(AutoNeg_A[pAC->Index],"Sense")==0) { AutoNeg = AN_SENS; } else { printk("sk98lin: Illegal value \"%s\" for AutoNeg_A\n", AutoNeg_A[pAC->Index]); } } DuplexCap = DC_BOTH; DupSet = SK_FALSE; if (DupCap_A != NULL && pAC->Index<SK_MAX_CARD_PARAM && DupCap_A[pAC->Index] != NULL) { DupSet = SK_TRUE; if (strcmp(DupCap_A[pAC->Index],"")==0) { DupSet = SK_FALSE; } else if (strcmp(DupCap_A[pAC->Index],"Both")==0) { DuplexCap = DC_BOTH; } else if (strcmp(DupCap_A[pAC->Index],"Full")==0) { DuplexCap = DC_FULL; } else if (strcmp(DupCap_A[pAC->Index],"Half")==0) { DuplexCap = DC_HALF; } else { printk("sk98lin: Illegal value \"%s\" for DupCap_A\n", DupCap_A[pAC->Index]); } } /* ** Check for illegal combinations */ if ((LinkSpeed == SK_LSPEED_1000MBPS) && ((DuplexCap == SK_LMODE_STAT_AUTOHALF) || (DuplexCap == SK_LMODE_STAT_HALF)) && (pAC->ChipsetType)) { printk("sk98lin: Half Duplex not possible with Gigabit speed!\n" " Using Full Duplex.\n"); DuplexCap = DC_FULL; } if ( AutoSet && AutoNeg==AN_SENS && DupSet) { printk("sk98lin, Port A: DuplexCapabilities" " ignored using Sense mode\n"); } if (AutoSet && AutoNeg==AN_OFF && DupSet && DuplexCap==DC_BOTH){ printk("sk98lin: Port A: Illegal combination" " of values AutoNeg. and DuplexCap.\n Using " "Full Duplex\n"); DuplexCap = DC_FULL; } if (AutoSet && AutoNeg==AN_OFF && !DupSet) { DuplexCap = DC_FULL; } if (!AutoSet && DupSet) { printk("sk98lin: Port A: Duplex setting not" " possible in\n default AutoNegotiation mode" " (Sense).\n Using AutoNegotiation On\n"); AutoNeg = AN_ON; } /* ** set the desired mode */ if (AutoSet || DupSet) { pAC->GIni.GP[0].PLinkModeConf = Capabilities[AutoNeg][DuplexCap]; } /* ** c) Any Flowcontrol-parameter set? */ if (FlowCtrl_A != NULL && pAC->Index<SK_MAX_CARD_PARAM && FlowCtrl_A[pAC->Index] != NULL) { if (strcmp(FlowCtrl_A[pAC->Index],"") == 0) { IsFlowCtrlDefined = SK_FALSE; } else if (strcmp(FlowCtrl_A[pAC->Index],"SymOrRem") == 0) { FlowCtrl = SK_FLOW_MODE_SYM_OR_REM; } else if (strcmp(FlowCtrl_A[pAC->Index],"Sym")==0) { FlowCtrl = SK_FLOW_MODE_SYMMETRIC; } else if (strcmp(FlowCtrl_A[pAC->Index],"LocSend")==0) { FlowCtrl = SK_FLOW_MODE_LOC_SEND; } else if (strcmp(FlowCtrl_A[pAC->Index],"None")==0) { FlowCtrl = SK_FLOW_MODE_NONE; } else { printk("sk98lin: Illegal value \"%s\" for FlowCtrl_A\n", FlowCtrl_A[pAC->Index]); IsFlowCtrlDefined = SK_FALSE; } } else { IsFlowCtrlDefined = SK_FALSE; } if (IsFlowCtrlDefined) { if ((AutoNeg == AN_OFF) && (FlowCtrl != SK_FLOW_MODE_NONE)) { printk("sk98lin: Port A: FlowControl" " impossible without AutoNegotiation," " disabled\n"); FlowCtrl = SK_FLOW_MODE_NONE; } pAC->GIni.GP[0].PFlowCtrlMode = FlowCtrl; } /* ** d) What is with the RoleParameter? */ if (Role_A != NULL && pAC->Index<SK_MAX_CARD_PARAM && Role_A[pAC->Index] != NULL) { if (strcmp(Role_A[pAC->Index],"")==0) { IsRoleDefined = SK_FALSE; } else if (strcmp(Role_A[pAC->Index],"Auto")==0) { MSMode = SK_MS_MODE_AUTO; } else if (strcmp(Role_A[pAC->Index],"Master")==0) { MSMode = SK_MS_MODE_MASTER; } else if (strcmp(Role_A[pAC->Index],"Slave")==0) { MSMode = SK_MS_MODE_SLAVE; } else { printk("sk98lin: Illegal value \"%s\" for Role_A\n", Role_A[pAC->Index]); IsRoleDefined = SK_FALSE; } } else { IsRoleDefined = SK_FALSE; } if (IsRoleDefined == SK_TRUE) { pAC->GIni.GP[0].PMSMode = MSMode; } /* ** Parse any parameter settings for port B: ** a) any LinkSpeed stated? */ IsConTypeDefined = SK_TRUE; IsLinkSpeedDefined = SK_TRUE; IsFlowCtrlDefined = SK_TRUE; IsModeDefined = SK_TRUE; if (Speed_B != NULL && pAC->Index<SK_MAX_CARD_PARAM && Speed_B[pAC->Index] != NULL) { if (strcmp(Speed_B[pAC->Index],"")==0) { IsLinkSpeedDefined = SK_FALSE; } else if (strcmp(Speed_B[pAC->Index],"Auto")==0) { LinkSpeed = SK_LSPEED_AUTO; } else if (strcmp(Speed_B[pAC->Index],"10")==0) { LinkSpeed = SK_LSPEED_10MBPS; } else if (strcmp(Speed_B[pAC->Index],"100")==0) { LinkSpeed = SK_LSPEED_100MBPS; } else if (strcmp(Speed_B[pAC->Index],"1000")==0) { LinkSpeed = SK_LSPEED_1000MBPS; } else { printk("sk98lin: Illegal value \"%s\" for Speed_B\n", Speed_B[pAC->Index]); IsLinkSpeedDefined = SK_FALSE; } } else { IsLinkSpeedDefined = SK_FALSE; } /* ** Check speed parameter: ** Only copper type adapter and GE V2 cards */ if (((!pAC->ChipsetType) || (pAC->GIni.GICopperType != SK_TRUE)) && ((LinkSpeed != SK_LSPEED_AUTO) && (LinkSpeed != SK_LSPEED_1000MBPS))) { printk("sk98lin: Illegal value for Speed_B. " "Not a copper card or GE V2 card\n Using " "speed 1000\n"); LinkSpeed = SK_LSPEED_1000MBPS; } /* ** Decide whether to set new config value if somethig valid has ** been received. */ if (IsLinkSpeedDefined) { pAC->GIni.GP[1].PLinkSpeed = LinkSpeed; } /* ** b) Any Autonegotiation and DuplexCapabilities set? ** Please note that both belong together... */ AutoNeg = AN_SENS; /* default: do auto Sense */ AutoSet = SK_FALSE; if (AutoNeg_B != NULL && pAC->Index<SK_MAX_CARD_PARAM && AutoNeg_B[pAC->Index] != NULL) { AutoSet = SK_TRUE; if (strcmp(AutoNeg_B[pAC->Index],"")==0) { AutoSet = SK_FALSE; } else if (strcmp(AutoNeg_B[pAC->Index],"On")==0) { AutoNeg = AN_ON; } else if (strcmp(AutoNeg_B[pAC->Index],"Off")==0) { AutoNeg = AN_OFF; } else if (strcmp(AutoNeg_B[pAC->Index],"Sense")==0) { AutoNeg = AN_SENS; } else { printk("sk98lin: Illegal value \"%s\" for AutoNeg_B\n", AutoNeg_B[pAC->Index]); } } DuplexCap = DC_BOTH; DupSet = SK_FALSE; if (DupCap_B != NULL && pAC->Index<SK_MAX_CARD_PARAM && DupCap_B[pAC->Index] != NULL) { DupSet = SK_TRUE; if (strcmp(DupCap_B[pAC->Index],"")==0) { DupSet = SK_FALSE; } else if (strcmp(DupCap_B[pAC->Index],"Both")==0) { DuplexCap = DC_BOTH; } else if (strcmp(DupCap_B[pAC->Index],"Full")==0) { DuplexCap = DC_FULL; } else if (strcmp(DupCap_B[pAC->Index],"Half")==0) { DuplexCap = DC_HALF; } else { printk("sk98lin: Illegal value \"%s\" for DupCap_B\n", DupCap_B[pAC->Index]); } } /* ** Check for illegal combinations */ if ((LinkSpeed == SK_LSPEED_1000MBPS) && ((DuplexCap == SK_LMODE_STAT_AUTOHALF) || (DuplexCap == SK_LMODE_STAT_HALF)) && (pAC->ChipsetType)) { printk("sk98lin: Half Duplex not possible with Gigabit speed!\n" " Using Full Duplex.\n"); DuplexCap = DC_FULL; } if (AutoSet && AutoNeg==AN_SENS && DupSet) { printk("sk98lin, Port B: DuplexCapabilities" " ignored using Sense mode\n"); } if (AutoSet && AutoNeg==AN_OFF && DupSet && DuplexCap==DC_BOTH){ printk("sk98lin: Port B: Illegal combination" " of values AutoNeg. and DuplexCap.\n Using " "Full Duplex\n"); DuplexCap = DC_FULL; } if (AutoSet && AutoNeg==AN_OFF && !DupSet) { DuplexCap = DC_FULL; } if (!AutoSet && DupSet) { printk("sk98lin: Port B: Duplex setting not" " possible in\n default AutoNegotiation mode" " (Sense).\n Using AutoNegotiation On\n"); AutoNeg = AN_ON; } /* ** set the desired mode */ if (AutoSet || DupSet) { pAC->GIni.GP[1].PLinkModeConf = Capabilities[AutoNeg][DuplexCap]; } /* ** c) Any FlowCtrl parameter set? */ if (FlowCtrl_B != NULL && pAC->Index<SK_MAX_CARD_PARAM && FlowCtrl_B[pAC->Index] != NULL) { if (strcmp(FlowCtrl_B[pAC->Index],"") == 0) { IsFlowCtrlDefined = SK_FALSE; } else if (strcmp(FlowCtrl_B[pAC->Index],"SymOrRem") == 0) { FlowCtrl = SK_FLOW_MODE_SYM_OR_REM; } else if (strcmp(FlowCtrl_B[pAC->Index],"Sym")==0) { FlowCtrl = SK_FLOW_MODE_SYMMETRIC; } else if (strcmp(FlowCtrl_B[pAC->Index],"LocSend")==0) { FlowCtrl = SK_FLOW_MODE_LOC_SEND; } else if (strcmp(FlowCtrl_B[pAC->Index],"None")==0) { FlowCtrl = SK_FLOW_MODE_NONE; } else { printk("sk98lin: Illegal value \"%s\" for FlowCtrl_B\n", FlowCtrl_B[pAC->Index]); IsFlowCtrlDefined = SK_FALSE; } } else { IsFlowCtrlDefined = SK_FALSE; } if (IsFlowCtrlDefined) { if ((AutoNeg == AN_OFF) && (FlowCtrl != SK_FLOW_MODE_NONE)) { printk("sk98lin: Port B: FlowControl" " impossible without AutoNegotiation," " disabled\n"); FlowCtrl = SK_FLOW_MODE_NONE; } pAC->GIni.GP[1].PFlowCtrlMode = FlowCtrl; } /* ** d) What is the RoleParameter? */ if (Role_B != NULL && pAC->Index<SK_MAX_CARD_PARAM && Role_B[pAC->Index] != NULL) { if (strcmp(Role_B[pAC->Index],"")==0) { IsRoleDefined = SK_FALSE; } else if (strcmp(Role_B[pAC->Index],"Auto")==0) { MSMode = SK_MS_MODE_AUTO; } else if (strcmp(Role_B[pAC->Index],"Master")==0) { MSMode = SK_MS_MODE_MASTER; } else if (strcmp(Role_B[pAC->Index],"Slave")==0) { MSMode = SK_MS_MODE_SLAVE; } else { printk("sk98lin: Illegal value \"%s\" for Role_B\n", Role_B[pAC->Index]); IsRoleDefined = SK_FALSE; } } else { IsRoleDefined = SK_FALSE; } if (IsRoleDefined) { pAC->GIni.GP[1].PMSMode = MSMode; } /* ** Evaluate settings for both ports */ pAC->ActivePort = 0; if (PrefPort != NULL && pAC->Index<SK_MAX_CARD_PARAM && PrefPort[pAC->Index] != NULL) { if (strcmp(PrefPort[pAC->Index],"") == 0) { /* Auto */ pAC->ActivePort = 0; pAC->Rlmt.Net[0].Preference = -1; /* auto */ pAC->Rlmt.Net[0].PrefPort = 0; } else if (strcmp(PrefPort[pAC->Index],"A") == 0) { /* ** do not set ActivePort here, thus a port ** switch is issued after net up. */ Port = 0; pAC->Rlmt.Net[0].Preference = Port; pAC->Rlmt.Net[0].PrefPort = Port; } else if (strcmp(PrefPort[pAC->Index],"B") == 0) { /* ** do not set ActivePort here, thus a port ** switch is issued after net up. */ if (pAC->GIni.GIMacsFound == 1) { printk("sk98lin: Illegal value \"B\" for PrefPort.\n" " Port B not available on single port adapters.\n"); pAC->ActivePort = 0; pAC->Rlmt.Net[0].Preference = -1; /* auto */ pAC->Rlmt.Net[0].PrefPort = 0; } else { Port = 1; pAC->Rlmt.Net[0].Preference = Port; pAC->Rlmt.Net[0].PrefPort = Port; } } else { printk("sk98lin: Illegal value \"%s\" for PrefPort\n", PrefPort[pAC->Index]); } } pAC->RlmtNets = 1; if (RlmtMode != NULL && pAC->Index<SK_MAX_CARD_PARAM && RlmtMode[pAC->Index] != NULL) { if (strcmp(RlmtMode[pAC->Index], "") == 0) { pAC->RlmtMode = 0; } else if (strcmp(RlmtMode[pAC->Index], "CheckLinkState") == 0) { pAC->RlmtMode = SK_RLMT_CHECK_LINK; } else if (strcmp(RlmtMode[pAC->Index], "CheckLocalPort") == 0) { pAC->RlmtMode = SK_RLMT_CHECK_LINK | SK_RLMT_CHECK_LOC_LINK; } else if (strcmp(RlmtMode[pAC->Index], "CheckSeg") == 0) { pAC->RlmtMode = SK_RLMT_CHECK_LINK | SK_RLMT_CHECK_LOC_LINK | SK_RLMT_CHECK_SEG; } else if ((strcmp(RlmtMode[pAC->Index], "DualNet") == 0) && (pAC->GIni.GIMacsFound == 2)) { pAC->RlmtMode = SK_RLMT_CHECK_LINK; pAC->RlmtNets = 2; } else { printk("sk98lin: Illegal value \"%s\" for" " RlmtMode, using default\n", RlmtMode[pAC->Index]); pAC->RlmtMode = 0; } } else { pAC->RlmtMode = 0; } /* ** Check the interrupt moderation parameters */ if (Moderation[pAC->Index] != NULL) { if (strcmp(Moderation[pAC->Index], "") == 0) { pAC->DynIrqModInfo.IntModTypeSelect = C_INT_MOD_NONE; } else if (strcmp(Moderation[pAC->Index], "Static") == 0) { pAC->DynIrqModInfo.IntModTypeSelect = C_INT_MOD_STATIC; } else if (strcmp(Moderation[pAC->Index], "Dynamic") == 0) { pAC->DynIrqModInfo.IntModTypeSelect = C_INT_MOD_DYNAMIC; } else if (strcmp(Moderation[pAC->Index], "None") == 0) { pAC->DynIrqModInfo.IntModTypeSelect = C_INT_MOD_NONE; } else { printk("sk98lin: Illegal value \"%s\" for Moderation.\n" " Disable interrupt moderation.\n", Moderation[pAC->Index]); pAC->DynIrqModInfo.IntModTypeSelect = C_INT_MOD_NONE; } } else { pAC->DynIrqModInfo.IntModTypeSelect = C_INT_MOD_NONE; } if (Stats[pAC->Index] != NULL) { if (strcmp(Stats[pAC->Index], "Yes") == 0) { pAC->DynIrqModInfo.DisplayStats = SK_TRUE; } else { pAC->DynIrqModInfo.DisplayStats = SK_FALSE; } } else { pAC->DynIrqModInfo.DisplayStats = SK_FALSE; } if (ModerationMask[pAC->Index] != NULL) { if (strcmp(ModerationMask[pAC->Index], "Rx") == 0) { pAC->DynIrqModInfo.MaskIrqModeration = IRQ_MASK_RX_ONLY; } else if (strcmp(ModerationMask[pAC->Index], "Tx") == 0) { pAC->DynIrqModInfo.MaskIrqModeration = IRQ_MASK_TX_ONLY; } else if (strcmp(ModerationMask[pAC->Index], "Sp") == 0) { pAC->DynIrqModInfo.MaskIrqModeration = IRQ_MASK_SP_ONLY; } else if (strcmp(ModerationMask[pAC->Index], "RxSp") == 0) { pAC->DynIrqModInfo.MaskIrqModeration = IRQ_MASK_SP_RX; } else if (strcmp(ModerationMask[pAC->Index], "SpRx") == 0) { pAC->DynIrqModInfo.MaskIrqModeration = IRQ_MASK_SP_RX; } else if (strcmp(ModerationMask[pAC->Index], "RxTx") == 0) { pAC->DynIrqModInfo.MaskIrqModeration = IRQ_MASK_TX_RX; } else if (strcmp(ModerationMask[pAC->Index], "TxRx") == 0) { pAC->DynIrqModInfo.MaskIrqModeration = IRQ_MASK_TX_RX; } else if (strcmp(ModerationMask[pAC->Index], "TxSp") == 0) { pAC->DynIrqModInfo.MaskIrqModeration = IRQ_MASK_SP_TX; } else if (strcmp(ModerationMask[pAC->Index], "SpTx") == 0) { pAC->DynIrqModInfo.MaskIrqModeration = IRQ_MASK_SP_TX; } else if (strcmp(ModerationMask[pAC->Index], "RxTxSp") == 0) { pAC->DynIrqModInfo.MaskIrqModeration = IRQ_MASK_RX_TX_SP; } else if (strcmp(ModerationMask[pAC->Index], "RxSpTx") == 0) { pAC->DynIrqModInfo.MaskIrqModeration = IRQ_MASK_RX_TX_SP; } else if (strcmp(ModerationMask[pAC->Index], "TxRxSp") == 0) { pAC->DynIrqModInfo.MaskIrqModeration = IRQ_MASK_RX_TX_SP; } else if (strcmp(ModerationMask[pAC->Index], "TxSpRx") == 0) { pAC->DynIrqModInfo.MaskIrqModeration = IRQ_MASK_RX_TX_SP; } else if (strcmp(ModerationMask[pAC->Index], "SpTxRx") == 0) { pAC->DynIrqModInfo.MaskIrqModeration = IRQ_MASK_RX_TX_SP; } else if (strcmp(ModerationMask[pAC->Index], "SpRxTx") == 0) { pAC->DynIrqModInfo.MaskIrqModeration = IRQ_MASK_RX_TX_SP; } else { /* some rubbish */ pAC->DynIrqModInfo.MaskIrqModeration = IRQ_MASK_RX_ONLY; } } else { /* operator has stated nothing */ pAC->DynIrqModInfo.MaskIrqModeration = IRQ_MASK_TX_RX; } if (AutoSizing[pAC->Index] != NULL) { if (strcmp(AutoSizing[pAC->Index], "On") == 0) { pAC->DynIrqModInfo.AutoSizing = SK_FALSE; } else { pAC->DynIrqModInfo.AutoSizing = SK_FALSE; } } else { /* operator has stated nothing */ pAC->DynIrqModInfo.AutoSizing = SK_FALSE; } if (IntsPerSec[pAC->Index] != 0) { if ((IntsPerSec[pAC->Index]< C_INT_MOD_IPS_LOWER_RANGE) || (IntsPerSec[pAC->Index] > C_INT_MOD_IPS_UPPER_RANGE)) { printk("sk98lin: Illegal value \"%d\" for IntsPerSec. (Range: %d - %d)\n" " Using default value of %i.\n", IntsPerSec[pAC->Index], C_INT_MOD_IPS_LOWER_RANGE, C_INT_MOD_IPS_UPPER_RANGE, C_INTS_PER_SEC_DEFAULT); pAC->DynIrqModInfo.MaxModIntsPerSec = C_INTS_PER_SEC_DEFAULT; } else { pAC->DynIrqModInfo.MaxModIntsPerSec = IntsPerSec[pAC->Index]; } } else { pAC->DynIrqModInfo.MaxModIntsPerSec = C_INTS_PER_SEC_DEFAULT; } /* ** Evaluate upper and lower moderation threshold */ pAC->DynIrqModInfo.MaxModIntsPerSecUpperLimit = pAC->DynIrqModInfo.MaxModIntsPerSec + (pAC->DynIrqModInfo.MaxModIntsPerSec / 2); pAC->DynIrqModInfo.MaxModIntsPerSecLowerLimit = pAC->DynIrqModInfo.MaxModIntsPerSec - (pAC->DynIrqModInfo.MaxModIntsPerSec / 2); pAC->DynIrqModInfo.PrevTimeVal = jiffies; /* initial value */ } /* GetConfiguration */ /***************************************************************************** * * ProductStr - return a adapter identification string from vpd * * Description: * This function reads the product name string from the vpd area * and puts it the field pAC->DeviceString. * * Returns: N/A */ static inline int ProductStr( SK_AC *pAC, /* pointer to adapter context */ char *DeviceStr, /* result string */ int StrLen /* length of the string */ ) { char Keyword[] = VPD_NAME; /* vpd productname identifier */ int ReturnCode; /* return code from vpd_read */ unsigned long Flags; spin_lock_irqsave(&pAC->SlowPathLock, Flags); ReturnCode = VpdRead(pAC, pAC->IoBase, Keyword, DeviceStr, &StrLen); spin_unlock_irqrestore(&pAC->SlowPathLock, Flags); return ReturnCode; } /* ProductStr */ /***************************************************************************** * * StartDrvCleanupTimer - Start timer to check for descriptors which * might be placed in descriptor ring, but * havent been handled up to now * * Description: * This function requests a HW-timer fo the Yukon card. The actions to * perform when this timer expires, are located in the SkDrvEvent(). * * Returns: N/A */ static void StartDrvCleanupTimer(SK_AC *pAC) { SK_EVPARA EventParam; /* Event struct for timer event */ SK_MEMSET((char *) &EventParam, 0, sizeof(EventParam)); EventParam.Para32[0] = SK_DRV_RX_CLEANUP_TIMER; SkTimerStart(pAC, pAC->IoBase, &pAC->DrvCleanupTimer, SK_DRV_RX_CLEANUP_TIMER_LENGTH, SKGE_DRV, SK_DRV_TIMER, EventParam); } /***************************************************************************** * * StopDrvCleanupTimer - Stop timer to check for descriptors * * Description: * This function requests a HW-timer fo the Yukon card. The actions to * perform when this timer expires, are located in the SkDrvEvent(). * * Returns: N/A */ static void StopDrvCleanupTimer(SK_AC *pAC) { SkTimerStop(pAC, pAC->IoBase, &pAC->DrvCleanupTimer); SK_MEMSET((char *) &pAC->DrvCleanupTimer, 0, sizeof(SK_TIMER)); } /****************************************************************************/ /* functions for common modules *********************************************/ /****************************************************************************/ /***************************************************************************** * * SkDrvAllocRlmtMbuf - allocate an RLMT mbuf * * Description: * This routine returns an RLMT mbuf or NULL. The RLMT Mbuf structure * is embedded into a socket buff data area. * * Context: * runtime * * Returns: * NULL or pointer to Mbuf. */ SK_MBUF *SkDrvAllocRlmtMbuf( SK_AC *pAC, /* pointer to adapter context */ SK_IOC IoC, /* the IO-context */ unsigned BufferSize) /* size of the requested buffer */ { SK_MBUF *pRlmtMbuf; /* pointer to a new rlmt-mbuf structure */ struct sk_buff *pMsgBlock; /* pointer to a new message block */ pMsgBlock = alloc_skb(BufferSize + sizeof(SK_MBUF), GFP_ATOMIC); if (pMsgBlock == NULL) { return (NULL); } pRlmtMbuf = (SK_MBUF*) pMsgBlock->data; skb_reserve(pMsgBlock, sizeof(SK_MBUF)); pRlmtMbuf->pNext = NULL; pRlmtMbuf->pOs = pMsgBlock; pRlmtMbuf->pData = pMsgBlock->data; /* Data buffer. */ pRlmtMbuf->Size = BufferSize; /* Data buffer size. */ pRlmtMbuf->Length = 0; /* Length of packet (<= Size). */ return (pRlmtMbuf); } /* SkDrvAllocRlmtMbuf */ /***************************************************************************** * * SkDrvFreeRlmtMbuf - free an RLMT mbuf * * Description: * This routine frees one or more RLMT mbuf(s). * * Context: * runtime * * Returns: * Nothing */ void SkDrvFreeRlmtMbuf( SK_AC *pAC, /* pointer to adapter context */ SK_IOC IoC, /* the IO-context */ SK_MBUF *pMbuf) /* size of the requested buffer */ { SK_MBUF *pFreeMbuf; SK_MBUF *pNextMbuf; pFreeMbuf = pMbuf; do { pNextMbuf = pFreeMbuf->pNext; DEV_KFREE_SKB_ANY(pFreeMbuf->pOs); pFreeMbuf = pNextMbuf; } while ( pFreeMbuf != NULL ); } /* SkDrvFreeRlmtMbuf */ /***************************************************************************** * * SkOsGetTime - provide a time value * * Description: * This routine provides a time value. The unit is 1/HZ (defined by Linux). * It is not used for absolute time, but only for time differences. * * * Returns: * Time value */ SK_U64 SkOsGetTime(SK_AC *pAC) { SK_U64 PrivateJiffies; SkOsGetTimeCurrent(pAC, &PrivateJiffies); return PrivateJiffies; } /* SkOsGetTime */ /***************************************************************************** * * SkPciReadCfgDWord - read a 32 bit value from pci config space * * Description: * This routine reads a 32 bit value from the pci configuration * space. * * Returns: * 0 - indicate everything worked ok. * != 0 - error indication */ int SkPciReadCfgDWord( SK_AC *pAC, /* Adapter Control structure pointer */ int PciAddr, /* PCI register address */ SK_U32 *pVal) /* pointer to store the read value */ { pci_read_config_dword(pAC->PciDev, PciAddr, pVal); return(0); } /* SkPciReadCfgDWord */ /***************************************************************************** * * SkPciReadCfgWord - read a 16 bit value from pci config space * * Description: * This routine reads a 16 bit value from the pci configuration * space. * * Returns: * 0 - indicate everything worked ok. * != 0 - error indication */ int SkPciReadCfgWord( SK_AC *pAC, /* Adapter Control structure pointer */ int PciAddr, /* PCI register address */ SK_U16 *pVal) /* pointer to store the read value */ { pci_read_config_word(pAC->PciDev, PciAddr, pVal); return(0); } /* SkPciReadCfgWord */ /***************************************************************************** * * SkPciReadCfgByte - read a 8 bit value from pci config space * * Description: * This routine reads a 8 bit value from the pci configuration * space. * * Returns: * 0 - indicate everything worked ok. * != 0 - error indication */ int SkPciReadCfgByte( SK_AC *pAC, /* Adapter Control structure pointer */ int PciAddr, /* PCI register address */ SK_U8 *pVal) /* pointer to store the read value */ { pci_read_config_byte(pAC->PciDev, PciAddr, pVal); return(0); } /* SkPciReadCfgByte */ /***************************************************************************** * * SkPciWriteCfgWord - write a 16 bit value to pci config space * * Description: * This routine writes a 16 bit value to the pci configuration * space. The flag PciConfigUp indicates whether the config space * is accesible or must be set up first. * * Returns: * 0 - indicate everything worked ok. * != 0 - error indication */ int SkPciWriteCfgWord( SK_AC *pAC, /* Adapter Control structure pointer */ int PciAddr, /* PCI register address */ SK_U16 Val) /* pointer to store the read value */ { pci_write_config_word(pAC->PciDev, PciAddr, Val); return(0); } /* SkPciWriteCfgWord */ /***************************************************************************** * * SkPciWriteCfgWord - write a 8 bit value to pci config space * * Description: * This routine writes a 8 bit value to the pci configuration * space. The flag PciConfigUp indicates whether the config space * is accesible or must be set up first. * * Returns: * 0 - indicate everything worked ok. * != 0 - error indication */ int SkPciWriteCfgByte( SK_AC *pAC, /* Adapter Control structure pointer */ int PciAddr, /* PCI register address */ SK_U8 Val) /* pointer to store the read value */ { pci_write_config_byte(pAC->PciDev, PciAddr, Val); return(0); } /* SkPciWriteCfgByte */ /***************************************************************************** * * SkDrvEvent - handle driver events * * Description: * This function handles events from all modules directed to the driver * * Context: * Is called under protection of slow path lock. * * Returns: * 0 if everything ok * < 0 on error * */ int SkDrvEvent( SK_AC *pAC, /* pointer to adapter context */ SK_IOC IoC, /* io-context */ SK_U32 Event, /* event-id */ SK_EVPARA Param) /* event-parameter */ { SK_MBUF *pRlmtMbuf; /* pointer to a rlmt-mbuf structure */ struct sk_buff *pMsg; /* pointer to a message block */ int FromPort; /* the port from which we switch away */ int ToPort; /* the port we switch to */ SK_EVPARA NewPara; /* parameter for further events */ int Stat; unsigned long Flags; SK_BOOL DualNet; switch (Event) { case SK_DRV_ADAP_FAIL: SK_DBG_MSG(NULL, SK_DBGMOD_DRV, SK_DBGCAT_DRV_EVENT, ("ADAPTER FAIL EVENT\n")); printk("%s: Adapter failed.\n", pAC->dev[0]->name); /* disable interrupts */ SK_OUT32(pAC->IoBase, B0_IMSK, 0); /* cgoos */ break; case SK_DRV_PORT_FAIL: FromPort = Param.Para32[0]; SK_DBG_MSG(NULL, SK_DBGMOD_DRV, SK_DBGCAT_DRV_EVENT, ("PORT FAIL EVENT, Port: %d\n", FromPort)); if (FromPort == 0) { printk("%s: Port A failed.\n", pAC->dev[0]->name); } else { printk("%s: Port B failed.\n", pAC->dev[1]->name); } /* cgoos */ break; case SK_DRV_PORT_RESET: /* SK_U32 PortIdx */ /* action list 4 */ FromPort = Param.Para32[0]; SK_DBG_MSG(NULL, SK_DBGMOD_DRV, SK_DBGCAT_DRV_EVENT, ("PORT RESET EVENT, Port: %d ", FromPort)); NewPara.Para64 = FromPort; SkPnmiEvent(pAC, IoC, SK_PNMI_EVT_XMAC_RESET, NewPara); spin_lock_irqsave( &pAC->TxPort[FromPort][TX_PRIO_LOW].TxDesRingLock, Flags); SkGeStopPort(pAC, IoC, FromPort, SK_STOP_ALL, SK_HARD_RST); netif_carrier_off(pAC->dev[Param.Para32[0]]); spin_unlock_irqrestore( &pAC->TxPort[FromPort][TX_PRIO_LOW].TxDesRingLock, Flags); /* clear rx ring from received frames */ ReceiveIrq(pAC, &pAC->RxPort[FromPort], SK_FALSE); ClearTxRing(pAC, &pAC->TxPort[FromPort][TX_PRIO_LOW]); spin_lock_irqsave( &pAC->TxPort[FromPort][TX_PRIO_LOW].TxDesRingLock, Flags); /* tschilling: Handling of return value inserted. */ if (SkGeInitPort(pAC, IoC, FromPort)) { if (FromPort == 0) { printk("%s: SkGeInitPort A failed.\n", pAC->dev[0]->name); } else { printk("%s: SkGeInitPort B failed.\n", pAC->dev[1]->name); } } SkAddrMcUpdate(pAC,IoC, FromPort); PortReInitBmu(pAC, FromPort); SkGePollTxD(pAC, IoC, FromPort, SK_TRUE); ClearAndStartRx(pAC, FromPort); spin_unlock_irqrestore( &pAC->TxPort[FromPort][TX_PRIO_LOW].TxDesRingLock, Flags); break; case SK_DRV_NET_UP: /* SK_U32 PortIdx */ { struct net_device *dev = pAC->dev[Param.Para32[0]]; /* action list 5 */ FromPort = Param.Para32[0]; SK_DBG_MSG(NULL, SK_DBGMOD_DRV, SK_DBGCAT_DRV_EVENT, ("NET UP EVENT, Port: %d ", Param.Para32[0])); /* Mac update */ SkAddrMcUpdate(pAC,IoC, FromPort); if (DoPrintInterfaceChange) { printk("%s: network connection up using" " port %c\n", pAC->dev[Param.Para32[0]]->name, 'A'+Param.Para32[0]); /* tschilling: Values changed according to LinkSpeedUsed. */ Stat = pAC->GIni.GP[FromPort].PLinkSpeedUsed; if (Stat == SK_LSPEED_STAT_10MBPS) { printk(" speed: 10\n"); } else if (Stat == SK_LSPEED_STAT_100MBPS) { printk(" speed: 100\n"); } else if (Stat == SK_LSPEED_STAT_1000MBPS) { printk(" speed: 1000\n"); } else { printk(" speed: unknown\n"); } Stat = pAC->GIni.GP[FromPort].PLinkModeStatus; if (Stat == SK_LMODE_STAT_AUTOHALF || Stat == SK_LMODE_STAT_AUTOFULL) { printk(" autonegotiation: yes\n"); } else { printk(" autonegotiation: no\n"); } if (Stat == SK_LMODE_STAT_AUTOHALF || Stat == SK_LMODE_STAT_HALF) { printk(" duplex mode: half\n"); } else { printk(" duplex mode: full\n"); } Stat = pAC->GIni.GP[FromPort].PFlowCtrlStatus; if (Stat == SK_FLOW_STAT_REM_SEND ) { printk(" flowctrl: remote send\n"); } else if (Stat == SK_FLOW_STAT_LOC_SEND ){ printk(" flowctrl: local send\n"); } else if (Stat == SK_FLOW_STAT_SYMMETRIC ){ printk(" flowctrl: symmetric\n"); } else { printk(" flowctrl: none\n"); } /* tschilling: Check against CopperType now. */ if ((pAC->GIni.GICopperType == SK_TRUE) && (pAC->GIni.GP[FromPort].PLinkSpeedUsed == SK_LSPEED_STAT_1000MBPS)) { Stat = pAC->GIni.GP[FromPort].PMSStatus; if (Stat == SK_MS_STAT_MASTER ) { printk(" role: master\n"); } else if (Stat == SK_MS_STAT_SLAVE ) { printk(" role: slave\n"); } else { printk(" role: ???\n"); } } /* Display dim (dynamic interrupt moderation) informations */ if (pAC->DynIrqModInfo.IntModTypeSelect == C_INT_MOD_STATIC) printk(" irq moderation: static (%d ints/sec)\n", pAC->DynIrqModInfo.MaxModIntsPerSec); else if (pAC->DynIrqModInfo.IntModTypeSelect == C_INT_MOD_DYNAMIC) printk(" irq moderation: dynamic (%d ints/sec)\n", pAC->DynIrqModInfo.MaxModIntsPerSec); else printk(" irq moderation: disabled\n"); printk(" scatter-gather: %s\n", (dev->features & NETIF_F_SG) ? "enabled" : "disabled"); printk(" tx-checksum: %s\n", (dev->features & NETIF_F_IP_CSUM) ? "enabled" : "disabled"); printk(" rx-checksum: %s\n", pAC->RxPort[Param.Para32[0]].RxCsum ? "enabled" : "disabled"); } else { DoPrintInterfaceChange = SK_TRUE; } if ((Param.Para32[0] != pAC->ActivePort) && (pAC->RlmtNets == 1)) { NewPara.Para32[0] = pAC->ActivePort; NewPara.Para32[1] = Param.Para32[0]; SkEventQueue(pAC, SKGE_DRV, SK_DRV_SWITCH_INTERN, NewPara); } /* Inform the world that link protocol is up. */ netif_carrier_on(dev); break; } case SK_DRV_NET_DOWN: /* SK_U32 Reason */ /* action list 7 */ SK_DBG_MSG(NULL, SK_DBGMOD_DRV, SK_DBGCAT_DRV_EVENT, ("NET DOWN EVENT ")); if (DoPrintInterfaceChange) { printk("%s: network connection down\n", pAC->dev[Param.Para32[1]]->name); } else { DoPrintInterfaceChange = SK_TRUE; } netif_carrier_off(pAC->dev[Param.Para32[1]]); break; case SK_DRV_SWITCH_HARD: /* SK_U32 FromPortIdx SK_U32 ToPortIdx */ SK_DBG_MSG(NULL, SK_DBGMOD_DRV, SK_DBGCAT_DRV_EVENT, ("PORT SWITCH HARD ")); case SK_DRV_SWITCH_SOFT: /* SK_U32 FromPortIdx SK_U32 ToPortIdx */ /* action list 6 */ printk("%s: switching to port %c\n", pAC->dev[0]->name, 'A'+Param.Para32[1]); case SK_DRV_SWITCH_INTERN: /* SK_U32 FromPortIdx SK_U32 ToPortIdx */ FromPort = Param.Para32[0]; ToPort = Param.Para32[1]; SK_DBG_MSG(NULL, SK_DBGMOD_DRV, SK_DBGCAT_DRV_EVENT, ("PORT SWITCH EVENT, From: %d To: %d (Pref %d) ", FromPort, ToPort, pAC->Rlmt.Net[0].PrefPort)); NewPara.Para64 = FromPort; SkPnmiEvent(pAC, IoC, SK_PNMI_EVT_XMAC_RESET, NewPara); NewPara.Para64 = ToPort; SkPnmiEvent(pAC, IoC, SK_PNMI_EVT_XMAC_RESET, NewPara); spin_lock_irqsave( &pAC->TxPort[FromPort][TX_PRIO_LOW].TxDesRingLock, Flags); spin_lock(&pAC->TxPort[ToPort][TX_PRIO_LOW].TxDesRingLock); SkGeStopPort(pAC, IoC, FromPort, SK_STOP_ALL, SK_SOFT_RST); SkGeStopPort(pAC, IoC, ToPort, SK_STOP_ALL, SK_SOFT_RST); spin_unlock(&pAC->TxPort[ToPort][TX_PRIO_LOW].TxDesRingLock); spin_unlock_irqrestore( &pAC->TxPort[FromPort][TX_PRIO_LOW].TxDesRingLock, Flags); ReceiveIrq(pAC, &pAC->RxPort[FromPort], SK_FALSE); /* clears rx ring */ ReceiveIrq(pAC, &pAC->RxPort[ToPort], SK_FALSE); /* clears rx ring */ ClearTxRing(pAC, &pAC->TxPort[FromPort][TX_PRIO_LOW]); ClearTxRing(pAC, &pAC->TxPort[ToPort][TX_PRIO_LOW]); spin_lock_irqsave( &pAC->TxPort[FromPort][TX_PRIO_LOW].TxDesRingLock, Flags); spin_lock(&pAC->TxPort[ToPort][TX_PRIO_LOW].TxDesRingLock); pAC->ActivePort = ToPort; #if 0 SetQueueSizes(pAC); #else /* tschilling: New common function with minimum size check. */ DualNet = SK_FALSE; if (pAC->RlmtNets == 2) { DualNet = SK_TRUE; } if (SkGeInitAssignRamToQueues( pAC, pAC->ActivePort, DualNet)) { spin_unlock(&pAC->TxPort[ToPort][TX_PRIO_LOW].TxDesRingLock); spin_unlock_irqrestore( &pAC->TxPort[FromPort][TX_PRIO_LOW].TxDesRingLock, Flags); printk("SkGeInitAssignRamToQueues failed.\n"); break; } #endif /* tschilling: Handling of return values inserted. */ if (SkGeInitPort(pAC, IoC, FromPort) || SkGeInitPort(pAC, IoC, ToPort)) { printk("%s: SkGeInitPort failed.\n", pAC->dev[0]->name); } if (Event == SK_DRV_SWITCH_SOFT) { SkMacRxTxEnable(pAC, IoC, FromPort); } SkMacRxTxEnable(pAC, IoC, ToPort); SkAddrSwap(pAC, IoC, FromPort, ToPort); SkAddrMcUpdate(pAC, IoC, FromPort); SkAddrMcUpdate(pAC, IoC, ToPort); PortReInitBmu(pAC, FromPort); PortReInitBmu(pAC, ToPort); SkGePollTxD(pAC, IoC, FromPort, SK_TRUE); SkGePollTxD(pAC, IoC, ToPort, SK_TRUE); ClearAndStartRx(pAC, FromPort); ClearAndStartRx(pAC, ToPort); spin_unlock(&pAC->TxPort[ToPort][TX_PRIO_LOW].TxDesRingLock); spin_unlock_irqrestore( &pAC->TxPort[FromPort][TX_PRIO_LOW].TxDesRingLock, Flags); break; case SK_DRV_RLMT_SEND: /* SK_MBUF *pMb */ SK_DBG_MSG(NULL, SK_DBGMOD_DRV, SK_DBGCAT_DRV_EVENT, ("RLS ")); pRlmtMbuf = (SK_MBUF*) Param.pParaPtr; pMsg = (struct sk_buff*) pRlmtMbuf->pOs; skb_put(pMsg, pRlmtMbuf->Length); if (XmitFrame(pAC, &pAC->TxPort[pRlmtMbuf->PortIdx][TX_PRIO_LOW], pMsg) < 0) DEV_KFREE_SKB_ANY(pMsg); break; case SK_DRV_TIMER: if (Param.Para32[0] == SK_DRV_MODERATION_TIMER) { /* ** expiration of the moderation timer implies that ** dynamic moderation is to be applied */ SkDimStartModerationTimer(pAC); SkDimModerate(pAC); if (pAC->DynIrqModInfo.DisplayStats) { SkDimDisplayModerationSettings(pAC); } } else if (Param.Para32[0] == SK_DRV_RX_CLEANUP_TIMER) { /* ** check if we need to check for descriptors which ** haven't been handled the last millisecs */ StartDrvCleanupTimer(pAC); if (pAC->GIni.GIMacsFound == 2) { ReceiveIrq(pAC, &pAC->RxPort[1], SK_FALSE); } ReceiveIrq(pAC, &pAC->RxPort[0], SK_FALSE); } else { printk("Expiration of unknown timer\n"); } break; default: break; } SK_DBG_MSG(NULL, SK_DBGMOD_DRV, SK_DBGCAT_DRV_EVENT, ("END EVENT ")); return (0); } /* SkDrvEvent */ /***************************************************************************** * * SkErrorLog - log errors * * Description: * This function logs errors to the system buffer and to the console * * Returns: * 0 if everything ok * < 0 on error * */ void SkErrorLog( SK_AC *pAC, int ErrClass, int ErrNum, char *pErrorMsg) { char ClassStr[80]; switch (ErrClass) { case SK_ERRCL_OTHER: strcpy(ClassStr, "Other error"); break; case SK_ERRCL_CONFIG: strcpy(ClassStr, "Configuration error"); break; case SK_ERRCL_INIT: strcpy(ClassStr, "Initialization error"); break; case SK_ERRCL_NORES: strcpy(ClassStr, "Out of resources error"); break; case SK_ERRCL_SW: strcpy(ClassStr, "internal Software error"); break; case SK_ERRCL_HW: strcpy(ClassStr, "Hardware failure"); break; case SK_ERRCL_COMM: strcpy(ClassStr, "Communication error"); break; } printk(KERN_INFO "%s: -- ERROR --\n Class: %s\n" " Nr: 0x%x\n Msg: %s\n", pAC->dev[0]->name, ClassStr, ErrNum, pErrorMsg); } /* SkErrorLog */ #ifdef SK_DIAG_SUPPORT /***************************************************************************** * * SkDrvEnterDiagMode - handles DIAG attach request * * Description: * Notify the kernel to NOT access the card any longer due to DIAG * Deinitialize the Card * * Returns: * int */ int SkDrvEnterDiagMode( SK_AC *pAc) /* pointer to adapter context */ { DEV_NET *pNet = netdev_priv(pAc->dev[0]); SK_AC *pAC = pNet->pAC; SK_MEMCPY(&(pAc->PnmiBackup), &(pAc->PnmiStruct), sizeof(SK_PNMI_STRUCT_DATA)); pAC->DiagModeActive = DIAG_ACTIVE; if (pAC->BoardLevel > SK_INIT_DATA) { if (netif_running(pAC->dev[0])) { pAC->WasIfUp[0] = SK_TRUE; pAC->DiagFlowCtrl = SK_TRUE; /* for SkGeClose */ DoPrintInterfaceChange = SK_FALSE; SkDrvDeInitAdapter(pAC, 0); /* performs SkGeClose */ } else { pAC->WasIfUp[0] = SK_FALSE; } if (pNet != netdev_priv(pAC->dev[1])) { pNet = netdev_priv(pAC->dev[1]); if (netif_running(pAC->dev[1])) { pAC->WasIfUp[1] = SK_TRUE; pAC->DiagFlowCtrl = SK_TRUE; /* for SkGeClose */ DoPrintInterfaceChange = SK_FALSE; SkDrvDeInitAdapter(pAC, 1); /* do SkGeClose */ } else { pAC->WasIfUp[1] = SK_FALSE; } } pAC->BoardLevel = SK_INIT_DATA; } return(0); } /***************************************************************************** * * SkDrvLeaveDiagMode - handles DIAG detach request * * Description: * Notify the kernel to may access the card again after use by DIAG * Initialize the Card * * Returns: * int */ int SkDrvLeaveDiagMode( SK_AC *pAc) /* pointer to adapter control context */ { SK_MEMCPY(&(pAc->PnmiStruct), &(pAc->PnmiBackup), sizeof(SK_PNMI_STRUCT_DATA)); pAc->DiagModeActive = DIAG_NOTACTIVE; pAc->Pnmi.DiagAttached = SK_DIAG_IDLE; if (pAc->WasIfUp[0] == SK_TRUE) { pAc->DiagFlowCtrl = SK_TRUE; /* for SkGeClose */ DoPrintInterfaceChange = SK_FALSE; SkDrvInitAdapter(pAc, 0); /* first device */ } if (pAc->WasIfUp[1] == SK_TRUE) { pAc->DiagFlowCtrl = SK_TRUE; /* for SkGeClose */ DoPrintInterfaceChange = SK_FALSE; SkDrvInitAdapter(pAc, 1); /* second device */ } return(0); } /***************************************************************************** * * ParseDeviceNbrFromSlotName - Evaluate PCI device number * * Description: * This function parses the PCI slot name information string and will * retrieve the devcie number out of it. The slot_name maintianed by * linux is in the form of '02:0a.0', whereas the first two characters * represent the bus number in hex (in the sample above this is * pci bus 0x02) and the next two characters the device number (0x0a). * * Returns: * SK_U32: The device number from the PCI slot name */ static SK_U32 ParseDeviceNbrFromSlotName( const char *SlotName) /* pointer to pci slot name eg. '02:0a.0' */ { char *CurrCharPos = (char *) SlotName; int FirstNibble = -1; int SecondNibble = -1; SK_U32 Result = 0; while (*CurrCharPos != '\0') { if (*CurrCharPos == ':') { while (*CurrCharPos != '.') { CurrCharPos++; if ( (*CurrCharPos >= '0') && (*CurrCharPos <= '9')) { if (FirstNibble == -1) { /* dec. value for '0' */ FirstNibble = *CurrCharPos - 48; } else { SecondNibble = *CurrCharPos - 48; } } else if ( (*CurrCharPos >= 'a') && (*CurrCharPos <= 'f') ) { if (FirstNibble == -1) { FirstNibble = *CurrCharPos - 87; } else { SecondNibble = *CurrCharPos - 87; } } else { Result = 0; } } Result = FirstNibble; Result = Result << 4; /* first nibble is higher one */ Result = Result | SecondNibble; } CurrCharPos++; /* next character */ } return (Result); } /**************************************************************************** * * SkDrvDeInitAdapter - deinitialize adapter (this function is only * called if Diag attaches to that card) * * Description: * Close initialized adapter. * * Returns: * 0 - on success * error code - on error */ static int SkDrvDeInitAdapter( SK_AC *pAC, /* pointer to adapter context */ int devNbr) /* what device is to be handled */ { struct SK_NET_DEVICE *dev; dev = pAC->dev[devNbr]; /* On Linux 2.6 the network driver does NOT mess with reference ** counts. The driver MUST be able to be unloaded at any time ** due to the possibility of hotplug. */ if (SkGeClose(dev) != 0) { return (-1); } return (0); } /* SkDrvDeInitAdapter() */ /**************************************************************************** * * SkDrvInitAdapter - Initialize adapter (this function is only * called if Diag deattaches from that card) * * Description: * Close initialized adapter. * * Returns: * 0 - on success * error code - on error */ static int SkDrvInitAdapter( SK_AC *pAC, /* pointer to adapter context */ int devNbr) /* what device is to be handled */ { struct SK_NET_DEVICE *dev; dev = pAC->dev[devNbr]; if (SkGeOpen(dev) != 0) { return (-1); } /* ** Use correct MTU size and indicate to kernel TX queue can be started */ if (SkGeChangeMtu(dev, dev->mtu) != 0) { return (-1); } return (0); } /* SkDrvInitAdapter */ #endif #ifdef DEBUG /****************************************************************************/ /* "debug only" section *****************************************************/ /****************************************************************************/ /***************************************************************************** * * DumpMsg - print a frame * * Description: * This function prints frames to the system logfile/to the console. * * Returns: N/A * */ static void DumpMsg(struct sk_buff *skb, char *str) { int msglen; if (skb == NULL) { printk("DumpMsg(): NULL-Message\n"); return; } if (skb->data == NULL) { printk("DumpMsg(): Message empty\n"); return; } msglen = skb->len; if (msglen > 64) msglen = 64; printk("--- Begin of message from %s , len %d (from %d) ----\n", str, msglen, skb->len); DumpData((char *)skb->data, msglen); printk("------- End of message ---------\n"); } /* DumpMsg */ /***************************************************************************** * * DumpData - print a data area * * Description: * This function prints a area of data to the system logfile/to the * console. * * Returns: N/A * */ static void DumpData(char *p, int size) { register int i; int haddr, addr; char hex_buffer[180]; char asc_buffer[180]; char HEXCHAR[] = "0123456789ABCDEF"; addr = 0; haddr = 0; hex_buffer[0] = 0; asc_buffer[0] = 0; for (i=0; i < size; ) { if (*p >= '0' && *p <='z') asc_buffer[addr] = *p; else asc_buffer[addr] = '.'; addr++; asc_buffer[addr] = 0; hex_buffer[haddr] = HEXCHAR[(*p & 0xf0) >> 4]; haddr++; hex_buffer[haddr] = HEXCHAR[*p & 0x0f]; haddr++; hex_buffer[haddr] = ' '; haddr++; hex_buffer[haddr] = 0; p++; i++; if (i%16 == 0) { printk("%s %s\n", hex_buffer, asc_buffer); addr = 0; haddr = 0; } } } /* DumpData */ /***************************************************************************** * * DumpLong - print a data area as long values * * Description: * This function prints a area of data to the system logfile/to the * console. * * Returns: N/A * */ static void DumpLong(char *pc, int size) { register int i; int haddr, addr; char hex_buffer[180]; char asc_buffer[180]; char HEXCHAR[] = "0123456789ABCDEF"; long *p; int l; addr = 0; haddr = 0; hex_buffer[0] = 0; asc_buffer[0] = 0; p = (long*) pc; for (i=0; i < size; ) { l = (long) *p; hex_buffer[haddr] = HEXCHAR[(l >> 28) & 0xf]; haddr++; hex_buffer[haddr] = HEXCHAR[(l >> 24) & 0xf]; haddr++; hex_buffer[haddr] = HEXCHAR[(l >> 20) & 0xf]; haddr++; hex_buffer[haddr] = HEXCHAR[(l >> 16) & 0xf]; haddr++; hex_buffer[haddr] = HEXCHAR[(l >> 12) & 0xf]; haddr++; hex_buffer[haddr] = HEXCHAR[(l >> 8) & 0xf]; haddr++; hex_buffer[haddr] = HEXCHAR[(l >> 4) & 0xf]; haddr++; hex_buffer[haddr] = HEXCHAR[l & 0x0f]; haddr++; hex_buffer[haddr] = ' '; haddr++; hex_buffer[haddr] = 0; p++; i++; if (i%8 == 0) { printk("%4x %s\n", (i-8)*4, hex_buffer); haddr = 0; } } printk("------------------------\n"); } /* DumpLong */ #endif static int __devinit skge_probe_one(struct pci_dev *pdev, const struct pci_device_id *ent) { SK_AC *pAC; DEV_NET *pNet = NULL; struct net_device *dev = NULL; static int boards_found = 0; int error = -ENODEV; int using_dac = 0; char DeviceStr[80]; if (pci_enable_device(pdev)) goto out; /* Configure DMA attributes. */ if (sizeof(dma_addr_t) > sizeof(u32) && !(error = pci_set_dma_mask(pdev, DMA_64BIT_MASK))) { using_dac = 1; error = pci_set_consistent_dma_mask(pdev, DMA_64BIT_MASK); if (error < 0) { printk(KERN_ERR "sk98lin %s unable to obtain 64 bit DMA " "for consistent allocations\n", pci_name(pdev)); goto out_disable_device; } } else { error = pci_set_dma_mask(pdev, DMA_32BIT_MASK); if (error) { printk(KERN_ERR "sk98lin %s no usable DMA configuration\n", pci_name(pdev)); goto out_disable_device; } } error = -ENOMEM; dev = alloc_etherdev(sizeof(DEV_NET)); if (!dev) { printk(KERN_ERR "sk98lin: unable to allocate etherdev " "structure!\n"); goto out_disable_device; } pNet = netdev_priv(dev); pNet->pAC = kzalloc(sizeof(SK_AC), GFP_KERNEL); if (!pNet->pAC) { printk(KERN_ERR "sk98lin: unable to allocate adapter " "structure!\n"); goto out_free_netdev; } pAC = pNet->pAC; pAC->PciDev = pdev; pAC->dev[0] = dev; pAC->dev[1] = dev; pAC->CheckQueue = SK_FALSE; dev->irq = pdev->irq; error = SkGeInitPCI(pAC); if (error) { printk(KERN_ERR "sk98lin: PCI setup failed: %i\n", error); goto out_free_netdev; } SET_MODULE_OWNER(dev); dev->open = &SkGeOpen; dev->stop = &SkGeClose; dev->hard_start_xmit = &SkGeXmit; dev->get_stats = &SkGeStats; dev->set_multicast_list = &SkGeSetRxMode; dev->set_mac_address = &SkGeSetMacAddr; dev->do_ioctl = &SkGeIoctl; dev->change_mtu = &SkGeChangeMtu; #ifdef CONFIG_NET_POLL_CONTROLLER dev->poll_controller = &SkGePollController; #endif SET_NETDEV_DEV(dev, &pdev->dev); SET_ETHTOOL_OPS(dev, &SkGeEthtoolOps); /* Use only if yukon hardware */ if (pAC->ChipsetType) { #ifdef USE_SK_TX_CHECKSUM dev->features |= NETIF_F_IP_CSUM; #endif #ifdef SK_ZEROCOPY dev->features |= NETIF_F_SG; #endif #ifdef USE_SK_RX_CHECKSUM pAC->RxPort[0].RxCsum = 1; #endif } if (using_dac) dev->features |= NETIF_F_HIGHDMA; pAC->Index = boards_found++; error = SkGeBoardInit(dev, pAC); if (error) goto out_free_netdev; /* Read Adapter name from VPD */ if (ProductStr(pAC, DeviceStr, sizeof(DeviceStr)) != 0) { error = -EIO; printk(KERN_ERR "sk98lin: Could not read VPD data.\n"); goto out_free_resources; } /* Register net device */ error = register_netdev(dev); if (error) { printk(KERN_ERR "sk98lin: Could not register device.\n"); goto out_free_resources; } /* Print adapter specific string from vpd */ printk("%s: %s\n", dev->name, DeviceStr); /* Print configuration settings */ printk(" PrefPort:%c RlmtMode:%s\n", 'A' + pAC->Rlmt.Net[0].Port[pAC->Rlmt.Net[0].PrefPort]->PortNumber, (pAC->RlmtMode==0) ? "Check Link State" : ((pAC->RlmtMode==1) ? "Check Link State" : ((pAC->RlmtMode==3) ? "Check Local Port" : ((pAC->RlmtMode==7) ? "Check Segmentation" : ((pAC->RlmtMode==17) ? "Dual Check Link State" :"Error"))))); SkGeYellowLED(pAC, pAC->IoBase, 1); memcpy(&dev->dev_addr, &pAC->Addr.Net[0].CurrentMacAddress, 6); memcpy(dev->perm_addr, dev->dev_addr, dev->addr_len); pNet->PortNr = 0; pNet->NetNr = 0; boards_found++; pci_set_drvdata(pdev, dev); /* More then one port found */ if ((pAC->GIni.GIMacsFound == 2 ) && (pAC->RlmtNets == 2)) { dev = alloc_etherdev(sizeof(DEV_NET)); if (!dev) { printk(KERN_ERR "sk98lin: unable to allocate etherdev " "structure!\n"); goto single_port; } pNet = netdev_priv(dev); pNet->PortNr = 1; pNet->NetNr = 1; pNet->pAC = pAC; dev->open = &SkGeOpen; dev->stop = &SkGeClose; dev->hard_start_xmit = &SkGeXmit; dev->get_stats = &SkGeStats; dev->set_multicast_list = &SkGeSetRxMode; dev->set_mac_address = &SkGeSetMacAddr; dev->do_ioctl = &SkGeIoctl; dev->change_mtu = &SkGeChangeMtu; SET_NETDEV_DEV(dev, &pdev->dev); SET_ETHTOOL_OPS(dev, &SkGeEthtoolOps); if (pAC->ChipsetType) { #ifdef USE_SK_TX_CHECKSUM dev->features |= NETIF_F_IP_CSUM; #endif #ifdef SK_ZEROCOPY dev->features |= NETIF_F_SG; #endif #ifdef USE_SK_RX_CHECKSUM pAC->RxPort[1].RxCsum = 1; #endif } if (using_dac) dev->features |= NETIF_F_HIGHDMA; error = register_netdev(dev); if (error) { printk(KERN_ERR "sk98lin: Could not register device" " for second port. (%d)\n", error); free_netdev(dev); goto single_port; } pAC->dev[1] = dev; memcpy(&dev->dev_addr, &pAC->Addr.Net[1].CurrentMacAddress, 6); memcpy(dev->perm_addr, dev->dev_addr, dev->addr_len); printk("%s: %s\n", dev->name, DeviceStr); printk(" PrefPort:B RlmtMode:Dual Check Link State\n"); } single_port: /* Save the hardware revision */ pAC->HWRevision = (((pAC->GIni.GIPciHwRev >> 4) & 0x0F)*10) + (pAC->GIni.GIPciHwRev & 0x0F); /* Set driver globals */ pAC->Pnmi.pDriverFileName = DRIVER_FILE_NAME; pAC->Pnmi.pDriverReleaseDate = DRIVER_REL_DATE; memset(&pAC->PnmiBackup, 0, sizeof(SK_PNMI_STRUCT_DATA)); memcpy(&pAC->PnmiBackup, &pAC->PnmiStruct, sizeof(SK_PNMI_STRUCT_DATA)); return 0; out_free_resources: FreeResources(dev); out_free_netdev: free_netdev(dev); out_disable_device: pci_disable_device(pdev); out: return error; } static void __devexit skge_remove_one(struct pci_dev *pdev) { struct net_device *dev = pci_get_drvdata(pdev); DEV_NET *pNet = netdev_priv(dev); SK_AC *pAC = pNet->pAC; struct net_device *otherdev = pAC->dev[1]; unregister_netdev(dev); SkGeYellowLED(pAC, pAC->IoBase, 0); if (pAC->BoardLevel == SK_INIT_RUN) { SK_EVPARA EvPara; unsigned long Flags; /* board is still alive */ spin_lock_irqsave(&pAC->SlowPathLock, Flags); EvPara.Para32[0] = 0; EvPara.Para32[1] = -1; SkEventQueue(pAC, SKGE_RLMT, SK_RLMT_STOP, EvPara); EvPara.Para32[0] = 1; EvPara.Para32[1] = -1; SkEventQueue(pAC, SKGE_RLMT, SK_RLMT_STOP, EvPara); SkEventDispatcher(pAC, pAC->IoBase); /* disable interrupts */ SK_OUT32(pAC->IoBase, B0_IMSK, 0); SkGeDeInit(pAC, pAC->IoBase); spin_unlock_irqrestore(&pAC->SlowPathLock, Flags); pAC->BoardLevel = SK_INIT_DATA; /* We do NOT check here, if IRQ was pending, of course*/ } if (pAC->BoardLevel == SK_INIT_IO) { /* board is still alive */ SkGeDeInit(pAC, pAC->IoBase); pAC->BoardLevel = SK_INIT_DATA; } FreeResources(dev); free_netdev(dev); if (otherdev != dev) free_netdev(otherdev); kfree(pAC); } #ifdef CONFIG_PM static int skge_suspend(struct pci_dev *pdev, pm_message_t state) { struct net_device *dev = pci_get_drvdata(pdev); DEV_NET *pNet = netdev_priv(dev); SK_AC *pAC = pNet->pAC; struct net_device *otherdev = pAC->dev[1]; if (netif_running(dev)) { netif_carrier_off(dev); DoPrintInterfaceChange = SK_FALSE; SkDrvDeInitAdapter(pAC, 0); /* performs SkGeClose */ netif_device_detach(dev); } if (otherdev != dev) { if (netif_running(otherdev)) { netif_carrier_off(otherdev); DoPrintInterfaceChange = SK_FALSE; SkDrvDeInitAdapter(pAC, 1); /* performs SkGeClose */ netif_device_detach(otherdev); } } pci_save_state(pdev); pci_enable_wake(pdev, pci_choose_state(pdev, state), 0); if (pAC->AllocFlag & SK_ALLOC_IRQ) { free_irq(dev->irq, dev); } pci_disable_device(pdev); pci_set_power_state(pdev, pci_choose_state(pdev, state)); return 0; } static int skge_resume(struct pci_dev *pdev) { struct net_device *dev = pci_get_drvdata(pdev); DEV_NET *pNet = netdev_priv(dev); SK_AC *pAC = pNet->pAC; struct net_device *otherdev = pAC->dev[1]; int ret; pci_set_power_state(pdev, PCI_D0); pci_restore_state(pdev); pci_enable_device(pdev); pci_set_master(pdev); if (pAC->GIni.GIMacsFound == 2) ret = request_irq(dev->irq, SkGeIsr, SA_SHIRQ, "sk98lin", dev); else ret = request_irq(dev->irq, SkGeIsrOnePort, SA_SHIRQ, "sk98lin", dev); if (ret) { printk(KERN_WARNING "sk98lin: unable to acquire IRQ %d\n", dev->irq); pAC->AllocFlag &= ~SK_ALLOC_IRQ; dev->irq = 0; pci_disable_device(pdev); return -EBUSY; } netif_device_attach(dev); if (netif_running(dev)) { DoPrintInterfaceChange = SK_FALSE; SkDrvInitAdapter(pAC, 0); /* first device */ } if (otherdev != dev) { netif_device_attach(otherdev); if (netif_running(otherdev)) { DoPrintInterfaceChange = SK_FALSE; SkDrvInitAdapter(pAC, 1); /* second device */ } } return 0; } #else #define skge_suspend NULL #define skge_resume NULL #endif static struct pci_device_id skge_pci_tbl[] = { { PCI_VENDOR_ID_3COM, 0x1700, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0 }, { PCI_VENDOR_ID_3COM, 0x80eb, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0 }, { PCI_VENDOR_ID_SYSKONNECT, 0x4300, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0 }, { PCI_VENDOR_ID_SYSKONNECT, 0x4320, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0 }, /* DLink card does not have valid VPD so this driver gags * { PCI_VENDOR_ID_DLINK, 0x4c00, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0 }, */ { PCI_VENDOR_ID_MARVELL, 0x4320, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0 }, { PCI_VENDOR_ID_MARVELL, 0x5005, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0 }, { PCI_VENDOR_ID_CNET, 0x434e, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0 }, { PCI_VENDOR_ID_LINKSYS, 0x1032, PCI_ANY_ID, 0x0015, }, { PCI_VENDOR_ID_LINKSYS, 0x1064, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0 }, { 0 } }; MODULE_DEVICE_TABLE(pci, skge_pci_tbl); static struct pci_driver skge_driver = { .name = "sk98lin", .id_table = skge_pci_tbl, .probe = skge_probe_one, .remove = __devexit_p(skge_remove_one), .suspend = skge_suspend, .resume = skge_resume, }; static int __init skge_init(void) { return pci_module_init(&skge_driver); } static void __exit skge_exit(void) { pci_unregister_driver(&skge_driver); } module_init(skge_init); module_exit(skge_exit);