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#define HP100_DEFAULT_PRIORITY_TX 0
87
88#undef HP100_DEBUG
89#undef HP100_DEBUG_B
90#undef HP100_DEBUG_BM
91
92#undef HP100_DEBUG_TRAINING
93#undef HP100_DEBUG_TX
94#undef HP100_DEBUG_IRQ
95#undef HP100_DEBUG_RX
96
97#undef HP100_MULTICAST_FILTER
98
99#include <linux/module.h>
100#include <linux/kernel.h>
101#include <linux/string.h>
102#include <linux/errno.h>
103#include <linux/ioport.h>
104#include <linux/slab.h>
105#include <linux/interrupt.h>
106#include <linux/eisa.h>
107#include <linux/pci.h>
108#include <linux/dma-mapping.h>
109#include <linux/spinlock.h>
110#include <linux/netdevice.h>
111#include <linux/etherdevice.h>
112#include <linux/skbuff.h>
113#include <linux/types.h>
114#include <linux/delay.h>
115#include <linux/init.h>
116#include <linux/bitops.h>
117#include <linux/jiffies.h>
118
119#include <asm/io.h>
120
121#include "hp100.h"
122
123
124
125
126
127#define HP100_BUS_ISA 0
128#define HP100_BUS_EISA 1
129#define HP100_BUS_PCI 2
130
131#define HP100_REGION_SIZE 0x20
132#define HP100_SIG_LEN 8
133
134#define HP100_MAX_PACKET_SIZE (1536+4)
135#define HP100_MIN_PACKET_SIZE 60
136
137#ifndef HP100_DEFAULT_RX_RATIO
138
139#define HP100_DEFAULT_RX_RATIO 75
140#endif
141
142#ifndef HP100_DEFAULT_PRIORITY_TX
143
144#define HP100_DEFAULT_PRIORITY_TX 0
145#endif
146
147
148
149
150
151struct hp100_private {
152 spinlock_t lock;
153 char id[HP100_SIG_LEN];
154 u_short chip;
155 u_short soft_model;
156 u_int memory_size;
157 u_int virt_memory_size;
158 u_short rx_ratio;
159 u_short priority_tx;
160 u_short mode;
161 u_char bus;
162 struct pci_dev *pci_dev;
163 short mem_mapped;
164 void __iomem *mem_ptr_virt;
165 unsigned long mem_ptr_phys;
166 short lan_type;
167 int hub_status;
168 u_char mac1_mode;
169 u_char mac2_mode;
170 u_char hash_bytes[8];
171 struct net_device_stats stats;
172
173
174 hp100_ring_t *rxrhead;
175 hp100_ring_t *rxrtail;
176 hp100_ring_t *txrhead;
177 hp100_ring_t *txrtail;
178
179 hp100_ring_t rxring[MAX_RX_PDL];
180 hp100_ring_t txring[MAX_TX_PDL];
181
182 u_int *page_vaddr_algn;
183 u_long whatever_offset;
184 int rxrcommit;
185 int txrcommit;
186};
187
188
189
190
191#ifdef CONFIG_ISA
192static const char *hp100_isa_tbl[] = {
193 "HWPF150",
194 "HWP1950",
195};
196#endif
197
198#ifdef CONFIG_EISA
199static struct eisa_device_id hp100_eisa_tbl[] = {
200 { "HWPF180" },
201 { "HWP1920" },
202 { "HWP1940" },
203 { "HWP1990" },
204 { "CPX0301" },
205 { "CPX0401" },
206 { "" }
207};
208MODULE_DEVICE_TABLE(eisa, hp100_eisa_tbl);
209#endif
210
211#ifdef CONFIG_PCI
212static struct pci_device_id hp100_pci_tbl[] = {
213 {PCI_VENDOR_ID_HP, PCI_DEVICE_ID_HP_J2585A, PCI_ANY_ID, PCI_ANY_ID,},
214 {PCI_VENDOR_ID_HP, PCI_DEVICE_ID_HP_J2585B, PCI_ANY_ID, PCI_ANY_ID,},
215 {PCI_VENDOR_ID_HP, PCI_DEVICE_ID_HP_J2970A, PCI_ANY_ID, PCI_ANY_ID,},
216 {PCI_VENDOR_ID_HP, PCI_DEVICE_ID_HP_J2973A, PCI_ANY_ID, PCI_ANY_ID,},
217 {PCI_VENDOR_ID_COMPEX, PCI_DEVICE_ID_COMPEX_ENET100VG4, PCI_ANY_ID, PCI_ANY_ID,},
218 {PCI_VENDOR_ID_COMPEX2, PCI_DEVICE_ID_COMPEX2_100VG, PCI_ANY_ID, PCI_ANY_ID,},
219
220 {}
221};
222MODULE_DEVICE_TABLE(pci, hp100_pci_tbl);
223#endif
224
225static int hp100_rx_ratio = HP100_DEFAULT_RX_RATIO;
226static int hp100_priority_tx = HP100_DEFAULT_PRIORITY_TX;
227static int hp100_mode = 1;
228
229module_param(hp100_rx_ratio, int, 0);
230module_param(hp100_priority_tx, int, 0);
231module_param(hp100_mode, int, 0);
232
233
234
235
236
237static int hp100_probe1(struct net_device *dev, int ioaddr, u_char bus,
238 struct pci_dev *pci_dev);
239
240
241static int hp100_open(struct net_device *dev);
242static int hp100_close(struct net_device *dev);
243static int hp100_start_xmit(struct sk_buff *skb, struct net_device *dev);
244static int hp100_start_xmit_bm(struct sk_buff *skb,
245 struct net_device *dev);
246static void hp100_rx(struct net_device *dev);
247static struct net_device_stats *hp100_get_stats(struct net_device *dev);
248static void hp100_misc_interrupt(struct net_device *dev);
249static void hp100_update_stats(struct net_device *dev);
250static void hp100_clear_stats(struct hp100_private *lp, int ioaddr);
251static void hp100_set_multicast_list(struct net_device *dev);
252static irqreturn_t hp100_interrupt(int irq, void *dev_id);
253static void hp100_start_interface(struct net_device *dev);
254static void hp100_stop_interface(struct net_device *dev);
255static void hp100_load_eeprom(struct net_device *dev, u_short ioaddr);
256static int hp100_sense_lan(struct net_device *dev);
257static int hp100_login_to_vg_hub(struct net_device *dev,
258 u_short force_relogin);
259static int hp100_down_vg_link(struct net_device *dev);
260static void hp100_cascade_reset(struct net_device *dev, u_short enable);
261static void hp100_BM_shutdown(struct net_device *dev);
262static void hp100_mmuinit(struct net_device *dev);
263static void hp100_init_pdls(struct net_device *dev);
264static int hp100_init_rxpdl(struct net_device *dev,
265 register hp100_ring_t * ringptr,
266 register u_int * pdlptr);
267static int hp100_init_txpdl(struct net_device *dev,
268 register hp100_ring_t * ringptr,
269 register u_int * pdlptr);
270static void hp100_rxfill(struct net_device *dev);
271static void hp100_hwinit(struct net_device *dev);
272static void hp100_clean_txring(struct net_device *dev);
273#ifdef HP100_DEBUG
274static void hp100_RegisterDump(struct net_device *dev);
275#endif
276
277
278
279
280
281
282
283static inline dma_addr_t virt_to_whatever(struct net_device *dev, u32 * ptr)
284{
285 struct hp100_private *lp = netdev_priv(dev);
286 return ((u_long) ptr) + lp->whatever_offset;
287}
288
289static inline u_int pdl_map_data(struct hp100_private *lp, void *data)
290{
291 return pci_map_single(lp->pci_dev, data,
292 MAX_ETHER_SIZE, PCI_DMA_FROMDEVICE);
293}
294
295
296static void wait(void)
297{
298 mdelay(1);
299}
300
301
302
303
304
305
306
307
308
309
310
311static __devinit const char *hp100_read_id(int ioaddr)
312{
313 int i;
314 static char str[HP100_SIG_LEN];
315 unsigned char sig[4], sum;
316 unsigned short rev;
317
318 hp100_page(ID_MAC_ADDR);
319 sum = 0;
320 for (i = 0; i < 4; i++) {
321 sig[i] = hp100_inb(BOARD_ID + i);
322 sum += sig[i];
323 }
324
325 sum += hp100_inb(BOARD_ID + i);
326 if (sum != 0xff)
327 return NULL;
328
329 str[0] = ((sig[0] >> 2) & 0x1f) + ('A' - 1);
330 str[1] = (((sig[0] & 3) << 3) | (sig[1] >> 5)) + ('A' - 1);
331 str[2] = (sig[1] & 0x1f) + ('A' - 1);
332 rev = (sig[2] << 8) | sig[3];
333 sprintf(str + 3, "%04X", rev);
334
335 return str;
336}
337
338#ifdef CONFIG_ISA
339static __init int hp100_isa_probe1(struct net_device *dev, int ioaddr)
340{
341 const char *sig;
342 int i;
343
344 if (!request_region(ioaddr, HP100_REGION_SIZE, "hp100"))
345 goto err;
346
347 if (hp100_inw(HW_ID) != HP100_HW_ID_CASCADE) {
348 release_region(ioaddr, HP100_REGION_SIZE);
349 goto err;
350 }
351
352 sig = hp100_read_id(ioaddr);
353 release_region(ioaddr, HP100_REGION_SIZE);
354
355 if (sig == NULL)
356 goto err;
357
358 for (i = 0; i < ARRAY_SIZE(hp100_isa_tbl); i++) {
359 if (!strcmp(hp100_isa_tbl[i], sig))
360 break;
361
362 }
363
364 if (i < ARRAY_SIZE(hp100_isa_tbl))
365 return hp100_probe1(dev, ioaddr, HP100_BUS_ISA, NULL);
366 err:
367 return -ENODEV;
368
369}
370
371
372
373
374
375static int __init hp100_isa_probe(struct net_device *dev, int addr)
376{
377 int err = -ENODEV;
378
379
380 if (addr > 0xff && addr < 0x400)
381 err = hp100_isa_probe1(dev, addr);
382
383 else if (addr != 0)
384 err = -ENXIO;
385
386 else {
387
388 for (addr = 0x100; addr < 0x400; addr += 0x20) {
389 err = hp100_isa_probe1(dev, addr);
390 if (!err)
391 break;
392 }
393 }
394 return err;
395}
396#endif
397
398#if !defined(MODULE) && defined(CONFIG_ISA)
399struct net_device * __init hp100_probe(int unit)
400{
401 struct net_device *dev = alloc_etherdev(sizeof(struct hp100_private));
402 int err;
403
404 if (!dev)
405 return ERR_PTR(-ENODEV);
406
407#ifdef HP100_DEBUG_B
408 hp100_outw(0x4200, TRACE);
409 printk("hp100: %s: probe\n", dev->name);
410#endif
411
412 if (unit >= 0) {
413 sprintf(dev->name, "eth%d", unit);
414 netdev_boot_setup_check(dev);
415 }
416
417 err = hp100_isa_probe(dev, dev->base_addr);
418 if (err)
419 goto out;
420
421 return dev;
422 out:
423 free_netdev(dev);
424 return ERR_PTR(err);
425}
426#endif
427
428static int __devinit hp100_probe1(struct net_device *dev, int ioaddr,
429 u_char bus, struct pci_dev *pci_dev)
430{
431 int i;
432 int err = -ENODEV;
433 const char *eid;
434 u_int chip;
435 u_char uc;
436 u_int memory_size = 0, virt_memory_size = 0;
437 u_short local_mode, lsw;
438 short mem_mapped;
439 unsigned long mem_ptr_phys;
440 void __iomem *mem_ptr_virt;
441 struct hp100_private *lp;
442
443#ifdef HP100_DEBUG_B
444 hp100_outw(0x4201, TRACE);
445 printk("hp100: %s: probe1\n", dev->name);
446#endif
447
448
449 if (!request_region(ioaddr, HP100_REGION_SIZE, "hp100"))
450 goto out1;
451
452 if (hp100_inw(HW_ID) != HP100_HW_ID_CASCADE)
453 goto out2;
454
455 chip = hp100_inw(PAGING) & HP100_CHIPID_MASK;
456#ifdef HP100_DEBUG
457 if (chip == HP100_CHIPID_SHASTA)
458 printk("hp100: %s: Shasta Chip detected. (This is a pre 802.12 chip)\n", dev->name);
459 else if (chip == HP100_CHIPID_RAINIER)
460 printk("hp100: %s: Rainier Chip detected. (This is a pre 802.12 chip)\n", dev->name);
461 else if (chip == HP100_CHIPID_LASSEN)
462 printk("hp100: %s: Lassen Chip detected.\n", dev->name);
463 else
464 printk("hp100: %s: Warning: Unknown CASCADE chip (id=0x%.4x).\n", dev->name, chip);
465#endif
466
467 dev->base_addr = ioaddr;
468
469 eid = hp100_read_id(ioaddr);
470 if (eid == NULL) {
471 printk(KERN_WARNING "hp100_probe: bad ID checksum at base port 0x%x\n", ioaddr);
472 goto out2;
473 }
474
475 hp100_page(ID_MAC_ADDR);
476 for (i = uc = 0; i < 7; i++)
477 uc += hp100_inb(LAN_ADDR + i);
478 if (uc != 0xff) {
479 printk(KERN_WARNING "hp100_probe: bad lan address checksum at port 0x%x)\n", ioaddr);
480 err = -EIO;
481 goto out2;
482 }
483
484
485
486 hp100_load_eeprom(dev, ioaddr);
487 wait();
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517 local_mode = hp100_mode;
518 if (local_mode < 1 || local_mode > 4)
519 local_mode = 1;
520#ifdef HP100_DEBUG
521 printk("hp100: %s: original LSW = 0x%x\n", dev->name,
522 hp100_inw(OPTION_LSW));
523#endif
524
525 if (local_mode == 3) {
526 hp100_outw(HP100_MEM_EN | HP100_RESET_LB, OPTION_LSW);
527 hp100_outw(HP100_IO_EN | HP100_SET_LB, OPTION_LSW);
528 hp100_outw(HP100_BM_WRITE | HP100_BM_READ | HP100_RESET_HB, OPTION_LSW);
529 printk("hp100: IO mapped mode forced.\n");
530 } else if (local_mode == 2) {
531 hp100_outw(HP100_MEM_EN | HP100_SET_LB, OPTION_LSW);
532 hp100_outw(HP100_IO_EN | HP100_SET_LB, OPTION_LSW);
533 hp100_outw(HP100_BM_WRITE | HP100_BM_READ | HP100_RESET_HB, OPTION_LSW);
534 printk("hp100: Shared memory mode requested.\n");
535 } else if (local_mode == 4) {
536 if (chip == HP100_CHIPID_LASSEN) {
537 hp100_outw(HP100_BM_WRITE | HP100_BM_READ | HP100_SET_HB, OPTION_LSW);
538 hp100_outw(HP100_IO_EN | HP100_MEM_EN | HP100_RESET_LB, OPTION_LSW);
539 printk("hp100: Busmaster mode requested.\n");
540 }
541 local_mode = 1;
542 }
543
544 if (local_mode == 1) {
545 lsw = hp100_inw(OPTION_LSW);
546
547 if ((lsw & HP100_IO_EN) && (~lsw & HP100_MEM_EN) &&
548 (~lsw & (HP100_BM_WRITE | HP100_BM_READ))) {
549#ifdef HP100_DEBUG
550 printk("hp100: %s: IO_EN bit is set on card.\n", dev->name);
551#endif
552 local_mode = 3;
553 } else if (chip == HP100_CHIPID_LASSEN &&
554 (lsw & (HP100_BM_WRITE | HP100_BM_READ)) == (HP100_BM_WRITE | HP100_BM_READ)) {
555
556
557
558
559
560 if((bus == HP100_BUS_PCI) &&
561 (pci_set_dma_mask(pci_dev, DMA_32BIT_MASK))) {
562
563 goto busmasterfail;
564 }
565 printk("hp100: Busmaster mode enabled.\n");
566 hp100_outw(HP100_MEM_EN | HP100_IO_EN | HP100_RESET_LB, OPTION_LSW);
567 } else {
568 busmasterfail:
569#ifdef HP100_DEBUG
570 printk("hp100: %s: Card not configured for BM or BM not supported with this card.\n", dev->name);
571 printk("hp100: %s: Trying shared memory mode.\n", dev->name);
572#endif
573
574 local_mode = 2;
575 hp100_outw(HP100_MEM_EN | HP100_SET_LB, OPTION_LSW);
576
577 }
578 }
579#ifdef HP100_DEBUG
580 printk("hp100: %s: new LSW = 0x%x\n", dev->name, hp100_inw(OPTION_LSW));
581#endif
582
583
584 hp100_page(HW_MAP);
585 mem_mapped = ((hp100_inw(OPTION_LSW) & (HP100_MEM_EN)) != 0);
586 mem_ptr_phys = 0UL;
587 mem_ptr_virt = NULL;
588 memory_size = (8192 << ((hp100_inb(SRAM) >> 5) & 0x07));
589 virt_memory_size = 0;
590
591
592 if (mem_mapped || (local_mode == 1)) {
593 mem_ptr_phys = (hp100_inw(MEM_MAP_LSW) | (hp100_inw(MEM_MAP_MSW) << 16));
594 mem_ptr_phys &= ~0x1fff;
595
596 if (bus == HP100_BUS_ISA && (mem_ptr_phys & ~0xfffff) != 0) {
597 printk("hp100: Can only use programmed i/o mode.\n");
598 mem_ptr_phys = 0;
599 mem_mapped = 0;
600 local_mode = 3;
601 }
602
603
604
605 if (local_mode != 1) {
606
607 for (virt_memory_size = memory_size; virt_memory_size > 16383; virt_memory_size >>= 1) {
608 if ((mem_ptr_virt = ioremap((u_long) mem_ptr_phys, virt_memory_size)) == NULL) {
609#ifdef HP100_DEBUG
610 printk("hp100: %s: ioremap for 0x%x bytes high PCI memory at 0x%lx failed\n", dev->name, virt_memory_size, mem_ptr_phys);
611#endif
612 } else {
613#ifdef HP100_DEBUG
614 printk("hp100: %s: remapped 0x%x bytes high PCI memory at 0x%lx to %p.\n", dev->name, virt_memory_size, mem_ptr_phys, mem_ptr_virt);
615#endif
616 break;
617 }
618 }
619
620 if (mem_ptr_virt == NULL) {
621 printk("hp100: Failed to ioremap the PCI card memory. Will have to use i/o mapped mode.\n");
622 local_mode = 3;
623 virt_memory_size = 0;
624 }
625 }
626 }
627
628 if (local_mode == 3) {
629 mem_mapped = 0;
630 mem_ptr_phys = 0;
631 mem_ptr_virt = NULL;
632 printk("hp100: Using (slow) programmed i/o mode.\n");
633 }
634
635
636 lp = netdev_priv(dev);
637
638 spin_lock_init(&lp->lock);
639 strlcpy(lp->id, eid, HP100_SIG_LEN);
640 lp->chip = chip;
641 lp->mode = local_mode;
642 lp->bus = bus;
643 lp->pci_dev = pci_dev;
644 lp->priority_tx = hp100_priority_tx;
645 lp->rx_ratio = hp100_rx_ratio;
646 lp->mem_ptr_phys = mem_ptr_phys;
647 lp->mem_ptr_virt = mem_ptr_virt;
648 hp100_page(ID_MAC_ADDR);
649 lp->soft_model = hp100_inb(SOFT_MODEL);
650 lp->mac1_mode = HP100_MAC1MODE3;
651 lp->mac2_mode = HP100_MAC2MODE3;
652 memset(&lp->hash_bytes, 0x00, 8);
653
654 dev->base_addr = ioaddr;
655
656 lp->memory_size = memory_size;
657 lp->virt_memory_size = virt_memory_size;
658 lp->rx_ratio = hp100_rx_ratio;
659
660 dev->open = hp100_open;
661 dev->stop = hp100_close;
662
663 if (lp->mode == 1)
664 dev->hard_start_xmit = hp100_start_xmit_bm;
665 else
666 dev->hard_start_xmit = hp100_start_xmit;
667
668 dev->get_stats = hp100_get_stats;
669 dev->set_multicast_list = &hp100_set_multicast_list;
670
671
672 if (bus == HP100_BUS_PCI) {
673 dev->irq = pci_dev->irq;
674 } else {
675 hp100_page(HW_MAP);
676 dev->irq = hp100_inb(IRQ_CHANNEL) & HP100_IRQMASK;
677 if (dev->irq == 2)
678 dev->irq = 9;
679 }
680
681 if (lp->mode == 1)
682 dev->dma = 4;
683
684
685 hp100_page(ID_MAC_ADDR);
686 for (i = uc = 0; i < 6; i++)
687 dev->dev_addr[i] = hp100_inb(LAN_ADDR + i);
688
689
690 hp100_clear_stats(lp, ioaddr);
691
692
693
694
695
696
697
698
699
700
701 if (lp->mode == 1) {
702 dma_addr_t page_baddr;
703
704
705
706
707 if ((lp->page_vaddr_algn = pci_alloc_consistent(lp->pci_dev, MAX_RINGSIZE, &page_baddr)) == NULL) {
708 err = -ENOMEM;
709 goto out2;
710 }
711 lp->whatever_offset = ((u_long) page_baddr) - ((u_long) lp->page_vaddr_algn);
712
713#ifdef HP100_DEBUG_BM
714 printk("hp100: %s: Reserved DMA memory from 0x%x to 0x%x\n", dev->name, (u_int) lp->page_vaddr_algn, (u_int) lp->page_vaddr_algn + MAX_RINGSIZE);
715#endif
716 lp->rxrcommit = lp->txrcommit = 0;
717 lp->rxrhead = lp->rxrtail = &(lp->rxring[0]);
718 lp->txrhead = lp->txrtail = &(lp->txring[0]);
719 }
720
721
722
723
724
725
726 hp100_hwinit(dev);
727
728
729 lp->lan_type = hp100_sense_lan(dev);
730
731
732 printk("hp100: at 0x%x, IRQ %d, ", ioaddr, dev->irq);
733 switch (bus) {
734 case HP100_BUS_EISA:
735 printk("EISA");
736 break;
737 case HP100_BUS_PCI:
738 printk("PCI");
739 break;
740 default:
741 printk("ISA");
742 break;
743 }
744 printk(" bus, %dk SRAM (rx/tx %d%%).\n", lp->memory_size >> 10, lp->rx_ratio);
745
746 if (lp->mode == 2) {
747 printk("hp100: Memory area at 0x%lx-0x%lx", mem_ptr_phys,
748 (mem_ptr_phys + (mem_ptr_phys > 0x100000 ? (u_long) lp->memory_size : 16 * 1024)) - 1);
749 if (mem_ptr_virt)
750 printk(" (virtual base %p)", mem_ptr_virt);
751 printk(".\n");
752
753
754 dev->mem_start = mem_ptr_phys;
755 dev->mem_end = mem_ptr_phys + lp->memory_size;
756 }
757
758 printk("hp100: ");
759 if (lp->lan_type != HP100_LAN_ERR)
760 printk("Adapter is attached to ");
761 switch (lp->lan_type) {
762 case HP100_LAN_100:
763 printk("100Mb/s Voice Grade AnyLAN network.\n");
764 break;
765 case HP100_LAN_10:
766 printk("10Mb/s network (10baseT).\n");
767 break;
768 case HP100_LAN_COAX:
769 printk("10Mb/s network (coax).\n");
770 break;
771 default:
772 printk("Warning! Link down.\n");
773 }
774
775 err = register_netdev(dev);
776 if (err)
777 goto out3;
778
779 return 0;
780out3:
781 if (local_mode == 1)
782 pci_free_consistent(lp->pci_dev, MAX_RINGSIZE + 0x0f,
783 lp->page_vaddr_algn,
784 virt_to_whatever(dev, lp->page_vaddr_algn));
785 if (mem_ptr_virt)
786 iounmap(mem_ptr_virt);
787out2:
788 release_region(ioaddr, HP100_REGION_SIZE);
789out1:
790 return err;
791}
792
793
794static void hp100_hwinit(struct net_device *dev)
795{
796 int ioaddr = dev->base_addr;
797 struct hp100_private *lp = netdev_priv(dev);
798
799#ifdef HP100_DEBUG_B
800 hp100_outw(0x4202, TRACE);
801 printk("hp100: %s: hwinit\n", dev->name);
802#endif
803
804
805
806
807 hp100_page(PERFORMANCE);
808 hp100_outw(0xfefe, IRQ_MASK);
809 hp100_outw(0xffff, IRQ_STATUS);
810
811 hp100_outw(HP100_INT_EN | HP100_RESET_LB, OPTION_LSW);
812 hp100_outw(HP100_TRI_INT | HP100_SET_HB, OPTION_LSW);
813
814 if (lp->mode == 1) {
815 hp100_BM_shutdown(dev);
816 wait();
817 } else {
818 hp100_outw(HP100_INT_EN | HP100_RESET_LB, OPTION_LSW);
819 hp100_cascade_reset(dev, 1);
820 hp100_page(MAC_CTRL);
821 hp100_andb(~(HP100_RX_EN | HP100_TX_EN), MAC_CFG_1);
822 }
823
824
825 hp100_load_eeprom(dev, 0);
826
827 wait();
828
829
830 hp100_cascade_reset(dev, 1);
831
832
833 hp100_outw(HP100_DEBUG_EN |
834 HP100_RX_HDR |
835 HP100_EE_EN |
836 HP100_BM_WRITE |
837 HP100_BM_READ | HP100_RESET_HB |
838 HP100_FAKE_INT |
839 HP100_INT_EN |
840 HP100_MEM_EN |
841 HP100_IO_EN | HP100_RESET_LB, OPTION_LSW);
842
843 hp100_outw(HP100_TRI_INT |
844 HP100_MMAP_DIS | HP100_SET_HB, OPTION_LSW);
845
846 hp100_outb(HP100_PRIORITY_TX |
847 HP100_ADV_NXT_PKT |
848 HP100_TX_CMD | HP100_RESET_LB, OPTION_MSW);
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867 hp100_mmuinit(dev);
868
869
870 wait();
871
872
873 hp100_cascade_reset(dev, 0);
874
875
876
877
878 if ((lp->lan_type == HP100_LAN_100) || (lp->lan_type == HP100_LAN_ERR))
879 hp100_login_to_vg_hub(dev, 0);
880
881}
882
883
884
885
886
887
888static void hp100_mmuinit(struct net_device *dev)
889{
890 int ioaddr = dev->base_addr;
891 struct hp100_private *lp = netdev_priv(dev);
892 int i;
893
894#ifdef HP100_DEBUG_B
895 hp100_outw(0x4203, TRACE);
896 printk("hp100: %s: mmuinit\n", dev->name);
897#endif
898
899#ifdef HP100_DEBUG
900 if (0 != (hp100_inw(OPTION_LSW) & HP100_HW_RST)) {
901 printk("hp100: %s: Not in reset when entering mmuinit. Fix me.\n", dev->name);
902 return;
903 }
904#endif
905
906
907 hp100_page(PERFORMANCE);
908 hp100_outw(0xfefe, IRQ_MASK);
909 hp100_outw(0xffff, IRQ_STATUS);
910
911
912
913
914
915
916
917
918 hp100_outw(HP100_DEBUG_EN |
919 HP100_RX_HDR |
920 HP100_EE_EN | HP100_RESET_HB |
921 HP100_IO_EN |
922 HP100_FAKE_INT |
923 HP100_INT_EN | HP100_RESET_LB, OPTION_LSW);
924
925 hp100_outw(HP100_TRI_INT | HP100_SET_HB, OPTION_LSW);
926
927 if (lp->mode == 1) {
928 hp100_outw(HP100_BM_WRITE |
929 HP100_BM_READ |
930 HP100_MMAP_DIS | HP100_SET_HB, OPTION_LSW);
931 } else if (lp->mode == 2) {
932 hp100_outw(HP100_BM_WRITE |
933 HP100_BM_READ | HP100_RESET_HB, OPTION_LSW);
934 hp100_outw(HP100_MMAP_DIS | HP100_RESET_HB, OPTION_LSW);
935 hp100_outw(HP100_MEM_EN | HP100_SET_LB, OPTION_LSW);
936 hp100_outw(HP100_IO_EN | HP100_SET_LB, OPTION_LSW);
937 } else if (lp->mode == 3) {
938 hp100_outw(HP100_MMAP_DIS | HP100_SET_HB |
939 HP100_IO_EN | HP100_SET_LB, OPTION_LSW);
940 }
941
942 hp100_page(HW_MAP);
943 hp100_outb(0, EARLYRXCFG);
944 hp100_outw(0, EARLYTXCFG);
945
946
947
948
949 if (lp->mode == 1) {
950
951 hp100_page(HW_MAP);
952 hp100_andb(~HP100_PDL_USE3, MODECTRL1);
953 hp100_andb(~HP100_TX_DUALQ, MODECTRL1);
954
955
956 hp100_orb(HP100_EN_BUS_FAIL, MODECTRL2);
957
958 hp100_outw(HP100_BM_READ | HP100_BM_WRITE | HP100_SET_HB, OPTION_LSW);
959 hp100_page(HW_MAP);
960
961 hp100_orb(HP100_BM_BURST_RD | HP100_BM_BURST_WR, BM);
962 if ((lp->chip == HP100_CHIPID_RAINIER) || (lp->chip == HP100_CHIPID_SHASTA))
963 hp100_orb(HP100_BM_PAGE_CK, BM);
964 hp100_orb(HP100_BM_MASTER, BM);
965 } else {
966
967 hp100_page(HW_MAP);
968 hp100_andb(~HP100_BM_MASTER, BM);
969 }
970
971
972
973
974 hp100_page(MMU_CFG);
975 if (lp->mode == 1) {
976 int xmit_stop, recv_stop;
977
978 if ((lp->chip == HP100_CHIPID_RAINIER)
979 || (lp->chip == HP100_CHIPID_SHASTA)) {
980 int pdl_stop;
981
982
983
984
985
986
987
988
989 pdl_stop = lp->memory_size;
990 xmit_stop = (pdl_stop - 508 * (MAX_RX_PDL) - 16) & ~(0x03ff);
991 recv_stop = (xmit_stop * (lp->rx_ratio) / 100) & ~(0x03ff);
992 hp100_outw((pdl_stop >> 4) - 1, PDL_MEM_STOP);
993#ifdef HP100_DEBUG_BM
994 printk("hp100: %s: PDL_STOP = 0x%x\n", dev->name, pdl_stop);
995#endif
996 } else {
997
998 xmit_stop = (lp->memory_size) - 1;
999 recv_stop = ((lp->memory_size * lp->rx_ratio) / 100) & ~(0x03ff);
1000 }
1001
1002 hp100_outw(xmit_stop >> 4, TX_MEM_STOP);
1003 hp100_outw(recv_stop >> 4, RX_MEM_STOP);
1004#ifdef HP100_DEBUG_BM
1005 printk("hp100: %s: TX_STOP = 0x%x\n", dev->name, xmit_stop >> 4);
1006 printk("hp100: %s: RX_STOP = 0x%x\n", dev->name, recv_stop >> 4);
1007#endif
1008 } else {
1009
1010 hp100_outw((((lp->memory_size * lp->rx_ratio) / 100) >> 4), RX_MEM_STOP);
1011 hp100_outw(((lp->memory_size - 1) >> 4), TX_MEM_STOP);
1012#ifdef HP100_DEBUG
1013 printk("hp100: %s: TX_MEM_STOP: 0x%x\n", dev->name, hp100_inw(TX_MEM_STOP));
1014 printk("hp100: %s: RX_MEM_STOP: 0x%x\n", dev->name, hp100_inw(RX_MEM_STOP));
1015#endif
1016 }
1017
1018
1019 hp100_page(MAC_ADDRESS);
1020 for (i = 0; i < 6; i++)
1021 hp100_outb(dev->dev_addr[i], MAC_ADDR + i);
1022
1023
1024 for (i = 0; i < 8; i++)
1025 hp100_outb(0x0, HASH_BYTE0 + i);
1026
1027
1028 hp100_page(MAC_CTRL);
1029
1030
1031
1032
1033 hp100_andb(~(HP100_RX_EN |
1034 HP100_TX_EN |
1035 HP100_ACC_ERRORED |
1036 HP100_ACC_MC |
1037 HP100_ACC_BC | HP100_ACC_PHY), MAC_CFG_1);
1038
1039 hp100_outb(0x00, MAC_CFG_2);
1040
1041
1042
1043 hp100_outb(0x00, VG_LAN_CFG_2);
1044
1045 if (lp->priority_tx)
1046 hp100_outb(HP100_PRIORITY_TX | HP100_SET_LB, OPTION_MSW);
1047 else
1048 hp100_outb(HP100_PRIORITY_TX | HP100_RESET_LB, OPTION_MSW);
1049
1050 hp100_outb(HP100_ADV_NXT_PKT |
1051 HP100_TX_CMD | HP100_RESET_LB, OPTION_MSW);
1052
1053
1054 if (lp->mode == 1)
1055 hp100_init_pdls(dev);
1056
1057
1058 hp100_page(PERFORMANCE);
1059 hp100_outw(0xfefe, IRQ_MASK);
1060 hp100_outw(0xffff, IRQ_STATUS);
1061}
1062
1063
1064
1065
1066
1067static int hp100_open(struct net_device *dev)
1068{
1069 struct hp100_private *lp = netdev_priv(dev);
1070#ifdef HP100_DEBUG_B
1071 int ioaddr = dev->base_addr;
1072#endif
1073
1074#ifdef HP100_DEBUG_B
1075 hp100_outw(0x4204, TRACE);
1076 printk("hp100: %s: open\n", dev->name);
1077#endif
1078
1079
1080 if (request_irq(dev->irq, hp100_interrupt,
1081 lp->bus == HP100_BUS_PCI || lp->bus ==
1082 HP100_BUS_EISA ? IRQF_SHARED : IRQF_DISABLED,
1083 "hp100", dev)) {
1084 printk("hp100: %s: unable to get IRQ %d\n", dev->name, dev->irq);
1085 return -EAGAIN;
1086 }
1087
1088 dev->trans_start = jiffies;
1089 netif_start_queue(dev);
1090
1091 lp->lan_type = hp100_sense_lan(dev);
1092 lp->mac1_mode = HP100_MAC1MODE3;
1093 lp->mac2_mode = HP100_MAC2MODE3;
1094 memset(&lp->hash_bytes, 0x00, 8);
1095
1096 hp100_stop_interface(dev);
1097
1098 hp100_hwinit(dev);
1099
1100 hp100_start_interface(dev);
1101
1102 return 0;
1103}
1104
1105
1106static int hp100_close(struct net_device *dev)
1107{
1108 int ioaddr = dev->base_addr;
1109 struct hp100_private *lp = netdev_priv(dev);
1110
1111#ifdef HP100_DEBUG_B
1112 hp100_outw(0x4205, TRACE);
1113 printk("hp100: %s: close\n", dev->name);
1114#endif
1115
1116 hp100_page(PERFORMANCE);
1117 hp100_outw(0xfefe, IRQ_MASK);
1118
1119 hp100_stop_interface(dev);
1120
1121 if (lp->lan_type == HP100_LAN_100)
1122 lp->hub_status = hp100_login_to_vg_hub(dev, 0);
1123
1124 netif_stop_queue(dev);
1125
1126 free_irq(dev->irq, dev);
1127
1128#ifdef HP100_DEBUG
1129 printk("hp100: %s: close LSW = 0x%x\n", dev->name,
1130 hp100_inw(OPTION_LSW));
1131#endif
1132
1133 return 0;
1134}
1135
1136
1137
1138
1139
1140static void hp100_init_pdls(struct net_device *dev)
1141{
1142 struct hp100_private *lp = netdev_priv(dev);
1143 hp100_ring_t *ringptr;
1144 u_int *pageptr;
1145 int i;
1146
1147#ifdef HP100_DEBUG_B
1148 int ioaddr = dev->base_addr;
1149#endif
1150
1151#ifdef HP100_DEBUG_B
1152 hp100_outw(0x4206, TRACE);
1153 printk("hp100: %s: init pdls\n", dev->name);
1154#endif
1155
1156 if (!lp->page_vaddr_algn)
1157 printk("hp100: %s: Warning: lp->page_vaddr_algn not initialised!\n", dev->name);
1158 else {
1159
1160
1161
1162
1163 memset(lp->page_vaddr_algn, 0, MAX_RINGSIZE);
1164 pageptr = lp->page_vaddr_algn;
1165
1166 lp->rxrcommit = 0;
1167 ringptr = lp->rxrhead = lp->rxrtail = &(lp->rxring[0]);
1168
1169
1170 for (i = MAX_RX_PDL - 1; i >= 0; i--) {
1171 lp->rxring[i].next = ringptr;
1172 ringptr = &(lp->rxring[i]);
1173 pageptr += hp100_init_rxpdl(dev, ringptr, pageptr);
1174 }
1175
1176
1177 lp->txrcommit = 0;
1178 ringptr = lp->txrhead = lp->txrtail = &(lp->txring[0]);
1179 for (i = MAX_TX_PDL - 1; i >= 0; i--) {
1180 lp->txring[i].next = ringptr;
1181 ringptr = &(lp->txring[i]);
1182 pageptr += hp100_init_txpdl(dev, ringptr, pageptr);
1183 }
1184 }
1185}
1186
1187
1188
1189
1190static int hp100_init_rxpdl(struct net_device *dev,
1191 register hp100_ring_t * ringptr,
1192 register u32 * pdlptr)
1193{
1194
1195
1196 if (0 != (((unsigned long) pdlptr) & 0xf))
1197 printk("hp100: %s: Init rxpdl: Unaligned pdlptr 0x%lx.\n",
1198 dev->name, (unsigned long) pdlptr);
1199
1200 ringptr->pdl = pdlptr + 1;
1201 ringptr->pdl_paddr = virt_to_whatever(dev, pdlptr + 1);
1202 ringptr->skb = (void *) NULL;
1203
1204
1205
1206
1207
1208
1209
1210
1211
1212 *(pdlptr + 2) = (u_int) virt_to_whatever(dev, pdlptr);
1213 *(pdlptr + 3) = 4;
1214
1215 return ((((MAX_RX_FRAG * 2 + 2) + 3) / 4) * 4);
1216}
1217
1218
1219static int hp100_init_txpdl(struct net_device *dev,
1220 register hp100_ring_t * ringptr,
1221 register u32 * pdlptr)
1222{
1223 if (0 != (((unsigned long) pdlptr) & 0xf))
1224 printk("hp100: %s: Init txpdl: Unaligned pdlptr 0x%lx.\n", dev->name, (unsigned long) pdlptr);
1225
1226 ringptr->pdl = pdlptr;
1227 ringptr->pdl_paddr = virt_to_whatever(dev, pdlptr);
1228 ringptr->skb = (void *) NULL;
1229
1230 return ((((MAX_TX_FRAG * 2 + 2) + 3) / 4) * 4);
1231}
1232
1233
1234
1235
1236
1237
1238
1239
1240static int hp100_build_rx_pdl(hp100_ring_t * ringptr,
1241 struct net_device *dev)
1242{
1243#ifdef HP100_DEBUG_B
1244 int ioaddr = dev->base_addr;
1245#endif
1246#ifdef HP100_DEBUG_BM
1247 u_int *p;
1248#endif
1249
1250#ifdef HP100_DEBUG_B
1251 hp100_outw(0x4207, TRACE);
1252 printk("hp100: %s: build rx pdl\n", dev->name);
1253#endif
1254
1255
1256
1257
1258
1259 ringptr->skb = dev_alloc_skb(((MAX_ETHER_SIZE + 2 + 3) / 4) * 4);
1260
1261 if (NULL != ringptr->skb) {
1262
1263
1264
1265
1266
1267 skb_reserve(ringptr->skb, 2);
1268
1269 ringptr->skb->dev = dev;
1270 ringptr->skb->data = (u_char *) skb_put(ringptr->skb, MAX_ETHER_SIZE);
1271
1272
1273
1274
1275
1276
1277
1278
1279#ifdef HP100_DEBUG_BM
1280 printk("hp100: %s: build_rx_pdl: PDH@0x%x, skb->data (len %d) at 0x%x\n",
1281 dev->name, (u_int) ringptr->pdl,
1282 ((MAX_ETHER_SIZE + 2 + 3) / 4) * 4,
1283 (unsigned int) ringptr->skb->data);
1284#endif
1285
1286
1287
1288 ringptr->pdl[0] = 0x00020000;
1289 ringptr->pdl[3] = pdl_map_data(netdev_priv(dev),
1290 ringptr->skb->data);
1291 ringptr->pdl[4] = MAX_ETHER_SIZE;
1292
1293#ifdef HP100_DEBUG_BM
1294 for (p = (ringptr->pdl); p < (ringptr->pdl + 5); p++)
1295 printk("hp100: %s: Adr 0x%.8x = 0x%.8x\n", dev->name, (u_int) p, (u_int) * p);
1296#endif
1297 return (1);
1298 }
1299
1300
1301
1302
1303
1304#ifdef HP100_DEBUG_BM
1305 printk("hp100: %s: build_rx_pdl: PDH@0x%x, No space for skb.\n", dev->name, (u_int) ringptr->pdl);
1306#endif
1307
1308 ringptr->pdl[0] = 0x00010000;
1309
1310 return (0);
1311}
1312
1313
1314
1315
1316
1317
1318
1319
1320
1321
1322
1323static void hp100_rxfill(struct net_device *dev)
1324{
1325 int ioaddr = dev->base_addr;
1326
1327 struct hp100_private *lp = netdev_priv(dev);
1328 hp100_ring_t *ringptr;
1329
1330#ifdef HP100_DEBUG_B
1331 hp100_outw(0x4208, TRACE);
1332 printk("hp100: %s: rxfill\n", dev->name);
1333#endif
1334
1335 hp100_page(PERFORMANCE);
1336
1337 while (lp->rxrcommit < MAX_RX_PDL) {
1338
1339
1340
1341 ringptr = lp->rxrtail;
1342 if (0 == hp100_build_rx_pdl(ringptr, dev)) {
1343 return;
1344 }
1345
1346
1347
1348#ifdef HP100_DEBUG_BM
1349 printk("hp100: %s: rxfill: Hand to card: pdl #%d @0x%x phys:0x%x, buffer: 0x%x\n",
1350 dev->name, lp->rxrcommit, (u_int) ringptr->pdl,
1351 (u_int) ringptr->pdl_paddr, (u_int) ringptr->pdl[3]);
1352#endif
1353
1354 hp100_outl((u32) ringptr->pdl_paddr, RX_PDA);
1355
1356 lp->rxrcommit += 1;
1357 lp->rxrtail = ringptr->next;
1358 }
1359}
1360
1361
1362
1363
1364
1365static void hp100_BM_shutdown(struct net_device *dev)
1366{
1367 int ioaddr = dev->base_addr;
1368 struct hp100_private *lp = netdev_priv(dev);
1369 unsigned long time;
1370
1371#ifdef HP100_DEBUG_B
1372 hp100_outw(0x4209, TRACE);
1373 printk("hp100: %s: bm shutdown\n", dev->name);
1374#endif
1375
1376 hp100_page(PERFORMANCE);
1377 hp100_outw(0xfefe, IRQ_MASK);
1378 hp100_outw(0xffff, IRQ_STATUS);
1379
1380
1381 hp100_outw(HP100_INT_EN | HP100_RESET_LB, OPTION_LSW);
1382
1383
1384 hp100_page(MAC_CTRL);
1385 hp100_andb(~(HP100_RX_EN | HP100_TX_EN), MAC_CFG_1);
1386
1387
1388 if (0 != (hp100_inw(OPTION_LSW) & HP100_HW_RST)) {
1389
1390
1391
1392 hp100_page(MAC_CTRL);
1393 for (time = 0; time < 5000; time++) {
1394 if ((hp100_inb(MAC_CFG_1) & (HP100_TX_IDLE | HP100_RX_IDLE)) == (HP100_TX_IDLE | HP100_RX_IDLE))
1395 break;
1396 }
1397
1398
1399 if (lp->chip == HP100_CHIPID_LASSEN) {
1400
1401 hp100_page(HW_MAP);
1402 hp100_andb(~HP100_BM_MASTER, BM);
1403
1404 for (time = 0; time < 32000; time++) {
1405 if (0 == (hp100_inb(BM) & HP100_BM_MASTER))
1406 break;
1407 }
1408 } else {
1409
1410
1411
1412 hp100_page(PERFORMANCE);
1413
1414 for (time = 0; time < 10000; time++) {
1415
1416
1417 if ((hp100_inb(RX_PDL) == 0) && (hp100_inb(RX_PKT_CNT) == 0))
1418 break;
1419 }
1420
1421 if (time >= 10000)
1422 printk("hp100: %s: BM shutdown error.\n", dev->name);
1423
1424
1425
1426
1427
1428
1429 for (time = 0; time < 10000; time++) {
1430 if ((0 == hp100_inb(TX_PKT_CNT)) &&
1431 (0 != (hp100_inb(TX_MEM_FREE) & HP100_AUTO_COMPARE)))
1432 break;
1433 }
1434
1435
1436 hp100_page(HW_MAP);
1437 hp100_andb(~HP100_BM_MASTER, BM);
1438 }
1439
1440 hp100_cascade_reset(dev, 1);
1441 }
1442 hp100_page(PERFORMANCE);
1443
1444
1445}
1446
1447static int hp100_check_lan(struct net_device *dev)
1448{
1449 struct hp100_private *lp = netdev_priv(dev);
1450
1451 if (lp->lan_type < 0) {
1452 hp100_stop_interface(dev);
1453 if ((lp->lan_type = hp100_sense_lan(dev)) < 0) {
1454 printk("hp100: %s: no connection found - check wire\n", dev->name);
1455 hp100_start_interface(dev);
1456 return -EIO;
1457 }
1458 if (lp->lan_type == HP100_LAN_100)
1459 lp->hub_status = hp100_login_to_vg_hub(dev, 0);
1460 hp100_start_interface(dev);
1461 }
1462 return 0;
1463}
1464
1465
1466
1467
1468
1469
1470static int hp100_start_xmit_bm(struct sk_buff *skb, struct net_device *dev)
1471{
1472 unsigned long flags;
1473 int i, ok_flag;
1474 int ioaddr = dev->base_addr;
1475 struct hp100_private *lp = netdev_priv(dev);
1476 hp100_ring_t *ringptr;
1477
1478#ifdef HP100_DEBUG_B
1479 hp100_outw(0x4210, TRACE);
1480 printk("hp100: %s: start_xmit_bm\n", dev->name);
1481#endif
1482
1483 if (skb == NULL) {
1484 return 0;
1485 }
1486
1487 if (skb->len <= 0)
1488 return 0;
1489
1490 if (lp->chip == HP100_CHIPID_SHASTA && skb_padto(skb, ETH_ZLEN))
1491 return 0;
1492
1493
1494 if (lp->txrtail->next == lp->txrhead) {
1495
1496#ifdef HP100_DEBUG
1497 printk("hp100: %s: start_xmit_bm: No TX PDL available.\n", dev->name);
1498#endif
1499
1500 if (time_before(jiffies, dev->trans_start + HZ))
1501 return -EAGAIN;
1502
1503 if (hp100_check_lan(dev))
1504 return -EIO;
1505
1506 if (lp->lan_type == HP100_LAN_100 && lp->hub_status < 0) {
1507
1508 printk("hp100: %s: login to 100Mb/s hub retry\n", dev->name);
1509 hp100_stop_interface(dev);
1510 lp->hub_status = hp100_login_to_vg_hub(dev, 0);
1511 hp100_start_interface(dev);
1512 } else {
1513 spin_lock_irqsave(&lp->lock, flags);
1514 hp100_ints_off();
1515 i = hp100_sense_lan(dev);
1516 hp100_ints_on();
1517 spin_unlock_irqrestore(&lp->lock, flags);
1518 if (i == HP100_LAN_ERR)
1519 printk("hp100: %s: link down detected\n", dev->name);
1520 else if (lp->lan_type != i) {
1521
1522 printk("hp100: %s: cable change 10Mb/s <-> 100Mb/s detected\n", dev->name);
1523 lp->lan_type = i;
1524 hp100_stop_interface(dev);
1525 if (lp->lan_type == HP100_LAN_100)
1526 lp->hub_status = hp100_login_to_vg_hub(dev, 0);
1527 hp100_start_interface(dev);
1528 } else {
1529 printk("hp100: %s: interface reset\n", dev->name);
1530 hp100_stop_interface(dev);
1531 if (lp->lan_type == HP100_LAN_100)
1532 lp->hub_status = hp100_login_to_vg_hub(dev, 0);
1533 hp100_start_interface(dev);
1534 }
1535 }
1536
1537 dev->trans_start = jiffies;
1538 return -EAGAIN;
1539 }
1540
1541
1542
1543
1544
1545 spin_lock_irqsave(&lp->lock, flags);
1546 ringptr = lp->txrtail;
1547 lp->txrtail = ringptr->next;
1548
1549
1550 ok_flag = skb->len >= HP100_MIN_PACKET_SIZE;
1551 i = ok_flag ? skb->len : HP100_MIN_PACKET_SIZE;
1552
1553 ringptr->skb = skb;
1554 ringptr->pdl[0] = ((1 << 16) | i);
1555 if (lp->chip == HP100_CHIPID_SHASTA) {
1556
1557 ringptr->pdl[2] = i;
1558 } else {
1559
1560 ringptr->pdl[2] = skb->len;
1561 }
1562
1563
1564 ringptr->pdl[1] = ((u32) pci_map_single(lp->pci_dev, skb->data, ringptr->pdl[2], PCI_DMA_TODEVICE));
1565
1566
1567 hp100_outl(ringptr->pdl_paddr, TX_PDA_L);
1568
1569 lp->txrcommit++;
1570 spin_unlock_irqrestore(&lp->lock, flags);
1571
1572
1573 lp->stats.tx_packets++;
1574 lp->stats.tx_bytes += skb->len;
1575 dev->trans_start = jiffies;
1576
1577 return 0;
1578}
1579
1580
1581
1582
1583
1584
1585
1586
1587
1588static void hp100_clean_txring(struct net_device *dev)
1589{
1590 struct hp100_private *lp = netdev_priv(dev);
1591 int ioaddr = dev->base_addr;
1592 int donecount;
1593
1594#ifdef HP100_DEBUG_B
1595 hp100_outw(0x4211, TRACE);
1596 printk("hp100: %s: clean txring\n", dev->name);
1597#endif
1598
1599
1600 donecount = (lp->txrcommit) - hp100_inb(TX_PDL);
1601
1602#ifdef HP100_DEBUG
1603 if (donecount > MAX_TX_PDL)
1604 printk("hp100: %s: Warning: More PDLs transmitted than commited to card???\n", dev->name);
1605#endif
1606
1607 for (; 0 != donecount; donecount--) {
1608#ifdef HP100_DEBUG_BM
1609 printk("hp100: %s: Free skb: data @0x%.8x txrcommit=0x%x TXPDL=0x%x, done=0x%x\n",
1610 dev->name, (u_int) lp->txrhead->skb->data,
1611 lp->txrcommit, hp100_inb(TX_PDL), donecount);
1612#endif
1613
1614 pci_unmap_single(lp->pci_dev, (dma_addr_t) lp->txrhead->pdl[1], lp->txrhead->pdl[2], PCI_DMA_TODEVICE);
1615 dev_kfree_skb_any(lp->txrhead->skb);
1616 lp->txrhead->skb = (void *) NULL;
1617 lp->txrhead = lp->txrhead->next;
1618 lp->txrcommit--;
1619 }
1620}
1621
1622
1623static int hp100_start_xmit(struct sk_buff *skb, struct net_device *dev)
1624{
1625 unsigned long flags;
1626 int i, ok_flag;
1627 int ioaddr = dev->base_addr;
1628 u_short val;
1629 struct hp100_private *lp = netdev_priv(dev);
1630
1631#ifdef HP100_DEBUG_B
1632 hp100_outw(0x4212, TRACE);
1633 printk("hp100: %s: start_xmit\n", dev->name);
1634#endif
1635
1636 if (skb == NULL) {
1637 return 0;
1638 }
1639
1640 if (skb->len <= 0)
1641 return 0;
1642
1643 if (hp100_check_lan(dev))
1644 return -EIO;
1645
1646
1647 i = hp100_inl(TX_MEM_FREE) & 0x7fffffff;
1648 if (!(((i / 2) - 539) > (skb->len + 16) && (hp100_inb(TX_PKT_CNT) < 255))) {
1649#ifdef HP100_DEBUG
1650 printk("hp100: %s: start_xmit: tx free mem = 0x%x\n", dev->name, i);
1651#endif
1652
1653 if (time_before(jiffies, dev->trans_start + HZ)) {
1654#ifdef HP100_DEBUG
1655 printk("hp100: %s: trans_start timing problem\n",
1656 dev->name);
1657#endif
1658 return -EAGAIN;
1659 }
1660 if (lp->lan_type == HP100_LAN_100 && lp->hub_status < 0) {
1661
1662 printk("hp100: %s: login to 100Mb/s hub retry\n", dev->name);
1663 hp100_stop_interface(dev);
1664 lp->hub_status = hp100_login_to_vg_hub(dev, 0);
1665 hp100_start_interface(dev);
1666 } else {
1667 spin_lock_irqsave(&lp->lock, flags);
1668 hp100_ints_off();
1669 i = hp100_sense_lan(dev);
1670 hp100_ints_on();
1671 spin_unlock_irqrestore(&lp->lock, flags);
1672 if (i == HP100_LAN_ERR)
1673 printk("hp100: %s: link down detected\n", dev->name);
1674 else if (lp->lan_type != i) {
1675
1676 printk("hp100: %s: cable change 10Mb/s <-> 100Mb/s detected\n", dev->name);
1677 lp->lan_type = i;
1678 hp100_stop_interface(dev);
1679 if (lp->lan_type == HP100_LAN_100)
1680 lp->hub_status = hp100_login_to_vg_hub(dev, 0);
1681 hp100_start_interface(dev);
1682 } else {
1683 printk("hp100: %s: interface reset\n", dev->name);
1684 hp100_stop_interface(dev);
1685 if (lp->lan_type == HP100_LAN_100)
1686 lp->hub_status = hp100_login_to_vg_hub(dev, 0);
1687 hp100_start_interface(dev);
1688 mdelay(1);
1689 }
1690 }
1691 dev->trans_start = jiffies;
1692 return -EAGAIN;
1693 }
1694
1695 for (i = 0; i < 6000 && (hp100_inb(OPTION_MSW) & HP100_TX_CMD); i++) {
1696#ifdef HP100_DEBUG_TX
1697 printk("hp100: %s: start_xmit: busy\n", dev->name);
1698#endif
1699 }
1700
1701 spin_lock_irqsave(&lp->lock, flags);
1702 hp100_ints_off();
1703 val = hp100_inw(IRQ_STATUS);
1704
1705
1706 hp100_outw(HP100_TX_COMPLETE, IRQ_STATUS);
1707#ifdef HP100_DEBUG_TX
1708 printk("hp100: %s: start_xmit: irq_status=0x%.4x, irqmask=0x%.4x, len=%d\n",
1709 dev->name, val, hp100_inw(IRQ_MASK), (int) skb->len);
1710#endif
1711
1712 ok_flag = skb->len >= HP100_MIN_PACKET_SIZE;
1713 i = ok_flag ? skb->len : HP100_MIN_PACKET_SIZE;
1714
1715 hp100_outw(i, DATA32);
1716 hp100_outw(i, FRAGMENT_LEN);
1717
1718 if (lp->mode == 2) {
1719
1720 memcpy_toio(lp->mem_ptr_virt, skb->data, (skb->len + 3) & ~3);
1721 if (!ok_flag)
1722 memset_io(lp->mem_ptr_virt, 0, HP100_MIN_PACKET_SIZE - skb->len);
1723 } else {
1724 outsl(ioaddr + HP100_REG_DATA32, skb->data,
1725 (skb->len + 3) >> 2);
1726 if (!ok_flag)
1727 for (i = (skb->len + 3) & ~3; i < HP100_MIN_PACKET_SIZE; i += 4)
1728 hp100_outl(0, DATA32);
1729 }
1730
1731 hp100_outb(HP100_TX_CMD | HP100_SET_LB, OPTION_MSW);
1732
1733 lp->stats.tx_packets++;
1734 lp->stats.tx_bytes += skb->len;
1735 dev->trans_start = jiffies;
1736 hp100_ints_on();
1737 spin_unlock_irqrestore(&lp->lock, flags);
1738
1739 dev_kfree_skb_any(skb);
1740
1741#ifdef HP100_DEBUG_TX
1742 printk("hp100: %s: start_xmit: end\n", dev->name);
1743#endif
1744
1745 return 0;
1746}
1747
1748
1749
1750
1751
1752
1753
1754
1755
1756
1757
1758static void hp100_rx(struct net_device *dev)
1759{
1760 int packets, pkt_len;
1761 int ioaddr = dev->base_addr;
1762 struct hp100_private *lp = netdev_priv(dev);
1763 u_int header;
1764 struct sk_buff *skb;
1765
1766#ifdef DEBUG_B
1767 hp100_outw(0x4213, TRACE);
1768 printk("hp100: %s: rx\n", dev->name);
1769#endif
1770
1771
1772
1773
1774 packets = hp100_inb(RX_PKT_CNT);
1775#ifdef HP100_DEBUG_RX
1776 if (packets > 1)
1777 printk("hp100: %s: rx: waiting packets = %d\n", dev->name, packets);
1778#endif
1779
1780 while (packets-- > 0) {
1781
1782
1783 for (pkt_len = 0; pkt_len < 6000 && (hp100_inb(OPTION_MSW) & HP100_ADV_NXT_PKT); pkt_len++) {
1784#ifdef HP100_DEBUG_RX
1785 printk ("hp100: %s: rx: busy, remaining packets = %d\n", dev->name, packets);
1786#endif
1787 }
1788
1789
1790
1791 if (lp->mode == 2) {
1792 header = readl(lp->mem_ptr_virt);
1793 } else
1794 header = hp100_inl(DATA32);
1795
1796 pkt_len = ((header & HP100_PKT_LEN_MASK) + 3) & ~3;
1797
1798#ifdef HP100_DEBUG_RX
1799 printk("hp100: %s: rx: new packet - length=%d, errors=0x%x, dest=0x%x\n",
1800 dev->name, header & HP100_PKT_LEN_MASK,
1801 (header >> 16) & 0xfff8, (header >> 16) & 7);
1802#endif
1803
1804
1805 skb = dev_alloc_skb(pkt_len+2);
1806 if (skb == NULL) {
1807#ifdef HP100_DEBUG
1808 printk("hp100: %s: rx: couldn't allocate a sk_buff of size %d\n",
1809 dev->name, pkt_len);
1810#endif
1811 lp->stats.rx_dropped++;
1812 } else {
1813
1814 u_char *ptr;
1815
1816 skb_reserve(skb,2);
1817
1818
1819 skb_put(skb, pkt_len);
1820 ptr = skb->data;
1821
1822
1823 if (lp->mode == 2)
1824 memcpy_fromio(ptr, lp->mem_ptr_virt,pkt_len);
1825 else
1826 insl(ioaddr + HP100_REG_DATA32, ptr, pkt_len >> 2);
1827
1828 skb->protocol = eth_type_trans(skb, dev);
1829
1830#ifdef HP100_DEBUG_RX
1831 printk("hp100: %s: rx: %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x\n",
1832 dev->name, ptr[0], ptr[1], ptr[2], ptr[3],
1833 ptr[4], ptr[5], ptr[6], ptr[7], ptr[8],
1834 ptr[9], ptr[10], ptr[11]);
1835#endif
1836 netif_rx(skb);
1837 dev->last_rx = jiffies;
1838 lp->stats.rx_packets++;
1839 lp->stats.rx_bytes += pkt_len;
1840 }
1841
1842
1843 hp100_outb(HP100_ADV_NXT_PKT | HP100_SET_LB, OPTION_MSW);
1844
1845 switch (header & 0x00070000) {
1846 case (HP100_MULTI_ADDR_HASH << 16):
1847 case (HP100_MULTI_ADDR_NO_HASH << 16):
1848 lp->stats.multicast++;
1849 break;
1850 }
1851 }
1852#ifdef HP100_DEBUG_RX
1853 printk("hp100_rx: %s: end\n", dev->name);
1854#endif
1855}
1856
1857
1858
1859
1860static void hp100_rx_bm(struct net_device *dev)
1861{
1862 int ioaddr = dev->base_addr;
1863 struct hp100_private *lp = netdev_priv(dev);
1864 hp100_ring_t *ptr;
1865 u_int header;
1866 int pkt_len;
1867
1868#ifdef HP100_DEBUG_B
1869 hp100_outw(0x4214, TRACE);
1870 printk("hp100: %s: rx_bm\n", dev->name);
1871#endif
1872
1873#ifdef HP100_DEBUG
1874 if (0 == lp->rxrcommit) {
1875 printk("hp100: %s: rx_bm called although no PDLs were committed to adapter?\n", dev->name);
1876 return;
1877 } else
1878
1879
1880 if ((hp100_inw(RX_PKT_CNT) & 0x00ff) >= lp->rxrcommit) {
1881 printk("hp100: %s: More packets received than commited? RX_PKT_CNT=0x%x, commit=0x%x\n",
1882 dev->name, hp100_inw(RX_PKT_CNT) & 0x00ff,
1883 lp->rxrcommit);
1884 return;
1885 }
1886#endif
1887
1888 while ((lp->rxrcommit > hp100_inb(RX_PDL))) {
1889
1890
1891
1892
1893
1894
1895
1896
1897 ptr = lp->rxrhead;
1898
1899 header = *(ptr->pdl - 1);
1900 pkt_len = (header & HP100_PKT_LEN_MASK);
1901
1902
1903 pci_unmap_single(lp->pci_dev, (dma_addr_t) ptr->pdl[3], MAX_ETHER_SIZE, PCI_DMA_FROMDEVICE);
1904
1905#ifdef HP100_DEBUG_BM
1906 printk("hp100: %s: rx_bm: header@0x%x=0x%x length=%d, errors=0x%x, dest=0x%x\n",
1907 dev->name, (u_int) (ptr->pdl - 1), (u_int) header,
1908 pkt_len, (header >> 16) & 0xfff8, (header >> 16) & 7);
1909 printk("hp100: %s: RX_PDL_COUNT:0x%x TX_PDL_COUNT:0x%x, RX_PKT_CNT=0x%x PDH=0x%x, Data@0x%x len=0x%x\n",
1910 dev->name, hp100_inb(RX_PDL), hp100_inb(TX_PDL),
1911 hp100_inb(RX_PKT_CNT), (u_int) * (ptr->pdl),
1912 (u_int) * (ptr->pdl + 3), (u_int) * (ptr->pdl + 4));
1913#endif
1914
1915 if ((pkt_len >= MIN_ETHER_SIZE) &&
1916 (pkt_len <= MAX_ETHER_SIZE)) {
1917 if (ptr->skb == NULL) {
1918 printk("hp100: %s: rx_bm: skb null\n", dev->name);
1919
1920 lp->stats.rx_dropped++;
1921 } else {
1922 skb_trim(ptr->skb, pkt_len);
1923 ptr->skb->protocol =
1924 eth_type_trans(ptr->skb, dev);
1925
1926 netif_rx(ptr->skb);
1927
1928 dev->last_rx = jiffies;
1929 lp->stats.rx_packets++;
1930 lp->stats.rx_bytes += pkt_len;
1931 }
1932
1933 switch (header & 0x00070000) {
1934 case (HP100_MULTI_ADDR_HASH << 16):
1935 case (HP100_MULTI_ADDR_NO_HASH << 16):
1936 lp->stats.multicast++;
1937 break;
1938 }
1939 } else {
1940#ifdef HP100_DEBUG
1941 printk("hp100: %s: rx_bm: Received bad packet (length=%d)\n", dev->name, pkt_len);
1942#endif
1943 if (ptr->skb != NULL)
1944 dev_kfree_skb_any(ptr->skb);
1945 lp->stats.rx_errors++;
1946 }
1947
1948 lp->rxrhead = lp->rxrhead->next;
1949
1950
1951 if (0 == hp100_build_rx_pdl(lp->rxrtail, dev)) {
1952
1953#ifdef HP100_DEBUG
1954 printk("hp100: %s: rx_bm: No space for new PDL.\n", dev->name);
1955#endif
1956 return;
1957 } else {
1958 hp100_outl((u32) lp->rxrtail->pdl_paddr, RX_PDA);
1959 lp->rxrtail = lp->rxrtail->next;
1960 }
1961
1962 }
1963}
1964
1965
1966
1967
1968static struct net_device_stats *hp100_get_stats(struct net_device *dev)
1969{
1970 unsigned long flags;
1971 int ioaddr = dev->base_addr;
1972 struct hp100_private *lp = netdev_priv(dev);
1973
1974#ifdef HP100_DEBUG_B
1975 hp100_outw(0x4215, TRACE);
1976#endif
1977
1978 spin_lock_irqsave(&lp->lock, flags);
1979 hp100_ints_off();
1980 hp100_update_stats(dev);
1981 hp100_ints_on();
1982 spin_unlock_irqrestore(&lp->lock, flags);
1983 return &(lp->stats);
1984}
1985
1986static void hp100_update_stats(struct net_device *dev)
1987{
1988 int ioaddr = dev->base_addr;
1989 u_short val;
1990 struct hp100_private *lp = netdev_priv(dev);
1991
1992#ifdef HP100_DEBUG_B
1993 hp100_outw(0x4216, TRACE);
1994 printk("hp100: %s: update-stats\n", dev->name);
1995#endif
1996
1997
1998 hp100_page(MAC_CTRL);
1999 val = hp100_inw(DROPPED) & 0x0fff;
2000 lp->stats.rx_errors += val;
2001 lp->stats.rx_over_errors += val;
2002 val = hp100_inb(CRC);
2003 lp->stats.rx_errors += val;
2004 lp->stats.rx_crc_errors += val;
2005 val = hp100_inb(ABORT);
2006 lp->stats.tx_errors += val;
2007 lp->stats.tx_aborted_errors += val;
2008 hp100_page(PERFORMANCE);
2009}
2010
2011static void hp100_misc_interrupt(struct net_device *dev)
2012{
2013#ifdef HP100_DEBUG_B
2014 int ioaddr = dev->base_addr;
2015#endif
2016 struct hp100_private *lp = netdev_priv(dev);
2017
2018#ifdef HP100_DEBUG_B
2019 int ioaddr = dev->base_addr;
2020 hp100_outw(0x4216, TRACE);
2021 printk("hp100: %s: misc_interrupt\n", dev->name);
2022#endif
2023
2024
2025 lp->stats.rx_errors++;
2026 lp->stats.tx_errors++;
2027}
2028
2029static void hp100_clear_stats(struct hp100_private *lp, int ioaddr)
2030{
2031 unsigned long flags;
2032
2033#ifdef HP100_DEBUG_B
2034 hp100_outw(0x4217, TRACE);
2035 printk("hp100: %s: clear_stats\n", dev->name);
2036#endif
2037
2038 spin_lock_irqsave(&lp->lock, flags);
2039 hp100_page(MAC_CTRL);
2040 hp100_inw(DROPPED);
2041 hp100_inb(CRC);
2042 hp100_inb(ABORT);
2043 hp100_page(PERFORMANCE);
2044 spin_unlock_irqrestore(&lp->lock, flags);
2045}
2046
2047
2048
2049
2050
2051
2052
2053
2054
2055
2056static void hp100_set_multicast_list(struct net_device *dev)
2057{
2058 unsigned long flags;
2059 int ioaddr = dev->base_addr;
2060 struct hp100_private *lp = netdev_priv(dev);
2061
2062#ifdef HP100_DEBUG_B
2063 hp100_outw(0x4218, TRACE);
2064 printk("hp100: %s: set_mc_list\n", dev->name);
2065#endif
2066
2067 spin_lock_irqsave(&lp->lock, flags);
2068 hp100_ints_off();
2069 hp100_page(MAC_CTRL);
2070 hp100_andb(~(HP100_RX_EN | HP100_TX_EN), MAC_CFG_1);
2071
2072 if (dev->flags & IFF_PROMISC) {
2073 lp->mac2_mode = HP100_MAC2MODE6;
2074 lp->mac1_mode = HP100_MAC1MODE6;
2075 memset(&lp->hash_bytes, 0xff, 8);
2076 } else if (dev->mc_count || (dev->flags & IFF_ALLMULTI)) {
2077 lp->mac2_mode = HP100_MAC2MODE5;
2078 lp->mac1_mode = HP100_MAC1MODE5;
2079#ifdef HP100_MULTICAST_FILTER
2080 if (dev->flags & IFF_ALLMULTI) {
2081
2082 memset(&lp->hash_bytes, 0xff, 8);
2083 } else {
2084 int i, j, idx;
2085 u_char *addrs;
2086 struct dev_mc_list *dmi;
2087
2088 memset(&lp->hash_bytes, 0x00, 8);
2089#ifdef HP100_DEBUG
2090 printk("hp100: %s: computing hash filter - mc_count = %i\n", dev->name, dev->mc_count);
2091#endif
2092 for (i = 0, dmi = dev->mc_list; i < dev->mc_count; i++, dmi = dmi->next) {
2093 addrs = dmi->dmi_addr;
2094 if ((*addrs & 0x01) == 0x01) {
2095#ifdef HP100_DEBUG
2096 DECLARE_MAC_BUF(mac);
2097 printk("hp100: %s: multicast = %s, ",
2098 dev->name, print_mac(mac, addrs));
2099#endif
2100 for (j = idx = 0; j < 6; j++) {
2101 idx ^= *addrs++ & 0x3f;
2102 printk(":%02x:", idx);
2103 }
2104#ifdef HP100_DEBUG
2105 printk("idx = %i\n", idx);
2106#endif
2107 lp->hash_bytes[idx >> 3] |= (1 << (idx & 7));
2108 }
2109 }
2110 }
2111#else
2112 memset(&lp->hash_bytes, 0xff, 8);
2113#endif
2114 } else {
2115 lp->mac2_mode = HP100_MAC2MODE3;
2116 lp->mac1_mode = HP100_MAC1MODE3;
2117 memset(&lp->hash_bytes, 0x00, 8);
2118 }
2119
2120 if (((hp100_inb(MAC_CFG_1) & 0x0f) != lp->mac1_mode) ||
2121 (hp100_inb(MAC_CFG_2) != lp->mac2_mode)) {
2122 int i;
2123
2124 hp100_outb(lp->mac2_mode, MAC_CFG_2);
2125 hp100_andb(HP100_MAC1MODEMASK, MAC_CFG_1);
2126 hp100_orb(lp->mac1_mode, MAC_CFG_1);
2127
2128 hp100_page(MAC_ADDRESS);
2129 for (i = 0; i < 8; i++)
2130 hp100_outb(lp->hash_bytes[i], HASH_BYTE0 + i);
2131#ifdef HP100_DEBUG
2132 printk("hp100: %s: mac1 = 0x%x, mac2 = 0x%x, multicast hash = %02x:%02x:%02x:%02x:%02x:%02x:%02x:%02x\n",
2133 dev->name, lp->mac1_mode, lp->mac2_mode,
2134 lp->hash_bytes[0], lp->hash_bytes[1],
2135 lp->hash_bytes[2], lp->hash_bytes[3],
2136 lp->hash_bytes[4], lp->hash_bytes[5],
2137 lp->hash_bytes[6], lp->hash_bytes[7]);
2138#endif
2139
2140 if (lp->lan_type == HP100_LAN_100) {
2141#ifdef HP100_DEBUG
2142 printk("hp100: %s: 100VG MAC settings have changed - relogin.\n", dev->name);
2143#endif
2144 lp->hub_status = hp100_login_to_vg_hub(dev, 1);
2145 }
2146 } else {
2147 int i;
2148 u_char old_hash_bytes[8];
2149
2150 hp100_page(MAC_ADDRESS);
2151 for (i = 0; i < 8; i++)
2152 old_hash_bytes[i] = hp100_inb(HASH_BYTE0 + i);
2153 if (memcmp(old_hash_bytes, &lp->hash_bytes, 8)) {
2154 for (i = 0; i < 8; i++)
2155 hp100_outb(lp->hash_bytes[i], HASH_BYTE0 + i);
2156#ifdef HP100_DEBUG
2157 printk("hp100: %s: multicast hash = %02x:%02x:%02x:%02x:%02x:%02x:%02x:%02x\n",
2158 dev->name, lp->hash_bytes[0],
2159 lp->hash_bytes[1], lp->hash_bytes[2],
2160 lp->hash_bytes[3], lp->hash_bytes[4],
2161 lp->hash_bytes[5], lp->hash_bytes[6],
2162 lp->hash_bytes[7]);
2163#endif
2164
2165 if (lp->lan_type == HP100_LAN_100) {
2166#ifdef HP100_DEBUG
2167 printk("hp100: %s: 100VG MAC settings have changed - relogin.\n", dev->name);
2168#endif
2169 lp->hub_status = hp100_login_to_vg_hub(dev, 1);
2170 }
2171 }
2172 }
2173
2174 hp100_page(MAC_CTRL);
2175 hp100_orb(HP100_RX_EN | HP100_RX_IDLE |
2176 HP100_TX_EN | HP100_TX_IDLE, MAC_CFG_1);
2177
2178 hp100_page(PERFORMANCE);
2179 hp100_ints_on();
2180 spin_unlock_irqrestore(&lp->lock, flags);
2181}
2182
2183
2184
2185
2186
2187static irqreturn_t hp100_interrupt(int irq, void *dev_id)
2188{
2189 struct net_device *dev = (struct net_device *) dev_id;
2190 struct hp100_private *lp = netdev_priv(dev);
2191
2192 int ioaddr;
2193 u_int val;
2194
2195 if (dev == NULL)
2196 return IRQ_NONE;
2197 ioaddr = dev->base_addr;
2198
2199 spin_lock(&lp->lock);
2200
2201 hp100_ints_off();
2202
2203#ifdef HP100_DEBUG_B
2204 hp100_outw(0x4219, TRACE);
2205#endif
2206
2207
2208 val = hp100_inw(IRQ_STATUS);
2209#ifdef HP100_DEBUG_IRQ
2210 printk("hp100: %s: mode=%x,IRQ_STAT=0x%.4x,RXPKTCNT=0x%.2x RXPDL=0x%.2x TXPKTCNT=0x%.2x TXPDL=0x%.2x\n",
2211 dev->name, lp->mode, (u_int) val, hp100_inb(RX_PKT_CNT),
2212 hp100_inb(RX_PDL), hp100_inb(TX_PKT_CNT), hp100_inb(TX_PDL));
2213#endif
2214
2215 if (val == 0) {
2216 spin_unlock(&lp->lock);
2217 hp100_ints_on();
2218 return IRQ_NONE;
2219 }
2220
2221
2222
2223
2224
2225
2226
2227
2228 if (val & HP100_RX_PDL_FILL_COMPL) {
2229 if (lp->mode == 1)
2230 hp100_rx_bm(dev);
2231 else {
2232 printk("hp100: %s: rx_pdl_fill_compl interrupt although not busmaster?\n", dev->name);
2233 }
2234 }
2235
2236
2237
2238
2239
2240
2241
2242
2243
2244 if (val & HP100_RX_PACKET) {
2245 if (lp->mode != 1)
2246 hp100_rx(dev);
2247 else if (!(val & HP100_RX_PDL_FILL_COMPL)) {
2248
2249 hp100_rx_bm(dev);
2250 }
2251 }
2252
2253
2254
2255
2256
2257
2258
2259 hp100_outw(val, IRQ_STATUS);
2260
2261
2262
2263
2264
2265
2266
2267 if (val & (HP100_TX_ERROR | HP100_RX_ERROR)) {
2268#ifdef HP100_DEBUG_IRQ
2269 printk("hp100: %s: TX/RX Error IRQ\n", dev->name);
2270#endif
2271 hp100_update_stats(dev);
2272 if (lp->mode == 1) {
2273 hp100_rxfill(dev);
2274 hp100_clean_txring(dev);
2275 }
2276 }
2277
2278
2279
2280
2281 if ((lp->mode == 1) && (val & (HP100_RX_PDA_ZERO)))
2282 hp100_rxfill(dev);
2283
2284
2285
2286
2287
2288 if ((lp->mode == 1) && (val & (HP100_TX_COMPLETE)))
2289 hp100_clean_txring(dev);
2290
2291
2292
2293
2294
2295 if (val & HP100_MISC_ERROR) {
2296#ifdef HP100_DEBUG_IRQ
2297 printk
2298 ("hp100: %s: Misc. Error Interrupt - Check cabling.\n",
2299 dev->name);
2300#endif
2301 if (lp->mode == 1) {
2302 hp100_clean_txring(dev);
2303 hp100_rxfill(dev);
2304 }
2305 hp100_misc_interrupt(dev);
2306 }
2307
2308 spin_unlock(&lp->lock);
2309 hp100_ints_on();
2310 return IRQ_HANDLED;
2311}
2312
2313
2314
2315
2316
2317static void hp100_start_interface(struct net_device *dev)
2318{
2319 unsigned long flags;
2320 int ioaddr = dev->base_addr;
2321 struct hp100_private *lp = netdev_priv(dev);
2322
2323#ifdef HP100_DEBUG_B
2324 hp100_outw(0x4220, TRACE);
2325 printk("hp100: %s: hp100_start_interface\n", dev->name);
2326#endif
2327
2328 spin_lock_irqsave(&lp->lock, flags);
2329
2330
2331
2332 hp100_page(PERFORMANCE);
2333 hp100_outw(0xfefe, IRQ_MASK);
2334 hp100_outw(0xffff, IRQ_STATUS);
2335 hp100_outw(HP100_FAKE_INT | HP100_INT_EN | HP100_RESET_LB,
2336 OPTION_LSW);
2337
2338 hp100_outw(HP100_TRI_INT | HP100_RESET_HB, OPTION_LSW);
2339
2340 if (lp->mode == 1) {
2341
2342 hp100_page(HW_MAP);
2343 hp100_orb(HP100_BM_MASTER, BM);
2344 hp100_rxfill(dev);
2345 } else if (lp->mode == 2) {
2346
2347 hp100_outw(HP100_MMAP_DIS | HP100_RESET_HB, OPTION_LSW);
2348 }
2349
2350 hp100_page(PERFORMANCE);
2351 hp100_outw(0xfefe, IRQ_MASK);
2352 hp100_outw(0xffff, IRQ_STATUS);
2353
2354
2355 if (lp->mode == 1) {
2356 hp100_outw(HP100_RX_PDL_FILL_COMPL |
2357 HP100_RX_PDA_ZERO | HP100_RX_ERROR |
2358
2359 HP100_SET_HB |
2360
2361 HP100_TX_COMPLETE |
2362
2363 HP100_TX_ERROR | HP100_SET_LB, IRQ_MASK);
2364 } else {
2365 hp100_outw(HP100_RX_PACKET |
2366 HP100_RX_ERROR | HP100_SET_HB |
2367 HP100_TX_ERROR | HP100_SET_LB, IRQ_MASK);
2368 }
2369
2370
2371
2372 spin_unlock_irqrestore(&lp->lock, flags);
2373
2374
2375 hp100_set_multicast_list(dev);
2376}
2377
2378static void hp100_stop_interface(struct net_device *dev)
2379{
2380 struct hp100_private *lp = netdev_priv(dev);
2381 int ioaddr = dev->base_addr;
2382 u_int val;
2383
2384#ifdef HP100_DEBUG_B
2385 printk("hp100: %s: hp100_stop_interface\n", dev->name);
2386 hp100_outw(0x4221, TRACE);
2387#endif
2388
2389 if (lp->mode == 1)
2390 hp100_BM_shutdown(dev);
2391 else {
2392
2393 hp100_outw(HP100_INT_EN | HP100_RESET_LB |
2394 HP100_TRI_INT | HP100_MMAP_DIS | HP100_SET_HB,
2395 OPTION_LSW);
2396 val = hp100_inw(OPTION_LSW);
2397
2398 hp100_page(MAC_CTRL);
2399 hp100_andb(~(HP100_RX_EN | HP100_TX_EN), MAC_CFG_1);
2400
2401 if (!(val & HP100_HW_RST))
2402 return;
2403
2404 for (val = 0; val < 6000; val++)
2405 if ((hp100_inb(MAC_CFG_1) & (HP100_TX_IDLE | HP100_RX_IDLE)) == (HP100_TX_IDLE | HP100_RX_IDLE)) {
2406 hp100_page(PERFORMANCE);
2407 return;
2408 }
2409 printk("hp100: %s: hp100_stop_interface - timeout\n", dev->name);
2410 hp100_page(PERFORMANCE);
2411 }
2412}
2413
2414static void hp100_load_eeprom(struct net_device *dev, u_short probe_ioaddr)
2415{
2416 int i;
2417 int ioaddr = probe_ioaddr > 0 ? probe_ioaddr : dev->base_addr;
2418
2419#ifdef HP100_DEBUG_B
2420 hp100_outw(0x4222, TRACE);
2421#endif
2422
2423 hp100_page(EEPROM_CTRL);
2424 hp100_andw(~HP100_EEPROM_LOAD, EEPROM_CTRL);
2425 hp100_orw(HP100_EEPROM_LOAD, EEPROM_CTRL);
2426 for (i = 0; i < 10000; i++)
2427 if (!(hp100_inb(OPTION_MSW) & HP100_EE_LOAD))
2428 return;
2429 printk("hp100: %s: hp100_load_eeprom - timeout\n", dev->name);
2430}
2431
2432
2433
2434
2435
2436
2437static int hp100_sense_lan(struct net_device *dev)
2438{
2439 int ioaddr = dev->base_addr;
2440 u_short val_VG, val_10;
2441 struct hp100_private *lp = netdev_priv(dev);
2442
2443#ifdef HP100_DEBUG_B
2444 hp100_outw(0x4223, TRACE);
2445#endif
2446
2447 hp100_page(MAC_CTRL);
2448 val_10 = hp100_inb(10_LAN_CFG_1);
2449 val_VG = hp100_inb(VG_LAN_CFG_1);
2450 hp100_page(PERFORMANCE);
2451#ifdef HP100_DEBUG
2452 printk("hp100: %s: sense_lan: val_VG = 0x%04x, val_10 = 0x%04x\n",
2453 dev->name, val_VG, val_10);
2454#endif
2455
2456 if (val_10 & HP100_LINK_BEAT_ST)
2457 return HP100_LAN_10;
2458
2459 if (val_10 & HP100_AUI_ST) {
2460
2461
2462
2463
2464
2465 val_10 |= HP100_AUI_SEL | HP100_LOW_TH;
2466 hp100_page(MAC_CTRL);
2467 hp100_outb(val_10, 10_LAN_CFG_1);
2468 hp100_page(PERFORMANCE);
2469 return HP100_LAN_COAX;
2470 }
2471
2472
2473 if ( !strcmp(lp->id, "HWP1920") ||
2474 (lp->pci_dev &&
2475 lp->pci_dev->vendor == PCI_VENDOR_ID &&
2476 (lp->pci_dev->device == PCI_DEVICE_ID_HP_J2970A ||
2477 lp->pci_dev->device == PCI_DEVICE_ID_HP_J2973A)))
2478 return HP100_LAN_ERR;
2479
2480 if (val_VG & HP100_LINK_CABLE_ST)
2481 return HP100_LAN_100;
2482 return HP100_LAN_ERR;
2483}
2484
2485static int hp100_down_vg_link(struct net_device *dev)
2486{
2487 struct hp100_private *lp = netdev_priv(dev);
2488 int ioaddr = dev->base_addr;
2489 unsigned long time;
2490 long savelan, newlan;
2491
2492#ifdef HP100_DEBUG_B
2493 hp100_outw(0x4224, TRACE);
2494 printk("hp100: %s: down_vg_link\n", dev->name);
2495#endif
2496
2497 hp100_page(MAC_CTRL);
2498 time = jiffies + (HZ / 4);
2499 do {
2500 if (hp100_inb(VG_LAN_CFG_1) & HP100_LINK_CABLE_ST)
2501 break;
2502 if (!in_interrupt())
2503 schedule_timeout_interruptible(1);
2504 } while (time_after(time, jiffies));
2505
2506 if (time_after_eq(jiffies, time))
2507 return 0;
2508
2509
2510
2511 hp100_andb(~(HP100_LOAD_ADDR | HP100_LINK_CMD), VG_LAN_CFG_1);
2512 hp100_orb(HP100_VG_SEL, VG_LAN_CFG_1);
2513
2514
2515 time = jiffies + (HZ / 2);
2516 do {
2517 if (!(hp100_inb(VG_LAN_CFG_1) & HP100_LINK_UP_ST))
2518 break;
2519 if (!in_interrupt())
2520 schedule_timeout_interruptible(1);
2521 } while (time_after(time, jiffies));
2522
2523#ifdef HP100_DEBUG
2524 if (time_after_eq(jiffies, time))
2525 printk("hp100: %s: down_vg_link: Link does not go down?\n", dev->name);
2526#endif
2527
2528
2529
2530
2531 if (lp->chip == HP100_CHIPID_LASSEN) {
2532
2533
2534 hp100_andb(~HP100_VG_RESET, VG_LAN_CFG_1);
2535 udelay(1500);
2536 hp100_orb(HP100_VG_RESET, VG_LAN_CFG_1);
2537 udelay(1500);
2538 }
2539
2540
2541
2542
2543
2544
2545 if (lp->chip == HP100_CHIPID_LASSEN) {
2546
2547 savelan = newlan = hp100_inl(10_LAN_CFG_1);
2548 newlan &= ~(HP100_VG_SEL << 16);
2549 newlan |= (HP100_DOT3_MAC) << 8;
2550 hp100_andb(~HP100_AUTO_MODE, MAC_CFG_3);
2551 hp100_outl(newlan, 10_LAN_CFG_1);
2552
2553
2554 time = jiffies + (HZ * 5);
2555 do {
2556 if (!(hp100_inb(MAC_CFG_4) & HP100_MAC_SEL_ST))
2557 break;
2558 if (!in_interrupt())
2559 schedule_timeout_interruptible(1);
2560 } while (time_after(time, jiffies));
2561
2562 hp100_orb(HP100_AUTO_MODE, MAC_CFG_3);
2563 hp100_outl(savelan, 10_LAN_CFG_1);
2564 }
2565
2566 time = jiffies + (3 * HZ);
2567 do {
2568 if ((hp100_inb(VG_LAN_CFG_1) & HP100_LINK_CABLE_ST) == 0)
2569 break;
2570 if (!in_interrupt())
2571 schedule_timeout_interruptible(1);
2572 } while (time_after(time, jiffies));
2573
2574 if (time_before_eq(time, jiffies)) {
2575#ifdef HP100_DEBUG
2576 printk("hp100: %s: down_vg_link: timeout\n", dev->name);
2577#endif
2578 return -EIO;
2579 }
2580
2581 time = jiffies + (2 * HZ);
2582 do {
2583 if (!in_interrupt())
2584 schedule_timeout_interruptible(1);
2585 } while (time_after(time, jiffies));
2586
2587 return 0;
2588}
2589
2590static int hp100_login_to_vg_hub(struct net_device *dev, u_short force_relogin)
2591{
2592 int ioaddr = dev->base_addr;
2593 struct hp100_private *lp = netdev_priv(dev);
2594 u_short val = 0;
2595 unsigned long time;
2596 int startst;
2597
2598#ifdef HP100_DEBUG_B
2599 hp100_outw(0x4225, TRACE);
2600 printk("hp100: %s: login_to_vg_hub\n", dev->name);
2601#endif
2602
2603
2604
2605
2606
2607 hp100_page(MAC_CTRL);
2608 startst = hp100_inb(VG_LAN_CFG_1);
2609 if ((force_relogin == 1) || (hp100_inb(MAC_CFG_4) & HP100_MAC_SEL_ST)) {
2610#ifdef HP100_DEBUG_TRAINING
2611 printk("hp100: %s: Start training\n", dev->name);
2612#endif
2613
2614
2615 hp100_orb(HP100_VG_RESET, VG_LAN_CFG_1);
2616
2617
2618
2619 if ((lp->chip == HP100_CHIPID_LASSEN) && (startst & HP100_LINK_CABLE_ST))
2620 hp100_andb(~HP100_DOT3_MAC, 10_LAN_CFG_2);
2621
2622
2623 hp100_andb(~(HP100_LINK_CMD ), VG_LAN_CFG_1);
2624
2625#ifdef HP100_DEBUG_TRAINING
2626 printk("hp100: %s: Bring down the link\n", dev->name);
2627#endif
2628
2629
2630 time = jiffies + (HZ / 10);
2631 do {
2632 if (~(hp100_inb(VG_LAN_CFG_1) & HP100_LINK_UP_ST))
2633 break;
2634 if (!in_interrupt())
2635 schedule_timeout_interruptible(1);
2636 } while (time_after(time, jiffies));
2637
2638
2639 if ((dev->flags) & IFF_PROMISC) {
2640 hp100_orb(HP100_PROM_MODE, VG_LAN_CFG_2);
2641 if (lp->chip == HP100_CHIPID_LASSEN)
2642 hp100_orw(HP100_MACRQ_PROMSC, TRAIN_REQUEST);
2643 } else {
2644 hp100_andb(~HP100_PROM_MODE, VG_LAN_CFG_2);
2645
2646
2647
2648 if (lp->chip == HP100_CHIPID_LASSEN) {
2649 hp100_andw(~HP100_MACRQ_PROMSC, TRAIN_REQUEST);
2650 }
2651 }
2652
2653
2654 if (lp->chip == HP100_CHIPID_LASSEN)
2655 hp100_orb(HP100_MACRQ_FRAMEFMT_EITHER, TRAIN_REQUEST);
2656
2657 hp100_orb(HP100_LINK_CMD | HP100_LOAD_ADDR | HP100_VG_RESET, VG_LAN_CFG_1);
2658
2659
2660
2661
2662
2663
2664
2665 hp100_page(MAC_CTRL);
2666 time = jiffies + (1 * HZ);
2667 do {
2668 if (hp100_inb(VG_LAN_CFG_1) & HP100_LINK_CABLE_ST)
2669 break;
2670 if (!in_interrupt())
2671 schedule_timeout_interruptible(1);
2672 } while (time_before(jiffies, time));
2673
2674 if (time_after_eq(jiffies, time)) {
2675#ifdef HP100_DEBUG_TRAINING
2676 printk("hp100: %s: Link cable status not ok? Training aborted.\n", dev->name);
2677#endif
2678 } else {
2679#ifdef HP100_DEBUG_TRAINING
2680 printk
2681 ("hp100: %s: HUB tones detected. Trying to train.\n",
2682 dev->name);
2683#endif
2684
2685 time = jiffies + (2 * HZ);
2686 do {
2687 val = hp100_inb(VG_LAN_CFG_1);
2688 if ((val & (HP100_LINK_UP_ST))) {
2689#ifdef HP100_DEBUG_TRAINING
2690 printk("hp100: %s: Passed training.\n", dev->name);
2691#endif
2692 break;
2693 }
2694 if (!in_interrupt())
2695 schedule_timeout_interruptible(1);
2696 } while (time_after(time, jiffies));
2697 }
2698
2699
2700 if (time_before_eq(jiffies, time) && (val & HP100_LINK_UP_ST)) {
2701#ifdef HP100_DEBUG_TRAINING
2702 printk("hp100: %s: Successfully logged into the HUB.\n", dev->name);
2703 if (lp->chip == HP100_CHIPID_LASSEN) {
2704 val = hp100_inw(TRAIN_ALLOW);
2705 printk("hp100: %s: Card supports 100VG MAC Version \"%s\" ",
2706 dev->name, (hp100_inw(TRAIN_REQUEST) & HP100_CARD_MACVER) ? "802.12" : "Pre");
2707 printk("Driver will use MAC Version \"%s\"\n", (val & HP100_HUB_MACVER) ? "802.12" : "Pre");
2708 printk("hp100: %s: Frame format is %s.\n", dev->name, (val & HP100_MALLOW_FRAMEFMT) ? "802.5" : "802.3");
2709 }
2710#endif
2711 } else {
2712
2713 printk("hp100: %s: Problem logging into the HUB.\n", dev->name);
2714 if (lp->chip == HP100_CHIPID_LASSEN) {
2715
2716 val = hp100_inw(TRAIN_ALLOW);
2717#ifdef HP100_DEBUG_TRAINING
2718 printk("hp100: %s: MAC Configuration requested: 0x%04x, HUB allowed: 0x%04x\n", dev->name, hp100_inw(TRAIN_REQUEST), val);
2719#endif
2720 if (val & HP100_MALLOW_ACCDENIED)
2721 printk("hp100: %s: HUB access denied.\n", dev->name);
2722 if (val & HP100_MALLOW_CONFIGURE)
2723 printk("hp100: %s: MAC Configuration is incompatible with the Network.\n", dev->name);
2724 if (val & HP100_MALLOW_DUPADDR)
2725 printk("hp100: %s: Duplicate MAC Address on the Network.\n", dev->name);
2726 }
2727 }
2728
2729
2730
2731
2732 if ((lp->chip == HP100_CHIPID_LASSEN) && (startst & HP100_LINK_CABLE_ST)) {
2733 hp100_page(MAC_CTRL);
2734 hp100_orb(HP100_DOT3_MAC, 10_LAN_CFG_2);
2735 }
2736
2737 val = hp100_inb(VG_LAN_CFG_1);
2738
2739
2740 hp100_page(PERFORMANCE);
2741 hp100_outw(HP100_MISC_ERROR, IRQ_STATUS);
2742
2743 if (val & HP100_LINK_UP_ST)
2744 return (0);
2745 else {
2746 printk("hp100: %s: Training failed.\n", dev->name);
2747 hp100_down_vg_link(dev);
2748 return -EIO;
2749 }
2750 }
2751
2752 return -EIO;
2753}
2754
2755static void hp100_cascade_reset(struct net_device *dev, u_short enable)
2756{
2757 int ioaddr = dev->base_addr;
2758 struct hp100_private *lp = netdev_priv(dev);
2759
2760#ifdef HP100_DEBUG_B
2761 hp100_outw(0x4226, TRACE);
2762 printk("hp100: %s: cascade_reset\n", dev->name);
2763#endif
2764
2765 if (enable) {
2766 hp100_outw(HP100_HW_RST | HP100_RESET_LB, OPTION_LSW);
2767 if (lp->chip == HP100_CHIPID_LASSEN) {
2768
2769 hp100_page(HW_MAP);
2770 hp100_andb(~HP100_PCI_RESET, PCICTRL2);
2771 hp100_orb(HP100_PCI_RESET, PCICTRL2);
2772
2773
2774
2775 udelay(400);
2776 hp100_andb(~HP100_PCI_RESET, PCICTRL2);
2777 hp100_page(PERFORMANCE);
2778 }
2779 } else {
2780 hp100_outw(HP100_HW_RST | HP100_SET_LB, OPTION_LSW);
2781 udelay(400);
2782 hp100_page(PERFORMANCE);
2783 }
2784}
2785
2786#ifdef HP100_DEBUG
2787void hp100_RegisterDump(struct net_device *dev)
2788{
2789 int ioaddr = dev->base_addr;
2790 int Page;
2791 int Register;
2792
2793
2794 printk("hp100: %s: Cascade Register Dump\n", dev->name);
2795 printk("hardware id #1: 0x%.2x\n", hp100_inb(HW_ID));
2796 printk("hardware id #2/paging: 0x%.2x\n", hp100_inb(PAGING));
2797 printk("option #1: 0x%.4x\n", hp100_inw(OPTION_LSW));
2798 printk("option #2: 0x%.4x\n", hp100_inw(OPTION_MSW));
2799
2800
2801 for (Page = 0; Page < 8; Page++) {
2802
2803 printk("page: 0x%.2x\n", Page);
2804 outw(Page, ioaddr + 0x02);
2805 for (Register = 0x8; Register < 0x22; Register += 2) {
2806
2807 if (((Register != 0x10) && (Register != 0x12)) || (Page > 0)) {
2808 printk("0x%.2x = 0x%.4x\n", Register, inw(ioaddr + Register));
2809 }
2810 }
2811 }
2812 hp100_page(PERFORMANCE);
2813}
2814#endif
2815
2816
2817static void cleanup_dev(struct net_device *d)
2818{
2819 struct hp100_private *p = netdev_priv(d);
2820
2821 unregister_netdev(d);
2822 release_region(d->base_addr, HP100_REGION_SIZE);
2823
2824 if (p->mode == 1)
2825 pci_free_consistent(p->pci_dev, MAX_RINGSIZE + 0x0f,
2826 p->page_vaddr_algn,
2827 virt_to_whatever(d, p->page_vaddr_algn));
2828 if (p->mem_ptr_virt)
2829 iounmap(p->mem_ptr_virt);
2830
2831 free_netdev(d);
2832}
2833
2834#ifdef CONFIG_EISA
2835static int __init hp100_eisa_probe (struct device *gendev)
2836{
2837 struct net_device *dev = alloc_etherdev(sizeof(struct hp100_private));
2838 struct eisa_device *edev = to_eisa_device(gendev);
2839 int err;
2840
2841 if (!dev)
2842 return -ENOMEM;
2843
2844 SET_NETDEV_DEV(dev, &edev->dev);
2845
2846 err = hp100_probe1(dev, edev->base_addr + 0xC38, HP100_BUS_EISA, NULL);
2847 if (err)
2848 goto out1;
2849
2850#ifdef HP100_DEBUG
2851 printk("hp100: %s: EISA adapter found at 0x%x\n", dev->name,
2852 dev->base_addr);
2853#endif
2854 gendev->driver_data = dev;
2855 return 0;
2856 out1:
2857 free_netdev(dev);
2858 return err;
2859}
2860
2861static int __devexit hp100_eisa_remove (struct device *gendev)
2862{
2863 struct net_device *dev = gendev->driver_data;
2864 cleanup_dev(dev);
2865 return 0;
2866}
2867
2868static struct eisa_driver hp100_eisa_driver = {
2869 .id_table = hp100_eisa_tbl,
2870 .driver = {
2871 .name = "hp100",
2872 .probe = hp100_eisa_probe,
2873 .remove = __devexit_p (hp100_eisa_remove),
2874 }
2875};
2876#endif
2877
2878#ifdef CONFIG_PCI
2879static int __devinit hp100_pci_probe (struct pci_dev *pdev,
2880 const struct pci_device_id *ent)
2881{
2882 struct net_device *dev;
2883 int ioaddr;
2884 u_short pci_command;
2885 int err;
2886
2887 if (pci_enable_device(pdev))
2888 return -ENODEV;
2889
2890 dev = alloc_etherdev(sizeof(struct hp100_private));
2891 if (!dev) {
2892 err = -ENOMEM;
2893 goto out0;
2894 }
2895
2896 SET_NETDEV_DEV(dev, &pdev->dev);
2897
2898 pci_read_config_word(pdev, PCI_COMMAND, &pci_command);
2899 if (!(pci_command & PCI_COMMAND_IO)) {
2900#ifdef HP100_DEBUG
2901 printk("hp100: %s: PCI I/O Bit has not been set. Setting...\n", dev->name);
2902#endif
2903 pci_command |= PCI_COMMAND_IO;
2904 pci_write_config_word(pdev, PCI_COMMAND, pci_command);
2905 }
2906
2907 if (!(pci_command & PCI_COMMAND_MASTER)) {
2908#ifdef HP100_DEBUG
2909 printk("hp100: %s: PCI Master Bit has not been set. Setting...\n", dev->name);
2910#endif
2911 pci_command |= PCI_COMMAND_MASTER;
2912 pci_write_config_word(pdev, PCI_COMMAND, pci_command);
2913 }
2914
2915 ioaddr = pci_resource_start(pdev, 0);
2916 err = hp100_probe1(dev, ioaddr, HP100_BUS_PCI, pdev);
2917 if (err)
2918 goto out1;
2919
2920#ifdef HP100_DEBUG
2921 printk("hp100: %s: PCI adapter found at 0x%x\n", dev->name, ioaddr);
2922#endif
2923 pci_set_drvdata(pdev, dev);
2924 return 0;
2925 out1:
2926 free_netdev(dev);
2927 out0:
2928 pci_disable_device(pdev);
2929 return err;
2930}
2931
2932static void __devexit hp100_pci_remove (struct pci_dev *pdev)
2933{
2934 struct net_device *dev = pci_get_drvdata(pdev);
2935
2936 cleanup_dev(dev);
2937 pci_disable_device(pdev);
2938}
2939
2940
2941static struct pci_driver hp100_pci_driver = {
2942 .name = "hp100",
2943 .id_table = hp100_pci_tbl,
2944 .probe = hp100_pci_probe,
2945 .remove = __devexit_p(hp100_pci_remove),
2946};
2947#endif
2948
2949
2950
2951
2952
2953MODULE_LICENSE("GPL");
2954MODULE_AUTHOR("Jaroslav Kysela <perex@perex.cz>, "
2955 "Siegfried \"Frieder\" Loeffler (dg1sek) <floeff@mathematik.uni-stuttgart.de>");
2956MODULE_DESCRIPTION("HP CASCADE Architecture Driver for 100VG-AnyLan Network Adapters");
2957
2958
2959
2960
2961
2962
2963
2964#if defined(MODULE) && defined(CONFIG_ISA)
2965#define HP100_DEVICES 5
2966
2967static int hp100_port[HP100_DEVICES] = { 0, [1 ... (HP100_DEVICES-1)] = -1 };
2968module_param_array(hp100_port, int, NULL, 0);
2969
2970
2971static struct net_device *hp100_devlist[HP100_DEVICES];
2972
2973static int __init hp100_isa_init(void)
2974{
2975 struct net_device *dev;
2976 int i, err, cards = 0;
2977
2978
2979 if (hp100_port[0] == 0)
2980 return -ENODEV;
2981
2982
2983 for (i = 0; i < HP100_DEVICES && hp100_port[i] != -1; ++i) {
2984 dev = alloc_etherdev(sizeof(struct hp100_private));
2985 if (!dev) {
2986 printk(KERN_WARNING "hp100: no memory for network device\n");
2987 while (cards > 0)
2988 cleanup_dev(hp100_devlist[--cards]);
2989
2990 return -ENOMEM;
2991 }
2992
2993 err = hp100_isa_probe(dev, hp100_port[i]);
2994 if (!err)
2995 hp100_devlist[cards++] = dev;
2996 else
2997 free_netdev(dev);
2998 }
2999
3000 return cards > 0 ? 0 : -ENODEV;
3001}
3002
3003static void hp100_isa_cleanup(void)
3004{
3005 int i;
3006
3007 for (i = 0; i < HP100_DEVICES; i++) {
3008 struct net_device *dev = hp100_devlist[i];
3009 if (dev)
3010 cleanup_dev(dev);
3011 }
3012}
3013#else
3014#define hp100_isa_init() (0)
3015#define hp100_isa_cleanup() do { } while(0)
3016#endif
3017
3018static int __init hp100_module_init(void)
3019{
3020 int err;
3021
3022 err = hp100_isa_init();
3023 if (err && err != -ENODEV)
3024 goto out;
3025#ifdef CONFIG_EISA
3026 err = eisa_driver_register(&hp100_eisa_driver);
3027 if (err && err != -ENODEV)
3028 goto out2;
3029#endif
3030#ifdef CONFIG_PCI
3031 err = pci_register_driver(&hp100_pci_driver);
3032 if (err && err != -ENODEV)
3033 goto out3;
3034#endif
3035 out:
3036 return err;
3037 out3:
3038#ifdef CONFIG_EISA
3039 eisa_driver_unregister (&hp100_eisa_driver);
3040 out2:
3041#endif
3042 hp100_isa_cleanup();
3043 goto out;
3044}
3045
3046
3047static void __exit hp100_module_exit(void)
3048{
3049 hp100_isa_cleanup();
3050#ifdef CONFIG_EISA
3051 eisa_driver_unregister (&hp100_eisa_driver);
3052#endif
3053#ifdef CONFIG_PCI
3054 pci_unregister_driver (&hp100_pci_driver);
3055#endif
3056}
3057
3058module_init(hp100_module_init)
3059module_exit(hp100_module_exit)
3060
3061
3062
3063
3064
3065
3066
3067
3068