| /****************************************************************************** |
| * |
| * Name: skge.c |
| * Project: GEnesis, PCI Gigabit Ethernet Adapter |
| * Version: $Revision: 1.46 $ |
| * Date: $Date: 2003/02/25 14:16:36 $ |
| * Purpose: The main driver source module |
| * |
| ******************************************************************************/ |
| |
| /****************************************************************************** |
| * |
| * (C)Copyright 1998-2003 SysKonnect GmbH. |
| * |
| * Driver for SysKonnect Gigabit Ethernet Server Adapters: |
| * |
| * SK-9871 (single link 1000Base-ZX) |
| * SK-9872 (dual link 1000Base-ZX) |
| * SK-9861 (single link 1000Base-SX, VF45 Volition Plug) |
| * SK-9862 (dual link 1000Base-SX, VF45 Volition Plug) |
| * SK-9841 (single link 1000Base-LX) |
| * SK-9842 (dual link 1000Base-LX) |
| * SK-9843 (single link 1000Base-SX) |
| * SK-9844 (dual link 1000Base-SX) |
| * SK-9821 (single link 1000Base-T) |
| * SK-9822 (dual link 1000Base-T) |
| * SK-9881 (single link 1000Base-SX V2 LC) |
| * SK-9871 (single link 1000Base-ZX V2) |
| * SK-9861 (single link 1000Base-SX V2, VF45 Volition Plug) |
| * SK-9841 (single link 1000Base-LX V2) |
| * SK-9843 (single link 1000Base-SX V2) |
| * SK-9821 (single link 1000Base-T V2) |
| * |
| * 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. |
| * |
| ******************************************************************************/ |
| |
| /****************************************************************************** |
| * |
| * History: |
| * |
| * $Log: skge.c,v $ |
| * Revision 1.46 2003/02/25 14:16:36 mlindner |
| * Fix: Copyright statement |
| * |
| * Revision 1.45 2003/02/25 13:25:55 mlindner |
| * Add: Performance improvements |
| * Add: Support for various vendors |
| * Fix: Init function |
| * |
| * Revision 1.44 2003/01/09 09:25:26 mlindner |
| * Fix: Remove useless init_module/cleanup_module forward declarations |
| * |
| * Revision 1.43 2002/11/29 08:42:41 mlindner |
| * Fix: Boot message |
| * |
| * Revision 1.42 2002/11/28 13:30:23 mlindner |
| * Add: New frame check |
| * |
| * Revision 1.41 2002/11/27 13:55:18 mlindner |
| * Fix: Drop wrong csum packets |
| * Fix: Initialize proc_entry after hw check |
| * |
| * Revision 1.40 2002/10/31 07:50:37 tschilli |
| * Function SkGeInitAssignRamToQueues() from common module inserted. |
| * Autonegotiation is set to ON for all adapters. |
| * LinkSpeedUsed is used in link up status report. |
| * Role parameter will show up for 1000 Mbps links only. |
| * GetConfiguration() inserted after init level 1 in SkGeChangeMtu(). |
| * All return values of SkGeInit() and SkGeInitPort() are checked. |
| * |
| * Revision 1.39 2002/10/02 12:56:05 mlindner |
| * Add: Support for Yukon |
| * Add: Support for ZEROCOPY, scatter-gather and hw checksum |
| * Add: New transmit ring function (use SG and TCP/UDP hardware checksumming) |
| * Add: New init function |
| * Add: Speed check and setup |
| * Add: Merge source for kernel 2.2.x and 2.4.x |
| * Add: Opcode check for tcp |
| * Add: Frame length check |
| * Fix: Transmit complete interrupt |
| * Fix: Interrupt moderation |
| * |
| * Revision 1.29.2.13 2002/01/14 12:44:52 mlindner |
| * Fix: Rlmt modes |
| * |
| * Revision 1.29.2.12 2001/12/07 12:06:18 mlindner |
| * Fix: malloc -> slab changes |
| * |
| * Revision 1.29.2.11 2001/12/06 15:19:20 mlindner |
| * Add: DMA attributes |
| * Fix: Module initialisation |
| * Fix: pci_map_single and pci_unmap_single replaced |
| * |
| * Revision 1.29.2.10 2001/12/06 09:56:50 mlindner |
| * Corrected some printk's |
| * |
| * Revision 1.29.2.9 2001/09/05 12:15:34 mlindner |
| * Add: LBFO Changes |
| * Fix: Counter Errors (Jumbo == to long errors) |
| * Fix: Changed pAC->PciDev declaration |
| * Fix: too short counters |
| * |
| * Revision 1.29.2.8 2001/06/25 12:10:44 mlindner |
| * fix: ReceiveIrq() changed. |
| * |
| * Revision 1.29.2.7 2001/06/25 08:07:05 mlindner |
| * fix: RLMT locking in ReceiveIrq() changed. |
| * |
| * Revision 1.29.2.6 2001/05/21 07:59:29 mlindner |
| * fix: MTU init problems |
| * |
| * Revision 1.29.2.5 2001/05/08 11:25:08 mlindner |
| * fix: removed VLAN error message |
| * |
| * Revision 1.29.2.4 2001/05/04 13:31:43 gklug |
| * fix: do not handle eth_copy on bad fragments received. |
| * |
| * Revision 1.29.2.3 2001/04/23 08:06:43 mlindner |
| * Fix: error handling |
| * |
| * Revision 1.29.2.2 2001/03/15 12:04:54 mlindner |
| * Fixed memory problem |
| * |
| * Revision 1.29.2.1 2001/03/12 16:41:44 mlindner |
| * add: procfs function |
| * add: dual-net function |
| * add: RLMT networks |
| * add: extended PNMI features |
| * |
| * Kernel 2.4.x specific: |
| * Revision 1.xx 2000/09/12 13:31:56 cgoos |
| * Fixed missign "dev=NULL in skge_probe. |
| * Added counting for jumbo frames (corrects error statistic). |
| * Removed VLAN tag check (enables VLAN support). |
| * |
| * Kernel 2.2.x specific: |
| * Revision 1.29 2000/02/21 13:31:56 cgoos |
| * Fixed "unused" warning for UltraSPARC change. |
| * |
| * Partially kernel 2.2.x specific: |
| * Revision 1.28 2000/02/21 10:32:36 cgoos |
| * Added fixes for UltraSPARC. |
| * Now printing RlmtMode and PrefPort setting at startup. |
| * Changed XmitFrame return value. |
| * Fixed rx checksum calculation for BIG ENDIAN systems. |
| * Fixed rx jumbo frames counted as ierrors. |
| * |
| * |
| * Revision 1.27 1999/11/25 09:06:28 cgoos |
| * Changed base_addr to unsigned long. |
| * |
| * Revision 1.26 1999/11/22 13:29:16 cgoos |
| * Changed license header to GPL. |
| * Changes for inclusion in linux kernel (2.2.13). |
| * Removed 2.0.x defines. |
| * Changed SkGeProbe to skge_probe. |
| * Added checks in SkGeIoctl. |
| * |
| * Revision 1.25 1999/10/07 14:47:52 cgoos |
| * Changed 984x to 98xx. |
| * |
| * Revision 1.24 1999/09/30 07:21:01 cgoos |
| * Removed SK_RLMT_SLOW_LOOKAHEAD option. |
| * Giving spanning tree packets also to OS now. |
| * |
| * Revision 1.23 1999/09/29 07:36:50 cgoos |
| * Changed assignment for IsBc/IsMc. |
| * |
| * Revision 1.22 1999/09/28 12:57:09 cgoos |
| * Added CheckQueue also to Single-Port-ISR. |
| * |
| * Revision 1.21 1999/09/28 12:42:41 cgoos |
| * Changed parameter strings for RlmtMode. |
| * |
| * Revision 1.20 1999/09/28 12:37:57 cgoos |
| * Added CheckQueue for fast delivery of RLMT frames. |
| * |
| * Revision 1.19 1999/09/16 07:57:25 cgoos |
| * Copperfield changes. |
| * |
| * Revision 1.18 1999/09/03 13:06:30 cgoos |
| * Fixed RlmtMode=CheckSeg bug: wrong DEV_KFREE_SKB in RLMT_SEND caused |
| * double allocated skb's. |
| * FrameStat in ReceiveIrq was accessed via wrong Rxd. |
| * Queue size for async. standby Tx queue was zero. |
| * FillRxLimit of 0 could cause problems with ReQueue, changed to 1. |
| * Removed debug output of checksum statistic. |
| * |
| * Revision 1.17 1999/08/11 13:55:27 cgoos |
| * Transmit descriptor polling was not reenabled after SkGePortInit. |
| * |
| * Revision 1.16 1999/07/27 15:17:29 cgoos |
| * Added some "\n" in output strings (removed while debuging...). |
| * |
| * Revision 1.15 1999/07/23 12:09:30 cgoos |
| * Performance optimization, rx checksumming, large frame support. |
| * |
| * Revision 1.14 1999/07/14 11:26:27 cgoos |
| * Removed Link LED settings (now in RLMT). |
| * Added status output at NET UP. |
| * Fixed SMP problems with Tx and SWITCH running in parallel. |
| * Fixed return code problem at RLMT_SEND event. |
| * |
| * Revision 1.13 1999/04/07 10:11:42 cgoos |
| * Fixed Single Port problems. |
| * Fixed Multi-Adapter problems. |
| * Always display startup string. |
| * |
| * Revision 1.12 1999/03/29 12:26:37 cgoos |
| * Reversed locking to fine granularity. |
| * Fixed skb double alloc problem (caused by incorrect xmit return code). |
| * Enhanced function descriptions. |
| * |
| * Revision 1.11 1999/03/15 13:10:51 cgoos |
| * Changed device identifier in output string to ethX. |
| * |
| * Revision 1.10 1999/03/15 12:12:34 cgoos |
| * Changed copyright notice. |
| * |
| * Revision 1.9 1999/03/15 12:10:17 cgoos |
| * Changed locking to one driver lock. |
| * Added check of SK_AC-size (for consistency with library). |
| * |
| * Revision 1.8 1999/03/08 11:44:02 cgoos |
| * Fixed missing dev->tbusy in SkGeXmit. |
| * Changed large frame (jumbo) buffer number. |
| * Added copying of short frames. |
| * |
| * Revision 1.7 1999/03/04 13:26:57 cgoos |
| * Fixed spinlock calls for SMP. |
| * |
| * Revision 1.6 1999/03/02 09:53:51 cgoos |
| * Added descriptor revertion for big endian machines. |
| * |
| * Revision 1.5 1999/03/01 08:50:59 cgoos |
| * Fixed SkGeChangeMtu. |
| * Fixed pci config space accesses. |
| * |
| * Revision 1.4 1999/02/18 15:48:44 cgoos |
| * Corrected some printk's. |
| * |
| * Revision 1.3 1999/02/18 12:45:55 cgoos |
| * Changed SK_MAX_CARD_PARAM to default 16 |
| * |
| * Revision 1.2 1999/02/18 10:55:32 cgoos |
| * Removed SkGeDrvTimeStamp function. |
| * Printing "ethX:" before adapter type at adapter init. |
| * |
| * |
| * 10-Feb-1999 cg Created, based on Linux' acenic.c, 3c59x.c and |
| * SysKonnects GEnesis Solaris driver |
| * |
| ******************************************************************************/ |
| |
| /****************************************************************************** |
| * |
| * 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/version.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> |
| * <asm/byteorder.h> |
| * <asm/bitops.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/skcsum.h" |
| * "h/skrlmt.h" |
| * |
| ******************************************************************************/ |
| |
| #include <config.h> |
| |
| #ifdef CONFIG_SK98 |
| |
| #include "h/skversion.h" |
| #if 0 |
| #include <linux/module.h> |
| #include <linux/init.h> |
| #include <linux/proc_fs.h> |
| #endif |
| #include "h/skdrv1st.h" |
| #include "h/skdrv2nd.h" |
| |
| |
| /* defines ******************************************************************/ |
| /* for debuging on x86 only */ |
| /* #define BREAKPOINT() asm(" int $3"); */ |
| |
| /* use the scatter-gather functionality with sendfile() */ |
| #if 0 |
| #define SK_ZEROCOPY |
| #endif |
| |
| /* use of a transmit complete interrupt */ |
| #define USE_TX_COMPLETE |
| |
| /* use interrupt moderation (for tx complete only) */ |
| #define USE_INT_MOD |
| #define INTS_PER_SEC 1000 |
| |
| /* |
| * 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 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) |
| |
| /* 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); |
| |
| #if 0 |
| static void SkGeIsr(int irq, void *dev_id, struct pt_regs *ptregs); |
| static void 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); |
| #else |
| void SkGeIsr(int irq, void *dev_id, struct pt_regs *ptregs); |
| void SkGeIsrOnePort(int irq, void *dev_id, struct pt_regs *ptregs); |
| int SkGeOpen(struct SK_NET_DEVICE *dev); |
| int SkGeClose(struct SK_NET_DEVICE *dev); |
| int SkGeXmit(struct sk_buff *skb, struct SK_NET_DEVICE *dev); |
| #endif |
| static void GetConfiguration(SK_AC*); |
| static void ProductStr(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*); |
| #if 0 |
| static void ReceiveIrq(SK_AC*, RX_PORT*, SK_BOOL); |
| #else |
| void ReceiveIrq(SK_AC*, RX_PORT*, SK_BOOL); |
| #endif |
| 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*); |
| #if 0 |
| static void SetQueueSizes(SK_AC *pAC); |
| |
| static int SkGeChangeMtu(struct SK_NET_DEVICE *dev, int new_mtu); |
| #endif |
| static void PortReInitBmu(SK_AC*, int); |
| #if 0 |
| static int SkGeIocMib(DEV_NET*, unsigned int, int); |
| static int XmitFrameSG(SK_AC*, TX_PORT*, struct sk_buff*); |
| #endif |
| |
| /*Extern */ |
| |
| /* external Proc function */ |
| extern int proc_read( |
| char *buffer, |
| char **buffer_location, |
| off_t offset, |
| int buffer_length, |
| int *eof, |
| void *data); |
| |
| #ifdef DEBUG |
| static void DumpMsg(struct sk_buff*, char*); |
| static void DumpData(char*, int); |
| static void DumpLong(char*, int); |
| #endif |
| void dump_frag( SK_U8 *data, int length); |
| |
| /* global variables *********************************************************/ |
| #if 0 |
| static const char *BootString = BOOT_STRING; |
| #endif |
| struct SK_NET_DEVICE *SkGeRootDev = NULL; |
| static int probed __initdata = 0; |
| |
| /* local variables **********************************************************/ |
| static uintptr_t TxQueueAddr[SK_MAX_MACS][2] = {{0x680, 0x600},{0x780, 0x700}}; |
| static uintptr_t RxQueueAddr[SK_MAX_MACS] = {0x400, 0x480}; |
| |
| |
| /* local variables **********************************************************/ |
| const char SK_Root_Dir_entry[8]; |
| |
| #if 0 |
| static struct proc_dir_entry *pSkRootDir; |
| #endif |
| |
| |
| static struct pci_device_id supported[] = { |
| {PCI_VENDOR_ID_3COM, 0x1700}, |
| {PCI_VENDOR_ID_SYSKONNECT, PCI_DEVICE_ID_SYSKONNECT_GE}, |
| {PCI_VENDOR_ID_SYSKONNECT, PCI_DEVICE_ID_SYSKONNECT_YU}, |
| {} |
| }; |
| |
| |
| /***************************************************************************** |
| * |
| * skge_probe - find all SK-98xx adapters |
| * |
| * Description: |
| * This function scans the PCI bus for SK-98xx adapters. Resources for |
| * each adapter are allocated and the adapter is brought into Init 1 |
| * state. |
| * |
| * Returns: |
| * 0, if everything is ok |
| * !=0, on error |
| */ |
| #if 0 |
| static int __init skge_probe (void) |
| #else |
| int skge_probe (struct eth_device ** ret_dev) |
| #endif |
| { |
| #if 0 |
| int proc_root_initialized = 0; |
| #endif |
| int boards_found = 0; |
| #if 0 |
| int vendor_flag = SK_FALSE; |
| #endif |
| SK_AC *pAC; |
| DEV_NET *pNet = NULL; |
| #if 0 |
| struct proc_dir_entry *pProcFile; |
| struct pci_dev *pdev = NULL; |
| unsigned long base_address; |
| #else |
| u32 base_address; |
| #endif |
| struct SK_NET_DEVICE *dev = NULL; |
| #if 0 |
| SK_BOOL DeviceFound = SK_FALSE; |
| #endif |
| SK_BOOL BootStringCount = SK_FALSE; |
| #if 1 |
| pci_dev_t devno; |
| #endif |
| |
| if (probed) |
| return -ENODEV; |
| probed++; |
| |
| if (!pci_present()) /* is PCI support present? */ |
| return -ENODEV; |
| |
| #if 0 |
| while((pdev = pci_find_class(PCI_CLASS_NETWORK_ETHERNET << 8, pdev))) |
| #else |
| while((devno = pci_find_devices (supported, boards_found)) >= 0) |
| #endif |
| { |
| |
| dev = NULL; |
| pNet = NULL; |
| |
| |
| #if 0 |
| SK_PCI_ISCOMPLIANT(vendor_flag, pdev); |
| if (!vendor_flag) |
| continue; |
| #endif |
| |
| /* if ((pdev->vendor != PCI_VENDOR_ID_SYSKONNECT) && |
| ((pdev->device != PCI_DEVICE_ID_SYSKONNECT_GE) || |
| (pdev->device != PCI_DEVICE_ID_SYSKONNECT_YU))){ |
| continue; |
| } |
| */ |
| #if 0 |
| /* Configure DMA attributes. */ |
| if (pci_set_dma_mask(pdev, (u64) 0xffffffffffffffff) && |
| pci_set_dma_mask(pdev, (u64) 0xffffffff)) |
| continue; |
| #endif |
| |
| |
| #if 0 |
| if ((dev = init_etherdev(dev, sizeof(DEV_NET))) == NULL) { |
| printk(KERN_ERR "Unable to allocate etherdev " |
| "structure!\n"); |
| break; |
| } |
| #else |
| dev = malloc (sizeof *dev); |
| memset(dev, 0, sizeof(*dev)); |
| dev->priv = malloc(sizeof(DEV_NET)); |
| #endif |
| |
| if (dev->priv == NULL) { |
| printk(KERN_ERR "Unable to allocate adapter " |
| "structure!\n"); |
| break; |
| } |
| |
| pNet = dev->priv; |
| pNet->pAC = kmalloc(sizeof(SK_AC), GFP_KERNEL); |
| if (pNet->pAC == NULL){ |
| kfree(dev->priv); |
| printk(KERN_ERR "Unable to allocate adapter " |
| "structure!\n"); |
| break; |
| } |
| |
| /* Print message */ |
| if (!BootStringCount) { |
| /* set display flag to TRUE so that */ |
| /* we only display this string ONCE */ |
| BootStringCount = SK_TRUE; |
| #ifdef SK98_INFO |
| printk("%s\n", BootString); |
| #endif |
| } |
| |
| memset(pNet->pAC, 0, sizeof(SK_AC)); |
| pAC = pNet->pAC; |
| #if 0 |
| pAC->PciDev = pdev; |
| pAC->PciDevId = pdev->device; |
| pAC->dev[0] = dev; |
| pAC->dev[1] = dev; |
| #else |
| pAC->PciDev = devno; |
| ret_dev[0] = pAC->dev[0] = dev; |
| ret_dev[1] = pAC->dev[1] = dev; |
| #endif |
| sprintf(pAC->Name, "SysKonnect SK-98xx"); |
| pAC->CheckQueue = SK_FALSE; |
| |
| pNet->Mtu = 1500; |
| pNet->Up = 0; |
| #if 0 |
| dev->irq = pdev->irq; |
| |
| 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; |
| dev->flags &= ~IFF_RUNNING; |
| #endif |
| |
| #ifdef SK_ZEROCOPY |
| if (pAC->GIni.GIChipId == CHIP_ID_YUKON) { |
| /* Use only if yukon hardware */ |
| /* SK and ZEROCOPY - fly baby... */ |
| dev->features |= NETIF_F_SG | NETIF_F_IP_CSUM; |
| } |
| #endif |
| |
| #if 0 |
| /* |
| * Dummy value. |
| */ |
| dev->base_addr = 42; |
| pci_set_master(pdev); |
| |
| pci_set_master(pdev); |
| base_address = pci_resource_start (pdev, 0); |
| #else |
| pci_write_config_dword(devno, |
| PCI_COMMAND, |
| PCI_COMMAND_MEMORY | PCI_COMMAND_MASTER); |
| pci_read_config_dword (devno, PCI_BASE_ADDRESS_0, |
| &base_address); |
| #endif |
| |
| #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. |
| */ |
| #if 0 |
| pAC->IoBase = (char*)ioremap(base_address, 0x4000); |
| #else |
| pAC->IoBase = (char*)pci_mem_to_phys(devno, base_address); |
| #endif |
| |
| if (!pAC->IoBase){ |
| printk(KERN_ERR "%s: Unable to map I/O register, " |
| "SK 98xx No. %i will be disabled.\n", |
| dev->name, boards_found); |
| kfree(dev); |
| break; |
| } |
| |
| pAC->Index = boards_found; |
| if (SkGeBoardInit(dev, pAC)) { |
| FreeResources(dev); |
| kfree(dev); |
| continue; |
| } |
| |
| #if 0 |
| memcpy((caddr_t) &dev->dev_addr, |
| (caddr_t) &pAC->Addr.Net[0].CurrentMacAddress, 6); |
| #else |
| memcpy((caddr_t) &dev->enetaddr, |
| (caddr_t) &pAC->Addr.Net[0].CurrentMacAddress, 6); |
| #endif |
| |
| #if 0 |
| /* First adapter... Create proc and print message */ |
| if (!DeviceFound) { |
| DeviceFound = SK_TRUE; |
| SK_MEMCPY(&SK_Root_Dir_entry, BootString, |
| sizeof(SK_Root_Dir_entry) - 1); |
| |
| /*Create proc (directory)*/ |
| if(!proc_root_initialized) { |
| pSkRootDir = create_proc_entry(SK_Root_Dir_entry, |
| S_IFDIR | S_IWUSR | S_IRUGO | S_IXUGO, proc_net); |
| proc_root_initialized = 1; |
| } |
| |
| pSkRootDir->owner = THIS_MODULE; |
| } |
| |
| |
| /* Create proc file */ |
| pProcFile = create_proc_entry(dev->name, |
| S_IFREG | S_IXUSR | S_IWGRP | S_IROTH, |
| pSkRootDir); |
| |
| |
| pProcFile->read_proc = proc_read; |
| pProcFile->write_proc = NULL; |
| pProcFile->nlink = 1; |
| pProcFile->size = sizeof(dev->name + 1); |
| pProcFile->data = (void *)pProcFile; |
| #endif |
| |
| pNet->PortNr = 0; |
| pNet->NetNr = 0; |
| |
| #ifdef SK_ZEROCOPY |
| if (pAC->GIni.GIChipId == CHIP_ID_YUKON) { |
| /* SG and ZEROCOPY - fly baby... */ |
| dev->features |= NETIF_F_SG | NETIF_F_IP_CSUM; |
| } |
| #endif |
| |
| boards_found++; |
| |
| /* More then one port found */ |
| if ((pAC->GIni.GIMacsFound == 2 ) && (pAC->RlmtNets == 2)) { |
| #if 0 |
| if ((dev = init_etherdev(NULL, sizeof(DEV_NET))) == 0) { |
| printk(KERN_ERR "Unable to allocate etherdev " |
| "structure!\n"); |
| break; |
| } |
| #else |
| dev = malloc (sizeof *dev); |
| memset(dev, 0, sizeof(*dev)); |
| dev->priv = malloc(sizeof(DEV_NET)); |
| #endif |
| |
| pAC->dev[1] = dev; |
| pNet = dev->priv; |
| pNet->PortNr = 1; |
| pNet->NetNr = 1; |
| pNet->pAC = pAC; |
| pNet->Mtu = 1500; |
| pNet->Up = 0; |
| |
| #if 0 |
| 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; |
| dev->flags &= ~IFF_RUNNING; |
| #endif |
| |
| #ifdef SK_ZEROCOPY |
| if (pAC->GIni.GIChipId == CHIP_ID_YUKON) { |
| /* SG and ZEROCOPY - fly baby... */ |
| dev->features |= NETIF_F_SG | NETIF_F_IP_CSUM; |
| } |
| #endif |
| |
| #if 0 |
| pProcFile = create_proc_entry(dev->name, |
| S_IFREG | S_IXUSR | S_IWGRP | S_IROTH, |
| pSkRootDir); |
| |
| |
| pProcFile->read_proc = proc_read; |
| pProcFile->write_proc = NULL; |
| pProcFile->nlink = 1; |
| pProcFile->size = sizeof(dev->name + 1); |
| pProcFile->data = (void *)pProcFile; |
| #endif |
| |
| #if 0 |
| memcpy((caddr_t) &dev->dev_addr, |
| (caddr_t) &pAC->Addr.Net[1].CurrentMacAddress, 6); |
| #else |
| memcpy((caddr_t) &dev->enetaddr, |
| (caddr_t) &pAC->Addr.Net[1].CurrentMacAddress, 6); |
| #endif |
| |
| printk("%s: %s\n", dev->name, pAC->DeviceStr); |
| printk(" PrefPort:B RlmtMode:Dual Check Link State\n"); |
| |
| } |
| |
| |
| /* Save the hardware revision */ |
| pAC->HWRevision = (((pAC->GIni.GIPciHwRev >> 4) & 0x0F)*10) + |
| (pAC->GIni.GIPciHwRev & 0x0F); |
| |
| /* |
| * This is bollocks, but we need to tell the net-init |
| * code that it shall go for the next device. |
| */ |
| #if 0 |
| #ifndef MODULE |
| dev->base_addr = 0; |
| #endif |
| #endif |
| } |
| |
| /* |
| * If we're at this point we're going through skge_probe() for |
| * the first time. Return success (0) if we've initialized 1 |
| * or more boards. Otherwise, return failure (-ENODEV). |
| */ |
| |
| return boards_found; |
| } /* skge_probe */ |
| |
| |
| /***************************************************************************** |
| * |
| * 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; |
| |
| if (dev->priv) { |
| pNet = (DEV_NET*) dev->priv; |
| pAC = pNet->pAC; |
| AllocFlag = pAC->AllocFlag; |
| #if 0 |
| if (AllocFlag & SK_ALLOC_IRQ) { |
| free_irq(dev->irq, dev); |
| } |
| if (pAC->IoBase) { |
| iounmap(pAC->IoBase); |
| } |
| #endif |
| if (pAC->pDescrMem) { |
| BoardFreeMem(pAC); |
| } |
| } |
| |
| } /* FreeResources */ |
| |
| #if 0 |
| MODULE_AUTHOR("Mirko Lindner <mlindner@syskonnect.de>"); |
| MODULE_DESCRIPTION("SysKonnect SK-NET Gigabit Ethernet SK-98xx driver"); |
| MODULE_LICENSE("GPL"); |
| MODULE_PARM(Speed_A, "1-" __MODULE_STRING(SK_MAX_CARD_PARAM) "s"); |
| MODULE_PARM(Speed_B, "1-" __MODULE_STRING(SK_MAX_CARD_PARAM) "s"); |
| MODULE_PARM(AutoNeg_A, "1-" __MODULE_STRING(SK_MAX_CARD_PARAM) "s"); |
| MODULE_PARM(AutoNeg_B, "1-" __MODULE_STRING(SK_MAX_CARD_PARAM) "s"); |
| MODULE_PARM(DupCap_A, "1-" __MODULE_STRING(SK_MAX_CARD_PARAM) "s"); |
| MODULE_PARM(DupCap_B, "1-" __MODULE_STRING(SK_MAX_CARD_PARAM) "s"); |
| MODULE_PARM(FlowCtrl_A, "1-" __MODULE_STRING(SK_MAX_CARD_PARAM) "s"); |
| MODULE_PARM(FlowCtrl_B, "1-" __MODULE_STRING(SK_MAX_CARD_PARAM) "s"); |
| MODULE_PARM(Role_A, "1-" __MODULE_STRING(SK_MAX_CARD_PARAM) "s"); |
| MODULE_PARM(Role_B, "1-" __MODULE_STRING(SK_MAX_CARD_PARAM) "s"); |
| MODULE_PARM(PrefPort, "1-" __MODULE_STRING(SK_MAX_CARD_PARAM) "s"); |
| MODULE_PARM(RlmtMode, "1-" __MODULE_STRING(SK_MAX_CARD_PARAM) "s"); |
| /* not used, just there because every driver should have them: */ |
| MODULE_PARM(options, "1-" __MODULE_STRING(SK_MAX_CARD_PARAM) "i"); |
| MODULE_PARM(debug, "i"); |
| #endif |
| |
| |
| #ifdef LINK_SPEED_A |
| static char *Speed_A[SK_MAX_CARD_PARAM] = LINK_SPEED_A; |
| #else |
| static char *Speed_A[SK_MAX_CARD_PARAM] = {"", }; |
| #endif |
| |
| #ifdef LINK_SPEED_B |
| static char *Speed_B[SK_MAX_CARD_PARAM] = LINK_SPEED_B; |
| #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 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 |
| |
| #if 0 |
| static int debug = 0; /* not used */ |
| static int options[SK_MAX_CARD_PARAM] = {0, }; /* not used */ |
| |
| |
| /***************************************************************************** |
| * |
| * skge_init_module - module initialization function |
| * |
| * Description: |
| * Very simple, only call skge_probe and return approriate result. |
| * |
| * Returns: |
| * 0, if everything is ok |
| * !=0, on error |
| */ |
| static int __init skge_init_module(void) |
| { |
| int cards; |
| SkGeRootDev = NULL; |
| |
| /* just to avoid warnings ... */ |
| debug = 0; |
| options[0] = 0; |
| |
| cards = skge_probe(); |
| if (cards == 0) { |
| printk("sk98lin: No adapter found.\n"); |
| } |
| return cards ? 0 : -ENODEV; |
| } /* skge_init_module */ |
| |
| |
| /***************************************************************************** |
| * |
| * skge_cleanup_module - module unload function |
| * |
| * Description: |
| * Disable adapter if it is still running, free resources, |
| * free device struct. |
| * |
| * Returns: N/A |
| */ |
| static void __exit skge_cleanup_module(void) |
| { |
| DEV_NET *pNet; |
| SK_AC *pAC; |
| struct SK_NET_DEVICE *next; |
| unsigned long Flags; |
| SK_EVPARA EvPara; |
| |
| while (SkGeRootDev) { |
| pNet = (DEV_NET*) SkGeRootDev->priv; |
| pAC = pNet->pAC; |
| next = pAC->Next; |
| |
| netif_stop_queue(SkGeRootDev); |
| SkGeYellowLED(pAC, pAC->IoBase, 0); |
| |
| if(pAC->BoardLevel == 2) { |
| /* 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 = 0; |
| /* We do NOT check here, if IRQ was pending, of course*/ |
| } |
| |
| if(pAC->BoardLevel == 1) { |
| /* board is still alive */ |
| SkGeDeInit(pAC, pAC->IoBase); |
| pAC->BoardLevel = 0; |
| } |
| |
| if ((pAC->GIni.GIMacsFound == 2) && pAC->RlmtNets == 2){ |
| unregister_netdev(pAC->dev[1]); |
| kfree(pAC->dev[1]); |
| } |
| |
| FreeResources(SkGeRootDev); |
| |
| SkGeRootDev->get_stats = NULL; |
| /* |
| * otherwise unregister_netdev calls get_stats with |
| * invalid IO ... :-( |
| */ |
| unregister_netdev(SkGeRootDev); |
| kfree(SkGeRootDev); |
| kfree(pAC); |
| SkGeRootDev = next; |
| } |
| |
| /* clear proc-dir */ |
| remove_proc_entry(pSkRootDir->name, proc_net); |
| |
| } /* skge_cleanup_module */ |
| |
| module_init(skge_init_module); |
| module_exit(skge_cleanup_module); |
| #endif |
| |
| |
| /***************************************************************************** |
| * |
| * 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 __init 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; |
| #if 0 |
| int Ret; /* return code of request_irq */ |
| #endif |
| 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); |
| |
| /* level 0 init common modules here */ |
| |
| spin_lock_irqsave(&pAC->SlowPathLock, Flags); |
| /* Does a RESET on board ...*/ |
| if (SkGeInit(pAC, pAC->IoBase, 0) != 0) { |
| printk("HWInit (0) failed.\n"); |
| spin_unlock_irqrestore(&pAC->SlowPathLock, Flags); |
| return(-EAGAIN); |
| } |
| SkI2cInit( pAC, pAC->IoBase, 0); |
| SkEventInit(pAC, pAC->IoBase, 0); |
| SkPnmiInit( pAC, pAC->IoBase, 0); |
| SkAddrInit( pAC, pAC->IoBase, 0); |
| SkRlmtInit( pAC, pAC->IoBase, 0); |
| SkTimerInit(pAC, pAC->IoBase, 0); |
| |
| pAC->BoardLevel = 0; |
| 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, 1) != 0) { |
| printk("HWInit (1) failed.\n"); |
| spin_unlock_irqrestore(&pAC->SlowPathLock, Flags); |
| return(-EAGAIN); |
| } |
| SkI2cInit( pAC, pAC->IoBase, 1); |
| SkEventInit(pAC, pAC->IoBase, 1); |
| SkPnmiInit( pAC, pAC->IoBase, 1); |
| SkAddrInit( pAC, pAC->IoBase, 1); |
| SkRlmtInit( pAC, pAC->IoBase, 1); |
| SkTimerInit(pAC, pAC->IoBase, 1); |
| |
| GetConfiguration(pAC); |
| if (pAC->RlmtNets == 2) { |
| pAC->GIni.GIPortUsage = SK_MUL_LINK; |
| } |
| |
| pAC->BoardLevel = 1; |
| spin_unlock_irqrestore(&pAC->SlowPathLock, Flags); |
| |
| #if 0 |
| if (pAC->GIni.GIMacsFound == 2) { |
| Ret = request_irq(dev->irq, SkGeIsr, SA_SHIRQ, pAC->Name, dev); |
| } else if (pAC->GIni.GIMacsFound == 1) { |
| Ret = request_irq(dev->irq, SkGeIsrOnePort, SA_SHIRQ, |
| pAC->Name, dev); |
| } else { |
| printk(KERN_WARNING "%s: Illegal number of ports: %d\n", |
| dev->name, pAC->GIni.GIMacsFound); |
| return -EAGAIN; |
| } |
| |
| if (Ret) { |
| printk(KERN_WARNING "%s: Requested IRQ %d is busy.\n", |
| dev->name, dev->irq); |
| return -EAGAIN; |
| } |
| #endif |
| 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(-EAGAIN); |
| } |
| |
| SkCsSetReceiveFlags(pAC, |
| SKCS_PROTO_IP | SKCS_PROTO_TCP | SKCS_PROTO_UDP, |
| &pAC->CsOfs1, &pAC->CsOfs2, 0); |
| pAC->CsOfs = (pAC->CsOfs2 << 16) | pAC->CsOfs1; |
| |
| BoardInitMem(pAC); |
| #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)) { |
| BoardFreeMem(pAC); |
| printk("SkGeInitAssignRamToQueues failed.\n"); |
| return(-EAGAIN); |
| } |
| #endif |
| |
| /* Print adapter specific string from vpd */ |
| ProductStr(pAC); |
| #ifdef SK98_INFO |
| printk("%s: %s\n", dev->name, pAC->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"))))); |
| #endif |
| |
| SkGeYellowLED(pAC, pAC->IoBase, 1); |
| |
| /* |
| * Register the device here |
| */ |
| pAC->Next = SkGeRootDev; |
| SkGeRootDev = dev; |
| |
| 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 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 void BoardInitMem( |
| SK_AC *pAC) /* pointer to adapter context */ |
| { |
| 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; |
| pDescr->TcpSumStarts = pAC->CsOfs; |
| |
| /* 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]+ |
| TX_Q_CUR_DESCR_LOW, |
| (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]+ |
| TX_Q_DESCR_HIGH, |
| (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]+RX_Q_CUR_DESCR_LOW, |
| (uint32_t)(((caddr_t)(pAC->RxPort[PortIndex].pRxdRingHead) - |
| pAC->RxPort[PortIndex].pRxDescrRing + |
| pAC->RxPort[PortIndex].VRxDescrRing) & 0xFFFFFFFF)); |
| SK_OUT32(pAC->IoBase, RxQueueAddr[PortIndex]+RX_Q_DESCR_HIGH, |
| (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 |
| * |
| */ |
| #if 0 |
| static void SkGeIsr(int irq, void *dev_id, struct pt_regs *ptregs) |
| #else |
| void SkGeIsr(int irq, void *dev_id, struct pt_regs *ptregs) |
| #endif |
| { |
| 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 = (DEV_NET*) dev->priv; |
| pAC = pNet->pAC; |
| |
| /* |
| * Check and process if its our interrupt |
| */ |
| SK_IN32(pAC->IoBase, B0_SP_ISRC, &IntSrc); |
| if (IntSrc == 0) { |
| return; |
| } |
| |
| while (((IntSrc & IRQ_MASK) & ~SPECIAL_IRQS) != 0) { |
| #if 0 /* software irq currently not used */ |
| if (IntSrc & IRQ_SW) { |
| SK_DBG_MSG(NULL, SK_DBGMOD_DRV, |
| SK_DBGCAT_DRV_INT_SRC, |
| ("Software IRQ\n")); |
| } |
| #endif |
| if (IntSrc & IRQ_EOF_RX1) { |
| 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 & IRQ_EOF_RX2) { |
| 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 & IRQ_EOF_AS_TX1) { |
| 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 & IRQ_EOF_AS_TX2) { |
| 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 & IRQ_EOF_SY_TX1) { |
| 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 & IRQ_EOF_SY_TX2) { |
| 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 & IRQ_EOF_RX1) |
| ClearAndStartRx(pAC, 0); |
| if (IntSrc & IRQ_EOF_RX2) |
| ClearAndStartRx(pAC, 1); |
| #ifdef USE_TX_COMPLETE /* only if tx complete interrupt used */ |
| if (IntSrc & IRQ_EOF_AS_TX1) |
| ClearTxIrq(pAC, 0, TX_PRIO_LOW); |
| if (IntSrc & IRQ_EOF_AS_TX2) |
| ClearTxIrq(pAC, 1, TX_PRIO_LOW); |
| #endif |
| SK_IN32(pAC->IoBase, B0_ISRC, &IntSrc); |
| } /* while (IntSrc & IRQ_MASK != 0) */ |
| |
| 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) |
| */ |
| |
| 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, IRQ_MASK); |
| |
| return; |
| } /* 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 |
| * |
| */ |
| #if 0 |
| static void SkGeIsrOnePort(int irq, void *dev_id, struct pt_regs *ptregs) |
| #else |
| void SkGeIsrOnePort(int irq, void *dev_id, struct pt_regs *ptregs) |
| #endif |
| { |
| 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 = (DEV_NET*) dev->priv; |
| pAC = pNet->pAC; |
| |
| /* |
| * Check and process if its our interrupt |
| */ |
| SK_IN32(pAC->IoBase, B0_SP_ISRC, &IntSrc); |
| if (IntSrc == 0) { |
| return; |
| } |
| |
| while (((IntSrc & IRQ_MASK) & ~SPECIAL_IRQS) != 0) { |
| #if 0 /* software irq currently not used */ |
| if (IntSrc & IRQ_SW) { |
| SK_DBG_MSG(NULL, SK_DBGMOD_DRV, |
| SK_DBGCAT_DRV_INT_SRC, |
| ("Software IRQ\n")); |
| } |
| #endif |
| if (IntSrc & IRQ_EOF_RX1) { |
| 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 & IRQ_EOF_AS_TX1) { |
| 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 & IRQ_EOF_SY_TX1) { |
| 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 & IRQ_EOF_RX1) |
| ClearAndStartRx(pAC, 0); |
| #ifdef USE_TX_COMPLETE /* only if tx complete interrupt used */ |
| if (IntSrc & IRQ_EOF_AS_TX1) |
| ClearTxIrq(pAC, 0, TX_PRIO_LOW); |
| #endif |
| SK_IN32(pAC->IoBase, B0_ISRC, &IntSrc); |
| } /* while (IntSrc & IRQ_MASK != 0) */ |
| |
| 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) |
| */ |
| ReceiveIrq(pAC, &pAC->RxPort[0], SK_TRUE); |
| |
| /* IRQ is processed - Enable IRQs again*/ |
| SK_OUT32(pAC->IoBase, B0_IMSK, IRQ_MASK); |
| |
| return; |
| } /* SkGeIsrOnePort */ |
| |
| |
| /**************************************************************************** |
| * |
| * 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 |
| */ |
| #if 0 |
| static int SkGeOpen( |
| #else |
| int SkGeOpen( |
| #endif |
| 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 = (DEV_NET*) dev->priv; |
| pAC = pNet->pAC; |
| |
| SK_DBG_MSG(NULL, SK_DBGMOD_DRV, SK_DBGCAT_DRV_ENTRY, |
| ("SkGeOpen: pAC=0x%lX:\n", (unsigned long)pAC)); |
| |
| if (pAC->BoardLevel == 0) { |
| /* level 1 init common modules here */ |
| if (SkGeInit(pAC, pAC->IoBase, 1) != 0) { |
| printk("%s: HWInit (1) failed.\n", pAC->dev[pNet->PortNr]->name); |
| return (-1); |
| } |
| SkI2cInit (pAC, pAC->IoBase, 1); |
| SkEventInit (pAC, pAC->IoBase, 1); |
| SkPnmiInit (pAC, pAC->IoBase, 1); |
| SkAddrInit (pAC, pAC->IoBase, 1); |
| SkRlmtInit (pAC, pAC->IoBase, 1); |
| SkTimerInit (pAC, pAC->IoBase, 1); |
| pAC->BoardLevel = 1; |
| } |
| |
| if (pAC->BoardLevel != 2) { |
| /* tschilling: Level 2 init modules here, check return value. */ |
| if (SkGeInit(pAC, pAC->IoBase, 2) != 0) { |
| printk("%s: HWInit (2) failed.\n", pAC->dev[pNet->PortNr]->name); |
| return (-1); |
| } |
| SkI2cInit (pAC, pAC->IoBase, 2); |
| SkEventInit (pAC, pAC->IoBase, 2); |
| SkPnmiInit (pAC, pAC->IoBase, 2); |
| SkAddrInit (pAC, pAC->IoBase, 2); |
| SkRlmtInit (pAC, pAC->IoBase, 2); |
| SkTimerInit (pAC, pAC->IoBase, 2); |
| pAC->BoardLevel = 2; |
| } |
| |
| 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); |
| |
| #ifdef USE_INT_MOD |
| /* moderate only TX complete interrupts (these are not time critical) */ |
| #define IRQ_MOD_MASK (IRQ_EOF_AS_TX1 | IRQ_EOF_AS_TX2) |
| { |
| unsigned long ModBase; |
| ModBase = 53125000 / INTS_PER_SEC; |
| SK_OUT32(pAC->IoBase, B2_IRQM_INI, ModBase); |
| SK_OUT32(pAC->IoBase, B2_IRQM_MSK, IRQ_MOD_MASK); |
| SK_OUT32(pAC->IoBase, B2_IRQM_CTRL, TIM_START); |
| } |
| #endif |
| |
| /* enable Interrupts */ |
| SK_OUT32(pAC->IoBase, B0_IMSK, IRQ_MASK); |
| 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++; |
| pNet->Up = 1; |
| |
| MOD_INC_USE_COUNT; |
| |
| 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 |
| */ |
| #if 0 |
| static int SkGeClose( |
| #else |
| int SkGeClose( |
| #endif |
| struct SK_NET_DEVICE *dev) |
| { |
| DEV_NET *pNet; |
| SK_AC *pAC; |
| |
| unsigned long Flags; /* for spin lock */ |
| int i; |
| int PortIdx; |
| SK_EVPARA EvPara; |
| |
| netif_stop_queue(dev); |
| pNet = (DEV_NET*) dev->priv; |
| pAC = pNet->pAC; |
| |
| if (pAC->RlmtNets == 1) |
| PortIdx = pAC->ActivePort; |
| else |
| PortIdx = pNet->NetNr; |
| |
| SK_DBG_MSG(NULL, SK_DBGMOD_DRV, SK_DBGCAT_DRV_ENTRY, |
| ("SkGeClose: pAC=0x%lX ", (unsigned long)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 = 0; |
| 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); |
| 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 ")); |
| |
| pAC->MaxPorts--; |
| pNet->Up = 0; |
| MOD_DEC_USE_COUNT; |
| |
| 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) !!! |
| */ |
| #if 0 |
| static int SkGeXmit(struct sk_buff *skb, struct SK_NET_DEVICE *dev) |
| #else |
| int SkGeXmit(struct sk_buff *skb, struct SK_NET_DEVICE *dev) |
| #endif |
| { |
| DEV_NET *pNet; |
| SK_AC *pAC; |
| int Rc; /* return code of XmitFrame */ |
| |
| pNet = (DEV_NET*) dev->priv; |
| pAC = pNet->pAC; |
| |
| #if 0 |
| if ((!skb_shinfo(skb)->nr_frags) || |
| #else |
| if (1 || |
| #endif |
| (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 { |
| #if 0 |
| /* 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); |
| #endif |
| } |
| |
| /* 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); |
| |
| #if 0 |
| dev->trans_start = jiffies; |
| #endif |
| 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 */ |
| unsigned long Flags; |
| SK_U64 PhysAddr; |
| int BytesSend; |
| |
| 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 */ |
| 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")); |
| /* this message can not be sent now */ |
| /* 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); |
| } |
| } |
| /* advance head counter behind descriptor needed for this frame */ |
| pTxd = pTxPort->pTxdRingHead; |
| pTxPort->pTxdRingHead = pTxd->pNextTxd; |
| pTxPort->TxdRingFree--; |
| /* the needed descriptor is reserved now */ |
| |
| /* |
| * everything allocated ok, so add buffer to descriptor |
| */ |
| |
| #ifdef SK_DUMP_TX |
| DumpMsg(pMessage, "XmitFrame"); |
| #endif |
| |
| /* set up descriptor and CONTROL dword */ |
| #if 0 |
| PhysAddr = (SK_U64) pci_map_page(pAC->PciDev, |
| virt_to_page(pMessage->data), |
| ((unsigned long) pMessage->data & |
| ~PAGE_MASK), |
| pMessage->len, |
| PCI_DMA_TODEVICE); |
| #else |
| PhysAddr = (SK_U64) pci_phys_to_mem(pAC->PciDev, (u32) pMessage->data); |
| #endif |
| pTxd->VDataLow = (SK_U32) (PhysAddr & 0xffffffff); |
| pTxd->VDataHigh = (SK_U32) (PhysAddr >> 32); |
| pTxd->pMBuf = pMessage; |
| pTxd->TBControl = TX_CTRL_OWN_BMU | TX_CTRL_STF | |
| TX_CTRL_CHECK_DEFAULT | TX_CTRL_SOFTWARE | |
| #ifdef USE_TX_COMPLETE |
| TX_CTRL_EOF | TX_CTRL_EOF_IRQ | pMessage->len; |
| #else |
| TX_CTRL_EOF | pMessage->len; |
| #endif |
| |
| if ((pTxPort->pTxdRingPrev->TBControl & TX_CTRL_OWN_BMU) == 0) { |
| /* previous descriptor already done, so give tx start cmd */ |
| /* StartTx(pAC, pTxPort->HwAddr); */ |
| SK_OUT8(pTxPort->HwAddr, TX_Q_CTRL, TX_Q_CTRL_START); |
| } |
| pTxPort->pTxdRingPrev = pTxd; |
| |
| |
| BytesSend = pMessage->len; |
| spin_unlock_irqrestore(&pTxPort->TxDesRingLock, Flags); |
| /* after releasing the lock, the skb may be immidiately freed */ |
| 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) |
| */ |
| #if 0 |
| 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 */ |
| { |
| |
| int i; |
| int BytesSend; |
| int hlength; |
| int protocol; |
| skb_frag_t *sk_frag; |
| TXD *pTxd; |
| TXD *pTxdFst; |
| TXD *pTxdLst; |
| SK_U64 PhysAddr; |
| unsigned long Flags; |
| |
| 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; |
| protocol = 0; |
| |
| /* map first fragment (header) */ |
| 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); |
| |
| /* HW checksum? */ |
| if (pMessage->ip_summed == CHECKSUM_HW) { |
| pTxd->TBControl = TX_CTRL_STF | |
| TX_CTRL_ST_FWD | |
| skb_headlen(pMessage); |
| |
| /* We have to use the opcode for tcp here because the opcode for |
| udp is not working in the hardware yet (revision 2.0)*/ |
| protocol = ((SK_U8)pMessage->data[23] & 0xf); |
| if ((protocol == 17) && (pAC->GIni.GIChipRev != 0)) |
| pTxd->TBControl |= BMU_UDP_CHECK; |
| else |
| pTxd->TBControl |= BMU_TCP_CHECK ; |
| |
| hlength = ((SK_U8)pMessage->data[14] & 0xf) * 4; |
| pTxd->TcpSumOfs = 0; /* PH-Checksum already claculated */ |
| pTxd->TcpSumSt = 14+hlength+16; |
| pTxd->TcpSumWr = 14+hlength; |
| |
| } else { |
| pTxd->TBControl = TX_CTRL_CHECK_DEFAULT | |
| TX_CTRL_SOFTWARE | |
| TX_CTRL_STF | |
| skb_headlen(pMessage); |
| } |
| |
| pTxd = pTxd->pNextTxd; |
| pTxPort->TxdRingFree--; |
| BytesSend += skb_headlen(pMessage); |
| |
| |
| /* Map SG fragments */ |
| for (i = 0; i < skb_shinfo(pMessage)->nr_frags; i++) { |
| sk_frag = &skb_shinfo(pMessage)->frags[i]; |
| |
| /* 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; |
| |
| /* HW checksum */ |
| if (pMessage->ip_summed == CHECKSUM_HW) { |
| pTxd->TBControl = TX_CTRL_OWN_BMU | |
| TX_CTRL_SOFTWARE | |
| TX_CTRL_ST_FWD; |
| |
| /* 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 ((protocol == 17) && (pAC->GIni.GIChipRev != 0)) |
| pTxd->TBControl |= BMU_UDP_CHECK ; |
| else |
| pTxd->TBControl |= BMU_TCP_CHECK ; |
| |
| } else { |
| pTxd->TBControl = TX_CTRL_CHECK_DEFAULT | |
| TX_CTRL_SOFTWARE | |
| TX_CTRL_OWN_BMU; |
| } |
| |
| /* Last fragment */ |
| if( (i+1) == skb_shinfo(pMessage)->nr_frags ) { |
| #ifdef USE_TX_COMPLETE |
| pTxd->TBControl |= TX_CTRL_EOF | |
| TX_CTRL_EOF_IRQ | |
| sk_frag->size; |
| #else |
| pTxd->TBControl |= TX_CTRL_EOF | |
| sk_frag->size; |
| #endif |
| pTxdFst->TBControl |= TX_CTRL_OWN_BMU | |
| TX_CTRL_SOFTWARE; |
| |
| } else { |
| pTxd->TBControl |= sk_frag->size; |
| } |
| pTxdLst = pTxd; |
| pTxd = pTxd->pNextTxd; |
| pTxPort->TxdRingFree--; |
| BytesSend += sk_frag->size; |
| } |
| |
| if ((pTxPort->pTxdRingPrev->TBControl & TX_CTRL_OWN_BMU) == 0) { |
| /* previous descriptor already done, so give tx start cmd */ |
| /* StartTx(pAC, pTxPort->HwAddr); */ |
| SK_OUT8(pTxPort->HwAddr, TX_Q_CTRL, TX_Q_CTRL_START); |
| } |
| |
| pTxPort->pTxdRingPrev = pTxdLst; |
| pTxPort->pTxdRingHead = pTxd; |
| |
| spin_unlock_irqrestore(&pTxPort->TxDesRingLock, Flags); |
| |
| if (pTxPort->TxdRingFree > 0) |
| return (BytesSend); |
| else |
| return (0); |
| } |
| #endif |
| |
| |
| void dump_frag( SK_U8 *data, int length) |
| { |
| int i; |
| |
| printk("Length: %d\n", length); |
| for( i=0; i < length; i++ ) { |
| printk(" %02x", (SK_U8)*(data + i) ); |
| if( !((i+1) % 20) ) |
| printk("\n"); |
| } |
| printk("\n\n"); |
| |
| } |
| |
| |
| /***************************************************************************** |
| * |
| * 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 TX_CTRL_SOFTWARE bit not set in start frame |
| * or TX_CTRL_OWN_BMU bit set in any frame |
| */ |
| while (1) { |
| Control = pTxd->TBControl; |
| if ((Control & TX_CTRL_SOFTWARE) == 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 & TX_CTRL_OWN_BMU) { |
| pTxPort->pTxdRingTail = pTxd; |
| if (pTxPort->TxdRingFree > 0) { |
| netif_wake_queue(pAC->dev[pTxPort->PortIndex]); |
| } |
| return; |
| } |
| |
| /* release the DMA mapping */ |
| 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 & TX_CTRL_EOF) |
| DEV_KFREE_SKB_ANY(pTxd->pMBuf); /* free message */ |
| |
| pTxPort->TxdRingFree++; |
| pTxd->TBControl &= ~TX_CTRL_SOFTWARE; |
| 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; |
| #if 0 |
| 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); |
| #else |
| PhysAddr = (SK_U64) pci_phys_to_mem(pAC->PciDev, (u32)pMsgBlock->data); |
| #endif |
| pRxd->VDataLow = (SK_U32) (PhysAddr & 0xffffffff); |
| pRxd->VDataHigh = (SK_U32) (PhysAddr >> 32); |
| pRxd->pMBuf = pMsgBlock; |
| pRxd->RBControl = RX_CTRL_OWN_BMU | RX_CTRL_STF | |
| RX_CTRL_EOF_IRQ | RX_CTRL_CHECK_CSUM | 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 = RX_CTRL_OWN_BMU | RX_CTRL_STF | |
| RX_CTRL_EOF_IRQ | RX_CTRL_CHECK_CSUM | 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 |
| */ |
| #if 0 |
| static void ReceiveIrq( |
| #else |
| void ReceiveIrq( |
| #endif |
| 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; |
| unsigned short Csum1; |
| unsigned short Csum2; |
| unsigned short Type; |
| #if 0 |
| int Result; |
| #endif |
| SK_U64 PhysAddr; |
| |
| rx_start: |
| /* do forever; exit if RX_CTRL_OWN_BMU 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 & RX_CTRL_OWN_BMU) != 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; |
| } |
| |
| /* get length of frame and check it */ |
| FrameLength = Control & RX_CTRL_LEN_MASK; |
| if (FrameLength > pAC->RxBufSize) { |
| goto rx_failed; |
| } |
| |
| /* check for STF and EOF */ |
| if ((Control & (RX_CTRL_STF | RX_CTRL_EOF)) != |
| (RX_CTRL_STF | RX_CTRL_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 & RX_CTRL_STAT_VALID) != RX_CTRL_STAT_VALID || |
| (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)); |
| |
| PhysAddr = ((SK_U64) pRxd->VDataHigh) << (SK_U64)32; |
| PhysAddr |= (SK_U64) pRxd->VDataLow; |
| pci_dma_sync_single(pAC->PciDev, |
| (dma_addr_t) PhysAddr, |
| FrameLength, |
| PCI_DMA_FROMDEVICE); |
| 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(pAC->PciDev, |
| (dma_addr_t) PhysAddr, |
| FrameLength, |
| PCI_DMA_FROMDEVICE); |
| eth_copy_and_sum(pNewMsg, pMsg->data, |
| FrameLength, 0); |
| 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); |
| /* hardware checksum */ |
| Type = ntohs(*((short*)&pMsg->data[12])); |
| if (Type == 0x800) { |
| Csum1=le16_to_cpu(pRxd->TcpSums & 0xffff); |
| Csum2=le16_to_cpu((pRxd->TcpSums >> 16) & 0xffff); |
| #if 0 |
| if ((((Csum1 & 0xfffe) && (Csum2 & 0xfffe)) && |
| (pAC->GIni.GIChipId == CHIP_ID_GENESIS)) || |
| (pAC->GIni.GIChipId == CHIP_ID_YUKON)) { |
| Result = SkCsGetReceiveInfo(pAC, |
| &pMsg->data[14], |
| Csum1, Csum2, pRxPort->PortIndex); |
| if (Result == |
| SKCS_STATUS_IP_FRAGMENT || |
| Result == |
| SKCS_STATUS_IP_CSUM_OK || |
| Result == |
| SKCS_STATUS_TCP_CSUM_OK || |
| Result == |
| SKCS_STATUS_UDP_CSUM_OK) { |
| pMsg->ip_summed = |
| CHECKSUM_UNNECESSARY; |
| } else { |
| SK_DBG_MSG(NULL, SK_DBGMOD_DRV, |
| SK_DBGCAT_DRV_RX_PROGRESS, |
| ("skge: CRC error. Frame dropped!\n")); |
| goto rx_failed; |
| } |
| }/* checksumControl calculation valid */ |
| #endif |
| } /* IP frame */ |
| } /* frame > SK_COPY_TRESHOLD */ |
| |
| 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); |
| |
| #if 0 |
| 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 |
| NetReceive(pMsg->data, pMsg->len); |
| dev_kfree_skb_any(pMsg); |
| #endif |
| } |
| 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 0 |
| 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 |
| if (0) { |
| } |
| #endif |
| 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 > 0) { |
| 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]+RX_Q_CTRL, |
| RX_Q_CTRL_START | RX_Q_CTRL_CLR_I_EOF); |
| } /* 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]+TX_Q_CTRL, |
| TX_Q_CTRL_CLR_I_EOF); |
| } /* 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 &= RX_CTRL_OWN_BMU; |
| 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 &= ~TX_CTRL_OWN_BMU; |
| pTxd = pTxd->pNextTxd; |
| } |
| FreeTxDescriptors(pAC, pTxPort); |
| spin_unlock_irqrestore(&pTxPort->TxDesRingLock, Flags); |
| } /* ClearTxRing */ |
| |
| |
| #if 0 |
| /***************************************************************************** |
| * |
| * SetQueueSizes - configure the sizes of rx and tx queues |
| * |
| * Description: |
| * This function assigns the sizes for active and passive port |
| * to the appropriate HWinit structure variables. |
| * The passive port(s) get standard values, all remaining RAM |
| * is given to the active port. |
| * The queue sizes are in kbyte and must be multiple of 8. |
| * The limits for the number of buffers filled into the rx rings |
| * is also set in this routine. |
| * |
| * Returns: |
| * none |
| */ |
| static void SetQueueSizes( |
| SK_AC *pAC) /* pointer to the adapter context */ |
| { |
| int StandbyRam; /* adapter RAM used for a standby port */ |
| int RemainingRam; /* adapter RAM available for the active port */ |
| int RxRam; /* RAM used for the active port receive queue */ |
| int i; /* loop counter */ |
| |
| if (pAC->RlmtNets == 1) { |
| StandbyRam = SK_RLMT_STANDBY_QRXSIZE + SK_RLMT_STANDBY_QXASIZE + |
| SK_RLMT_STANDBY_QXSSIZE; |
| RemainingRam = pAC->GIni.GIRamSize - |
| (pAC->GIni.GIMacsFound-1) * StandbyRam; |
| for (i=0; i<pAC->GIni.GIMacsFound; i++) { |
| pAC->GIni.GP[i].PRxQSize = SK_RLMT_STANDBY_QRXSIZE; |
| pAC->GIni.GP[i].PXSQSize = SK_RLMT_STANDBY_QXSSIZE; |
| pAC->GIni.GP[i].PXAQSize = SK_RLMT_STANDBY_QXASIZE; |
| } |
| RxRam = (RemainingRam * 8 / 10) & ~7; |
| pAC->GIni.GP[pAC->ActivePort].PRxQSize = RxRam; |
| pAC->GIni.GP[pAC->ActivePort].PXSQSize = 0; |
| pAC->GIni.GP[pAC->ActivePort].PXAQSize = |
| (RemainingRam - RxRam) & ~7; |
| pAC->RxQueueSize = RxRam; |
| pAC->TxSQueueSize = 0; |
| pAC->TxAQueueSize = (RemainingRam - RxRam) & ~7; |
| SK_DBG_MSG(NULL, SK_DBGMOD_DRV, SK_DBGCAT_DRV_ENTRY, |
| ("queue sizes settings - rx:%d txA:%d txS:%d\n", |
| pAC->RxQueueSize,pAC->TxAQueueSize, pAC->TxSQueueSize)); |
| } else { |
| RemainingRam = pAC->GIni.GIRamSize/pAC->GIni.GIMacsFound; |
| RxRam = (RemainingRam * 8 / 10) & ~7; |
| for (i=0; i<pAC->GIni.GIMacsFound; i++) { |
| pAC->GIni.GP[i].PRxQSize = RxRam; |
| pAC->GIni.GP[i].PXSQSize = 0; |
| pAC->GIni.GP[i].PXAQSize = (RemainingRam - RxRam) & ~7; |
| } |
| |
| pAC->RxQueueSize = RxRam; |
| pAC->TxSQueueSize = 0; |
| pAC->TxAQueueSize = (RemainingRam - RxRam) & ~7; |
| } |
| for (i=0; i<SK_MAX_MACS; i++) { |
| pAC->RxPort[i].RxFillLimit = pAC->RxDescrPerRing; |
| } |
| |
| if (pAC->RlmtNets == 2) { |
| for (i=0; i<pAC->GIni.GIMacsFound; i++) { |
| pAC->RxPort[i].RxFillLimit = pAC->RxDescrPerRing - 100; |
| } |
| } else { |
| for (i=0; i<pAC->GIni.GIMacsFound; i++) { |
| pAC->RxPort[i].RxFillLimit = pAC->RxDescrPerRing - 100; |
| } |
| /* |
| * Do not set the Limit to 0, because this could cause |
| * wrap around with ReQueue'ed buffers (a buffer could |
| * be requeued in the same position, made accessable to |
| * the hardware, and the hardware could change its |
| * contents! |
| */ |
| pAC->RxPort[pAC->ActivePort].RxFillLimit = 1; |
| } |
| |
| #ifdef DEBUG |
| for (i=0; i<pAC->GIni.GIMacsFound; i++) { |
| SK_DBG_MSG(NULL, SK_DBGMOD_DRV, SK_DBGCAT_DRV_TX_PROGRESS, |
| ("i: %d, RxQSize: %d, PXSQsize: %d, PXAQSize: %d\n", |
| i, |
| pAC->GIni.GP[i].PRxQSize, |
| pAC->GIni.GP[i].PXSQSize, |
| pAC->GIni.GP[i].PXAQSize)); |
| } |
| #endif |
| } /* SetQueueSizes */ |
| |
| |
| /***************************************************************************** |
| * |
| * 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 = (DEV_NET*) dev->priv; |
| 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 */ |
| #endif |
| |
| |
| /***************************************************************************** |
| * |
| * 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 |
| */ |
| #if 0 |
| 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 = (DEV_NET*) dev->priv; |
| 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; |
| DEV_NET *pOtherNet; |
| 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 = (DEV_NET*) dev->priv; |
| pAC = pNet->pAC; |
| |
| if ((NewMtu < 68) || (NewMtu > SK_JUMBO_MTU)) { |
| return -EINVAL; |
| } |
| |
| if(pAC->BoardLevel != 2) { |
| return -EINVAL; |
| } |
| |
| pNet->Mtu = NewMtu; |
| pOtherNet = (DEV_NET*)pAC->dev[1 - pNet->NetNr]->priv; |
| if ((pOtherNet->Mtu > 1500) && (NewMtu <= 1500) && (pOtherNet->Up==1)) { |
| return(0); |
| } |
| |
| EvPara.Para32[0] = pNet->NetNr; |
| EvPara.Para32[1] = -1; |
| |
| pAC->RxBufSize = NewMtu + 32; |
| dev->mtu = NewMtu; |
| |
| SK_DBG_MSG(NULL, SK_DBGMOD_DRV, SK_DBGCAT_DRV_ENTRY, |
| ("New MTU: %d\n", NewMtu)); |
| |
| /* prevent reconfiguration while changing the MTU */ |
| |
| /* disable interrupts */ |
| SK_OUT32(pAC->IoBase, B0_IMSK, 0); |
| spin_lock_irqsave(&pAC->SlowPathLock, Flags); |
| |
| /* Found more than one port */ |
| if ((pAC->GIni.GIMacsFound == 2 ) && |
| (pAC->RlmtNets == 2)) { |
| /* Stop both ports */ |
| EvPara.Para32[0] = 0; |
| 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); |
| } |
| |
| SkEventDispatcher(pAC, pAC->IoBase); |
| |
| for (i=0; i<pAC->GIni.GIMacsFound; i++) { |
| spin_lock_irqsave( |
| &pAC->TxPort[i][TX_PRIO_LOW].TxDesRingLock, Flags); |
| netif_stop_queue(pAC->dev[i]); |
| |
| } |
| |
| /* |
| * adjust number of rx buffers allocated |
| */ |
| if (NewMtu > 1500) { |
| /* use less rx buffers */ |
| for (i=0; i<pAC->GIni.GIMacsFound; i++) { |
| /* Found more than one port */ |
| if ((pAC->GIni.GIMacsFound == 2 ) && |
| (pAC->RlmtNets == 2)) { |
| pAC->RxPort[i].RxFillLimit = |
| pAC->RxDescrPerRing - 100; |
| } else { |
| if (i == pAC->ActivePort) |
| pAC->RxPort[i].RxFillLimit = |
| pAC->RxDescrPerRing - 100; |
| else |
| pAC->RxPort[i].RxFillLimit = |
| pAC->RxDescrPerRing - 10; |
| } |
| } |
| } |
| else { |
| /* use normal amount of rx buffers */ |
| for (i=0; i<pAC->GIni.GIMacsFound; i++) { |
| /* Found more than one port */ |
| 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 - 100; |
| } |
| } |
| } |
| |
| 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, 1); |
| SkI2cInit( pAC, pAC->IoBase, 1); |
| SkEventInit(pAC, pAC->IoBase, 1); |
| SkPnmiInit( pAC, pAC->IoBase, 1); |
| SkAddrInit( pAC, pAC->IoBase, 1); |
| SkRlmtInit( pAC, pAC->IoBase, 1); |
| SkTimerInit(pAC, pAC->IoBase, 1); |
| |
| /* |
| * tschilling: |
| * Speed and others are set back to default in level 1 init! |
| */ |
| GetConfiguration(pAC); |
| |
| SkGeInit( pAC, pAC->IoBase, 2); |
| SkI2cInit( pAC, pAC->IoBase, 2); |
| SkEventInit(pAC, pAC->IoBase, 2); |
| SkPnmiInit( pAC, pAC->IoBase, 2); |
| SkAddrInit( pAC, pAC->IoBase, 2); |
| SkRlmtInit( pAC, pAC->IoBase, 2); |
| SkTimerInit(pAC, pAC->IoBase, 2); |
| |
| /* |
| * 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); |
| |
| #ifdef USE_INT_MOD |
| { |
| unsigned long ModBase; |
| ModBase = 53125000 / INTS_PER_SEC; |
| SK_OUT32(pAC->IoBase, B2_IRQM_INI, ModBase); |
| SK_OUT32(pAC->IoBase, B2_IRQM_MSK, IRQ_MOD_MASK); |
| SK_OUT32(pAC->IoBase, B2_IRQM_CTRL, TIM_START); |
| } |
| #endif |
| |
| 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 */ |
| SK_OUT32(pAC->IoBase, B0_IMSK, IRQ_MASK); |
| SK_OUT32(pAC->IoBase, B0_HWE_IMSK, IRQ_HWE_MASK); |
| |
| SkEventQueue(pAC, SKGE_RLMT, SK_RLMT_START, EvPara); |
| SkEventDispatcher(pAC, pAC->IoBase); |
| |
| /* Found more than one port */ |
| if ((pAC->GIni.GIMacsFound == 2 ) && |
| (pAC->RlmtNets == 2)) { |
| /* Start both ports */ |
| EvPara.Para32[0] = pAC->RlmtNets; |
| EvPara.Para32[1] = -1; |
| SkEventQueue(pAC, SKGE_RLMT, SK_RLMT_SET_NETS, |
| EvPara); |
| |
| |
| EvPara.Para32[1] = -1; |
| EvPara.Para32[0] = pNet->PortNr; |
| SkEventQueue(pAC, SKGE_RLMT, SK_RLMT_START, EvPara); |
| |
| if (pOtherNet->Up) { |
| 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); |
| |
| return 0; |
| } /* 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 = (DEV_NET*) dev->priv; |
| 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; |
| 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); |
| 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 (pNet->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 (usefull 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; |
| |
| SK_GE_IOCTL Ioctl; |
| unsigned int Err = 0; |
| int Size; |
| |
| SK_DBG_MSG(NULL, SK_DBGMOD_DRV, SK_DBGCAT_DRV_ENTRY, |
| ("SkGeIoctl starts now...\n")); |
| |
| pNet = (DEV_NET*) dev->priv; |
| 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; |
| 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 */ |
| #endif |
| |
| |
| /***************************************************************************** |
| * |
| * 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 */ |
| int LinkSpeed; /* Link speed */ |
| int AutoNeg; /* auto negotiation off (0) or on (1) */ |
| int DuplexCap; /* duplex capabilities (0=both, 1=full, 2=half */ |
| int MSMode; /* master / slave mode selection */ |
| SK_BOOL AutoSet; |
| SK_BOOL DupSet; |
| /* |
| * 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 |
| |
| /* settings for port A */ |
| /* settings link speed */ |
| LinkSpeed = SK_LSPEED_AUTO; /* default: do auto select */ |
| if (Speed_A != NULL && pAC->Index<SK_MAX_CARD_PARAM && |
| Speed_A[pAC->Index] != NULL) { |
| if (strcmp(Speed_A[pAC->Index],"")==0) { |
| LinkSpeed = SK_LSPEED_AUTO; |
| } |
| 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("%s: Illegal value for Speed_A\n", |
| pAC->dev[0]->name); |
| } |
| |
| /* Check speed parameter */ |
| /* Only copper type adapter and GE V2 cards */ |
| if (((pAC->GIni.GIChipId != CHIP_ID_YUKON) || |
| (pAC->GIni.GICopperType != SK_TRUE)) && |
| ((LinkSpeed != SK_LSPEED_AUTO) && |
| (LinkSpeed != SK_LSPEED_1000MBPS))) { |
| printk("%s: Illegal value for Speed_A. " |
| "Not a copper card or GE V2 card\n Using " |
| "speed 1000\n", pAC->dev[0]->name); |
| LinkSpeed = SK_LSPEED_1000MBPS; |
| } |
| pAC->GIni.GP[0].PLinkSpeed = LinkSpeed; |
| |
| /* Autonegotiation */ |
| 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("%s: Illegal value for AutoNeg_A\n", |
| pAC->dev[0]->name); |
| } |
| |
| 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("%s: Illegal value for DupCap_A\n", |
| pAC->dev[0]->name); |
| } |
| |
| /* check for illegal combinations */ |
| if (AutoSet && AutoNeg==AN_SENS && DupSet) { |
| printk("%s, Port A: DuplexCapabilities" |
| " ignored using Sense mode\n", pAC->dev[0]->name); |
| } |
| if (AutoSet && AutoNeg==AN_OFF && DupSet && DuplexCap==DC_BOTH){ |
| printk("%s, Port A: Illegal combination" |
| " of values AutoNeg. and DuplexCap.\n Using " |
| "Full Duplex\n", pAC->dev[0]->name); |
| |
| DuplexCap = DC_FULL; |
| } |
| if (AutoSet && AutoNeg==AN_OFF && !DupSet) { |
| DuplexCap = DC_FULL; |
| } |
| |
| if (!AutoSet && DupSet) { |
| printk("%s, Port A: Duplex setting not" |
| " possible in\n default AutoNegotiation mode" |
| " (Sense).\n Using AutoNegotiation On\n", |
| pAC->dev[0]->name); |
| AutoNeg = AN_ON; |
| } |
| |
| /* set the desired mode */ |
| pAC->GIni.GP[0].PLinkModeConf = |
| Capabilities[AutoNeg][DuplexCap]; |
| |
| pAC->GIni.GP[0].PFlowCtrlMode = SK_FLOW_MODE_SYM_OR_REM; |
| if (FlowCtrl_A != NULL && pAC->Index<SK_MAX_CARD_PARAM && |
| FlowCtrl_A[pAC->Index] != NULL) { |
| if (strcmp(FlowCtrl_A[pAC->Index],"") == 0) { |
| } |
| else if (strcmp(FlowCtrl_A[pAC->Index],"SymOrRem") == 0) { |
| pAC->GIni.GP[0].PFlowCtrlMode = |
| SK_FLOW_MODE_SYM_OR_REM; |
| } |
| else if (strcmp(FlowCtrl_A[pAC->Index],"Sym")==0) { |
| pAC->GIni.GP[0].PFlowCtrlMode = |
| SK_FLOW_MODE_SYMMETRIC; |
| } |
| else if (strcmp(FlowCtrl_A[pAC->Index],"LocSend")==0) { |
| pAC->GIni.GP[0].PFlowCtrlMode = |
| SK_FLOW_MODE_LOC_SEND; |
| } |
| else if (strcmp(FlowCtrl_A[pAC->Index],"None")==0) { |
| pAC->GIni.GP[0].PFlowCtrlMode = |
| SK_FLOW_MODE_NONE; |
| } |
| else printk("Illegal value for FlowCtrl_A\n"); |
| } |
| if (AutoNeg==AN_OFF && pAC->GIni.GP[0].PFlowCtrlMode!= |
| SK_FLOW_MODE_NONE) { |
| printk("%s, Port A: FlowControl" |
| " impossible without AutoNegotiation," |
| " disabled\n", pAC->dev[0]->name); |
| pAC->GIni.GP[0].PFlowCtrlMode = SK_FLOW_MODE_NONE; |
| } |
| |
| MSMode = SK_MS_MODE_AUTO; /* default: do auto select */ |
| if (Role_A != NULL && pAC->Index<SK_MAX_CARD_PARAM && |
| Role_A[pAC->Index] != NULL) { |
| if (strcmp(Role_A[pAC->Index],"")==0) { |
| } |
| 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("%s: Illegal value for Role_A\n", |
| pAC->dev[0]->name); |
| } |
| pAC->GIni.GP[0].PMSMode = MSMode; |
| |
| |
| /* settings for port B */ |
| /* settings link speed */ |
| LinkSpeed = SK_LSPEED_AUTO; /* default: do auto select */ |
| if (Speed_B != NULL && pAC->Index<SK_MAX_CARD_PARAM && |
| Speed_B[pAC->Index] != NULL) { |
| if (strcmp(Speed_B[pAC->Index],"")==0) { |
| LinkSpeed = SK_LSPEED_AUTO; |
| } |
| 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("%s: Illegal value for Speed_B\n", |
| pAC->dev[1]->name); |
| } |
| |
| /* Check speed parameter */ |
| /* Only copper type adapter and GE V2 cards */ |
| if (((pAC->GIni.GIChipId != CHIP_ID_YUKON) || |
| (pAC->GIni.GICopperType != SK_TRUE)) && |
| ((LinkSpeed != SK_LSPEED_AUTO) && |
| (LinkSpeed != SK_LSPEED_1000MBPS))) { |
| printk("%s: Illegal value for Speed_B. " |
| "Not a copper card or GE V2 card\n Using " |
| "speed 1000\n", pAC->dev[1]->name); |
| LinkSpeed = SK_LSPEED_1000MBPS; |
| } |
| pAC->GIni.GP[1].PLinkSpeed = LinkSpeed; |
| |
| /* Auto negotiation */ |
| 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("Illegal value for AutoNeg_B\n"); |
| } |
| |
| 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("Illegal value for DupCap_B\n"); |
| } |
| |
| /* check for illegal combinations */ |
| if (AutoSet && AutoNeg==AN_SENS && DupSet) { |
| printk("%s, Port B: DuplexCapabilities" |
| " ignored using Sense mode\n", pAC->dev[1]->name); |
| } |
| if (AutoSet && AutoNeg==AN_OFF && DupSet && DuplexCap==DC_BOTH){ |
| printk("%s, Port B: Illegal combination" |
| " of values AutoNeg. and DuplexCap.\n Using " |
| "Full Duplex\n", pAC->dev[1]->name); |
| |
| DuplexCap = DC_FULL; |
| } |
| if (AutoSet && AutoNeg==AN_OFF && !DupSet) { |
| DuplexCap = DC_FULL; |
| } |
| |
| if (!AutoSet && DupSet) { |
| printk("%s, Port B: Duplex setting not" |
| " possible in\n default AutoNegotiation mode" |
| " (Sense).\n Using AutoNegotiation On\n", |
| pAC->dev[1]->name); |
| AutoNeg = AN_ON; |
| } |
| |
| /* set the desired mode */ |
| pAC->GIni.GP[1].PLinkModeConf = |
| Capabilities[AutoNeg][DuplexCap]; |
| |
| pAC->GIni.GP[1].PFlowCtrlMode = SK_FLOW_MODE_SYM_OR_REM; |
| if (FlowCtrl_B != NULL && pAC->Index<SK_MAX_CARD_PARAM && |
| FlowCtrl_B[pAC->Index] != NULL) { |
| if (strcmp(FlowCtrl_B[pAC->Index],"") == 0) { |
| } |
| else if (strcmp(FlowCtrl_B[pAC->Index],"SymOrRem") == 0) { |
| pAC->GIni.GP[1].PFlowCtrlMode = |
| SK_FLOW_MODE_SYM_OR_REM; |
| } |
| else if (strcmp(FlowCtrl_B[pAC->Index],"Sym")==0) { |
| pAC->GIni.GP[1].PFlowCtrlMode = |
| SK_FLOW_MODE_SYMMETRIC; |
| } |
| else if (strcmp(FlowCtrl_B[pAC->Index],"LocSend")==0) { |
| pAC->GIni.GP[1].PFlowCtrlMode = |
| SK_FLOW_MODE_LOC_SEND; |
| } |
| else if (strcmp(FlowCtrl_B[pAC->Index],"None")==0) { |
| pAC->GIni.GP[1].PFlowCtrlMode = |
| SK_FLOW_MODE_NONE; |
| } |
| else printk("Illegal value for FlowCtrl_B\n"); |
| } |
| if (AutoNeg==AN_OFF && pAC->GIni.GP[1].PFlowCtrlMode!= |
| SK_FLOW_MODE_NONE) { |
| printk("%s, Port B: FlowControl" |
| " impossible without AutoNegotiation," |
| " disabled\n", pAC->dev[1]->name); |
| pAC->GIni.GP[1].PFlowCtrlMode = SK_FLOW_MODE_NONE; |
| } |
| |
| MSMode = SK_MS_MODE_AUTO; /* default: do auto select */ |
| if (Role_B != NULL && pAC->Index<SK_MAX_CARD_PARAM && |
| Role_B[pAC->Index] != NULL) { |
| if (strcmp(Role_B[pAC->Index],"")==0) { |
| } |
| 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("%s: Illegal value for Role_B\n", |
| pAC->dev[1]->name); |
| } |
| pAC->GIni.GP[1].PMSMode = MSMode; |
| |
| |
| /* 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. |
| */ |
| Port = 1; |
| pAC->Rlmt.Net[0].Preference = Port; |
| pAC->Rlmt.Net[0].PrefPort = Port; |
| } |
| else printk("%s: Illegal value for PrefPort\n", |
| pAC->dev[0]->name); |
| } |
| |
| 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("%s: Illegal value for" |
| " RlmtMode, using default\n", pAC->dev[0]->name); |
| pAC->RlmtMode = 0; |
| } |
| } |
| else { |
| pAC->RlmtMode = 0; |
| } |
| } /* 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 void ProductStr( |
| SK_AC *pAC /* pointer to adapter context */ |
| ) |
| { |
| int StrLen = 80; /* length of the string, defined in SK_AC */ |
| 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, pAC->DeviceStr, |
| &StrLen); |
| spin_unlock_irqrestore(&pAC->SlowPathLock, Flags); |
| if (ReturnCode != 0) { |
| /* there was an error reading the vpd data */ |
| SK_DBG_MSG(NULL, SK_DBGMOD_DRV, SK_DBGCAT_DRV_ERROR, |
| ("Error reading VPD data: %d\n", ReturnCode)); |
| pAC->DeviceStr[0] = '\0'; |
| } |
| } /* ProductStr */ |
| |
| |
| /****************************************************************************/ |
| /* 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) |
| { |
| #if 0 |
| return jiffies; |
| #else |
| return get_timer(0); |
| #endif |
| } /* 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 */ |
| |
| |
| /***************************************************************************** |
| * |
| * 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 |
| */ |
| 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 */ |
| |
| |
| /***************************************************************************** |
| * |
| * 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 */ |
| #if 0 |
| int Stat; |
| #endif |
| 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); |
| #if 0 |
| pAC->dev[Param.Para32[0]]->flags &= ~IFF_RUNNING; |
| #endif |
| 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 */ |
| /* 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])); |
| #ifdef SK98_INFO |
| 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"); |
| } |
| } |
| |
| #ifdef SK_ZEROCOPY |
| if (pAC->GIni.GIChipId == CHIP_ID_YUKON) |
| printk(" scatter-gather: enabled\n"); |
| else |
| printk(" scatter-gather: disabled\n"); |
| |
| #else |
| printk(" scatter-gather: disabled\n"); |
| #endif |
| #endif /* SK98_INFO */ |
| |
| 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. */ |
| #if 0 |
| pAC->dev[Param.Para32[0]]->flags |= IFF_RUNNING; |
| #endif |
| |
| 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 ")); |
| #ifdef SK98_INFO |
| printk("%s: network connection down\n", pAC->dev[Param.Para32[1]]->name); |
| #endif |
| #if 0 |
| pAC->dev[Param.Para32[1]]->flags &= ~IFF_RUNNING; |
| #endif |
| 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_irqsave( |
| &pAC->TxPort[ToPort][TX_PRIO_LOW].TxDesRingLock, Flags); |
| SkGeStopPort(pAC, IoC, FromPort, SK_STOP_ALL, SK_SOFT_RST); |
| SkGeStopPort(pAC, IoC, ToPort, SK_STOP_ALL, SK_SOFT_RST); |
| spin_unlock_irqrestore( |
| &pAC->TxPort[ToPort][TX_PRIO_LOW].TxDesRingLock, Flags); |
| 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_irqsave( |
| &pAC->TxPort[ToPort][TX_PRIO_LOW].TxDesRingLock, Flags); |
| 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_irqrestore( |
| &pAC->TxPort[ToPort][TX_PRIO_LOW].TxDesRingLock, Flags); |
| 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_irqrestore( |
| &pAC->TxPort[ToPort][TX_PRIO_LOW].TxDesRingLock, Flags); |
| 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; |
| 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 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 |
| |
| #endif /* CONFIG_SK98 */ |
