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