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