1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88#include <linux/module.h>
89#include <linux/kernel.h>
90#include <linux/string.h>
91#include <linux/errno.h>
92#include <linux/interrupt.h>
93#include <linux/ioport.h>
94#include <linux/init.h>
95#include <linux/delay.h>
96#include <linux/netdevice.h>
97#include <linux/etherdevice.h>
98#include <linux/skbuff.h>
99#include <linux/if_arp.h>
100#include <linux/bitops.h>
101
102#include <asm/system.h>
103#include <asm/io.h>
104#include <asm/dma.h>
105
106
107#include "wireless/i82593.h"
108
109static char version[] __initdata = "znet.c:v1.02 9/23/94 becker@scyld.com\n";
110
111#ifndef ZNET_DEBUG
112#define ZNET_DEBUG 1
113#endif
114static unsigned int znet_debug = ZNET_DEBUG;
115module_param (znet_debug, int, 0);
116MODULE_PARM_DESC (znet_debug, "ZNet debug level");
117MODULE_LICENSE("GPL");
118
119
120#define DMA_RX_MODE 0x14
121#define DMA_TX_MODE 0x18
122#define dma_page_eq(ptr1, ptr2) ((long)(ptr1)>>17 == (long)(ptr2)>>17)
123#define RX_BUF_SIZE 8192
124#define TX_BUF_SIZE 8192
125#define DMA_BUF_SIZE (RX_BUF_SIZE + 16)
126
127#define TX_TIMEOUT 10
128
129struct znet_private {
130 int rx_dma, tx_dma;
131 spinlock_t lock;
132 short sia_base, sia_size, io_size;
133 struct i82593_conf_block i593_init;
134
135 ushort *rx_start, *rx_cur, *rx_end;
136 ushort *tx_start, *tx_cur, *tx_end;
137 ushort tx_buf_len;
138};
139
140
141static struct net_device *znet_dev;
142
143struct netidblk {
144 char magic[8];
145 unsigned char netid[8];
146 char nettype, globalopt;
147 char vendor[8];
148 char product[8];
149 char irq1, irq2;
150 char dma1, dma2;
151 short dma_mem_misc[8];
152 short iobase1, iosize1;
153 short iobase2, iosize2;
154 char driver_options;
155 char pad;
156};
157
158static int znet_open(struct net_device *dev);
159static netdev_tx_t znet_send_packet(struct sk_buff *skb,
160 struct net_device *dev);
161static irqreturn_t znet_interrupt(int irq, void *dev_id);
162static void znet_rx(struct net_device *dev);
163static int znet_close(struct net_device *dev);
164static void hardware_init(struct net_device *dev);
165static void update_stop_hit(short ioaddr, unsigned short rx_stop_offset);
166static void znet_tx_timeout (struct net_device *dev);
167
168
169static int znet_request_resources (struct net_device *dev)
170{
171 struct znet_private *znet = netdev_priv(dev);
172
173 if (request_irq (dev->irq, &znet_interrupt, 0, "ZNet", dev))
174 goto failed;
175 if (request_dma (znet->rx_dma, "ZNet rx"))
176 goto free_irq;
177 if (request_dma (znet->tx_dma, "ZNet tx"))
178 goto free_rx_dma;
179 if (!request_region (znet->sia_base, znet->sia_size, "ZNet SIA"))
180 goto free_tx_dma;
181 if (!request_region (dev->base_addr, znet->io_size, "ZNet I/O"))
182 goto free_sia;
183
184 return 0;
185
186 free_sia:
187 release_region (znet->sia_base, znet->sia_size);
188 free_tx_dma:
189 free_dma (znet->tx_dma);
190 free_rx_dma:
191 free_dma (znet->rx_dma);
192 free_irq:
193 free_irq (dev->irq, dev);
194 failed:
195 return -1;
196}
197
198static void znet_release_resources (struct net_device *dev)
199{
200 struct znet_private *znet = netdev_priv(dev);
201
202 release_region (znet->sia_base, znet->sia_size);
203 release_region (dev->base_addr, znet->io_size);
204 free_dma (znet->tx_dma);
205 free_dma (znet->rx_dma);
206 free_irq (dev->irq, dev);
207}
208
209
210static void znet_transceiver_power (struct net_device *dev, int on)
211{
212 struct znet_private *znet = netdev_priv(dev);
213 unsigned char v;
214
215
216
217 outb(0x10, znet->sia_base);
218
219 if (on)
220 v = inb(znet->sia_base + 1) | 0x84;
221 else
222 v = inb(znet->sia_base + 1) & ~0x84;
223
224 outb(v, znet->sia_base+1);
225}
226
227
228
229static void znet_set_multicast_list (struct net_device *dev)
230{
231 struct znet_private *znet = netdev_priv(dev);
232 short ioaddr = dev->base_addr;
233 struct i82593_conf_block *cfblk = &znet->i593_init;
234
235 memset(cfblk, 0x00, sizeof(struct i82593_conf_block));
236
237
238
239
240
241
242
243
244
245
246
247 cfblk->fifo_limit = 10;
248 cfblk->forgnesi = 0;
249 cfblk->fifo_32 = 1;
250 cfblk->d6mod = 0;
251 cfblk->throttle_enb = 1;
252
253
254 cfblk->throttle = 8;
255 cfblk->cntrxint = 0;
256 cfblk->contin = 1;
257
258
259 cfblk->addr_len = ETH_ALEN;
260 cfblk->acloc = 1;
261 cfblk->preamb_len = 2;
262 cfblk->loopback = 0;
263
264
265 cfblk->lin_prio = 0;
266 cfblk->tbofstop = 0;
267 cfblk->exp_prio = 0;
268 cfblk->bof_met = 0;
269
270
271 cfblk->ifrm_spc = 6;
272
273
274 cfblk->slottim_low = 0;
275
276
277 cfblk->slottim_hi = 2;
278 cfblk->max_retr = 15;
279
280
281 cfblk->prmisc = ((dev->flags & IFF_PROMISC) ? 1 : 0);
282 cfblk->bc_dis = 0;
283 cfblk->crs_1 = 0;
284 cfblk->nocrc_ins = 0;
285 cfblk->crc_1632 = 0;
286 cfblk->crs_cdt = 0;
287
288
289 cfblk->cs_filter = 0;
290 cfblk->crs_src = 0;
291 cfblk->cd_filter = 0;
292
293
294 cfblk->min_fr_len = ETH_ZLEN >> 2;
295
296
297 cfblk->lng_typ = 1;
298 cfblk->lng_fld = 1;
299 cfblk->rxcrc_xf = 1;
300 cfblk->artx = 1;
301 cfblk->sarec = 1;
302 cfblk->tx_jabber = 0;
303 cfblk->hash_1 = 1;
304 cfblk->lbpkpol = 0;
305
306
307 cfblk->fdx = 0;
308
309
310 cfblk->dummy_6 = 0x3f;
311 cfblk->mult_ia = 0;
312 cfblk->dis_bof = 0;
313
314
315 cfblk->dummy_1 = 1;
316 cfblk->tx_ifs_retrig = 3;
317 cfblk->mc_all = (dev->mc_list || (dev->flags&IFF_ALLMULTI));
318 cfblk->rcv_mon = 0;
319 cfblk->frag_acpt = 0;
320 cfblk->tstrttrs = 0;
321
322
323 cfblk->fretx = 1;
324 cfblk->runt_eop = 0;
325 cfblk->hw_sw_pin = 0;
326 cfblk->big_endn = 0;
327 cfblk->syncrqs = 1;
328 cfblk->sttlen = 1;
329 cfblk->rx_eop = 0;
330 cfblk->tx_eop = 0;
331
332
333 cfblk->rbuf_size = RX_BUF_SIZE >> 12;
334 cfblk->rcvstop = 1;
335
336 if (znet_debug > 2) {
337 int i;
338 unsigned char *c;
339
340 for (i = 0, c = (char *) cfblk; i < sizeof (*cfblk); i++)
341 printk ("%02X ", c[i]);
342 printk ("\n");
343 }
344
345 *znet->tx_cur++ = sizeof(struct i82593_conf_block);
346 memcpy(znet->tx_cur, cfblk, sizeof(struct i82593_conf_block));
347 znet->tx_cur += sizeof(struct i82593_conf_block)/2;
348 outb(OP0_CONFIGURE | CR0_CHNL, ioaddr);
349
350
351
352}
353
354static const struct net_device_ops znet_netdev_ops = {
355 .ndo_open = znet_open,
356 .ndo_stop = znet_close,
357 .ndo_start_xmit = znet_send_packet,
358 .ndo_set_multicast_list = znet_set_multicast_list,
359 .ndo_tx_timeout = znet_tx_timeout,
360 .ndo_change_mtu = eth_change_mtu,
361 .ndo_set_mac_address = eth_mac_addr,
362 .ndo_validate_addr = eth_validate_addr,
363};
364
365
366
367
368
369static int __init znet_probe (void)
370{
371 int i;
372 struct netidblk *netinfo;
373 struct znet_private *znet;
374 struct net_device *dev;
375 char *p;
376 int err = -ENOMEM;
377
378
379 for(p = (char *)phys_to_virt(0xf0000); p < (char *)phys_to_virt(0x100000); p++)
380 if (*p == 'N' && strncmp(p, "NETIDBLK", 8) == 0)
381 break;
382
383 if (p >= (char *)phys_to_virt(0x100000)) {
384 if (znet_debug > 1)
385 printk(KERN_INFO "No Z-Note ethernet adaptor found.\n");
386 return -ENODEV;
387 }
388
389 dev = alloc_etherdev(sizeof(struct znet_private));
390 if (!dev)
391 return -ENOMEM;
392
393 znet = netdev_priv(dev);
394
395 netinfo = (struct netidblk *)p;
396 dev->base_addr = netinfo->iobase1;
397 dev->irq = netinfo->irq1;
398
399
400 for (i = 0; i < 6; i++)
401 dev->dev_addr[i] = netinfo->netid[i];
402
403 printk(KERN_INFO "%s: ZNET at %#3lx, %pM"
404 ", using IRQ %d DMA %d and %d.\n",
405 dev->name, dev->base_addr, dev->dev_addr,
406 dev->irq, netinfo->dma1, netinfo->dma2);
407
408 if (znet_debug > 1) {
409 printk(KERN_INFO "%s: vendor '%16.16s' IRQ1 %d IRQ2 %d DMA1 %d DMA2 %d.\n",
410 dev->name, netinfo->vendor,
411 netinfo->irq1, netinfo->irq2,
412 netinfo->dma1, netinfo->dma2);
413 printk(KERN_INFO "%s: iobase1 %#x size %d iobase2 %#x size %d net type %2.2x.\n",
414 dev->name, netinfo->iobase1, netinfo->iosize1,
415 netinfo->iobase2, netinfo->iosize2, netinfo->nettype);
416 }
417
418 if (znet_debug > 0)
419 printk(KERN_INFO "%s", version);
420
421 znet->rx_dma = netinfo->dma1;
422 znet->tx_dma = netinfo->dma2;
423 spin_lock_init(&znet->lock);
424 znet->sia_base = 0xe6;
425 znet->sia_size = 2;
426
427
428
429 znet->io_size = 2;
430
431 if (!(znet->rx_start = kmalloc (DMA_BUF_SIZE, GFP_KERNEL | GFP_DMA)))
432 goto free_dev;
433 if (!(znet->tx_start = kmalloc (DMA_BUF_SIZE, GFP_KERNEL | GFP_DMA)))
434 goto free_rx;
435
436 if (!dma_page_eq (znet->rx_start, znet->rx_start + (RX_BUF_SIZE/2-1)) ||
437 !dma_page_eq (znet->tx_start, znet->tx_start + (TX_BUF_SIZE/2-1))) {
438 printk (KERN_WARNING "tx/rx crossing DMA frontiers, giving up\n");
439 goto free_tx;
440 }
441
442 znet->rx_end = znet->rx_start + RX_BUF_SIZE/2;
443 znet->tx_buf_len = TX_BUF_SIZE/2;
444 znet->tx_end = znet->tx_start + znet->tx_buf_len;
445
446
447 dev->netdev_ops = &znet_netdev_ops;
448 dev->watchdog_timeo = TX_TIMEOUT;
449 err = register_netdev(dev);
450 if (err)
451 goto free_tx;
452 znet_dev = dev;
453 return 0;
454
455 free_tx:
456 kfree(znet->tx_start);
457 free_rx:
458 kfree(znet->rx_start);
459 free_dev:
460 free_netdev(dev);
461 return err;
462}
463
464
465static int znet_open(struct net_device *dev)
466{
467 int ioaddr = dev->base_addr;
468
469 if (znet_debug > 2)
470 printk(KERN_DEBUG "%s: znet_open() called.\n", dev->name);
471
472
473 if (znet_request_resources (dev)) {
474 printk(KERN_WARNING "%s: Not opened -- resource busy?!?\n", dev->name);
475 return -EBUSY;
476 }
477
478 znet_transceiver_power (dev, 1);
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493 mdelay (50);
494
495
496 if (inb(ioaddr) != 0x10 && inb(ioaddr) != 0x00)
497 printk(KERN_WARNING "%s: Problem turning on the transceiver power.\n",
498 dev->name);
499
500 hardware_init(dev);
501 netif_start_queue (dev);
502
503 return 0;
504}
505
506
507static void znet_tx_timeout (struct net_device *dev)
508{
509 int ioaddr = dev->base_addr;
510 ushort event, tx_status, rx_offset, state;
511
512 outb (CR0_STATUS_0, ioaddr);
513 event = inb (ioaddr);
514 outb (CR0_STATUS_1, ioaddr);
515 tx_status = inw (ioaddr);
516 outb (CR0_STATUS_2, ioaddr);
517 rx_offset = inw (ioaddr);
518 outb (CR0_STATUS_3, ioaddr);
519 state = inb (ioaddr);
520 printk (KERN_WARNING "%s: transmit timed out, status %02x %04x %04x %02x,"
521 " resetting.\n", dev->name, event, tx_status, rx_offset, state);
522 if (tx_status == TX_LOST_CRS)
523 printk (KERN_WARNING "%s: Tx carrier error, check transceiver cable.\n",
524 dev->name);
525 outb (OP0_RESET, ioaddr);
526 hardware_init (dev);
527 netif_wake_queue (dev);
528}
529
530static netdev_tx_t znet_send_packet(struct sk_buff *skb, struct net_device *dev)
531{
532 int ioaddr = dev->base_addr;
533 struct znet_private *znet = netdev_priv(dev);
534 unsigned long flags;
535 short length = skb->len;
536
537 if (znet_debug > 4)
538 printk(KERN_DEBUG "%s: ZNet_send_packet.\n", dev->name);
539
540 if (length < ETH_ZLEN) {
541 if (skb_padto(skb, ETH_ZLEN))
542 return NETDEV_TX_OK;
543 length = ETH_ZLEN;
544 }
545
546 netif_stop_queue (dev);
547
548
549 outb(CR0_STATUS_0, ioaddr);
550 if (inw(ioaddr) == 0x0010 &&
551 inw(ioaddr) == 0x0000 &&
552 inw(ioaddr) == 0x0010) {
553 if (znet_debug > 1)
554 printk (KERN_WARNING "%s : waking up\n", dev->name);
555 hardware_init(dev);
556 znet_transceiver_power (dev, 1);
557 }
558
559 if (1) {
560 unsigned char *buf = (void *)skb->data;
561 ushort *tx_link = znet->tx_cur - 1;
562 ushort rnd_len = (length + 1)>>1;
563
564 dev->stats.tx_bytes+=length;
565
566 if (znet->tx_cur >= znet->tx_end)
567 znet->tx_cur = znet->tx_start;
568 *znet->tx_cur++ = length;
569 if (znet->tx_cur + rnd_len + 1 > znet->tx_end) {
570 int semi_cnt = (znet->tx_end - znet->tx_cur)<<1;
571 memcpy(znet->tx_cur, buf, semi_cnt);
572 rnd_len -= semi_cnt>>1;
573 memcpy(znet->tx_start, buf + semi_cnt, length - semi_cnt);
574 znet->tx_cur = znet->tx_start + rnd_len;
575 } else {
576 memcpy(znet->tx_cur, buf, skb->len);
577 znet->tx_cur += rnd_len;
578 }
579 *znet->tx_cur++ = 0;
580
581 spin_lock_irqsave(&znet->lock, flags);
582 {
583 *tx_link = OP0_TRANSMIT | CR0_CHNL;
584
585 outb(OP0_TRANSMIT | CR0_CHNL, ioaddr);
586 }
587 spin_unlock_irqrestore (&znet->lock, flags);
588
589 dev->trans_start = jiffies;
590 netif_start_queue (dev);
591
592 if (znet_debug > 4)
593 printk(KERN_DEBUG "%s: Transmitter queued, length %d.\n", dev->name, length);
594 }
595 dev_kfree_skb(skb);
596 return NETDEV_TX_OK;
597}
598
599
600static irqreturn_t znet_interrupt(int irq, void *dev_id)
601{
602 struct net_device *dev = dev_id;
603 struct znet_private *znet = netdev_priv(dev);
604 int ioaddr;
605 int boguscnt = 20;
606 int handled = 0;
607
608 spin_lock (&znet->lock);
609
610 ioaddr = dev->base_addr;
611
612 outb(CR0_STATUS_0, ioaddr);
613 do {
614 ushort status = inb(ioaddr);
615 if (znet_debug > 5) {
616 ushort result, rx_ptr, running;
617 outb(CR0_STATUS_1, ioaddr);
618 result = inw(ioaddr);
619 outb(CR0_STATUS_2, ioaddr);
620 rx_ptr = inw(ioaddr);
621 outb(CR0_STATUS_3, ioaddr);
622 running = inb(ioaddr);
623 printk(KERN_DEBUG "%s: interrupt, status %02x, %04x %04x %02x serial %d.\n",
624 dev->name, status, result, rx_ptr, running, boguscnt);
625 }
626 if ((status & SR0_INTERRUPT) == 0)
627 break;
628
629 handled = 1;
630
631 if ((status & SR0_EVENT_MASK) == SR0_TRANSMIT_DONE ||
632 (status & SR0_EVENT_MASK) == SR0_RETRANSMIT_DONE ||
633 (status & SR0_EVENT_MASK) == SR0_TRANSMIT_NO_CRC_DONE) {
634 int tx_status;
635 outb(CR0_STATUS_1, ioaddr);
636 tx_status = inw(ioaddr);
637
638 if (tx_status & TX_OK) {
639 dev->stats.tx_packets++;
640 dev->stats.collisions += tx_status & TX_NCOL_MASK;
641 } else {
642 if (tx_status & (TX_LOST_CTS | TX_LOST_CRS))
643 dev->stats.tx_carrier_errors++;
644 if (tx_status & TX_UND_RUN)
645 dev->stats.tx_fifo_errors++;
646 if (!(tx_status & TX_HRT_BEAT))
647 dev->stats.tx_heartbeat_errors++;
648 if (tx_status & TX_MAX_COL)
649 dev->stats.tx_aborted_errors++;
650
651 if ((tx_status | (TX_LOST_CRS | TX_LOST_CTS | TX_UND_RUN | TX_HRT_BEAT | TX_MAX_COL)) != (TX_LOST_CRS | TX_LOST_CTS | TX_UND_RUN | TX_HRT_BEAT | TX_MAX_COL))
652 dev->stats.tx_errors++;
653
654
655
656
657
658
659
660 znet_transceiver_power (dev, 0);
661 znet_transceiver_power (dev, 1);
662 }
663 netif_wake_queue (dev);
664 }
665
666 if ((status & SR0_RECEPTION) ||
667 (status & SR0_EVENT_MASK) == SR0_STOP_REG_HIT) {
668 znet_rx(dev);
669 }
670
671 outb(CR0_INT_ACK, ioaddr);
672 } while (boguscnt--);
673
674 spin_unlock (&znet->lock);
675
676 return IRQ_RETVAL(handled);
677}
678
679static void znet_rx(struct net_device *dev)
680{
681 struct znet_private *znet = netdev_priv(dev);
682 int ioaddr = dev->base_addr;
683 int boguscount = 1;
684 short next_frame_end_offset = 0;
685 short *cur_frame_end;
686 short cur_frame_end_offset;
687
688 outb(CR0_STATUS_2, ioaddr);
689 cur_frame_end_offset = inw(ioaddr);
690
691 if (cur_frame_end_offset == znet->rx_cur - znet->rx_start) {
692 printk(KERN_WARNING "%s: Interrupted, but nothing to receive, offset %03x.\n",
693 dev->name, cur_frame_end_offset);
694 return;
695 }
696
697
698
699
700
701 while (znet->rx_start + cur_frame_end_offset != znet->rx_cur
702 && ++boguscount < 5) {
703 unsigned short hi_cnt, lo_cnt, hi_status, lo_status;
704 int count, status;
705
706 if (cur_frame_end_offset < 4) {
707
708
709
710 memcpy(znet->rx_end, znet->rx_start, 8);
711 cur_frame_end_offset += (RX_BUF_SIZE/2);
712 }
713 cur_frame_end = znet->rx_start + cur_frame_end_offset - 4;
714
715 lo_status = *cur_frame_end++;
716 hi_status = *cur_frame_end++;
717 status = ((hi_status & 0xff) << 8) + (lo_status & 0xff);
718 lo_cnt = *cur_frame_end++;
719 hi_cnt = *cur_frame_end++;
720 count = ((hi_cnt & 0xff) << 8) + (lo_cnt & 0xff);
721
722 if (znet_debug > 5)
723 printk(KERN_DEBUG "Constructing trailer at location %03x, %04x %04x %04x %04x"
724 " count %#x status %04x.\n",
725 cur_frame_end_offset<<1, lo_status, hi_status, lo_cnt, hi_cnt,
726 count, status);
727 cur_frame_end[-4] = status;
728 cur_frame_end[-3] = next_frame_end_offset;
729 cur_frame_end[-2] = count;
730 next_frame_end_offset = cur_frame_end_offset;
731 cur_frame_end_offset -= ((count + 1)>>1) + 3;
732 if (cur_frame_end_offset < 0)
733 cur_frame_end_offset += RX_BUF_SIZE/2;
734 };
735
736
737 do {
738 ushort *this_rfp_ptr = znet->rx_start + next_frame_end_offset;
739 int status = this_rfp_ptr[-4];
740 int pkt_len = this_rfp_ptr[-2];
741
742 if (znet_debug > 5)
743 printk(KERN_DEBUG "Looking at trailer ending at %04x status %04x length %03x"
744 " next %04x.\n", next_frame_end_offset<<1, status, pkt_len,
745 this_rfp_ptr[-3]<<1);
746
747 if ( ! (status & RX_RCV_OK)) {
748 dev->stats.rx_errors++;
749 if (status & RX_CRC_ERR) dev->stats.rx_crc_errors++;
750 if (status & RX_ALG_ERR) dev->stats.rx_frame_errors++;
751#if 0
752 if (status & 0x0200) dev->stats.rx_over_errors++;
753 if (status & 0x0100) dev->stats.rx_fifo_errors++;
754#else
755
756 if (status & RX_OVRRUN) dev->stats.rx_over_errors++;
757#endif
758 if (status & RX_SRT_FRM) dev->stats.rx_length_errors++;
759 } else if (pkt_len > 1536) {
760 dev->stats.rx_length_errors++;
761 } else {
762
763 struct sk_buff *skb;
764
765 skb = dev_alloc_skb(pkt_len);
766 if (skb == NULL) {
767 if (znet_debug)
768 printk(KERN_WARNING "%s: Memory squeeze, dropping packet.\n", dev->name);
769 dev->stats.rx_dropped++;
770 break;
771 }
772
773 if (&znet->rx_cur[(pkt_len+1)>>1] > znet->rx_end) {
774 int semi_cnt = (znet->rx_end - znet->rx_cur)<<1;
775 memcpy(skb_put(skb,semi_cnt), znet->rx_cur, semi_cnt);
776 memcpy(skb_put(skb,pkt_len-semi_cnt), znet->rx_start,
777 pkt_len - semi_cnt);
778 } else {
779 memcpy(skb_put(skb,pkt_len), znet->rx_cur, pkt_len);
780 if (znet_debug > 6) {
781 unsigned int *packet = (unsigned int *) skb->data;
782 printk(KERN_DEBUG "Packet data is %08x %08x %08x %08x.\n", packet[0],
783 packet[1], packet[2], packet[3]);
784 }
785 }
786 skb->protocol=eth_type_trans(skb,dev);
787 netif_rx(skb);
788 dev->stats.rx_packets++;
789 dev->stats.rx_bytes += pkt_len;
790 }
791 znet->rx_cur = this_rfp_ptr;
792 if (znet->rx_cur >= znet->rx_end)
793 znet->rx_cur -= RX_BUF_SIZE/2;
794 update_stop_hit(ioaddr, (znet->rx_cur - znet->rx_start)<<1);
795 next_frame_end_offset = this_rfp_ptr[-3];
796 if (next_frame_end_offset == 0)
797 break;
798 this_rfp_ptr = znet->rx_start + next_frame_end_offset;
799 } while (--boguscount);
800
801
802
803
804 return;
805}
806
807
808static int znet_close(struct net_device *dev)
809{
810 int ioaddr = dev->base_addr;
811
812 netif_stop_queue (dev);
813
814 outb(OP0_RESET, ioaddr);
815
816 if (znet_debug > 1)
817 printk(KERN_DEBUG "%s: Shutting down ethercard.\n", dev->name);
818
819 znet_transceiver_power (dev, 0);
820
821 znet_release_resources (dev);
822
823 return 0;
824}
825
826static void show_dma(struct net_device *dev)
827{
828 short ioaddr = dev->base_addr;
829 unsigned char stat = inb (ioaddr);
830 struct znet_private *znet = netdev_priv(dev);
831 unsigned long flags;
832 short dma_port = ((znet->tx_dma&3)<<2) + IO_DMA2_BASE;
833 unsigned addr = inb(dma_port);
834 short residue;
835
836 addr |= inb(dma_port) << 8;
837 residue = get_dma_residue(znet->tx_dma);
838
839 if (znet_debug > 1) {
840 flags=claim_dma_lock();
841 printk(KERN_DEBUG "Stat:%02x Addr: %04x cnt:%3x\n",
842 stat, addr<<1, residue);
843 release_dma_lock(flags);
844 }
845}
846
847
848
849static void hardware_init(struct net_device *dev)
850{
851 unsigned long flags;
852 short ioaddr = dev->base_addr;
853 struct znet_private *znet = netdev_priv(dev);
854
855 znet->rx_cur = znet->rx_start;
856 znet->tx_cur = znet->tx_start;
857
858
859 outb(OP0_RESET, ioaddr);
860
861 flags=claim_dma_lock();
862 disable_dma(znet->rx_dma);
863 clear_dma_ff(znet->rx_dma);
864 set_dma_mode(znet->rx_dma, DMA_RX_MODE);
865 set_dma_addr(znet->rx_dma, (unsigned int) znet->rx_start);
866 set_dma_count(znet->rx_dma, RX_BUF_SIZE);
867 enable_dma(znet->rx_dma);
868
869 disable_dma(znet->tx_dma);
870 clear_dma_ff(znet->tx_dma);
871 set_dma_mode(znet->tx_dma, DMA_TX_MODE);
872 set_dma_addr(znet->tx_dma, (unsigned int) znet->tx_start);
873 set_dma_count(znet->tx_dma, znet->tx_buf_len<<1);
874 enable_dma(znet->tx_dma);
875 release_dma_lock(flags);
876
877 if (znet_debug > 1)
878 printk(KERN_DEBUG "%s: Initializing the i82593, rx buf %p tx buf %p\n",
879 dev->name, znet->rx_start,znet->tx_start);
880
881
882 *znet->tx_cur++ = 0;
883 *znet->tx_cur++ = 0;
884 show_dma(dev);
885 outb(OP0_CONFIGURE | CR0_CHNL, ioaddr);
886
887 znet_set_multicast_list (dev);
888
889 *znet->tx_cur++ = 6;
890 memcpy(znet->tx_cur, dev->dev_addr, 6);
891 znet->tx_cur += 3;
892 show_dma(dev);
893 outb(OP0_IA_SETUP | CR0_CHNL, ioaddr);
894 show_dma(dev);
895
896 update_stop_hit(ioaddr, 8192);
897 if (znet_debug > 1) printk(KERN_DEBUG "enabling Rx.\n");
898 outb(OP0_RCV_ENABLE, ioaddr);
899 netif_start_queue (dev);
900}
901
902static void update_stop_hit(short ioaddr, unsigned short rx_stop_offset)
903{
904 outb(OP0_SWIT_TO_PORT_1 | CR0_CHNL, ioaddr);
905 if (znet_debug > 5)
906 printk(KERN_DEBUG "Updating stop hit with value %02x.\n",
907 (rx_stop_offset >> 6) | CR1_STOP_REG_UPDATE);
908 outb((rx_stop_offset >> 6) | CR1_STOP_REG_UPDATE, ioaddr);
909 outb(OP1_SWIT_TO_PORT_0, ioaddr);
910}
911
912static __exit void znet_cleanup (void)
913{
914 if (znet_dev) {
915 struct znet_private *znet = netdev_priv(znet_dev);
916
917 unregister_netdev (znet_dev);
918 kfree (znet->rx_start);
919 kfree (znet->tx_start);
920 free_netdev (znet_dev);
921 }
922}
923
924module_init (znet_probe);
925module_exit (znet_cleanup);
926