[PATCH] irq-flags: drivers/net: Use the new IRQF_ constants
[linux-2.6.git] / drivers / net / sk98lin / skge.c
1 /******************************************************************************
2  *
3  * Name:        skge.c
4  * Project:     GEnesis, PCI Gigabit Ethernet Adapter
5  * Version:     $Revision: 1.45 $
6  * Date:        $Date: 2004/02/12 14:41:02 $
7  * Purpose:     The main driver source module
8  *
9  ******************************************************************************/
10
11 /******************************************************************************
12  *
13  *      (C)Copyright 1998-2002 SysKonnect GmbH.
14  *      (C)Copyright 2002-2003 Marvell.
15  *
16  *      Driver for Marvell Yukon chipset and SysKonnect Gigabit Ethernet 
17  *      Server Adapters.
18  *
19  *      Created 10-Feb-1999, based on Linux' acenic.c, 3c59x.c and
20  *      SysKonnects GEnesis Solaris driver
21  *      Author: Christoph Goos (cgoos@syskonnect.de)
22  *              Mirko Lindner (mlindner@syskonnect.de)
23  *
24  *      Address all question to: linux@syskonnect.de
25  *
26  *      The technical manual for the adapters is available from SysKonnect's
27  *      web pages: www.syskonnect.com
28  *      Goto "Support" and search Knowledge Base for "manual".
29  *      
30  *      This program is free software; you can redistribute it and/or modify
31  *      it under the terms of the GNU General Public License as published by
32  *      the Free Software Foundation; either version 2 of the License, or
33  *      (at your option) any later version.
34  *
35  *      The information in this file is provided "AS IS" without warranty.
36  *
37  ******************************************************************************/
38
39 /******************************************************************************
40  *
41  * Possible compiler options (#define xxx / -Dxxx):
42  *
43  *      debugging can be enable by changing SK_DEBUG_CHKMOD and
44  *      SK_DEBUG_CHKCAT in makefile (described there).
45  *
46  ******************************************************************************/
47
48 /******************************************************************************
49  *
50  * Description:
51  *
52  *      This is the main module of the Linux GE driver.
53  *      
54  *      All source files except skge.c, skdrv1st.h, skdrv2nd.h and sktypes.h
55  *      are part of SysKonnect's COMMON MODULES for the SK-98xx adapters.
56  *      Those are used for drivers on multiple OS', so some thing may seem
57  *      unnecessary complicated on Linux. Please do not try to 'clean up'
58  *      them without VERY good reasons, because this will make it more
59  *      difficult to keep the Linux driver in synchronisation with the
60  *      other versions.
61  *
62  * Include file hierarchy:
63  *
64  *      <linux/module.h>
65  *
66  *      "h/skdrv1st.h"
67  *              <linux/types.h>
68  *              <linux/kernel.h>
69  *              <linux/string.h>
70  *              <linux/errno.h>
71  *              <linux/ioport.h>
72  *              <linux/slab.h>
73  *              <linux/interrupt.h>
74  *              <linux/pci.h>
75  *              <linux/bitops.h>
76  *              <asm/byteorder.h>
77  *              <asm/io.h>
78  *              <linux/netdevice.h>
79  *              <linux/etherdevice.h>
80  *              <linux/skbuff.h>
81  *          those three depending on kernel version used:
82  *              <linux/bios32.h>
83  *              <linux/init.h>
84  *              <asm/uaccess.h>
85  *              <net/checksum.h>
86  *
87  *              "h/skerror.h"
88  *              "h/skdebug.h"
89  *              "h/sktypes.h"
90  *              "h/lm80.h"
91  *              "h/xmac_ii.h"
92  *
93  *      "h/skdrv2nd.h"
94  *              "h/skqueue.h"
95  *              "h/skgehwt.h"
96  *              "h/sktimer.h"
97  *              "h/ski2c.h"
98  *              "h/skgepnmi.h"
99  *              "h/skvpd.h"
100  *              "h/skgehw.h"
101  *              "h/skgeinit.h"
102  *              "h/skaddr.h"
103  *              "h/skgesirq.h"
104  *              "h/skrlmt.h"
105  *
106  ******************************************************************************/
107
108 #include        "h/skversion.h"
109
110 #include        <linux/in.h>
111 #include        <linux/module.h>
112 #include        <linux/moduleparam.h>
113 #include        <linux/init.h>
114 #include        <linux/dma-mapping.h>
115 #include        <linux/ip.h>
116
117 #include        "h/skdrv1st.h"
118 #include        "h/skdrv2nd.h"
119
120 /*******************************************************************************
121  *
122  * Defines
123  *
124  ******************************************************************************/
125
126 /* for debuging on x86 only */
127 /* #define BREAKPOINT() asm(" int $3"); */
128
129 /* use the transmit hw checksum driver functionality */
130 #define USE_SK_TX_CHECKSUM
131
132 /* use the receive hw checksum driver functionality */
133 #define USE_SK_RX_CHECKSUM
134
135 /* use the scatter-gather functionality with sendfile() */
136 #define SK_ZEROCOPY
137
138 /* use of a transmit complete interrupt */
139 #define USE_TX_COMPLETE
140
141 /*
142  * threshold for copying small receive frames
143  * set to 0 to avoid copying, set to 9001 to copy all frames
144  */
145 #define SK_COPY_THRESHOLD       50
146
147 /* number of adapters that can be configured via command line params */
148 #define SK_MAX_CARD_PARAM       16
149
150
151
152 /*
153  * use those defines for a compile-in version of the driver instead
154  * of command line parameters
155  */
156 // #define LINK_SPEED_A {"Auto", }
157 // #define LINK_SPEED_B {"Auto", }
158 // #define AUTO_NEG_A   {"Sense", }
159 // #define AUTO_NEG_B   {"Sense", }
160 // #define DUP_CAP_A    {"Both", }
161 // #define DUP_CAP_B    {"Both", }
162 // #define FLOW_CTRL_A  {"SymOrRem", }
163 // #define FLOW_CTRL_B  {"SymOrRem", }
164 // #define ROLE_A       {"Auto", }
165 // #define ROLE_B       {"Auto", }
166 // #define PREF_PORT    {"A", }
167 // #define CON_TYPE     {"Auto", }
168 // #define RLMT_MODE    {"CheckLinkState", }
169
170 #define DEV_KFREE_SKB(skb) dev_kfree_skb(skb)
171 #define DEV_KFREE_SKB_IRQ(skb) dev_kfree_skb_irq(skb)
172 #define DEV_KFREE_SKB_ANY(skb) dev_kfree_skb_any(skb)
173
174
175 /* Set blink mode*/
176 #define OEM_CONFIG_VALUE (      SK_ACT_LED_BLINK | \
177                                 SK_DUP_LED_NORMAL | \
178                                 SK_LED_LINK100_ON)
179
180
181 /* Isr return value */
182 #define SkIsrRetVar     irqreturn_t
183 #define SkIsrRetNone    IRQ_NONE
184 #define SkIsrRetHandled IRQ_HANDLED
185
186
187 /*******************************************************************************
188  *
189  * Local Function Prototypes
190  *
191  ******************************************************************************/
192
193 static void     FreeResources(struct SK_NET_DEVICE *dev);
194 static int      SkGeBoardInit(struct SK_NET_DEVICE *dev, SK_AC *pAC);
195 static SK_BOOL  BoardAllocMem(SK_AC *pAC);
196 static void     BoardFreeMem(SK_AC *pAC);
197 static void     BoardInitMem(SK_AC *pAC);
198 static void     SetupRing(SK_AC*, void*, uintptr_t, RXD**, RXD**, RXD**, int*, SK_BOOL);
199 static SkIsrRetVar      SkGeIsr(int irq, void *dev_id, struct pt_regs *ptregs);
200 static SkIsrRetVar      SkGeIsrOnePort(int irq, void *dev_id, struct pt_regs *ptregs);
201 static int      SkGeOpen(struct SK_NET_DEVICE *dev);
202 static int      SkGeClose(struct SK_NET_DEVICE *dev);
203 static int      SkGeXmit(struct sk_buff *skb, struct SK_NET_DEVICE *dev);
204 static int      SkGeSetMacAddr(struct SK_NET_DEVICE *dev, void *p);
205 static void     SkGeSetRxMode(struct SK_NET_DEVICE *dev);
206 static struct   net_device_stats *SkGeStats(struct SK_NET_DEVICE *dev);
207 static int      SkGeIoctl(struct SK_NET_DEVICE *dev, struct ifreq *rq, int cmd);
208 static void     GetConfiguration(SK_AC*);
209 static int      XmitFrame(SK_AC*, TX_PORT*, struct sk_buff*);
210 static void     FreeTxDescriptors(SK_AC*pAC, TX_PORT*);
211 static void     FillRxRing(SK_AC*, RX_PORT*);
212 static SK_BOOL  FillRxDescriptor(SK_AC*, RX_PORT*);
213 static void     ReceiveIrq(SK_AC*, RX_PORT*, SK_BOOL);
214 static void     ClearAndStartRx(SK_AC*, int);
215 static void     ClearTxIrq(SK_AC*, int, int);
216 static void     ClearRxRing(SK_AC*, RX_PORT*);
217 static void     ClearTxRing(SK_AC*, TX_PORT*);
218 static int      SkGeChangeMtu(struct SK_NET_DEVICE *dev, int new_mtu);
219 static void     PortReInitBmu(SK_AC*, int);
220 static int      SkGeIocMib(DEV_NET*, unsigned int, int);
221 static int      SkGeInitPCI(SK_AC *pAC);
222 static void     StartDrvCleanupTimer(SK_AC *pAC);
223 static void     StopDrvCleanupTimer(SK_AC *pAC);
224 static int      XmitFrameSG(SK_AC*, TX_PORT*, struct sk_buff*);
225
226 #ifdef SK_DIAG_SUPPORT
227 static SK_U32   ParseDeviceNbrFromSlotName(const char *SlotName);
228 static int      SkDrvInitAdapter(SK_AC *pAC, int devNbr);
229 static int      SkDrvDeInitAdapter(SK_AC *pAC, int devNbr);
230 #endif
231
232 /*******************************************************************************
233  *
234  * Extern Function Prototypes
235  *
236  ******************************************************************************/
237 extern void SkDimEnableModerationIfNeeded(SK_AC *pAC);  
238 extern void SkDimDisplayModerationSettings(SK_AC *pAC);
239 extern void SkDimStartModerationTimer(SK_AC *pAC);
240 extern void SkDimModerate(SK_AC *pAC);
241 extern void SkGeBlinkTimer(unsigned long data);
242
243 #ifdef DEBUG
244 static void     DumpMsg(struct sk_buff*, char*);
245 static void     DumpData(char*, int);
246 static void     DumpLong(char*, int);
247 #endif
248
249 /* global variables *********************************************************/
250 static SK_BOOL DoPrintInterfaceChange = SK_TRUE;
251 extern  struct ethtool_ops SkGeEthtoolOps;
252
253 /* local variables **********************************************************/
254 static uintptr_t TxQueueAddr[SK_MAX_MACS][2] = {{0x680, 0x600},{0x780, 0x700}};
255 static uintptr_t RxQueueAddr[SK_MAX_MACS] = {0x400, 0x480};
256
257 /*****************************************************************************
258  *
259  *      SkPciWriteCfgDWord - write a 32 bit value to pci config space
260  *
261  * Description:
262  *      This routine writes a 32 bit value to the pci configuration
263  *      space.
264  *
265  * Returns:
266  *      0 - indicate everything worked ok.
267  *      != 0 - error indication
268  */
269 static inline int SkPciWriteCfgDWord(
270 SK_AC *pAC,     /* Adapter Control structure pointer */
271 int PciAddr,            /* PCI register address */
272 SK_U32 Val)             /* pointer to store the read value */
273 {
274         pci_write_config_dword(pAC->PciDev, PciAddr, Val);
275         return(0);
276 } /* SkPciWriteCfgDWord */
277
278 /*****************************************************************************
279  *
280  *      SkGeInitPCI - Init the PCI resources
281  *
282  * Description:
283  *      This function initialize the PCI resources and IO
284  *
285  * Returns:
286  *      0 - indicate everything worked ok.
287  *      != 0 - error indication
288  */
289 static __devinit int SkGeInitPCI(SK_AC *pAC)
290 {
291         struct SK_NET_DEVICE *dev = pAC->dev[0];
292         struct pci_dev *pdev = pAC->PciDev;
293         int retval;
294
295         dev->mem_start = pci_resource_start (pdev, 0);
296         pci_set_master(pdev);
297
298         retval = pci_request_regions(pdev, "sk98lin");
299         if (retval)
300                 goto out;
301
302 #ifdef SK_BIG_ENDIAN
303         /*
304          * On big endian machines, we use the adapter's aibility of
305          * reading the descriptors as big endian.
306          */
307         {
308                 SK_U32          our2;
309                 SkPciReadCfgDWord(pAC, PCI_OUR_REG_2, &our2);
310                 our2 |= PCI_REV_DESC;
311                 SkPciWriteCfgDWord(pAC, PCI_OUR_REG_2, our2);
312         }
313 #endif
314
315         /*
316          * Remap the regs into kernel space.
317          */
318         pAC->IoBase = ioremap_nocache(dev->mem_start, 0x4000);
319         if (!pAC->IoBase) {
320                 retval = -EIO;
321                 goto out_release;
322         }
323
324         return 0;
325
326  out_release:
327         pci_release_regions(pdev);
328  out:
329         return retval;
330 }
331
332
333 /*****************************************************************************
334  *
335  *      FreeResources - release resources allocated for adapter
336  *
337  * Description:
338  *      This function releases the IRQ, unmaps the IO and
339  *      frees the desriptor ring.
340  *
341  * Returns: N/A
342  *      
343  */
344 static void FreeResources(struct SK_NET_DEVICE *dev)
345 {
346 SK_U32 AllocFlag;
347 DEV_NET         *pNet;
348 SK_AC           *pAC;
349
350         pNet = netdev_priv(dev);
351         pAC = pNet->pAC;
352         AllocFlag = pAC->AllocFlag;
353         if (pAC->PciDev) {
354                 pci_release_regions(pAC->PciDev);
355         }
356         if (AllocFlag & SK_ALLOC_IRQ) {
357                 free_irq(dev->irq, dev);
358         }
359         if (pAC->IoBase) {
360                 iounmap(pAC->IoBase);
361         }
362         if (pAC->pDescrMem) {
363                 BoardFreeMem(pAC);
364         }
365         
366 } /* FreeResources */
367
368 MODULE_AUTHOR("Mirko Lindner <mlindner@syskonnect.de>");
369 MODULE_DESCRIPTION("SysKonnect SK-NET Gigabit Ethernet SK-98xx driver");
370 MODULE_LICENSE("GPL");
371
372 #ifdef LINK_SPEED_A
373 static char *Speed_A[SK_MAX_CARD_PARAM] = LINK_SPEED;
374 #else
375 static char *Speed_A[SK_MAX_CARD_PARAM] = {"", };
376 #endif
377
378 #ifdef LINK_SPEED_B
379 static char *Speed_B[SK_MAX_CARD_PARAM] = LINK_SPEED;
380 #else
381 static char *Speed_B[SK_MAX_CARD_PARAM] = {"", };
382 #endif
383
384 #ifdef AUTO_NEG_A
385 static char *AutoNeg_A[SK_MAX_CARD_PARAM] = AUTO_NEG_A;
386 #else
387 static char *AutoNeg_A[SK_MAX_CARD_PARAM] = {"", };
388 #endif
389
390 #ifdef DUP_CAP_A
391 static char *DupCap_A[SK_MAX_CARD_PARAM] = DUP_CAP_A;
392 #else
393 static char *DupCap_A[SK_MAX_CARD_PARAM] = {"", };
394 #endif
395
396 #ifdef FLOW_CTRL_A
397 static char *FlowCtrl_A[SK_MAX_CARD_PARAM] = FLOW_CTRL_A;
398 #else
399 static char *FlowCtrl_A[SK_MAX_CARD_PARAM] = {"", };
400 #endif
401
402 #ifdef ROLE_A
403 static char *Role_A[SK_MAX_CARD_PARAM] = ROLE_A;
404 #else
405 static char *Role_A[SK_MAX_CARD_PARAM] = {"", };
406 #endif
407
408 #ifdef AUTO_NEG_B
409 static char *AutoNeg_B[SK_MAX_CARD_PARAM] = AUTO_NEG_B;
410 #else
411 static char *AutoNeg_B[SK_MAX_CARD_PARAM] = {"", };
412 #endif
413
414 #ifdef DUP_CAP_B
415 static char *DupCap_B[SK_MAX_CARD_PARAM] = DUP_CAP_B;
416 #else
417 static char *DupCap_B[SK_MAX_CARD_PARAM] = {"", };
418 #endif
419
420 #ifdef FLOW_CTRL_B
421 static char *FlowCtrl_B[SK_MAX_CARD_PARAM] = FLOW_CTRL_B;
422 #else
423 static char *FlowCtrl_B[SK_MAX_CARD_PARAM] = {"", };
424 #endif
425
426 #ifdef ROLE_B
427 static char *Role_B[SK_MAX_CARD_PARAM] = ROLE_B;
428 #else
429 static char *Role_B[SK_MAX_CARD_PARAM] = {"", };
430 #endif
431
432 #ifdef CON_TYPE
433 static char *ConType[SK_MAX_CARD_PARAM] = CON_TYPE;
434 #else
435 static char *ConType[SK_MAX_CARD_PARAM] = {"", };
436 #endif
437
438 #ifdef PREF_PORT
439 static char *PrefPort[SK_MAX_CARD_PARAM] = PREF_PORT;
440 #else
441 static char *PrefPort[SK_MAX_CARD_PARAM] = {"", };
442 #endif
443
444 #ifdef RLMT_MODE
445 static char *RlmtMode[SK_MAX_CARD_PARAM] = RLMT_MODE;
446 #else
447 static char *RlmtMode[SK_MAX_CARD_PARAM] = {"", };
448 #endif
449
450 static int   IntsPerSec[SK_MAX_CARD_PARAM];
451 static char *Moderation[SK_MAX_CARD_PARAM];
452 static char *ModerationMask[SK_MAX_CARD_PARAM];
453 static char *AutoSizing[SK_MAX_CARD_PARAM];
454 static char *Stats[SK_MAX_CARD_PARAM];
455
456 module_param_array(Speed_A, charp, NULL, 0);
457 module_param_array(Speed_B, charp, NULL, 0);
458 module_param_array(AutoNeg_A, charp, NULL, 0);
459 module_param_array(AutoNeg_B, charp, NULL, 0);
460 module_param_array(DupCap_A, charp, NULL, 0);
461 module_param_array(DupCap_B, charp, NULL, 0);
462 module_param_array(FlowCtrl_A, charp, NULL, 0);
463 module_param_array(FlowCtrl_B, charp, NULL, 0);
464 module_param_array(Role_A, charp, NULL, 0);
465 module_param_array(Role_B, charp, NULL, 0);
466 module_param_array(ConType, charp, NULL, 0);
467 module_param_array(PrefPort, charp, NULL, 0);
468 module_param_array(RlmtMode, charp, NULL, 0);
469 /* used for interrupt moderation */
470 module_param_array(IntsPerSec, int, NULL, 0);
471 module_param_array(Moderation, charp, NULL, 0);
472 module_param_array(Stats, charp, NULL, 0);
473 module_param_array(ModerationMask, charp, NULL, 0);
474 module_param_array(AutoSizing, charp, NULL, 0);
475
476 /*****************************************************************************
477  *
478  *      SkGeBoardInit - do level 0 and 1 initialization
479  *
480  * Description:
481  *      This function prepares the board hardware for running. The desriptor
482  *      ring is set up, the IRQ is allocated and the configuration settings
483  *      are examined.
484  *
485  * Returns:
486  *      0, if everything is ok
487  *      !=0, on error
488  */
489 static int __devinit SkGeBoardInit(struct SK_NET_DEVICE *dev, SK_AC *pAC)
490 {
491 short   i;
492 unsigned long Flags;
493 char    *DescrString = "sk98lin: Driver for Linux"; /* this is given to PNMI */
494 char    *VerStr = VER_STRING;
495 int     Ret;                    /* return code of request_irq */
496 SK_BOOL DualNet;
497
498         SK_DBG_MSG(NULL, SK_DBGMOD_DRV, SK_DBGCAT_DRV_ENTRY,
499                 ("IoBase: %08lX\n", (unsigned long)pAC->IoBase));
500         for (i=0; i<SK_MAX_MACS; i++) {
501                 pAC->TxPort[i][0].HwAddr = pAC->IoBase + TxQueueAddr[i][0];
502                 pAC->TxPort[i][0].PortIndex = i;
503                 pAC->RxPort[i].HwAddr = pAC->IoBase + RxQueueAddr[i];
504                 pAC->RxPort[i].PortIndex = i;
505         }
506
507         /* Initialize the mutexes */
508         for (i=0; i<SK_MAX_MACS; i++) {
509                 spin_lock_init(&pAC->TxPort[i][0].TxDesRingLock);
510                 spin_lock_init(&pAC->RxPort[i].RxDesRingLock);
511         }
512         spin_lock_init(&pAC->SlowPathLock);
513
514         /* setup phy_id blink timer */
515         pAC->BlinkTimer.function = SkGeBlinkTimer;
516         pAC->BlinkTimer.data = (unsigned long) dev;
517         init_timer(&pAC->BlinkTimer);
518
519         /* level 0 init common modules here */
520         
521         spin_lock_irqsave(&pAC->SlowPathLock, Flags);
522         /* Does a RESET on board ...*/
523         if (SkGeInit(pAC, pAC->IoBase, SK_INIT_DATA) != 0) {
524                 printk("HWInit (0) failed.\n");
525                 spin_unlock_irqrestore(&pAC->SlowPathLock, Flags);
526                 return -EIO;
527         }
528         SkI2cInit(  pAC, pAC->IoBase, SK_INIT_DATA);
529         SkEventInit(pAC, pAC->IoBase, SK_INIT_DATA);
530         SkPnmiInit( pAC, pAC->IoBase, SK_INIT_DATA);
531         SkAddrInit( pAC, pAC->IoBase, SK_INIT_DATA);
532         SkRlmtInit( pAC, pAC->IoBase, SK_INIT_DATA);
533         SkTimerInit(pAC, pAC->IoBase, SK_INIT_DATA);
534
535         pAC->BoardLevel = SK_INIT_DATA;
536         pAC->RxBufSize  = ETH_BUF_SIZE;
537
538         SK_PNMI_SET_DRIVER_DESCR(pAC, DescrString);
539         SK_PNMI_SET_DRIVER_VER(pAC, VerStr);
540
541         spin_unlock_irqrestore(&pAC->SlowPathLock, Flags);
542
543         /* level 1 init common modules here (HW init) */
544         spin_lock_irqsave(&pAC->SlowPathLock, Flags);
545         if (SkGeInit(pAC, pAC->IoBase, SK_INIT_IO) != 0) {
546                 printk("sk98lin: HWInit (1) failed.\n");
547                 spin_unlock_irqrestore(&pAC->SlowPathLock, Flags);
548                 return -EIO;
549         }
550         SkI2cInit(  pAC, pAC->IoBase, SK_INIT_IO);
551         SkEventInit(pAC, pAC->IoBase, SK_INIT_IO);
552         SkPnmiInit( pAC, pAC->IoBase, SK_INIT_IO);
553         SkAddrInit( pAC, pAC->IoBase, SK_INIT_IO);
554         SkRlmtInit( pAC, pAC->IoBase, SK_INIT_IO);
555         SkTimerInit(pAC, pAC->IoBase, SK_INIT_IO);
556
557         /* Set chipset type support */
558         pAC->ChipsetType = 0;
559         if ((pAC->GIni.GIChipId == CHIP_ID_YUKON) ||
560                 (pAC->GIni.GIChipId == CHIP_ID_YUKON_LITE)) {
561                 pAC->ChipsetType = 1;
562         }
563
564         GetConfiguration(pAC);
565         if (pAC->RlmtNets == 2) {
566                 pAC->GIni.GIPortUsage = SK_MUL_LINK;
567         }
568
569         pAC->BoardLevel = SK_INIT_IO;
570         spin_unlock_irqrestore(&pAC->SlowPathLock, Flags);
571
572         if (pAC->GIni.GIMacsFound == 2) {
573                  Ret = request_irq(dev->irq, SkGeIsr, IRQF_SHARED, "sk98lin", dev);
574         } else if (pAC->GIni.GIMacsFound == 1) {
575                 Ret = request_irq(dev->irq, SkGeIsrOnePort, IRQF_SHARED,
576                         "sk98lin", dev);
577         } else {
578                 printk(KERN_WARNING "sk98lin: Illegal number of ports: %d\n",
579                        pAC->GIni.GIMacsFound);
580                 return -EIO;
581         }
582
583         if (Ret) {
584                 printk(KERN_WARNING "sk98lin: Requested IRQ %d is busy.\n",
585                        dev->irq);
586                 return Ret;
587         }
588         pAC->AllocFlag |= SK_ALLOC_IRQ;
589
590         /* Alloc memory for this board (Mem for RxD/TxD) : */
591         if(!BoardAllocMem(pAC)) {
592                 printk("No memory for descriptor rings.\n");
593                 return -ENOMEM;
594         }
595
596         BoardInitMem(pAC);
597         /* tschilling: New common function with minimum size check. */
598         DualNet = SK_FALSE;
599         if (pAC->RlmtNets == 2) {
600                 DualNet = SK_TRUE;
601         }
602         
603         if (SkGeInitAssignRamToQueues(
604                 pAC,
605                 pAC->ActivePort,
606                 DualNet)) {
607                 BoardFreeMem(pAC);
608                 printk("sk98lin: SkGeInitAssignRamToQueues failed.\n");
609                 return -EIO;
610         }
611
612         return (0);
613 } /* SkGeBoardInit */
614
615
616 /*****************************************************************************
617  *
618  *      BoardAllocMem - allocate the memory for the descriptor rings
619  *
620  * Description:
621  *      This function allocates the memory for all descriptor rings.
622  *      Each ring is aligned for the desriptor alignment and no ring
623  *      has a 4 GByte boundary in it (because the upper 32 bit must
624  *      be constant for all descriptiors in one rings).
625  *
626  * Returns:
627  *      SK_TRUE, if all memory could be allocated
628  *      SK_FALSE, if not
629  */
630 static __devinit SK_BOOL BoardAllocMem(SK_AC    *pAC)
631 {
632 caddr_t         pDescrMem;      /* pointer to descriptor memory area */
633 size_t          AllocLength;    /* length of complete descriptor area */
634 int             i;              /* loop counter */
635 unsigned long   BusAddr;
636
637         
638         /* rings plus one for alignment (do not cross 4 GB boundary) */
639         /* RX_RING_SIZE is assumed bigger than TX_RING_SIZE */
640 #if (BITS_PER_LONG == 32)
641         AllocLength = (RX_RING_SIZE + TX_RING_SIZE) * pAC->GIni.GIMacsFound + 8;
642 #else
643         AllocLength = (RX_RING_SIZE + TX_RING_SIZE) * pAC->GIni.GIMacsFound
644                 + RX_RING_SIZE + 8;
645 #endif
646
647         pDescrMem = pci_alloc_consistent(pAC->PciDev, AllocLength,
648                                          &pAC->pDescrMemDMA);
649
650         if (pDescrMem == NULL) {
651                 return (SK_FALSE);
652         }
653         pAC->pDescrMem = pDescrMem;
654         BusAddr = (unsigned long) pAC->pDescrMemDMA;
655
656         /* Descriptors need 8 byte alignment, and this is ensured
657          * by pci_alloc_consistent.
658          */
659         for (i=0; i<pAC->GIni.GIMacsFound; i++) {
660                 SK_DBG_MSG(NULL, SK_DBGMOD_DRV, SK_DBGCAT_DRV_TX_PROGRESS,
661                         ("TX%d/A: pDescrMem: %lX,   PhysDescrMem: %lX\n",
662                         i, (unsigned long) pDescrMem,
663                         BusAddr));
664                 pAC->TxPort[i][0].pTxDescrRing = pDescrMem;
665                 pAC->TxPort[i][0].VTxDescrRing = BusAddr;
666                 pDescrMem += TX_RING_SIZE;
667                 BusAddr += TX_RING_SIZE;
668         
669                 SK_DBG_MSG(NULL, SK_DBGMOD_DRV, SK_DBGCAT_DRV_TX_PROGRESS,
670                         ("RX%d: pDescrMem: %lX,   PhysDescrMem: %lX\n",
671                         i, (unsigned long) pDescrMem,
672                         (unsigned long)BusAddr));
673                 pAC->RxPort[i].pRxDescrRing = pDescrMem;
674                 pAC->RxPort[i].VRxDescrRing = BusAddr;
675                 pDescrMem += RX_RING_SIZE;
676                 BusAddr += RX_RING_SIZE;
677         } /* for */
678         
679         return (SK_TRUE);
680 } /* BoardAllocMem */
681
682
683 /****************************************************************************
684  *
685  *      BoardFreeMem - reverse of BoardAllocMem
686  *
687  * Description:
688  *      Free all memory allocated in BoardAllocMem: adapter context,
689  *      descriptor rings, locks.
690  *
691  * Returns:     N/A
692  */
693 static void BoardFreeMem(
694 SK_AC           *pAC)
695 {
696 size_t          AllocLength;    /* length of complete descriptor area */
697
698         SK_DBG_MSG(NULL, SK_DBGMOD_DRV, SK_DBGCAT_DRV_ENTRY,
699                 ("BoardFreeMem\n"));
700 #if (BITS_PER_LONG == 32)
701         AllocLength = (RX_RING_SIZE + TX_RING_SIZE) * pAC->GIni.GIMacsFound + 8;
702 #else
703         AllocLength = (RX_RING_SIZE + TX_RING_SIZE) * pAC->GIni.GIMacsFound
704                 + RX_RING_SIZE + 8;
705 #endif
706
707         pci_free_consistent(pAC->PciDev, AllocLength,
708                             pAC->pDescrMem, pAC->pDescrMemDMA);
709         pAC->pDescrMem = NULL;
710 } /* BoardFreeMem */
711
712
713 /*****************************************************************************
714  *
715  *      BoardInitMem - initiate the descriptor rings
716  *
717  * Description:
718  *      This function sets the descriptor rings up in memory.
719  *      The adapter is initialized with the descriptor start addresses.
720  *
721  * Returns:     N/A
722  */
723 static __devinit void BoardInitMem(SK_AC *pAC)
724 {
725 int     i;              /* loop counter */
726 int     RxDescrSize;    /* the size of a rx descriptor rounded up to alignment*/
727 int     TxDescrSize;    /* the size of a tx descriptor rounded up to alignment*/
728
729         SK_DBG_MSG(NULL, SK_DBGMOD_DRV, SK_DBGCAT_DRV_ENTRY,
730                 ("BoardInitMem\n"));
731
732         RxDescrSize = (((sizeof(RXD) - 1) / DESCR_ALIGN) + 1) * DESCR_ALIGN;
733         pAC->RxDescrPerRing = RX_RING_SIZE / RxDescrSize;
734         TxDescrSize = (((sizeof(TXD) - 1) / DESCR_ALIGN) + 1) * DESCR_ALIGN;
735         pAC->TxDescrPerRing = TX_RING_SIZE / RxDescrSize;
736         
737         for (i=0; i<pAC->GIni.GIMacsFound; i++) {
738                 SetupRing(
739                         pAC,
740                         pAC->TxPort[i][0].pTxDescrRing,
741                         pAC->TxPort[i][0].VTxDescrRing,
742                         (RXD**)&pAC->TxPort[i][0].pTxdRingHead,
743                         (RXD**)&pAC->TxPort[i][0].pTxdRingTail,
744                         (RXD**)&pAC->TxPort[i][0].pTxdRingPrev,
745                         &pAC->TxPort[i][0].TxdRingFree,
746                         SK_TRUE);
747                 SetupRing(
748                         pAC,
749                         pAC->RxPort[i].pRxDescrRing,
750                         pAC->RxPort[i].VRxDescrRing,
751                         &pAC->RxPort[i].pRxdRingHead,
752                         &pAC->RxPort[i].pRxdRingTail,
753                         &pAC->RxPort[i].pRxdRingPrev,
754                         &pAC->RxPort[i].RxdRingFree,
755                         SK_FALSE);
756         }
757 } /* BoardInitMem */
758
759
760 /*****************************************************************************
761  *
762  *      SetupRing - create one descriptor ring
763  *
764  * Description:
765  *      This function creates one descriptor ring in the given memory area.
766  *      The head, tail and number of free descriptors in the ring are set.
767  *
768  * Returns:
769  *      none
770  */
771 static void SetupRing(
772 SK_AC           *pAC,
773 void            *pMemArea,      /* a pointer to the memory area for the ring */
774 uintptr_t       VMemArea,       /* the virtual bus address of the memory area */
775 RXD             **ppRingHead,   /* address where the head should be written */
776 RXD             **ppRingTail,   /* address where the tail should be written */
777 RXD             **ppRingPrev,   /* address where the tail should be written */
778 int             *pRingFree,     /* address where the # of free descr. goes */
779 SK_BOOL         IsTx)           /* flag: is this a tx ring */
780 {
781 int     i;              /* loop counter */
782 int     DescrSize;      /* the size of a descriptor rounded up to alignment*/
783 int     DescrNum;       /* number of descriptors per ring */
784 RXD     *pDescr;        /* pointer to a descriptor (receive or transmit) */
785 RXD     *pNextDescr;    /* pointer to the next descriptor */
786 RXD     *pPrevDescr;    /* pointer to the previous descriptor */
787 uintptr_t VNextDescr;   /* the virtual bus address of the next descriptor */
788
789         if (IsTx == SK_TRUE) {
790                 DescrSize = (((sizeof(TXD) - 1) / DESCR_ALIGN) + 1) *
791                         DESCR_ALIGN;
792                 DescrNum = TX_RING_SIZE / DescrSize;
793         } else {
794                 DescrSize = (((sizeof(RXD) - 1) / DESCR_ALIGN) + 1) *
795                         DESCR_ALIGN;
796                 DescrNum = RX_RING_SIZE / DescrSize;
797         }
798         
799         SK_DBG_MSG(NULL, SK_DBGMOD_DRV, SK_DBGCAT_DRV_TX_PROGRESS,
800                 ("Descriptor size: %d   Descriptor Number: %d\n",
801                 DescrSize,DescrNum));
802         
803         pDescr = (RXD*) pMemArea;
804         pPrevDescr = NULL;
805         pNextDescr = (RXD*) (((char*)pDescr) + DescrSize);
806         VNextDescr = VMemArea + DescrSize;
807         for(i=0; i<DescrNum; i++) {
808                 /* set the pointers right */
809                 pDescr->VNextRxd = VNextDescr & 0xffffffffULL;
810                 pDescr->pNextRxd = pNextDescr;
811                 if (!IsTx) pDescr->TcpSumStarts = ETH_HLEN << 16 | ETH_HLEN;
812
813                 /* advance one step */
814                 pPrevDescr = pDescr;
815                 pDescr = pNextDescr;
816                 pNextDescr = (RXD*) (((char*)pDescr) + DescrSize);
817                 VNextDescr += DescrSize;
818         }
819         pPrevDescr->pNextRxd = (RXD*) pMemArea;
820         pPrevDescr->VNextRxd = VMemArea;
821         pDescr = (RXD*) pMemArea;
822         *ppRingHead = (RXD*) pMemArea;
823         *ppRingTail = *ppRingHead;
824         *ppRingPrev = pPrevDescr;
825         *pRingFree = DescrNum;
826 } /* SetupRing */
827
828
829 /*****************************************************************************
830  *
831  *      PortReInitBmu - re-initiate the descriptor rings for one port
832  *
833  * Description:
834  *      This function reinitializes the descriptor rings of one port
835  *      in memory. The port must be stopped before.
836  *      The HW is initialized with the descriptor start addresses.
837  *
838  * Returns:
839  *      none
840  */
841 static void PortReInitBmu(
842 SK_AC   *pAC,           /* pointer to adapter context */
843 int     PortIndex)      /* index of the port for which to re-init */
844 {
845         SK_DBG_MSG(NULL, SK_DBGMOD_DRV, SK_DBGCAT_DRV_ENTRY,
846                 ("PortReInitBmu "));
847
848         /* set address of first descriptor of ring in BMU */
849         SK_OUT32(pAC->IoBase, TxQueueAddr[PortIndex][TX_PRIO_LOW]+ Q_DA_L,
850                 (uint32_t)(((caddr_t)
851                 (pAC->TxPort[PortIndex][TX_PRIO_LOW].pTxdRingHead) -
852                 pAC->TxPort[PortIndex][TX_PRIO_LOW].pTxDescrRing +
853                 pAC->TxPort[PortIndex][TX_PRIO_LOW].VTxDescrRing) &
854                 0xFFFFFFFF));
855         SK_OUT32(pAC->IoBase, TxQueueAddr[PortIndex][TX_PRIO_LOW]+ Q_DA_H,
856                 (uint32_t)(((caddr_t)
857                 (pAC->TxPort[PortIndex][TX_PRIO_LOW].pTxdRingHead) -
858                 pAC->TxPort[PortIndex][TX_PRIO_LOW].pTxDescrRing +
859                 pAC->TxPort[PortIndex][TX_PRIO_LOW].VTxDescrRing) >> 32));
860         SK_OUT32(pAC->IoBase, RxQueueAddr[PortIndex]+Q_DA_L,
861                 (uint32_t)(((caddr_t)(pAC->RxPort[PortIndex].pRxdRingHead) -
862                 pAC->RxPort[PortIndex].pRxDescrRing +
863                 pAC->RxPort[PortIndex].VRxDescrRing) & 0xFFFFFFFF));
864         SK_OUT32(pAC->IoBase, RxQueueAddr[PortIndex]+Q_DA_H,
865                 (uint32_t)(((caddr_t)(pAC->RxPort[PortIndex].pRxdRingHead) -
866                 pAC->RxPort[PortIndex].pRxDescrRing +
867                 pAC->RxPort[PortIndex].VRxDescrRing) >> 32));
868 } /* PortReInitBmu */
869
870
871 /****************************************************************************
872  *
873  *      SkGeIsr - handle adapter interrupts
874  *
875  * Description:
876  *      The interrupt routine is called when the network adapter
877  *      generates an interrupt. It may also be called if another device
878  *      shares this interrupt vector with the driver.
879  *
880  * Returns: N/A
881  *
882  */
883 static SkIsrRetVar SkGeIsr(int irq, void *dev_id, struct pt_regs *ptregs)
884 {
885 struct SK_NET_DEVICE *dev = (struct SK_NET_DEVICE *)dev_id;
886 DEV_NET         *pNet;
887 SK_AC           *pAC;
888 SK_U32          IntSrc;         /* interrupts source register contents */       
889
890         pNet = netdev_priv(dev);
891         pAC = pNet->pAC;
892         
893         /*
894          * Check and process if its our interrupt
895          */
896         SK_IN32(pAC->IoBase, B0_SP_ISRC, &IntSrc);
897         if (IntSrc == 0) {
898                 return SkIsrRetNone;
899         }
900
901         while (((IntSrc & IRQ_MASK) & ~SPECIAL_IRQS) != 0) {
902 #if 0 /* software irq currently not used */
903                 if (IntSrc & IS_IRQ_SW) {
904                         SK_DBG_MSG(NULL, SK_DBGMOD_DRV,
905                                 SK_DBGCAT_DRV_INT_SRC,
906                                 ("Software IRQ\n"));
907                 }
908 #endif
909                 if (IntSrc & IS_R1_F) {
910                         SK_DBG_MSG(NULL, SK_DBGMOD_DRV,
911                                 SK_DBGCAT_DRV_INT_SRC,
912                                 ("EOF RX1 IRQ\n"));
913                         ReceiveIrq(pAC, &pAC->RxPort[0], SK_TRUE);
914                         SK_PNMI_CNT_RX_INTR(pAC, 0);
915                 }
916                 if (IntSrc & IS_R2_F) {
917                         SK_DBG_MSG(NULL, SK_DBGMOD_DRV,
918                                 SK_DBGCAT_DRV_INT_SRC,
919                                 ("EOF RX2 IRQ\n"));
920                         ReceiveIrq(pAC, &pAC->RxPort[1], SK_TRUE);
921                         SK_PNMI_CNT_RX_INTR(pAC, 1);
922                 }
923 #ifdef USE_TX_COMPLETE /* only if tx complete interrupt used */
924                 if (IntSrc & IS_XA1_F) {
925                         SK_DBG_MSG(NULL, SK_DBGMOD_DRV,
926                                 SK_DBGCAT_DRV_INT_SRC,
927                                 ("EOF AS TX1 IRQ\n"));
928                         SK_PNMI_CNT_TX_INTR(pAC, 0);
929                         spin_lock(&pAC->TxPort[0][TX_PRIO_LOW].TxDesRingLock);
930                         FreeTxDescriptors(pAC, &pAC->TxPort[0][TX_PRIO_LOW]);
931                         spin_unlock(&pAC->TxPort[0][TX_PRIO_LOW].TxDesRingLock);
932                 }
933                 if (IntSrc & IS_XA2_F) {
934                         SK_DBG_MSG(NULL, SK_DBGMOD_DRV,
935                                 SK_DBGCAT_DRV_INT_SRC,
936                                 ("EOF AS TX2 IRQ\n"));
937                         SK_PNMI_CNT_TX_INTR(pAC, 1);
938                         spin_lock(&pAC->TxPort[1][TX_PRIO_LOW].TxDesRingLock);
939                         FreeTxDescriptors(pAC, &pAC->TxPort[1][TX_PRIO_LOW]);
940                         spin_unlock(&pAC->TxPort[1][TX_PRIO_LOW].TxDesRingLock);
941                 }
942 #if 0 /* only if sync. queues used */
943                 if (IntSrc & IS_XS1_F) {
944                         SK_DBG_MSG(NULL, SK_DBGMOD_DRV,
945                                 SK_DBGCAT_DRV_INT_SRC,
946                                 ("EOF SY TX1 IRQ\n"));
947                         SK_PNMI_CNT_TX_INTR(pAC, 1);
948                         spin_lock(&pAC->TxPort[0][TX_PRIO_HIGH].TxDesRingLock);
949                         FreeTxDescriptors(pAC, 0, TX_PRIO_HIGH);
950                         spin_unlock(&pAC->TxPort[0][TX_PRIO_HIGH].TxDesRingLock);
951                         ClearTxIrq(pAC, 0, TX_PRIO_HIGH);
952                 }
953                 if (IntSrc & IS_XS2_F) {
954                         SK_DBG_MSG(NULL, SK_DBGMOD_DRV,
955                                 SK_DBGCAT_DRV_INT_SRC,
956                                 ("EOF SY TX2 IRQ\n"));
957                         SK_PNMI_CNT_TX_INTR(pAC, 1);
958                         spin_lock(&pAC->TxPort[1][TX_PRIO_HIGH].TxDesRingLock);
959                         FreeTxDescriptors(pAC, 1, TX_PRIO_HIGH);
960                         spin_unlock(&pAC->TxPort[1][TX_PRIO_HIGH].TxDesRingLock);
961                         ClearTxIrq(pAC, 1, TX_PRIO_HIGH);
962                 }
963 #endif
964 #endif
965
966                 /* do all IO at once */
967                 if (IntSrc & IS_R1_F)
968                         ClearAndStartRx(pAC, 0);
969                 if (IntSrc & IS_R2_F)
970                         ClearAndStartRx(pAC, 1);
971 #ifdef USE_TX_COMPLETE /* only if tx complete interrupt used */
972                 if (IntSrc & IS_XA1_F)
973                         ClearTxIrq(pAC, 0, TX_PRIO_LOW);
974                 if (IntSrc & IS_XA2_F)
975                         ClearTxIrq(pAC, 1, TX_PRIO_LOW);
976 #endif
977                 SK_IN32(pAC->IoBase, B0_ISRC, &IntSrc);
978         } /* while (IntSrc & IRQ_MASK != 0) */
979
980         IntSrc &= pAC->GIni.GIValIrqMask;
981         if ((IntSrc & SPECIAL_IRQS) || pAC->CheckQueue) {
982                 SK_DBG_MSG(NULL, SK_DBGMOD_DRV, SK_DBGCAT_DRV_INT_SRC,
983                         ("SPECIAL IRQ DP-Cards => %x\n", IntSrc));
984                 pAC->CheckQueue = SK_FALSE;
985                 spin_lock(&pAC->SlowPathLock);
986                 if (IntSrc & SPECIAL_IRQS)
987                         SkGeSirqIsr(pAC, pAC->IoBase, IntSrc);
988
989                 SkEventDispatcher(pAC, pAC->IoBase);
990                 spin_unlock(&pAC->SlowPathLock);
991         }
992         /*
993          * do it all again is case we cleared an interrupt that
994          * came in after handling the ring (OUTs may be delayed
995          * in hardware buffers, but are through after IN)
996          *
997          * rroesler: has been commented out and shifted to
998          *           SkGeDrvEvent(), because it is timer
999          *           guarded now
1000          *
1001         ReceiveIrq(pAC, &pAC->RxPort[0], SK_TRUE);
1002         ReceiveIrq(pAC, &pAC->RxPort[1], SK_TRUE);
1003          */
1004
1005         if (pAC->CheckQueue) {
1006                 pAC->CheckQueue = SK_FALSE;
1007                 spin_lock(&pAC->SlowPathLock);
1008                 SkEventDispatcher(pAC, pAC->IoBase);
1009                 spin_unlock(&pAC->SlowPathLock);
1010         }
1011
1012         /* IRQ is processed - Enable IRQs again*/
1013         SK_OUT32(pAC->IoBase, B0_IMSK, pAC->GIni.GIValIrqMask);
1014
1015                 return SkIsrRetHandled;
1016 } /* SkGeIsr */
1017
1018
1019 /****************************************************************************
1020  *
1021  *      SkGeIsrOnePort - handle adapter interrupts for single port adapter
1022  *
1023  * Description:
1024  *      The interrupt routine is called when the network adapter
1025  *      generates an interrupt. It may also be called if another device
1026  *      shares this interrupt vector with the driver.
1027  *      This is the same as above, but handles only one port.
1028  *
1029  * Returns: N/A
1030  *
1031  */
1032 static SkIsrRetVar SkGeIsrOnePort(int irq, void *dev_id, struct pt_regs *ptregs)
1033 {
1034 struct SK_NET_DEVICE *dev = (struct SK_NET_DEVICE *)dev_id;
1035 DEV_NET         *pNet;
1036 SK_AC           *pAC;
1037 SK_U32          IntSrc;         /* interrupts source register contents */       
1038
1039         pNet = netdev_priv(dev);
1040         pAC = pNet->pAC;
1041         
1042         /*
1043          * Check and process if its our interrupt
1044          */
1045         SK_IN32(pAC->IoBase, B0_SP_ISRC, &IntSrc);
1046         if (IntSrc == 0) {
1047                 return SkIsrRetNone;
1048         }
1049         
1050         while (((IntSrc & IRQ_MASK) & ~SPECIAL_IRQS) != 0) {
1051 #if 0 /* software irq currently not used */
1052                 if (IntSrc & IS_IRQ_SW) {
1053                         SK_DBG_MSG(NULL, SK_DBGMOD_DRV,
1054                                 SK_DBGCAT_DRV_INT_SRC,
1055                                 ("Software IRQ\n"));
1056                 }
1057 #endif
1058                 if (IntSrc & IS_R1_F) {
1059                         SK_DBG_MSG(NULL, SK_DBGMOD_DRV,
1060                                 SK_DBGCAT_DRV_INT_SRC,
1061                                 ("EOF RX1 IRQ\n"));
1062                         ReceiveIrq(pAC, &pAC->RxPort[0], SK_TRUE);
1063                         SK_PNMI_CNT_RX_INTR(pAC, 0);
1064                 }
1065 #ifdef USE_TX_COMPLETE /* only if tx complete interrupt used */
1066                 if (IntSrc & IS_XA1_F) {
1067                         SK_DBG_MSG(NULL, SK_DBGMOD_DRV,
1068                                 SK_DBGCAT_DRV_INT_SRC,
1069                                 ("EOF AS TX1 IRQ\n"));
1070                         SK_PNMI_CNT_TX_INTR(pAC, 0);
1071                         spin_lock(&pAC->TxPort[0][TX_PRIO_LOW].TxDesRingLock);
1072                         FreeTxDescriptors(pAC, &pAC->TxPort[0][TX_PRIO_LOW]);
1073                         spin_unlock(&pAC->TxPort[0][TX_PRIO_LOW].TxDesRingLock);
1074                 }
1075 #if 0 /* only if sync. queues used */
1076                 if (IntSrc & IS_XS1_F) {
1077                         SK_DBG_MSG(NULL, SK_DBGMOD_DRV,
1078                                 SK_DBGCAT_DRV_INT_SRC,
1079                                 ("EOF SY TX1 IRQ\n"));
1080                         SK_PNMI_CNT_TX_INTR(pAC, 0);
1081                         spin_lock(&pAC->TxPort[0][TX_PRIO_HIGH].TxDesRingLock);
1082                         FreeTxDescriptors(pAC, 0, TX_PRIO_HIGH);
1083                         spin_unlock(&pAC->TxPort[0][TX_PRIO_HIGH].TxDesRingLock);
1084                         ClearTxIrq(pAC, 0, TX_PRIO_HIGH);
1085                 }
1086 #endif
1087 #endif
1088
1089                 /* do all IO at once */
1090                 if (IntSrc & IS_R1_F)
1091                         ClearAndStartRx(pAC, 0);
1092 #ifdef USE_TX_COMPLETE /* only if tx complete interrupt used */
1093                 if (IntSrc & IS_XA1_F)
1094                         ClearTxIrq(pAC, 0, TX_PRIO_LOW);
1095 #endif
1096                 SK_IN32(pAC->IoBase, B0_ISRC, &IntSrc);
1097         } /* while (IntSrc & IRQ_MASK != 0) */
1098         
1099         IntSrc &= pAC->GIni.GIValIrqMask;
1100         if ((IntSrc & SPECIAL_IRQS) || pAC->CheckQueue) {
1101                 SK_DBG_MSG(NULL, SK_DBGMOD_DRV, SK_DBGCAT_DRV_INT_SRC,
1102                         ("SPECIAL IRQ SP-Cards => %x\n", IntSrc));
1103                 pAC->CheckQueue = SK_FALSE;
1104                 spin_lock(&pAC->SlowPathLock);
1105                 if (IntSrc & SPECIAL_IRQS)
1106                         SkGeSirqIsr(pAC, pAC->IoBase, IntSrc);
1107
1108                 SkEventDispatcher(pAC, pAC->IoBase);
1109                 spin_unlock(&pAC->SlowPathLock);
1110         }
1111         /*
1112          * do it all again is case we cleared an interrupt that
1113          * came in after handling the ring (OUTs may be delayed
1114          * in hardware buffers, but are through after IN)
1115          *
1116          * rroesler: has been commented out and shifted to
1117          *           SkGeDrvEvent(), because it is timer
1118          *           guarded now
1119          *
1120         ReceiveIrq(pAC, &pAC->RxPort[0], SK_TRUE);
1121          */
1122
1123         /* IRQ is processed - Enable IRQs again*/
1124         SK_OUT32(pAC->IoBase, B0_IMSK, pAC->GIni.GIValIrqMask);
1125
1126                 return SkIsrRetHandled;
1127 } /* SkGeIsrOnePort */
1128
1129 #ifdef CONFIG_NET_POLL_CONTROLLER
1130 /****************************************************************************
1131  *
1132  *      SkGePollController - polling receive, for netconsole
1133  *
1134  * Description:
1135  *      Polling receive - used by netconsole and other diagnostic tools
1136  *      to allow network i/o with interrupts disabled.
1137  *
1138  * Returns: N/A
1139  */
1140 static void SkGePollController(struct net_device *dev)
1141 {
1142         disable_irq(dev->irq);
1143         SkGeIsr(dev->irq, dev, NULL);
1144         enable_irq(dev->irq);
1145 }
1146 #endif
1147
1148 /****************************************************************************
1149  *
1150  *      SkGeOpen - handle start of initialized adapter
1151  *
1152  * Description:
1153  *      This function starts the initialized adapter.
1154  *      The board level variable is set and the adapter is
1155  *      brought to full functionality.
1156  *      The device flags are set for operation.
1157  *      Do all necessary level 2 initialization, enable interrupts and
1158  *      give start command to RLMT.
1159  *
1160  * Returns:
1161  *      0 on success
1162  *      != 0 on error
1163  */
1164 static int SkGeOpen(
1165 struct SK_NET_DEVICE    *dev)
1166 {
1167         DEV_NET                 *pNet;
1168         SK_AC                   *pAC;
1169         unsigned long   Flags;          /* for spin lock */
1170         int                             i;
1171         SK_EVPARA               EvPara;         /* an event parameter union */
1172
1173         pNet = netdev_priv(dev);
1174         pAC = pNet->pAC;
1175         
1176         SK_DBG_MSG(NULL, SK_DBGMOD_DRV, SK_DBGCAT_DRV_ENTRY,
1177                 ("SkGeOpen: pAC=0x%lX:\n", (unsigned long)pAC));
1178
1179 #ifdef SK_DIAG_SUPPORT
1180         if (pAC->DiagModeActive == DIAG_ACTIVE) {
1181                 if (pAC->Pnmi.DiagAttached == SK_DIAG_RUNNING) {
1182                         return (-1);   /* still in use by diag; deny actions */
1183                 } 
1184         }
1185 #endif
1186
1187         /* Set blink mode */
1188         if ((pAC->PciDev->vendor == 0x1186) || (pAC->PciDev->vendor == 0x11ab ))
1189                 pAC->GIni.GILedBlinkCtrl = OEM_CONFIG_VALUE;
1190
1191         if (pAC->BoardLevel == SK_INIT_DATA) {
1192                 /* level 1 init common modules here */
1193                 if (SkGeInit(pAC, pAC->IoBase, SK_INIT_IO) != 0) {
1194                         printk("%s: HWInit (1) failed.\n", pAC->dev[pNet->PortNr]->name);
1195                         return (-1);
1196                 }
1197                 SkI2cInit       (pAC, pAC->IoBase, SK_INIT_IO);
1198                 SkEventInit     (pAC, pAC->IoBase, SK_INIT_IO);
1199                 SkPnmiInit      (pAC, pAC->IoBase, SK_INIT_IO);
1200                 SkAddrInit      (pAC, pAC->IoBase, SK_INIT_IO);
1201                 SkRlmtInit      (pAC, pAC->IoBase, SK_INIT_IO);
1202                 SkTimerInit     (pAC, pAC->IoBase, SK_INIT_IO);
1203                 pAC->BoardLevel = SK_INIT_IO;
1204         }
1205
1206         if (pAC->BoardLevel != SK_INIT_RUN) {
1207                 /* tschilling: Level 2 init modules here, check return value. */
1208                 if (SkGeInit(pAC, pAC->IoBase, SK_INIT_RUN) != 0) {
1209                         printk("%s: HWInit (2) failed.\n", pAC->dev[pNet->PortNr]->name);
1210                         return (-1);
1211                 }
1212                 SkI2cInit       (pAC, pAC->IoBase, SK_INIT_RUN);
1213                 SkEventInit     (pAC, pAC->IoBase, SK_INIT_RUN);
1214                 SkPnmiInit      (pAC, pAC->IoBase, SK_INIT_RUN);
1215                 SkAddrInit      (pAC, pAC->IoBase, SK_INIT_RUN);
1216                 SkRlmtInit      (pAC, pAC->IoBase, SK_INIT_RUN);
1217                 SkTimerInit     (pAC, pAC->IoBase, SK_INIT_RUN);
1218                 pAC->BoardLevel = SK_INIT_RUN;
1219         }
1220
1221         for (i=0; i<pAC->GIni.GIMacsFound; i++) {
1222                 /* Enable transmit descriptor polling. */
1223                 SkGePollTxD(pAC, pAC->IoBase, i, SK_TRUE);
1224                 FillRxRing(pAC, &pAC->RxPort[i]);
1225         }
1226         SkGeYellowLED(pAC, pAC->IoBase, 1);
1227
1228         StartDrvCleanupTimer(pAC);
1229         SkDimEnableModerationIfNeeded(pAC);     
1230         SkDimDisplayModerationSettings(pAC);
1231
1232         pAC->GIni.GIValIrqMask &= IRQ_MASK;
1233
1234         /* enable Interrupts */
1235         SK_OUT32(pAC->IoBase, B0_IMSK, pAC->GIni.GIValIrqMask);
1236         SK_OUT32(pAC->IoBase, B0_HWE_IMSK, IRQ_HWE_MASK);
1237
1238         spin_lock_irqsave(&pAC->SlowPathLock, Flags);
1239
1240         if ((pAC->RlmtMode != 0) && (pAC->MaxPorts == 0)) {
1241                 EvPara.Para32[0] = pAC->RlmtNets;
1242                 EvPara.Para32[1] = -1;
1243                 SkEventQueue(pAC, SKGE_RLMT, SK_RLMT_SET_NETS,
1244                         EvPara);
1245                 EvPara.Para32[0] = pAC->RlmtMode;
1246                 EvPara.Para32[1] = 0;
1247                 SkEventQueue(pAC, SKGE_RLMT, SK_RLMT_MODE_CHANGE,
1248                         EvPara);
1249         }
1250
1251         EvPara.Para32[0] = pNet->NetNr;
1252         EvPara.Para32[1] = -1;
1253         SkEventQueue(pAC, SKGE_RLMT, SK_RLMT_START, EvPara);
1254         SkEventDispatcher(pAC, pAC->IoBase);
1255         spin_unlock_irqrestore(&pAC->SlowPathLock, Flags);
1256
1257         pAC->MaxPorts++;
1258
1259
1260         SK_DBG_MSG(NULL, SK_DBGMOD_DRV, SK_DBGCAT_DRV_ENTRY,
1261                 ("SkGeOpen suceeded\n"));
1262
1263         return (0);
1264 } /* SkGeOpen */
1265
1266
1267 /****************************************************************************
1268  *
1269  *      SkGeClose - Stop initialized adapter
1270  *
1271  * Description:
1272  *      Close initialized adapter.
1273  *
1274  * Returns:
1275  *      0 - on success
1276  *      error code - on error
1277  */
1278 static int SkGeClose(
1279 struct SK_NET_DEVICE    *dev)
1280 {
1281         DEV_NET         *pNet;
1282         DEV_NET         *newPtrNet;
1283         SK_AC           *pAC;
1284
1285         unsigned long   Flags;          /* for spin lock */
1286         int             i;
1287         int             PortIdx;
1288         SK_EVPARA       EvPara;
1289
1290         SK_DBG_MSG(NULL, SK_DBGMOD_DRV, SK_DBGCAT_DRV_ENTRY,
1291                 ("SkGeClose: pAC=0x%lX ", (unsigned long)pAC));
1292
1293         pNet = netdev_priv(dev);
1294         pAC = pNet->pAC;
1295
1296 #ifdef SK_DIAG_SUPPORT
1297         if (pAC->DiagModeActive == DIAG_ACTIVE) {
1298                 if (pAC->DiagFlowCtrl == SK_FALSE) {
1299                         /* 
1300                         ** notify that the interface which has been closed
1301                         ** by operator interaction must not be started up 
1302                         ** again when the DIAG has finished. 
1303                         */
1304                         newPtrNet = netdev_priv(pAC->dev[0]);
1305                         if (newPtrNet == pNet) {
1306                                 pAC->WasIfUp[0] = SK_FALSE;
1307                         } else {
1308                                 pAC->WasIfUp[1] = SK_FALSE;
1309                         }
1310                         return 0; /* return to system everything is fine... */
1311                 } else {
1312                         pAC->DiagFlowCtrl = SK_FALSE;
1313                 }
1314         }
1315 #endif
1316
1317         netif_stop_queue(dev);
1318
1319         if (pAC->RlmtNets == 1)
1320                 PortIdx = pAC->ActivePort;
1321         else
1322                 PortIdx = pNet->NetNr;
1323
1324         StopDrvCleanupTimer(pAC);
1325
1326         /*
1327          * Clear multicast table, promiscuous mode ....
1328          */
1329         SkAddrMcClear(pAC, pAC->IoBase, PortIdx, 0);
1330         SkAddrPromiscuousChange(pAC, pAC->IoBase, PortIdx,
1331                 SK_PROM_MODE_NONE);
1332
1333         if (pAC->MaxPorts == 1) {
1334                 spin_lock_irqsave(&pAC->SlowPathLock, Flags);
1335                 /* disable interrupts */
1336                 SK_OUT32(pAC->IoBase, B0_IMSK, 0);
1337                 EvPara.Para32[0] = pNet->NetNr;
1338                 EvPara.Para32[1] = -1;
1339                 SkEventQueue(pAC, SKGE_RLMT, SK_RLMT_STOP, EvPara);
1340                 SkEventDispatcher(pAC, pAC->IoBase);
1341                 SK_OUT32(pAC->IoBase, B0_IMSK, 0);
1342                 /* stop the hardware */
1343                 SkGeDeInit(pAC, pAC->IoBase);
1344                 pAC->BoardLevel = SK_INIT_DATA;
1345                 spin_unlock_irqrestore(&pAC->SlowPathLock, Flags);
1346         } else {
1347
1348                 spin_lock_irqsave(&pAC->SlowPathLock, Flags);
1349                 EvPara.Para32[0] = pNet->NetNr;
1350                 EvPara.Para32[1] = -1;
1351                 SkEventQueue(pAC, SKGE_RLMT, SK_RLMT_STOP, EvPara);
1352                 SkPnmiEvent(pAC, pAC->IoBase, SK_PNMI_EVT_XMAC_RESET, EvPara);
1353                 SkEventDispatcher(pAC, pAC->IoBase);
1354                 spin_unlock_irqrestore(&pAC->SlowPathLock, Flags);
1355                 
1356                 /* Stop port */
1357                 spin_lock_irqsave(&pAC->TxPort[pNet->PortNr]
1358                         [TX_PRIO_LOW].TxDesRingLock, Flags);
1359                 SkGeStopPort(pAC, pAC->IoBase, pNet->PortNr,
1360                         SK_STOP_ALL, SK_HARD_RST);
1361                 spin_unlock_irqrestore(&pAC->TxPort[pNet->PortNr]
1362                         [TX_PRIO_LOW].TxDesRingLock, Flags);
1363         }
1364
1365         if (pAC->RlmtNets == 1) {
1366                 /* clear all descriptor rings */
1367                 for (i=0; i<pAC->GIni.GIMacsFound; i++) {
1368                         ReceiveIrq(pAC, &pAC->RxPort[i], SK_TRUE);
1369                         ClearRxRing(pAC, &pAC->RxPort[i]);
1370                         ClearTxRing(pAC, &pAC->TxPort[i][TX_PRIO_LOW]);
1371                 }
1372         } else {
1373                 /* clear port descriptor rings */
1374                 ReceiveIrq(pAC, &pAC->RxPort[pNet->PortNr], SK_TRUE);
1375                 ClearRxRing(pAC, &pAC->RxPort[pNet->PortNr]);
1376                 ClearTxRing(pAC, &pAC->TxPort[pNet->PortNr][TX_PRIO_LOW]);
1377         }
1378
1379         SK_DBG_MSG(NULL, SK_DBGMOD_DRV, SK_DBGCAT_DRV_ENTRY,
1380                 ("SkGeClose: done "));
1381
1382         SK_MEMSET(&(pAC->PnmiBackup), 0, sizeof(SK_PNMI_STRUCT_DATA));
1383         SK_MEMCPY(&(pAC->PnmiBackup), &(pAC->PnmiStruct), 
1384                         sizeof(SK_PNMI_STRUCT_DATA));
1385
1386         pAC->MaxPorts--;
1387
1388         return (0);
1389 } /* SkGeClose */
1390
1391
1392 /*****************************************************************************
1393  *
1394  *      SkGeXmit - Linux frame transmit function
1395  *
1396  * Description:
1397  *      The system calls this function to send frames onto the wire.
1398  *      It puts the frame in the tx descriptor ring. If the ring is
1399  *      full then, the 'tbusy' flag is set.
1400  *
1401  * Returns:
1402  *      0, if everything is ok
1403  *      !=0, on error
1404  * WARNING: returning 1 in 'tbusy' case caused system crashes (double
1405  *      allocated skb's) !!!
1406  */
1407 static int SkGeXmit(struct sk_buff *skb, struct SK_NET_DEVICE *dev)
1408 {
1409 DEV_NET         *pNet;
1410 SK_AC           *pAC;
1411 int                     Rc;     /* return code of XmitFrame */
1412
1413         pNet = netdev_priv(dev);
1414         pAC = pNet->pAC;
1415
1416         if ((!skb_shinfo(skb)->nr_frags) ||
1417                 (pAC->GIni.GIChipId == CHIP_ID_GENESIS)) {
1418                 /* Don't activate scatter-gather and hardware checksum */
1419
1420                 if (pAC->RlmtNets == 2)
1421                         Rc = XmitFrame(
1422                                 pAC,
1423                                 &pAC->TxPort[pNet->PortNr][TX_PRIO_LOW],
1424                                 skb);
1425                 else
1426                         Rc = XmitFrame(
1427                                 pAC,
1428                                 &pAC->TxPort[pAC->ActivePort][TX_PRIO_LOW],
1429                                 skb);
1430         } else {
1431                 /* scatter-gather and hardware TCP checksumming anabled*/
1432                 if (pAC->RlmtNets == 2)
1433                         Rc = XmitFrameSG(
1434                                 pAC,
1435                                 &pAC->TxPort[pNet->PortNr][TX_PRIO_LOW],
1436                                 skb);
1437                 else
1438                         Rc = XmitFrameSG(
1439                                 pAC,
1440                                 &pAC->TxPort[pAC->ActivePort][TX_PRIO_LOW],
1441                                 skb);
1442         }
1443
1444         /* Transmitter out of resources? */
1445         if (Rc <= 0) {
1446                 netif_stop_queue(dev);
1447         }
1448
1449         /* If not taken, give buffer ownership back to the
1450          * queueing layer.
1451          */
1452         if (Rc < 0)
1453                 return (1);
1454
1455         dev->trans_start = jiffies;
1456         return (0);
1457 } /* SkGeXmit */
1458
1459
1460 /*****************************************************************************
1461  *
1462  *      XmitFrame - fill one socket buffer into the transmit ring
1463  *
1464  * Description:
1465  *      This function puts a message into the transmit descriptor ring
1466  *      if there is a descriptors left.
1467  *      Linux skb's consist of only one continuous buffer.
1468  *      The first step locks the ring. It is held locked
1469  *      all time to avoid problems with SWITCH_../PORT_RESET.
1470  *      Then the descriptoris allocated.
1471  *      The second part is linking the buffer to the descriptor.
1472  *      At the very last, the Control field of the descriptor
1473  *      is made valid for the BMU and a start TX command is given
1474  *      if necessary.
1475  *
1476  * Returns:
1477  *      > 0 - on succes: the number of bytes in the message
1478  *      = 0 - on resource shortage: this frame sent or dropped, now
1479  *              the ring is full ( -> set tbusy)
1480  *      < 0 - on failure: other problems ( -> return failure to upper layers)
1481  */
1482 static int XmitFrame(
1483 SK_AC           *pAC,           /* pointer to adapter context           */
1484 TX_PORT         *pTxPort,       /* pointer to struct of port to send to */
1485 struct sk_buff  *pMessage)      /* pointer to send-message              */
1486 {
1487         TXD             *pTxd;          /* the rxd to fill */
1488         TXD             *pOldTxd;
1489         unsigned long    Flags;
1490         SK_U64           PhysAddr;
1491         int              BytesSend = pMessage->len;
1492
1493         SK_DBG_MSG(NULL, SK_DBGMOD_DRV, SK_DBGCAT_DRV_TX_PROGRESS, ("X"));
1494
1495         spin_lock_irqsave(&pTxPort->TxDesRingLock, Flags);
1496 #ifndef USE_TX_COMPLETE
1497         FreeTxDescriptors(pAC, pTxPort);
1498 #endif
1499         if (pTxPort->TxdRingFree == 0) {
1500                 /* 
1501                 ** no enough free descriptors in ring at the moment.
1502                 ** Maybe free'ing some old one help?
1503                 */
1504                 FreeTxDescriptors(pAC, pTxPort);
1505                 if (pTxPort->TxdRingFree == 0) {
1506                         spin_unlock_irqrestore(&pTxPort->TxDesRingLock, Flags);
1507                         SK_PNMI_CNT_NO_TX_BUF(pAC, pTxPort->PortIndex);
1508                         SK_DBG_MSG(NULL, SK_DBGMOD_DRV,
1509                                 SK_DBGCAT_DRV_TX_PROGRESS,
1510                                 ("XmitFrame failed\n"));
1511                         /* 
1512                         ** the desired message can not be sent
1513                         ** Because tbusy seems to be set, the message 
1514                         ** should not be freed here. It will be used 
1515                         ** by the scheduler of the ethernet handler 
1516                         */
1517                         return (-1);
1518                 }
1519         }
1520
1521         /*
1522         ** If the passed socket buffer is of smaller MTU-size than 60,
1523         ** copy everything into new buffer and fill all bytes between
1524         ** the original packet end and the new packet end of 60 with 0x00.
1525         ** This is to resolve faulty padding by the HW with 0xaa bytes.
1526         */
1527         if (BytesSend < C_LEN_ETHERNET_MINSIZE) {
1528                 if (skb_padto(pMessage, C_LEN_ETHERNET_MINSIZE)) {
1529                         spin_unlock_irqrestore(&pTxPort->TxDesRingLock, Flags);
1530                         return 0;
1531                 }
1532                 pMessage->len = C_LEN_ETHERNET_MINSIZE;
1533         }
1534
1535         /* 
1536         ** advance head counter behind descriptor needed for this frame, 
1537         ** so that needed descriptor is reserved from that on. The next
1538         ** action will be to add the passed buffer to the TX-descriptor
1539         */
1540         pTxd = pTxPort->pTxdRingHead;
1541         pTxPort->pTxdRingHead = pTxd->pNextTxd;
1542         pTxPort->TxdRingFree--;
1543
1544 #ifdef SK_DUMP_TX
1545         DumpMsg(pMessage, "XmitFrame");
1546 #endif
1547
1548         /* 
1549         ** First step is to map the data to be sent via the adapter onto
1550         ** the DMA memory. Kernel 2.2 uses virt_to_bus(), but kernels 2.4
1551         ** and 2.6 need to use pci_map_page() for that mapping.
1552         */
1553         PhysAddr = (SK_U64) pci_map_page(pAC->PciDev,
1554                                         virt_to_page(pMessage->data),
1555                                         ((unsigned long) pMessage->data & ~PAGE_MASK),
1556                                         pMessage->len,
1557                                         PCI_DMA_TODEVICE);
1558         pTxd->VDataLow  = (SK_U32) (PhysAddr & 0xffffffff);
1559         pTxd->VDataHigh = (SK_U32) (PhysAddr >> 32);
1560         pTxd->pMBuf     = pMessage;
1561
1562         if (pMessage->ip_summed == CHECKSUM_HW) {
1563                 u16 hdrlen = pMessage->h.raw - pMessage->data;
1564                 u16 offset = hdrlen + pMessage->csum;
1565
1566                 if ((pMessage->h.ipiph->protocol == IPPROTO_UDP ) &&
1567                         (pAC->GIni.GIChipRev == 0) &&
1568                         (pAC->GIni.GIChipId == CHIP_ID_YUKON)) {
1569                         pTxd->TBControl = BMU_TCP_CHECK;
1570                 } else {
1571                         pTxd->TBControl = BMU_UDP_CHECK;
1572                 }
1573
1574                 pTxd->TcpSumOfs = 0;
1575                 pTxd->TcpSumSt  = hdrlen;
1576                 pTxd->TcpSumWr  = offset;
1577
1578                 pTxd->TBControl |= BMU_OWN | BMU_STF | 
1579                                    BMU_SW  | BMU_EOF |
1580 #ifdef USE_TX_COMPLETE
1581                                    BMU_IRQ_EOF |
1582 #endif
1583                                    pMessage->len;
1584         } else {
1585                 pTxd->TBControl = BMU_OWN | BMU_STF | BMU_CHECK | 
1586                                   BMU_SW  | BMU_EOF |
1587 #ifdef USE_TX_COMPLETE
1588                                    BMU_IRQ_EOF |
1589 #endif
1590                         pMessage->len;
1591         }
1592
1593         /* 
1594         ** If previous descriptor already done, give TX start cmd 
1595         */
1596         pOldTxd = xchg(&pTxPort->pTxdRingPrev, pTxd);
1597         if ((pOldTxd->TBControl & BMU_OWN) == 0) {
1598                 SK_OUT8(pTxPort->HwAddr, Q_CSR, CSR_START);
1599         }       
1600
1601         /* 
1602         ** after releasing the lock, the skb may immediately be free'd 
1603         */
1604         spin_unlock_irqrestore(&pTxPort->TxDesRingLock, Flags);
1605         if (pTxPort->TxdRingFree != 0) {
1606                 return (BytesSend);
1607         } else {
1608                 return (0);
1609         }
1610
1611 } /* XmitFrame */
1612
1613 /*****************************************************************************
1614  *
1615  *      XmitFrameSG - fill one socket buffer into the transmit ring
1616  *                (use SG and TCP/UDP hardware checksumming)
1617  *
1618  * Description:
1619  *      This function puts a message into the transmit descriptor ring
1620  *      if there is a descriptors left.
1621  *
1622  * Returns:
1623  *      > 0 - on succes: the number of bytes in the message
1624  *      = 0 - on resource shortage: this frame sent or dropped, now
1625  *              the ring is full ( -> set tbusy)
1626  *      < 0 - on failure: other problems ( -> return failure to upper layers)
1627  */
1628 static int XmitFrameSG(
1629 SK_AC           *pAC,           /* pointer to adapter context           */
1630 TX_PORT         *pTxPort,       /* pointer to struct of port to send to */
1631 struct sk_buff  *pMessage)      /* pointer to send-message              */
1632 {
1633
1634         TXD             *pTxd;
1635         TXD             *pTxdFst;
1636         TXD             *pTxdLst;
1637         int              CurrFrag;
1638         int              BytesSend;
1639         skb_frag_t      *sk_frag;
1640         SK_U64           PhysAddr;
1641         unsigned long    Flags;
1642         SK_U32           Control;
1643
1644         spin_lock_irqsave(&pTxPort->TxDesRingLock, Flags);
1645 #ifndef USE_TX_COMPLETE
1646         FreeTxDescriptors(pAC, pTxPort);
1647 #endif
1648         if ((skb_shinfo(pMessage)->nr_frags +1) > pTxPort->TxdRingFree) {
1649                 FreeTxDescriptors(pAC, pTxPort);
1650                 if ((skb_shinfo(pMessage)->nr_frags + 1) > pTxPort->TxdRingFree) {
1651                         spin_unlock_irqrestore(&pTxPort->TxDesRingLock, Flags);
1652                         SK_PNMI_CNT_NO_TX_BUF(pAC, pTxPort->PortIndex);
1653                         SK_DBG_MSG(NULL, SK_DBGMOD_DRV,
1654                                 SK_DBGCAT_DRV_TX_PROGRESS,
1655                                 ("XmitFrameSG failed - Ring full\n"));
1656                                 /* this message can not be sent now */
1657                         return(-1);
1658                 }
1659         }
1660
1661         pTxd      = pTxPort->pTxdRingHead;
1662         pTxdFst   = pTxd;
1663         pTxdLst   = pTxd;
1664         BytesSend = 0;
1665
1666         /* 
1667         ** Map the first fragment (header) into the DMA-space
1668         */
1669         PhysAddr = (SK_U64) pci_map_page(pAC->PciDev,
1670                         virt_to_page(pMessage->data),
1671                         ((unsigned long) pMessage->data & ~PAGE_MASK),
1672                         skb_headlen(pMessage),
1673                         PCI_DMA_TODEVICE);
1674
1675         pTxd->VDataLow  = (SK_U32) (PhysAddr & 0xffffffff);
1676         pTxd->VDataHigh = (SK_U32) (PhysAddr >> 32);
1677
1678         /* 
1679         ** Does the HW need to evaluate checksum for TCP or UDP packets? 
1680         */
1681         if (pMessage->ip_summed == CHECKSUM_HW) {
1682                 u16 hdrlen = pMessage->h.raw - pMessage->data;
1683                 u16 offset = hdrlen + pMessage->csum;
1684
1685                 Control = BMU_STFWD;
1686
1687                 /* 
1688                 ** We have to use the opcode for tcp here,  because the
1689                 ** opcode for udp is not working in the hardware yet 
1690                 ** (Revision 2.0)
1691                 */
1692                 if ((pMessage->h.ipiph->protocol == IPPROTO_UDP ) &&
1693                         (pAC->GIni.GIChipRev == 0) &&
1694                         (pAC->GIni.GIChipId == CHIP_ID_YUKON)) {
1695                         Control |= BMU_TCP_CHECK;
1696                 } else {
1697                         Control |= BMU_UDP_CHECK;
1698                 }
1699
1700                 pTxd->TcpSumOfs = 0;
1701                 pTxd->TcpSumSt  = hdrlen;
1702                 pTxd->TcpSumWr  = offset;
1703         } else
1704                 Control = BMU_CHECK | BMU_SW;
1705
1706         pTxd->TBControl = BMU_STF | Control | skb_headlen(pMessage);
1707
1708         pTxd = pTxd->pNextTxd;
1709         pTxPort->TxdRingFree--;
1710         BytesSend += skb_headlen(pMessage);
1711
1712         /* 
1713         ** Browse over all SG fragments and map each of them into the DMA space
1714         */
1715         for (CurrFrag = 0; CurrFrag < skb_shinfo(pMessage)->nr_frags; CurrFrag++) {
1716                 sk_frag = &skb_shinfo(pMessage)->frags[CurrFrag];
1717                 /* 
1718                 ** we already have the proper value in entry
1719                 */
1720                 PhysAddr = (SK_U64) pci_map_page(pAC->PciDev,
1721                                                  sk_frag->page,
1722                                                  sk_frag->page_offset,
1723                                                  sk_frag->size,
1724                                                  PCI_DMA_TODEVICE);
1725
1726                 pTxd->VDataLow  = (SK_U32) (PhysAddr & 0xffffffff);
1727                 pTxd->VDataHigh = (SK_U32) (PhysAddr >> 32);
1728                 pTxd->pMBuf     = pMessage;
1729                 
1730                 pTxd->TBControl = Control | BMU_OWN | sk_frag->size;
1731
1732                 /* 
1733                 ** Do we have the last fragment? 
1734                 */
1735                 if( (CurrFrag+1) == skb_shinfo(pMessage)->nr_frags )  {
1736 #ifdef USE_TX_COMPLETE
1737                         pTxd->TBControl |= BMU_EOF | BMU_IRQ_EOF;
1738 #else
1739                         pTxd->TBControl |= BMU_EOF;
1740 #endif
1741                         pTxdFst->TBControl |= BMU_OWN | BMU_SW;
1742                 }
1743                 pTxdLst = pTxd;
1744                 pTxd    = pTxd->pNextTxd;
1745                 pTxPort->TxdRingFree--;
1746                 BytesSend += sk_frag->size;
1747         }
1748
1749         /* 
1750         ** If previous descriptor already done, give TX start cmd 
1751         */
1752         if ((pTxPort->pTxdRingPrev->TBControl & BMU_OWN) == 0) {
1753                 SK_OUT8(pTxPort->HwAddr, Q_CSR, CSR_START);
1754         }
1755
1756         pTxPort->pTxdRingPrev = pTxdLst;
1757         pTxPort->pTxdRingHead = pTxd;
1758
1759         spin_unlock_irqrestore(&pTxPort->TxDesRingLock, Flags);
1760
1761         if (pTxPort->TxdRingFree > 0) {
1762                 return (BytesSend);
1763         } else {
1764                 return (0);
1765         }
1766 }
1767
1768 /*****************************************************************************
1769  *
1770  *      FreeTxDescriptors - release descriptors from the descriptor ring
1771  *
1772  * Description:
1773  *      This function releases descriptors from a transmit ring if they
1774  *      have been sent by the BMU.
1775  *      If a descriptors is sent, it can be freed and the message can
1776  *      be freed, too.
1777  *      The SOFTWARE controllable bit is used to prevent running around a
1778  *      completely free ring for ever. If this bit is no set in the
1779  *      frame (by XmitFrame), this frame has never been sent or is
1780  *      already freed.
1781  *      The Tx descriptor ring lock must be held while calling this function !!!
1782  *
1783  * Returns:
1784  *      none
1785  */
1786 static void FreeTxDescriptors(
1787 SK_AC   *pAC,           /* pointer to the adapter context */
1788 TX_PORT *pTxPort)       /* pointer to destination port structure */
1789 {
1790 TXD     *pTxd;          /* pointer to the checked descriptor */
1791 TXD     *pNewTail;      /* pointer to 'end' of the ring */
1792 SK_U32  Control;        /* TBControl field of descriptor */
1793 SK_U64  PhysAddr;       /* address of DMA mapping */
1794
1795         pNewTail = pTxPort->pTxdRingTail;
1796         pTxd     = pNewTail;
1797         /*
1798         ** loop forever; exits if BMU_SW bit not set in start frame
1799         ** or BMU_OWN bit set in any frame
1800         */
1801         while (1) {
1802                 Control = pTxd->TBControl;
1803                 if ((Control & BMU_SW) == 0) {
1804                         /*
1805                         ** software controllable bit is set in first
1806                         ** fragment when given to BMU. Not set means that
1807                         ** this fragment was never sent or is already
1808                         ** freed ( -> ring completely free now).
1809                         */
1810                         pTxPort->pTxdRingTail = pTxd;
1811                         netif_wake_queue(pAC->dev[pTxPort->PortIndex]);
1812                         return;
1813                 }
1814                 if (Control & BMU_OWN) {
1815                         pTxPort->pTxdRingTail = pTxd;
1816                         if (pTxPort->TxdRingFree > 0) {
1817                                 netif_wake_queue(pAC->dev[pTxPort->PortIndex]);
1818                         }
1819                         return;
1820                 }
1821                 
1822                 /* 
1823                 ** release the DMA mapping, because until not unmapped
1824                 ** this buffer is considered being under control of the
1825                 ** adapter card!
1826                 */
1827                 PhysAddr = ((SK_U64) pTxd->VDataHigh) << (SK_U64) 32;
1828                 PhysAddr |= (SK_U64) pTxd->VDataLow;
1829                 pci_unmap_page(pAC->PciDev, PhysAddr,
1830                                  pTxd->pMBuf->len,
1831                                  PCI_DMA_TODEVICE);
1832
1833                 if (Control & BMU_EOF)
1834                         DEV_KFREE_SKB_ANY(pTxd->pMBuf); /* free message */
1835
1836                 pTxPort->TxdRingFree++;
1837                 pTxd->TBControl &= ~BMU_SW;
1838                 pTxd = pTxd->pNextTxd; /* point behind fragment with EOF */
1839         } /* while(forever) */
1840 } /* FreeTxDescriptors */
1841
1842 /*****************************************************************************
1843  *
1844  *      FillRxRing - fill the receive ring with valid descriptors
1845  *
1846  * Description:
1847  *      This function fills the receive ring descriptors with data
1848  *      segments and makes them valid for the BMU.
1849  *      The active ring is filled completely, if possible.
1850  *      The non-active ring is filled only partial to save memory.
1851  *
1852  * Description of rx ring structure:
1853  *      head - points to the descriptor which will be used next by the BMU
1854  *      tail - points to the next descriptor to give to the BMU
1855  *      
1856  * Returns:     N/A
1857  */
1858 static void FillRxRing(
1859 SK_AC           *pAC,           /* pointer to the adapter context */
1860 RX_PORT         *pRxPort)       /* ptr to port struct for which the ring
1861                                    should be filled */
1862 {
1863 unsigned long   Flags;
1864
1865         spin_lock_irqsave(&pRxPort->RxDesRingLock, Flags);
1866         while (pRxPort->RxdRingFree > pRxPort->RxFillLimit) {
1867                 if(!FillRxDescriptor(pAC, pRxPort))
1868                         break;
1869         }
1870         spin_unlock_irqrestore(&pRxPort->RxDesRingLock, Flags);
1871 } /* FillRxRing */
1872
1873
1874 /*****************************************************************************
1875  *
1876  *      FillRxDescriptor - fill one buffer into the receive ring
1877  *
1878  * Description:
1879  *      The function allocates a new receive buffer and
1880  *      puts it into the next descriptor.
1881  *
1882  * Returns:
1883  *      SK_TRUE - a buffer was added to the ring
1884  *      SK_FALSE - a buffer could not be added
1885  */
1886 static SK_BOOL FillRxDescriptor(
1887 SK_AC           *pAC,           /* pointer to the adapter context struct */
1888 RX_PORT         *pRxPort)       /* ptr to port struct of ring to fill */
1889 {
1890 struct sk_buff  *pMsgBlock;     /* pointer to a new message block */
1891 RXD             *pRxd;          /* the rxd to fill */
1892 SK_U16          Length;         /* data fragment length */
1893 SK_U64          PhysAddr;       /* physical address of a rx buffer */
1894
1895         pMsgBlock = alloc_skb(pAC->RxBufSize, GFP_ATOMIC);
1896         if (pMsgBlock == NULL) {
1897                 SK_DBG_MSG(NULL, SK_DBGMOD_DRV,
1898                         SK_DBGCAT_DRV_ENTRY,
1899                         ("%s: Allocation of rx buffer failed !\n",
1900                         pAC->dev[pRxPort->PortIndex]->name));
1901                 SK_PNMI_CNT_NO_RX_BUF(pAC, pRxPort->PortIndex);
1902                 return(SK_FALSE);
1903         }
1904         skb_reserve(pMsgBlock, 2); /* to align IP frames */
1905         /* skb allocated ok, so add buffer */
1906         pRxd = pRxPort->pRxdRingTail;
1907         pRxPort->pRxdRingTail = pRxd->pNextRxd;
1908         pRxPort->RxdRingFree--;
1909         Length = pAC->RxBufSize;
1910         PhysAddr = (SK_U64) pci_map_page(pAC->PciDev,
1911                 virt_to_page(pMsgBlock->data),
1912                 ((unsigned long) pMsgBlock->data &
1913                 ~PAGE_MASK),
1914                 pAC->RxBufSize - 2,
1915                 PCI_DMA_FROMDEVICE);
1916
1917         pRxd->VDataLow  = (SK_U32) (PhysAddr & 0xffffffff);
1918         pRxd->VDataHigh = (SK_U32) (PhysAddr >> 32);
1919         pRxd->pMBuf     = pMsgBlock;
1920         pRxd->RBControl = BMU_OWN       | 
1921                           BMU_STF       | 
1922                           BMU_IRQ_EOF   | 
1923                           BMU_TCP_CHECK | 
1924                           Length;
1925         return (SK_TRUE);
1926
1927 } /* FillRxDescriptor */
1928
1929
1930 /*****************************************************************************
1931  *
1932  *      ReQueueRxBuffer - fill one buffer back into the receive ring
1933  *
1934  * Description:
1935  *      Fill a given buffer back into the rx ring. The buffer
1936  *      has been previously allocated and aligned, and its phys.
1937  *      address calculated, so this is no more necessary.
1938  *
1939  * Returns: N/A
1940  */
1941 static void ReQueueRxBuffer(
1942 SK_AC           *pAC,           /* pointer to the adapter context struct */
1943 RX_PORT         *pRxPort,       /* ptr to port struct of ring to fill */
1944 struct sk_buff  *pMsg,          /* pointer to the buffer */
1945 SK_U32          PhysHigh,       /* phys address high dword */
1946 SK_U32          PhysLow)        /* phys address low dword */
1947 {
1948 RXD             *pRxd;          /* the rxd to fill */
1949 SK_U16          Length;         /* data fragment length */
1950
1951         pRxd = pRxPort->pRxdRingTail;
1952         pRxPort->pRxdRingTail = pRxd->pNextRxd;
1953         pRxPort->RxdRingFree--;
1954         Length = pAC->RxBufSize;
1955
1956         pRxd->VDataLow  = PhysLow;
1957         pRxd->VDataHigh = PhysHigh;
1958         pRxd->pMBuf     = pMsg;
1959         pRxd->RBControl = BMU_OWN       | 
1960                           BMU_STF       |
1961                           BMU_IRQ_EOF   | 
1962                           BMU_TCP_CHECK | 
1963                           Length;
1964         return;
1965 } /* ReQueueRxBuffer */
1966
1967 /*****************************************************************************
1968  *
1969  *      ReceiveIrq - handle a receive IRQ
1970  *
1971  * Description:
1972  *      This function is called when a receive IRQ is set.
1973  *      It walks the receive descriptor ring and sends up all
1974  *      frames that are complete.
1975  *
1976  * Returns:     N/A
1977  */
1978 static void ReceiveIrq(
1979         SK_AC           *pAC,                   /* pointer to adapter context */
1980         RX_PORT         *pRxPort,               /* pointer to receive port struct */
1981         SK_BOOL         SlowPathLock)   /* indicates if SlowPathLock is needed */
1982 {
1983 RXD                             *pRxd;                  /* pointer to receive descriptors */
1984 SK_U32                  Control;                /* control field of descriptor */
1985 struct sk_buff  *pMsg;                  /* pointer to message holding frame */
1986 struct sk_buff  *pNewMsg;               /* pointer to a new message for copying frame */
1987 int                             FrameLength;    /* total length of received frame */
1988 SK_MBUF                 *pRlmtMbuf;             /* ptr to a buffer for giving a frame to rlmt */
1989 SK_EVPARA               EvPara;                 /* an event parameter union */  
1990 unsigned long   Flags;                  /* for spin lock */
1991 int                             PortIndex = pRxPort->PortIndex;
1992 unsigned int    Offset;
1993 unsigned int    NumBytes;
1994 unsigned int    ForRlmt;
1995 SK_BOOL                 IsBc;
1996 SK_BOOL                 IsMc;
1997 SK_BOOL  IsBadFrame;                    /* Bad frame */
1998
1999 SK_U32                  FrameStat;
2000 SK_U64                  PhysAddr;
2001
2002 rx_start:       
2003         /* do forever; exit if BMU_OWN found */
2004         for ( pRxd = pRxPort->pRxdRingHead ;
2005                   pRxPort->RxdRingFree < pAC->RxDescrPerRing ;
2006                   pRxd = pRxd->pNextRxd,
2007                   pRxPort->pRxdRingHead = pRxd,
2008                   pRxPort->RxdRingFree ++) {
2009
2010                 /*
2011                  * For a better understanding of this loop
2012                  * Go through every descriptor beginning at the head
2013                  * Please note: the ring might be completely received so the OWN bit
2014                  * set is not a good crirteria to leave that loop.
2015                  * Therefore the RingFree counter is used.
2016                  * On entry of this loop pRxd is a pointer to the Rxd that needs
2017                  * to be checked next.
2018                  */
2019
2020                 Control = pRxd->RBControl;
2021         
2022                 /* check if this descriptor is ready */
2023                 if ((Control & BMU_OWN) != 0) {
2024                         /* this descriptor is not yet ready */
2025                         /* This is the usual end of the loop */
2026                         /* We don't need to start the ring again */
2027                         FillRxRing(pAC, pRxPort);
2028                         return;
2029                 }
2030                 pAC->DynIrqModInfo.NbrProcessedDescr++;
2031
2032                 /* get length of frame and check it */
2033                 FrameLength = Control & BMU_BBC;
2034                 if (FrameLength > pAC->RxBufSize) {
2035                         goto rx_failed;
2036                 }
2037
2038                 /* check for STF and EOF */
2039                 if ((Control & (BMU_STF | BMU_EOF)) != (BMU_STF | BMU_EOF)) {
2040                         goto rx_failed;
2041                 }
2042
2043                 /* here we have a complete frame in the ring */
2044                 pMsg = pRxd->pMBuf;
2045
2046                 FrameStat = pRxd->FrameStat;
2047
2048                 /* check for frame length mismatch */
2049 #define XMR_FS_LEN_SHIFT        18
2050 #define GMR_FS_LEN_SHIFT        16
2051                 if (pAC->GIni.GIChipId == CHIP_ID_GENESIS) {
2052                         if (FrameLength != (SK_U32) (FrameStat >> XMR_FS_LEN_SHIFT)) {
2053                                 SK_DBG_MSG(NULL, SK_DBGMOD_DRV,
2054                                         SK_DBGCAT_DRV_RX_PROGRESS,
2055                                         ("skge: Frame length mismatch (%u/%u).\n",
2056                                         FrameLength,
2057                                         (SK_U32) (FrameStat >> XMR_FS_LEN_SHIFT)));
2058                                 goto rx_failed;
2059                         }
2060                 }
2061                 else {
2062                         if (FrameLength != (SK_U32) (FrameStat >> GMR_FS_LEN_SHIFT)) {
2063                                 SK_DBG_MSG(NULL, SK_DBGMOD_DRV,
2064                                         SK_DBGCAT_DRV_RX_PROGRESS,
2065                                         ("skge: Frame length mismatch (%u/%u).\n",
2066                                         FrameLength,
2067                                         (SK_U32) (FrameStat >> XMR_FS_LEN_SHIFT)));
2068                                 goto rx_failed;
2069                         }
2070                 }
2071
2072                 /* Set Rx Status */
2073                 if (pAC->GIni.GIChipId == CHIP_ID_GENESIS) {
2074                         IsBc = (FrameStat & XMR_FS_BC) != 0;
2075                         IsMc = (FrameStat & XMR_FS_MC) != 0;
2076                         IsBadFrame = (FrameStat &
2077                                 (XMR_FS_ANY_ERR | XMR_FS_2L_VLAN)) != 0;
2078                 } else {
2079                         IsBc = (FrameStat & GMR_FS_BC) != 0;
2080                         IsMc = (FrameStat & GMR_FS_MC) != 0;
2081                         IsBadFrame = (((FrameStat & GMR_FS_ANY_ERR) != 0) ||
2082                                                         ((FrameStat & GMR_FS_RX_OK) == 0));
2083                 }
2084
2085                 SK_DBG_MSG(NULL, SK_DBGMOD_DRV, 0,
2086                         ("Received frame of length %d on port %d\n",
2087                         FrameLength, PortIndex));
2088                 SK_DBG_MSG(NULL, SK_DBGMOD_DRV, 0,
2089                         ("Number of free rx descriptors: %d\n",
2090                         pRxPort->RxdRingFree));
2091 /* DumpMsg(pMsg, "Rx"); */
2092
2093                 if ((Control & BMU_STAT_VAL) != BMU_STAT_VAL || (IsBadFrame)) {
2094 #if 0
2095                         (FrameStat & (XMR_FS_ANY_ERR | XMR_FS_2L_VLAN)) != 0) {
2096 #endif
2097                         /* there is a receive error in this frame */
2098                         SK_DBG_MSG(NULL, SK_DBGMOD_DRV,
2099                                 SK_DBGCAT_DRV_RX_PROGRESS,
2100                                 ("skge: Error in received frame, dropped!\n"
2101                                 "Control: %x\nRxStat: %x\n",
2102                                 Control, FrameStat));
2103
2104                         ReQueueRxBuffer(pAC, pRxPort, pMsg,
2105                                 pRxd->VDataHigh, pRxd->VDataLow);
2106
2107                         continue;
2108                 }
2109
2110                 /*
2111                  * if short frame then copy data to reduce memory waste
2112                  */
2113                 if ((FrameLength < SK_COPY_THRESHOLD) &&
2114                         ((pNewMsg = alloc_skb(FrameLength+2, GFP_ATOMIC)) != NULL)) {
2115                         /*
2116                          * Short frame detected and allocation successfull
2117                          */
2118                         /* use new skb and copy data */
2119                         skb_reserve(pNewMsg, 2);
2120                         skb_put(pNewMsg, FrameLength);
2121                         PhysAddr = ((SK_U64) pRxd->VDataHigh) << (SK_U64)32;
2122                         PhysAddr |= (SK_U64) pRxd->VDataLow;
2123
2124                         pci_dma_sync_single_for_cpu(pAC->PciDev,
2125                                                     (dma_addr_t) PhysAddr,
2126                                                     FrameLength,
2127                                                     PCI_DMA_FROMDEVICE);
2128                         memcpy(pNewMsg->data, pMsg, FrameLength);
2129
2130                         pci_dma_sync_single_for_device(pAC->PciDev,
2131                                                        (dma_addr_t) PhysAddr,
2132                                                        FrameLength,
2133                                                        PCI_DMA_FROMDEVICE);
2134                         ReQueueRxBuffer(pAC, pRxPort, pMsg,
2135                                 pRxd->VDataHigh, pRxd->VDataLow);
2136
2137                         pMsg = pNewMsg;
2138
2139                 }
2140                 else {
2141                         /*
2142                          * if large frame, or SKB allocation failed, pass
2143                          * the SKB directly to the networking
2144                          */
2145
2146                         PhysAddr = ((SK_U64) pRxd->VDataHigh) << (SK_U64)32;
2147                         PhysAddr |= (SK_U64) pRxd->VDataLow;
2148
2149                         /* release the DMA mapping */
2150                         pci_unmap_single(pAC->PciDev,
2151                                          PhysAddr,
2152                                          pAC->RxBufSize - 2,
2153                                          PCI_DMA_FROMDEVICE);
2154
2155                         /* set length in message */
2156                         skb_put(pMsg, FrameLength);
2157                 } /* frame > SK_COPY_TRESHOLD */
2158
2159 #ifdef USE_SK_RX_CHECKSUM
2160                 pMsg->csum = pRxd->TcpSums & 0xffff;
2161                 pMsg->ip_summed = CHECKSUM_HW;
2162 #else
2163                 pMsg->ip_summed = CHECKSUM_NONE;
2164 #endif
2165
2166                 SK_DBG_MSG(NULL, SK_DBGMOD_DRV, 1,("V"));
2167                 ForRlmt = SK_RLMT_RX_PROTOCOL;
2168 #if 0
2169                 IsBc = (FrameStat & XMR_FS_BC)==XMR_FS_BC;
2170 #endif
2171                 SK_RLMT_PRE_LOOKAHEAD(pAC, PortIndex, FrameLength,
2172                         IsBc, &Offset, &NumBytes);
2173                 if (NumBytes != 0) {
2174 #if 0
2175                         IsMc = (FrameStat & XMR_FS_MC)==XMR_FS_MC;
2176 #endif
2177                         SK_RLMT_LOOKAHEAD(pAC, PortIndex,
2178                                 &pMsg->data[Offset],
2179                                 IsBc, IsMc, &ForRlmt);
2180                 }
2181                 if (ForRlmt == SK_RLMT_RX_PROTOCOL) {
2182                                         SK_DBG_MSG(NULL, SK_DBGMOD_DRV, 1,("W"));
2183                         /* send up only frames from active port */
2184                         if ((PortIndex == pAC->ActivePort) ||
2185                                 (pAC->RlmtNets == 2)) {
2186                                 /* frame for upper layer */
2187                                 SK_DBG_MSG(NULL, SK_DBGMOD_DRV, 1,("U"));
2188 #ifdef xDEBUG
2189                                 DumpMsg(pMsg, "Rx");
2190 #endif
2191                                 SK_PNMI_CNT_RX_OCTETS_DELIVERED(pAC,
2192                                         FrameLength, pRxPort->PortIndex);
2193
2194                                 pMsg->dev = pAC->dev[pRxPort->PortIndex];
2195                                 pMsg->protocol = eth_type_trans(pMsg,
2196                                         pAC->dev[pRxPort->PortIndex]);
2197                                 netif_rx(pMsg);
2198                                 pAC->dev[pRxPort->PortIndex]->last_rx = jiffies;
2199                         }
2200                         else {
2201                                 /* drop frame */
2202                                 SK_DBG_MSG(NULL, SK_DBGMOD_DRV,
2203                                         SK_DBGCAT_DRV_RX_PROGRESS,
2204                                         ("D"));
2205                                 DEV_KFREE_SKB(pMsg);
2206                         }
2207                         
2208                 } /* if not for rlmt */
2209                 else {
2210                         /* packet for rlmt */
2211                         SK_DBG_MSG(NULL, SK_DBGMOD_DRV,
2212                                 SK_DBGCAT_DRV_RX_PROGRESS, ("R"));
2213                         pRlmtMbuf = SkDrvAllocRlmtMbuf(pAC,
2214                                 pAC->IoBase, FrameLength);
2215                         if (pRlmtMbuf != NULL) {
2216                                 pRlmtMbuf->pNext = NULL;
2217                                 pRlmtMbuf->Length = FrameLength;
2218                                 pRlmtMbuf->PortIdx = PortIndex;
2219                                 EvPara.pParaPtr = pRlmtMbuf;
2220                                 memcpy((char*)(pRlmtMbuf->pData),
2221                                            (char*)(pMsg->data),
2222                                            FrameLength);
2223
2224                                 /* SlowPathLock needed? */
2225                                 if (SlowPathLock == SK_TRUE) {
2226                                         spin_lock_irqsave(&pAC->SlowPathLock, Flags);
2227                                         SkEventQueue(pAC, SKGE_RLMT,
2228                                                 SK_RLMT_PACKET_RECEIVED,
2229                                                 EvPara);
2230                                         pAC->CheckQueue = SK_TRUE;
2231                                         spin_unlock_irqrestore(&pAC->SlowPathLock, Flags);
2232                                 } else {
2233                                         SkEventQueue(pAC, SKGE_RLMT,
2234                                                 SK_RLMT_PACKET_RECEIVED,
2235                                                 EvPara);
2236                                         pAC->CheckQueue = SK_TRUE;
2237                                 }
2238
2239                                 SK_DBG_MSG(NULL, SK_DBGMOD_DRV,
2240                                         SK_DBGCAT_DRV_RX_PROGRESS,
2241                                         ("Q"));
2242                         }
2243                         if ((pAC->dev[pRxPort->PortIndex]->flags &
2244                                 (IFF_PROMISC | IFF_ALLMULTI)) != 0 ||
2245                                 (ForRlmt & SK_RLMT_RX_PROTOCOL) ==
2246                                 SK_RLMT_RX_PROTOCOL) {
2247                                 pMsg->dev = pAC->dev[pRxPort->PortIndex];
2248                                 pMsg->protocol = eth_type_trans(pMsg,
2249                                         pAC->dev[pRxPort->PortIndex]);
2250                                 netif_rx(pMsg);
2251                                 pAC->dev[pRxPort->PortIndex]->last_rx = jiffies;
2252                         }
2253                         else {
2254                                 DEV_KFREE_SKB(pMsg);
2255                         }
2256
2257                 } /* if packet for rlmt */
2258         } /* for ... scanning the RXD ring */
2259
2260         /* RXD ring is empty -> fill and restart */
2261         FillRxRing(pAC, pRxPort);
2262         /* do not start if called from Close */
2263         if (pAC->BoardLevel > SK_INIT_DATA) {
2264                 ClearAndStartRx(pAC, PortIndex);
2265         }
2266         return;
2267
2268 rx_failed:
2269         /* remove error frame */
2270         SK_DBG_MSG(NULL, SK_DBGMOD_DRV, SK_DBGCAT_DRV_ERROR,
2271                 ("Schrottdescriptor, length: 0x%x\n", FrameLength));
2272
2273         /* release the DMA mapping */
2274
2275         PhysAddr = ((SK_U64) pRxd->VDataHigh) << (SK_U64)32;
2276         PhysAddr |= (SK_U64) pRxd->VDataLow;
2277         pci_unmap_page(pAC->PciDev,
2278                          PhysAddr,
2279                          pAC->RxBufSize - 2,
2280                          PCI_DMA_FROMDEVICE);
2281         DEV_KFREE_SKB_IRQ(pRxd->pMBuf);
2282         pRxd->pMBuf = NULL;
2283         pRxPort->RxdRingFree++;
2284         pRxPort->pRxdRingHead = pRxd->pNextRxd;
2285         goto rx_start;
2286
2287 } /* ReceiveIrq */
2288
2289
2290 /*****************************************************************************
2291  *
2292  *      ClearAndStartRx - give a start receive command to BMU, clear IRQ
2293  *
2294  * Description:
2295  *      This function sends a start command and a clear interrupt
2296  *      command for one receive queue to the BMU.
2297  *
2298  * Returns: N/A
2299  *      none
2300  */
2301 static void ClearAndStartRx(
2302 SK_AC   *pAC,           /* pointer to the adapter context */
2303 int     PortIndex)      /* index of the receive port (XMAC) */
2304 {
2305         SK_OUT8(pAC->IoBase,
2306                 RxQueueAddr[PortIndex]+Q_CSR,
2307                 CSR_START | CSR_IRQ_CL_F);
2308 } /* ClearAndStartRx */
2309
2310
2311 /*****************************************************************************
2312  *
2313  *      ClearTxIrq - give a clear transmit IRQ command to BMU
2314  *
2315  * Description:
2316  *      This function sends a clear tx IRQ command for one
2317  *      transmit queue to the BMU.
2318  *
2319  * Returns: N/A
2320  */
2321 static void ClearTxIrq(
2322 SK_AC   *pAC,           /* pointer to the adapter context */
2323 int     PortIndex,      /* index of the transmit port (XMAC) */
2324 int     Prio)           /* priority or normal queue */
2325 {
2326         SK_OUT8(pAC->IoBase, 
2327                 TxQueueAddr[PortIndex][Prio]+Q_CSR,
2328                 CSR_IRQ_CL_F);
2329 } /* ClearTxIrq */
2330
2331
2332 /*****************************************************************************
2333  *
2334  *      ClearRxRing - remove all buffers from the receive ring
2335  *
2336  * Description:
2337  *      This function removes all receive buffers from the ring.
2338  *      The receive BMU must be stopped before calling this function.
2339  *
2340  * Returns: N/A
2341  */
2342 static void ClearRxRing(
2343 SK_AC   *pAC,           /* pointer to adapter context */
2344 RX_PORT *pRxPort)       /* pointer to rx port struct */
2345 {
2346 RXD             *pRxd;  /* pointer to the current descriptor */
2347 unsigned long   Flags;
2348 SK_U64          PhysAddr;
2349
2350         if (pRxPort->RxdRingFree == pAC->RxDescrPerRing) {
2351                 return;
2352         }
2353         spin_lock_irqsave(&pRxPort->RxDesRingLock, Flags);
2354         pRxd = pRxPort->pRxdRingHead;
2355         do {
2356                 if (pRxd->pMBuf != NULL) {
2357
2358                         PhysAddr = ((SK_U64) pRxd->VDataHigh) << (SK_U64)32;
2359                         PhysAddr |= (SK_U64) pRxd->VDataLow;
2360                         pci_unmap_page(pAC->PciDev,
2361                                          PhysAddr,
2362                                          pAC->RxBufSize - 2,
2363                                          PCI_DMA_FROMDEVICE);
2364                         DEV_KFREE_SKB(pRxd->pMBuf);
2365                         pRxd->pMBuf = NULL;
2366                 }
2367                 pRxd->RBControl &= BMU_OWN;
2368                 pRxd = pRxd->pNextRxd;
2369                 pRxPort->RxdRingFree++;
2370         } while (pRxd != pRxPort->pRxdRingTail);
2371         pRxPort->pRxdRingTail = pRxPort->pRxdRingHead;
2372         spin_unlock_irqrestore(&pRxPort->RxDesRingLock, Flags);
2373 } /* ClearRxRing */
2374
2375 /*****************************************************************************
2376  *
2377  *      ClearTxRing - remove all buffers from the transmit ring
2378  *
2379  * Description:
2380  *      This function removes all transmit buffers from the ring.
2381  *      The transmit BMU must be stopped before calling this function
2382  *      and transmitting at the upper level must be disabled.
2383  *      The BMU own bit of all descriptors is cleared, the rest is
2384  *      done by calling FreeTxDescriptors.
2385  *
2386  * Returns: N/A
2387  */
2388 static void ClearTxRing(
2389 SK_AC   *pAC,           /* pointer to adapter context */
2390 TX_PORT *pTxPort)       /* pointer to tx prt struct */
2391 {
2392 TXD             *pTxd;          /* pointer to the current descriptor */
2393 int             i;
2394 unsigned long   Flags;
2395
2396         spin_lock_irqsave(&pTxPort->TxDesRingLock, Flags);
2397         pTxd = pTxPort->pTxdRingHead;
2398         for (i=0; i<pAC->TxDescrPerRing; i++) {
2399                 pTxd->TBControl &= ~BMU_OWN;
2400                 pTxd = pTxd->pNextTxd;
2401         }
2402         FreeTxDescriptors(pAC, pTxPort);
2403         spin_unlock_irqrestore(&pTxPort->TxDesRingLock, Flags);
2404 } /* ClearTxRing */
2405
2406 /*****************************************************************************
2407  *
2408  *      SkGeSetMacAddr - Set the hardware MAC address
2409  *
2410  * Description:
2411  *      This function sets the MAC address used by the adapter.
2412  *
2413  * Returns:
2414  *      0, if everything is ok
2415  *      !=0, on error
2416  */
2417 static int SkGeSetMacAddr(struct SK_NET_DEVICE *dev, void *p)
2418 {
2419
2420 DEV_NET *pNet = netdev_priv(dev);
2421 SK_AC   *pAC = pNet->pAC;
2422
2423 struct sockaddr *addr = p;
2424 unsigned long   Flags;
2425         
2426         SK_DBG_MSG(NULL, SK_DBGMOD_DRV, SK_DBGCAT_DRV_ENTRY,
2427                 ("SkGeSetMacAddr starts now...\n"));
2428         if(netif_running(dev))
2429                 return -EBUSY;
2430
2431         memcpy(dev->dev_addr, addr->sa_data,dev->addr_len);
2432         
2433         spin_lock_irqsave(&pAC->SlowPathLock, Flags);
2434
2435         if (pAC->RlmtNets == 2)
2436                 SkAddrOverride(pAC, pAC->IoBase, pNet->NetNr,
2437                         (SK_MAC_ADDR*)dev->dev_addr, SK_ADDR_VIRTUAL_ADDRESS);
2438         else
2439                 SkAddrOverride(pAC, pAC->IoBase, pAC->ActivePort,
2440                         (SK_MAC_ADDR*)dev->dev_addr, SK_ADDR_VIRTUAL_ADDRESS);
2441
2442         
2443         
2444         spin_unlock_irqrestore(&pAC->SlowPathLock, Flags);
2445         return 0;
2446 } /* SkGeSetMacAddr */
2447
2448
2449 /*****************************************************************************
2450  *
2451  *      SkGeSetRxMode - set receive mode
2452  *
2453  * Description:
2454  *      This function sets the receive mode of an adapter. The adapter
2455  *      supports promiscuous mode, allmulticast mode and a number of
2456  *      multicast addresses. If more multicast addresses the available
2457  *      are selected, a hash function in the hardware is used.
2458  *
2459  * Returns:
2460  *      0, if everything is ok
2461  *      !=0, on error
2462  */
2463 static void SkGeSetRxMode(struct SK_NET_DEVICE *dev)
2464 {
2465
2466 DEV_NET         *pNet;
2467 SK_AC           *pAC;
2468
2469 struct dev_mc_list      *pMcList;
2470 int                     i;
2471 int                     PortIdx;
2472 unsigned long           Flags;
2473
2474         SK_DBG_MSG(NULL, SK_DBGMOD_DRV, SK_DBGCAT_DRV_ENTRY,
2475                 ("SkGeSetRxMode starts now... "));
2476
2477         pNet = netdev_priv(dev);
2478         pAC = pNet->pAC;
2479         if (pAC->RlmtNets == 1)
2480                 PortIdx = pAC->ActivePort;
2481         else
2482                 PortIdx = pNet->NetNr;
2483
2484         spin_lock_irqsave(&pAC->SlowPathLock, Flags);
2485         if (dev->flags & IFF_PROMISC) {
2486                 SK_DBG_MSG(NULL, SK_DBGMOD_DRV, SK_DBGCAT_DRV_ENTRY,
2487                         ("PROMISCUOUS mode\n"));
2488                 SkAddrPromiscuousChange(pAC, pAC->IoBase, PortIdx,
2489                         SK_PROM_MODE_LLC);
2490         } else if (dev->flags & IFF_ALLMULTI) {
2491                 SK_DBG_MSG(NULL, SK_DBGMOD_DRV, SK_DBGCAT_DRV_ENTRY,
2492                         ("ALLMULTI mode\n"));
2493                 SkAddrPromiscuousChange(pAC, pAC->IoBase, PortIdx,
2494                         SK_PROM_MODE_ALL_MC);
2495         } else {
2496                 SkAddrPromiscuousChange(pAC, pAC->IoBase, PortIdx,
2497                         SK_PROM_MODE_NONE);
2498                 SkAddrMcClear(pAC, pAC->IoBase, PortIdx, 0);
2499
2500                 SK_DBG_MSG(NULL, SK_DBGMOD_DRV, SK_DBGCAT_DRV_ENTRY,
2501                         ("Number of MC entries: %d ", dev->mc_count));
2502                 
2503                 pMcList = dev->mc_list;
2504                 for (i=0; i<dev->mc_count; i++, pMcList = pMcList->next) {
2505                         SkAddrMcAdd(pAC, pAC->IoBase, PortIdx,
2506                                 (SK_MAC_ADDR*)pMcList->dmi_addr, 0);
2507                         SK_DBG_MSG(NULL, SK_DBGMOD_DRV, SK_DBGCAT_DRV_MCA,
2508                                 ("%02x:%02x:%02x:%02x:%02x:%02x\n",
2509                                 pMcList->dmi_addr[0],
2510                                 pMcList->dmi_addr[1],
2511                                 pMcList->dmi_addr[2],
2512                                 pMcList->dmi_addr[3],
2513                                 pMcList->dmi_addr[4],
2514                                 pMcList->dmi_addr[5]));
2515                 }
2516                 SkAddrMcUpdate(pAC, pAC->IoBase, PortIdx);
2517         }
2518         spin_unlock_irqrestore(&pAC->SlowPathLock, Flags);
2519         
2520         return;
2521 } /* SkGeSetRxMode */
2522
2523
2524 /*****************************************************************************
2525  *
2526  *      SkGeChangeMtu - set the MTU to another value
2527  *
2528  * Description:
2529  *      This function sets is called whenever the MTU size is changed
2530  *      (ifconfig mtu xxx dev ethX). If the MTU is bigger than standard
2531  *      ethernet MTU size, long frame support is activated.
2532  *
2533  * Returns:
2534  *      0, if everything is ok
2535  *      !=0, on error
2536  */
2537 static int SkGeChangeMtu(struct SK_NET_DEVICE *dev, int NewMtu)
2538 {
2539 DEV_NET         *pNet;
2540 struct net_device *pOtherDev;
2541 SK_AC           *pAC;
2542 unsigned long   Flags;
2543 int             i;
2544 SK_EVPARA       EvPara;
2545
2546         SK_DBG_MSG(NULL, SK_DBGMOD_DRV, SK_DBGCAT_DRV_ENTRY,
2547                 ("SkGeChangeMtu starts now...\n"));
2548
2549         pNet = netdev_priv(dev);
2550         pAC  = pNet->pAC;
2551
2552         if ((NewMtu < 68) || (NewMtu > SK_JUMBO_MTU)) {
2553                 return -EINVAL;
2554         }
2555
2556         if(pAC->BoardLevel != SK_INIT_RUN) {
2557                 return -EINVAL;
2558         }
2559
2560 #ifdef SK_DIAG_SUPPORT
2561         if (pAC->DiagModeActive == DIAG_ACTIVE) {
2562                 if (pAC->DiagFlowCtrl == SK_FALSE) {
2563                         return -1; /* still in use, deny any actions of MTU */
2564                 } else {
2565                         pAC->DiagFlowCtrl = SK_FALSE;
2566                 }
2567         }
2568 #endif
2569
2570         pOtherDev = pAC->dev[1 - pNet->NetNr];
2571
2572         if ( netif_running(pOtherDev) && (pOtherDev->mtu > 1500)
2573              && (NewMtu <= 1500))
2574                 return 0;
2575
2576         pAC->RxBufSize = NewMtu + 32;
2577         dev->mtu = NewMtu;
2578
2579         SK_DBG_MSG(NULL, SK_DBGMOD_DRV, SK_DBGCAT_DRV_ENTRY,
2580                 ("New MTU: %d\n", NewMtu));
2581
2582         /* 
2583         ** Prevent any reconfiguration while changing the MTU 
2584         ** by disabling any interrupts 
2585         */
2586         SK_OUT32(pAC->IoBase, B0_IMSK, 0);
2587         spin_lock_irqsave(&pAC->SlowPathLock, Flags);
2588
2589         /* 
2590         ** Notify RLMT that any ports are to be stopped
2591         */
2592         EvPara.Para32[0] =  0;
2593         EvPara.Para32[1] = -1;
2594         if ((pAC->GIni.GIMacsFound == 2 ) && (pAC->RlmtNets == 2)) {
2595                 SkEventQueue(pAC, SKGE_RLMT, SK_RLMT_STOP, EvPara);
2596                 EvPara.Para32[0] =  1;
2597                 SkEventQueue(pAC, SKGE_RLMT, SK_RLMT_STOP, EvPara);
2598         } else {
2599                 SkEventQueue(pAC, SKGE_RLMT, SK_RLMT_STOP, EvPara);
2600         }
2601
2602         /*
2603         ** After calling the SkEventDispatcher(), RLMT is aware about
2604         ** the stopped ports -> configuration can take place!
2605         */
2606         SkEventDispatcher(pAC, pAC->IoBase);
2607
2608         for (i=0; i<pAC->GIni.GIMacsFound; i++) {
2609                 spin_lock(&pAC->TxPort[i][TX_PRIO_LOW].TxDesRingLock);
2610                 netif_stop_queue(pAC->dev[i]);
2611
2612         }
2613
2614         /*
2615         ** Depending on the desired MTU size change, a different number of 
2616         ** RX buffers need to be allocated
2617         */
2618         if (NewMtu > 1500) {
2619             /* 
2620             ** Use less rx buffers 
2621             */
2622             for (i=0; i<pAC->GIni.GIMacsFound; i++) {
2623                 if ((pAC->GIni.GIMacsFound == 2 ) && (pAC->RlmtNets == 2)) {
2624                     pAC->RxPort[i].RxFillLimit =  pAC->RxDescrPerRing -
2625                                                  (pAC->RxDescrPerRing / 4);
2626                 } else {
2627                     if (i == pAC->ActivePort) {
2628                         pAC->RxPort[i].RxFillLimit = pAC->RxDescrPerRing - 
2629                                                     (pAC->RxDescrPerRing / 4);
2630                     } else {
2631                         pAC->RxPort[i].RxFillLimit = pAC->RxDescrPerRing - 
2632                                                     (pAC->RxDescrPerRing / 10);
2633                     }
2634                 }
2635             }
2636         } else {
2637             /* 
2638             ** Use the normal amount of rx buffers 
2639             */
2640             for (i=0; i<pAC->GIni.GIMacsFound; i++) {
2641                 if ((pAC->GIni.GIMacsFound == 2 ) && (pAC->RlmtNets == 2)) {
2642                     pAC->RxPort[i].RxFillLimit = 1;
2643                 } else {
2644                     if (i == pAC->ActivePort) {
2645                         pAC->RxPort[i].RxFillLimit = 1;
2646                     } else {
2647                         pAC->RxPort[i].RxFillLimit = pAC->RxDescrPerRing -
2648                                                     (pAC->RxDescrPerRing / 4);
2649                     }
2650                 }
2651             }
2652         }
2653         
2654         SkGeDeInit(pAC, pAC->IoBase);
2655
2656         /*
2657         ** enable/disable hardware support for long frames
2658         */
2659         if (NewMtu > 1500) {
2660 // pAC->JumboActivated = SK_TRUE; /* is never set back !!! */
2661                 pAC->GIni.GIPortUsage = SK_JUMBO_LINK;
2662         } else {
2663             if ((pAC->GIni.GIMacsFound == 2 ) && (pAC->RlmtNets == 2)) {
2664                 pAC->GIni.GIPortUsage = SK_MUL_LINK;
2665             } else {
2666                 pAC->GIni.GIPortUsage = SK_RED_LINK;
2667             }
2668         }
2669
2670         SkGeInit(   pAC, pAC->IoBase, SK_INIT_IO);
2671         SkI2cInit(  pAC, pAC->IoBase, SK_INIT_IO);
2672         SkEventInit(pAC, pAC->IoBase, SK_INIT_IO);
2673         SkPnmiInit( pAC, pAC->IoBase, SK_INIT_IO);
2674         SkAddrInit( pAC, pAC->IoBase, SK_INIT_IO);
2675         SkRlmtInit( pAC, pAC->IoBase, SK_INIT_IO);
2676         SkTimerInit(pAC, pAC->IoBase, SK_INIT_IO);
2677         
2678         /*
2679         ** tschilling:
2680         ** Speed and others are set back to default in level 1 init!
2681         */
2682         GetConfiguration(pAC);
2683         
2684         SkGeInit(   pAC, pAC->IoBase, SK_INIT_RUN);
2685         SkI2cInit(  pAC, pAC->IoBase, SK_INIT_RUN);
2686         SkEventInit(pAC, pAC->IoBase, SK_INIT_RUN);
2687         SkPnmiInit( pAC, pAC->IoBase, SK_INIT_RUN);
2688         SkAddrInit( pAC, pAC->IoBase, SK_INIT_RUN);
2689         SkRlmtInit( pAC, pAC->IoBase, SK_INIT_RUN);
2690         SkTimerInit(pAC, pAC->IoBase, SK_INIT_RUN);
2691
2692         /*
2693         ** clear and reinit the rx rings here
2694         */
2695         for (i=0; i<pAC->GIni.GIMacsFound; i++) {
2696                 ReceiveIrq(pAC, &pAC->RxPort[i], SK_TRUE);
2697                 ClearRxRing(pAC, &pAC->RxPort[i]);
2698                 FillRxRing(pAC, &pAC->RxPort[i]);
2699
2700                 /* 
2701                 ** Enable transmit descriptor polling
2702                 */
2703                 SkGePollTxD(pAC, pAC->IoBase, i, SK_TRUE);
2704                 FillRxRing(pAC, &pAC->RxPort[i]);
2705         };
2706
2707         SkGeYellowLED(pAC, pAC->IoBase, 1);
2708         SkDimEnableModerationIfNeeded(pAC);     
2709         SkDimDisplayModerationSettings(pAC);
2710
2711         netif_start_queue(pAC->dev[pNet->PortNr]);
2712         for (i=pAC->GIni.GIMacsFound-1; i>=0; i--) {
2713                 spin_unlock(&pAC->TxPort[i][TX_PRIO_LOW].TxDesRingLock);
2714         }
2715
2716         /* 
2717         ** Enable Interrupts again 
2718         */
2719         SK_OUT32(pAC->IoBase, B0_IMSK, pAC->GIni.GIValIrqMask);
2720         SK_OUT32(pAC->IoBase, B0_HWE_IMSK, IRQ_HWE_MASK);
2721
2722         SkEventQueue(pAC, SKGE_RLMT, SK_RLMT_START, EvPara);
2723         SkEventDispatcher(pAC, pAC->IoBase);
2724
2725         /* 
2726         ** Notify RLMT about the changing and restarting one (or more) ports
2727         */
2728         if ((pAC->GIni.GIMacsFound == 2 ) && (pAC->RlmtNets == 2)) {
2729                 EvPara.Para32[0] = pAC->RlmtNets;
2730                 EvPara.Para32[1] = -1;
2731                 SkEventQueue(pAC, SKGE_RLMT, SK_RLMT_SET_NETS, EvPara);
2732                 EvPara.Para32[0] = pNet->PortNr;
2733                 EvPara.Para32[1] = -1;
2734                 SkEventQueue(pAC, SKGE_RLMT, SK_RLMT_START, EvPara);
2735                         
2736                 if (netif_running(pOtherDev)) {
2737                         DEV_NET *pOtherNet = netdev_priv(pOtherDev);
2738                         EvPara.Para32[0] = pOtherNet->PortNr;
2739                         SkEventQueue(pAC, SKGE_RLMT, SK_RLMT_START, EvPara);
2740                 }
2741         } else {
2742                 SkEventQueue(pAC, SKGE_RLMT, SK_RLMT_START, EvPara);
2743         }
2744
2745         SkEventDispatcher(pAC, pAC->IoBase);
2746         spin_unlock_irqrestore(&pAC->SlowPathLock, Flags);
2747         
2748         /*
2749         ** While testing this driver with latest kernel 2.5 (2.5.70), it 
2750         ** seems as if upper layers have a problem to handle a successful
2751         ** return value of '0'. If such a zero is returned, the complete 
2752         ** system hangs for several minutes (!), which is in acceptable.
2753         **
2754         ** Currently it is not clear, what the exact reason for this problem
2755         ** is. The implemented workaround for 2.5 is to return the desired 
2756         ** new MTU size if all needed changes for the new MTU size where 
2757         ** performed. In kernels 2.2 and 2.4, a zero value is returned,
2758         ** which indicates the successful change of the mtu-size.
2759         */
2760         return NewMtu;
2761
2762 } /* SkGeChangeMtu */
2763
2764
2765 /*****************************************************************************
2766  *
2767  *      SkGeStats - return ethernet device statistics
2768  *
2769  * Description:
2770  *      This function return statistic data about the ethernet device
2771  *      to the operating system.
2772  *
2773  * Returns:
2774  *      pointer to the statistic structure.
2775  */
2776 static struct net_device_stats *SkGeStats(struct SK_NET_DEVICE *dev)
2777 {
2778 DEV_NET *pNet = netdev_priv(dev);
2779 SK_AC   *pAC = pNet->pAC;
2780 SK_PNMI_STRUCT_DATA *pPnmiStruct;       /* structure for all Pnmi-Data */
2781 SK_PNMI_STAT    *pPnmiStat;             /* pointer to virtual XMAC stat. data */
2782 SK_PNMI_CONF    *pPnmiConf;             /* pointer to virtual link config. */
2783 unsigned int    Size;                   /* size of pnmi struct */
2784 unsigned long   Flags;                  /* for spin lock */
2785
2786         SK_DBG_MSG(NULL, SK_DBGMOD_DRV, SK_DBGCAT_DRV_ENTRY,
2787                 ("SkGeStats starts now...\n"));
2788         pPnmiStruct = &pAC->PnmiStruct;
2789
2790 #ifdef SK_DIAG_SUPPORT
2791         if ((pAC->DiagModeActive == DIAG_NOTACTIVE) &&
2792                 (pAC->BoardLevel == SK_INIT_RUN)) {
2793 #endif
2794         SK_MEMSET(pPnmiStruct, 0, sizeof(SK_PNMI_STRUCT_DATA));
2795         spin_lock_irqsave(&pAC->SlowPathLock, Flags);
2796         Size = SK_PNMI_STRUCT_SIZE;
2797                 SkPnmiGetStruct(pAC, pAC->IoBase, pPnmiStruct, &Size, pNet->NetNr);
2798         spin_unlock_irqrestore(&pAC->SlowPathLock, Flags);
2799 #ifdef SK_DIAG_SUPPORT
2800         }
2801 #endif
2802
2803         pPnmiStat = &pPnmiStruct->Stat[0];
2804         pPnmiConf = &pPnmiStruct->Conf[0];
2805
2806         pAC->stats.rx_packets = (SK_U32) pPnmiStruct->RxDeliveredCts & 0xFFFFFFFF;
2807         pAC->stats.tx_packets = (SK_U32) pPnmiStat->StatTxOkCts & 0xFFFFFFFF;
2808         pAC->stats.rx_bytes = (SK_U32) pPnmiStruct->RxOctetsDeliveredCts;
2809         pAC->stats.tx_bytes = (SK_U32) pPnmiStat->StatTxOctetsOkCts;
2810         
2811         if (dev->mtu <= 1500) {
2812                 pAC->stats.rx_errors = (SK_U32) pPnmiStruct->InErrorsCts & 0xFFFFFFFF;
2813         } else {
2814                 pAC->stats.rx_errors = (SK_U32) ((pPnmiStruct->InErrorsCts -
2815                         pPnmiStat->StatRxTooLongCts) & 0xFFFFFFFF);
2816         }
2817
2818
2819         if (pAC->GIni.GP[0].PhyType == SK_PHY_XMAC && pAC->HWRevision < 12)
2820                 pAC->stats.rx_errors = pAC->stats.rx_errors - pPnmiStat->StatRxShortsCts;
2821
2822         pAC->stats.tx_errors = (SK_U32) pPnmiStat->StatTxSingleCollisionCts & 0xFFFFFFFF;
2823         pAC->stats.rx_dropped = (SK_U32) pPnmiStruct->RxNoBufCts & 0xFFFFFFFF;
2824         pAC->stats.tx_dropped = (SK_U32) pPnmiStruct->TxNoBufCts & 0xFFFFFFFF;
2825         pAC->stats.multicast = (SK_U32) pPnmiStat->StatRxMulticastOkCts & 0xFFFFFFFF;
2826         pAC->stats.collisions = (SK_U32) pPnmiStat->StatTxSingleCollisionCts & 0xFFFFFFFF;
2827
2828         /* detailed rx_errors: */
2829         pAC->stats.rx_length_errors = (SK_U32) pPnmiStat->StatRxRuntCts & 0xFFFFFFFF;
2830         pAC->stats.rx_over_errors = (SK_U32) pPnmiStat->StatRxFifoOverflowCts & 0xFFFFFFFF;
2831         pAC->stats.rx_crc_errors = (SK_U32) pPnmiStat->StatRxFcsCts & 0xFFFFFFFF;
2832         pAC->stats.rx_frame_errors = (SK_U32) pPnmiStat->StatRxFramingCts & 0xFFFFFFFF;
2833         pAC->stats.rx_fifo_errors = (SK_U32) pPnmiStat->StatRxFifoOverflowCts & 0xFFFFFFFF;
2834         pAC->stats.rx_missed_errors = (SK_U32) pPnmiStat->StatRxMissedCts & 0xFFFFFFFF;
2835
2836         /* detailed tx_errors */
2837         pAC->stats.tx_aborted_errors = (SK_U32) 0;
2838         pAC->stats.tx_carrier_errors = (SK_U32) pPnmiStat->StatTxCarrierCts & 0xFFFFFFFF;
2839         pAC->stats.tx_fifo_errors = (SK_U32) pPnmiStat->StatTxFifoUnderrunCts & 0xFFFFFFFF;
2840         pAC->stats.tx_heartbeat_errors = (SK_U32) pPnmiStat->StatTxCarrierCts & 0xFFFFFFFF;
2841         pAC->stats.tx_window_errors = (SK_U32) 0;
2842
2843         return(&pAC->stats);
2844 } /* SkGeStats */
2845
2846
2847 /*****************************************************************************
2848  *
2849  *      SkGeIoctl - IO-control function
2850  *
2851  * Description:
2852  *      This function is called if an ioctl is issued on the device.
2853  *      There are three subfunction for reading, writing and test-writing
2854  *      the private MIB data structure (useful for SysKonnect-internal tools).
2855  *
2856  * Returns:
2857  *      0, if everything is ok
2858  *      !=0, on error
2859  */
2860 static int SkGeIoctl(struct SK_NET_DEVICE *dev, struct ifreq *rq, int cmd)
2861 {
2862 DEV_NET         *pNet;
2863 SK_AC           *pAC;
2864 void            *pMemBuf;
2865 struct pci_dev  *pdev = NULL;
2866 SK_GE_IOCTL     Ioctl;
2867 unsigned int    Err = 0;
2868 int             Size = 0;
2869 int             Ret = 0;
2870 unsigned int    Length = 0;
2871 int             HeaderLength = sizeof(SK_U32) + sizeof(SK_U32);
2872
2873         SK_DBG_MSG(NULL, SK_DBGMOD_DRV, SK_DBGCAT_DRV_ENTRY,
2874                 ("SkGeIoctl starts now...\n"));
2875
2876         pNet = netdev_priv(dev);
2877         pAC = pNet->pAC;
2878         
2879         if(copy_from_user(&Ioctl, rq->ifr_data, sizeof(SK_GE_IOCTL))) {
2880                 return -EFAULT;
2881         }
2882
2883         switch(cmd) {
2884         case SK_IOCTL_SETMIB:
2885         case SK_IOCTL_PRESETMIB:
2886                 if (!capable(CAP_NET_ADMIN)) return -EPERM;
2887         case SK_IOCTL_GETMIB:
2888                 if(copy_from_user(&pAC->PnmiStruct, Ioctl.pData,
2889                         Ioctl.Len<sizeof(pAC->PnmiStruct)?
2890                         Ioctl.Len : sizeof(pAC->PnmiStruct))) {
2891                         return -EFAULT;
2892                 }
2893                 Size = SkGeIocMib(pNet, Ioctl.Len, cmd);
2894                 if(copy_to_user(Ioctl.pData, &pAC->PnmiStruct,
2895                         Ioctl.Len<Size? Ioctl.Len : Size)) {
2896                         return -EFAULT;
2897                 }
2898                 Ioctl.Len = Size;
2899                 if(copy_to_user(rq->ifr_data, &Ioctl, sizeof(SK_GE_IOCTL))) {
2900                         return -EFAULT;
2901                 }
2902                 break;
2903         case SK_IOCTL_GEN:
2904                 if (Ioctl.Len < (sizeof(pAC->PnmiStruct) + HeaderLength)) {
2905                         Length = Ioctl.Len;
2906                 } else {
2907                         Length = sizeof(pAC->PnmiStruct) + HeaderLength;
2908                 }
2909                 if (NULL == (pMemBuf = kmalloc(Length, GFP_KERNEL))) {
2910                         return -ENOMEM;
2911                 }
2912                 if(copy_from_user(pMemBuf, Ioctl.pData, Length)) {
2913                         Err = -EFAULT;
2914                         goto fault_gen;
2915                 }
2916                 if ((Ret = SkPnmiGenIoctl(pAC, pAC->IoBase, pMemBuf, &Length, 0)) < 0) {
2917                         Err = -EFAULT;
2918                         goto fault_gen;
2919                 }
2920                 if(copy_to_user(Ioctl.pData, pMemBuf, Length) ) {
2921                         Err = -EFAULT;
2922                         goto fault_gen;
2923                 }
2924                 Ioctl.Len = Length;
2925                 if(copy_to_user(rq->ifr_data, &Ioctl, sizeof(SK_GE_IOCTL))) {
2926                         Err = -EFAULT;
2927                         goto fault_gen;
2928                 }
2929 fault_gen:
2930                 kfree(pMemBuf); /* cleanup everything */
2931                 break;
2932 #ifdef SK_DIAG_SUPPORT
2933        case SK_IOCTL_DIAG:
2934                 if (!capable(CAP_NET_ADMIN)) return -EPERM;
2935                 if (Ioctl.Len < (sizeof(pAC->PnmiStruct) + HeaderLength)) {
2936                         Length = Ioctl.Len;
2937                 } else {
2938                         Length = sizeof(pAC->PnmiStruct) + HeaderLength;
2939                 }
2940                 if (NULL == (pMemBuf = kmalloc(Length, GFP_KERNEL))) {
2941                         return -ENOMEM;
2942                 }
2943                 if(copy_from_user(pMemBuf, Ioctl.pData, Length)) {
2944                         Err = -EFAULT;
2945                         goto fault_diag;
2946                 }
2947                 pdev = pAC->PciDev;
2948                 Length = 3 * sizeof(SK_U32);  /* Error, Bus and Device */
2949                 /* 
2950                 ** While coding this new IOCTL interface, only a few lines of code
2951                 ** are to to be added. Therefore no dedicated function has been 
2952                 ** added. If more functionality is added, a separate function 
2953                 ** should be used...
2954                 */
2955                 * ((SK_U32 *)pMemBuf) = 0;
2956                 * ((SK_U32 *)pMemBuf + 1) = pdev->bus->number;
2957                 * ((SK_U32 *)pMemBuf + 2) = ParseDeviceNbrFromSlotName(pci_name(pdev));
2958                 if(copy_to_user(Ioctl.pData, pMemBuf, Length) ) {
2959                         Err = -EFAULT;
2960                         goto fault_diag;
2961                 }
2962                 Ioctl.Len = Length;
2963                 if(copy_to_user(rq->ifr_data, &Ioctl, sizeof(SK_GE_IOCTL))) {
2964                         Err = -EFAULT;
2965                         goto fault_diag;
2966                 }
2967 fault_diag:
2968                 kfree(pMemBuf); /* cleanup everything */
2969                 break;
2970 #endif
2971         default:
2972                 Err = -EOPNOTSUPP;
2973         }
2974
2975         return(Err);
2976
2977 } /* SkGeIoctl */
2978
2979
2980 /*****************************************************************************
2981  *
2982  *      SkGeIocMib - handle a GetMib, SetMib- or PresetMib-ioctl message
2983  *
2984  * Description:
2985  *      This function reads/writes the MIB data using PNMI (Private Network
2986  *      Management Interface).
2987  *      The destination for the data must be provided with the
2988  *      ioctl call and is given to the driver in the form of
2989  *      a user space address.
2990  *      Copying from the user-provided data area into kernel messages
2991  *      and back is done by copy_from_user and copy_to_user calls in
2992  *      SkGeIoctl.
2993  *
2994  * Returns:
2995  *      returned size from PNMI call
2996  */
2997 static int SkGeIocMib(
2998 DEV_NET         *pNet,  /* pointer to the adapter context */
2999 unsigned int    Size,   /* length of ioctl data */
3000 int             mode)   /* flag for set/preset */
3001 {
3002 unsigned long   Flags;  /* for spin lock */
3003 SK_AC           *pAC;
3004
3005         SK_DBG_MSG(NULL, SK_DBGMOD_DRV, SK_DBGCAT_DRV_ENTRY,
3006                 ("SkGeIocMib starts now...\n"));
3007         pAC = pNet->pAC;
3008         /* access MIB */
3009         spin_lock_irqsave(&pAC->SlowPathLock, Flags);
3010         switch(mode) {
3011         case SK_IOCTL_GETMIB:
3012                 SkPnmiGetStruct(pAC, pAC->IoBase, &pAC->PnmiStruct, &Size,
3013                         pNet->NetNr);
3014                 break;
3015         case SK_IOCTL_PRESETMIB:
3016                 SkPnmiPreSetStruct(pAC, pAC->IoBase, &pAC->PnmiStruct, &Size,
3017                         pNet->NetNr);
3018                 break;
3019         case SK_IOCTL_SETMIB:
3020                 SkPnmiSetStruct(pAC, pAC->IoBase, &pAC->PnmiStruct, &Size,
3021                         pNet->NetNr);
3022                 break;
3023         default:
3024                 break;
3025         }
3026         spin_unlock_irqrestore(&pAC->SlowPathLock, Flags);
3027         SK_DBG_MSG(NULL, SK_DBGMOD_DRV, SK_DBGCAT_DRV_ENTRY,
3028                 ("MIB data access succeeded\n"));
3029         return (Size);
3030 } /* SkGeIocMib */
3031
3032
3033 /*****************************************************************************
3034  *
3035  *      GetConfiguration - read configuration information
3036  *
3037  * Description:
3038  *      This function reads per-adapter configuration information from
3039  *      the options provided on the command line.
3040  *
3041  * Returns:
3042  *      none
3043  */
3044 static void GetConfiguration(
3045 SK_AC   *pAC)   /* pointer to the adapter context structure */
3046 {
3047 SK_I32  Port;           /* preferred port */
3048 SK_BOOL AutoSet;
3049 SK_BOOL DupSet;
3050 int     LinkSpeed          = SK_LSPEED_AUTO;    /* Link speed */
3051 int     AutoNeg            = 1;                 /* autoneg off (0) or on (1) */
3052 int     DuplexCap          = 0;                 /* 0=both,1=full,2=half */
3053 int     FlowCtrl           = SK_FLOW_MODE_SYM_OR_REM;   /* FlowControl  */
3054 int     MSMode             = SK_MS_MODE_AUTO;   /* master/slave mode    */
3055
3056 SK_BOOL IsConTypeDefined   = SK_TRUE;
3057 SK_BOOL IsLinkSpeedDefined = SK_TRUE;
3058 SK_BOOL IsFlowCtrlDefined  = SK_TRUE;
3059 SK_BOOL IsRoleDefined      = SK_TRUE;
3060 SK_BOOL IsModeDefined      = SK_TRUE;
3061 /*
3062  *      The two parameters AutoNeg. and DuplexCap. map to one configuration
3063  *      parameter. The mapping is described by this table:
3064  *      DuplexCap ->    |       both    |       full    |       half    |
3065  *      AutoNeg         |               |               |               |
3066  *      -----------------------------------------------------------------
3067  *      Off             |    illegal    |       Full    |       Half    |
3068  *      -----------------------------------------------------------------
3069  *      On              |   AutoBoth    |   AutoFull    |   AutoHalf    |
3070  *      -----------------------------------------------------------------
3071  *      Sense           |   AutoSense   |   AutoSense   |   AutoSense   |
3072  */
3073 int     Capabilities[3][3] =
3074                 { {                -1, SK_LMODE_FULL     , SK_LMODE_HALF     },
3075                   {SK_LMODE_AUTOBOTH , SK_LMODE_AUTOFULL , SK_LMODE_AUTOHALF },
3076                   {SK_LMODE_AUTOSENSE, SK_LMODE_AUTOSENSE, SK_LMODE_AUTOSENSE} };
3077
3078 #define DC_BOTH 0
3079 #define DC_FULL 1
3080 #define DC_HALF 2
3081 #define AN_OFF  0
3082 #define AN_ON   1
3083 #define AN_SENS 2
3084 #define M_CurrPort pAC->GIni.GP[Port]
3085
3086
3087         /*
3088         ** Set the default values first for both ports!
3089         */
3090         for (Port = 0; Port < SK_MAX_MACS; Port++) {
3091                 M_CurrPort.PLinkModeConf = Capabilities[AN_ON][DC_BOTH];
3092                 M_CurrPort.PFlowCtrlMode = SK_FLOW_MODE_SYM_OR_REM;
3093                 M_CurrPort.PMSMode       = SK_MS_MODE_AUTO;
3094                 M_CurrPort.PLinkSpeed    = SK_LSPEED_AUTO;
3095         }
3096
3097         /*
3098         ** Check merged parameter ConType. If it has not been used,
3099         ** verify any other parameter (e.g. AutoNeg) and use default values. 
3100         **
3101         ** Stating both ConType and other lowlevel link parameters is also
3102         ** possible. If this is the case, the passed ConType-parameter is 
3103         ** overwritten by the lowlevel link parameter.
3104         **
3105         ** The following settings are used for a merged ConType-parameter:
3106         **
3107         ** ConType   DupCap   AutoNeg   FlowCtrl      Role      Speed
3108         ** -------   ------   -------   --------   ----------   -----
3109         **  Auto      Both      On      SymOrRem      Auto       Auto
3110         **  100FD     Full      Off       None      <ignored>    100
3111         **  100HD     Half      Off       None      <ignored>    100
3112         **  10FD      Full      Off       None      <ignored>    10
3113         **  10HD      Half      Off       None      <ignored>    10
3114         ** 
3115         ** This ConType parameter is used for all ports of the adapter!
3116         */
3117         if ( (ConType != NULL)                && 
3118              (pAC->Index < SK_MAX_CARD_PARAM) &&
3119              (ConType[pAC->Index] != NULL) ) {
3120
3121                         /* Check chipset family */
3122                         if ((!pAC->ChipsetType) && 
3123                                 (strcmp(ConType[pAC->Index],"Auto")!=0) &&
3124                                 (strcmp(ConType[pAC->Index],"")!=0)) {
3125                                 /* Set the speed parameter back */
3126                                         printk("sk98lin: Illegal value \"%s\" " 
3127                                                         "for ConType."
3128                                                         " Using Auto.\n", 
3129                                                         ConType[pAC->Index]);
3130
3131                                         sprintf(ConType[pAC->Index], "Auto");   
3132                         }
3133
3134                                 if (strcmp(ConType[pAC->Index],"")==0) {
3135                         IsConTypeDefined = SK_FALSE; /* No ConType defined */
3136                                 } else if (strcmp(ConType[pAC->Index],"Auto")==0) {
3137                     for (Port = 0; Port < SK_MAX_MACS; Port++) {
3138                         M_CurrPort.PLinkModeConf = Capabilities[AN_ON][DC_BOTH];
3139                         M_CurrPort.PFlowCtrlMode = SK_FLOW_MODE_SYM_OR_REM;
3140                         M_CurrPort.PMSMode       = SK_MS_MODE_AUTO;
3141                         M_CurrPort.PLinkSpeed    = SK_LSPEED_AUTO;
3142                     }
3143                 } else if (strcmp(ConType[pAC->Index],"100FD")==0) {
3144                     for (Port = 0; Port < SK_MAX_MACS; Port++) {
3145                         M_CurrPort.PLinkModeConf = Capabilities[AN_OFF][DC_FULL];
3146                         M_CurrPort.PFlowCtrlMode = SK_FLOW_MODE_NONE;
3147                         M_CurrPort.PMSMode       = SK_MS_MODE_AUTO;
3148                         M_CurrPort.PLinkSpeed    = SK_LSPEED_100MBPS;
3149                     }
3150                 } else if (strcmp(ConType[pAC->Index],"100HD")==0) {
3151                     for (Port = 0; Port < SK_MAX_MACS; Port++) {
3152                         M_CurrPort.PLinkModeConf = Capabilities[AN_OFF][DC_HALF];
3153                         M_CurrPort.PFlowCtrlMode = SK_FLOW_MODE_NONE;
3154                         M_CurrPort.PMSMode       = SK_MS_MODE_AUTO;
3155                         M_CurrPort.PLinkSpeed    = SK_LSPEED_100MBPS;
3156                     }
3157                 } else if (strcmp(ConType[pAC->Index],"10FD")==0) {
3158                     for (Port = 0; Port < SK_MAX_MACS; Port++) {
3159                         M_CurrPort.PLinkModeConf = Capabilities[AN_OFF][DC_FULL];
3160                         M_CurrPort.PFlowCtrlMode = SK_FLOW_MODE_NONE;
3161                         M_CurrPort.PMSMode       = SK_MS_MODE_AUTO;
3162                         M_CurrPort.PLinkSpeed    = SK_LSPEED_10MBPS;
3163                     }
3164                 } else if (strcmp(ConType[pAC->Index],"10HD")==0) {
3165                     for (Port = 0; Port < SK_MAX_MACS; Port++) {
3166                         M_CurrPort.PLinkModeConf = Capabilities[AN_OFF][DC_HALF];
3167                         M_CurrPort.PFlowCtrlMode = SK_FLOW_MODE_NONE;
3168                         M_CurrPort.PMSMode       = SK_MS_MODE_AUTO;
3169                         M_CurrPort.PLinkSpeed    = SK_LSPEED_10MBPS;
3170                     }
3171                 } else { 
3172                     printk("sk98lin: Illegal value \"%s\" for ConType\n", 
3173                         ConType[pAC->Index]);
3174                     IsConTypeDefined = SK_FALSE; /* Wrong ConType defined */
3175                 }
3176         } else {
3177             IsConTypeDefined = SK_FALSE; /* No ConType defined */
3178         }
3179
3180         /*
3181         ** Parse any parameter settings for port A:
3182         ** a) any LinkSpeed stated?
3183         */
3184         if (Speed_A != NULL && pAC->Index<SK_MAX_CARD_PARAM &&
3185                 Speed_A[pAC->Index] != NULL) {
3186                 if (strcmp(Speed_A[pAC->Index],"")==0) {
3187                     IsLinkSpeedDefined = SK_FALSE;
3188                 } else if (strcmp(Speed_A[pAC->Index],"Auto")==0) {
3189                     LinkSpeed = SK_LSPEED_AUTO;
3190                 } else if (strcmp(Speed_A[pAC->Index],"10")==0) {
3191                     LinkSpeed = SK_LSPEED_10MBPS;
3192                 } else if (strcmp(Speed_A[pAC->Index],"100")==0) {
3193                     LinkSpeed = SK_LSPEED_100MBPS;
3194                 } else if (strcmp(Speed_A[pAC->Index],"1000")==0) {
3195                     LinkSpeed = SK_LSPEED_1000MBPS;
3196                 } else {
3197                     printk("sk98lin: Illegal value \"%s\" for Speed_A\n",
3198                         Speed_A[pAC->Index]);
3199                     IsLinkSpeedDefined = SK_FALSE;
3200                 }
3201         } else {
3202             IsLinkSpeedDefined = SK_FALSE;
3203         }
3204
3205         /* 
3206         ** Check speed parameter: 
3207         **    Only copper type adapter and GE V2 cards 
3208         */
3209         if (((!pAC->ChipsetType) || (pAC->GIni.GICopperType != SK_TRUE)) &&
3210                 ((LinkSpeed != SK_LSPEED_AUTO) &&
3211                 (LinkSpeed != SK_LSPEED_1000MBPS))) {
3212                 printk("sk98lin: Illegal value for Speed_A. "
3213                         "Not a copper card or GE V2 card\n    Using "
3214                         "speed 1000\n");
3215                 LinkSpeed = SK_LSPEED_1000MBPS;
3216         }
3217         
3218         /*      
3219         ** Decide whether to set new config value if somethig valid has
3220         ** been received.
3221         */
3222         if (IsLinkSpeedDefined) {
3223                 pAC->GIni.GP[0].PLinkSpeed = LinkSpeed;
3224         } 
3225
3226         /* 
3227         ** b) Any Autonegotiation and DuplexCapabilities set?
3228         **    Please note that both belong together...
3229         */
3230         AutoNeg = AN_ON; /* tschilling: Default: Autonegotiation on! */
3231         AutoSet = SK_FALSE;
3232         if (AutoNeg_A != NULL && pAC->Index<SK_MAX_CARD_PARAM &&
3233                 AutoNeg_A[pAC->Index] != NULL) {
3234                 AutoSet = SK_TRUE;
3235                 if (strcmp(AutoNeg_A[pAC->Index],"")==0) {
3236                     AutoSet = SK_FALSE;
3237                 } else if (strcmp(AutoNeg_A[pAC->Index],"On")==0) {
3238                     AutoNeg = AN_ON;
3239                 } else if (strcmp(AutoNeg_A[pAC->Index],"Off")==0) {
3240                     AutoNeg = AN_OFF;
3241                 } else if (strcmp(AutoNeg_A[pAC->Index],"Sense")==0) {
3242                     AutoNeg = AN_SENS;
3243                 } else {
3244                     printk("sk98lin: Illegal value \"%s\" for AutoNeg_A\n",
3245                         AutoNeg_A[pAC->Index]);
3246                 }
3247         }
3248
3249         DuplexCap = DC_BOTH;
3250         DupSet    = SK_FALSE;
3251         if (DupCap_A != NULL && pAC->Index<SK_MAX_CARD_PARAM &&
3252                 DupCap_A[pAC->Index] != NULL) {
3253                 DupSet = SK_TRUE;
3254                 if (strcmp(DupCap_A[pAC->Index],"")==0) {
3255                     DupSet = SK_FALSE;
3256                 } else if (strcmp(DupCap_A[pAC->Index],"Both")==0) {
3257                     DuplexCap = DC_BOTH;
3258                 } else if (strcmp(DupCap_A[pAC->Index],"Full")==0) {
3259                     DuplexCap = DC_FULL;
3260                 } else if (strcmp(DupCap_A[pAC->Index],"Half")==0) {
3261                     DuplexCap = DC_HALF;
3262                 } else {
3263                     printk("sk98lin: Illegal value \"%s\" for DupCap_A\n",
3264                         DupCap_A[pAC->Index]);
3265                 }
3266         }
3267
3268         /* 
3269         ** Check for illegal combinations 
3270         */
3271         if ((LinkSpeed == SK_LSPEED_1000MBPS) &&
3272                 ((DuplexCap == SK_LMODE_STAT_AUTOHALF) ||
3273                 (DuplexCap == SK_LMODE_STAT_HALF)) &&
3274                 (pAC->ChipsetType)) {
3275                     printk("sk98lin: Half Duplex not possible with Gigabit speed!\n"
3276                                         "    Using Full Duplex.\n");
3277                                 DuplexCap = DC_FULL;
3278         }
3279
3280         if ( AutoSet && AutoNeg==AN_SENS && DupSet) {
3281                 printk("sk98lin, Port A: DuplexCapabilities"
3282                         " ignored using Sense mode\n");
3283         }
3284
3285         if (AutoSet && AutoNeg==AN_OFF && DupSet && DuplexCap==DC_BOTH){
3286                 printk("sk98lin: Port A: Illegal combination"
3287                         " of values AutoNeg. and DuplexCap.\n    Using "
3288                         "Full Duplex\n");
3289                 DuplexCap = DC_FULL;
3290         }
3291
3292         if (AutoSet && AutoNeg==AN_OFF && !DupSet) {
3293                 DuplexCap = DC_FULL;
3294         }
3295         
3296         if (!AutoSet && DupSet) {
3297                 printk("sk98lin: Port A: Duplex setting not"
3298                         " possible in\n    default AutoNegotiation mode"
3299                         " (Sense).\n    Using AutoNegotiation On\n");
3300                 AutoNeg = AN_ON;
3301         }
3302         
3303         /* 
3304         ** set the desired mode 
3305         */
3306         if (AutoSet || DupSet) {
3307             pAC->GIni.GP[0].PLinkModeConf = Capabilities[AutoNeg][DuplexCap];
3308         }
3309         
3310         /* 
3311         ** c) Any Flowcontrol-parameter set?
3312         */
3313         if (FlowCtrl_A != NULL && pAC->Index<SK_MAX_CARD_PARAM &&
3314                 FlowCtrl_A[pAC->Index] != NULL) {
3315                 if (strcmp(FlowCtrl_A[pAC->Index],"") == 0) {
3316                     IsFlowCtrlDefined = SK_FALSE;
3317                 } else if (strcmp(FlowCtrl_A[pAC->Index],"SymOrRem") == 0) {
3318                     FlowCtrl = SK_FLOW_MODE_SYM_OR_REM;
3319                 } else if (strcmp(FlowCtrl_A[pAC->Index],"Sym")==0) {
3320                     FlowCtrl = SK_FLOW_MODE_SYMMETRIC;
3321                 } else if (strcmp(FlowCtrl_A[pAC->Index],"LocSend")==0) {
3322                     FlowCtrl = SK_FLOW_MODE_LOC_SEND;
3323                 } else if (strcmp(FlowCtrl_A[pAC->Index],"None")==0) {
3324                     FlowCtrl = SK_FLOW_MODE_NONE;
3325                 } else {
3326                     printk("sk98lin: Illegal value \"%s\" for FlowCtrl_A\n",
3327                         FlowCtrl_A[pAC->Index]);
3328                     IsFlowCtrlDefined = SK_FALSE;
3329                 }
3330         } else {
3331            IsFlowCtrlDefined = SK_FALSE;
3332         }
3333
3334         if (IsFlowCtrlDefined) {
3335             if ((AutoNeg == AN_OFF) && (FlowCtrl != SK_FLOW_MODE_NONE)) {
3336                 printk("sk98lin: Port A: FlowControl"
3337                         " impossible without AutoNegotiation,"
3338                         " disabled\n");
3339                 FlowCtrl = SK_FLOW_MODE_NONE;
3340             }
3341             pAC->GIni.GP[0].PFlowCtrlMode = FlowCtrl;
3342         }
3343
3344         /*
3345         ** d) What is with the RoleParameter?
3346         */
3347         if (Role_A != NULL && pAC->Index<SK_MAX_CARD_PARAM &&
3348                 Role_A[pAC->Index] != NULL) {
3349                 if (strcmp(Role_A[pAC->Index],"")==0) {
3350                    IsRoleDefined = SK_FALSE;
3351                 } else if (strcmp(Role_A[pAC->Index],"Auto")==0) {
3352                     MSMode = SK_MS_MODE_AUTO;
3353                 } else if (strcmp(Role_A[pAC->Index],"Master")==0) {
3354                     MSMode = SK_MS_MODE_MASTER;
3355                 } else if (strcmp(Role_A[pAC->Index],"Slave")==0) {
3356                     MSMode = SK_MS_MODE_SLAVE;
3357                 } else {
3358                     printk("sk98lin: Illegal value \"%s\" for Role_A\n",
3359                         Role_A[pAC->Index]);
3360                     IsRoleDefined = SK_FALSE;
3361                 }
3362         } else {
3363            IsRoleDefined = SK_FALSE;
3364         }
3365
3366         if (IsRoleDefined == SK_TRUE) {
3367             pAC->GIni.GP[0].PMSMode = MSMode;
3368         }
3369         
3370
3371         
3372         /* 
3373         ** Parse any parameter settings for port B:
3374         ** a) any LinkSpeed stated?
3375         */
3376         IsConTypeDefined   = SK_TRUE;
3377         IsLinkSpeedDefined = SK_TRUE;
3378         IsFlowCtrlDefined  = SK_TRUE;
3379         IsModeDefined      = SK_TRUE;
3380
3381         if (Speed_B != NULL && pAC->Index<SK_MAX_CARD_PARAM &&
3382                 Speed_B[pAC->Index] != NULL) {
3383                 if (strcmp(Speed_B[pAC->Index],"")==0) {
3384                     IsLinkSpeedDefined = SK_FALSE;
3385                 } else if (strcmp(Speed_B[pAC->Index],"Auto")==0) {
3386                     LinkSpeed = SK_LSPEED_AUTO;
3387                 } else if (strcmp(Speed_B[pAC->Index],"10")==0) {
3388                     LinkSpeed = SK_LSPEED_10MBPS;
3389                 } else if (strcmp(Speed_B[pAC->Index],"100")==0) {
3390                     LinkSpeed = SK_LSPEED_100MBPS;
3391                 } else if (strcmp(Speed_B[pAC->Index],"1000")==0) {
3392                     LinkSpeed = SK_LSPEED_1000MBPS;
3393                 } else {
3394                     printk("sk98lin: Illegal value \"%s\" for Speed_B\n",
3395                         Speed_B[pAC->Index]);
3396                     IsLinkSpeedDefined = SK_FALSE;
3397                 }
3398         } else {
3399             IsLinkSpeedDefined = SK_FALSE;
3400         }
3401
3402         /* 
3403         ** Check speed parameter:
3404         **    Only copper type adapter and GE V2 cards 
3405         */
3406         if (((!pAC->ChipsetType) || (pAC->GIni.GICopperType != SK_TRUE)) &&
3407                 ((LinkSpeed != SK_LSPEED_AUTO) &&
3408                 (LinkSpeed != SK_LSPEED_1000MBPS))) {
3409                 printk("sk98lin: Illegal value for Speed_B. "
3410                         "Not a copper card or GE V2 card\n    Using "
3411                         "speed 1000\n");
3412                 LinkSpeed = SK_LSPEED_1000MBPS;
3413         }
3414
3415         /*      
3416         ** Decide whether to set new config value if somethig valid has
3417         ** been received.
3418         */
3419         if (IsLinkSpeedDefined) {
3420             pAC->GIni.GP[1].PLinkSpeed = LinkSpeed;
3421         }
3422
3423         /* 
3424         ** b) Any Autonegotiation and DuplexCapabilities set?
3425         **    Please note that both belong together...
3426         */
3427         AutoNeg = AN_SENS; /* default: do auto Sense */
3428         AutoSet = SK_FALSE;
3429         if (AutoNeg_B != NULL && pAC->Index<SK_MAX_CARD_PARAM &&
3430                 AutoNeg_B[pAC->Index] != NULL) {
3431                 AutoSet = SK_TRUE;
3432                 if (strcmp(AutoNeg_B[pAC->Index],"")==0) {
3433                     AutoSet = SK_FALSE;
3434                 } else if (strcmp(AutoNeg_B[pAC->Index],"On")==0) {
3435                     AutoNeg = AN_ON;
3436                 } else if (strcmp(AutoNeg_B[pAC->Index],"Off")==0) {
3437                     AutoNeg = AN_OFF;
3438                 } else if (strcmp(AutoNeg_B[pAC->Index],"Sense")==0) {
3439                     AutoNeg = AN_SENS;
3440                 } else {
3441                     printk("sk98lin: Illegal value \"%s\" for AutoNeg_B\n",
3442                         AutoNeg_B[pAC->Index]);
3443                 }
3444         }
3445
3446         DuplexCap = DC_BOTH;
3447         DupSet    = SK_FALSE;
3448         if (DupCap_B != NULL && pAC->Index<SK_MAX_CARD_PARAM &&
3449                 DupCap_B[pAC->Index] != NULL) {
3450                 DupSet = SK_TRUE;
3451                 if (strcmp(DupCap_B[pAC->Index],"")==0) {
3452                     DupSet = SK_FALSE;
3453                 } else if (strcmp(DupCap_B[pAC->Index],"Both")==0) {
3454                     DuplexCap = DC_BOTH;
3455                 } else if (strcmp(DupCap_B[pAC->Index],"Full")==0) {
3456                     DuplexCap = DC_FULL;
3457                 } else if (strcmp(DupCap_B[pAC->Index],"Half")==0) {
3458                     DuplexCap = DC_HALF;
3459                 } else {
3460                     printk("sk98lin: Illegal value \"%s\" for DupCap_B\n",
3461                         DupCap_B[pAC->Index]);
3462                 }
3463         }
3464
3465         
3466         /* 
3467         ** Check for illegal combinations 
3468         */
3469         if ((LinkSpeed == SK_LSPEED_1000MBPS) &&
3470                 ((DuplexCap == SK_LMODE_STAT_AUTOHALF) ||
3471                 (DuplexCap == SK_LMODE_STAT_HALF)) &&
3472                 (pAC->ChipsetType)) {
3473                     printk("sk98lin: Half Duplex not possible with Gigabit speed!\n"
3474                                         "    Using Full Duplex.\n");
3475                                 DuplexCap = DC_FULL;
3476         }
3477
3478         if (AutoSet && AutoNeg==AN_SENS && DupSet) {
3479                 printk("sk98lin, Port B: DuplexCapabilities"
3480                         " ignored using Sense mode\n");
3481         }
3482
3483         if (AutoSet && AutoNeg==AN_OFF && DupSet && DuplexCap==DC_BOTH){
3484                 printk("sk98lin: Port B: Illegal combination"
3485                         " of values AutoNeg. and DuplexCap.\n    Using "
3486                         "Full Duplex\n");
3487                 DuplexCap = DC_FULL;
3488         }
3489
3490         if (AutoSet && AutoNeg==AN_OFF && !DupSet) {
3491                 DuplexCap = DC_FULL;
3492         }
3493         
3494         if (!AutoSet && DupSet) {
3495                 printk("sk98lin: Port B: Duplex setting not"
3496                         " possible in\n    default AutoNegotiation mode"
3497                         " (Sense).\n    Using AutoNegotiation On\n");
3498                 AutoNeg = AN_ON;
3499         }
3500
3501         /* 
3502         ** set the desired mode 
3503         */
3504         if (AutoSet || DupSet) {
3505             pAC->GIni.GP[1].PLinkModeConf = Capabilities[AutoNeg][DuplexCap];
3506         }
3507
3508         /*
3509         ** c) Any FlowCtrl parameter set?
3510         */
3511         if (FlowCtrl_B != NULL && pAC->Index<SK_MAX_CARD_PARAM &&
3512                 FlowCtrl_B[pAC->Index] != NULL) {
3513                 if (strcmp(FlowCtrl_B[pAC->Index],"") == 0) {
3514                     IsFlowCtrlDefined = SK_FALSE;
3515                 } else if (strcmp(FlowCtrl_B[pAC->Index],"SymOrRem") == 0) {
3516                     FlowCtrl = SK_FLOW_MODE_SYM_OR_REM;
3517                 } else if (strcmp(FlowCtrl_B[pAC->Index],"Sym")==0) {
3518                     FlowCtrl = SK_FLOW_MODE_SYMMETRIC;
3519                 } else if (strcmp(FlowCtrl_B[pAC->Index],"LocSend")==0) {
3520                     FlowCtrl = SK_FLOW_MODE_LOC_SEND;
3521                 } else if (strcmp(FlowCtrl_B[pAC->Index],"None")==0) {
3522                     FlowCtrl = SK_FLOW_MODE_NONE;
3523                 } else {
3524                     printk("sk98lin: Illegal value \"%s\" for FlowCtrl_B\n",
3525                         FlowCtrl_B[pAC->Index]);
3526                     IsFlowCtrlDefined = SK_FALSE;
3527                 }
3528         } else {
3529                 IsFlowCtrlDefined = SK_FALSE;
3530         }
3531
3532         if (IsFlowCtrlDefined) {
3533             if ((AutoNeg == AN_OFF) && (FlowCtrl != SK_FLOW_MODE_NONE)) {
3534                 printk("sk98lin: Port B: FlowControl"
3535                         " impossible without AutoNegotiation,"
3536                         " disabled\n");
3537                 FlowCtrl = SK_FLOW_MODE_NONE;
3538             }
3539             pAC->GIni.GP[1].PFlowCtrlMode = FlowCtrl;
3540         }
3541
3542         /*
3543         ** d) What is the RoleParameter?
3544         */
3545         if (Role_B != NULL && pAC->Index<SK_MAX_CARD_PARAM &&
3546                 Role_B[pAC->Index] != NULL) {
3547                 if (strcmp(Role_B[pAC->Index],"")==0) {
3548                     IsRoleDefined = SK_FALSE;
3549                 } else if (strcmp(Role_B[pAC->Index],"Auto")==0) {
3550                     MSMode = SK_MS_MODE_AUTO;
3551                 } else if (strcmp(Role_B[pAC->Index],"Master")==0) {
3552                     MSMode = SK_MS_MODE_MASTER;
3553                 } else if (strcmp(Role_B[pAC->Index],"Slave")==0) {
3554                     MSMode = SK_MS_MODE_SLAVE;
3555                 } else {
3556                     printk("sk98lin: Illegal value \"%s\" for Role_B\n",
3557                         Role_B[pAC->Index]);
3558                     IsRoleDefined = SK_FALSE;
3559                 }
3560         } else {
3561             IsRoleDefined = SK_FALSE;
3562         }
3563
3564         if (IsRoleDefined) {
3565             pAC->GIni.GP[1].PMSMode = MSMode;
3566         }
3567         
3568         /*
3569         ** Evaluate settings for both ports
3570         */
3571         pAC->ActivePort = 0;
3572         if (PrefPort != NULL && pAC->Index<SK_MAX_CARD_PARAM &&
3573                 PrefPort[pAC->Index] != NULL) {
3574                 if (strcmp(PrefPort[pAC->Index],"") == 0) { /* Auto */
3575                         pAC->ActivePort             =  0;
3576                         pAC->Rlmt.Net[0].Preference = -1; /* auto */
3577                         pAC->Rlmt.Net[0].PrefPort   =  0;
3578                 } else if (strcmp(PrefPort[pAC->Index],"A") == 0) {
3579                         /*
3580                         ** do not set ActivePort here, thus a port
3581                         ** switch is issued after net up.
3582                         */
3583                         Port                        = 0;
3584                         pAC->Rlmt.Net[0].Preference = Port;
3585                         pAC->Rlmt.Net[0].PrefPort   = Port;
3586                 } else if (strcmp(PrefPort[pAC->Index],"B") == 0) {
3587                         /*
3588                         ** do not set ActivePort here, thus a port
3589                         ** switch is issued after net up.
3590                         */
3591                         if (pAC->GIni.GIMacsFound == 1) {
3592                                 printk("sk98lin: Illegal value \"B\" for PrefPort.\n"
3593                                         "      Port B not available on single port adapters.\n");
3594
3595                                 pAC->ActivePort             =  0;
3596                                 pAC->Rlmt.Net[0].Preference = -1; /* auto */
3597                                 pAC->Rlmt.Net[0].PrefPort   =  0;
3598                         } else {
3599                                 Port                        = 1;
3600                                 pAC->Rlmt.Net[0].Preference = Port;
3601                                 pAC->Rlmt.Net[0].PrefPort   = Port;
3602                         }
3603                 } else {
3604                     printk("sk98lin: Illegal value \"%s\" for PrefPort\n",
3605                         PrefPort[pAC->Index]);
3606                 }
3607         }
3608
3609         pAC->RlmtNets = 1;
3610
3611         if (RlmtMode != NULL && pAC->Index<SK_MAX_CARD_PARAM &&
3612                 RlmtMode[pAC->Index] != NULL) {
3613                 if (strcmp(RlmtMode[pAC->Index], "") == 0) {
3614                         pAC->RlmtMode = 0;
3615                 } else if (strcmp(RlmtMode[pAC->Index], "CheckLinkState") == 0) {
3616                         pAC->RlmtMode = SK_RLMT_CHECK_LINK;
3617                 } else if (strcmp(RlmtMode[pAC->Index], "CheckLocalPort") == 0) {
3618                         pAC->RlmtMode = SK_RLMT_CHECK_LINK |
3619                                         SK_RLMT_CHECK_LOC_LINK;
3620                 } else if (strcmp(RlmtMode[pAC->Index], "CheckSeg") == 0) {
3621                         pAC->RlmtMode = SK_RLMT_CHECK_LINK     |
3622                                         SK_RLMT_CHECK_LOC_LINK |
3623                                         SK_RLMT_CHECK_SEG;
3624                 } else if ((strcmp(RlmtMode[pAC->Index], "DualNet") == 0) &&
3625                         (pAC->GIni.GIMacsFound == 2)) {
3626                         pAC->RlmtMode = SK_RLMT_CHECK_LINK;
3627                         pAC->RlmtNets = 2;
3628                 } else {
3629                     printk("sk98lin: Illegal value \"%s\" for"
3630                         " RlmtMode, using default\n", 
3631                         RlmtMode[pAC->Index]);
3632                         pAC->RlmtMode = 0;
3633                 }
3634         } else {
3635                 pAC->RlmtMode = 0;
3636         }
3637         
3638         /*
3639         ** Check the interrupt moderation parameters
3640         */
3641         if (Moderation[pAC->Index] != NULL) {
3642                 if (strcmp(Moderation[pAC->Index], "") == 0) {
3643                         pAC->DynIrqModInfo.IntModTypeSelect = C_INT_MOD_NONE;
3644                 } else if (strcmp(Moderation[pAC->Index], "Static") == 0) {
3645                         pAC->DynIrqModInfo.IntModTypeSelect = C_INT_MOD_STATIC;
3646                 } else if (strcmp(Moderation[pAC->Index], "Dynamic") == 0) {
3647                         pAC->DynIrqModInfo.IntModTypeSelect = C_INT_MOD_DYNAMIC;
3648                 } else if (strcmp(Moderation[pAC->Index], "None") == 0) {
3649                         pAC->DynIrqModInfo.IntModTypeSelect = C_INT_MOD_NONE;
3650                 } else {
3651                         printk("sk98lin: Illegal value \"%s\" for Moderation.\n"
3652                                 "      Disable interrupt moderation.\n",
3653                                 Moderation[pAC->Index]);
3654                         pAC->DynIrqModInfo.IntModTypeSelect = C_INT_MOD_NONE;
3655                 }
3656         } else {
3657                 pAC->DynIrqModInfo.IntModTypeSelect = C_INT_MOD_NONE;
3658         }
3659
3660         if (Stats[pAC->Index] != NULL) {
3661                 if (strcmp(Stats[pAC->Index], "Yes") == 0) {
3662                         pAC->DynIrqModInfo.DisplayStats = SK_TRUE;
3663                 } else {
3664                         pAC->DynIrqModInfo.DisplayStats = SK_FALSE;
3665                 }
3666         } else {
3667                 pAC->DynIrqModInfo.DisplayStats = SK_FALSE;
3668         }
3669
3670         if (ModerationMask[pAC->Index] != NULL) {
3671                 if (strcmp(ModerationMask[pAC->Index], "Rx") == 0) {
3672                         pAC->DynIrqModInfo.MaskIrqModeration = IRQ_MASK_RX_ONLY;
3673                 } else if (strcmp(ModerationMask[pAC->Index], "Tx") == 0) {
3674                         pAC->DynIrqModInfo.MaskIrqModeration = IRQ_MASK_TX_ONLY;
3675                 } else if (strcmp(ModerationMask[pAC->Index], "Sp") == 0) {
3676                         pAC->DynIrqModInfo.MaskIrqModeration = IRQ_MASK_SP_ONLY;
3677                 } else if (strcmp(ModerationMask[pAC->Index], "RxSp") == 0) {
3678                         pAC->DynIrqModInfo.MaskIrqModeration = IRQ_MASK_SP_RX;
3679                 } else if (strcmp(ModerationMask[pAC->Index], "SpRx") == 0) {
3680                         pAC->DynIrqModInfo.MaskIrqModeration = IRQ_MASK_SP_RX;
3681                 } else if (strcmp(ModerationMask[pAC->Index], "RxTx") == 0) {
3682                         pAC->DynIrqModInfo.MaskIrqModeration = IRQ_MASK_TX_RX;
3683                 } else if (strcmp(ModerationMask[pAC->Index], "TxRx") == 0) {
3684                         pAC->DynIrqModInfo.MaskIrqModeration = IRQ_MASK_TX_RX;
3685                 } else if (strcmp(ModerationMask[pAC->Index], "TxSp") == 0) {
3686                         pAC->DynIrqModInfo.MaskIrqModeration = IRQ_MASK_SP_TX;
3687                 } else if (strcmp(ModerationMask[pAC->Index], "SpTx") == 0) {
3688                         pAC->DynIrqModInfo.MaskIrqModeration = IRQ_MASK_SP_TX;
3689                 } else if (strcmp(ModerationMask[pAC->Index], "RxTxSp") == 0) {
3690                         pAC->DynIrqModInfo.MaskIrqModeration = IRQ_MASK_RX_TX_SP;
3691                 } else if (strcmp(ModerationMask[pAC->Index], "RxSpTx") == 0) {
3692                         pAC->DynIrqModInfo.MaskIrqModeration = IRQ_MASK_RX_TX_SP;
3693                 } else if (strcmp(ModerationMask[pAC->Index], "TxRxSp") == 0) {
3694                         pAC->DynIrqModInfo.MaskIrqModeration = IRQ_MASK_RX_TX_SP;
3695                 } else if (strcmp(ModerationMask[pAC->Index], "TxSpRx") == 0) {
3696                         pAC->DynIrqModInfo.MaskIrqModeration = IRQ_MASK_RX_TX_SP;
3697                 } else if (strcmp(ModerationMask[pAC->Index], "SpTxRx") == 0) {
3698                         pAC->DynIrqModInfo.MaskIrqModeration = IRQ_MASK_RX_TX_SP;
3699                 } else if (strcmp(ModerationMask[pAC->Index], "SpRxTx") == 0) {
3700                         pAC->DynIrqModInfo.MaskIrqModeration = IRQ_MASK_RX_TX_SP;
3701                 } else { /* some rubbish */
3702                         pAC->DynIrqModInfo.MaskIrqModeration = IRQ_MASK_RX_ONLY;
3703                 }
3704         } else {  /* operator has stated nothing */
3705                 pAC->DynIrqModInfo.MaskIrqModeration = IRQ_MASK_TX_RX;
3706         }
3707
3708         if (AutoSizing[pAC->Index] != NULL) {
3709                 if (strcmp(AutoSizing[pAC->Index], "On") == 0) {
3710                         pAC->DynIrqModInfo.AutoSizing = SK_FALSE;
3711                 } else {
3712                         pAC->DynIrqModInfo.AutoSizing = SK_FALSE;
3713                 }
3714         } else {  /* operator has stated nothing */
3715                 pAC->DynIrqModInfo.AutoSizing = SK_FALSE;
3716         }
3717
3718         if (IntsPerSec[pAC->Index] != 0) {
3719                 if ((IntsPerSec[pAC->Index]< C_INT_MOD_IPS_LOWER_RANGE) || 
3720                         (IntsPerSec[pAC->Index] > C_INT_MOD_IPS_UPPER_RANGE)) {
3721                         printk("sk98lin: Illegal value \"%d\" for IntsPerSec. (Range: %d - %d)\n"
3722                                 "      Using default value of %i.\n", 
3723                                 IntsPerSec[pAC->Index],
3724                                 C_INT_MOD_IPS_LOWER_RANGE,
3725                                 C_INT_MOD_IPS_UPPER_RANGE,
3726                                 C_INTS_PER_SEC_DEFAULT);
3727                         pAC->DynIrqModInfo.MaxModIntsPerSec = C_INTS_PER_SEC_DEFAULT;
3728                 } else {
3729                         pAC->DynIrqModInfo.MaxModIntsPerSec = IntsPerSec[pAC->Index];
3730                 }
3731         } else {
3732                 pAC->DynIrqModInfo.MaxModIntsPerSec = C_INTS_PER_SEC_DEFAULT;
3733         }
3734
3735         /*
3736         ** Evaluate upper and lower moderation threshold
3737         */
3738         pAC->DynIrqModInfo.MaxModIntsPerSecUpperLimit =
3739                 pAC->DynIrqModInfo.MaxModIntsPerSec +
3740                 (pAC->DynIrqModInfo.MaxModIntsPerSec / 2);
3741
3742         pAC->DynIrqModInfo.MaxModIntsPerSecLowerLimit =
3743                 pAC->DynIrqModInfo.MaxModIntsPerSec -
3744                 (pAC->DynIrqModInfo.MaxModIntsPerSec / 2);
3745
3746         pAC->DynIrqModInfo.PrevTimeVal = jiffies;  /* initial value */
3747
3748
3749 } /* GetConfiguration */
3750
3751
3752 /*****************************************************************************
3753  *
3754  *      ProductStr - return a adapter identification string from vpd
3755  *
3756  * Description:
3757  *      This function reads the product name string from the vpd area
3758  *      and puts it the field pAC->DeviceString.
3759  *
3760  * Returns: N/A
3761  */
3762 static inline int ProductStr(
3763         SK_AC   *pAC,           /* pointer to adapter context */
3764         char    *DeviceStr,     /* result string */
3765         int      StrLen         /* length of the string */
3766 )
3767 {
3768 char    Keyword[] = VPD_NAME;   /* vpd productname identifier */
3769 int     ReturnCode;             /* return code from vpd_read */
3770 unsigned long Flags;
3771
3772         spin_lock_irqsave(&pAC->SlowPathLock, Flags);
3773         ReturnCode = VpdRead(pAC, pAC->IoBase, Keyword, DeviceStr, &StrLen);
3774         spin_unlock_irqrestore(&pAC->SlowPathLock, Flags);
3775
3776         return ReturnCode;
3777 } /* ProductStr */
3778
3779 /*****************************************************************************
3780  *
3781  *      StartDrvCleanupTimer - Start timer to check for descriptors which
3782  *                             might be placed in descriptor ring, but
3783  *                             havent been handled up to now
3784  *
3785  * Description:
3786  *      This function requests a HW-timer fo the Yukon card. The actions to
3787  *      perform when this timer expires, are located in the SkDrvEvent().
3788  *
3789  * Returns: N/A
3790  */
3791 static void
3792 StartDrvCleanupTimer(SK_AC *pAC) {
3793     SK_EVPARA    EventParam;   /* Event struct for timer event */
3794
3795     SK_MEMSET((char *) &EventParam, 0, sizeof(EventParam));
3796     EventParam.Para32[0] = SK_DRV_RX_CLEANUP_TIMER;
3797     SkTimerStart(pAC, pAC->IoBase, &pAC->DrvCleanupTimer,
3798                  SK_DRV_RX_CLEANUP_TIMER_LENGTH,
3799                  SKGE_DRV, SK_DRV_TIMER, EventParam);
3800 }
3801
3802 /*****************************************************************************
3803  *
3804  *      StopDrvCleanupTimer - Stop timer to check for descriptors
3805  *
3806  * Description:
3807  *      This function requests a HW-timer fo the Yukon card. The actions to
3808  *      perform when this timer expires, are located in the SkDrvEvent().
3809  *
3810  * Returns: N/A
3811  */
3812 static void
3813 StopDrvCleanupTimer(SK_AC *pAC) {
3814     SkTimerStop(pAC, pAC->IoBase, &pAC->DrvCleanupTimer);
3815     SK_MEMSET((char *) &pAC->DrvCleanupTimer, 0, sizeof(SK_TIMER));
3816 }
3817
3818 /****************************************************************************/
3819 /* functions for common modules *********************************************/
3820 /****************************************************************************/
3821
3822
3823 /*****************************************************************************
3824  *
3825  *      SkDrvAllocRlmtMbuf - allocate an RLMT mbuf
3826  *
3827  * Description:
3828  *      This routine returns an RLMT mbuf or NULL. The RLMT Mbuf structure
3829  *      is embedded into a socket buff data area.
3830  *
3831  * Context:
3832  *      runtime
3833  *
3834  * Returns:
3835  *      NULL or pointer to Mbuf.
3836  */
3837 SK_MBUF *SkDrvAllocRlmtMbuf(
3838 SK_AC           *pAC,           /* pointer to adapter context */
3839 SK_IOC          IoC,            /* the IO-context */
3840 unsigned        BufferSize)     /* size of the requested buffer */
3841 {
3842 SK_MBUF         *pRlmtMbuf;     /* pointer to a new rlmt-mbuf structure */
3843 struct sk_buff  *pMsgBlock;     /* pointer to a new message block */
3844
3845         pMsgBlock = alloc_skb(BufferSize + sizeof(SK_MBUF), GFP_ATOMIC);
3846         if (pMsgBlock == NULL) {
3847                 return (NULL);
3848         }
3849         pRlmtMbuf = (SK_MBUF*) pMsgBlock->data;
3850         skb_reserve(pMsgBlock, sizeof(SK_MBUF));
3851         pRlmtMbuf->pNext = NULL;
3852         pRlmtMbuf->pOs = pMsgBlock;
3853         pRlmtMbuf->pData = pMsgBlock->data;     /* Data buffer. */
3854         pRlmtMbuf->Size = BufferSize;           /* Data buffer size. */
3855         pRlmtMbuf->Length = 0;          /* Length of packet (<= Size). */
3856         return (pRlmtMbuf);
3857
3858 } /* SkDrvAllocRlmtMbuf */
3859
3860
3861 /*****************************************************************************
3862  *
3863  *      SkDrvFreeRlmtMbuf - free an RLMT mbuf
3864  *
3865  * Description:
3866  *      This routine frees one or more RLMT mbuf(s).
3867  *
3868  * Context:
3869  *      runtime
3870  *
3871  * Returns:
3872  *      Nothing
3873  */
3874 void  SkDrvFreeRlmtMbuf(
3875 SK_AC           *pAC,           /* pointer to adapter context */
3876 SK_IOC          IoC,            /* the IO-context */
3877 SK_MBUF         *pMbuf)         /* size of the requested buffer */
3878 {
3879 SK_MBUF         *pFreeMbuf;
3880 SK_MBUF         *pNextMbuf;
3881
3882         pFreeMbuf = pMbuf;
3883         do {
3884                 pNextMbuf = pFreeMbuf->pNext;
3885                 DEV_KFREE_SKB_ANY(pFreeMbuf->pOs);
3886                 pFreeMbuf = pNextMbuf;
3887         } while ( pFreeMbuf != NULL );
3888 } /* SkDrvFreeRlmtMbuf */
3889
3890
3891 /*****************************************************************************
3892  *
3893  *      SkOsGetTime - provide a time value
3894  *
3895  * Description:
3896  *      This routine provides a time value. The unit is 1/HZ (defined by Linux).
3897  *      It is not used for absolute time, but only for time differences.
3898  *
3899  *
3900  * Returns:
3901  *      Time value
3902  */
3903 SK_U64 SkOsGetTime(SK_AC *pAC)
3904 {
3905         SK_U64  PrivateJiffies;
3906         SkOsGetTimeCurrent(pAC, &PrivateJiffies);
3907         return PrivateJiffies;
3908 } /* SkOsGetTime */
3909
3910
3911 /*****************************************************************************
3912  *
3913  *      SkPciReadCfgDWord - read a 32 bit value from pci config space
3914  *
3915  * Description:
3916  *      This routine reads a 32 bit value from the pci configuration
3917  *      space.
3918  *
3919  * Returns:
3920  *      0 - indicate everything worked ok.
3921  *      != 0 - error indication
3922  */
3923 int SkPciReadCfgDWord(
3924 SK_AC *pAC,             /* Adapter Control structure pointer */
3925 int PciAddr,            /* PCI register address */
3926 SK_U32 *pVal)           /* pointer to store the read value */
3927 {
3928         pci_read_config_dword(pAC->PciDev, PciAddr, pVal);
3929         return(0);
3930 } /* SkPciReadCfgDWord */
3931
3932
3933 /*****************************************************************************
3934  *
3935  *      SkPciReadCfgWord - read a 16 bit value from pci config space
3936  *
3937  * Description:
3938  *      This routine reads a 16 bit value from the pci configuration
3939  *      space.
3940  *
3941  * Returns:
3942  *      0 - indicate everything worked ok.
3943  *      != 0 - error indication
3944  */
3945 int SkPciReadCfgWord(
3946 SK_AC *pAC,     /* Adapter Control structure pointer */
3947 int PciAddr,            /* PCI register address */
3948 SK_U16 *pVal)           /* pointer to store the read value */
3949 {
3950         pci_read_config_word(pAC->PciDev, PciAddr, pVal);
3951         return(0);
3952 } /* SkPciReadCfgWord */
3953
3954
3955 /*****************************************************************************
3956  *
3957  *      SkPciReadCfgByte - read a 8 bit value from pci config space
3958  *
3959  * Description:
3960  *      This routine reads a 8 bit value from the pci configuration
3961  *      space.
3962  *
3963  * Returns:
3964  *      0 - indicate everything worked ok.
3965  *      != 0 - error indication
3966  */
3967 int SkPciReadCfgByte(
3968 SK_AC *pAC,     /* Adapter Control structure pointer */
3969 int PciAddr,            /* PCI register address */
3970 SK_U8 *pVal)            /* pointer to store the read value */
3971 {
3972         pci_read_config_byte(pAC->PciDev, PciAddr, pVal);
3973         return(0);
3974 } /* SkPciReadCfgByte */
3975
3976
3977 /*****************************************************************************
3978  *
3979  *      SkPciWriteCfgWord - write a 16 bit value to pci config space
3980  *
3981  * Description:
3982  *      This routine writes a 16 bit value to the pci configuration
3983  *      space. The flag PciConfigUp indicates whether the config space
3984  *      is accesible or must be set up first.
3985  *
3986  * Returns:
3987  *      0 - indicate everything worked ok.
3988  *      != 0 - error indication
3989  */
3990 int SkPciWriteCfgWord(
3991 SK_AC *pAC,     /* Adapter Control structure pointer */
3992 int PciAddr,            /* PCI register address */
3993 SK_U16 Val)             /* pointer to store the read value */
3994 {
3995         pci_write_config_word(pAC->PciDev, PciAddr, Val);
3996         return(0);
3997 } /* SkPciWriteCfgWord */
3998
3999
4000 /*****************************************************************************
4001  *
4002  *      SkPciWriteCfgWord - write a 8 bit value to pci config space
4003  *
4004  * Description:
4005  *      This routine writes a 8 bit value to the pci configuration
4006  *      space. The flag PciConfigUp indicates whether the config space
4007  *      is accesible or must be set up first.
4008  *
4009  * Returns:
4010  *      0 - indicate everything worked ok.
4011  *      != 0 - error indication
4012  */
4013 int SkPciWriteCfgByte(
4014 SK_AC *pAC,     /* Adapter Control structure pointer */
4015 int PciAddr,            /* PCI register address */
4016 SK_U8 Val)              /* pointer to store the read value */
4017 {
4018         pci_write_config_byte(pAC->PciDev, PciAddr, Val);
4019         return(0);
4020 } /* SkPciWriteCfgByte */
4021
4022
4023 /*****************************************************************************
4024  *
4025  *      SkDrvEvent - handle driver events
4026  *
4027  * Description:
4028  *      This function handles events from all modules directed to the driver
4029  *
4030  * Context:
4031  *      Is called under protection of slow path lock.
4032  *
4033  * Returns:
4034  *      0 if everything ok
4035  *      < 0  on error
4036  *      
4037  */
4038 int SkDrvEvent(
4039 SK_AC *pAC,             /* pointer to adapter context */
4040 SK_IOC IoC,             /* io-context */
4041 SK_U32 Event,           /* event-id */
4042 SK_EVPARA Param)        /* event-parameter */
4043 {
4044 SK_MBUF         *pRlmtMbuf;     /* pointer to a rlmt-mbuf structure */
4045 struct sk_buff  *pMsg;          /* pointer to a message block */
4046 int             FromPort;       /* the port from which we switch away */
4047 int             ToPort;         /* the port we switch to */
4048 SK_EVPARA       NewPara;        /* parameter for further events */
4049 int             Stat;
4050 unsigned long   Flags;
4051 SK_BOOL         DualNet;
4052
4053         switch (Event) {
4054         case SK_DRV_ADAP_FAIL:
4055                 SK_DBG_MSG(NULL, SK_DBGMOD_DRV, SK_DBGCAT_DRV_EVENT,
4056                         ("ADAPTER FAIL EVENT\n"));
4057                 printk("%s: Adapter failed.\n", pAC->dev[0]->name);
4058                 /* disable interrupts */
4059                 SK_OUT32(pAC->IoBase, B0_IMSK, 0);
4060                 /* cgoos */
4061                 break;
4062         case SK_DRV_PORT_FAIL:
4063                 FromPort = Param.Para32[0];
4064                 SK_DBG_MSG(NULL, SK_DBGMOD_DRV, SK_DBGCAT_DRV_EVENT,
4065                         ("PORT FAIL EVENT, Port: %d\n", FromPort));
4066                 if (FromPort == 0) {
4067                         printk("%s: Port A failed.\n", pAC->dev[0]->name);
4068                 } else {
4069                         printk("%s: Port B failed.\n", pAC->dev[1]->name);
4070                 }
4071                 /* cgoos */
4072                 break;
4073         case SK_DRV_PORT_RESET:  /* SK_U32 PortIdx */
4074                 /* action list 4 */
4075                 FromPort = Param.Para32[0];
4076                 SK_DBG_MSG(NULL, SK_DBGMOD_DRV, SK_DBGCAT_DRV_EVENT,
4077                         ("PORT RESET EVENT, Port: %d ", FromPort));
4078                 NewPara.Para64 = FromPort;
4079                 SkPnmiEvent(pAC, IoC, SK_PNMI_EVT_XMAC_RESET, NewPara);
4080                 spin_lock_irqsave(
4081                         &pAC->TxPort[FromPort][TX_PRIO_LOW].TxDesRingLock,
4082                         Flags);
4083
4084                 SkGeStopPort(pAC, IoC, FromPort, SK_STOP_ALL, SK_HARD_RST);
4085                 netif_carrier_off(pAC->dev[Param.Para32[0]]);
4086                 spin_unlock_irqrestore(
4087                         &pAC->TxPort[FromPort][TX_PRIO_LOW].TxDesRingLock,
4088                         Flags);
4089                 
4090                 /* clear rx ring from received frames */
4091                 ReceiveIrq(pAC, &pAC->RxPort[FromPort], SK_FALSE);
4092                 
4093                 ClearTxRing(pAC, &pAC->TxPort[FromPort][TX_PRIO_LOW]);
4094                 spin_lock_irqsave(
4095                         &pAC->TxPort[FromPort][TX_PRIO_LOW].TxDesRingLock,
4096                         Flags);
4097                 
4098                 /* tschilling: Handling of return value inserted. */
4099                 if (SkGeInitPort(pAC, IoC, FromPort)) {
4100                         if (FromPort == 0) {
4101                                 printk("%s: SkGeInitPort A failed.\n", pAC->dev[0]->name);
4102                         } else {
4103                                 printk("%s: SkGeInitPort B failed.\n", pAC->dev[1]->name);
4104                         }
4105                 }
4106                 SkAddrMcUpdate(pAC,IoC, FromPort);
4107                 PortReInitBmu(pAC, FromPort);
4108                 SkGePollTxD(pAC, IoC, FromPort, SK_TRUE);
4109                 ClearAndStartRx(pAC, FromPort);
4110                 spin_unlock_irqrestore(
4111                         &pAC->TxPort[FromPort][TX_PRIO_LOW].TxDesRingLock,
4112                         Flags);
4113                 break;
4114         case SK_DRV_NET_UP:      /* SK_U32 PortIdx */
4115         {       struct net_device *dev = pAC->dev[Param.Para32[0]];
4116                 /* action list 5 */
4117                 FromPort = Param.Para32[0];
4118                 SK_DBG_MSG(NULL, SK_DBGMOD_DRV, SK_DBGCAT_DRV_EVENT,
4119                         ("NET UP EVENT, Port: %d ", Param.Para32[0]));
4120                 /* Mac update */
4121                 SkAddrMcUpdate(pAC,IoC, FromPort);
4122
4123                 if (DoPrintInterfaceChange) {
4124                 printk("%s: network connection up using"
4125                         " port %c\n", pAC->dev[Param.Para32[0]]->name, 'A'+Param.Para32[0]);
4126
4127                 /* tschilling: Values changed according to LinkSpeedUsed. */
4128                 Stat = pAC->GIni.GP[FromPort].PLinkSpeedUsed;
4129                 if (Stat == SK_LSPEED_STAT_10MBPS) {
4130                         printk("    speed:           10\n");
4131                 } else if (Stat == SK_LSPEED_STAT_100MBPS) {
4132                         printk("    speed:           100\n");
4133                 } else if (Stat == SK_LSPEED_STAT_1000MBPS) {
4134                         printk("    speed:           1000\n");
4135                 } else {
4136                         printk("    speed:           unknown\n");
4137                 }
4138
4139
4140                 Stat = pAC->GIni.GP[FromPort].PLinkModeStatus;
4141                 if (Stat == SK_LMODE_STAT_AUTOHALF ||
4142                         Stat == SK_LMODE_STAT_AUTOFULL) {
4143                         printk("    autonegotiation: yes\n");
4144                 }
4145                 else {
4146                         printk("    autonegotiation: no\n");
4147                 }
4148                 if (Stat == SK_LMODE_STAT_AUTOHALF ||
4149                         Stat == SK_LMODE_STAT_HALF) {
4150                         printk("    duplex mode:     half\n");
4151                 }
4152                 else {
4153                         printk("    duplex mode:     full\n");
4154                 }
4155                 Stat = pAC->GIni.GP[FromPort].PFlowCtrlStatus;
4156                 if (Stat == SK_FLOW_STAT_REM_SEND ) {
4157                         printk("    flowctrl:        remote send\n");
4158                 }
4159                 else if (Stat == SK_FLOW_STAT_LOC_SEND ){
4160                         printk("    flowctrl:        local send\n");
4161                 }
4162                 else if (Stat == SK_FLOW_STAT_SYMMETRIC ){
4163                         printk("    flowctrl:        symmetric\n");
4164                 }
4165                 else {
4166                         printk("    flowctrl:        none\n");
4167                 }
4168                 
4169                 /* tschilling: Check against CopperType now. */
4170                 if ((pAC->GIni.GICopperType == SK_TRUE) &&
4171                         (pAC->GIni.GP[FromPort].PLinkSpeedUsed ==
4172                         SK_LSPEED_STAT_1000MBPS)) {
4173                         Stat = pAC->GIni.GP[FromPort].PMSStatus;
4174                         if (Stat == SK_MS_STAT_MASTER ) {
4175                                 printk("    role:            master\n");
4176                         }
4177                         else if (Stat == SK_MS_STAT_SLAVE ) {
4178                                 printk("    role:            slave\n");
4179                         }
4180                         else {
4181                                 printk("    role:            ???\n");
4182                         }
4183                 }
4184
4185                 /* 
4186                    Display dim (dynamic interrupt moderation) 
4187                    informations
4188                  */
4189                 if (pAC->DynIrqModInfo.IntModTypeSelect == C_INT_MOD_STATIC)
4190                         printk("    irq moderation:  static (%d ints/sec)\n",
4191                                         pAC->DynIrqModInfo.MaxModIntsPerSec);
4192                 else if (pAC->DynIrqModInfo.IntModTypeSelect == C_INT_MOD_DYNAMIC)
4193                         printk("    irq moderation:  dynamic (%d ints/sec)\n",
4194                                         pAC->DynIrqModInfo.MaxModIntsPerSec);
4195                 else
4196                         printk("    irq moderation:  disabled\n");
4197
4198
4199                 printk("    scatter-gather:  %s\n",
4200                        (dev->features & NETIF_F_SG) ? "enabled" : "disabled");
4201                 printk("    tx-checksum:     %s\n",
4202                        (dev->features & NETIF_F_IP_CSUM) ? "enabled" : "disabled");
4203                 printk("    rx-checksum:     %s\n",
4204                        pAC->RxPort[Param.Para32[0]].RxCsum ? "enabled" : "disabled");
4205
4206                 } else {
4207                         DoPrintInterfaceChange = SK_TRUE;
4208                 }
4209         
4210                 if ((Param.Para32[0] != pAC->ActivePort) &&
4211                         (pAC->RlmtNets == 1)) {
4212                         NewPara.Para32[0] = pAC->ActivePort;
4213                         NewPara.Para32[1] = Param.Para32[0];
4214                         SkEventQueue(pAC, SKGE_DRV, SK_DRV_SWITCH_INTERN,
4215                                 NewPara);
4216                 }
4217
4218                 /* Inform the world that link protocol is up. */
4219                 netif_carrier_on(dev);
4220                 break;
4221         }
4222         case SK_DRV_NET_DOWN:    /* SK_U32 Reason */
4223                 /* action list 7 */
4224                 SK_DBG_MSG(NULL, SK_DBGMOD_DRV, SK_DBGCAT_DRV_EVENT,
4225                         ("NET DOWN EVENT "));
4226                 if (DoPrintInterfaceChange) {
4227                         printk("%s: network connection down\n", 
4228                                 pAC->dev[Param.Para32[1]]->name);
4229                 } else {
4230                         DoPrintInterfaceChange = SK_TRUE;
4231                 }
4232                 netif_carrier_off(pAC->dev[Param.Para32[1]]);
4233                 break;
4234         case SK_DRV_SWITCH_HARD: /* SK_U32 FromPortIdx SK_U32 ToPortIdx */
4235                 SK_DBG_MSG(NULL, SK_DBGMOD_DRV, SK_DBGCAT_DRV_EVENT,
4236                         ("PORT SWITCH HARD "));
4237         case SK_DRV_SWITCH_SOFT: /* SK_U32 FromPortIdx SK_U32 ToPortIdx */
4238         /* action list 6 */
4239                 printk("%s: switching to port %c\n", pAC->dev[0]->name,
4240                         'A'+Param.Para32[1]);
4241         case SK_DRV_SWITCH_INTERN: /* SK_U32 FromPortIdx SK_U32 ToPortIdx */
4242                 FromPort = Param.Para32[0];
4243                 ToPort = Param.Para32[1];
4244                 SK_DBG_MSG(NULL, SK_DBGMOD_DRV, SK_DBGCAT_DRV_EVENT,
4245                         ("PORT SWITCH EVENT, From: %d  To: %d (Pref %d) ",
4246                         FromPort, ToPort, pAC->Rlmt.Net[0].PrefPort));
4247                 NewPara.Para64 = FromPort;
4248                 SkPnmiEvent(pAC, IoC, SK_PNMI_EVT_XMAC_RESET, NewPara);
4249                 NewPara.Para64 = ToPort;
4250                 SkPnmiEvent(pAC, IoC, SK_PNMI_EVT_XMAC_RESET, NewPara);
4251                 spin_lock_irqsave(
4252                         &pAC->TxPort[FromPort][TX_PRIO_LOW].TxDesRingLock,
4253                         Flags);
4254                 spin_lock(&pAC->TxPort[ToPort][TX_PRIO_LOW].TxDesRingLock);
4255                 SkGeStopPort(pAC, IoC, FromPort, SK_STOP_ALL, SK_SOFT_RST);
4256                 SkGeStopPort(pAC, IoC, ToPort, SK_STOP_ALL, SK_SOFT_RST);
4257                 spin_unlock(&pAC->TxPort[ToPort][TX_PRIO_LOW].TxDesRingLock);
4258                 spin_unlock_irqrestore(
4259                         &pAC->TxPort[FromPort][TX_PRIO_LOW].TxDesRingLock,
4260                         Flags);
4261
4262                 ReceiveIrq(pAC, &pAC->RxPort[FromPort], SK_FALSE); /* clears rx ring */
4263                 ReceiveIrq(pAC, &pAC->RxPort[ToPort], SK_FALSE); /* clears rx ring */
4264                 
4265                 ClearTxRing(pAC, &pAC->TxPort[FromPort][TX_PRIO_LOW]);
4266                 ClearTxRing(pAC, &pAC->TxPort[ToPort][TX_PRIO_LOW]);
4267                 spin_lock_irqsave(
4268                         &pAC->TxPort[FromPort][TX_PRIO_LOW].TxDesRingLock,
4269                         Flags);
4270                 spin_lock(&pAC->TxPort[ToPort][TX_PRIO_LOW].TxDesRingLock);
4271                 pAC->ActivePort = ToPort;
4272 #if 0
4273                 SetQueueSizes(pAC);
4274 #else
4275                 /* tschilling: New common function with minimum size check. */
4276                 DualNet = SK_FALSE;
4277                 if (pAC->RlmtNets == 2) {
4278                         DualNet = SK_TRUE;
4279                 }
4280                 
4281                 if (SkGeInitAssignRamToQueues(
4282                         pAC,
4283                         pAC->ActivePort,
4284                         DualNet)) {
4285                         spin_unlock(&pAC->TxPort[ToPort][TX_PRIO_LOW].TxDesRingLock);
4286                         spin_unlock_irqrestore(
4287                                 &pAC->TxPort[FromPort][TX_PRIO_LOW].TxDesRingLock,
4288                                 Flags);
4289                         printk("SkGeInitAssignRamToQueues failed.\n");
4290                         break;
4291                 }
4292 #endif
4293                 /* tschilling: Handling of return values inserted. */
4294                 if (SkGeInitPort(pAC, IoC, FromPort) ||
4295                         SkGeInitPort(pAC, IoC, ToPort)) {
4296                         printk("%s: SkGeInitPort failed.\n", pAC->dev[0]->name);
4297                 }
4298                 if (Event == SK_DRV_SWITCH_SOFT) {
4299                         SkMacRxTxEnable(pAC, IoC, FromPort);
4300                 }
4301                 SkMacRxTxEnable(pAC, IoC, ToPort);
4302                 SkAddrSwap(pAC, IoC, FromPort, ToPort);
4303                 SkAddrMcUpdate(pAC, IoC, FromPort);
4304                 SkAddrMcUpdate(pAC, IoC, ToPort);
4305                 PortReInitBmu(pAC, FromPort);
4306                 PortReInitBmu(pAC, ToPort);
4307                 SkGePollTxD(pAC, IoC, FromPort, SK_TRUE);
4308                 SkGePollTxD(pAC, IoC, ToPort, SK_TRUE);
4309                 ClearAndStartRx(pAC, FromPort);
4310                 ClearAndStartRx(pAC, ToPort);
4311                 spin_unlock(&pAC->TxPort[ToPort][TX_PRIO_LOW].TxDesRingLock);
4312                 spin_unlock_irqrestore(
4313                         &pAC->TxPort[FromPort][TX_PRIO_LOW].TxDesRingLock,
4314                         Flags);
4315                 break;
4316         case SK_DRV_RLMT_SEND:   /* SK_MBUF *pMb */
4317                 SK_DBG_MSG(NULL, SK_DBGMOD_DRV, SK_DBGCAT_DRV_EVENT,
4318                         ("RLS "));
4319                 pRlmtMbuf = (SK_MBUF*) Param.pParaPtr;
4320                 pMsg = (struct sk_buff*) pRlmtMbuf->pOs;
4321                 skb_put(pMsg, pRlmtMbuf->Length);
4322                 if (XmitFrame(pAC, &pAC->TxPort[pRlmtMbuf->PortIdx][TX_PRIO_LOW],
4323                         pMsg) < 0)
4324
4325                         DEV_KFREE_SKB_ANY(pMsg);
4326                 break;
4327         case SK_DRV_TIMER:
4328                 if (Param.Para32[0] == SK_DRV_MODERATION_TIMER) {
4329                         /*
4330                         ** expiration of the moderation timer implies that
4331                         ** dynamic moderation is to be applied
4332                         */
4333                         SkDimStartModerationTimer(pAC);
4334                         SkDimModerate(pAC);
4335                         if (pAC->DynIrqModInfo.DisplayStats) {
4336                             SkDimDisplayModerationSettings(pAC);
4337                         }
4338                 } else if (Param.Para32[0] == SK_DRV_RX_CLEANUP_TIMER) {
4339                         /*
4340                         ** check if we need to check for descriptors which
4341                         ** haven't been handled the last millisecs
4342                         */
4343                         StartDrvCleanupTimer(pAC);
4344                         if (pAC->GIni.GIMacsFound == 2) {
4345                                 ReceiveIrq(pAC, &pAC->RxPort[1], SK_FALSE);
4346                         }
4347                         ReceiveIrq(pAC, &pAC->RxPort[0], SK_FALSE);
4348                 } else {
4349                         printk("Expiration of unknown timer\n");
4350                 }
4351                 break;
4352         default:
4353                 break;
4354         }
4355         SK_DBG_MSG(NULL, SK_DBGMOD_DRV, SK_DBGCAT_DRV_EVENT,
4356                 ("END EVENT "));
4357         
4358         return (0);
4359 } /* SkDrvEvent */
4360
4361
4362 /*****************************************************************************
4363  *
4364  *      SkErrorLog - log errors
4365  *
4366  * Description:
4367  *      This function logs errors to the system buffer and to the console
4368  *
4369  * Returns:
4370  *      0 if everything ok
4371  *      < 0  on error
4372  *      
4373  */
4374 void SkErrorLog(
4375 SK_AC   *pAC,
4376 int     ErrClass,
4377 int     ErrNum,
4378 char    *pErrorMsg)
4379 {
4380 char    ClassStr[80];
4381
4382         switch (ErrClass) {
4383         case SK_ERRCL_OTHER:
4384                 strcpy(ClassStr, "Other error");
4385                 break;
4386         case SK_ERRCL_CONFIG:
4387                 strcpy(ClassStr, "Configuration error");
4388                 break;
4389         case SK_ERRCL_INIT:
4390                 strcpy(ClassStr, "Initialization error");
4391                 break;
4392         case SK_ERRCL_NORES:
4393                 strcpy(ClassStr, "Out of resources error");
4394                 break;
4395         case SK_ERRCL_SW:
4396                 strcpy(ClassStr, "internal Software error");
4397                 break;
4398         case SK_ERRCL_HW:
4399                 strcpy(ClassStr, "Hardware failure");
4400                 break;
4401         case SK_ERRCL_COMM:
4402                 strcpy(ClassStr, "Communication error");
4403                 break;
4404         }
4405         printk(KERN_INFO "%s: -- ERROR --\n        Class:  %s\n"
4406                 "        Nr:  0x%x\n        Msg:  %s\n", pAC->dev[0]->name,
4407                 ClassStr, ErrNum, pErrorMsg);
4408
4409 } /* SkErrorLog */
4410
4411 #ifdef SK_DIAG_SUPPORT
4412
4413 /*****************************************************************************
4414  *
4415  *      SkDrvEnterDiagMode - handles DIAG attach request
4416  *
4417  * Description:
4418  *      Notify the kernel to NOT access the card any longer due to DIAG
4419  *      Deinitialize the Card
4420  *
4421  * Returns:
4422  *      int
4423  */
4424 int SkDrvEnterDiagMode(
4425 SK_AC   *pAc)   /* pointer to adapter context */
4426 {
4427         DEV_NET *pNet = netdev_priv(pAc->dev[0]);
4428         SK_AC   *pAC  = pNet->pAC;
4429
4430         SK_MEMCPY(&(pAc->PnmiBackup), &(pAc->PnmiStruct), 
4431                         sizeof(SK_PNMI_STRUCT_DATA));
4432
4433         pAC->DiagModeActive = DIAG_ACTIVE;
4434         if (pAC->BoardLevel > SK_INIT_DATA) {
4435                 if (netif_running(pAC->dev[0])) {
4436                         pAC->WasIfUp[0] = SK_TRUE;
4437                         pAC->DiagFlowCtrl = SK_TRUE; /* for SkGeClose      */
4438                         DoPrintInterfaceChange = SK_FALSE;
4439                         SkDrvDeInitAdapter(pAC, 0);  /* performs SkGeClose */
4440                 } else {
4441                         pAC->WasIfUp[0] = SK_FALSE;
4442                 }
4443                 if (pNet != netdev_priv(pAC->dev[1])) {
4444                         pNet = netdev_priv(pAC->dev[1]);
4445                         if (netif_running(pAC->dev[1])) {
4446                                 pAC->WasIfUp[1] = SK_TRUE;
4447                                 pAC->DiagFlowCtrl = SK_TRUE; /* for SkGeClose */
4448                                 DoPrintInterfaceChange = SK_FALSE;
4449                                 SkDrvDeInitAdapter(pAC, 1);  /* do SkGeClose  */
4450                         } else {
4451                                 pAC->WasIfUp[1] = SK_FALSE;
4452                         }
4453                 }
4454                 pAC->BoardLevel = SK_INIT_DATA;
4455         }
4456         return(0);
4457 }
4458
4459 /*****************************************************************************
4460  *
4461  *      SkDrvLeaveDiagMode - handles DIAG detach request
4462  *
4463  * Description:
4464  *      Notify the kernel to may access the card again after use by DIAG
4465  *      Initialize the Card
4466  *
4467  * Returns:
4468  *      int
4469  */
4470 int SkDrvLeaveDiagMode(
4471 SK_AC   *pAc)   /* pointer to adapter control context */
4472
4473         SK_MEMCPY(&(pAc->PnmiStruct), &(pAc->PnmiBackup), 
4474                         sizeof(SK_PNMI_STRUCT_DATA));
4475         pAc->DiagModeActive    = DIAG_NOTACTIVE;
4476         pAc->Pnmi.DiagAttached = SK_DIAG_IDLE;
4477         if (pAc->WasIfUp[0] == SK_TRUE) {
4478                 pAc->DiagFlowCtrl = SK_TRUE; /* for SkGeClose */
4479                 DoPrintInterfaceChange = SK_FALSE;
4480                 SkDrvInitAdapter(pAc, 0);    /* first device  */
4481         }
4482         if (pAc->WasIfUp[1] == SK_TRUE) {
4483                 pAc->DiagFlowCtrl = SK_TRUE; /* for SkGeClose */
4484                 DoPrintInterfaceChange = SK_FALSE;
4485                 SkDrvInitAdapter(pAc, 1);    /* second device */
4486         }
4487         return(0);
4488 }
4489
4490 /*****************************************************************************
4491  *
4492  *      ParseDeviceNbrFromSlotName - Evaluate PCI device number
4493  *
4494  * Description:
4495  *      This function parses the PCI slot name information string and will
4496  *      retrieve the devcie number out of it. The slot_name maintianed by
4497  *      linux is in the form of '02:0a.0', whereas the first two characters 
4498  *      represent the bus number in hex (in the sample above this is 
4499  *      pci bus 0x02) and the next two characters the device number (0x0a).
4500  *
4501  * Returns:
4502  *      SK_U32: The device number from the PCI slot name
4503  */ 
4504
4505 static SK_U32 ParseDeviceNbrFromSlotName(
4506 const char *SlotName)   /* pointer to pci slot name eg. '02:0a.0' */
4507 {
4508         char    *CurrCharPos    = (char *) SlotName;
4509         int     FirstNibble     = -1;
4510         int     SecondNibble    = -1;
4511         SK_U32  Result          =  0;
4512
4513         while (*CurrCharPos != '\0') {
4514                 if (*CurrCharPos == ':') { 
4515                         while (*CurrCharPos != '.') {
4516                                 CurrCharPos++;  
4517                                 if (    (*CurrCharPos >= '0') && 
4518                                         (*CurrCharPos <= '9')) {
4519                                         if (FirstNibble == -1) {
4520                                                 /* dec. value for '0' */
4521                                                 FirstNibble = *CurrCharPos - 48;
4522                                         } else {
4523                                                 SecondNibble = *CurrCharPos - 48;
4524                                         }  
4525                                 } else if (     (*CurrCharPos >= 'a') && 
4526                                                 (*CurrCharPos <= 'f')  ) {
4527                                         if (FirstNibble == -1) {
4528                                                 FirstNibble = *CurrCharPos - 87; 
4529                                         } else {
4530                                                 SecondNibble = *CurrCharPos - 87; 
4531                                         }
4532                                 } else {
4533                                         Result = 0;
4534                                 }
4535                         }
4536
4537                         Result = FirstNibble;
4538                         Result = Result << 4; /* first nibble is higher one */
4539                         Result = Result | SecondNibble;
4540                 }
4541                 CurrCharPos++;   /* next character */
4542         }
4543         return (Result);
4544 }
4545
4546 /****************************************************************************
4547  *
4548  *      SkDrvDeInitAdapter - deinitialize adapter (this function is only 
4549  *                              called if Diag attaches to that card)
4550  *
4551  * Description:
4552  *      Close initialized adapter.
4553  *
4554  * Returns:
4555  *      0 - on success
4556  *      error code - on error
4557  */
4558 static int SkDrvDeInitAdapter(
4559 SK_AC   *pAC,           /* pointer to adapter context   */
4560 int      devNbr)        /* what device is to be handled */
4561 {
4562         struct SK_NET_DEVICE *dev;
4563
4564         dev = pAC->dev[devNbr];
4565
4566         /* On Linux 2.6 the network driver does NOT mess with reference
4567         ** counts.  The driver MUST be able to be unloaded at any time
4568         ** due to the possibility of hotplug.
4569         */
4570         if (SkGeClose(dev) != 0) {
4571                 return (-1);
4572         }
4573         return (0);
4574
4575 } /* SkDrvDeInitAdapter() */
4576
4577 /****************************************************************************
4578  *
4579  *      SkDrvInitAdapter - Initialize adapter (this function is only 
4580  *                              called if Diag deattaches from that card)
4581  *
4582  * Description:
4583  *      Close initialized adapter.
4584  *
4585  * Returns:
4586  *      0 - on success
4587  *      error code - on error
4588  */
4589 static int SkDrvInitAdapter(
4590 SK_AC   *pAC,           /* pointer to adapter context   */
4591 int      devNbr)        /* what device is to be handled */
4592 {
4593         struct SK_NET_DEVICE *dev;
4594
4595         dev = pAC->dev[devNbr];
4596
4597         if (SkGeOpen(dev) != 0) {
4598                 return (-1);
4599         }
4600
4601         /*
4602         ** Use correct MTU size and indicate to kernel TX queue can be started
4603         */ 
4604         if (SkGeChangeMtu(dev, dev->mtu) != 0) {
4605                 return (-1);
4606         } 
4607         return (0);
4608
4609 } /* SkDrvInitAdapter */
4610
4611 #endif
4612
4613 #ifdef DEBUG
4614 /****************************************************************************/
4615 /* "debug only" section *****************************************************/
4616 /****************************************************************************/
4617
4618
4619 /*****************************************************************************
4620  *
4621  *      DumpMsg - print a frame
4622  *
4623  * Description:
4624  *      This function prints frames to the system logfile/to the console.
4625  *
4626  * Returns: N/A
4627  *      
4628  */
4629 static void DumpMsg(struct sk_buff *skb, char *str)
4630 {
4631         int     msglen;
4632
4633         if (skb == NULL) {
4634                 printk("DumpMsg(): NULL-Message\n");
4635                 return;
4636         }
4637
4638         if (skb->data == NULL) {
4639                 printk("DumpMsg(): Message empty\n");
4640                 return;
4641         }
4642
4643         msglen = skb->len;
4644         if (msglen > 64)
4645                 msglen = 64;
4646
4647         printk("--- Begin of message from %s , len %d (from %d) ----\n", str, msglen, skb->len);
4648
4649         DumpData((char *)skb->data, msglen);
4650
4651         printk("------- End of message ---------\n");
4652 } /* DumpMsg */
4653
4654
4655
4656 /*****************************************************************************
4657  *
4658  *      DumpData - print a data area
4659  *
4660  * Description:
4661  *      This function prints a area of data to the system logfile/to the
4662  *      console.
4663  *
4664  * Returns: N/A
4665  *      
4666  */
4667 static void DumpData(char *p, int size)
4668 {
4669 register int    i;
4670 int     haddr, addr;
4671 char    hex_buffer[180];
4672 char    asc_buffer[180];
4673 char    HEXCHAR[] = "0123456789ABCDEF";
4674
4675         addr = 0;
4676         haddr = 0;
4677         hex_buffer[0] = 0;
4678         asc_buffer[0] = 0;
4679         for (i=0; i < size; ) {
4680                 if (*p >= '0' && *p <='z')
4681                         asc_buffer[addr] = *p;
4682                 else
4683                         asc_buffer[addr] = '.';
4684                 addr++;
4685                 asc_buffer[addr] = 0;
4686                 hex_buffer[haddr] = HEXCHAR[(*p & 0xf0) >> 4];
4687                 haddr++;
4688                 hex_buffer[haddr] = HEXCHAR[*p & 0x0f];
4689                 haddr++;
4690                 hex_buffer[haddr] = ' ';
4691                 haddr++;
4692                 hex_buffer[haddr] = 0;
4693                 p++;
4694                 i++;
4695                 if (i%16 == 0) {
4696                         printk("%s  %s\n", hex_buffer, asc_buffer);
4697                         addr = 0;
4698                         haddr = 0;
4699                 }
4700         }
4701 } /* DumpData */
4702
4703
4704 /*****************************************************************************
4705  *
4706  *      DumpLong - print a data area as long values
4707  *
4708  * Description:
4709  *      This function prints a area of data to the system logfile/to the
4710  *      console.
4711  *
4712  * Returns: N/A
4713  *      
4714  */
4715 static void DumpLong(char *pc, int size)
4716 {
4717 register int    i;
4718 int     haddr, addr;
4719 char    hex_buffer[180];
4720 char    asc_buffer[180];
4721 char    HEXCHAR[] = "0123456789ABCDEF";
4722 long    *p;
4723 int     l;
4724
4725         addr = 0;
4726         haddr = 0;
4727         hex_buffer[0] = 0;
4728         asc_buffer[0] = 0;
4729         p = (long*) pc;
4730         for (i=0; i < size; ) {
4731                 l = (long) *p;
4732                 hex_buffer[haddr] = HEXCHAR[(l >> 28) & 0xf];
4733                 haddr++;
4734                 hex_buffer[haddr] = HEXCHAR[(l >> 24) & 0xf];
4735                 haddr++;
4736                 hex_buffer[haddr] = HEXCHAR[(l >> 20) & 0xf];
4737                 haddr++;
4738                 hex_buffer[haddr] = HEXCHAR[(l >> 16) & 0xf];
4739                 haddr++;
4740                 hex_buffer[haddr] = HEXCHAR[(l >> 12) & 0xf];
4741                 haddr++;
4742                 hex_buffer[haddr] = HEXCHAR[(l >> 8) & 0xf];
4743                 haddr++;
4744                 hex_buffer[haddr] = HEXCHAR[(l >> 4) & 0xf];
4745                 haddr++;
4746                 hex_buffer[haddr] = HEXCHAR[l & 0x0f];
4747                 haddr++;
4748                 hex_buffer[haddr] = ' ';
4749                 haddr++;
4750                 hex_buffer[haddr] = 0;
4751                 p++;
4752                 i++;
4753                 if (i%8 == 0) {
4754                         printk("%4x %s\n", (i-8)*4, hex_buffer);
4755                         haddr = 0;
4756                 }
4757         }
4758         printk("------------------------\n");
4759 } /* DumpLong */
4760
4761 #endif
4762
4763 static int __devinit skge_probe_one(struct pci_dev *pdev,
4764                 const struct pci_device_id *ent)
4765 {
4766         SK_AC                   *pAC;
4767         DEV_NET                 *pNet = NULL;
4768         struct net_device       *dev = NULL;
4769         static int boards_found = 0;
4770         int error = -ENODEV;
4771         int using_dac = 0;
4772         char DeviceStr[80];
4773
4774         if (pci_enable_device(pdev))
4775                 goto out;
4776  
4777         /* Configure DMA attributes. */
4778         if (sizeof(dma_addr_t) > sizeof(u32) &&
4779             !(error = pci_set_dma_mask(pdev, DMA_64BIT_MASK))) {
4780                 using_dac = 1;
4781                 error = pci_set_consistent_dma_mask(pdev, DMA_64BIT_MASK);
4782                 if (error < 0) {
4783                         printk(KERN_ERR "sk98lin %s unable to obtain 64 bit DMA "
4784                                "for consistent allocations\n", pci_name(pdev));
4785                         goto out_disable_device;
4786                 }
4787         } else {
4788                 error = pci_set_dma_mask(pdev, DMA_32BIT_MASK);
4789                 if (error) {
4790                         printk(KERN_ERR "sk98lin %s no usable DMA configuration\n",
4791                                pci_name(pdev));
4792                         goto out_disable_device;
4793                 }
4794         }
4795
4796         error = -ENOMEM;
4797         dev = alloc_etherdev(sizeof(DEV_NET));
4798         if (!dev) {
4799                 printk(KERN_ERR "sk98lin: unable to allocate etherdev "
4800                        "structure!\n");
4801                 goto out_disable_device;
4802         }
4803
4804         pNet = netdev_priv(dev);
4805         pNet->pAC = kzalloc(sizeof(SK_AC), GFP_KERNEL);
4806         if (!pNet->pAC) {
4807                 printk(KERN_ERR "sk98lin: unable to allocate adapter "
4808                        "structure!\n");
4809                 goto out_free_netdev;
4810         }
4811
4812         pAC = pNet->pAC;
4813         pAC->PciDev = pdev;
4814
4815         pAC->dev[0] = dev;
4816         pAC->dev[1] = dev;
4817         pAC->CheckQueue = SK_FALSE;
4818
4819         dev->irq = pdev->irq;
4820
4821         error = SkGeInitPCI(pAC);
4822         if (error) {
4823                 printk(KERN_ERR "sk98lin: PCI setup failed: %i\n", error);
4824                 goto out_free_netdev;
4825         }
4826
4827         SET_MODULE_OWNER(dev);
4828         dev->open =             &SkGeOpen;
4829         dev->stop =             &SkGeClose;
4830         dev->hard_start_xmit =  &SkGeXmit;
4831         dev->get_stats =        &SkGeStats;
4832         dev->set_multicast_list = &SkGeSetRxMode;
4833         dev->set_mac_address =  &SkGeSetMacAddr;
4834         dev->do_ioctl =         &SkGeIoctl;
4835         dev->change_mtu =       &SkGeChangeMtu;
4836 #ifdef CONFIG_NET_POLL_CONTROLLER
4837         dev->poll_controller =  &SkGePollController;
4838 #endif
4839         SET_NETDEV_DEV(dev, &pdev->dev);
4840         SET_ETHTOOL_OPS(dev, &SkGeEthtoolOps);
4841
4842         /* Use only if yukon hardware */
4843         if (pAC->ChipsetType) {
4844 #ifdef USE_SK_TX_CHECKSUM
4845                 dev->features |= NETIF_F_IP_CSUM;
4846 #endif
4847 #ifdef SK_ZEROCOPY
4848                 dev->features |= NETIF_F_SG;
4849 #endif
4850 #ifdef USE_SK_RX_CHECKSUM
4851                 pAC->RxPort[0].RxCsum = 1;
4852 #endif
4853         }
4854
4855         if (using_dac)
4856                 dev->features |= NETIF_F_HIGHDMA;
4857
4858         pAC->Index = boards_found++;
4859
4860         error = SkGeBoardInit(dev, pAC);
4861         if (error)
4862                 goto out_free_netdev;
4863
4864         /* Read Adapter name from VPD */
4865         if (ProductStr(pAC, DeviceStr, sizeof(DeviceStr)) != 0) {
4866                 error = -EIO;
4867                 printk(KERN_ERR "sk98lin: Could not read VPD data.\n");
4868                 goto out_free_resources;
4869         }
4870
4871         /* Register net device */
4872         error = register_netdev(dev);
4873         if (error) {
4874                 printk(KERN_ERR "sk98lin: Could not register device.\n");
4875                 goto out_free_resources;
4876         }
4877
4878         /* Print adapter specific string from vpd */
4879         printk("%s: %s\n", dev->name, DeviceStr);
4880
4881         /* Print configuration settings */
4882         printk("      PrefPort:%c  RlmtMode:%s\n",
4883                 'A' + pAC->Rlmt.Net[0].Port[pAC->Rlmt.Net[0].PrefPort]->PortNumber,
4884                 (pAC->RlmtMode==0)  ? "Check Link State" :
4885                 ((pAC->RlmtMode==1) ? "Check Link State" :
4886                 ((pAC->RlmtMode==3) ? "Check Local Port" :
4887                 ((pAC->RlmtMode==7) ? "Check Segmentation" :
4888                 ((pAC->RlmtMode==17) ? "Dual Check Link State" :"Error")))));
4889
4890         SkGeYellowLED(pAC, pAC->IoBase, 1);
4891
4892         memcpy(&dev->dev_addr, &pAC->Addr.Net[0].CurrentMacAddress, 6);
4893         memcpy(dev->perm_addr, dev->dev_addr, dev->addr_len);
4894
4895         pNet->PortNr = 0;
4896         pNet->NetNr  = 0;
4897
4898         boards_found++;
4899
4900         pci_set_drvdata(pdev, dev);
4901
4902         /* More then one port found */
4903         if ((pAC->GIni.GIMacsFound == 2 ) && (pAC->RlmtNets == 2)) {
4904                 dev = alloc_etherdev(sizeof(DEV_NET));
4905                 if (!dev) {
4906                         printk(KERN_ERR "sk98lin: unable to allocate etherdev "
4907                                 "structure!\n");
4908                         goto single_port;
4909                 }
4910
4911                 pNet          = netdev_priv(dev);
4912                 pNet->PortNr  = 1;
4913                 pNet->NetNr   = 1;
4914                 pNet->pAC     = pAC;
4915
4916                 dev->open               = &SkGeOpen;
4917                 dev->stop               = &SkGeClose;
4918                 dev->hard_start_xmit    = &SkGeXmit;
4919                 dev->get_stats          = &SkGeStats;
4920                 dev->set_multicast_list = &SkGeSetRxMode;
4921                 dev->set_mac_address    = &SkGeSetMacAddr;
4922                 dev->do_ioctl           = &SkGeIoctl;
4923                 dev->change_mtu         = &SkGeChangeMtu;
4924                 SET_NETDEV_DEV(dev, &pdev->dev);
4925                 SET_ETHTOOL_OPS(dev, &SkGeEthtoolOps);
4926
4927                 if (pAC->ChipsetType) {
4928 #ifdef USE_SK_TX_CHECKSUM
4929                         dev->features |= NETIF_F_IP_CSUM;
4930 #endif
4931 #ifdef SK_ZEROCOPY
4932                         dev->features |= NETIF_F_SG;
4933 #endif
4934 #ifdef USE_SK_RX_CHECKSUM
4935                         pAC->RxPort[1].RxCsum = 1;
4936 #endif
4937                 }
4938
4939                 if (using_dac)
4940                         dev->features |= NETIF_F_HIGHDMA;
4941
4942                 error = register_netdev(dev);
4943                 if (error) {
4944                         printk(KERN_ERR "sk98lin: Could not register device"
4945                                " for second port. (%d)\n", error);
4946                         free_netdev(dev);
4947                         goto single_port;
4948                 }
4949
4950                 pAC->dev[1]   = dev;
4951                 memcpy(&dev->dev_addr,
4952                        &pAC->Addr.Net[1].CurrentMacAddress, 6);
4953                 memcpy(dev->perm_addr, dev->dev_addr, dev->addr_len);
4954
4955                 printk("%s: %s\n", dev->name, DeviceStr);
4956                 printk("      PrefPort:B  RlmtMode:Dual Check Link State\n");
4957         }
4958
4959 single_port:
4960
4961         /* Save the hardware revision */
4962         pAC->HWRevision = (((pAC->GIni.GIPciHwRev >> 4) & 0x0F)*10) +
4963                 (pAC->GIni.GIPciHwRev & 0x0F);
4964
4965         /* Set driver globals */
4966         pAC->Pnmi.pDriverFileName    = DRIVER_FILE_NAME;
4967         pAC->Pnmi.pDriverReleaseDate = DRIVER_REL_DATE;
4968
4969         memset(&pAC->PnmiBackup, 0, sizeof(SK_PNMI_STRUCT_DATA));
4970         memcpy(&pAC->PnmiBackup, &pAC->PnmiStruct, sizeof(SK_PNMI_STRUCT_DATA));
4971
4972         return 0;
4973
4974  out_free_resources:
4975         FreeResources(dev);
4976  out_free_netdev:
4977         free_netdev(dev);
4978  out_disable_device:
4979         pci_disable_device(pdev);
4980  out:
4981         return error;
4982 }
4983
4984 static void __devexit skge_remove_one(struct pci_dev *pdev)
4985 {
4986         struct net_device *dev = pci_get_drvdata(pdev);
4987         DEV_NET *pNet = netdev_priv(dev);
4988         SK_AC *pAC = pNet->pAC;
4989         struct net_device *otherdev = pAC->dev[1];
4990
4991         unregister_netdev(dev);
4992
4993         SkGeYellowLED(pAC, pAC->IoBase, 0);
4994
4995         if (pAC->BoardLevel == SK_INIT_RUN) {
4996                 SK_EVPARA EvPara;
4997                 unsigned long Flags;
4998
4999                 /* board is still alive */
5000                 spin_lock_irqsave(&pAC->SlowPathLock, Flags);
5001                 EvPara.Para32[0] = 0;
5002                 EvPara.Para32[1] = -1;
5003                 SkEventQueue(pAC, SKGE_RLMT, SK_RLMT_STOP, EvPara);
5004                 EvPara.Para32[0] = 1;
5005                 EvPara.Para32[1] = -1;
5006                 SkEventQueue(pAC, SKGE_RLMT, SK_RLMT_STOP, EvPara);
5007                 SkEventDispatcher(pAC, pAC->IoBase);
5008                 /* disable interrupts */
5009                 SK_OUT32(pAC->IoBase, B0_IMSK, 0);
5010                 SkGeDeInit(pAC, pAC->IoBase);
5011                 spin_unlock_irqrestore(&pAC->SlowPathLock, Flags);
5012                 pAC->BoardLevel = SK_INIT_DATA;
5013                 /* We do NOT check here, if IRQ was pending, of course*/
5014         }
5015
5016         if (pAC->BoardLevel == SK_INIT_IO) {
5017                 /* board is still alive */
5018                 SkGeDeInit(pAC, pAC->IoBase);
5019                 pAC->BoardLevel = SK_INIT_DATA;
5020         }
5021
5022         FreeResources(dev);
5023         free_netdev(dev);
5024         if (otherdev != dev)
5025                 free_netdev(otherdev);
5026         kfree(pAC);
5027 }
5028
5029 #ifdef CONFIG_PM
5030 static int skge_suspend(struct pci_dev *pdev, pm_message_t state)
5031 {
5032         struct net_device *dev = pci_get_drvdata(pdev);
5033         DEV_NET *pNet = netdev_priv(dev);
5034         SK_AC *pAC = pNet->pAC;
5035         struct net_device *otherdev = pAC->dev[1];
5036
5037         if (netif_running(dev)) {
5038                 netif_carrier_off(dev);
5039                 DoPrintInterfaceChange = SK_FALSE;
5040                 SkDrvDeInitAdapter(pAC, 0);  /* performs SkGeClose */
5041                 netif_device_detach(dev);
5042         }
5043         if (otherdev != dev) {
5044                 if (netif_running(otherdev)) {
5045                         netif_carrier_off(otherdev);
5046                         DoPrintInterfaceChange = SK_FALSE;
5047                         SkDrvDeInitAdapter(pAC, 1);  /* performs SkGeClose */
5048                         netif_device_detach(otherdev);
5049                 }
5050         }
5051
5052         pci_save_state(pdev);
5053         pci_enable_wake(pdev, pci_choose_state(pdev, state), 0);
5054         if (pAC->AllocFlag & SK_ALLOC_IRQ) {
5055                 free_irq(dev->irq, dev);
5056         }
5057         pci_disable_device(pdev);
5058         pci_set_power_state(pdev, pci_choose_state(pdev, state));
5059
5060         return 0;
5061 }
5062
5063 static int skge_resume(struct pci_dev *pdev)
5064 {
5065         struct net_device *dev = pci_get_drvdata(pdev);
5066         DEV_NET *pNet = netdev_priv(dev);
5067         SK_AC *pAC = pNet->pAC;
5068         struct net_device *otherdev = pAC->dev[1];
5069         int ret;
5070
5071         pci_set_power_state(pdev, PCI_D0);
5072         pci_restore_state(pdev);
5073         pci_enable_device(pdev);
5074         pci_set_master(pdev);
5075         if (pAC->GIni.GIMacsFound == 2)
5076                 ret = request_irq(dev->irq, SkGeIsr, IRQF_SHARED, "sk98lin", dev);
5077         else
5078                 ret = request_irq(dev->irq, SkGeIsrOnePort, IRQF_SHARED, "sk98lin", dev);
5079         if (ret) {
5080                 printk(KERN_WARNING "sk98lin: unable to acquire IRQ %d\n", dev->irq);
5081                 pAC->AllocFlag &= ~SK_ALLOC_IRQ;
5082                 dev->irq = 0;
5083                 pci_disable_device(pdev);
5084                 return -EBUSY;
5085         }
5086
5087         netif_device_attach(dev);
5088         if (netif_running(dev)) {
5089                 DoPrintInterfaceChange = SK_FALSE;
5090                 SkDrvInitAdapter(pAC, 0);    /* first device  */
5091         }
5092         if (otherdev != dev) {
5093                 netif_device_attach(otherdev);
5094                 if (netif_running(otherdev)) {
5095                         DoPrintInterfaceChange = SK_FALSE;
5096                         SkDrvInitAdapter(pAC, 1);    /* second device  */
5097                 }
5098         }
5099
5100         return 0;
5101 }
5102 #else
5103 #define skge_suspend NULL
5104 #define skge_resume NULL
5105 #endif
5106
5107 static struct pci_device_id skge_pci_tbl[] = {
5108         { PCI_VENDOR_ID_3COM, 0x1700, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0 },
5109         { PCI_VENDOR_ID_3COM, 0x80eb, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0 },
5110         { PCI_VENDOR_ID_SYSKONNECT, 0x4300, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0 },
5111         { PCI_VENDOR_ID_SYSKONNECT, 0x4320, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0 },
5112 /* DLink card does not have valid VPD so this driver gags
5113  *      { PCI_VENDOR_ID_DLINK, 0x4c00, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0 },
5114  */
5115         { PCI_VENDOR_ID_MARVELL, 0x4320, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0 },
5116         { PCI_VENDOR_ID_MARVELL, 0x5005, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0 },
5117         { PCI_VENDOR_ID_CNET, 0x434e, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0 },
5118         { PCI_VENDOR_ID_LINKSYS, 0x1032, PCI_ANY_ID, 0x0015, },
5119         { PCI_VENDOR_ID_LINKSYS, 0x1064, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0 },
5120         { 0 }
5121 };
5122
5123 MODULE_DEVICE_TABLE(pci, skge_pci_tbl);
5124
5125 static struct pci_driver skge_driver = {
5126         .name           = "sk98lin",
5127         .id_table       = skge_pci_tbl,
5128         .probe          = skge_probe_one,
5129         .remove         = __devexit_p(skge_remove_one),
5130         .suspend        = skge_suspend,
5131         .resume         = skge_resume,
5132 };
5133
5134 static int __init skge_init(void)
5135 {
5136         return pci_module_init(&skge_driver);
5137 }
5138
5139 static void __exit skge_exit(void)
5140 {
5141         pci_unregister_driver(&skge_driver);
5142 }
5143
5144 module_init(skge_init);
5145 module_exit(skge_exit);