v2.4.9.9 -> v2.4.9.10
[opensuse:kernel.git] / drivers / net / fealnx.c
1 /*
2         Written 1998-2000 by Donald Becker.
3
4         This software may be used and distributed according to the terms of
5         the GNU General Public License (GPL), incorporated herein by reference.
6         Drivers based on or derived from this code fall under the GPL and must
7         retain the authorship, copyright and license notice.  This file is not
8         a complete program and may only be used when the entire operating
9         system is licensed under the GPL.
10
11         The author may be reached as becker@scyld.com, or C/O
12         Scyld Computing Corporation
13         410 Severn Ave., Suite 210
14         Annapolis MD 21403
15
16         Support information and updates available at
17         http://www.scyld.com/network/pci-skeleton.html
18 */
19
20 static int debug;               /* 1-> print debug message */
21 static int max_interrupt_work = 20;
22
23 /* Maximum number of multicast addresses to filter (vs. Rx-all-multicast). */
24 static int multicast_filter_limit = 32;
25
26 /* Set the copy breakpoint for the copy-only-tiny-frames scheme. */
27 /* Setting to > 1518 effectively disables this feature.          */
28 static int rx_copybreak;
29
30 /* Used to pass the media type, etc.                            */
31 /* Both 'options[]' and 'full_duplex[]' should exist for driver */
32 /* interoperability.                                            */
33 /* The media type is usually passed in 'options[]'.             */
34 #define MAX_UNITS 8             /* More are supported, limit only on options */
35 static int options[MAX_UNITS] = { -1, -1, -1, -1, -1, -1, -1, -1 };
36 static int full_duplex[MAX_UNITS] = { -1, -1, -1, -1, -1, -1, -1, -1 };
37
38 /* Operational parameters that are set at compile time.                 */
39 /* Keep the ring sizes a power of two for compile efficiency.           */
40 /* The compiler will convert <unsigned>'%'<2^N> into a bit mask.        */
41 /* Making the Tx ring too large decreases the effectiveness of channel  */
42 /* bonding and packet priority.                                         */
43 /* There are no ill effects from too-large receive rings.               */
44 // 88-12-9 modify,
45 // #define TX_RING_SIZE    16
46 // #define RX_RING_SIZE    32
47 #define TX_RING_SIZE    6
48 #define RX_RING_SIZE    12
49 #define TX_TOTAL_SIZE   TX_RING_SIZE*sizeof(struct fealnx_desc)
50 #define RX_TOTAL_SIZE   RX_RING_SIZE*sizeof(struct fealnx_desc)
51
52 /* Operational parameters that usually are not changed. */
53 /* Time in jiffies before concluding the transmitter is hung. */
54 #define TX_TIMEOUT      (2*HZ)
55
56 #define PKT_BUF_SZ      1536    /* Size of each temporary Rx buffer. */
57
58
59 /* Include files, designed to support most kernel versions 2.0.0 and later. */
60 #include <linux/module.h>
61 #include <linux/kernel.h>
62 #include <linux/sched.h>
63 #include <linux/string.h>
64 #include <linux/timer.h>
65 #include <linux/errno.h>
66 #include <linux/ioport.h>
67 #include <linux/slab.h>
68 #include <linux/interrupt.h>
69 #include <linux/pci.h>
70 #include <linux/netdevice.h>
71 #include <linux/etherdevice.h>
72 #include <linux/skbuff.h>
73 #include <linux/init.h>
74 #include <linux/mii.h>
75 #include <asm/processor.h>      /* Processor type for cache alignment. */
76 #include <asm/bitops.h>
77 #include <asm/io.h>
78
79 /* These identify the driver base version and may not be removed. */
80 static char version[] __devinitdata =
81 KERN_INFO "fealnx.c:v2.50 1/17/2001\n";
82
83
84 /* This driver was written to use PCI memory space, however some x86 systems
85    work only with I/O space accesses. */
86 #ifndef __alpha__
87 #define USE_IO_OPS
88 #endif
89
90 #ifdef USE_IO_OPS
91 #undef readb
92 #undef readw
93 #undef readl
94 #undef writeb
95 #undef writew
96 #undef writel
97 #define readb inb
98 #define readw inw
99 #define readl inl
100 #define writeb outb
101 #define writew outw
102 #define writel outl
103 #endif
104
105 /* Kernel compatibility defines, some common to David Hinds' PCMCIA package. */
106 /* This is only in the support-all-kernels source code. */
107
108 #define RUN_AT(x) (jiffies + (x))
109
110 MODULE_AUTHOR("Myson or whoever");
111 MODULE_DESCRIPTION("Myson MTD-8xx 100/10M Ethernet PCI Adapter Driver");
112 MODULE_PARM(max_interrupt_work, "i");
113 //MODULE_PARM(min_pci_latency, "i");
114 MODULE_PARM(debug, "i");
115 MODULE_PARM(rx_copybreak, "i");
116 MODULE_PARM(multicast_filter_limit, "i");
117 MODULE_PARM(options, "1-" __MODULE_STRING(MAX_UNITS) "i");
118 MODULE_PARM(full_duplex, "1-" __MODULE_STRING(MAX_UNITS) "i");
119 MODULE_PARM_DESC(max_interrupt_work, "fealnx maximum events handled per interrupt");
120 MODULE_PARM_DESC(debug, "fealnx enable debugging (0-1)");
121 MODULE_PARM_DESC(rx_copybreak, "fealnx copy breakpoint for copy-only-tiny-frames");
122 MODULE_PARM_DESC(multicast_filter_limit, "fealnx maximum number of filtered multicast addresses");
123 MODULE_PARM_DESC(options, "fealnx: Bits 0-3: media type, bit 17: full duplex");
124 MODULE_PARM_DESC(full_duplex, "fealnx full duplex setting(s) (1)");
125
126 #define MIN_REGION_SIZE 136
127
128 enum pci_flags_bit {
129         PCI_USES_IO = 1,
130         PCI_USES_MEM = 2,
131         PCI_USES_MASTER = 4,
132         PCI_ADDR0 = 0x10 << 0,
133         PCI_ADDR1 = 0x10 << 1,
134         PCI_ADDR2 = 0x10 << 2,
135         PCI_ADDR3 = 0x10 << 3,
136 };
137
138 /* A chip capabilities table, matching the entries in pci_tbl[] above. */
139 enum chip_capability_flags {
140         HAS_MII_XCVR,
141         HAS_CHIP_XCVR,
142 };
143
144 /* 89/6/13 add, */
145 /* for different PHY */
146 enum phy_type_flags {
147         MysonPHY = 1,
148         AhdocPHY = 2,
149         SeeqPHY = 3,
150         MarvellPHY = 4,
151         Myson981 = 5,
152         LevelOnePHY = 6,
153         OtherPHY = 10,
154 };
155
156 struct chip_info {
157         char *chip_name;
158         int io_size;
159         int flags;
160 };
161
162 static struct chip_info skel_netdrv_tbl[] = {
163         {"100/10M Ethernet PCI Adapter", 136, HAS_MII_XCVR},
164         {"100/10M Ethernet PCI Adapter", 136, HAS_CHIP_XCVR},
165         {"1000/100/10M Ethernet PCI Adapter", 136, HAS_MII_XCVR},
166 };
167
168 /* Offsets to the Command and Status Registers. */
169 enum fealnx_offsets {
170         PAR0 = 0x0,             /* physical address 0-3 */
171         PAR1 = 0x04,            /* physical address 4-5 */
172         MAR0 = 0x08,            /* multicast address 0-3 */
173         MAR1 = 0x0C,            /* multicast address 4-7 */
174         FAR0 = 0x10,            /* flow-control address 0-3 */
175         FAR1 = 0x14,            /* flow-control address 4-5 */
176         TCRRCR = 0x18,          /* receive & transmit configuration */
177         BCR = 0x1C,             /* bus command */
178         TXPDR = 0x20,           /* transmit polling demand */
179         RXPDR = 0x24,           /* receive polling demand */
180         RXCWP = 0x28,           /* receive current word pointer */
181         TXLBA = 0x2C,           /* transmit list base address */
182         RXLBA = 0x30,           /* receive list base address */
183         ISR = 0x34,             /* interrupt status */
184         IMR = 0x38,             /* interrupt mask */
185         FTH = 0x3C,             /* flow control high/low threshold */
186         MANAGEMENT = 0x40,      /* bootrom/eeprom and mii management */
187         TALLY = 0x44,           /* tally counters for crc and mpa */
188         TSR = 0x48,             /* tally counter for transmit status */
189         BMCRSR = 0x4c,          /* basic mode control and status */
190         PHYIDENTIFIER = 0x50,   /* phy identifier */
191         ANARANLPAR = 0x54,      /* auto-negotiation advertisement and link
192                                    partner ability */
193         ANEROCR = 0x58,         /* auto-negotiation expansion and pci conf. */
194         BPREMRPSR = 0x5c,       /* bypass & receive error mask and phy status */
195 };
196
197 /* Bits in the interrupt status/enable registers. */
198 /* The bits in the Intr Status/Enable registers, mostly interrupt sources. */
199 enum intr_status_bits {
200         RFCON = 0x00020000,     /* receive flow control xon packet */
201         RFCOFF = 0x00010000,    /* receive flow control xoff packet */
202         LSCStatus = 0x00008000, /* link status change */
203         ANCStatus = 0x00004000, /* autonegotiation completed */
204         FBE = 0x00002000,       /* fatal bus error */
205         FBEMask = 0x00001800,   /* mask bit12-11 */
206         ParityErr = 0x00000000, /* parity error */
207         TargetErr = 0x00001000, /* target abort */
208         MasterErr = 0x00000800, /* master error */
209         TUNF = 0x00000400,      /* transmit underflow */
210         ROVF = 0x00000200,      /* receive overflow */
211         ETI = 0x00000100,       /* transmit early int */
212         ERI = 0x00000080,       /* receive early int */
213         CNTOVF = 0x00000040,    /* counter overflow */
214         RBU = 0x00000020,       /* receive buffer unavailable */
215         TBU = 0x00000010,       /* transmit buffer unavilable */
216         TI = 0x00000008,        /* transmit interrupt */
217         RI = 0x00000004,        /* receive interrupt */
218         RxErr = 0x00000002,     /* receive error */
219 };
220
221 /* Bits in the NetworkConfig register. */
222 enum rx_mode_bits {
223         RxModeMask = 0xe0,
224         PROM = 0x80,            /* promiscuous mode */
225         AB = 0x40,              /* accept broadcast */
226         AM = 0x20,              /* accept mutlicast */
227         ARP = 0x08,             /* receive runt pkt */
228         ALP = 0x04,             /* receive long pkt */
229         SEP = 0x02,             /* receive error pkt */
230 };
231
232 /* The Tulip Rx and Tx buffer descriptors. */
233 struct fealnx_desc {
234         s32 status;
235         s32 control;
236         u32 buffer;
237         u32 next_desc;
238         struct fealnx_desc *next_desc_logical;
239         struct sk_buff *skbuff;
240         u32 reserved1;
241         u32 reserved2;
242 };
243
244 /* Bits in network_desc.status */
245 enum rx_desc_status_bits {
246         RXOWN = 0x80000000,     /* own bit */
247         FLNGMASK = 0x0fff0000,  /* frame length */
248         FLNGShift = 16,
249         MARSTATUS = 0x00004000, /* multicast address received */
250         BARSTATUS = 0x00002000, /* broadcast address received */
251         PHYSTATUS = 0x00001000, /* physical address received */
252         RXFSD = 0x00000800,     /* first descriptor */
253         RXLSD = 0x00000400,     /* last descriptor */
254         ErrorSummary = 0x80,    /* error summary */
255         RUNT = 0x40,            /* runt packet received */
256         LONG = 0x20,            /* long packet received */
257         FAE = 0x10,             /* frame align error */
258         CRC = 0x08,             /* crc error */
259         RXER = 0x04,            /* receive error */
260 };
261
262 enum rx_desc_control_bits {
263         RXIC = 0x00800000,      /* interrupt control */
264         RBSShift = 0,
265 };
266
267 enum tx_desc_status_bits {
268         TXOWN = 0x80000000,     /* own bit */
269         JABTO = 0x00004000,     /* jabber timeout */
270         CSL = 0x00002000,       /* carrier sense lost */
271         LC = 0x00001000,        /* late collision */
272         EC = 0x00000800,        /* excessive collision */
273         UDF = 0x00000400,       /* fifo underflow */
274         DFR = 0x00000200,       /* deferred */
275         HF = 0x00000100,        /* heartbeat fail */
276         NCRMask = 0x000000ff,   /* collision retry count */
277         NCRShift = 0,
278 };
279
280 enum tx_desc_control_bits {
281         TXIC = 0x80000000,      /* interrupt control */
282         ETIControl = 0x40000000,        /* early transmit interrupt */
283         TXLD = 0x20000000,      /* last descriptor */
284         TXFD = 0x10000000,      /* first descriptor */
285         CRCEnable = 0x08000000, /* crc control */
286         PADEnable = 0x04000000, /* padding control */
287         RetryTxLC = 0x02000000, /* retry late collision */
288         PKTSMask = 0x3ff800,    /* packet size bit21-11 */
289         PKTSShift = 11,
290         TBSMask = 0x000007ff,   /* transmit buffer bit 10-0 */
291         TBSShift = 0,
292 };
293
294 /* BootROM/EEPROM/MII Management Register */
295 #define MASK_MIIR_MII_READ       0x00000000
296 #define MASK_MIIR_MII_WRITE      0x00000008
297 #define MASK_MIIR_MII_MDO        0x00000004
298 #define MASK_MIIR_MII_MDI        0x00000002
299 #define MASK_MIIR_MII_MDC        0x00000001
300
301 /* ST+OP+PHYAD+REGAD+TA */
302 #define OP_READ             0x6000      /* ST:01+OP:10+PHYAD+REGAD+TA:Z0 */
303 #define OP_WRITE            0x5002      /* ST:01+OP:01+PHYAD+REGAD+TA:10 */
304
305 /* ------------------------------------------------------------------------- */
306 /*      Constants for Myson PHY                                              */
307 /* ------------------------------------------------------------------------- */
308 #define MysonPHYID      0xd0000302
309 /* 89-7-27 add, (begin) */
310 #define MysonPHYID0     0x0302
311 #define StatusRegister  18
312 #define SPEED100        0x0400  // bit10
313 #define FULLMODE        0x0800  // bit11
314 /* 89-7-27 add, (end) */
315
316 /* ------------------------------------------------------------------------- */
317 /*      Constants for Seeq 80225 PHY                                         */
318 /* ------------------------------------------------------------------------- */
319 #define SeeqPHYID0      0x0016
320
321 #define MIIRegister18   18
322 #define SPD_DET_100     0x80
323 #define DPLX_DET_FULL   0x40
324
325 /* ------------------------------------------------------------------------- */
326 /*      Constants for Ahdoc 101 PHY                                          */
327 /* ------------------------------------------------------------------------- */
328 #define AhdocPHYID0     0x0022
329
330 #define DiagnosticReg   18
331 #define DPLX_FULL       0x0800
332 #define Speed_100       0x0400
333
334 /* 89/6/13 add, */
335 /* -------------------------------------------------------------------------- */
336 /*      Constants                                                             */
337 /* -------------------------------------------------------------------------- */
338 #define MarvellPHYID0           0x0141
339 #define LevelOnePHYID0          0x0013
340
341 #define MII1000BaseTControlReg  9
342 #define MII1000BaseTStatusReg   10
343 #define SpecificReg             17
344
345 /* for 1000BaseT Control Register */
346 #define PHYAbletoPerform1000FullDuplex  0x0200
347 #define PHYAbletoPerform1000HalfDuplex  0x0100
348 #define PHY1000AbilityMask              0x300
349
350 // for phy specific status register, marvell phy.
351 #define SpeedMask       0x0c000
352 #define Speed_1000M     0x08000
353 #define Speed_100M      0x4000
354 #define Speed_10M       0
355 #define Full_Duplex     0x2000
356
357 // 89/12/29 add, for phy specific status register, levelone phy, (begin)
358 #define LXT1000_100M    0x08000
359 #define LXT1000_1000M   0x0c000
360 #define LXT1000_Full    0x200
361 // 89/12/29 add, for phy specific status register, levelone phy, (end)
362
363 /* for 3-in-1 case */
364 #define PS10            0x00080000
365 #define FD              0x00100000
366 #define PS1000          0x00010000
367 #define LinkIsUp2       0x00040000
368
369 /* for PHY */
370 #define LinkIsUp        0x0004
371
372
373 struct netdev_private {
374         /* Descriptor rings first for alignment. */
375         struct fealnx_desc *rx_ring;
376         struct fealnx_desc *tx_ring;
377
378         dma_addr_t rx_ring_dma;
379         dma_addr_t tx_ring_dma;
380
381         struct net_device_stats stats;
382
383         /* Media monitoring timer. */
384         struct timer_list timer;
385
386         /* Frequently used values: keep some adjacent for cache effect. */
387         int flags;
388         struct pci_dev *pci_dev;
389         unsigned long crvalue;
390         unsigned long bcrvalue;
391         unsigned long imrvalue;
392         struct fealnx_desc *cur_rx;
393         struct fealnx_desc *lack_rxbuf;
394         int really_rx_count;
395         struct fealnx_desc *cur_tx;
396         struct fealnx_desc *cur_tx_copy;
397         int really_tx_count;
398         int free_tx_count;
399         unsigned int rx_buf_sz; /* Based on MTU+slack. */
400
401         /* These values are keep track of the transceiver/media in use. */
402         unsigned int linkok;
403         unsigned int line_speed;
404         unsigned int duplexmode;
405         unsigned int full_duplex:1;     /* Full-duplex operation requested. */
406         unsigned int duplex_lock:1;
407         unsigned int medialock:1;       /* Do not sense media. */
408         unsigned int default_port:4;    /* Last dev->if_port value. */
409         unsigned int PHYType;
410
411         /* MII transceiver section. */
412         int mii_cnt;            /* MII device addresses. */
413         unsigned char phys[2];  /* MII device addresses. */
414 };
415
416
417 static unsigned int mdio_read(struct net_device *dev, int phy_id, int location);
418 static void mdio_write(struct net_device *dev, int phy_id, int location, int value);
419 static int netdev_open(struct net_device *dev);
420 static void getlinktype(struct net_device *dev);
421 static void getlinkstatus(struct net_device *dev);
422 static void netdev_timer(unsigned long data);
423 static void tx_timeout(struct net_device *dev);
424 static void init_ring(struct net_device *dev);
425 static int start_tx(struct sk_buff *skb, struct net_device *dev);
426 static void intr_handler(int irq, void *dev_instance, struct pt_regs *regs);
427 static int netdev_rx(struct net_device *dev);
428 static inline unsigned ether_crc(int length, unsigned char *data);
429 static void set_rx_mode(struct net_device *dev);
430 static struct net_device_stats *get_stats(struct net_device *dev);
431 static int mii_ioctl(struct net_device *dev, struct ifreq *rq, int cmd);
432 static int netdev_close(struct net_device *dev);
433
434
435 void stop_nic_tx(long ioaddr, long crvalue)
436 {
437         writel(crvalue & (~0x40000), ioaddr + TCRRCR);
438
439         /* wait for tx stop */
440         {
441                 int i = 0, delay = 0x1000;
442
443                 while ((!(readl(ioaddr + TCRRCR) & 0x04000000)) && (i < delay)) {
444                         ++i;
445                 }
446         }
447 }
448
449
450 void stop_nic_rx(long ioaddr, long crvalue)
451 {
452         writel(crvalue & (~0x1), ioaddr + TCRRCR);
453
454         /* wait for rx stop */
455         {
456                 int i = 0, delay = 0x1000;
457
458                 while ((!(readl(ioaddr + TCRRCR) & 0x00008000)) && (i < delay)) {
459                         ++i;
460                 }
461         }
462 }
463
464
465
466 static int __devinit fealnx_init_one(struct pci_dev *pdev,
467                                      const struct pci_device_id *ent)
468 {
469         struct netdev_private *np;
470         int i, option, err, irq;
471         static int card_idx = -1;
472         char boardname[12];
473         long ioaddr;
474         unsigned int chip_id = ent->driver_data;
475         struct net_device *dev;
476         void *ring_space;
477         dma_addr_t ring_dma;
478         
479 /* when built into the kernel, we only print version if device is found */
480 #ifndef MODULE
481         static int printed_version;
482         if (!printed_version++)
483                 printk (version);
484 #endif
485         
486         card_idx++;
487         sprintf(boardname, "fealnx%d", card_idx);
488         
489         option = card_idx < MAX_UNITS ? options[card_idx] : 0;
490
491         i = pci_enable_device(pdev);
492         if (i) return i;
493         pci_set_master(pdev);
494         
495 #ifdef USE_IO_OPS
496         ioaddr = pci_resource_len(pdev, 0);
497 #else
498         ioaddr = pci_resource_len(pdev, 1);
499 #endif
500         if (ioaddr < MIN_REGION_SIZE) {
501                 printk(KERN_ERR "%s: region size %ld too small, aborting\n",
502                        boardname, ioaddr);
503                 return -ENODEV;
504         }
505
506         i = pci_request_regions(pdev, boardname);
507         if (i) return i;
508         
509         irq = pdev->irq;
510
511 #ifdef USE_IO_OPS
512         ioaddr = pci_resource_start(pdev, 0);
513 #else
514         ioaddr = (long) ioremap(pci_resource_start(pdev, 1),
515                                 pci_resource_len(pdev, 1));
516         if (!ioaddr) {
517                 err = -ENOMEM;
518                 goto err_out_res;
519         }
520 #endif
521         
522         dev = alloc_etherdev(sizeof(struct netdev_private));
523         if (!dev) {
524                 err = -ENOMEM;
525                 goto err_out_unmap;
526         }
527         SET_MODULE_OWNER(dev);
528
529         /* read ethernet id */
530         for (i = 0; i < 6; ++i)
531                 dev->dev_addr[i] = readb(ioaddr + PAR0 + i);
532
533         /* Reset the chip to erase previous misconfiguration. */
534         writel(0x00000001, ioaddr + BCR);
535
536         dev->base_addr = ioaddr;
537         dev->irq = irq;
538
539         /* Make certain the descriptor lists are aligned. */
540         np = dev->priv;
541         np->pci_dev = pdev;
542         np->flags = skel_netdrv_tbl[chip_id].flags;
543         pci_set_drvdata(pdev, dev);
544
545         ring_space = pci_alloc_consistent(pdev, RX_TOTAL_SIZE, &ring_dma);
546         if (!ring_space) {
547                 err = -ENOMEM;
548                 goto err_out_free_dev;
549         }
550         np->rx_ring = (struct fealnx_desc *)ring_space;
551         np->rx_ring_dma = ring_dma;
552
553         ring_space = pci_alloc_consistent(pdev, TX_TOTAL_SIZE, &ring_dma);
554         if (!ring_space) {
555                 err = -ENOMEM;
556                 goto err_out_free_rx;
557         }
558         np->tx_ring = (struct fealnx_desc *)ring_space;
559         np->tx_ring_dma = ring_dma;
560
561         /* find the connected MII xcvrs */
562         if (np->flags == HAS_MII_XCVR) {
563                 int phy, phy_idx = 0;
564
565                 for (phy = 1; phy < 32 && phy_idx < 4; phy++) {
566                         int mii_status = mdio_read(dev, phy, 1);
567
568                         if (mii_status != 0xffff && mii_status != 0x0000) {
569                                 np->phys[phy_idx++] = phy;
570                                 printk(KERN_INFO
571                                        "%s: MII PHY found at address %d, status "
572                                        "0x%4.4x.\n", dev->name, phy, mii_status);
573                                 /* get phy type */
574                                 {
575                                         unsigned int data;
576
577                                         data = mdio_read(dev, np->phys[0], 2);
578                                         if (data == SeeqPHYID0)
579                                                 np->PHYType = SeeqPHY;
580                                         else if (data == AhdocPHYID0)
581                                                 np->PHYType = AhdocPHY;
582                                         else if (data == MarvellPHYID0)
583                                                 np->PHYType = MarvellPHY;
584                                         else if (data == MysonPHYID0)
585                                                 np->PHYType = Myson981;
586                                         else if (data == LevelOnePHYID0)
587                                                 np->PHYType = LevelOnePHY;
588                                         else
589                                                 np->PHYType = OtherPHY;
590                                 }
591                         }
592                 }
593
594                 np->mii_cnt = phy_idx;
595                 if (phy_idx == 0) {
596                         printk(KERN_WARNING "%s: MII PHY not found -- this device may "
597                                "not operate correctly.\n", dev->name);
598                 }
599         } else {
600                 np->phys[0] = 32;
601 /* 89/6/23 add, (begin) */
602                 /* get phy type */
603                 if (readl(dev->base_addr + PHYIDENTIFIER) == MysonPHYID)
604                         np->PHYType = MysonPHY;
605                 else
606                         np->PHYType = OtherPHY;
607         }
608
609         if (dev->mem_start)
610                 option = dev->mem_start;
611
612         /* The lower four bits are the media type. */
613         if (option > 0) {
614                 if (option & 0x200)
615                         np->full_duplex = 1;
616                 np->default_port = option & 15;
617
618                 if (np->default_port)
619                         np->medialock = 1;
620         }
621
622         if (card_idx < MAX_UNITS && full_duplex[card_idx] > 0)
623                 np->full_duplex = full_duplex[card_idx];
624
625         if (np->full_duplex) {
626                 printk(KERN_INFO "%s: Media type forced to Full Duplex.\n", dev->name);
627 /* 89/6/13 add, (begin) */
628 //      if (np->PHYType==MarvellPHY)
629                 if ((np->PHYType == MarvellPHY) || (np->PHYType == LevelOnePHY)) {
630                         unsigned int data;
631
632                         data = mdio_read(dev, np->phys[0], 9);
633                         data = (data & 0xfcff) | 0x0200;
634                         mdio_write(dev, np->phys[0], 9, data);
635                 }
636 /* 89/6/13 add, (end) */
637                 if (np->flags == HAS_MII_XCVR)
638                         mdio_write(dev, np->phys[0], 4, 0x141);
639                 else
640                         writel(0x141, dev->base_addr + ANARANLPAR);
641                 np->duplex_lock = 1;
642         }
643
644         /* The chip-specific entries in the device structure. */
645         dev->open = &netdev_open;
646         dev->hard_start_xmit = &start_tx;
647         dev->stop = &netdev_close;
648         dev->get_stats = &get_stats;
649         dev->set_multicast_list = &set_rx_mode;
650         dev->do_ioctl = &mii_ioctl;
651         dev->tx_timeout = tx_timeout;
652         dev->watchdog_timeo = TX_TIMEOUT;
653         
654         err = register_netdev(dev);
655         if (err)
656                 goto err_out_free_tx;
657
658         printk(KERN_INFO "%s: %s at 0x%lx, ",
659                dev->name, skel_netdrv_tbl[chip_id].chip_name, ioaddr);
660         for (i = 0; i < 5; i++)
661                 printk("%2.2x:", dev->dev_addr[i]);
662         printk("%2.2x, IRQ %d.\n", dev->dev_addr[i], irq);
663
664         return 0;
665
666 err_out_free_tx:
667         pci_free_consistent(pdev, TX_TOTAL_SIZE, np->tx_ring, np->tx_ring_dma);
668 err_out_free_rx:
669         pci_free_consistent(pdev, RX_TOTAL_SIZE, np->rx_ring, np->rx_ring_dma);
670 err_out_free_dev:
671         kfree(dev);
672 err_out_unmap:
673 #ifndef USE_IO_OPS
674         iounmap((void *)ioaddr);
675 err_out_res:
676 #endif
677         pci_release_regions(pdev);
678         return err;
679 }
680
681 static void __devexit fealnx_remove_one(struct pci_dev *pdev)
682 {
683         struct net_device *dev = pci_get_drvdata(pdev);
684
685         if (dev) {
686                 struct netdev_private *np = dev->priv;
687
688                 pci_free_consistent(pdev, TX_TOTAL_SIZE, np->tx_ring,
689                         np->tx_ring_dma);
690                 pci_free_consistent(pdev, RX_TOTAL_SIZE, np->rx_ring,
691                         np->rx_ring_dma);
692                 unregister_netdev(dev);
693 #ifndef USE_IO_OPS
694                 iounmap((void *)dev->base_addr);
695 #endif
696                 kfree(dev);
697                 pci_release_regions(pdev);
698                 pci_set_drvdata(pdev, NULL);
699         } else
700                 printk(KERN_ERR "fealnx: remove for unknown device\n");
701 }
702
703 unsigned int m80x_read_tick(void)
704 /* function: Reads the Timer tick count register which decrements by 2 from  */
705 /*           65536 to 0 every 1/36.414 of a second. Each 2 decrements of the *//*           count represents 838 nsec's.                                    */
706 /* input   : none.                                                           */
707 /* output  : none.                                                           */
708 {
709         unsigned char tmp;
710         int value;
711
712         writeb((char) 0x06, 0x43);      // Command 8254 to latch T0's count
713
714         // now read the count.
715         tmp = (unsigned char) readb(0x40);
716         value = ((int) tmp) << 8;
717         tmp = (unsigned char) readb(0x40);
718         value |= (((int) tmp) & 0xff);
719         return (value);
720 }
721
722
723 void m80x_delay(unsigned int interval)
724 /* function: to wait for a specified time.                                   */
725 /* input   : interval ... the specified time.                                */
726 /* output  : none.                                                           */
727 {
728         unsigned int interval1, interval2, i = 0;
729
730         interval1 = m80x_read_tick();   // get initial value
731         do {
732                 interval2 = m80x_read_tick();
733                 if (interval1 < interval2)
734                         interval1 = interval2;
735                 ++i;
736         } while (((interval1 - interval2) < (ushort) interval) && (i < 65535));
737 }
738
739
740 static ulong m80x_send_cmd_to_phy(long miiport, int opcode, int phyad, int regad)
741 {
742         ulong miir;
743         int i;
744         unsigned int mask, data;
745
746         /* enable MII output */
747         miir = (ulong) readl(miiport);
748         miir &= 0xfffffff0;
749
750         miir |= MASK_MIIR_MII_WRITE + MASK_MIIR_MII_MDO;
751
752         /* send 32 1's preamble */
753         for (i = 0; i < 32; i++) {
754                 /* low MDC; MDO is already high (miir) */
755                 miir &= ~MASK_MIIR_MII_MDC;
756                 writel(miir, miiport);
757
758                 /* high MDC */
759                 miir |= MASK_MIIR_MII_MDC;
760                 writel(miir, miiport);
761         }
762
763         /* calculate ST+OP+PHYAD+REGAD+TA */
764         data = opcode | (phyad << 7) | (regad << 2);
765
766         /* sent out */
767         mask = 0x8000;
768         while (mask) {
769                 /* low MDC, prepare MDO */
770                 miir &= ~(MASK_MIIR_MII_MDC + MASK_MIIR_MII_MDO);
771                 if (mask & data)
772                         miir |= MASK_MIIR_MII_MDO;
773
774                 writel(miir, miiport);
775                 /* high MDC */
776                 miir |= MASK_MIIR_MII_MDC;
777                 writel(miir, miiport);
778                 m80x_delay(30);
779
780                 /* next */
781                 mask >>= 1;
782                 if (mask == 0x2 && opcode == OP_READ)
783                         miir &= ~MASK_MIIR_MII_WRITE;
784         }
785         return miir;
786 }
787
788
789 static unsigned int mdio_read(struct net_device *dev, int phyad, int regad)
790 {
791         long miiport = dev->base_addr + MANAGEMENT;
792         ulong miir;
793         unsigned int mask, data;
794
795         miir = m80x_send_cmd_to_phy(miiport, OP_READ, phyad, regad);
796
797         /* read data */
798         mask = 0x8000;
799         data = 0;
800         while (mask) {
801                 /* low MDC */
802                 miir &= ~MASK_MIIR_MII_MDC;
803                 writel(miir, miiport);
804
805                 /* read MDI */
806                 miir = readl(miiport);
807                 if (miir & MASK_MIIR_MII_MDI)
808                         data |= mask;
809
810                 /* high MDC, and wait */
811                 miir |= MASK_MIIR_MII_MDC;
812                 writel(miir, miiport);
813                 m80x_delay((int) 30);
814
815                 /* next */
816                 mask >>= 1;
817         }
818
819         /* low MDC */
820         miir &= ~MASK_MIIR_MII_MDC;
821         writel(miir, miiport);
822
823         return data;
824 }
825
826
827 static void mdio_write(struct net_device *dev, int phyad, int regad, int data)
828 {
829         long miiport = dev->base_addr + MANAGEMENT;
830         ulong miir;
831         unsigned int mask;
832
833         miir = m80x_send_cmd_to_phy(miiport, OP_WRITE, phyad, regad);
834
835         /* write data */
836         mask = 0x8000;
837         while (mask) {
838                 /* low MDC, prepare MDO */
839                 miir &= ~(MASK_MIIR_MII_MDC + MASK_MIIR_MII_MDO);
840                 if (mask & data)
841                         miir |= MASK_MIIR_MII_MDO;
842                 writel(miir, miiport);
843
844                 /* high MDC */
845                 miir |= MASK_MIIR_MII_MDC;
846                 writel(miir, miiport);
847
848                 /* next */
849                 mask >>= 1;
850         }
851
852         /* low MDC */
853         miir &= ~MASK_MIIR_MII_MDC;
854         writel(miir, miiport);
855
856         return;
857 }
858
859
860 static int netdev_open(struct net_device *dev)
861 {
862         struct netdev_private *np = dev->priv;
863         long ioaddr = dev->base_addr;
864
865         writel(0x00000001, ioaddr + BCR);       /* Reset */
866
867         if (request_irq(dev->irq, &intr_handler, SA_SHIRQ, dev->name, dev))
868                 return -EAGAIN;
869
870         init_ring(dev);
871
872         writel(np->rx_ring_dma, ioaddr + RXLBA);
873         writel(np->tx_ring_dma, ioaddr + TXLBA);
874
875         /* Initialize other registers. */
876         /* Configure the PCI bus bursts and FIFO thresholds.
877            486: Set 8 longword burst.
878            586: no burst limit.
879            Burst length 5:3
880            0 0 0   1
881            0 0 1   4
882            0 1 0   8
883            0 1 1   16
884            1 0 0   32
885            1 0 1   64
886            1 1 0   128
887            1 1 1   256
888            Wait the specified 50 PCI cycles after a reset by initializing
889            Tx and Rx queues and the address filter list. */
890 #if defined(__powerpc__) || defined(__sparc__)
891 // 89/9/1 modify, 
892 //   np->bcrvalue=0x04 | 0x0x38;  /* big-endian, 256 burst length */
893         np->bcrvalue = 0x04 | 0x10;     /* big-endian, tx 8 burst length */
894         np->crvalue = 0xe00;    /* rx 128 burst length */
895 #elif defined(__alpha__) || defined(__x86_64__)
896 // 89/9/1 modify, 
897 //   np->bcrvalue=0x38;           /* little-endian, 256 burst length */
898         np->bcrvalue = 0x10;    /* little-endian, 8 burst length */
899         np->crvalue = 0xe00;    /* rx 128 burst length */
900 #elif defined(__i386__)
901 #if defined(MODULE)
902 // 89/9/1 modify, 
903 //   np->bcrvalue=0x38;           /* little-endian, 256 burst length */
904         np->bcrvalue = 0x10;    /* little-endian, 8 burst length */
905         np->crvalue = 0xe00;    /* rx 128 burst length */
906 #else
907         /* When not a module we can work around broken '486 PCI boards. */
908 #define x86 boot_cpu_data.x86
909 // 89/9/1 modify, 
910 //   np->bcrvalue=(x86 <= 4 ? 0x10 : 0x38);
911         np->bcrvalue = 0x10;
912         np->crvalue = (x86 <= 4 ? 0xa00 : 0xe00);
913         if (x86 <= 4)
914                 printk(KERN_INFO "%s: This is a 386/486 PCI system, setting burst "
915                        "length to %x.\n", dev->name, (x86 <= 4 ? 0x10 : 0x38));
916 #endif
917 #else
918 // 89/9/1 modify,
919 //   np->bcrvalue=0x38;
920         np->bcrvalue = 0x10;
921         np->cralue = 0xe00;     /* rx 128 burst length */
922 #warning Processor architecture undefined!
923 #endif
924 // 89/12/29 add,
925 // 90/1/16 modify,
926 //   np->imrvalue=FBE|TUNF|CNTOVF|RBU|TI|RI;
927         np->imrvalue = TUNF | CNTOVF | RBU | TI | RI;
928         if (np->pci_dev->device == 0x891) {
929                 np->bcrvalue |= 0x200;  /* set PROG bit */
930                 np->crvalue |= 0x02000000;      /* set enhanced bit */
931                 np->imrvalue |= ETI;
932         }
933         writel(np->bcrvalue, ioaddr + BCR);
934
935         if (dev->if_port == 0)
936                 dev->if_port = np->default_port;
937
938         writel(0, dev->base_addr + RXPDR);
939 // 89/9/1 modify,
940 //   np->crvalue = 0x00e40001;    /* tx store and forward, tx/rx enable */
941         np->crvalue |= 0x00e40001;      /* tx store and forward, tx/rx enable */
942         np->full_duplex = np->duplex_lock;
943         getlinkstatus(dev);
944         if (np->linkok)
945                 getlinktype(dev);
946         set_rx_mode(dev);
947
948         netif_start_queue(dev);
949
950         /* Clear and Enable interrupts by setting the interrupt mask. */
951         writel(FBE | TUNF | CNTOVF | RBU | TI | RI, ioaddr + ISR);
952         writel(np->imrvalue, ioaddr + IMR);
953
954         if (debug)
955                 printk(KERN_DEBUG "%s: Done netdev_open().\n", dev->name);
956
957         /* Set the timer to check for link beat. */
958         init_timer(&np->timer);
959         np->timer.expires = RUN_AT(3 * HZ);
960         np->timer.data = (unsigned long) dev;
961         np->timer.function = &netdev_timer;
962
963         /* timer handler */
964         add_timer(&np->timer);
965
966         return 0;
967 }
968
969
970 static void getlinkstatus(struct net_device *dev)
971 /* function: Routine will read MII Status Register to get link status.       */
972 /* input   : dev... pointer to the adapter block.                            */
973 /* output  : none.                                                           */
974 {
975         struct netdev_private *np = dev->priv;
976         unsigned int i, DelayTime = 0x1000;
977
978         np->linkok = 0;
979
980         if (np->PHYType == MysonPHY) {
981                 for (i = 0; i < DelayTime; ++i) {
982                         if (readl(dev->base_addr + BMCRSR) & LinkIsUp2) {
983                                 np->linkok = 1;
984                                 return;
985                         }
986                         // delay
987                         m80x_delay(100);
988                 }
989         } else {
990                 for (i = 0; i < DelayTime; ++i) {
991                         if (mdio_read(dev, np->phys[0], 1) & 0x4) {
992                                 np->linkok = 1;
993                                 return;
994                         }
995                         // delay
996                         m80x_delay(100);
997                 }
998         }
999 }
1000
1001
1002 static void getlinktype(struct net_device *dev)
1003 {
1004         struct netdev_private *np = dev->priv;
1005
1006         if (np->PHYType == MysonPHY) {  /* 3-in-1 case */
1007                 if (readl(dev->base_addr + TCRRCR) & FD)
1008                         np->duplexmode = 2;     /* full duplex */
1009                 else
1010                         np->duplexmode = 1;     /* half duplex */
1011                 if (readl(dev->base_addr + TCRRCR) & PS10)
1012                         np->line_speed = 1;     /* 10M */
1013                 else
1014                         np->line_speed = 2;     /* 100M */
1015         } else {
1016                 if (np->PHYType == SeeqPHY) {   /* this PHY is SEEQ 80225 */
1017                         unsigned int data;
1018
1019                         data = mdio_read(dev, np->phys[0], MIIRegister18);
1020                         if (data & SPD_DET_100)
1021                                 np->line_speed = 2;     /* 100M */
1022                         else
1023                                 np->line_speed = 1;     /* 10M */
1024                         if (data & DPLX_DET_FULL)
1025                                 np->duplexmode = 2;     /* full duplex mode */
1026                         else
1027                                 np->duplexmode = 1;     /* half duplex mode */
1028                 } else if (np->PHYType == AhdocPHY) {
1029                         unsigned int data;
1030
1031                         data = mdio_read(dev, np->phys[0], DiagnosticReg);
1032                         if (data & Speed_100)
1033                                 np->line_speed = 2;     /* 100M */
1034                         else
1035                                 np->line_speed = 1;     /* 10M */
1036                         if (data & DPLX_FULL)
1037                                 np->duplexmode = 2;     /* full duplex mode */
1038                         else
1039                                 np->duplexmode = 1;     /* half duplex mode */
1040                 }
1041 /* 89/6/13 add, (begin) */
1042                 else if (np->PHYType == MarvellPHY) {
1043                         unsigned int data;
1044
1045                         data = mdio_read(dev, np->phys[0], SpecificReg);
1046                         if (data & Full_Duplex)
1047                                 np->duplexmode = 2;     /* full duplex mode */
1048                         else
1049                                 np->duplexmode = 1;     /* half duplex mode */
1050                         data &= SpeedMask;
1051                         if (data == Speed_1000M)
1052                                 np->line_speed = 3;     /* 1000M */
1053                         else if (data == Speed_100M)
1054                                 np->line_speed = 2;     /* 100M */
1055                         else
1056                                 np->line_speed = 1;     /* 10M */
1057                 }
1058 /* 89/6/13 add, (end) */
1059 /* 89/7/27 add, (begin) */
1060                 else if (np->PHYType == Myson981) {
1061                         unsigned int data;
1062
1063                         data = mdio_read(dev, np->phys[0], StatusRegister);
1064
1065                         if (data & SPEED100)
1066                                 np->line_speed = 2;
1067                         else
1068                                 np->line_speed = 1;
1069
1070                         if (data & FULLMODE)
1071                                 np->duplexmode = 2;
1072                         else
1073                                 np->duplexmode = 1;
1074                 }
1075 /* 89/7/27 add, (end) */
1076 /* 89/12/29 add */
1077                 else if (np->PHYType == LevelOnePHY) {
1078                         unsigned int data;
1079
1080                         data = mdio_read(dev, np->phys[0], SpecificReg);
1081                         if (data & LXT1000_Full)
1082                                 np->duplexmode = 2;     /* full duplex mode */
1083                         else
1084                                 np->duplexmode = 1;     /* half duplex mode */
1085                         data &= SpeedMask;
1086                         if (data == LXT1000_1000M)
1087                                 np->line_speed = 3;     /* 1000M */
1088                         else if (data == LXT1000_100M)
1089                                 np->line_speed = 2;     /* 100M */
1090                         else
1091                                 np->line_speed = 1;     /* 10M */
1092                 }
1093                 // chage crvalue
1094                 // np->crvalue&=(~PS10)&(~FD);
1095                 np->crvalue &= (~PS10) & (~FD) & (~PS1000);
1096                 if (np->line_speed == 1)
1097                         np->crvalue |= PS10;
1098                 else if (np->line_speed == 3)
1099                         np->crvalue |= PS1000;
1100                 if (np->duplexmode == 2)
1101                         np->crvalue |= FD;
1102         }
1103 }
1104
1105
1106 static void allocate_rx_buffers(struct net_device *dev)
1107 {
1108         struct netdev_private *np = dev->priv;
1109
1110         /*  allocate skb for rx buffers */
1111         while (np->really_rx_count != RX_RING_SIZE) {
1112                 struct sk_buff *skb;
1113
1114                 skb = dev_alloc_skb(np->rx_buf_sz);
1115                 np->lack_rxbuf->skbuff = skb;
1116
1117                 if (skb == NULL)
1118                         break;  /* Better luck next round. */
1119
1120                 skb->dev = dev; /* Mark as being used by this device. */
1121                 np->lack_rxbuf->buffer = pci_map_single(np->pci_dev, skb->tail,
1122                         np->rx_buf_sz, PCI_DMA_FROMDEVICE);
1123                 np->lack_rxbuf = np->lack_rxbuf->next_desc_logical;
1124                 ++np->really_rx_count;
1125         }
1126 }
1127
1128
1129 static void netdev_timer(unsigned long data)
1130 {
1131         struct net_device *dev = (struct net_device *) data;
1132         struct netdev_private *np = dev->priv;
1133         long ioaddr = dev->base_addr;
1134         int next_tick = 10 * HZ;
1135         int old_crvalue = np->crvalue;
1136         unsigned int old_linkok = np->linkok;
1137
1138         if (debug)
1139                 printk(KERN_DEBUG "%s: Media selection timer tick, status %8.8x "
1140                        "config %8.8x.\n", dev->name, readl(ioaddr + ISR),
1141                        readl(ioaddr + TCRRCR));
1142
1143         if (np->flags == HAS_MII_XCVR) {
1144                 getlinkstatus(dev);
1145                 if ((old_linkok == 0) && (np->linkok == 1)) {   /* we need to detect the media type again */
1146                         getlinktype(dev);
1147                         if (np->crvalue != old_crvalue) {
1148                                 stop_nic_tx(ioaddr, np->crvalue);
1149                                 stop_nic_rx(ioaddr, np->crvalue & (~0x40000));
1150                                 writel(np->crvalue, ioaddr + TCRRCR);
1151                         }
1152                 }
1153         }
1154
1155         allocate_rx_buffers(dev);
1156
1157         np->timer.expires = RUN_AT(next_tick);
1158         add_timer(&np->timer);
1159 }
1160
1161
1162 static void tx_timeout(struct net_device *dev)
1163 {
1164         struct netdev_private *np = dev->priv;
1165         long ioaddr = dev->base_addr;
1166
1167         printk(KERN_WARNING "%s: Transmit timed out, status %8.8x,"
1168                " resetting...\n", dev->name, readl(ioaddr + ISR));
1169
1170         {
1171                 int i;
1172
1173                 printk(KERN_DEBUG "  Rx ring %p: ", np->rx_ring);
1174                 for (i = 0; i < RX_RING_SIZE; i++)
1175                         printk(" %8.8x", (unsigned int) np->rx_ring[i].status);
1176                 printk("\n" KERN_DEBUG "  Tx ring %p: ", np->tx_ring);
1177                 for (i = 0; i < TX_RING_SIZE; i++)
1178                         printk(" %4.4x", np->tx_ring[i].status);
1179                 printk("\n");
1180         }
1181
1182         /* Perhaps we should reinitialize the hardware here.  Just trigger a
1183            Tx demand for now. */
1184         writel(0, dev->base_addr + TXPDR);
1185         dev->if_port = 0;
1186
1187         /* Stop and restart the chip's Tx processes . */
1188         dev->trans_start = jiffies;
1189         np->stats.tx_errors++;
1190
1191         return;
1192 }
1193
1194
1195 /* Initialize the Rx and Tx rings, along with various 'dev' bits. */
1196 static void init_ring(struct net_device *dev)
1197 {
1198         struct netdev_private *np = dev->priv;
1199         int i;
1200
1201         /* initialize rx variables */
1202         np->rx_buf_sz = (dev->mtu <= 1500 ? PKT_BUF_SZ : dev->mtu + 32);
1203         np->cur_rx = &np->rx_ring[0];
1204         np->lack_rxbuf = NULL;
1205         np->really_rx_count = 0;
1206
1207         /* initial rx descriptors. */
1208         for (i = 0; i < RX_RING_SIZE; i++) {
1209                 np->rx_ring[i].status = 0;
1210                 np->rx_ring[i].control = np->rx_buf_sz << RBSShift;
1211                 np->rx_ring[i].next_desc = np->rx_ring_dma +
1212                         (i + 1)*sizeof(struct fealnx_desc);
1213                 np->rx_ring[i].next_desc_logical = &np->rx_ring[i + 1];
1214                 np->rx_ring[i].skbuff = NULL;
1215         }
1216
1217         /* for the last rx descriptor */
1218         np->rx_ring[i - 1].next_desc = np->rx_ring_dma;
1219         np->rx_ring[i - 1].next_desc_logical = np->rx_ring;
1220
1221         /* allocate skb for rx buffers */
1222         for (i = 0; i < RX_RING_SIZE; i++) {
1223                 struct sk_buff *skb = dev_alloc_skb(np->rx_buf_sz);
1224
1225                 if (skb == NULL) {
1226                         np->lack_rxbuf = &np->rx_ring[i];
1227                         break;
1228                 }
1229
1230                 ++np->really_rx_count;
1231                 np->rx_ring[i].skbuff = skb;
1232                 skb->dev = dev; /* Mark as being used by this device. */
1233                 np->rx_ring[i].buffer = pci_map_single(np->pci_dev, skb->tail,
1234                         np->rx_buf_sz, PCI_DMA_FROMDEVICE);
1235                 np->rx_ring[i].status = RXOWN;
1236                 np->rx_ring[i].control |= RXIC;
1237         }
1238
1239         /* initialize tx variables */
1240         np->cur_tx = &np->tx_ring[0];
1241         np->cur_tx_copy = &np->tx_ring[0];
1242         np->really_tx_count = 0;
1243         np->free_tx_count = TX_RING_SIZE;
1244
1245         for (i = 0; i < TX_RING_SIZE; i++) {
1246                 np->tx_ring[i].status = 0;
1247                 np->tx_ring[i].next_desc = np->tx_ring_dma +
1248                         (i + 1)*sizeof(struct fealnx_desc);
1249                 np->tx_ring[i].next_desc_logical = &np->tx_ring[i + 1];
1250                 np->tx_ring[i].skbuff = NULL;
1251         }
1252
1253         /* for the last tx descriptor */
1254         np->tx_ring[i - 1].next_desc = np->tx_ring_dma;
1255         np->tx_ring[i - 1].next_desc_logical = &np->tx_ring[0];
1256
1257         return;
1258 }
1259
1260
1261 static int start_tx(struct sk_buff *skb, struct net_device *dev)
1262 {
1263         struct netdev_private *np = dev->priv;
1264
1265         np->cur_tx_copy->skbuff = skb;
1266
1267 #define one_buffer
1268 #define BPT 1022
1269 #if defined(one_buffer)
1270         np->cur_tx_copy->buffer = pci_map_single(np->pci_dev, skb->data,
1271                 skb->len, PCI_DMA_TODEVICE);
1272         np->cur_tx_copy->control = TXIC | TXLD | TXFD | CRCEnable | PADEnable;
1273         np->cur_tx_copy->control |= (skb->len << PKTSShift);    /* pkt size */
1274         np->cur_tx_copy->control |= (skb->len << TBSShift);     /* buffer size */
1275 // 89/12/29 add,
1276         if (np->pci_dev->device == 0x891)
1277                 np->cur_tx_copy->control |= ETIControl | RetryTxLC;
1278         np->cur_tx_copy->status = TXOWN;
1279         np->cur_tx_copy = np->cur_tx_copy->next_desc_logical;
1280         --np->free_tx_count;
1281 #elif defined(two_buffer)
1282         if (skb->len > BPT) {
1283                 struct fealnx_desc *next;
1284
1285                 /* for the first descriptor */
1286                 np->cur_tx_copy->buffer = pci_map_single(np->pci_dev, skb->data,
1287                         BPT, PCI_DMA_TODEVICE);
1288                 np->cur_tx_copy->control = TXIC | TXFD | CRCEnable | PADEnable;
1289                 np->cur_tx_copy->control |= (skb->len << PKTSShift);    /* pkt size */
1290                 np->cur_tx_copy->control |= (BPT << TBSShift);  /* buffer size */
1291
1292                 /* for the last descriptor */
1293                 next = (struct fealnx *) np->cur_tx_copy.next_desc_logical;
1294                 next->skbuff = skb;
1295                 next->control = TXIC | TXLD | CRCEnable | PADEnable;
1296                 next->control |= (skb->len << PKTSShift);       /* pkt size */
1297                 next->control |= ((skb->len - BPT) << TBSShift);        /* buf size */
1298 // 89/12/29 add,
1299                 if (np->pci_dev->device == 0x891)
1300                         np->cur_tx_copy->control |= ETIControl | RetryTxLC;
1301                 next->buffer = pci_map_single(ep->pci_dev, skb->data + BPT,
1302                                 skb->len - BPT, PCI_DMA_TODEVICE);
1303
1304                 next->status = TXOWN;
1305                 np->cur_tx_copy->status = TXOWN;
1306
1307                 np->cur_tx_copy = next->next_desc_logical;
1308                 np->free_tx_count -= 2;
1309         } else {
1310                 np->cur_tx_copy->buffer = pci_map_single(np->pci_dev, skb->data,
1311                         skb->len, PCI_DMA_TODEVICE);
1312                 np->cur_tx_copy->control = TXIC | TXLD | TXFD | CRCEnable | PADEnable;
1313                 np->cur_tx_copy->control |= (skb->len << PKTSShift);    /* pkt size */
1314                 np->cur_tx_copy->control |= (skb->len << TBSShift);     /* buffer size */
1315 // 89/12/29 add,
1316                 if (np->pci_dev->device == 0x891)
1317                         np->cur_tx_copy->control |= ETIControl | RetryTxLC;
1318                 np->cur_tx_copy->status = TXOWN;
1319                 np->cur_tx_copy = np->cur_tx_copy->next_desc_logical;
1320                 --np->free_tx_count;
1321         }
1322 #endif
1323
1324         if (np->free_tx_count < 2)
1325                 netif_stop_queue(dev);
1326         ++np->really_tx_count;
1327         writel(0, dev->base_addr + TXPDR);
1328         dev->trans_start = jiffies;
1329
1330         return 0;
1331 }
1332
1333
1334 void free_one_rx_descriptor(struct netdev_private *np)
1335 {
1336         if (np->really_rx_count == RX_RING_SIZE)
1337                 np->cur_rx->status = RXOWN;
1338         else {
1339                 np->lack_rxbuf->skbuff = np->cur_rx->skbuff;
1340                 np->lack_rxbuf->buffer = np->cur_rx->buffer;
1341                 np->lack_rxbuf->status = RXOWN;
1342                 ++np->really_rx_count;
1343                 np->lack_rxbuf = np->lack_rxbuf->next_desc_logical;
1344         }
1345         np->cur_rx = np->cur_rx->next_desc_logical;
1346 }
1347
1348
1349 void reset_rx_descriptors(struct net_device *dev)
1350 {
1351         struct netdev_private *np = dev->priv;
1352
1353         stop_nic_rx(dev->base_addr, np->crvalue);
1354
1355         while (!(np->cur_rx->status & RXOWN))
1356                 free_one_rx_descriptor(np);
1357
1358         allocate_rx_buffers(dev);
1359
1360         writel(np->rx_ring_dma + (np->cur_rx - np->rx_ring),
1361                 dev->base_addr + RXLBA);
1362         writel(np->crvalue, dev->base_addr + TCRRCR);
1363 }
1364
1365
1366 /* The interrupt handler does all of the Rx thread work and cleans up
1367    after the Tx thread. */
1368 static void intr_handler(int irq, void *dev_instance, struct pt_regs *rgs)
1369 {
1370         struct net_device *dev = (struct net_device *) dev_instance;
1371         struct netdev_private *np = dev->priv;
1372         long ioaddr, boguscnt = max_interrupt_work;
1373         unsigned int num_tx = 0;
1374
1375         writel(0, dev->base_addr + IMR);
1376
1377         ioaddr = dev->base_addr;
1378         np = (struct netdev_private *) dev->priv;
1379
1380         do {
1381                 u32 intr_status = readl(ioaddr + ISR);
1382
1383                 /* Acknowledge all of the current interrupt sources ASAP. */
1384                 writel(intr_status, ioaddr + ISR);
1385
1386                 if (debug)
1387                         printk(KERN_DEBUG "%s: Interrupt, status %4.4x.\n", dev->name,
1388                                intr_status);
1389
1390                 if (!(intr_status & np->imrvalue))
1391                         break;
1392
1393 // 90/1/16 delete,
1394 //
1395 //      if (intr_status & FBE)
1396 //      {   /* fatal error */
1397 //          stop_nic_tx(ioaddr, 0);
1398 //          stop_nic_rx(ioaddr, 0);
1399 //          break;
1400 //      };
1401
1402                 if (intr_status & TUNF)
1403                         writel(0, ioaddr + TXPDR);
1404
1405                 if (intr_status & CNTOVF) {
1406                         /* missed pkts */
1407                         np->stats.rx_missed_errors += readl(ioaddr + TALLY) & 0x7fff;
1408
1409                         /* crc error */
1410                         np->stats.rx_crc_errors +=
1411                             (readl(ioaddr + TALLY) & 0x7fff0000) >> 16;
1412                 }
1413
1414                 if (intr_status & (RI | RBU)) {
1415                         if (intr_status & RI)
1416                                 netdev_rx(dev);
1417                         else
1418                                 reset_rx_descriptors(dev);
1419                 }
1420
1421                 while (np->really_tx_count) {
1422                         long tx_status = np->cur_tx->status;
1423                         long tx_control = np->cur_tx->control;
1424
1425                         if (!(tx_control & TXLD)) {     /* this pkt is combined by two tx descriptors */
1426                                 struct fealnx_desc *next;
1427
1428                                 next = np->cur_tx->next_desc_logical;
1429                                 tx_status = next->status;
1430                                 tx_control = next->control;
1431                         }
1432
1433                         if (tx_status & TXOWN)
1434                                 break;
1435
1436                         if (!(np->crvalue & 0x02000000)) {
1437                                 if (tx_status & (CSL | LC | EC | UDF | HF)) {
1438                                         np->stats.tx_errors++;
1439                                         if (tx_status & EC)
1440                                                 np->stats.tx_aborted_errors++;
1441                                         if (tx_status & CSL)
1442                                                 np->stats.tx_carrier_errors++;
1443                                         if (tx_status & LC)
1444                                                 np->stats.tx_window_errors++;
1445                                         if (tx_status & UDF)
1446                                                 np->stats.tx_fifo_errors++;
1447                                         if ((tx_status & HF) && np->full_duplex == 0)
1448                                                 np->stats.tx_heartbeat_errors++;
1449
1450 #ifdef ETHER_STATS
1451                                         if (tx_status & EC)
1452                                                 np->stats.collisions16++;
1453 #endif
1454                                 } else {
1455 #ifdef ETHER_STATS
1456                                         if (tx_status & DFR)
1457                                                 np->stats.tx_deferred++;
1458 #endif
1459
1460                                         np->stats.tx_bytes +=
1461                                             ((tx_control & PKTSMask) >> PKTSShift);
1462
1463                                         np->stats.collisions +=
1464                                             ((tx_status & NCRMask) >> NCRShift);
1465                                         np->stats.tx_packets++;
1466                                 }
1467                         } else {
1468                                 np->stats.tx_bytes +=
1469                                     ((tx_control & PKTSMask) >> PKTSShift);
1470                                 np->stats.tx_packets++;
1471                         }
1472
1473                         /* Free the original skb. */
1474                         pci_unmap_single(np->pci_dev, np->cur_tx->buffer,
1475                                 np->cur_tx->skbuff->len, PCI_DMA_TODEVICE);
1476                         dev_kfree_skb_irq(np->cur_tx->skbuff);
1477                         np->cur_tx->skbuff = NULL;
1478                         --np->really_tx_count;
1479                         if (np->cur_tx->control & TXLD) {
1480                                 np->cur_tx = np->cur_tx->next_desc_logical;
1481                                 ++np->free_tx_count;
1482                         } else {
1483                                 np->cur_tx = np->cur_tx->next_desc_logical;
1484                                 np->cur_tx = np->cur_tx->next_desc_logical;
1485                                 np->free_tx_count += 2;
1486                         }
1487                         num_tx++;
1488                 }               /* end of for loop */
1489                 
1490                 if (num_tx && np->free_tx_count >= 2)
1491                         netif_wake_queue(dev);
1492
1493                 /* read transmit status for enhanced mode only */
1494                 if (np->crvalue & 0x02000000) {
1495                         long data;
1496
1497                         data = readl(ioaddr + TSR);
1498                         np->stats.tx_errors += (data & 0xff000000) >> 24;
1499                         np->stats.tx_aborted_errors += (data & 0xff000000) >> 24;
1500                         np->stats.tx_window_errors += (data & 0x00ff0000) >> 16;
1501 #ifdef ETHER_STATS
1502                         np->stats.collisions16 += (data & 0xff000000) >> 24;
1503 #endif
1504                         np->stats.collisions += (data & 0x0000ffff);
1505                 }
1506
1507                 if (--boguscnt < 0) {
1508                         printk(KERN_WARNING "%s: Too much work at interrupt, "
1509                                "status=0x%4.4x.\n", dev->name, intr_status);
1510                         break;
1511                 }
1512         } while (1);
1513
1514         /* read the tally counters */
1515         /* missed pkts */
1516         np->stats.rx_missed_errors += readl(ioaddr + TALLY) & 0x7fff;
1517
1518         /* crc error */
1519         np->stats.rx_crc_errors += (readl(ioaddr + TALLY) & 0x7fff0000) >> 16;
1520
1521         if (debug)
1522                 printk(KERN_DEBUG "%s: exiting interrupt, status=%#4.4x.\n",
1523                        dev->name, readl(ioaddr + ISR));
1524
1525         writel(np->imrvalue, ioaddr + IMR);
1526
1527         return;
1528 }
1529
1530
1531 /* This routine is logically part of the interrupt handler, but seperated
1532    for clarity and better register allocation. */
1533 static int netdev_rx(struct net_device *dev)
1534 {
1535         struct netdev_private *np = dev->priv;
1536
1537         /* If EOP is set on the next entry, it's a new packet. Send it up. */
1538         while (!(np->cur_rx->status & RXOWN)) {
1539                 s32 rx_status = np->cur_rx->status;
1540
1541                 if (np->really_rx_count == 0)
1542                         break;
1543
1544                 if (debug)
1545                         printk(KERN_DEBUG "  netdev_rx() status was %8.8x.\n", rx_status);
1546
1547                 if ((!((rx_status & RXFSD) && (rx_status & RXLSD)))
1548                     || (rx_status & ErrorSummary)) {
1549                         if (rx_status & ErrorSummary) { /* there was a fatal error */
1550                                 if (debug)
1551                                         printk(KERN_DEBUG
1552                                                "%s: Receive error, Rx status %8.8x.\n",
1553                                                dev->name, rx_status);
1554
1555                                 np->stats.rx_errors++;  /* end of a packet. */
1556                                 if (rx_status & (LONG | RUNT))
1557                                         np->stats.rx_length_errors++;
1558                                 if (rx_status & RXER)
1559                                         np->stats.rx_frame_errors++;
1560                                 if (rx_status & CRC)
1561                                         np->stats.rx_crc_errors++;
1562                         } else {
1563                                 int need_to_reset = 0;
1564                                 int desno = 0;
1565
1566                                 if (rx_status & RXFSD) {        /* this pkt is too long, over one rx buffer */
1567                                         struct fealnx_desc *cur;
1568
1569                                         /* check this packet is received completely? */
1570                                         cur = np->cur_rx;
1571                                         while (desno <= np->really_rx_count) {
1572                                                 ++desno;
1573                                                 if ((!(cur->status & RXOWN))
1574                                                     && (cur->status & RXLSD))
1575                                                         break;
1576                                                 /* goto next rx descriptor */
1577                                                 cur = cur->next_desc_logical;
1578                                         }
1579                                         if (desno > np->really_rx_count)
1580                                                 need_to_reset = 1;
1581                                 } else  /* RXLSD did not find, something error */
1582                                         need_to_reset = 1;
1583
1584                                 if (need_to_reset == 0) {
1585                                         int i;
1586
1587                                         np->stats.rx_length_errors++;
1588
1589                                         /* free all rx descriptors related this long pkt */
1590                                         for (i = 0; i < desno; ++i)
1591                                                 free_one_rx_descriptor(np);
1592                                         continue;
1593                                 } else {        /* something error, need to reset this chip */
1594                                         reset_rx_descriptors(dev);
1595                                 }
1596                                 break;  /* exit the while loop */
1597                         }
1598                 } else {        /* this received pkt is ok */
1599
1600                         struct sk_buff *skb;
1601                         /* Omit the four octet CRC from the length. */
1602                         short pkt_len = ((rx_status & FLNGMASK) >> FLNGShift) - 4;
1603
1604 #ifndef final_version
1605                         if (debug)
1606                                 printk(KERN_DEBUG "  netdev_rx() normal Rx pkt length %d"
1607                                        " status %x.\n", pkt_len, rx_status);
1608 #endif
1609                         pci_dma_sync_single(np->pci_dev, np->cur_rx->buffer,
1610                                 np->rx_buf_sz, PCI_DMA_FROMDEVICE);
1611                         pci_unmap_single(np->pci_dev, np->cur_rx->buffer,
1612                                 np->rx_buf_sz, PCI_DMA_FROMDEVICE);
1613
1614                         /* Check if the packet is long enough to accept without copying
1615                            to a minimally-sized skbuff. */
1616                         if (pkt_len < rx_copybreak &&
1617                             (skb = dev_alloc_skb(pkt_len + 2)) != NULL) {
1618                                 skb->dev = dev;
1619                                 skb_reserve(skb, 2);    /* 16 byte align the IP header */
1620                                 /* Call copy + cksum if available. */
1621
1622 #if ! defined(__alpha__)
1623                                 eth_copy_and_sum(skb, 
1624                                         np->cur_rx->skbuff->tail, pkt_len, 0);
1625                                 skb_put(skb, pkt_len);
1626 #else
1627                                 memcpy(skb_put(skb, pkt_len),
1628                                         np->cur_rx->skbuff->tail, pkt_len);
1629 #endif
1630                         } else {
1631                                 skb_put(skb = np->cur_rx->skbuff, pkt_len);
1632                                 np->cur_rx->skbuff = NULL;
1633                                 if (np->really_rx_count == RX_RING_SIZE)
1634                                         np->lack_rxbuf = np->cur_rx;
1635                                 --np->really_rx_count;
1636                         }
1637                         skb->protocol = eth_type_trans(skb, dev);
1638                         netif_rx(skb);
1639                         dev->last_rx = jiffies;
1640                         np->stats.rx_packets++;
1641                         np->stats.rx_bytes += pkt_len;
1642                 }
1643
1644                 if (np->cur_rx->skbuff == NULL) {
1645                         struct sk_buff *skb;
1646
1647                         skb = dev_alloc_skb(np->rx_buf_sz);
1648
1649                         if (skb != NULL) {
1650                                 skb->dev = dev; /* Mark as being used by this device. */
1651                                 np->cur_rx->buffer = pci_map_single(np->pci_dev, skb->tail,
1652                                         np->rx_buf_sz, PCI_DMA_FROMDEVICE);
1653                                 np->cur_rx->skbuff = skb;
1654                                 ++np->really_rx_count;
1655                         }
1656                 }
1657
1658                 if (np->cur_rx->skbuff != NULL)
1659                         free_one_rx_descriptor(np);
1660         }                       /* end of while loop */
1661
1662         /*  allocate skb for rx buffers */
1663         allocate_rx_buffers(dev);
1664
1665         return 0;
1666 }
1667
1668
1669 static struct net_device_stats *get_stats(struct net_device *dev)
1670 {
1671         long ioaddr = dev->base_addr;
1672         struct netdev_private *np = dev->priv;
1673
1674         /* The chip only need report frame silently dropped. */
1675         if (netif_running(dev)) {
1676                 np->stats.rx_missed_errors += readl(ioaddr + TALLY) & 0x7fff;
1677                 np->stats.rx_crc_errors += (readl(ioaddr + TALLY) & 0x7fff0000) >> 16;
1678         }
1679
1680         return &np->stats;
1681 }
1682
1683
1684 static unsigned const ethernet_polynomial = 0x04c11db7U;
1685 static inline u32 ether_crc(int length, unsigned char *data)
1686 {
1687         int crc = -1;
1688
1689         while (--length >= 0) {
1690                 unsigned char current_octet = *data++;
1691                 int bit;
1692
1693                 for (bit = 0; bit < 8; bit++, current_octet >>= 1) {
1694                         crc = (crc << 1) ^
1695                             ((crc < 0) ^ (current_octet & 1) ? ethernet_polynomial : 0);
1696                 }
1697         }
1698
1699         return crc;
1700 }
1701
1702
1703 static void set_rx_mode(struct net_device *dev)
1704 {
1705         struct netdev_private *np = dev->priv;
1706         long ioaddr = dev->base_addr;
1707         u32 mc_filter[2];       /* Multicast hash filter */
1708         u32 rx_mode;
1709
1710         if (dev->flags & IFF_PROMISC) { /* Set promiscuous. */
1711                 /* Unconditionally log net taps. */
1712                 printk(KERN_NOTICE "%s: Promiscuous mode enabled.\n", dev->name);
1713                 memset(mc_filter, 0xff, sizeof(mc_filter));
1714                 rx_mode = PROM | AB | AM;
1715         } else if ((dev->mc_count > multicast_filter_limit)
1716                    || (dev->flags & IFF_ALLMULTI)) {
1717                 /* Too many to match, or accept all multicasts. */
1718                 memset(mc_filter, 0xff, sizeof(mc_filter));
1719                 rx_mode = AB | AM;
1720         } else {
1721                 struct dev_mc_list *mclist;
1722                 int i;
1723
1724                 memset(mc_filter, 0, sizeof(mc_filter));
1725                 for (i = 0, mclist = dev->mc_list; mclist && i < dev->mc_count;
1726                      i++, mclist = mclist->next) {
1727                         set_bit((ether_crc(ETH_ALEN, mclist->dmi_addr) >> 26) ^ 0x3F,
1728                                 mc_filter);
1729                 }
1730                 rx_mode = AB | AM;
1731         }
1732
1733         stop_nic_tx(ioaddr, np->crvalue);
1734         stop_nic_rx(ioaddr, np->crvalue & (~0x40000));
1735
1736         writel(mc_filter[0], ioaddr + MAR0);
1737         writel(mc_filter[1], ioaddr + MAR1);
1738         np->crvalue &= ~RxModeMask;
1739         np->crvalue |= rx_mode;
1740         writel(np->crvalue, ioaddr + TCRRCR);
1741 }
1742
1743
1744 static int mii_ioctl(struct net_device *dev, struct ifreq *rq, int cmd)
1745 {
1746         struct mii_ioctl_data *data = (struct mii_ioctl_data *) & rq->ifr_data;
1747
1748         switch (cmd) {
1749         case SIOCGMIIPHY:               /* Get address of MII PHY in use. */
1750         case SIOCDEVPRIVATE:            /* for binary compat, remove in 2.5 */
1751                 data->phy_id = ((struct netdev_private *) dev->priv)->phys[0] & 0x1f;
1752                 /* Fall Through */
1753
1754         case SIOCGMIIREG:               /* Read MII PHY register. */
1755         case SIOCDEVPRIVATE+1:          /* for binary compat, remove in 2.5 */
1756                 data->val_out = mdio_read(dev, data->phy_id & 0x1f, data->reg_num & 0x1f);
1757                 return 0;
1758
1759         case SIOCSMIIREG:               /* Write MII PHY register. */
1760         case SIOCDEVPRIVATE+2:          /* for binary compat, remove in 2.5 */
1761                 if (!suser())
1762                         return -EPERM;
1763                 mdio_write(dev, data->phy_id & 0x1f, data->reg_num & 0x1f, data->val_in);
1764                 return 0;
1765         default:
1766                 return -EOPNOTSUPP;
1767         }
1768 }
1769
1770
1771 static int netdev_close(struct net_device *dev)
1772 {
1773         long ioaddr = dev->base_addr;
1774         struct netdev_private *np = dev->priv;
1775         int i;
1776
1777         netif_stop_queue(dev);
1778
1779         /* Disable interrupts by clearing the interrupt mask. */
1780         writel(0x0000, ioaddr + IMR);
1781
1782         /* Stop the chip's Tx and Rx processes. */
1783         stop_nic_tx(ioaddr, 0);
1784         stop_nic_rx(ioaddr, 0);
1785
1786         del_timer_sync(&np->timer);
1787
1788         free_irq(dev->irq, dev);
1789
1790         /* Free all the skbuffs in the Rx queue. */
1791         for (i = 0; i < RX_RING_SIZE; i++) {
1792                 struct sk_buff *skb = np->rx_ring[i].skbuff;
1793
1794                 np->rx_ring[i].status = 0;
1795                 if (skb) {
1796                         pci_unmap_single(np->pci_dev, np->rx_ring[i].buffer,
1797                                 np->rx_buf_sz, PCI_DMA_FROMDEVICE);
1798                         dev_kfree_skb(skb);
1799                         np->rx_ring[i].skbuff = NULL;
1800                 }
1801         }
1802
1803         for (i = 0; i < TX_RING_SIZE; i++) {
1804                 struct sk_buff *skb = np->tx_ring[i].skbuff;
1805
1806                 if (skb) {
1807                         pci_unmap_single(np->pci_dev, np->tx_ring[i].buffer,
1808                                 skb->len, PCI_DMA_TODEVICE);
1809                         dev_kfree_skb(skb);
1810                         np->tx_ring[i].skbuff = NULL;
1811                 }
1812         }
1813
1814         return 0;
1815 }
1816
1817 static struct pci_device_id fealnx_pci_tbl[] = __devinitdata {
1818         {0x1516, 0x0800, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
1819         {0x1516, 0x0803, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 1},
1820         {0x1516, 0x0891, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 2},
1821         {} /* terminate list */
1822 };
1823 MODULE_DEVICE_TABLE(pci, fealnx_pci_tbl);
1824
1825
1826 static struct pci_driver fealnx_driver = {
1827         name:           "fealnx",
1828         id_table:       fealnx_pci_tbl,
1829         probe:          fealnx_init_one,
1830         remove:         fealnx_remove_one,
1831 };
1832
1833 static int __init fealnx_init(void)
1834 {
1835 /* when a module, this is printed whether or not devices are found in probe */
1836 #ifdef MODULE
1837         printk (version);
1838 #endif
1839
1840         return pci_module_init(&fealnx_driver);
1841 }
1842
1843 static void __exit fealnx_exit(void)
1844 {
1845         pci_unregister_driver(&fealnx_driver);
1846 }
1847
1848 module_init(fealnx_init);
1849 module_exit(fealnx_exit);