drivers/net/eth16i.c

   1 /* eth16i.c An ICL EtherTeam 16i and 32 EISA ethernet driver for Linux
   2
   3    Written 1994-1999 by Mika Kuoppala
   4
   5    Copyright (C) 1994-1999 by Mika Kuoppala
   6    Based on skeleton.c and heavily on at1700.c by Donald Becker
   7
   8    This software may be used and distributed according to the terms
   9    of the GNU General Public License, incorporated herein by reference.
  10
  11    The author may be reached as miku@iki.fi
  12
  13    This driver supports following cards :
  14         - ICL EtherTeam 16i
  15         - ICL EtherTeam 32 EISA
  16           (Uses true 32 bit transfers rather than 16i compability mode)
  17
  18    Example Module usage:
  19         insmod eth16i.o io=0x2a0 mediatype=bnc
  20
  21         mediatype can be one of the following: bnc,tp,dix,auto,eprom
  22
  23         'auto' will try to autoprobe mediatype.
  24         'eprom' will use whatever type defined in eprom.
  25
  26    I have benchmarked driver with PII/300Mhz as a ftp client
  27    and 486/33Mhz as a ftp server. Top speed was 1128.37 kilobytes/sec.
  28
  29    Sources:
  30      - skeleton.c  a sample network driver core for linux,
  31        written by Donald Becker <becker@scyld.com>
  32      - at1700.c a driver for Allied Telesis AT1700, written
  33        by Donald Becker.
  34      - e16iSRV.asm a Netware 3.X Server Driver for ICL EtherTeam16i
  35        written by Markku Viima
  36      - The Fujitsu MB86965 databook.
  37
  38    Author thanks following persons due to their valueble assistance:
  39         Markku Viima (ICL)
  40         Ari Valve (ICL)
  41         Donald Becker
  42         Kurt Huwig <kurt@huwig.de>
  43
  44    Revision history:
  45
  46    Version      Date            Description
  47
  48    0.01         15.12-94        Initial version (card detection)
  49    0.02         23.01-95        Interrupt is now hooked correctly
  50    0.03         01.02-95        Rewrote initialization part
  51    0.04         07.02-95        Base skeleton done...
  52                                 Made a few changes to signature checking
  53                                 to make it a bit reliable.
  54                                 - fixed bug in tx_buf mapping
  55                                 - fixed bug in initialization (DLC_EN
  56                                   wasn't enabled when initialization
  57                                   was done.)
  58    0.05         08.02-95        If there were more than one packet to send,
  59                                 transmit was jammed due to invalid
  60                                 register write...now fixed
  61    0.06         19.02-95        Rewrote interrupt handling
  62    0.07         13.04-95        Wrote EEPROM read routines
  63                                 Card configuration now set according to
  64                                 data read from EEPROM
  65    0.08         23.06-95        Wrote part that tries to probe used interface
  66                                 port if AUTO is selected
  67
  68    0.09         01.09-95        Added module support
  69
  70    0.10         04.09-95        Fixed receive packet allocation to work
  71                                 with kernels > 1.3.x
  72
  73    0.20         20.09-95        Added support for EtherTeam32 EISA
  74
  75    0.21         17.10-95        Removed the unnecessary extern
  76                                 init_etherdev() declaration. Some
  77                                 other cleanups.
  78
  79    0.22         22.02-96        Receive buffer was not flushed
  80                                 correctly when faulty packet was
  81                                 received. Now fixed.
  82
  83    0.23         26.02-96        Made resetting the adapter
  84                                 more reliable.
  85
  86    0.24         27.02-96        Rewrote faulty packet handling in eth16i_rx
  87
  88    0.25         22.05-96        kfree() was missing from cleanup_module.
  89
  90    0.26         11.06-96        Sometimes card was not found by
  91                                 check_signature(). Now made more reliable.
  92
  93    0.27         23.06-96        Oops. 16 consecutive collisions halted
  94                                 adapter. Now will try to retransmit
  95                                 MAX_COL_16 times before finally giving up.
  96
  97    0.28         28.10-97        Added dev_id parameter (NULL) for free_irq
  98
  99    0.29         29.10-97        Multiple card support for module users
 100
 101    0.30         30.10-97        Fixed irq allocation bug.
 102                                 (request_irq moved from probe to open)
 103
 104    0.30a        21.08-98        Card detection made more relaxed. Driver
 105                                 had problems with some TCP/IP-PROM boots
 106                                 to find the card. Suggested by
 107                                 Kurt Huwig <kurt@huwig.de>
 108
 109    0.31         28.08-98        Media interface port can now be selected
 110                                 with module parameters or kernel
 111                                 boot parameters.
 112
 113    0.32         31.08-98        IRQ was never freed if open/close
 114                                 pair wasn't called. Now fixed.
 115
 116    0.33         10.09-98        When eth16i_open() was called after
 117                                 eth16i_close() chip never recovered.
 118                                 Now more shallow reset is made on
 119                                 close.
 120
 121    0.34         29.06-99        Fixed one bad #ifdef.
 122                                 Changed ioaddr -> io for consistency
 123
 124    0.35         01.07-99        transmit,-receive bytes were never
 125                                 updated in stats.
 126
 127    Bugs:
 128         In some cases the media interface autoprobing code doesn't find
 129         the correct interface type. In this case you can
 130         manually choose the interface type in DOS with E16IC.EXE which is
 131         configuration software for EtherTeam16i and EtherTeam32 cards.
 132         This is also true for IRQ setting. You cannot use module
 133         parameter to configure IRQ of the card (yet).
 134
 135    To do:
 136         - Real multicast support
 137         - Rewrite the media interface autoprobing code. Its _horrible_ !
 138         - Possibly merge all the MB86965 specific code to external
 139           module for use by eth16.c and Donald's at1700.c
 140         - IRQ configuration with module parameter. I will do
 141           this when i will get enough info about setting
 142           irq without configuration utility.
 143 */
 144
 145 static char *version =
 146     "eth16i.c: v0.35 01-Jul-1999 Mika Kuoppala (miku@iki.fi)\n";
 147
 148 #include <linux/module.h>
 149 #include <linux/kernel.h>
 150 #include <linux/types.h>
 151 #include <linux/fcntl.h>
 152 #include <linux/interrupt.h>
 153 #include <linux/ioport.h>
 154 #include <linux/in.h>
 155 #include <linux/slab.h>
 156 #include <linux/string.h>
 157 #include <linux/errno.h>
 158 #include <linux/init.h>
 159 #include <linux/spinlock.h>
 160 #include <linux/netdevice.h>
 161 #include <linux/etherdevice.h>
 162 #include <linux/skbuff.h>
 163 #include <linux/bitops.h>
 164 #include <linux/jiffies.h>
 165 #include <linux/io.h>
 166
 167 #include <asm/system.h>
 168 #include <asm/dma.h>
 169
 170
 171
 172 /* Few macros */
 173 #define BIT(a)                 ( (1 << (a)) )
 174 #define BITSET(ioaddr, bnum)   ((outb(((inb(ioaddr)) | (bnum)), ioaddr)))
 175 #define BITCLR(ioaddr, bnum)   ((outb(((inb(ioaddr)) & (~(bnum))), ioaddr)))
 176
 177 /* This is the I/O address space for Etherteam 16i adapter. */
 178 #define ETH16I_IO_EXTENT       32
 179
 180 /* Ticks before deciding that transmit has timed out */
 181 #define TX_TIMEOUT             (400*HZ/1000)
 182
 183 /* Maximum loop count when receiving packets */
 184 #define MAX_RX_LOOP            20
 185
 186 /* Some interrupt masks */
 187 #define ETH16I_INTR_ON         0xef8a       /* Higher is receive mask */
 188 #define ETH16I_INTR_OFF        0x0000
 189
 190 /* Buffers header status byte meanings */
 191 #define PKT_GOOD               BIT(5)
 192 #define PKT_GOOD_RMT           BIT(4)
 193 #define PKT_SHORT              BIT(3)
 194 #define PKT_ALIGN_ERR          BIT(2)
 195 #define PKT_CRC_ERR            BIT(1)
 196 #define PKT_RX_BUF_OVERFLOW    BIT(0)
 197
 198 /* Transmit status register (DLCR0) */
 199 #define TX_STATUS_REG          0
 200 #define TX_DONE                BIT(7)
 201 #define NET_BUSY               BIT(6)
 202 #define TX_PKT_RCD             BIT(5)
 203 #define CR_LOST                BIT(4)
 204 #define TX_JABBER_ERR          BIT(3)
 205 #define COLLISION              BIT(2)
 206 #define COLLISIONS_16          BIT(1)
 207
 208 /* Receive status register (DLCR1) */
 209 #define RX_STATUS_REG          1
 210 #define RX_PKT                 BIT(7)  /* Packet received */
 211 #define BUS_RD_ERR             BIT(6)
 212 #define SHORT_PKT_ERR          BIT(3)
 213 #define ALIGN_ERR              BIT(2)
 214 #define CRC_ERR                BIT(1)
 215 #define RX_BUF_OVERFLOW        BIT(0)
 216
 217 /* Transmit Interrupt Enable Register (DLCR2) */
 218 #define TX_INTR_REG            2
 219 #define TX_INTR_DONE           BIT(7)
 220 #define TX_INTR_COL            BIT(2)
 221 #define TX_INTR_16_COL         BIT(1)
 222
 223 /* Receive Interrupt Enable Register (DLCR3) */
 224 #define RX_INTR_REG            3
 225 #define RX_INTR_RECEIVE        BIT(7)
 226 #define RX_INTR_SHORT_PKT      BIT(3)
 227 #define RX_INTR_CRC_ERR        BIT(1)
 228 #define RX_INTR_BUF_OVERFLOW   BIT(0)
 229
 230 /* Transmit Mode Register (DLCR4) */
 231 #define TRANSMIT_MODE_REG      4
 232 #define LOOPBACK_CONTROL       BIT(1)
 233 #define CONTROL_OUTPUT         BIT(2)
 234
 235 /* Receive Mode Register (DLCR5) */
 236 #define RECEIVE_MODE_REG       5
 237 #define RX_BUFFER_EMPTY        BIT(6)
 238 #define ACCEPT_BAD_PACKETS     BIT(5)
 239 #define RECEIVE_SHORT_ADDR     BIT(4)
 240 #define ACCEPT_SHORT_PACKETS   BIT(3)
 241 #define REMOTE_RESET           BIT(2)
 242
 243 #define ADDRESS_FILTER_MODE    BIT(1) | BIT(0)
 244 #define REJECT_ALL             0
 245 #define ACCEPT_ALL             3
 246 #define MODE_1                 1            /* NODE ID, BC, MC, 2-24th bit */
 247 #define MODE_2                 2            /* NODE ID, BC, MC, Hash Table */
 248
 249 /* Configuration Register 0 (DLCR6) */
 250 #define CONFIG_REG_0           6
 251 #define DLC_EN                 BIT(7)
 252 #define SRAM_CYCLE_TIME_100NS  BIT(6)
 253 #define SYSTEM_BUS_WIDTH_8     BIT(5)       /* 1 = 8bit, 0 = 16bit */
 254 #define BUFFER_WIDTH_8         BIT(4)       /* 1 = 8bit, 0 = 16bit */
 255 #define TBS1                   BIT(3)
 256 #define TBS0                   BIT(2)
 257 #define SRAM_BS1               BIT(1)       /* 00=8kb,  01=16kb  */
 258 #define SRAM_BS0               BIT(0)       /* 10=32kb, 11=64kb  */
 259
 260 #ifndef ETH16I_TX_BUF_SIZE                   /* 0 = 2kb, 1 = 4kb  */
 261 #define ETH16I_TX_BUF_SIZE     3             /* 2 = 8kb, 3 = 16kb */
 262 #endif
 263 #define TX_BUF_1x2048          0
 264 #define TX_BUF_2x2048          1
 265 #define TX_BUF_2x4098          2
 266 #define TX_BUF_2x8192          3
 267
 268 /* Configuration Register 1 (DLCR7) */
 269 #define CONFIG_REG_1           7
 270 #define POWERUP                BIT(5)
 271
 272 /* Transmit start register */
 273 #define TRANSMIT_START_REG     10
 274 #define TRANSMIT_START_RB      2
 275 #define TX_START               BIT(7)       /* Rest of register bit indicate*/
 276                                             /* number of packets in tx buffer*/
 277 /* Node ID registers (DLCR8-13) */
 278 #define NODE_ID_0              8
 279 #define NODE_ID_RB             0
 280
 281 /* Hash Table registers (HT8-15) */
 282 #define HASH_TABLE_0           8
 283 #define HASH_TABLE_RB          1
 284
 285 /* Buffer memory ports */
 286 #define BUFFER_MEM_PORT_LB     8
 287 #define DATAPORT               BUFFER_MEM_PORT_LB
 288 #define BUFFER_MEM_PORT_HB     9
 289
 290 /* 16 Collision control register (BMPR11) */
 291 #define COL_16_REG             11
 292 #define HALT_ON_16             0x00
 293 #define RETRANS_AND_HALT_ON_16 0x02
 294
 295 /* Maximum number of attempts to send after 16 concecutive collisions */
 296 #define MAX_COL_16             10
 297
 298 /* DMA Burst and Transceiver Mode Register (BMPR13) */
 299 #define TRANSCEIVER_MODE_REG   13
 300 #define TRANSCEIVER_MODE_RB    2
 301 #define IO_BASE_UNLOCK         BIT(7)
 302 #define LOWER_SQUELCH_TRESH    BIT(6)
 303 #define LINK_TEST_DISABLE      BIT(5)
 304 #define AUI_SELECT             BIT(4)
 305 #define DIS_AUTO_PORT_SEL      BIT(3)
 306
 307 /* Filter Self Receive Register (BMPR14)  */
 308 #define FILTER_SELF_RX_REG     14
 309 #define SKIP_RX_PACKET         BIT(2)
 310 #define FILTER_SELF_RECEIVE    BIT(0)
 311
 312 /* EEPROM Control Register (BMPR 16) */
 313 #define EEPROM_CTRL_REG        16
 314
 315 /* EEPROM Data Register (BMPR 17) */
 316 #define EEPROM_DATA_REG        17
 317
 318 /* NMC93CSx6 EEPROM Control Bits */
 319 #define CS_0                   0x00
 320 #define CS_1                   0x20
 321 #define SK_0                   0x00
 322 #define SK_1                   0x40
 323 #define DI_0                   0x00
 324 #define DI_1                   0x80
 325
 326 /* NMC93CSx6 EEPROM Instructions */
 327 #define EEPROM_READ            0x80
 328
 329 /* NMC93CSx6 EEPROM Addresses */
 330 #define E_NODEID_0             0x02
 331 #define E_NODEID_1             0x03
 332 #define E_NODEID_2             0x04
 333 #define E_PORT_SELECT          0x14
 334   #define E_PORT_BNC           0x00
 335   #define E_PORT_DIX           0x01
 336   #define E_PORT_TP            0x02
 337   #define E_PORT_AUTO          0x03
 338   #define E_PORT_FROM_EPROM    0x04
 339 #define E_PRODUCT_CFG          0x30
 340
 341
 342 /* Macro to slow down io between EEPROM clock transitions */
 343 #define eeprom_slow_io() do { int _i = 40; while(--_i > 0) { inb(0x80); }}while(0)
 344
 345 /* Jumperless Configuration Register (BMPR19) */
 346 #define JUMPERLESS_CONFIG      19
 347
 348 /* ID ROM registers, writing to them also resets some parts of chip */
 349 #define ID_ROM_0               24
 350 #define ID_ROM_7               31
 351 #define RESET                  ID_ROM_0
 352
 353 /* This is the I/O address list to be probed when seeking the card */
 354 static unsigned int eth16i_portlist[] __initdata = {
 355         0x260, 0x280, 0x2A0, 0x240, 0x340, 0x320, 0x380, 0x300, 0
 356 };
 357
 358 static unsigned int eth32i_portlist[] __initdata = {
 359         0x1000, 0x2000, 0x3000, 0x4000, 0x5000, 0x6000, 0x7000, 0x8000,
 360         0x9000, 0xA000, 0xB000, 0xC000, 0xD000, 0xE000, 0xF000, 0
 361 };
 362
 363 /* This is the Interrupt lookup table for Eth16i card */
 364 static unsigned int eth16i_irqmap[] __initdata = { 9, 10, 5, 15, 0 };
 365 #define NUM_OF_ISA_IRQS    4
 366
 367 /* This is the Interrupt lookup table for Eth32i card */
 368 static unsigned int eth32i_irqmap[] __initdata = { 3, 5, 7, 9, 10, 11, 12, 15, 0 };
 369 #define EISA_IRQ_REG    0xc89
 370 #define NUM_OF_EISA_IRQS   8
 371
 372 static unsigned int eth16i_tx_buf_map[] = { 2048, 2048, 4096, 8192 };
 373
 374 /* Use 0 for production, 1 for verification, >2 for debug */
 375 #ifndef ETH16I_DEBUG
 376 #define ETH16I_DEBUG 0
 377 #endif
 378 static unsigned int eth16i_debug = ETH16I_DEBUG;
 379
 380 /* Information for each board */
 381
 382 struct eth16i_local {
 383         struct net_device_stats stats;
 384         unsigned char     tx_started;
 385         unsigned char     tx_buf_busy;
 386         unsigned short    tx_queue;  /* Number of packets in transmit buffer */
 387         unsigned short    tx_queue_len;
 388         unsigned int      tx_buf_size;
 389         unsigned long     open_time;
 390         unsigned long     tx_buffered_packets;
 391         unsigned long     tx_buffered_bytes;
 392         unsigned long     col_16;
 393         spinlock_t        lock;
 394 };
 395
 396 /* Function prototypes */
 397
 398 static int     eth16i_probe1(struct net_device *dev, int ioaddr);
 399 static int     eth16i_check_signature(int ioaddr);
 400 static int     eth16i_probe_port(int ioaddr);
 401 static void    eth16i_set_port(int ioaddr, int porttype);
 402 static int     eth16i_send_probe_packet(int ioaddr, unsigned char *b, int l);
 403 static int     eth16i_receive_probe_packet(int ioaddr);
 404 static int     eth16i_get_irq(int ioaddr);
 405 static int     eth16i_read_eeprom(int ioaddr, int offset);
 406 static int     eth16i_read_eeprom_word(int ioaddr);
 407 static void    eth16i_eeprom_cmd(int ioaddr, unsigned char command);
 408 static int     eth16i_open(struct net_device *dev);
 409 static int     eth16i_close(struct net_device *dev);
 410 static int     eth16i_tx(struct sk_buff *skb, struct net_device *dev);
 411 static void    eth16i_rx(struct net_device *dev);
 412 static void    eth16i_timeout(struct net_device *dev);
 413 static irqreturn_t eth16i_interrupt(int irq, void *dev_id);
 414 static void    eth16i_reset(struct net_device *dev);
 415 static void    eth16i_timeout(struct net_device *dev);
 416 static void    eth16i_skip_packet(struct net_device *dev);
 417 static void    eth16i_multicast(struct net_device *dev);
 418 static void    eth16i_select_regbank(unsigned char regbank, int ioaddr);
 419 static void    eth16i_initialize(struct net_device *dev, int boot);
 420
 421 #if 0
 422 static int     eth16i_set_irq(struct net_device *dev);
 423 #endif
 424
 425 #ifdef MODULE
 426 static ushort  eth16i_parse_mediatype(const char* s);
 427 #endif
 428
 429 static struct net_device_stats *eth16i_get_stats(struct net_device *dev);
 430
 431 static char cardname[] __initdata = "ICL EtherTeam 16i/32";
 432
 433 static int __init do_eth16i_probe(struct net_device *dev)
 434 {
 435         int i;
 436         int ioaddr;
 437         int base_addr = dev->base_addr;
 438
 439         if(eth16i_debug > 4)
 440                 printk(KERN_DEBUG "Probing started for %s\n", cardname);
 441
 442         if(base_addr > 0x1ff)           /* Check only single location */
 443                 return eth16i_probe1(dev, base_addr);
 444         else if(base_addr != 0)         /* Don't probe at all */
 445                 return -ENXIO;
 446
 447         /* Seek card from the ISA io address space */
 448         for(i = 0; (ioaddr = eth16i_portlist[i]) ; i++)
 449                 if(eth16i_probe1(dev, ioaddr) == 0)
 450                         return 0;
 451
 452         /* Seek card from the EISA io address space */
 453         for(i = 0; (ioaddr = eth32i_portlist[i]) ; i++)
 454                 if(eth16i_probe1(dev, ioaddr) == 0)
 455                         return 0;
 456
 457         return -ENODEV;
 458 }
 459
 460 #ifndef MODULE
 461 struct net_device * __init eth16i_probe(int unit)
 462 {
 463         struct net_device *dev = alloc_etherdev(sizeof(struct eth16i_local));
 464         int err;
 465
 466         if (!dev)
 467                 return ERR_PTR(-ENOMEM);
 468
 469         sprintf(dev->name, "eth%d", unit);
 470         netdev_boot_setup_check(dev);
 471
 472         err = do_eth16i_probe(dev);
 473         if (err)
 474                 goto out;
 475         return dev;
 476 out:
 477         free_netdev(dev);
 478         return ERR_PTR(err);
 479 }
 480 #endif
 481
 482 static int __init eth16i_probe1(struct net_device *dev, int ioaddr)
 483 {
 484         struct eth16i_local *lp = netdev_priv(dev);
 485         static unsigned version_printed;
 486         int retval;
 487
 488         /* Let's grab the region */
 489         if (!request_region(ioaddr, ETH16I_IO_EXTENT, cardname))
 490                 return -EBUSY;
 491
 492         /*
 493           The MB86985 chip has on register which holds information in which
 494           io address the chip lies. First read this register and compare
 495           it to our current io address and if match then this could
 496           be our chip.
 497           */
 498
 499         if(ioaddr < 0x1000) {
 500                 if(eth16i_portlist[(inb(ioaddr + JUMPERLESS_CONFIG) & 0x07)]
 501                    != ioaddr) {
 502                         retval = -ENODEV;
 503                         goto out;
 504                 }
 505         }
 506
 507         /* Now we will go a bit deeper and try to find the chip's signature */
 508
 509         if(eth16i_check_signature(ioaddr) != 0) {
 510                 retval = -ENODEV;
 511                 goto out;
 512         }
 513
 514         /*
 515            Now it seems that we have found a ethernet chip in this particular
 516            ioaddr. The MB86985 chip has this feature, that when you read a
 517            certain register it will increase it's io base address to next
 518            configurable slot. Now when we have found the chip, first thing is
 519            to make sure that the chip's ioaddr will hold still here.
 520            */
 521
 522         eth16i_select_regbank(TRANSCEIVER_MODE_RB, ioaddr);
 523         outb(0x00, ioaddr + TRANSCEIVER_MODE_REG);
 524
 525         outb(0x00, ioaddr + RESET);             /* Reset some parts of chip */
 526         BITSET(ioaddr + CONFIG_REG_0, BIT(7));  /* Disable the data link */
 527
 528         if( (eth16i_debug & version_printed++) == 0)
 529                 printk(KERN_INFO "%s", version);
 530
 531         dev->base_addr = ioaddr;
 532         dev->irq = eth16i_get_irq(ioaddr);
 533
 534         /* Try to obtain interrupt vector */
 535
 536         if ((retval = request_irq(dev->irq, (void *)&eth16i_interrupt, 0, cardname, dev))) {
 537                 printk(KERN_WARNING "%s at %#3x, but is unusable due to conflicting IRQ %d.\n",
 538                        cardname, ioaddr, dev->irq);
 539                 goto out;
 540         }
 541
 542         printk(KERN_INFO "%s: %s at %#3x, IRQ %d, ",
 543                dev->name, cardname, ioaddr, dev->irq);
 544
 545
 546         /* Now we will have to lock the chip's io address */
 547         eth16i_select_regbank(TRANSCEIVER_MODE_RB, ioaddr);
 548         outb(0x38, ioaddr + TRANSCEIVER_MODE_REG);
 549
 550         eth16i_initialize(dev, 1); /* Initialize rest of the chip's registers */
 551
 552         /* Now let's same some energy by shutting down the chip ;) */
 553         BITCLR(ioaddr + CONFIG_REG_1, POWERUP);
 554
 555         /* Initialize the device structure */
 556         memset(lp, 0, sizeof(struct eth16i_local));
 557         dev->open               = eth16i_open;
 558         dev->stop               = eth16i_close;
 559         dev->hard_start_xmit    = eth16i_tx;
 560         dev->get_stats          = eth16i_get_stats;
 561         dev->set_multicast_list = eth16i_multicast;
 562         dev->tx_timeout         = eth16i_timeout;
 563         dev->watchdog_timeo     = TX_TIMEOUT;
 564         spin_lock_init(&lp->lock);
 565
 566         retval = register_netdev(dev);
 567         if (retval)
 568                 goto out1;
 569         return 0;
 570 out1:
 571         free_irq(dev->irq, dev);
 572 out:
 573         release_region(ioaddr, ETH16I_IO_EXTENT);
 574         return retval;
 575 }
 576
 577
 578 static void eth16i_initialize(struct net_device *dev, int boot)
 579 {
 580         int ioaddr = dev->base_addr;
 581         int i, node_w = 0;
 582         unsigned char node_byte = 0;
 583
 584         /* Setup station address */
 585         eth16i_select_regbank(NODE_ID_RB, ioaddr);
 586         for(i = 0 ; i < 3 ; i++) {
 587                 unsigned short node_val = eth16i_read_eeprom(ioaddr, E_NODEID_0 + i);
 588                 ((unsigned short *)dev->dev_addr)[i] = ntohs(node_val);
 589         }
 590
 591         for(i = 0; i < 6; i++) {
 592                 outb( ((unsigned char *)dev->dev_addr)[i], ioaddr + NODE_ID_0 + i);
 593                 if(boot) {
 594                         printk("%02x", inb(ioaddr + NODE_ID_0 + i));
 595                         if(i != 5)
 596                                 printk(":");
 597                 }
 598         }
 599
 600         /* Now we will set multicast addresses to accept none */
 601         eth16i_select_regbank(HASH_TABLE_RB, ioaddr);
 602         for(i = 0; i < 8; i++)
 603                 outb(0x00, ioaddr + HASH_TABLE_0 + i);
 604
 605         /*
 606           Now let's disable the transmitter and receiver, set the buffer ram
 607           cycle time, bus width and buffer data path width. Also we shall
 608           set transmit buffer size and total buffer size.
 609           */
 610
 611         eth16i_select_regbank(2, ioaddr);
 612
 613         node_byte = 0;
 614         node_w = eth16i_read_eeprom(ioaddr, E_PRODUCT_CFG);
 615
 616         if( (node_w & 0xFF00) == 0x0800)
 617                 node_byte |= BUFFER_WIDTH_8;
 618
 619         node_byte |= SRAM_BS1;
 620
 621         if( (node_w & 0x00FF) == 64)
 622                 node_byte |= SRAM_BS0;
 623
 624         node_byte |= DLC_EN | SRAM_CYCLE_TIME_100NS | (ETH16I_TX_BUF_SIZE << 2);
 625
 626         outb(node_byte, ioaddr + CONFIG_REG_0);
 627
 628         /* We shall halt the transmitting, if 16 collisions are detected */
 629         outb(HALT_ON_16, ioaddr + COL_16_REG);
 630
 631 #ifdef MODULE
 632         /* if_port already set by init_module() */
 633 #else
 634         dev->if_port = (dev->mem_start < E_PORT_FROM_EPROM) ?
 635                 dev->mem_start : E_PORT_FROM_EPROM;
 636 #endif
 637
 638         /* Set interface port type */
 639         if(boot) {
 640                 char *porttype[] = {"BNC", "DIX", "TP", "AUTO", "FROM_EPROM" };
 641
 642                 switch(dev->if_port)
 643                 {
 644
 645                 case E_PORT_FROM_EPROM:
 646                         dev->if_port = eth16i_read_eeprom(ioaddr, E_PORT_SELECT);
 647                         break;
 648
 649                 case E_PORT_AUTO:
 650                         dev->if_port = eth16i_probe_port(ioaddr);
 651                         break;
 652
 653                 case E_PORT_BNC:
 654                 case E_PORT_TP:
 655                 case E_PORT_DIX:
 656                         break;
 657                 }
 658
 659                 printk(" %s interface.\n", porttype[dev->if_port]);
 660
 661                 eth16i_set_port(ioaddr, dev->if_port);
 662         }
 663
 664         /* Set Receive Mode to normal operation */
 665         outb(MODE_2, ioaddr + RECEIVE_MODE_REG);
 666 }
 667
 668 static int eth16i_probe_port(int ioaddr)
 669 {
 670         int i;
 671         int retcode;
 672         unsigned char dummy_packet[64];
 673
 674         /* Powerup the chip */
 675         outb(0xc0 | POWERUP, ioaddr + CONFIG_REG_1);
 676
 677         BITSET(ioaddr + CONFIG_REG_0, DLC_EN);
 678
 679         eth16i_select_regbank(NODE_ID_RB, ioaddr);
 680
 681         for(i = 0; i < 6; i++) {
 682                 dummy_packet[i] = inb(ioaddr + NODE_ID_0 + i);
 683                 dummy_packet[i+6] = inb(ioaddr + NODE_ID_0 + i);
 684         }
 685
 686         dummy_packet[12] = 0x00;
 687         dummy_packet[13] = 0x04;
 688         memset(dummy_packet + 14, 0, sizeof(dummy_packet) - 14);
 689
 690         eth16i_select_regbank(2, ioaddr);
 691
 692         for(i = 0; i < 3; i++) {
 693                 BITSET(ioaddr + CONFIG_REG_0, DLC_EN);
 694                 BITCLR(ioaddr + CONFIG_REG_0, DLC_EN);
 695                 eth16i_set_port(ioaddr, i);
 696
 697                 if(eth16i_debug > 1)
 698                         printk(KERN_DEBUG "Set port number %d\n", i);
 699
 700                 retcode = eth16i_send_probe_packet(ioaddr, dummy_packet, 64);
 701                 if(retcode == 0) {
 702                         retcode = eth16i_receive_probe_packet(ioaddr);
 703                         if(retcode != -1) {
 704                                 if(eth16i_debug > 1)
 705                                         printk(KERN_DEBUG "Eth16i interface port found at %d\n", i);
 706                                 return i;
 707                         }
 708                 }
 709                 else {
 710                         if(eth16i_debug > 1)
 711                                 printk(KERN_DEBUG "TRANSMIT_DONE timeout when probing interface port\n");
 712                 }
 713         }
 714
 715         if( eth16i_debug > 1)
 716                 printk(KERN_DEBUG "Using default port\n");
 717
 718         return E_PORT_BNC;
 719 }
 720
 721 static void eth16i_set_port(int ioaddr, int porttype)
 722 {
 723         unsigned short temp = 0;
 724
 725         eth16i_select_regbank(TRANSCEIVER_MODE_RB, ioaddr);
 726         outb(LOOPBACK_CONTROL, ioaddr + TRANSMIT_MODE_REG);
 727
 728         temp |= DIS_AUTO_PORT_SEL;
 729
 730         switch(porttype) {
 731
 732         case E_PORT_BNC :
 733                 temp |= AUI_SELECT;
 734                 break;
 735
 736         case E_PORT_TP :
 737                 break;
 738
 739         case E_PORT_DIX :
 740                 temp |= AUI_SELECT;
 741                 BITSET(ioaddr + TRANSMIT_MODE_REG, CONTROL_OUTPUT);
 742                 break;
 743         }
 744
 745         outb(temp, ioaddr + TRANSCEIVER_MODE_REG);
 746
 747         if(eth16i_debug > 1) {
 748                 printk(KERN_DEBUG "TRANSMIT_MODE_REG = %x\n", inb(ioaddr + TRANSMIT_MODE_REG));
 749                 printk(KERN_DEBUG "TRANSCEIVER_MODE_REG = %x\n",
 750                        inb(ioaddr+TRANSCEIVER_MODE_REG));
 751         }
 752 }
 753
 754 static int eth16i_send_probe_packet(int ioaddr, unsigned char *b, int l)
 755 {
 756         unsigned long starttime;
 757
 758         outb(0xff, ioaddr + TX_STATUS_REG);
 759
 760         outw(l, ioaddr + DATAPORT);
 761         outsw(ioaddr + DATAPORT, (unsigned short *)b, (l + 1) >> 1);
 762
 763         starttime = jiffies;
 764         outb(TX_START | 1, ioaddr + TRANSMIT_START_REG);
 765
 766         while( (inb(ioaddr + TX_STATUS_REG) & 0x80) == 0) {
 767                 if( time_after(jiffies, starttime + TX_TIMEOUT)) {
 768                         return -1;
 769                 }
 770         }
 771
 772         return 0;
 773 }
 774
 775 static int eth16i_receive_probe_packet(int ioaddr)
 776 {
 777         unsigned long starttime;
 778
 779         starttime = jiffies;
 780
 781         while((inb(ioaddr + TX_STATUS_REG) & 0x20) == 0) {
 782                 if( time_after(jiffies, starttime + TX_TIMEOUT)) {
 783
 784                         if(eth16i_debug > 1)
 785                                 printk(KERN_DEBUG "Timeout occurred waiting transmit packet received\n");
 786                         starttime = jiffies;
 787                         while((inb(ioaddr + RX_STATUS_REG) & 0x80) == 0) {
 788                                 if( time_after(jiffies, starttime + TX_TIMEOUT)) {
 789                                         if(eth16i_debug > 1)
 790                                                 printk(KERN_DEBUG "Timeout occurred waiting receive packet\n");
 791                                         return -1;
 792                                 }
 793                         }
 794
 795                         if(eth16i_debug > 1)
 796                                 printk(KERN_DEBUG "RECEIVE_PACKET\n");
 797                         return(0); /* Found receive packet */
 798                 }
 799         }
 800
 801         if(eth16i_debug > 1) {
 802                 printk(KERN_DEBUG "TRANSMIT_PACKET_RECEIVED %x\n", inb(ioaddr + TX_STATUS_REG));
 803                 printk(KERN_DEBUG "RX_STATUS_REG = %x\n", inb(ioaddr + RX_STATUS_REG));
 804         }
 805
 806         return(0); /* Return success */
 807 }
 808
 809 #if 0
 810 static int eth16i_set_irq(struct net_device* dev)
 811 {
 812         const int ioaddr = dev->base_addr;
 813         const int irq = dev->irq;
 814         int i = 0;
 815
 816         if(ioaddr < 0x1000) {
 817                 while(eth16i_irqmap[i] && eth16i_irqmap[i] != irq)
 818                         i++;
 819
 820                 if(i < NUM_OF_ISA_IRQS) {
 821                         u8 cbyte = inb(ioaddr + JUMPERLESS_CONFIG);
 822                         cbyte = (cbyte & 0x3F) | (i << 6);
 823                         outb(cbyte, ioaddr + JUMPERLESS_CONFIG);
 824                         return 0;
 825                 }
 826         }
 827         else {
 828                 printk(KERN_NOTICE "%s: EISA Interrupt cannot be set. Use EISA Configuration utility.\n", dev->name);
 829         }
 830
 831         return -1;
 832
 833 }
 834 #endif
 835
 836 static int __init eth16i_get_irq(int ioaddr)
 837 {
 838         unsigned char cbyte;
 839
 840         if( ioaddr < 0x1000) {
 841                 cbyte = inb(ioaddr + JUMPERLESS_CONFIG);
 842                 return( eth16i_irqmap[ ((cbyte & 0xC0) >> 6) ] );
 843         } else {  /* Oh..the card is EISA so method getting IRQ different */
 844                 unsigned short index = 0;
 845                 cbyte = inb(ioaddr + EISA_IRQ_REG);
 846                 while( (cbyte & 0x01) == 0) {
 847                         cbyte = cbyte >> 1;
 848                         index++;
 849                 }
 850                 return( eth32i_irqmap[ index ] );
 851         }
 852 }
 853
 854 static int __init eth16i_check_signature(int ioaddr)
 855 {
 856         int i;
 857         unsigned char creg[4] = { 0 };
 858
 859         for(i = 0; i < 4 ; i++) {
 860
 861                 creg[i] = inb(ioaddr + TRANSMIT_MODE_REG + i);
 862
 863                 if(eth16i_debug > 1)
 864                         printk("eth16i: read signature byte %x at %x\n",
 865                                creg[i],
 866                                ioaddr + TRANSMIT_MODE_REG + i);
 867         }
 868
 869         creg[0] &= 0x0F;      /* Mask collision cnr */
 870         creg[2] &= 0x7F;      /* Mask DCLEN bit */
 871
 872 #if 0
 873         /*
 874            This was removed because the card was sometimes left to state
 875            from which it couldn't be find anymore. If there is need
 876            to more strict check still this have to be fixed.
 877            */
 878         if( ! ((creg[0] == 0x06) && (creg[1] == 0x41)) ) {
 879                 if(creg[1] != 0x42)
 880                         return -1;
 881         }
 882 #endif
 883
 884         if( !((creg[2] == 0x36) && (creg[3] == 0xE0)) ) {
 885                 creg[2] &= 0x40;
 886                 creg[3] &= 0x03;
 887
 888                 if( !((creg[2] == 0x40) && (creg[3] == 0x00)) )
 889                         return -1;
 890         }
 891
 892         if(eth16i_read_eeprom(ioaddr, E_NODEID_0) != 0)
 893                 return -1;
 894
 895         if((eth16i_read_eeprom(ioaddr, E_NODEID_1) & 0xFF00) != 0x4B00)
 896                 return -1;
 897
 898         return 0;
 899 }
 900
 901 static int eth16i_read_eeprom(int ioaddr, int offset)
 902 {
 903         int data = 0;
 904
 905         eth16i_eeprom_cmd(ioaddr, EEPROM_READ | offset);
 906         outb(CS_1, ioaddr + EEPROM_CTRL_REG);
 907         data = eth16i_read_eeprom_word(ioaddr);
 908         outb(CS_0 | SK_0, ioaddr + EEPROM_CTRL_REG);
 909
 910         return(data);
 911 }
 912
 913 static int eth16i_read_eeprom_word(int ioaddr)
 914 {
 915         int i;
 916         int data = 0;
 917
 918         for(i = 16; i > 0; i--) {
 919                 outb(CS_1 | SK_0, ioaddr + EEPROM_CTRL_REG);
 920                 eeprom_slow_io();
 921                 outb(CS_1 | SK_1, ioaddr + EEPROM_CTRL_REG);
 922                 eeprom_slow_io();
 923                 data = (data << 1) |
 924                         ((inb(ioaddr + EEPROM_DATA_REG) & DI_1) ? 1 : 0);
 925
 926                 eeprom_slow_io();
 927         }
 928
 929         return(data);
 930 }
 931
 932 static void eth16i_eeprom_cmd(int ioaddr, unsigned char command)
 933 {
 934         int i;
 935
 936         outb(CS_0 | SK_0, ioaddr + EEPROM_CTRL_REG);
 937         outb(DI_0, ioaddr + EEPROM_DATA_REG);
 938         outb(CS_1 | SK_0, ioaddr + EEPROM_CTRL_REG);
 939         outb(DI_1, ioaddr + EEPROM_DATA_REG);
 940         outb(CS_1 | SK_1, ioaddr + EEPROM_CTRL_REG);
 941
 942         for(i = 7; i >= 0; i--) {
 943                 short cmd = ( (command & (1 << i)) ? DI_1 : DI_0 );
 944                 outb(cmd, ioaddr + EEPROM_DATA_REG);
 945                 outb(CS_1 | SK_0, ioaddr + EEPROM_CTRL_REG);
 946                 eeprom_slow_io();
 947                 outb(CS_1 | SK_1, ioaddr + EEPROM_CTRL_REG);
 948                 eeprom_slow_io();
 949         }
 950 }
 951
 952 static int eth16i_open(struct net_device *dev)
 953 {
 954         struct eth16i_local *lp = netdev_priv(dev);
 955         int ioaddr = dev->base_addr;
 956
 957         /* Powerup the chip */
 958         outb(0xc0 | POWERUP, ioaddr + CONFIG_REG_1);
 959
 960         /* Initialize the chip */
 961         eth16i_initialize(dev, 0);
 962
 963         /* Set the transmit buffer size */
 964         lp->tx_buf_size = eth16i_tx_buf_map[ETH16I_TX_BUF_SIZE & 0x03];
 965
 966         if(eth16i_debug > 0)
 967                 printk(KERN_DEBUG "%s: transmit buffer size %d\n",
 968                        dev->name, lp->tx_buf_size);
 969
 970         /* Now enable Transmitter and Receiver sections */
 971         BITCLR(ioaddr + CONFIG_REG_0, DLC_EN);
 972
 973         /* Now switch to register bank 2, for run time operation */
 974         eth16i_select_regbank(2, ioaddr);
 975
 976         lp->open_time = jiffies;
 977         lp->tx_started = 0;
 978         lp->tx_queue = 0;
 979         lp->tx_queue_len = 0;
 980
 981         /* Turn on interrupts*/
 982         outw(ETH16I_INTR_ON, ioaddr + TX_INTR_REG);
 983
 984         netif_start_queue(dev);
 985         return 0;
 986 }
 987
 988 static int eth16i_close(struct net_device *dev)
 989 {
 990         struct eth16i_local *lp = netdev_priv(dev);
 991         int ioaddr = dev->base_addr;
 992
 993         eth16i_reset(dev);
 994
 995         /* Turn off interrupts*/
 996         outw(ETH16I_INTR_OFF, ioaddr + TX_INTR_REG);
 997
 998         netif_stop_queue(dev);
 999
1000         lp->open_time = 0;
1001
1002         /* Disable transmit and receive */
1003         BITSET(ioaddr + CONFIG_REG_0, DLC_EN);
1004
1005         /* Reset the chip */
1006         /* outb(0xff, ioaddr + RESET); */
1007         /* outw(0xffff, ioaddr + TX_STATUS_REG);    */
1008
1009         outb(0x00, ioaddr + CONFIG_REG_1);
1010
1011         return 0;
1012 }
1013
1014 static void eth16i_timeout(struct net_device *dev)
1015 {
1016         struct eth16i_local *lp = netdev_priv(dev);
1017         int ioaddr = dev->base_addr;
1018         /*
1019            If we get here, some higher level has decided that
1020            we are broken. There should really be a "kick me"
1021            function call instead.
1022            */
1023
1024         outw(ETH16I_INTR_OFF, ioaddr + TX_INTR_REG);
1025         printk(KERN_WARNING "%s: transmit timed out with status %04x, %s ?\n",
1026                dev->name,
1027         inw(ioaddr + TX_STATUS_REG),  (inb(ioaddr + TX_STATUS_REG) & TX_DONE) ?
1028                        "IRQ conflict" : "network cable problem");
1029
1030         dev->trans_start = jiffies;
1031
1032         /* Let's dump all registers */
1033         if(eth16i_debug > 0) {
1034                 printk(KERN_DEBUG "%s: timeout: %02x %02x %02x %02x %02x %02x %02x %02x.\n",
1035                        dev->name, inb(ioaddr + 0),
1036                        inb(ioaddr + 1), inb(ioaddr + 2),
1037                        inb(ioaddr + 3), inb(ioaddr + 4),
1038                        inb(ioaddr + 5),
1039                        inb(ioaddr + 6), inb(ioaddr + 7));
1040
1041                 printk(KERN_DEBUG "%s: transmit start reg: %02x. collision reg %02x\n",
1042                        dev->name, inb(ioaddr + TRANSMIT_START_REG),
1043                        inb(ioaddr + COL_16_REG));
1044                         printk(KERN_DEBUG "lp->tx_queue = %d\n", lp->tx_queue);
1045                 printk(KERN_DEBUG "lp->tx_queue_len = %d\n", lp->tx_queue_len);
1046                 printk(KERN_DEBUG "lp->tx_started = %d\n", lp->tx_started);
1047         }
1048         lp->stats.tx_errors++;
1049         eth16i_reset(dev);
1050         dev->trans_start = jiffies;
1051         outw(ETH16I_INTR_ON, ioaddr + TX_INTR_REG);
1052         netif_wake_queue(dev);
1053 }
1054
1055 static int eth16i_tx(struct sk_buff *skb, struct net_device *dev)
1056 {
1057         struct eth16i_local *lp = netdev_priv(dev);
1058         int ioaddr = dev->base_addr;
1059         int status = 0;
1060         ushort length = skb->len;
1061         unsigned char *buf;
1062         unsigned long flags;
1063
1064         if (length < ETH_ZLEN) {
1065                 if (skb_padto(skb, ETH_ZLEN))
1066                         return 0;
1067                 length = ETH_ZLEN;
1068         }
1069         buf = skb->data;
1070
1071         netif_stop_queue(dev);
1072
1073         /* Turn off TX interrupts */
1074         outw(ETH16I_INTR_OFF, ioaddr + TX_INTR_REG);
1075
1076         /* We would be better doing the disable_irq tricks the 3c509 does,
1077            that would make this suck a lot less */
1078
1079         spin_lock_irqsave(&lp->lock, flags);
1080
1081         if( (length + 2) > (lp->tx_buf_size - lp->tx_queue_len)) {
1082                 if(eth16i_debug > 0)
1083                         printk(KERN_WARNING "%s: Transmit buffer full.\n", dev->name);
1084         }
1085         else {
1086                 outw(length, ioaddr + DATAPORT);
1087
1088                 if( ioaddr < 0x1000 )
1089                         outsw(ioaddr + DATAPORT, buf, (length + 1) >> 1);
1090                 else {
1091                         unsigned char frag = length % 4;
1092                         outsl(ioaddr + DATAPORT, buf, length >> 2);
1093                         if( frag != 0 ) {
1094                                 outsw(ioaddr + DATAPORT, (buf + (length & 0xFFFC)), 1);
1095                                 if( frag == 3 )
1096                                         outsw(ioaddr + DATAPORT,
1097                                               (buf + (length & 0xFFFC) + 2), 1);
1098                         }
1099                 }
1100                 lp->tx_buffered_packets++;
1101                 lp->tx_buffered_bytes = length;
1102                 lp->tx_queue++;
1103                 lp->tx_queue_len += length + 2;
1104         }
1105         lp->tx_buf_busy = 0;
1106
1107         if(lp->tx_started == 0) {
1108                 /* If the transmitter is idle..always trigger a transmit */
1109                 outb(TX_START | lp->tx_queue, ioaddr + TRANSMIT_START_REG);
1110                 lp->tx_queue = 0;
1111                 lp->tx_queue_len = 0;
1112                 dev->trans_start = jiffies;
1113                 lp->tx_started = 1;
1114                 netif_wake_queue(dev);
1115         }
1116         else if(lp->tx_queue_len < lp->tx_buf_size - (ETH_FRAME_LEN + 2)) {
1117                 /* There is still more room for one more packet in tx buffer */
1118                 netif_wake_queue(dev);
1119         }
1120
1121         spin_unlock_irqrestore(&lp->lock, flags);
1122
1123         outw(ETH16I_INTR_ON, ioaddr + TX_INTR_REG);
1124         /* Turn TX interrupts back on */
1125         /* outb(TX_INTR_DONE | TX_INTR_16_COL, ioaddr + TX_INTR_REG); */
1126         status = 0;
1127         dev_kfree_skb(skb);
1128         return 0;
1129 }
1130
1131 static void eth16i_rx(struct net_device *dev)
1132 {
1133         struct eth16i_local *lp = netdev_priv(dev);
1134         int ioaddr = dev->base_addr;
1135         int boguscount = MAX_RX_LOOP;
1136
1137         /* Loop until all packets have been read */
1138         while( (inb(ioaddr + RECEIVE_MODE_REG) & RX_BUFFER_EMPTY) == 0) {
1139
1140                 /* Read status byte from receive buffer */
1141                 ushort status = inw(ioaddr + DATAPORT);
1142
1143                 /* Get the size of the packet from receive buffer */
1144                 ushort pkt_len = inw(ioaddr + DATAPORT);
1145
1146                 if(eth16i_debug > 4)
1147                         printk(KERN_DEBUG "%s: Receiving packet mode %02x status %04x.\n",
1148                                dev->name,
1149                                inb(ioaddr + RECEIVE_MODE_REG), status);
1150
1151                 if( !(status & PKT_GOOD) ) {
1152                         lp->stats.rx_errors++;
1153
1154                         if( (pkt_len < ETH_ZLEN) || (pkt_len > ETH_FRAME_LEN) ) {
1155                                 lp->stats.rx_length_errors++;
1156                                 eth16i_reset(dev);
1157                                 return;
1158                         }
1159                         else {
1160                                 eth16i_skip_packet(dev);
1161                                 lp->stats.rx_dropped++;
1162                         }
1163                 }
1164                 else {   /* Ok so now we should have a good packet */
1165                         struct sk_buff *skb;
1166
1167                         skb = dev_alloc_skb(pkt_len + 3);
1168                         if( skb == NULL ) {
1169                                 printk(KERN_WARNING "%s: Could'n allocate memory for packet (len %d)\n",
1170                                        dev->name, pkt_len);
1171                                 eth16i_skip_packet(dev);
1172                                 lp->stats.rx_dropped++;
1173                                 break;
1174                         }
1175
1176                         skb_reserve(skb,2);
1177
1178                         /*
1179                            Now let's get the packet out of buffer.
1180                            size is (pkt_len + 1) >> 1, cause we are now reading words
1181                            and it have to be even aligned.
1182                            */
1183
1184                         if(ioaddr < 0x1000)
1185                                 insw(ioaddr + DATAPORT, skb_put(skb, pkt_len),
1186                                      (pkt_len + 1) >> 1);
1187                         else {
1188                                 unsigned char *buf = skb_put(skb, pkt_len);
1189                                 unsigned char frag = pkt_len % 4;
1190
1191                                 insl(ioaddr + DATAPORT, buf, pkt_len >> 2);
1192
1193                                 if(frag != 0) {
1194                                         unsigned short rest[2];
1195                                         rest[0] = inw( ioaddr + DATAPORT );
1196                                         if(frag == 3)
1197                                                 rest[1] = inw( ioaddr + DATAPORT );
1198
1199                                         memcpy(buf + (pkt_len & 0xfffc), (char *)rest, frag);
1200                                 }
1201                         }
1202
1203                         skb->protocol=eth_type_trans(skb, dev);
1204
1205                         if( eth16i_debug > 5 ) {
1206                                 int i;
1207                                 printk(KERN_DEBUG "%s: Received packet of length %d.\n",
1208                                        dev->name, pkt_len);
1209                                 for(i = 0; i < 14; i++)
1210                                         printk(KERN_DEBUG " %02x", skb->data[i]);
1211                                 printk(KERN_DEBUG ".\n");
1212                         }
1213                         netif_rx(skb);
1214                         dev->last_rx = jiffies;
1215                         lp->stats.rx_packets++;
1216                         lp->stats.rx_bytes += pkt_len;
1217
1218                 } /* else */
1219
1220                 if(--boguscount <= 0)
1221                         break;
1222
1223         } /* while */
1224 }
1225
1226 static irqreturn_t eth16i_interrupt(int irq, void *dev_id)
1227 {
1228         struct net_device *dev = dev_id;
1229         struct eth16i_local *lp;
1230         int ioaddr = 0, status;
1231         int handled = 0;
1232
1233         ioaddr = dev->base_addr;
1234         lp = netdev_priv(dev);
1235
1236         /* Turn off all interrupts from adapter */
1237         outw(ETH16I_INTR_OFF, ioaddr + TX_INTR_REG);
1238
1239         /* eth16i_tx won't be called */
1240         spin_lock(&lp->lock);
1241
1242         status = inw(ioaddr + TX_STATUS_REG);      /* Get the status */
1243         outw(status, ioaddr + TX_STATUS_REG);      /* Clear status bits */
1244
1245         if (status)
1246                 handled = 1;
1247
1248         if(eth16i_debug > 3)
1249                 printk(KERN_DEBUG "%s: Interrupt with status %04x.\n", dev->name, status);
1250
1251         if( status & 0x7f00 ) {
1252
1253                 lp->stats.rx_errors++;
1254
1255                 if(status & (BUS_RD_ERR << 8) )
1256                         printk(KERN_WARNING "%s: Bus read error.\n",dev->name);
1257                 if(status & (SHORT_PKT_ERR << 8) )   lp->stats.rx_length_errors++;
1258                 if(status & (ALIGN_ERR << 8) )       lp->stats.rx_frame_errors++;
1259                 if(status & (CRC_ERR << 8) )        lp->stats.rx_crc_errors++;
1260                 if(status & (RX_BUF_OVERFLOW << 8) ) lp->stats.rx_over_errors++;
1261         }
1262         if( status & 0x001a) {
1263
1264                 lp->stats.tx_errors++;
1265
1266                 if(status & CR_LOST) lp->stats.tx_carrier_errors++;
1267                 if(status & TX_JABBER_ERR) lp->stats.tx_window_errors++;
1268
1269 #if 0
1270                 if(status & COLLISION) {
1271                         lp->stats.collisions +=
1272                                 ((inb(ioaddr+TRANSMIT_MODE_REG) & 0xF0) >> 4);
1273                 }
1274 #endif
1275                 if(status & COLLISIONS_16) {
1276                         if(lp->col_16 < MAX_COL_16) {
1277                                 lp->col_16++;
1278                                 lp->stats.collisions++;
1279                                 /* Resume transmitting, skip failed packet */
1280                                 outb(0x02, ioaddr + COL_16_REG);
1281                         }
1282                         else {
1283                                 printk(KERN_WARNING "%s: bailing out due to many consecutive 16-in-a-row collisions. Network cable problem?\n", dev->name);
1284                         }
1285                 }
1286         }
1287
1288         if( status & 0x00ff ) {          /* Let's check the transmit status reg */
1289
1290                 if(status & TX_DONE) {         /* The transmit has been done */
1291                         lp->stats.tx_packets = lp->tx_buffered_packets;
1292                         lp->stats.tx_bytes += lp->tx_buffered_bytes;
1293                         lp->col_16 = 0;
1294
1295                         if(lp->tx_queue) {           /* Is there still packets ? */
1296                                 /* There was packet(s) so start transmitting and write also
1297                                    how many packets there is to be sended */
1298                                 outb(TX_START | lp->tx_queue, ioaddr + TRANSMIT_START_REG);
1299                                 lp->tx_queue = 0;
1300                                 lp->tx_queue_len = 0;
1301                                 lp->tx_started = 1;
1302                         }
1303                         else {
1304                                 lp->tx_started = 0;
1305                         }
1306                         netif_wake_queue(dev);
1307                 }
1308         }
1309
1310         if( ( status & 0x8000 ) ||
1311             ( (inb(ioaddr + RECEIVE_MODE_REG) & RX_BUFFER_EMPTY) == 0) ) {
1312                 eth16i_rx(dev);  /* We have packet in receive buffer */
1313         }
1314
1315         /* Turn interrupts back on */
1316         outw(ETH16I_INTR_ON, ioaddr + TX_INTR_REG);
1317
1318         if(lp->tx_queue_len < lp->tx_buf_size - (ETH_FRAME_LEN + 2)) {
1319                 /* There is still more room for one more packet in tx buffer */
1320                 netif_wake_queue(dev);
1321         }
1322
1323         spin_unlock(&lp->lock);
1324
1325         return IRQ_RETVAL(handled);
1326 }
1327
1328 static void eth16i_skip_packet(struct net_device *dev)
1329 {
1330         int ioaddr = dev->base_addr;
1331
1332         inw(ioaddr + DATAPORT);
1333         inw(ioaddr + DATAPORT);
1334         inw(ioaddr + DATAPORT);
1335
1336         outb(SKIP_RX_PACKET, ioaddr + FILTER_SELF_RX_REG);
1337         while( inb( ioaddr + FILTER_SELF_RX_REG ) != 0);
1338 }
1339
1340 static void eth16i_reset(struct net_device *dev)
1341 {
1342         struct eth16i_local *lp = netdev_priv(dev);
1343         int ioaddr = dev->base_addr;
1344
1345         if(eth16i_debug > 1)
1346                 printk(KERN_DEBUG "%s: Resetting device.\n", dev->name);
1347
1348         BITSET(ioaddr + CONFIG_REG_0, DLC_EN);
1349         outw(0xffff, ioaddr + TX_STATUS_REG);
1350         eth16i_select_regbank(2, ioaddr);
1351
1352         lp->tx_started = 0;
1353         lp->tx_buf_busy = 0;
1354         lp->tx_queue = 0;
1355         lp->tx_queue_len = 0;
1356         BITCLR(ioaddr + CONFIG_REG_0, DLC_EN);
1357 }
1358
1359 static void eth16i_multicast(struct net_device *dev)
1360 {
1361         int ioaddr = dev->base_addr;
1362
1363         if(dev->mc_count || dev->flags&(IFF_ALLMULTI|IFF_PROMISC))
1364         {
1365                 dev->flags|=IFF_PROMISC;        /* Must do this */
1366                 outb(3, ioaddr + RECEIVE_MODE_REG);
1367         } else {
1368                 outb(2, ioaddr + RECEIVE_MODE_REG);
1369         }
1370 }
1371
1372 static struct net_device_stats *eth16i_get_stats(struct net_device *dev)
1373 {
1374         struct eth16i_local *lp = netdev_priv(dev);
1375         return &lp->stats;
1376 }
1377
1378 static void eth16i_select_regbank(unsigned char banknbr, int ioaddr)
1379 {
1380         unsigned char data;
1381
1382         data = inb(ioaddr + CONFIG_REG_1);
1383         outb( ((data & 0xF3) | ( (banknbr & 0x03) << 2)), ioaddr + CONFIG_REG_1);
1384 }
1385
1386 #ifdef MODULE
1387
1388 static ushort eth16i_parse_mediatype(const char* s)
1389 {
1390         if(!s)
1391                 return E_PORT_FROM_EPROM;
1392
1393         if (!strncmp(s, "bnc", 3))
1394                 return E_PORT_BNC;
1395         else if (!strncmp(s, "tp", 2))
1396                 return E_PORT_TP;
1397         else if (!strncmp(s, "dix", 3))
1398                 return E_PORT_DIX;
1399         else if (!strncmp(s, "auto", 4))
1400                 return E_PORT_AUTO;
1401         else
1402                 return E_PORT_FROM_EPROM;
1403 }
1404
1405 #define MAX_ETH16I_CARDS 4  /* Max number of Eth16i cards per module */
1406
1407 static struct net_device *dev_eth16i[MAX_ETH16I_CARDS];
1408 static int io[MAX_ETH16I_CARDS];
1409 #if 0
1410 static int irq[MAX_ETH16I_CARDS];
1411 #endif
1412 static char* mediatype[MAX_ETH16I_CARDS];
1413 static int debug = -1;
1414
1415 MODULE_AUTHOR("Mika Kuoppala <miku@iki.fi>");
1416 MODULE_DESCRIPTION("ICL EtherTeam 16i/32 driver");
1417 MODULE_LICENSE("GPL");
1418
1419
1420 module_param_array(io, int, NULL, 0);
1421 MODULE_PARM_DESC(io, "eth16i I/O base address(es)");
1422
1423 #if 0
1424 module_param_array(irq, int, NULL, 0);
1425 MODULE_PARM_DESC(irq, "eth16i interrupt request number");
1426 #endif
1427
1428 module_param_array(mediatype, charp, NULL, 0);
1429 MODULE_PARM_DESC(mediatype, "eth16i media type of interface(s) (bnc,tp,dix,auto,eprom)");
1430
1431 module_param(debug, int, 0);
1432 MODULE_PARM_DESC(debug, "eth16i debug level (0-6)");
1433
1434 int __init init_module(void)
1435 {
1436         int this_dev, found = 0;
1437         struct net_device *dev;
1438
1439         for (this_dev = 0; this_dev < MAX_ETH16I_CARDS; this_dev++) {
1440                 dev = alloc_etherdev(sizeof(struct eth16i_local));
1441                 if (!dev)
1442                         break;
1443
1444                 dev->base_addr = io[this_dev];
1445
1446                 if(debug != -1)
1447                         eth16i_debug = debug;
1448
1449                 if(eth16i_debug > 1)
1450                         printk(KERN_NOTICE "eth16i(%d): interface type %s\n", this_dev, mediatype[this_dev] ? mediatype[this_dev] : "none" );
1451
1452                 dev->if_port = eth16i_parse_mediatype(mediatype[this_dev]);
1453
1454                 if(io[this_dev] == 0) {
1455                         if(this_dev != 0) /* Only autoprobe 1st one */
1456                                 break;
1457
1458                         printk(KERN_NOTICE "eth16i.c: Presently autoprobing (not recommended) for a single card.\n");
1459                 }
1460
1461                 if (do_eth16i_probe(dev) == 0) {
1462                         dev_eth16i[found++] = dev;
1463                         continue;
1464                 }
1465                 printk(KERN_WARNING "eth16i.c No Eth16i card found (i/o = 0x%x).\n",
1466                        io[this_dev]);
1467                 free_netdev(dev);
1468                 break;
1469         }
1470         if (found)
1471                 return 0;
1472         return -ENXIO;
1473 }
1474
1475 void __exit cleanup_module(void)
1476 {
1477         int this_dev;
1478
1479         for(this_dev = 0; this_dev < MAX_ETH16I_CARDS; this_dev++) {
1480                 struct net_device *dev = dev_eth16i[this_dev];
1481
1482                 if(dev->priv) {
1483                         unregister_netdev(dev);
1484                         free_irq(dev->irq, dev);
1485                         release_region(dev->base_addr, ETH16I_IO_EXTENT);
1486                         free_netdev(dev);
1487                 }
1488         }
1489 }
1490 #endif /* MODULE */
1491
1492 /*
1493  * Local variables:
1494  *  compile-command: "gcc -DMODULE -D__KERNEL__ -Wall -Wstrict-prototypes -O6 -c eth16i.c"
1495  *  alt-compile-command: "gcc -DMODVERSIONS -DMODULE -D__KERNEL__ -Wall -Wstrict -prototypes -O6 -c eth16i.c"
1496  *  tab-width: 8
1497  *  c-basic-offset: 8
1498  *  c-indent-level: 8
1499  * End:
1500  */
1501
1502 /* End of file eth16i.c */