/******************************************************************************
 *
 * 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>

#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;