1 /* znet.c: An Zenith Z-Note ethernet driver for linux. */
2
3 static const char *version = "znet.c:v1.02 9/23/94 becker@cesdis.gsfc.nasa.gov\n";
4
5 /*
6 Written by Donald Becker.
7
8 The author may be reached as becker@cesdis.gsfc.nasa.gov.
9 This driver is based on the Linux skeleton driver. The copyright of the
10 skeleton driver is held by the United States Government, as represented
11 by DIRNSA, and it is released under the GPL.
12
13 Thanks to Mike Hollick for alpha testing and suggestions.
14
15 References:
16 The Crynwr packet driver.
17
18 "82593 CSMA/CD Core LAN Controller" Intel datasheet, 1992
19 Intel Microcommunications Databook, Vol. 1, 1990.
20 As usual with Intel, the documentation is incomplete and inaccurate.
21 I had to read the Crynwr packet driver to figure out how to actually
22 use the i82593, and guess at what register bits matched the loosely
23 related i82586.
24
25 Theory of Operation
26
27 The i82593 used in the Zenith Z-Note series operates using two(!) slave
28 DMA channels, one interrupt, and one 8-bit I/O port.
29
30 While there several ways to configure '593 DMA system, I chose the one
31 that seemed commensurate with the highest system performance in the face
32 of moderate interrupt latency: Both DMA channels are configured as
33 recirculating ring buffers, with one channel (#0) dedicated to Rx and
34 the other channel (#1) to Tx and configuration. (Note that this is
35 different than the Crynwr driver, where the Tx DMA channel is initialized
36 before each operation. That approach simplifies operation and Tx error
37 recovery, but requires additional I/O in normal operation and precludes
38 transmit buffer chaining.)
39
40 Both rings are set to 8192 bytes using {TX,RX}_RING_SIZE. This provides
41 a reasonable ring size for Rx, while simplifying DMA buffer allocation --
42 DMA buffers must not cross a 128K boundary. (In truth the size selection
43 was influenced by my lack of '593 documentation. I thus was constrained
44 to use the Crynwr '593 initialization table, which sets the Rx ring size
45 to 8K.)
46
47 Despite my usual low opinion about Intel-designed parts, I must admit
48 that the bulk data handling of the i82593 is a good design for
49 an integrated system, like a laptop, where using two slave DMA channels
50 doesn't pose a problem. I still take issue with using only a single I/O
51 port. In the same controlled environment there are essentially no
52 limitations on I/O space, and using multiple locations would eliminate
53 the need for multiple operations when looking at status registers,
54 setting the Rx ring boundary, or switching to promiscuous mode.
55
56 I also question Zenith's selection of the '593: one of the advertised
57 advantages of earlier Intel parts was that if you figured out the magic
58 initialization incantation you could use the same part on many different
59 network types. Zenith's use of the "FriendlyNet" (sic) connector rather
60 than an on-board transceiver leads me to believe that they were planning
61 to take advantage of this. But, uhmmm, the '593 omits all but ethernet
62 functionality from the serial subsystem.
63 */
64
65 #include <linux/kernel.h>
66 #include <linux/sched.h>
67 #include <linux/string.h>
68 #include <linux/ptrace.h>
69 #include <linux/errno.h>
70 #include <linux/interrupt.h>
71 #include <linux/ioport.h>
72 #include <linux/init.h>
73 #include <asm/system.h>
74 #include <asm/bitops.h>
75 #include <asm/io.h>
76 #include <asm/dma.h>
77
78 #include <linux/netdevice.h>
79 #include <linux/etherdevice.h>
80 #include <linux/skbuff.h>
81 #include <linux/if_arp.h>
82
83 #ifndef ZNET_DEBUG
84 #define ZNET_DEBUG 1
85 #endif
86 static unsigned int znet_debug = ZNET_DEBUG;
87
88 /* The DMA modes we need aren't in <dma.h>. */
89 #define DMA_RX_MODE 0x14 /* Auto init, I/O to mem, ++, demand. */
90 #define DMA_TX_MODE 0x18 /* Auto init, Mem to I/O, ++, demand. */
91 #define dma_page_eq(ptr1, ptr2) ((long)(ptr1)>>17 == (long)(ptr2)>>17)
92 #define DMA_BUF_SIZE 8192
93 #define RX_BUF_SIZE 8192
94 #define TX_BUF_SIZE 8192
95
96 /* Commands to the i82593 channel 0. */
97 #define CMD0_CHNL_0 0x00
98 #define CMD0_CHNL_1 0x10 /* Switch to channel 1. */
99 #define CMD0_NOP (CMD0_CHNL_0)
100 #define CMD0_PORT_1 CMD0_CHNL_1
101 #define CMD1_PORT_0 1
102 #define CMD0_IA_SETUP 1
103 #define CMD0_CONFIGURE 2
104 #define CMD0_MULTICAST_LIST 3
105 #define CMD0_TRANSMIT 4
106 #define CMD0_DUMP 6
107 #define CMD0_DIAGNOSE 7
108 #define CMD0_Rx_ENABLE 8
109 #define CMD0_Rx_DISABLE 10
110 #define CMD0_Rx_STOP 11
111 #define CMD0_RETRANSMIT 12
112 #define CMD0_ABORT 13
113 #define CMD0_RESET 14
114
115 #define CMD0_ACK 0x80
116
117 #define CMD0_STAT0 (0 << 5)
118 #define CMD0_STAT1 (1 << 5)
119 #define CMD0_STAT2 (2 << 5)
120 #define CMD0_STAT3 (3 << 5)
121
122 #define TX_TIMEOUT 10
123
124 #define net_local znet_private
125 struct znet_private {
126 int rx_dma, tx_dma;
127 struct net_device_stats stats;
128 spinlock_t lock;
129 /* The starting, current, and end pointers for the packet buffers. */
130 ushort *rx_start, *rx_cur, *rx_end;
131 ushort *tx_start, *tx_cur, *tx_end;
132 ushort tx_buf_len; /* Tx buffer length, in words. */
133 };
134
135 /* Only one can be built-in;-> */
136 static struct znet_private zn;
137 static ushort dma_buffer1[DMA_BUF_SIZE/2];
138 static ushort dma_buffer2[DMA_BUF_SIZE/2];
139 static ushort dma_buffer3[DMA_BUF_SIZE/2 + 8];
140
141 /* The configuration block. What an undocumented nightmare. The first
142 set of values are those suggested (without explanation) for ethernet
143 in the Intel 82586 databook. The rest appear to be completely undocumented,
144 except for cryptic notes in the Crynwr packet driver. This driver uses
145 the Crynwr values verbatim. */
146
147 static unsigned char i593_init[] = {
148 0xAA, /* 0: 16-byte input & 80-byte output FIFO. */
149 /* threshold, 96-byte FIFO, 82593 mode. */
150 0x88, /* 1: Continuous w/interrupts, 128-clock DMA.*/
151 0x2E, /* 2: 8-byte preamble, NO address insertion, */
152 /* 6-byte Ethernet address, loopback off.*/
153 0x00, /* 3: Default priorities & backoff methods. */
154 0x60, /* 4: 96-bit interframe spacing. */
155 0x00, /* 5: 512-bit slot time (low-order). */
156 0xF2, /* 6: Slot time (high-order), 15 COLL retries. */
157 0x00, /* 7: Promisc-off, broadcast-on, default CRC. */
158 0x00, /* 8: Default carrier-sense, collision-detect. */
159 0x40, /* 9: 64-byte minimum frame length. */
160 0x5F, /* A: Type/length checks OFF, no CRC input,
161 "jabber" termination, etc. */
162 0x00, /* B: Full-duplex disabled. */
163 0x3F, /* C: Default multicast addresses & backoff. */
164 0x07, /* D: Default IFS retriggering. */
165 0x31, /* E: Internal retransmit, drop "runt" packets,
166 synchr. DRQ deassertion, 6 status bytes. */
167 0x22, /* F: Receive ring-buffer size (8K),
168 receive-stop register enable. */
169 };
170
171 struct netidblk {
172 char magic[8]; /* The magic number (string) "NETIDBLK" */
173 unsigned char netid[8]; /* The physical station address */
174 char nettype, globalopt;
175 char vendor[8]; /* The machine vendor and product name. */
176 char product[8];
177 char irq1, irq2; /* Interrupts, only one is currently used. */
178 char dma1, dma2;
179 short dma_mem_misc[8]; /* DMA buffer locations (unused in Linux). */
180 short iobase1, iosize1;
181 short iobase2, iosize2; /* Second iobase unused. */
182 char driver_options; /* Misc. bits */
183 char pad;
184 };
185
186 int znet_probe(struct net_device *dev);
187 static int znet_open(struct net_device *dev);
188 static int znet_send_packet(struct sk_buff *skb, struct net_device *dev);
189 static void znet_interrupt(int irq, void *dev_id, struct pt_regs *regs);
190 static void znet_rx(struct net_device *dev);
191 static int znet_close(struct net_device *dev);
192 static struct net_device_stats *net_get_stats(struct net_device *dev);
193 static void set_multicast_list(struct net_device *dev);
194 static void hardware_init(struct net_device *dev);
195 static void update_stop_hit(short ioaddr, unsigned short rx_stop_offset);
196 static void znet_tx_timeout (struct net_device *dev);
197
198 #ifdef notdef
199 static struct sigaction znet_sigaction = { &znet_interrupt, 0, 0, NULL, };
200 #endif
201
202
203 /* The Z-Note probe is pretty easy. The NETIDBLK exists in the safe-to-probe
204 BIOS area. We just scan for the signature, and pull the vital parameters
205 out of the structure. */
206
207 int __init znet_probe(struct net_device *dev)
208 {
209 int i;
210 struct netidblk *netinfo;
211 char *p;
212
213 /* This code scans the region 0xf0000 to 0xfffff for a "NETIDBLK". */
214 for(p = (char *)phys_to_virt(0xf0000); p < (char *)phys_to_virt(0x100000); p++)
215 if (*p == 'N' && strncmp(p, "NETIDBLK", 8) == 0)
216 break;
217
218 if (p >= (char *)phys_to_virt(0x100000)) {
219 if (znet_debug > 1)
220 printk(KERN_INFO "No Z-Note ethernet adaptor found.\n");
221 return -ENODEV;
222 }
223 netinfo = (struct netidblk *)p;
224 dev->base_addr = netinfo->iobase1;
225 dev->irq = netinfo->irq1;
226
227 printk(KERN_INFO "%s: ZNET at %#3lx,", dev->name, dev->base_addr);
228
229 /* The station address is in the "netidblk" at 0x0f0000. */
230 for (i = 0; i < 6; i++)
231 printk(" %2.2x", dev->dev_addr[i] = netinfo->netid[i]);
232
233 printk(", using IRQ %d DMA %d and %d.\n", dev->irq, netinfo->dma1,
234 netinfo->dma2);
235
236 if (znet_debug > 1) {
237 printk(KERN_INFO "%s: vendor '%16.16s' IRQ1 %d IRQ2 %d DMA1 %d DMA2 %d.\n",
238 dev->name, netinfo->vendor,
239 netinfo->irq1, netinfo->irq2,
240 netinfo->dma1, netinfo->dma2);
241 printk(KERN_INFO "%s: iobase1 %#x size %d iobase2 %#x size %d net type %2.2x.\n",
242 dev->name, netinfo->iobase1, netinfo->iosize1,
243 netinfo->iobase2, netinfo->iosize2, netinfo->nettype);
244 }
245
246 if (znet_debug > 0)
247 printk("%s%s", KERN_INFO, version);
248
249 dev->priv = (void *) &zn;
250 zn.rx_dma = netinfo->dma1;
251 zn.tx_dma = netinfo->dma2;
252 zn.lock = SPIN_LOCK_UNLOCKED;
253
254 /* These should never fail. You can't add devices to a sealed box! */
255 if (request_irq(dev->irq, &znet_interrupt, 0, "ZNet", dev)
256 || request_dma(zn.rx_dma,"ZNet rx")
257 || request_dma(zn.tx_dma,"ZNet tx")) {
258 printk(KERN_WARNING "%s: Not opened -- resource busy?!?\n", dev->name);
259 return -EBUSY;
260 }
261
262 /* Allocate buffer memory. We can cross a 128K boundary, so we
263 must be careful about the allocation. It's easiest to waste 8K. */
264 if (dma_page_eq(dma_buffer1, &dma_buffer1[RX_BUF_SIZE/2-1]))
265 zn.rx_start = dma_buffer1;
266 else
267 zn.rx_start = dma_buffer2;
268
269 if (dma_page_eq(dma_buffer3, &dma_buffer3[RX_BUF_SIZE/2-1]))
270 zn.tx_start = dma_buffer3;
271 else
272 zn.tx_start = dma_buffer2;
273 zn.rx_end = zn.rx_start + RX_BUF_SIZE/2;
274 zn.tx_buf_len = TX_BUF_SIZE/2;
275 zn.tx_end = zn.tx_start + zn.tx_buf_len;
276
277 /* The ZNET-specific entries in the device structure. */
278 dev->open = &znet_open;
279 dev->hard_start_xmit = &znet_send_packet;
280 dev->stop = &znet_close;
281 dev->get_stats = net_get_stats;
282 dev->set_multicast_list = &set_multicast_list;
283 dev->tx_timeout = znet_tx_timeout;
284 dev->watchdog_timeo = TX_TIMEOUT;
285
286 /* Fill in the 'dev' with ethernet-generic values. */
287 ether_setup(dev);
288
289 return 0;
290 }
291
292
293 static int znet_open(struct net_device *dev)
294 {
295 int ioaddr = dev->base_addr;
296
297 if (znet_debug > 2)
298 printk(KERN_DEBUG "%s: znet_open() called.\n", dev->name);
299
300 /* Turn on the 82501 SIA, using zenith-specific magic. */
301 outb(0x10, 0xe6); /* Select LAN control register */
302 outb(inb(0xe7) | 0x84, 0xe7); /* Turn on LAN power (bit 2). */
303 /* According to the Crynwr driver we should wait 50 msec. for the
304 LAN clock to stabilize. My experiments indicates that the '593 can
305 be initialized immediately. The delay is probably needed for the
306 DC-to-DC converter to come up to full voltage, and for the oscillator
307 to be spot-on at 20Mhz before transmitting.
308 Until this proves to be a problem we rely on the higher layers for the
309 delay and save allocating a timer entry. */
310
311 /* This follows the packet driver's lead, and checks for success. */
312 if (inb(ioaddr) != 0x10 && inb(ioaddr) != 0x00)
313 printk(KERN_WARNING "%s: Problem turning on the transceiver power.\n",
314 dev->name);
315
316 hardware_init(dev);
317 netif_start_queue (dev);
318
319 return 0;
320 }
321
322
323 static void znet_tx_timeout (struct net_device *dev)
324 {
325 int ioaddr = dev->base_addr;
326 ushort event, tx_status, rx_offset, state;
327
328 outb (CMD0_STAT0, ioaddr);
329 event = inb (ioaddr);
330 outb (CMD0_STAT1, ioaddr);
331 tx_status = inw (ioaddr);
332 outb (CMD0_STAT2, ioaddr);
333 rx_offset = inw (ioaddr);
334 outb (CMD0_STAT3, ioaddr);
335 state = inb (ioaddr);
336 printk (KERN_WARNING "%s: transmit timed out, status %02x %04x %04x %02x,"
337 " resetting.\n", dev->name, event, tx_status, rx_offset, state);
338 if (tx_status == 0x0400)
339 printk (KERN_WARNING "%s: Tx carrier error, check transceiver cable.\n",
340 dev->name);
341 outb (CMD0_RESET, ioaddr);
342 hardware_init (dev);
343 netif_start_queue (dev);
344 }
345
346 static int znet_send_packet(struct sk_buff *skb, struct net_device *dev)
347 {
348 int ioaddr = dev->base_addr;
349 struct net_local *lp = (struct net_local *)dev->priv;
350 unsigned long flags;
351
352 if (znet_debug > 4)
353 printk(KERN_DEBUG "%s: ZNet_send_packet.\n", dev->name);
354
355 netif_stop_queue (dev);
356
357 /* Check that the part hasn't reset itself, probably from suspend. */
358 outb(CMD0_STAT0, ioaddr);
359 if (inw(ioaddr) == 0x0010
360 && inw(ioaddr) == 0x0000
361 && inw(ioaddr) == 0x0010)
362 hardware_init(dev);
363
364 if (1) {
365 short length = ETH_ZLEN < skb->len ? skb->len : ETH_ZLEN;
366 unsigned char *buf = (void *)skb->data;
367 ushort *tx_link = zn.tx_cur - 1;
368 ushort rnd_len = (length + 1)>>1;
369
370 lp->stats.tx_bytes+=length;
371
372 {
373 short dma_port = ((zn.tx_dma&3)<<2) + IO_DMA2_BASE;
374 unsigned addr = inb(dma_port);
375 addr |= inb(dma_port) << 8;
376 addr <<= 1;
377 if (((int)zn.tx_cur & 0x1ffff) != addr)
378 printk(KERN_WARNING "Address mismatch at Tx: %#x vs %#x.\n",
379 (int)zn.tx_cur & 0xffff, addr);
380 zn.tx_cur = (ushort *)(((int)zn.tx_cur & 0xfe0000) | addr);
381 }
382
383 if (zn.tx_cur >= zn.tx_end)
384 zn.tx_cur = zn.tx_start;
385 *zn.tx_cur++ = length;
386 if (zn.tx_cur + rnd_len + 1 > zn.tx_end) {
387 int semi_cnt = (zn.tx_end - zn.tx_cur)<<1; /* Cvrt to byte cnt. */
388 memcpy(zn.tx_cur, buf, semi_cnt);
389 rnd_len -= semi_cnt>>1;
390 memcpy(zn.tx_start, buf + semi_cnt, length - semi_cnt);
391 zn.tx_cur = zn.tx_start + rnd_len;
392 } else {
393 memcpy(zn.tx_cur, buf, skb->len);
394 zn.tx_cur += rnd_len;
395 }
396 *zn.tx_cur++ = 0;
397
398 spin_lock_irqsave(&lp->lock, flags);
399 {
400 *tx_link = CMD0_TRANSMIT + CMD0_CHNL_1;
401 /* Is this always safe to do? */
402 outb(CMD0_TRANSMIT + CMD0_CHNL_1,ioaddr);
403 }
404 spin_unlock_irqrestore (&lp->lock, flags);
405
406 dev->trans_start = jiffies;
407 netif_start_queue (dev);
408
409 if (znet_debug > 4)
410 printk(KERN_DEBUG "%s: Transmitter queued, length %d.\n", dev->name, length);
411 }
412 dev_kfree_skb(skb);
413 return 0;
414 }
415
416 /* The ZNET interrupt handler. */
417 static void znet_interrupt(int irq, void *dev_id, struct pt_regs * regs)
418 {
419 struct net_device *dev = dev_id;
420 struct net_local *lp = (struct net_local *)dev->priv;
421 int ioaddr;
422 int boguscnt = 20;
423
424 if (dev == NULL) {
425 printk(KERN_WARNING "znet_interrupt(): IRQ %d for unknown device.\n", irq);
426 return;
427 }
428
429 spin_lock (&lp->lock);
430
431 ioaddr = dev->base_addr;
432
433 outb(CMD0_STAT0, ioaddr);
434 do {
435 ushort status = inb(ioaddr);
436 if (znet_debug > 5) {
437 ushort result, rx_ptr, running;
438 outb(CMD0_STAT1, ioaddr);
439 result = inw(ioaddr);
440 outb(CMD0_STAT2, ioaddr);
441 rx_ptr = inw(ioaddr);
442 outb(CMD0_STAT3, ioaddr);
443 running = inb(ioaddr);
444 printk(KERN_DEBUG "%s: interrupt, status %02x, %04x %04x %02x serial %d.\n",
445 dev->name, status, result, rx_ptr, running, boguscnt);
446 }
447 if ((status & 0x80) == 0)
448 break;
449
450 if ((status & 0x0F) == 4) { /* Transmit done. */
451 int tx_status;
452 outb(CMD0_STAT1, ioaddr);
453 tx_status = inw(ioaddr);
454 /* It's undocumented, but tx_status seems to match the i82586. */
455 if (tx_status & 0x2000) {
456 lp->stats.tx_packets++;
457 lp->stats.collisions += tx_status & 0xf;
458 } else {
459 if (tx_status & 0x0600) lp->stats.tx_carrier_errors++;
460 if (tx_status & 0x0100) lp->stats.tx_fifo_errors++;
461 if (!(tx_status & 0x0040)) lp->stats.tx_heartbeat_errors++;
462 if (tx_status & 0x0020) lp->stats.tx_aborted_errors++;
463 /* ...and the catch-all. */
464 if ((tx_status | 0x0760) != 0x0760)
465 lp->stats.tx_errors++;
466 }
467 netif_wake_queue (dev);
468 }
469
470 if ((status & 0x40)
471 || (status & 0x0f) == 11) {
472 znet_rx(dev);
473 }
474 /* Clear the interrupts we've handled. */
475 outb(CMD0_ACK,ioaddr);
476 } while (boguscnt--);
477
478 spin_unlock (&lp->lock);
479
480 return;
481 }
482
483 static void znet_rx(struct net_device *dev)
484 {
485 struct net_local *lp = (struct net_local *)dev->priv;
486 int ioaddr = dev->base_addr;
487 int boguscount = 1;
488 short next_frame_end_offset = 0; /* Offset of next frame start. */
489 short *cur_frame_end;
490 short cur_frame_end_offset;
491
492 outb(CMD0_STAT2, ioaddr);
493 cur_frame_end_offset = inw(ioaddr);
494
495 if (cur_frame_end_offset == zn.rx_cur - zn.rx_start) {
496 printk(KERN_WARNING "%s: Interrupted, but nothing to receive, offset %03x.\n",
497 dev->name, cur_frame_end_offset);
498 return;
499 }
500
501 /* Use same method as the Crynwr driver: construct a forward list in
502 the same area of the backwards links we now have. This allows us to
503 pass packets to the upper layers in the order they were received --
504 important for fast-path sequential operations. */
505 while (zn.rx_start + cur_frame_end_offset != zn.rx_cur
506 && ++boguscount < 5) {
507 unsigned short hi_cnt, lo_cnt, hi_status, lo_status;
508 int count, status;
509
510 if (cur_frame_end_offset < 4) {
511 /* Oh no, we have a special case: the frame trailer wraps around
512 the end of the ring buffer. We've saved space at the end of
513 the ring buffer for just this problem. */
514 memcpy(zn.rx_end, zn.rx_start, 8);
515 cur_frame_end_offset += (RX_BUF_SIZE/2);
516 }
517 cur_frame_end = zn.rx_start + cur_frame_end_offset - 4;
518
519 lo_status = *cur_frame_end++;
520 hi_status = *cur_frame_end++;
521 status = ((hi_status & 0xff) << 8) + (lo_status & 0xff);
522 lo_cnt = *cur_frame_end++;
523 hi_cnt = *cur_frame_end++;
524 count = ((hi_cnt & 0xff) << 8) + (lo_cnt & 0xff);
525
526 if (znet_debug > 5)
527 printk(KERN_DEBUG "Constructing trailer at location %03x, %04x %04x %04x %04x"
528 " count %#x status %04x.\n",
529 cur_frame_end_offset<<1, lo_status, hi_status, lo_cnt, hi_cnt,
530 count, status);
531 cur_frame_end[-4] = status;
532 cur_frame_end[-3] = next_frame_end_offset;
533 cur_frame_end[-2] = count;
534 next_frame_end_offset = cur_frame_end_offset;
535 cur_frame_end_offset -= ((count + 1)>>1) + 3;
536 if (cur_frame_end_offset < 0)
537 cur_frame_end_offset += RX_BUF_SIZE/2;
538 };
539
540 /* Now step forward through the list. */
541 do {
542 ushort *this_rfp_ptr = zn.rx_start + next_frame_end_offset;
543 int status = this_rfp_ptr[-4];
544 int pkt_len = this_rfp_ptr[-2];
545
546 if (znet_debug > 5)
547 printk(KERN_DEBUG "Looking at trailer ending at %04x status %04x length %03x"
548 " next %04x.\n", next_frame_end_offset<<1, status, pkt_len,
549 this_rfp_ptr[-3]<<1);
550 /* Once again we must assume that the i82586 docs apply. */
551 if ( ! (status & 0x2000)) { /* There was an error. */
552 lp->stats.rx_errors++;
553 if (status & 0x0800) lp->stats.rx_crc_errors++;
554 if (status & 0x0400) lp->stats.rx_frame_errors++;
555 if (status & 0x0200) lp->stats.rx_over_errors++; /* Wrong. */
556 if (status & 0x0100) lp->stats.rx_fifo_errors++;
557 if (status & 0x0080) lp->stats.rx_length_errors++;
558 } else if (pkt_len > 1536) {
559 lp->stats.rx_length_errors++;
560 } else {
561 /* Malloc up new buffer. */
562 struct sk_buff *skb;
563
564 skb = dev_alloc_skb(pkt_len);
565 if (skb == NULL) {
566 if (znet_debug)
567 printk(KERN_WARNING "%s: Memory squeeze, dropping packet.\n", dev->name);
568 lp->stats.rx_dropped++;
569 break;
570 }
571 skb->dev = dev;
572
573 if (&zn.rx_cur[(pkt_len+1)>>1] > zn.rx_end) {
574 int semi_cnt = (zn.rx_end - zn.rx_cur)<<1;
575 memcpy(skb_put(skb,semi_cnt), zn.rx_cur, semi_cnt);
576 memcpy(skb_put(skb,pkt_len-semi_cnt), zn.rx_start,
577 pkt_len - semi_cnt);
578 } else {
579 memcpy(skb_put(skb,pkt_len), zn.rx_cur, pkt_len);
580 if (znet_debug > 6) {
581 unsigned int *packet = (unsigned int *) skb->data;
582 printk(KERN_DEBUG "Packet data is %08x %08x %08x %08x.\n", packet[0],
583 packet[1], packet[2], packet[3]);
584 }
585 }
586 skb->protocol=eth_type_trans(skb,dev);
587 netif_rx(skb);
588 lp->stats.rx_packets++;
589 }
590 zn.rx_cur = this_rfp_ptr;
591 if (zn.rx_cur >= zn.rx_end)
592 zn.rx_cur -= RX_BUF_SIZE/2;
593 update_stop_hit(ioaddr, (zn.rx_cur - zn.rx_start)<<1);
594 next_frame_end_offset = this_rfp_ptr[-3];
595 if (next_frame_end_offset == 0) /* Read all the frames? */
596 break; /* Done for now */
597 this_rfp_ptr = zn.rx_start + next_frame_end_offset;
598 } while (--boguscount);
599
600 /* If any worth-while packets have been received, dev_rint()
601 has done a mark_bh(INET_BH) for us and will work on them
602 when we get to the bottom-half routine. */
603 return;
604 }
605
606 /* The inverse routine to znet_open(). */
607 static int znet_close(struct net_device *dev)
608 {
609 unsigned long flags;
610 int ioaddr = dev->base_addr;
611
612 netif_stop_queue (dev);
613
614 outb(CMD0_RESET, ioaddr); /* CMD0_RESET */
615
616 flags=claim_dma_lock();
617 disable_dma(zn.rx_dma);
618 disable_dma(zn.tx_dma);
619 release_dma_lock(flags);
620
621 free_irq(dev->irq, dev);
622
623 if (znet_debug > 1)
624 printk(KERN_DEBUG "%s: Shutting down ethercard.\n", dev->name);
625 /* Turn off transceiver power. */
626 outb(0x10, 0xe6); /* Select LAN control register */
627 outb(inb(0xe7) & ~0x84, 0xe7); /* Turn on LAN power (bit 2). */
628
629 return 0;
630 }
631
632 /* Get the current statistics. This may be called with the card open or
633 closed. */
634 static struct net_device_stats *net_get_stats(struct net_device *dev)
635 {
636 struct net_local *lp = (struct net_local *)dev->priv;
637
638 return &lp->stats;
639 }
640
641 /* Set or clear the multicast filter for this adaptor.
642 As a side effect this routine must also initialize the device parameters.
643 This is taken advantage of in open().
644
645 N.B. that we change i593_init[] in place. This (properly) makes the
646 mode change persistent, but must be changed if this code is moved to
647 a multiple adaptor environment.
648 */
649 static void set_multicast_list(struct net_device *dev)
650 {
651 short ioaddr = dev->base_addr;
652
653 if (dev->flags&IFF_PROMISC) {
654 /* Enable promiscuous mode */
655 i593_init[7] &= ~3; i593_init[7] |= 1;
656 i593_init[13] &= ~8; i593_init[13] |= 8;
657 } else if (dev->mc_list || (dev->flags&IFF_ALLMULTI)) {
658 /* Enable accept-all-multicast mode */
659 i593_init[7] &= ~3; i593_init[7] |= 0;
660 i593_init[13] &= ~8; i593_init[13] |= 8;
661 } else { /* Enable normal mode. */
662 i593_init[7] &= ~3; i593_init[7] |= 0;
663 i593_init[13] &= ~8; i593_init[13] |= 0;
664 }
665 *zn.tx_cur++ = sizeof(i593_init);
666 memcpy(zn.tx_cur, i593_init, sizeof(i593_init));
667 zn.tx_cur += sizeof(i593_init)/2;
668 outb(CMD0_CONFIGURE+CMD0_CHNL_1, ioaddr);
669 #ifdef not_tested
670 if (num_addrs > 0) {
671 int addrs_len = 6*num_addrs;
672 *zn.tx_cur++ = addrs_len;
673 memcpy(zn.tx_cur, addrs, addrs_len);
674 outb(CMD0_MULTICAST_LIST+CMD0_CHNL_1, ioaddr);
675 zn.tx_cur += addrs_len>>1;
676 }
677 #endif
678 }
679
680 void show_dma(void)
681 {
682 unsigned long flags;
683 short dma_port = ((zn.tx_dma&3)<<2) + IO_DMA2_BASE;
684 unsigned addr = inb(dma_port);
685 addr |= inb(dma_port) << 8;
686
687 flags=claim_dma_lock();
688 printk("Addr: %04x cnt:%3x...", addr<<1, get_dma_residue(zn.tx_dma));
689 release_dma_lock(flags);
690 }
691
692 /* Initialize the hardware. We have to do this when the board is open()ed
693 or when we come out of suspend mode. */
694 static void hardware_init(struct net_device *dev)
695 {
696 unsigned long flags;
697 short ioaddr = dev->base_addr;
698
699 zn.rx_cur = zn.rx_start;
700 zn.tx_cur = zn.tx_start;
701
702 /* Reset the chip, and start it up. */
703 outb(CMD0_RESET, ioaddr);
704
705 flags=claim_dma_lock();
706 disable_dma(zn.rx_dma); /* reset by an interrupting task. */
707 clear_dma_ff(zn.rx_dma);
708 set_dma_mode(zn.rx_dma, DMA_RX_MODE);
709 set_dma_addr(zn.rx_dma, (unsigned int) zn.rx_start);
710 set_dma_count(zn.rx_dma, RX_BUF_SIZE);
711 enable_dma(zn.rx_dma);
712 /* Now set up the Tx channel. */
713 disable_dma(zn.tx_dma);
714 clear_dma_ff(zn.tx_dma);
715 set_dma_mode(zn.tx_dma, DMA_TX_MODE);
716 set_dma_addr(zn.tx_dma, (unsigned int) zn.tx_start);
717 set_dma_count(zn.tx_dma, zn.tx_buf_len<<1);
718 enable_dma(zn.tx_dma);
719 release_dma_lock(flags);
720
721 if (znet_debug > 1)
722 printk(KERN_DEBUG "%s: Initializing the i82593, tx buf %p... ", dev->name,
723 zn.tx_start);
724 /* Do an empty configure command, just like the Crynwr driver. This
725 resets to chip to its default values. */
726 *zn.tx_cur++ = 0;
727 *zn.tx_cur++ = 0;
728 printk("stat:%02x ", inb(ioaddr)); show_dma();
729 outb(CMD0_CONFIGURE+CMD0_CHNL_1, ioaddr);
730 *zn.tx_cur++ = sizeof(i593_init);
731 memcpy(zn.tx_cur, i593_init, sizeof(i593_init));
732 zn.tx_cur += sizeof(i593_init)/2;
733 printk("stat:%02x ", inb(ioaddr)); show_dma();
734 outb(CMD0_CONFIGURE+CMD0_CHNL_1, ioaddr);
735 *zn.tx_cur++ = 6;
736 memcpy(zn.tx_cur, dev->dev_addr, 6);
737 zn.tx_cur += 3;
738 printk("stat:%02x ", inb(ioaddr)); show_dma();
739 outb(CMD0_IA_SETUP + CMD0_CHNL_1, ioaddr);
740 printk("stat:%02x ", inb(ioaddr)); show_dma();
741
742 update_stop_hit(ioaddr, 8192);
743 if (znet_debug > 1) printk("enabling Rx.\n");
744 outb(CMD0_Rx_ENABLE+CMD0_CHNL_0, ioaddr);
745 netif_start_queue (dev);
746 }
747
748 static void update_stop_hit(short ioaddr, unsigned short rx_stop_offset)
749 {
750 outb(CMD0_PORT_1, ioaddr);
751 if (znet_debug > 5)
752 printk(KERN_DEBUG "Updating stop hit with value %02x.\n",
753 (rx_stop_offset >> 6) | 0x80);
754 outb((rx_stop_offset >> 6) | 0x80, ioaddr);
755 outb(CMD1_PORT_0, ioaddr);
756 }
757
758 /*
759 * Local variables:
760 * compile-command: "gcc -D__KERNEL__ -I/usr/src/linux/net/inet -Wall -Wstrict-prototypes -O6 -m486 -c znet.c"
761 * version-control: t
762 * kept-new-versions: 5
763 * c-indent-level: 4
764 * tab-width: 4
765 * End:
766 */
767
This page was automatically generated by the
LXR engine.
Visit the LXR main site for more
information.