aboutsummaryrefslogtreecommitdiffstats
path: root/drivers/net/ethernet
diff options
context:
space:
mode:
authorJeff Kirsher <jeffrey.t.kirsher@intel.com>2011-07-24 16:19:50 -0400
committerJeff Kirsher <jeffrey.t.kirsher@intel.com>2011-08-13 02:46:43 -0400
commit7e25d72458c64e6ca76d69ae8da9ba98f1bf9d25 (patch)
tree2e40c0a52349fbafb1c8e580355f4a6a5835f186 /drivers/net/ethernet
parent9bba23b0ae933a143f8ea89e59c6becf0c1c1d1e (diff)
hp100: Move the HP driver
Move the HP driver into drivers/net/ethernet/hp/ and made the necessary Kconfig and Makefile changes. CC: Jaroslav Kysela <perex@perex.cz> Signed-off-by: Jeff Kirsher <jeffrey.t.kirsher@intel.com>
Diffstat (limited to 'drivers/net/ethernet')
-rw-r--r--drivers/net/ethernet/Kconfig1
-rw-r--r--drivers/net/ethernet/Makefile1
-rw-r--r--drivers/net/ethernet/hp/Kconfig31
-rw-r--r--drivers/net/ethernet/hp/Makefile5
-rw-r--r--drivers/net/ethernet/hp/hp100.c3068
-rw-r--r--drivers/net/ethernet/hp/hp100.h615
6 files changed, 3721 insertions, 0 deletions
diff --git a/drivers/net/ethernet/Kconfig b/drivers/net/ethernet/Kconfig
index 8cd38c91d549..c1ce35670ee1 100644
--- a/drivers/net/ethernet/Kconfig
+++ b/drivers/net/ethernet/Kconfig
@@ -30,6 +30,7 @@ source "drivers/net/ethernet/neterion/Kconfig"
30source "drivers/net/ethernet/faraday/Kconfig" 30source "drivers/net/ethernet/faraday/Kconfig"
31source "drivers/net/ethernet/freescale/Kconfig" 31source "drivers/net/ethernet/freescale/Kconfig"
32source "drivers/net/ethernet/fujitsu/Kconfig" 32source "drivers/net/ethernet/fujitsu/Kconfig"
33source "drivers/net/ethernet/hp/Kconfig"
33source "drivers/net/ethernet/ibm/Kconfig" 34source "drivers/net/ethernet/ibm/Kconfig"
34source "drivers/net/ethernet/intel/Kconfig" 35source "drivers/net/ethernet/intel/Kconfig"
35source "drivers/net/ethernet/i825xx/Kconfig" 36source "drivers/net/ethernet/i825xx/Kconfig"
diff --git a/drivers/net/ethernet/Makefile b/drivers/net/ethernet/Makefile
index 50e040c847d6..34e84fa3f43e 100644
--- a/drivers/net/ethernet/Makefile
+++ b/drivers/net/ethernet/Makefile
@@ -22,6 +22,7 @@ obj-$(CONFIG_NET_VENDOR_EXAR) += neterion/
22obj-$(CONFIG_NET_VENDOR_FARADAY) += faraday/ 22obj-$(CONFIG_NET_VENDOR_FARADAY) += faraday/
23obj-$(CONFIG_NET_VENDOR_FREESCALE) += freescale/ 23obj-$(CONFIG_NET_VENDOR_FREESCALE) += freescale/
24obj-$(CONFIG_NET_VENDOR_FUJITSU) += fujitsu/ 24obj-$(CONFIG_NET_VENDOR_FUJITSU) += fujitsu/
25obj-$(CONFIG_NET_VENDOR_HP) += hp/
25obj-$(CONFIG_NET_VENDOR_IBM) += ibm/ 26obj-$(CONFIG_NET_VENDOR_IBM) += ibm/
26obj-$(CONFIG_NET_VENDOR_INTEL) += intel/ 27obj-$(CONFIG_NET_VENDOR_INTEL) += intel/
27obj-$(CONFIG_NET_VENDOR_I825XX) += i825xx/ 28obj-$(CONFIG_NET_VENDOR_I825XX) += i825xx/
diff --git a/drivers/net/ethernet/hp/Kconfig b/drivers/net/ethernet/hp/Kconfig
new file mode 100644
index 000000000000..07b42e963143
--- /dev/null
+++ b/drivers/net/ethernet/hp/Kconfig
@@ -0,0 +1,31 @@
1#
2# HP network device configuration
3#
4
5config NET_VENDOR_HP
6 bool "HP devices"
7 depends on ISA || EISA || PCI
8 ---help---
9 If you have a network (Ethernet) card belonging to this class, say Y
10 and read the Ethernet-HOWTO, available from
11 <http://www.tldp.org/docs.html#howto>.
12
13 Note that the answer to this question doesn't directly affect the
14 kernel: saying N will just cause the configurator to skip all
15 the questions about HP cards. If you say Y, you will be asked for
16 your specific card in the following questions.
17
18if NET_VENDOR_HP
19
20config HP100
21 tristate "HP 10/100VG PCLAN (ISA, EISA, PCI) support"
22 depends on (ISA || EISA || PCI)
23 ---help---
24 If you have a network (Ethernet) card of this type, say Y and read
25 the Ethernet-HOWTO, available from
26 <http://www.tldp.org/docs.html#howto>.
27
28 To compile this driver as a module, choose M here. The module
29 will be called hp100.
30
31endif # NET_VENDOR_HP
diff --git a/drivers/net/ethernet/hp/Makefile b/drivers/net/ethernet/hp/Makefile
new file mode 100644
index 000000000000..20b6918b52bd
--- /dev/null
+++ b/drivers/net/ethernet/hp/Makefile
@@ -0,0 +1,5 @@
1#
2# Makefile for the HP network device drivers.
3#
4
5obj-$(CONFIG_HP100) += hp100.o
diff --git a/drivers/net/ethernet/hp/hp100.c b/drivers/net/ethernet/hp/hp100.c
new file mode 100644
index 000000000000..b6519c1ba7e1
--- /dev/null
+++ b/drivers/net/ethernet/hp/hp100.c
@@ -0,0 +1,3068 @@
1/*
2** hp100.c
3** HP CASCADE Architecture Driver for 100VG-AnyLan Network Adapters
4**
5** $Id: hp100.c,v 1.58 2001/09/24 18:03:01 perex Exp perex $
6**
7** Based on the HP100 driver written by Jaroslav Kysela <perex@jcu.cz>
8** Extended for new busmaster capable chipsets by
9** Siegfried "Frieder" Loeffler (dg1sek) <floeff@mathematik.uni-stuttgart.de>
10**
11** Maintained by: Jaroslav Kysela <perex@perex.cz>
12**
13** This driver has only been tested with
14** -- HP J2585B 10/100 Mbit/s PCI Busmaster
15** -- HP J2585A 10/100 Mbit/s PCI
16** -- HP J2970A 10 Mbit/s PCI Combo 10base-T/BNC
17** -- HP J2973A 10 Mbit/s PCI 10base-T
18** -- HP J2573 10/100 ISA
19** -- Compex ReadyLink ENET100-VG4 10/100 Mbit/s PCI / EISA
20** -- Compex FreedomLine 100/VG 10/100 Mbit/s ISA / EISA / PCI
21**
22** but it should also work with the other CASCADE based adapters.
23**
24** TODO:
25** - J2573 seems to hang sometimes when in shared memory mode.
26** - Mode for Priority TX
27** - Check PCI registers, performance might be improved?
28** - To reduce interrupt load in busmaster, one could switch off
29** the interrupts that are used to refill the queues whenever the
30** queues are filled up to more than a certain threshold.
31** - some updates for EISA version of card
32**
33**
34** This code is free software; you can redistribute it and/or modify
35** it under the terms of the GNU General Public License as published by
36** the Free Software Foundation; either version 2 of the License, or
37** (at your option) any later version.
38**
39** This code is distributed in the hope that it will be useful,
40** but WITHOUT ANY WARRANTY; without even the implied warranty of
41** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
42** GNU General Public License for more details.
43**
44** You should have received a copy of the GNU General Public License
45** along with this program; if not, write to the Free Software
46** Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
47**
48** 1.57c -> 1.58
49** - used indent to change coding-style
50** - added KTI DP-200 EISA ID
51** - ioremap is also used for low (<1MB) memory (multi-architecture support)
52**
53** 1.57b -> 1.57c - Arnaldo Carvalho de Melo <acme@conectiva.com.br>
54** - release resources on failure in init_module
55**
56** 1.57 -> 1.57b - Jean II
57** - fix spinlocks, SMP is now working !
58**
59** 1.56 -> 1.57
60** - updates for new PCI interface for 2.1 kernels
61**
62** 1.55 -> 1.56
63** - removed printk in misc. interrupt and update statistics to allow
64** monitoring of card status
65** - timing changes in xmit routines, relogin to 100VG hub added when
66** driver does reset
67** - included fix for Compex FreedomLine PCI adapter
68**
69** 1.54 -> 1.55
70** - fixed bad initialization in init_module
71** - added Compex FreedomLine adapter
72** - some fixes in card initialization
73**
74** 1.53 -> 1.54
75** - added hardware multicast filter support (doesn't work)
76** - little changes in hp100_sense_lan routine
77** - added support for Coax and AUI (J2970)
78** - fix for multiple cards and hp100_mode parameter (insmod)
79** - fix for shared IRQ
80**
81** 1.52 -> 1.53
82** - fixed bug in multicast support
83**
84*/
85
86#define HP100_DEFAULT_PRIORITY_TX 0
87
88#undef HP100_DEBUG
89#undef HP100_DEBUG_B /* Trace */
90#undef HP100_DEBUG_BM /* Debug busmaster code (PDL stuff) */
91
92#undef HP100_DEBUG_TRAINING /* Debug login-to-hub procedure */
93#undef HP100_DEBUG_TX
94#undef HP100_DEBUG_IRQ
95#undef HP100_DEBUG_RX
96
97#undef HP100_MULTICAST_FILTER /* Need to be debugged... */
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 * defines
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 /* for ioports */
132#define HP100_SIG_LEN 8 /* same as EISA_SIG_LEN */
133
134#define HP100_MAX_PACKET_SIZE (1536+4)
135#define HP100_MIN_PACKET_SIZE 60
136
137#ifndef HP100_DEFAULT_RX_RATIO
138/* default - 75% onboard memory on the card are used for RX packets */
139#define HP100_DEFAULT_RX_RATIO 75
140#endif
141
142#ifndef HP100_DEFAULT_PRIORITY_TX
143/* default - don't enable transmit outgoing packets as priority */
144#define HP100_DEFAULT_PRIORITY_TX 0
145#endif
146
147/*
148 * structures
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; /* 1 - 99 */
159 u_short priority_tx; /* != 0 - priority tx */
160 u_short mode; /* PIO, Shared Mem or Busmaster */
161 u_char bus;
162 struct pci_dev *pci_dev;
163 short mem_mapped; /* memory mapped access */
164 void __iomem *mem_ptr_virt; /* virtual memory mapped area, maybe NULL */
165 unsigned long mem_ptr_phys; /* physical memory mapped area */
166 short lan_type; /* 10Mb/s, 100Mb/s or -1 (error) */
167 int hub_status; /* was login to hub successful? */
168 u_char mac1_mode;
169 u_char mac2_mode;
170 u_char hash_bytes[8];
171
172 /* Rings for busmaster mode: */
173 hp100_ring_t *rxrhead; /* Head (oldest) index into rxring */
174 hp100_ring_t *rxrtail; /* Tail (newest) index into rxring */
175 hp100_ring_t *txrhead; /* Head (oldest) index into txring */
176 hp100_ring_t *txrtail; /* Tail (newest) index into txring */
177
178 hp100_ring_t rxring[MAX_RX_PDL];
179 hp100_ring_t txring[MAX_TX_PDL];
180
181 u_int *page_vaddr_algn; /* Aligned virtual address of allocated page */
182 u_long whatever_offset; /* Offset to bus/phys/dma address */
183 int rxrcommit; /* # Rx PDLs committed to adapter */
184 int txrcommit; /* # Tx PDLs committed to adapter */
185};
186
187/*
188 * variables
189 */
190#ifdef CONFIG_ISA
191static const char *hp100_isa_tbl[] = {
192 "HWPF150", /* HP J2573 rev A */
193 "HWP1950", /* HP J2573 */
194};
195#endif
196
197#ifdef CONFIG_EISA
198static struct eisa_device_id hp100_eisa_tbl[] = {
199 { "HWPF180" }, /* HP J2577 rev A */
200 { "HWP1920" }, /* HP 27248B */
201 { "HWP1940" }, /* HP J2577 */
202 { "HWP1990" }, /* HP J2577 */
203 { "CPX0301" }, /* ReadyLink ENET100-VG4 */
204 { "CPX0401" }, /* FreedomLine 100/VG */
205 { "" } /* Mandatory final entry ! */
206};
207MODULE_DEVICE_TABLE(eisa, hp100_eisa_tbl);
208#endif
209
210#ifdef CONFIG_PCI
211static DEFINE_PCI_DEVICE_TABLE(hp100_pci_tbl) = {
212 {PCI_VENDOR_ID_HP, PCI_DEVICE_ID_HP_J2585A, PCI_ANY_ID, PCI_ANY_ID,},
213 {PCI_VENDOR_ID_HP, PCI_DEVICE_ID_HP_J2585B, PCI_ANY_ID, PCI_ANY_ID,},
214 {PCI_VENDOR_ID_HP, PCI_DEVICE_ID_HP_J2970A, PCI_ANY_ID, PCI_ANY_ID,},
215 {PCI_VENDOR_ID_HP, PCI_DEVICE_ID_HP_J2973A, PCI_ANY_ID, PCI_ANY_ID,},
216 {PCI_VENDOR_ID_COMPEX, PCI_DEVICE_ID_COMPEX_ENET100VG4, PCI_ANY_ID, PCI_ANY_ID,},
217 {PCI_VENDOR_ID_COMPEX2, PCI_DEVICE_ID_COMPEX2_100VG, PCI_ANY_ID, PCI_ANY_ID,},
218/* {PCI_VENDOR_ID_KTI, PCI_DEVICE_ID_KTI_DP200, PCI_ANY_ID, PCI_ANY_ID }, */
219 {} /* Terminating entry */
220};
221MODULE_DEVICE_TABLE(pci, hp100_pci_tbl);
222#endif
223
224static int hp100_rx_ratio = HP100_DEFAULT_RX_RATIO;
225static int hp100_priority_tx = HP100_DEFAULT_PRIORITY_TX;
226static int hp100_mode = 1;
227
228module_param(hp100_rx_ratio, int, 0);
229module_param(hp100_priority_tx, int, 0);
230module_param(hp100_mode, int, 0);
231
232/*
233 * prototypes
234 */
235
236static int hp100_probe1(struct net_device *dev, int ioaddr, u_char bus,
237 struct pci_dev *pci_dev);
238
239
240static int hp100_open(struct net_device *dev);
241static int hp100_close(struct net_device *dev);
242static netdev_tx_t hp100_start_xmit(struct sk_buff *skb,
243 struct net_device *dev);
244static netdev_tx_t 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/* Conversion to new PCI API :
278 * Convert an address in a kernel buffer to a bus/phys/dma address.
279 * This work *only* for memory fragments part of lp->page_vaddr,
280 * because it was properly DMA allocated via pci_alloc_consistent(),
281 * so we just need to "retrieve" the original mapping to bus/phys/dma
282 * address - Jean II */
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/* TODO: This function should not really be needed in a good design... */
296static void wait(void)
297{
298 mdelay(1);
299}
300
301/*
302 * probe functions
303 * These functions should - if possible - avoid doing write operations
304 * since this could cause problems when the card is not installed.
305 */
306
307/*
308 * Read board id and convert to string.
309 * Effectively same code as decode_eisa_sig
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; /* bad checksum */
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 * Probe for ISA board.
372 * EISA and PCI are handled by device infrastructure.
373 */
374
375static int __init hp100_isa_probe(struct net_device *dev, int addr)
376{
377 int err = -ENODEV;
378
379 /* Probe for a specific ISA address */
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 /* Probe all ISA possible port regions */
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 /* CONFIG_ISA */
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 /* !MODULE && CONFIG_ISA */
427
428static const struct net_device_ops hp100_bm_netdev_ops = {
429 .ndo_open = hp100_open,
430 .ndo_stop = hp100_close,
431 .ndo_start_xmit = hp100_start_xmit_bm,
432 .ndo_get_stats = hp100_get_stats,
433 .ndo_set_multicast_list = hp100_set_multicast_list,
434 .ndo_change_mtu = eth_change_mtu,
435 .ndo_set_mac_address = eth_mac_addr,
436 .ndo_validate_addr = eth_validate_addr,
437};
438
439static const struct net_device_ops hp100_netdev_ops = {
440 .ndo_open = hp100_open,
441 .ndo_stop = hp100_close,
442 .ndo_start_xmit = hp100_start_xmit,
443 .ndo_get_stats = hp100_get_stats,
444 .ndo_set_multicast_list = hp100_set_multicast_list,
445 .ndo_change_mtu = eth_change_mtu,
446 .ndo_set_mac_address = eth_mac_addr,
447 .ndo_validate_addr = eth_validate_addr,
448};
449
450static int __devinit hp100_probe1(struct net_device *dev, int ioaddr,
451 u_char bus, struct pci_dev *pci_dev)
452{
453 int i;
454 int err = -ENODEV;
455 const char *eid;
456 u_int chip;
457 u_char uc;
458 u_int memory_size = 0, virt_memory_size = 0;
459 u_short local_mode, lsw;
460 short mem_mapped;
461 unsigned long mem_ptr_phys;
462 void __iomem *mem_ptr_virt;
463 struct hp100_private *lp;
464
465#ifdef HP100_DEBUG_B
466 hp100_outw(0x4201, TRACE);
467 printk("hp100: %s: probe1\n", dev->name);
468#endif
469
470 /* memory region for programmed i/o */
471 if (!request_region(ioaddr, HP100_REGION_SIZE, "hp100"))
472 goto out1;
473
474 if (hp100_inw(HW_ID) != HP100_HW_ID_CASCADE)
475 goto out2;
476
477 chip = hp100_inw(PAGING) & HP100_CHIPID_MASK;
478#ifdef HP100_DEBUG
479 if (chip == HP100_CHIPID_SHASTA)
480 printk("hp100: %s: Shasta Chip detected. (This is a pre 802.12 chip)\n", dev->name);
481 else if (chip == HP100_CHIPID_RAINIER)
482 printk("hp100: %s: Rainier Chip detected. (This is a pre 802.12 chip)\n", dev->name);
483 else if (chip == HP100_CHIPID_LASSEN)
484 printk("hp100: %s: Lassen Chip detected.\n", dev->name);
485 else
486 printk("hp100: %s: Warning: Unknown CASCADE chip (id=0x%.4x).\n", dev->name, chip);
487#endif
488
489 dev->base_addr = ioaddr;
490
491 eid = hp100_read_id(ioaddr);
492 if (eid == NULL) { /* bad checksum? */
493 printk(KERN_WARNING "hp100_probe: bad ID checksum at base port 0x%x\n", ioaddr);
494 goto out2;
495 }
496
497 hp100_page(ID_MAC_ADDR);
498 for (i = uc = 0; i < 7; i++)
499 uc += hp100_inb(LAN_ADDR + i);
500 if (uc != 0xff) {
501 printk(KERN_WARNING "hp100_probe: bad lan address checksum at port 0x%x)\n", ioaddr);
502 err = -EIO;
503 goto out2;
504 }
505
506 /* Make sure, that all registers are correctly updated... */
507
508 hp100_load_eeprom(dev, ioaddr);
509 wait();
510
511 /*
512 * Determine driver operation mode
513 *
514 * Use the variable "hp100_mode" upon insmod or as kernel parameter to
515 * force driver modes:
516 * hp100_mode=1 -> default, use busmaster mode if configured.
517 * hp100_mode=2 -> enable shared memory mode
518 * hp100_mode=3 -> force use of i/o mapped mode.
519 * hp100_mode=4 -> same as 1, but re-set the enable bit on the card.
520 */
521
522 /*
523 * LSW values:
524 * 0x2278 -> J2585B, PnP shared memory mode
525 * 0x2270 -> J2585B, shared memory mode, 0xdc000
526 * 0xa23c -> J2585B, I/O mapped mode
527 * 0x2240 -> EISA COMPEX, BusMaster (Shasta Chip)
528 * 0x2220 -> EISA HP, I/O (Shasta Chip)
529 * 0x2260 -> EISA HP, BusMaster (Shasta Chip)
530 */
531
532#if 0
533 local_mode = 0x2270;
534 hp100_outw(0xfefe, OPTION_LSW);
535 hp100_outw(local_mode | HP100_SET_LB | HP100_SET_HB, OPTION_LSW);
536#endif
537
538 /* hp100_mode value maybe used in future by another card */
539 local_mode = hp100_mode;
540 if (local_mode < 1 || local_mode > 4)
541 local_mode = 1; /* default */
542#ifdef HP100_DEBUG
543 printk("hp100: %s: original LSW = 0x%x\n", dev->name,
544 hp100_inw(OPTION_LSW));
545#endif
546
547 if (local_mode == 3) {
548 hp100_outw(HP100_MEM_EN | HP100_RESET_LB, OPTION_LSW);
549 hp100_outw(HP100_IO_EN | HP100_SET_LB, OPTION_LSW);
550 hp100_outw(HP100_BM_WRITE | HP100_BM_READ | HP100_RESET_HB, OPTION_LSW);
551 printk("hp100: IO mapped mode forced.\n");
552 } else if (local_mode == 2) {
553 hp100_outw(HP100_MEM_EN | HP100_SET_LB, OPTION_LSW);
554 hp100_outw(HP100_IO_EN | HP100_SET_LB, OPTION_LSW);
555 hp100_outw(HP100_BM_WRITE | HP100_BM_READ | HP100_RESET_HB, OPTION_LSW);
556 printk("hp100: Shared memory mode requested.\n");
557 } else if (local_mode == 4) {
558 if (chip == HP100_CHIPID_LASSEN) {
559 hp100_outw(HP100_BM_WRITE | HP100_BM_READ | HP100_SET_HB, OPTION_LSW);
560 hp100_outw(HP100_IO_EN | HP100_MEM_EN | HP100_RESET_LB, OPTION_LSW);
561 printk("hp100: Busmaster mode requested.\n");
562 }
563 local_mode = 1;
564 }
565
566 if (local_mode == 1) { /* default behaviour */
567 lsw = hp100_inw(OPTION_LSW);
568
569 if ((lsw & HP100_IO_EN) && (~lsw & HP100_MEM_EN) &&
570 (~lsw & (HP100_BM_WRITE | HP100_BM_READ))) {
571#ifdef HP100_DEBUG
572 printk("hp100: %s: IO_EN bit is set on card.\n", dev->name);
573#endif
574 local_mode = 3;
575 } else if (chip == HP100_CHIPID_LASSEN &&
576 (lsw & (HP100_BM_WRITE | HP100_BM_READ)) == (HP100_BM_WRITE | HP100_BM_READ)) {
577 /* Conversion to new PCI API :
578 * I don't have the doc, but I assume that the card
579 * can map the full 32bit address space.
580 * Also, we can have EISA Busmaster cards (not tested),
581 * so beware !!! - Jean II */
582 if((bus == HP100_BUS_PCI) &&
583 (pci_set_dma_mask(pci_dev, DMA_BIT_MASK(32)))) {
584 /* Gracefully fallback to shared memory */
585 goto busmasterfail;
586 }
587 printk("hp100: Busmaster mode enabled.\n");
588 hp100_outw(HP100_MEM_EN | HP100_IO_EN | HP100_RESET_LB, OPTION_LSW);
589 } else {
590 busmasterfail:
591#ifdef HP100_DEBUG
592 printk("hp100: %s: Card not configured for BM or BM not supported with this card.\n", dev->name);
593 printk("hp100: %s: Trying shared memory mode.\n", dev->name);
594#endif
595 /* In this case, try shared memory mode */
596 local_mode = 2;
597 hp100_outw(HP100_MEM_EN | HP100_SET_LB, OPTION_LSW);
598 /* hp100_outw(HP100_IO_EN|HP100_RESET_LB, OPTION_LSW); */
599 }
600 }
601#ifdef HP100_DEBUG
602 printk("hp100: %s: new LSW = 0x%x\n", dev->name, hp100_inw(OPTION_LSW));
603#endif
604
605 /* Check for shared memory on the card, eventually remap it */
606 hp100_page(HW_MAP);
607 mem_mapped = ((hp100_inw(OPTION_LSW) & (HP100_MEM_EN)) != 0);
608 mem_ptr_phys = 0UL;
609 mem_ptr_virt = NULL;
610 memory_size = (8192 << ((hp100_inb(SRAM) >> 5) & 0x07));
611 virt_memory_size = 0;
612
613 /* For memory mapped or busmaster mode, we want the memory address */
614 if (mem_mapped || (local_mode == 1)) {
615 mem_ptr_phys = (hp100_inw(MEM_MAP_LSW) | (hp100_inw(MEM_MAP_MSW) << 16));
616 mem_ptr_phys &= ~0x1fff; /* 8k alignment */
617
618 if (bus == HP100_BUS_ISA && (mem_ptr_phys & ~0xfffff) != 0) {
619 printk("hp100: Can only use programmed i/o mode.\n");
620 mem_ptr_phys = 0;
621 mem_mapped = 0;
622 local_mode = 3; /* Use programmed i/o */
623 }
624
625 /* We do not need access to shared memory in busmaster mode */
626 /* However in slave mode we need to remap high (>1GB) card memory */
627 if (local_mode != 1) { /* = not busmaster */
628 /* We try with smaller memory sizes, if ioremap fails */
629 for (virt_memory_size = memory_size; virt_memory_size > 16383; virt_memory_size >>= 1) {
630 if ((mem_ptr_virt = ioremap((u_long) mem_ptr_phys, virt_memory_size)) == NULL) {
631#ifdef HP100_DEBUG
632 printk("hp100: %s: ioremap for 0x%x bytes high PCI memory at 0x%lx failed\n", dev->name, virt_memory_size, mem_ptr_phys);
633#endif
634 } else {
635#ifdef HP100_DEBUG
636 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);
637#endif
638 break;
639 }
640 }
641
642 if (mem_ptr_virt == NULL) { /* all ioremap tries failed */
643 printk("hp100: Failed to ioremap the PCI card memory. Will have to use i/o mapped mode.\n");
644 local_mode = 3;
645 virt_memory_size = 0;
646 }
647 }
648 }
649
650 if (local_mode == 3) { /* io mapped forced */
651 mem_mapped = 0;
652 mem_ptr_phys = 0;
653 mem_ptr_virt = NULL;
654 printk("hp100: Using (slow) programmed i/o mode.\n");
655 }
656
657 /* Initialise the "private" data structure for this card. */
658 lp = netdev_priv(dev);
659
660 spin_lock_init(&lp->lock);
661 strlcpy(lp->id, eid, HP100_SIG_LEN);
662 lp->chip = chip;
663 lp->mode = local_mode;
664 lp->bus = bus;
665 lp->pci_dev = pci_dev;
666 lp->priority_tx = hp100_priority_tx;
667 lp->rx_ratio = hp100_rx_ratio;
668 lp->mem_ptr_phys = mem_ptr_phys;
669 lp->mem_ptr_virt = mem_ptr_virt;
670 hp100_page(ID_MAC_ADDR);
671 lp->soft_model = hp100_inb(SOFT_MODEL);
672 lp->mac1_mode = HP100_MAC1MODE3;
673 lp->mac2_mode = HP100_MAC2MODE3;
674 memset(&lp->hash_bytes, 0x00, 8);
675
676 dev->base_addr = ioaddr;
677
678 lp->memory_size = memory_size;
679 lp->virt_memory_size = virt_memory_size;
680 lp->rx_ratio = hp100_rx_ratio; /* can be conf'd with insmod */
681
682 if (lp->mode == 1) /* busmaster */
683 dev->netdev_ops = &hp100_bm_netdev_ops;
684 else
685 dev->netdev_ops = &hp100_netdev_ops;
686
687 /* Ask the card for which IRQ line it is configured */
688 if (bus == HP100_BUS_PCI) {
689 dev->irq = pci_dev->irq;
690 } else {
691 hp100_page(HW_MAP);
692 dev->irq = hp100_inb(IRQ_CHANNEL) & HP100_IRQMASK;
693 if (dev->irq == 2)
694 dev->irq = 9;
695 }
696
697 if (lp->mode == 1) /* busmaster */
698 dev->dma = 4;
699
700 /* Ask the card for its MAC address and store it for later use. */
701 hp100_page(ID_MAC_ADDR);
702 for (i = uc = 0; i < 6; i++)
703 dev->dev_addr[i] = hp100_inb(LAN_ADDR + i);
704
705 /* Reset statistics (counters) */
706 hp100_clear_stats(lp, ioaddr);
707
708 /* If busmaster mode is wanted, a dma-capable memory area is needed for
709 * the rx and tx PDLs
710 * PCI cards can access the whole PC memory. Therefore GFP_DMA is not
711 * needed for the allocation of the memory area.
712 */
713
714 /* TODO: We do not need this with old cards, where PDLs are stored
715 * in the cards shared memory area. But currently, busmaster has been
716 * implemented/tested only with the lassen chip anyway... */
717 if (lp->mode == 1) { /* busmaster */
718 dma_addr_t page_baddr;
719 /* Get physically continuous memory for TX & RX PDLs */
720 /* Conversion to new PCI API :
721 * Pages are always aligned and zeroed, no need to it ourself.
722 * Doc says should be OK for EISA bus as well - Jean II */
723 lp->page_vaddr_algn = pci_alloc_consistent(lp->pci_dev, MAX_RINGSIZE, &page_baddr);
724 if (!lp->page_vaddr_algn) {
725 err = -ENOMEM;
726 goto out_mem_ptr;
727 }
728 lp->whatever_offset = ((u_long) page_baddr) - ((u_long) lp->page_vaddr_algn);
729
730#ifdef HP100_DEBUG_BM
731 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);
732#endif
733 lp->rxrcommit = lp->txrcommit = 0;
734 lp->rxrhead = lp->rxrtail = &(lp->rxring[0]);
735 lp->txrhead = lp->txrtail = &(lp->txring[0]);
736 }
737
738 /* Initialise the card. */
739 /* (I'm not really sure if it's a good idea to do this during probing, but
740 * like this it's assured that the lan connection type can be sensed
741 * correctly)
742 */
743 hp100_hwinit(dev);
744
745 /* Try to find out which kind of LAN the card is connected to. */
746 lp->lan_type = hp100_sense_lan(dev);
747
748 /* Print out a message what about what we think we have probed. */
749 printk("hp100: at 0x%x, IRQ %d, ", ioaddr, dev->irq);
750 switch (bus) {
751 case HP100_BUS_EISA:
752 printk("EISA");
753 break;
754 case HP100_BUS_PCI:
755 printk("PCI");
756 break;
757 default:
758 printk("ISA");
759 break;
760 }
761 printk(" bus, %dk SRAM (rx/tx %d%%).\n", lp->memory_size >> 10, lp->rx_ratio);
762
763 if (lp->mode == 2) { /* memory mapped */
764 printk("hp100: Memory area at 0x%lx-0x%lx", mem_ptr_phys,
765 (mem_ptr_phys + (mem_ptr_phys > 0x100000 ? (u_long) lp->memory_size : 16 * 1024)) - 1);
766 if (mem_ptr_virt)
767 printk(" (virtual base %p)", mem_ptr_virt);
768 printk(".\n");
769
770 /* Set for info when doing ifconfig */
771 dev->mem_start = mem_ptr_phys;
772 dev->mem_end = mem_ptr_phys + lp->memory_size;
773 }
774
775 printk("hp100: ");
776 if (lp->lan_type != HP100_LAN_ERR)
777 printk("Adapter is attached to ");
778 switch (lp->lan_type) {
779 case HP100_LAN_100:
780 printk("100Mb/s Voice Grade AnyLAN network.\n");
781 break;
782 case HP100_LAN_10:
783 printk("10Mb/s network (10baseT).\n");
784 break;
785 case HP100_LAN_COAX:
786 printk("10Mb/s network (coax).\n");
787 break;
788 default:
789 printk("Warning! Link down.\n");
790 }
791
792 err = register_netdev(dev);
793 if (err)
794 goto out3;
795
796 return 0;
797out3:
798 if (local_mode == 1)
799 pci_free_consistent(lp->pci_dev, MAX_RINGSIZE + 0x0f,
800 lp->page_vaddr_algn,
801 virt_to_whatever(dev, lp->page_vaddr_algn));
802out_mem_ptr:
803 if (mem_ptr_virt)
804 iounmap(mem_ptr_virt);
805out2:
806 release_region(ioaddr, HP100_REGION_SIZE);
807out1:
808 return err;
809}
810
811/* This procedure puts the card into a stable init state */
812static void hp100_hwinit(struct net_device *dev)
813{
814 int ioaddr = dev->base_addr;
815 struct hp100_private *lp = netdev_priv(dev);
816
817#ifdef HP100_DEBUG_B
818 hp100_outw(0x4202, TRACE);
819 printk("hp100: %s: hwinit\n", dev->name);
820#endif
821
822 /* Initialise the card. -------------------------------------------- */
823
824 /* Clear all pending Ints and disable Ints */
825 hp100_page(PERFORMANCE);
826 hp100_outw(0xfefe, IRQ_MASK); /* mask off all ints */
827 hp100_outw(0xffff, IRQ_STATUS); /* clear all pending ints */
828
829 hp100_outw(HP100_INT_EN | HP100_RESET_LB, OPTION_LSW);
830 hp100_outw(HP100_TRI_INT | HP100_SET_HB, OPTION_LSW);
831
832 if (lp->mode == 1) {
833 hp100_BM_shutdown(dev); /* disables BM, puts cascade in reset */
834 wait();
835 } else {
836 hp100_outw(HP100_INT_EN | HP100_RESET_LB, OPTION_LSW);
837 hp100_cascade_reset(dev, 1);
838 hp100_page(MAC_CTRL);
839 hp100_andb(~(HP100_RX_EN | HP100_TX_EN), MAC_CFG_1);
840 }
841
842 /* Initiate EEPROM reload */
843 hp100_load_eeprom(dev, 0);
844
845 wait();
846
847 /* Go into reset again. */
848 hp100_cascade_reset(dev, 1);
849
850 /* Set Option Registers to a safe state */
851 hp100_outw(HP100_DEBUG_EN |
852 HP100_RX_HDR |
853 HP100_EE_EN |
854 HP100_BM_WRITE |
855 HP100_BM_READ | HP100_RESET_HB |
856 HP100_FAKE_INT |
857 HP100_INT_EN |
858 HP100_MEM_EN |
859 HP100_IO_EN | HP100_RESET_LB, OPTION_LSW);
860
861 hp100_outw(HP100_TRI_INT |
862 HP100_MMAP_DIS | HP100_SET_HB, OPTION_LSW);
863
864 hp100_outb(HP100_PRIORITY_TX |
865 HP100_ADV_NXT_PKT |
866 HP100_TX_CMD | HP100_RESET_LB, OPTION_MSW);
867
868 /* TODO: Configure MMU for Ram Test. */
869 /* TODO: Ram Test. */
870
871 /* Re-check if adapter is still at same i/o location */
872 /* (If the base i/o in eeprom has been changed but the */
873 /* registers had not been changed, a reload of the eeprom */
874 /* would move the adapter to the address stored in eeprom */
875
876 /* TODO: Code to implement. */
877
878 /* Until here it was code from HWdiscover procedure. */
879 /* Next comes code from mmuinit procedure of SCO BM driver which is
880 * called from HWconfigure in the SCO driver. */
881
882 /* Initialise MMU, eventually switch on Busmaster Mode, initialise
883 * multicast filter...
884 */
885 hp100_mmuinit(dev);
886
887 /* We don't turn the interrupts on here - this is done by start_interface. */
888 wait(); /* TODO: Do we really need this? */
889
890 /* Enable Hardware (e.g. unreset) */
891 hp100_cascade_reset(dev, 0);
892
893 /* ------- initialisation complete ----------- */
894
895 /* Finally try to log in the Hub if there may be a VG connection. */
896 if ((lp->lan_type == HP100_LAN_100) || (lp->lan_type == HP100_LAN_ERR))
897 hp100_login_to_vg_hub(dev, 0); /* relogin */
898
899}
900
901
902/*
903 * mmuinit - Reinitialise Cascade MMU and MAC settings.
904 * Note: Must already be in reset and leaves card in reset.
905 */
906static void hp100_mmuinit(struct net_device *dev)
907{
908 int ioaddr = dev->base_addr;
909 struct hp100_private *lp = netdev_priv(dev);
910 int i;
911
912#ifdef HP100_DEBUG_B
913 hp100_outw(0x4203, TRACE);
914 printk("hp100: %s: mmuinit\n", dev->name);
915#endif
916
917#ifdef HP100_DEBUG
918 if (0 != (hp100_inw(OPTION_LSW) & HP100_HW_RST)) {
919 printk("hp100: %s: Not in reset when entering mmuinit. Fix me.\n", dev->name);
920 return;
921 }
922#endif
923
924 /* Make sure IRQs are masked off and ack'ed. */
925 hp100_page(PERFORMANCE);
926 hp100_outw(0xfefe, IRQ_MASK); /* mask off all ints */
927 hp100_outw(0xffff, IRQ_STATUS); /* ack IRQ */
928
929 /*
930 * Enable Hardware
931 * - Clear Debug En, Rx Hdr Pipe, EE En, I/O En, Fake Int and Intr En
932 * - Set Tri-State Int, Bus Master Rd/Wr, and Mem Map Disable
933 * - Clear Priority, Advance Pkt and Xmit Cmd
934 */
935
936 hp100_outw(HP100_DEBUG_EN |
937 HP100_RX_HDR |
938 HP100_EE_EN | HP100_RESET_HB |
939 HP100_IO_EN |
940 HP100_FAKE_INT |
941 HP100_INT_EN | HP100_RESET_LB, OPTION_LSW);
942
943 hp100_outw(HP100_TRI_INT | HP100_SET_HB, OPTION_LSW);
944
945 if (lp->mode == 1) { /* busmaster */
946 hp100_outw(HP100_BM_WRITE |
947 HP100_BM_READ |
948 HP100_MMAP_DIS | HP100_SET_HB, OPTION_LSW);
949 } else if (lp->mode == 2) { /* memory mapped */
950 hp100_outw(HP100_BM_WRITE |
951 HP100_BM_READ | HP100_RESET_HB, OPTION_LSW);
952 hp100_outw(HP100_MMAP_DIS | HP100_RESET_HB, OPTION_LSW);
953 hp100_outw(HP100_MEM_EN | HP100_SET_LB, OPTION_LSW);
954 hp100_outw(HP100_IO_EN | HP100_SET_LB, OPTION_LSW);
955 } else if (lp->mode == 3) { /* i/o mapped mode */
956 hp100_outw(HP100_MMAP_DIS | HP100_SET_HB |
957 HP100_IO_EN | HP100_SET_LB, OPTION_LSW);
958 }
959
960 hp100_page(HW_MAP);
961 hp100_outb(0, EARLYRXCFG);
962 hp100_outw(0, EARLYTXCFG);
963
964 /*
965 * Enable Bus Master mode
966 */
967 if (lp->mode == 1) { /* busmaster */
968 /* Experimental: Set some PCI configuration bits */
969 hp100_page(HW_MAP);
970 hp100_andb(~HP100_PDL_USE3, MODECTRL1); /* BM engine read maximum */
971 hp100_andb(~HP100_TX_DUALQ, MODECTRL1); /* No Queue for Priority TX */
972
973 /* PCI Bus failures should result in a Misc. Interrupt */
974 hp100_orb(HP100_EN_BUS_FAIL, MODECTRL2);
975
976 hp100_outw(HP100_BM_READ | HP100_BM_WRITE | HP100_SET_HB, OPTION_LSW);
977 hp100_page(HW_MAP);
978 /* Use Burst Mode and switch on PAGE_CK */
979 hp100_orb(HP100_BM_BURST_RD | HP100_BM_BURST_WR, BM);
980 if ((lp->chip == HP100_CHIPID_RAINIER) || (lp->chip == HP100_CHIPID_SHASTA))
981 hp100_orb(HP100_BM_PAGE_CK, BM);
982 hp100_orb(HP100_BM_MASTER, BM);
983 } else { /* not busmaster */
984
985 hp100_page(HW_MAP);
986 hp100_andb(~HP100_BM_MASTER, BM);
987 }
988
989 /*
990 * Divide card memory into regions for Rx, Tx and, if non-ETR chip, PDLs
991 */
992 hp100_page(MMU_CFG);
993 if (lp->mode == 1) { /* only needed for Busmaster */
994 int xmit_stop, recv_stop;
995
996 if ((lp->chip == HP100_CHIPID_RAINIER) ||
997 (lp->chip == HP100_CHIPID_SHASTA)) {
998 int pdl_stop;
999
1000 /*
1001 * Each pdl is 508 bytes long. (63 frags * 4 bytes for address and
1002 * 4 bytes for header). We will leave NUM_RXPDLS * 508 (rounded
1003 * to the next higher 1k boundary) bytes for the rx-pdl's
1004 * Note: For non-etr chips the transmit stop register must be
1005 * programmed on a 1k boundary, i.e. bits 9:0 must be zero.
1006 */
1007 pdl_stop = lp->memory_size;
1008 xmit_stop = (pdl_stop - 508 * (MAX_RX_PDL) - 16) & ~(0x03ff);
1009 recv_stop = (xmit_stop * (lp->rx_ratio) / 100) & ~(0x03ff);
1010 hp100_outw((pdl_stop >> 4) - 1, PDL_MEM_STOP);
1011#ifdef HP100_DEBUG_BM
1012 printk("hp100: %s: PDL_STOP = 0x%x\n", dev->name, pdl_stop);
1013#endif
1014 } else {
1015 /* ETR chip (Lassen) in busmaster mode */
1016 xmit_stop = (lp->memory_size) - 1;
1017 recv_stop = ((lp->memory_size * lp->rx_ratio) / 100) & ~(0x03ff);
1018 }
1019
1020 hp100_outw(xmit_stop >> 4, TX_MEM_STOP);
1021 hp100_outw(recv_stop >> 4, RX_MEM_STOP);
1022#ifdef HP100_DEBUG_BM
1023 printk("hp100: %s: TX_STOP = 0x%x\n", dev->name, xmit_stop >> 4);
1024 printk("hp100: %s: RX_STOP = 0x%x\n", dev->name, recv_stop >> 4);
1025#endif
1026 } else {
1027 /* Slave modes (memory mapped and programmed io) */
1028 hp100_outw((((lp->memory_size * lp->rx_ratio) / 100) >> 4), RX_MEM_STOP);
1029 hp100_outw(((lp->memory_size - 1) >> 4), TX_MEM_STOP);
1030#ifdef HP100_DEBUG
1031 printk("hp100: %s: TX_MEM_STOP: 0x%x\n", dev->name, hp100_inw(TX_MEM_STOP));
1032 printk("hp100: %s: RX_MEM_STOP: 0x%x\n", dev->name, hp100_inw(RX_MEM_STOP));
1033#endif
1034 }
1035
1036 /* Write MAC address into page 1 */
1037 hp100_page(MAC_ADDRESS);
1038 for (i = 0; i < 6; i++)
1039 hp100_outb(dev->dev_addr[i], MAC_ADDR + i);
1040
1041 /* Zero the multicast hash registers */
1042 for (i = 0; i < 8; i++)
1043 hp100_outb(0x0, HASH_BYTE0 + i);
1044
1045 /* Set up MAC defaults */
1046 hp100_page(MAC_CTRL);
1047
1048 /* Go to LAN Page and zero all filter bits */
1049 /* Zero accept error, accept multicast, accept broadcast and accept */
1050 /* all directed packet bits */
1051 hp100_andb(~(HP100_RX_EN |
1052 HP100_TX_EN |
1053 HP100_ACC_ERRORED |
1054 HP100_ACC_MC |
1055 HP100_ACC_BC | HP100_ACC_PHY), MAC_CFG_1);
1056
1057 hp100_outb(0x00, MAC_CFG_2);
1058
1059 /* Zero the frame format bit. This works around a training bug in the */
1060 /* new hubs. */
1061 hp100_outb(0x00, VG_LAN_CFG_2); /* (use 802.3) */
1062
1063 if (lp->priority_tx)
1064 hp100_outb(HP100_PRIORITY_TX | HP100_SET_LB, OPTION_MSW);
1065 else
1066 hp100_outb(HP100_PRIORITY_TX | HP100_RESET_LB, OPTION_MSW);
1067
1068 hp100_outb(HP100_ADV_NXT_PKT |
1069 HP100_TX_CMD | HP100_RESET_LB, OPTION_MSW);
1070
1071 /* If busmaster, initialize the PDLs */
1072 if (lp->mode == 1)
1073 hp100_init_pdls(dev);
1074
1075 /* Go to performance page and initialize isr and imr registers */
1076 hp100_page(PERFORMANCE);
1077 hp100_outw(0xfefe, IRQ_MASK); /* mask off all ints */
1078 hp100_outw(0xffff, IRQ_STATUS); /* ack IRQ */
1079}
1080
1081/*
1082 * open/close functions
1083 */
1084
1085static int hp100_open(struct net_device *dev)
1086{
1087 struct hp100_private *lp = netdev_priv(dev);
1088#ifdef HP100_DEBUG_B
1089 int ioaddr = dev->base_addr;
1090#endif
1091
1092#ifdef HP100_DEBUG_B
1093 hp100_outw(0x4204, TRACE);
1094 printk("hp100: %s: open\n", dev->name);
1095#endif
1096
1097 /* New: if bus is PCI or EISA, interrupts might be shared interrupts */
1098 if (request_irq(dev->irq, hp100_interrupt,
1099 lp->bus == HP100_BUS_PCI || lp->bus ==
1100 HP100_BUS_EISA ? IRQF_SHARED : IRQF_DISABLED,
1101 "hp100", dev)) {
1102 printk("hp100: %s: unable to get IRQ %d\n", dev->name, dev->irq);
1103 return -EAGAIN;
1104 }
1105
1106 dev->trans_start = jiffies; /* prevent tx timeout */
1107 netif_start_queue(dev);
1108
1109 lp->lan_type = hp100_sense_lan(dev);
1110 lp->mac1_mode = HP100_MAC1MODE3;
1111 lp->mac2_mode = HP100_MAC2MODE3;
1112 memset(&lp->hash_bytes, 0x00, 8);
1113
1114 hp100_stop_interface(dev);
1115
1116 hp100_hwinit(dev);
1117
1118 hp100_start_interface(dev); /* sets mac modes, enables interrupts */
1119
1120 return 0;
1121}
1122
1123/* The close function is called when the interface is to be brought down */
1124static int hp100_close(struct net_device *dev)
1125{
1126 int ioaddr = dev->base_addr;
1127 struct hp100_private *lp = netdev_priv(dev);
1128
1129#ifdef HP100_DEBUG_B
1130 hp100_outw(0x4205, TRACE);
1131 printk("hp100: %s: close\n", dev->name);
1132#endif
1133
1134 hp100_page(PERFORMANCE);
1135 hp100_outw(0xfefe, IRQ_MASK); /* mask off all IRQs */
1136
1137 hp100_stop_interface(dev);
1138
1139 if (lp->lan_type == HP100_LAN_100)
1140 lp->hub_status = hp100_login_to_vg_hub(dev, 0);
1141
1142 netif_stop_queue(dev);
1143
1144 free_irq(dev->irq, dev);
1145
1146#ifdef HP100_DEBUG
1147 printk("hp100: %s: close LSW = 0x%x\n", dev->name,
1148 hp100_inw(OPTION_LSW));
1149#endif
1150
1151 return 0;
1152}
1153
1154
1155/*
1156 * Configure the PDL Rx rings and LAN
1157 */
1158static void hp100_init_pdls(struct net_device *dev)
1159{
1160 struct hp100_private *lp = netdev_priv(dev);
1161 hp100_ring_t *ringptr;
1162 u_int *pageptr; /* Warning : increment by 4 - Jean II */
1163 int i;
1164
1165#ifdef HP100_DEBUG_B
1166 int ioaddr = dev->base_addr;
1167#endif
1168
1169#ifdef HP100_DEBUG_B
1170 hp100_outw(0x4206, TRACE);
1171 printk("hp100: %s: init pdls\n", dev->name);
1172#endif
1173
1174 if (!lp->page_vaddr_algn)
1175 printk("hp100: %s: Warning: lp->page_vaddr_algn not initialised!\n", dev->name);
1176 else {
1177 /* pageptr shall point into the DMA accessible memory region */
1178 /* we use this pointer to status the upper limit of allocated */
1179 /* memory in the allocated page. */
1180 /* note: align the pointers to the pci cache line size */
1181 memset(lp->page_vaddr_algn, 0, MAX_RINGSIZE); /* Zero Rx/Tx ring page */
1182 pageptr = lp->page_vaddr_algn;
1183
1184 lp->rxrcommit = 0;
1185 ringptr = lp->rxrhead = lp->rxrtail = &(lp->rxring[0]);
1186
1187 /* Initialise Rx Ring */
1188 for (i = MAX_RX_PDL - 1; i >= 0; i--) {
1189 lp->rxring[i].next = ringptr;
1190 ringptr = &(lp->rxring[i]);
1191 pageptr += hp100_init_rxpdl(dev, ringptr, pageptr);
1192 }
1193
1194 /* Initialise Tx Ring */
1195 lp->txrcommit = 0;
1196 ringptr = lp->txrhead = lp->txrtail = &(lp->txring[0]);
1197 for (i = MAX_TX_PDL - 1; i >= 0; i--) {
1198 lp->txring[i].next = ringptr;
1199 ringptr = &(lp->txring[i]);
1200 pageptr += hp100_init_txpdl(dev, ringptr, pageptr);
1201 }
1202 }
1203}
1204
1205
1206/* These functions "format" the entries in the pdl structure */
1207/* They return how much memory the fragments need. */
1208static int hp100_init_rxpdl(struct net_device *dev,
1209 register hp100_ring_t * ringptr,
1210 register u32 * pdlptr)
1211{
1212 /* pdlptr is starting address for this pdl */
1213
1214 if (0 != (((unsigned long) pdlptr) & 0xf))
1215 printk("hp100: %s: Init rxpdl: Unaligned pdlptr 0x%lx.\n",
1216 dev->name, (unsigned long) pdlptr);
1217
1218 ringptr->pdl = pdlptr + 1;
1219 ringptr->pdl_paddr = virt_to_whatever(dev, pdlptr + 1);
1220 ringptr->skb = (void *) NULL;
1221
1222 /*
1223 * Write address and length of first PDL Fragment (which is used for
1224 * storing the RX-Header
1225 * We use the 4 bytes _before_ the PDH in the pdl memory area to
1226 * store this information. (PDH is at offset 0x04)
1227 */
1228 /* Note that pdlptr+1 and not pdlptr is the pointer to the PDH */
1229
1230 *(pdlptr + 2) = (u_int) virt_to_whatever(dev, pdlptr); /* Address Frag 1 */
1231 *(pdlptr + 3) = 4; /* Length Frag 1 */
1232
1233 return roundup(MAX_RX_FRAG * 2 + 2, 4);
1234}
1235
1236
1237static int hp100_init_txpdl(struct net_device *dev,
1238 register hp100_ring_t * ringptr,
1239 register u32 * pdlptr)
1240{
1241 if (0 != (((unsigned long) pdlptr) & 0xf))
1242 printk("hp100: %s: Init txpdl: Unaligned pdlptr 0x%lx.\n", dev->name, (unsigned long) pdlptr);
1243
1244 ringptr->pdl = pdlptr; /* +1; */
1245 ringptr->pdl_paddr = virt_to_whatever(dev, pdlptr); /* +1 */
1246 ringptr->skb = (void *) NULL;
1247
1248 return roundup(MAX_TX_FRAG * 2 + 2, 4);
1249}
1250
1251/*
1252 * hp100_build_rx_pdl allocates an skb_buff of maximum size plus two bytes
1253 * for possible odd word alignment rounding up to next dword and set PDL
1254 * address for fragment#2
1255 * Returns: 0 if unable to allocate skb_buff
1256 * 1 if successful
1257 */
1258static int hp100_build_rx_pdl(hp100_ring_t * ringptr,
1259 struct net_device *dev)
1260{
1261#ifdef HP100_DEBUG_B
1262 int ioaddr = dev->base_addr;
1263#endif
1264#ifdef HP100_DEBUG_BM
1265 u_int *p;
1266#endif
1267
1268#ifdef HP100_DEBUG_B
1269 hp100_outw(0x4207, TRACE);
1270 printk("hp100: %s: build rx pdl\n", dev->name);
1271#endif
1272
1273 /* Allocate skb buffer of maximum size */
1274 /* Note: This depends on the alloc_skb functions allocating more
1275 * space than requested, i.e. aligning to 16bytes */
1276
1277 ringptr->skb = dev_alloc_skb(roundup(MAX_ETHER_SIZE + 2, 4));
1278
1279 if (NULL != ringptr->skb) {
1280 /*
1281 * Reserve 2 bytes at the head of the buffer to land the IP header
1282 * on a long word boundary (According to the Network Driver section
1283 * in the Linux KHG, this should help to increase performance.)
1284 */
1285 skb_reserve(ringptr->skb, 2);
1286
1287 ringptr->skb->dev = dev;
1288 ringptr->skb->data = (u_char *) skb_put(ringptr->skb, MAX_ETHER_SIZE);
1289
1290 /* ringptr->pdl points to the beginning of the PDL, i.e. the PDH */
1291 /* Note: 1st Fragment is used for the 4 byte packet status
1292 * (receive header). Its PDL entries are set up by init_rxpdl. So
1293 * here we only have to set up the PDL fragment entries for the data
1294 * part. Those 4 bytes will be stored in the DMA memory region
1295 * directly before the PDL.
1296 */
1297#ifdef HP100_DEBUG_BM
1298 printk("hp100: %s: build_rx_pdl: PDH@0x%x, skb->data (len %d) at 0x%x\n",
1299 dev->name, (u_int) ringptr->pdl,
1300 roundup(MAX_ETHER_SIZE + 2, 4),
1301 (unsigned int) ringptr->skb->data);
1302#endif
1303
1304 /* Conversion to new PCI API : map skbuf data to PCI bus.
1305 * Doc says it's OK for EISA as well - Jean II */
1306 ringptr->pdl[0] = 0x00020000; /* Write PDH */
1307 ringptr->pdl[3] = pdl_map_data(netdev_priv(dev),
1308 ringptr->skb->data);
1309 ringptr->pdl[4] = MAX_ETHER_SIZE; /* Length of Data */
1310
1311#ifdef HP100_DEBUG_BM
1312 for (p = (ringptr->pdl); p < (ringptr->pdl + 5); p++)
1313 printk("hp100: %s: Adr 0x%.8x = 0x%.8x\n", dev->name, (u_int) p, (u_int) * p);
1314#endif
1315 return 1;
1316 }
1317 /* else: */
1318 /* alloc_skb failed (no memory) -> still can receive the header
1319 * fragment into PDL memory. make PDL safe by clearing msgptr and
1320 * making the PDL only 1 fragment (i.e. the 4 byte packet status)
1321 */
1322#ifdef HP100_DEBUG_BM
1323 printk("hp100: %s: build_rx_pdl: PDH@0x%x, No space for skb.\n", dev->name, (u_int) ringptr->pdl);
1324#endif
1325
1326 ringptr->pdl[0] = 0x00010000; /* PDH: Count=1 Fragment */
1327
1328 return 0;
1329}
1330
1331/*
1332 * hp100_rxfill - attempt to fill the Rx Ring will empty skb's
1333 *
1334 * Makes assumption that skb's are always contiguous memory areas and
1335 * therefore PDLs contain only 2 physical fragments.
1336 * - While the number of Rx PDLs with buffers is less than maximum
1337 * a. Get a maximum packet size skb
1338 * b. Put the physical address of the buffer into the PDL.
1339 * c. Output physical address of PDL to adapter.
1340 */
1341static void hp100_rxfill(struct net_device *dev)
1342{
1343 int ioaddr = dev->base_addr;
1344
1345 struct hp100_private *lp = netdev_priv(dev);
1346 hp100_ring_t *ringptr;
1347
1348#ifdef HP100_DEBUG_B
1349 hp100_outw(0x4208, TRACE);
1350 printk("hp100: %s: rxfill\n", dev->name);
1351#endif
1352
1353 hp100_page(PERFORMANCE);
1354
1355 while (lp->rxrcommit < MAX_RX_PDL) {
1356 /*
1357 ** Attempt to get a buffer and build a Rx PDL.
1358 */
1359 ringptr = lp->rxrtail;
1360 if (0 == hp100_build_rx_pdl(ringptr, dev)) {
1361 return; /* None available, return */
1362 }
1363
1364 /* Hand this PDL over to the card */
1365 /* Note: This needs performance page selected! */
1366#ifdef HP100_DEBUG_BM
1367 printk("hp100: %s: rxfill: Hand to card: pdl #%d @0x%x phys:0x%x, buffer: 0x%x\n",
1368 dev->name, lp->rxrcommit, (u_int) ringptr->pdl,
1369 (u_int) ringptr->pdl_paddr, (u_int) ringptr->pdl[3]);
1370#endif
1371
1372 hp100_outl((u32) ringptr->pdl_paddr, RX_PDA);
1373
1374 lp->rxrcommit += 1;
1375 lp->rxrtail = ringptr->next;
1376 }
1377}
1378
1379/*
1380 * BM_shutdown - shutdown bus mastering and leave chip in reset state
1381 */
1382
1383static void hp100_BM_shutdown(struct net_device *dev)
1384{
1385 int ioaddr = dev->base_addr;
1386 struct hp100_private *lp = netdev_priv(dev);
1387 unsigned long time;
1388
1389#ifdef HP100_DEBUG_B
1390 hp100_outw(0x4209, TRACE);
1391 printk("hp100: %s: bm shutdown\n", dev->name);
1392#endif
1393
1394 hp100_page(PERFORMANCE);
1395 hp100_outw(0xfefe, IRQ_MASK); /* mask off all ints */
1396 hp100_outw(0xffff, IRQ_STATUS); /* Ack all ints */
1397
1398 /* Ensure Interrupts are off */
1399 hp100_outw(HP100_INT_EN | HP100_RESET_LB, OPTION_LSW);
1400
1401 /* Disable all MAC activity */
1402 hp100_page(MAC_CTRL);
1403 hp100_andb(~(HP100_RX_EN | HP100_TX_EN), MAC_CFG_1); /* stop rx/tx */
1404
1405 /* If cascade MMU is not already in reset */
1406 if (0 != (hp100_inw(OPTION_LSW) & HP100_HW_RST)) {
1407 /* Wait 1.3ms (10Mb max packet time) to ensure MAC is idle so
1408 * MMU pointers will not be reset out from underneath
1409 */
1410 hp100_page(MAC_CTRL);
1411 for (time = 0; time < 5000; time++) {
1412 if ((hp100_inb(MAC_CFG_1) & (HP100_TX_IDLE | HP100_RX_IDLE)) == (HP100_TX_IDLE | HP100_RX_IDLE))
1413 break;
1414 }
1415
1416 /* Shutdown algorithm depends on the generation of Cascade */
1417 if (lp->chip == HP100_CHIPID_LASSEN) { /* ETR shutdown/reset */
1418 /* Disable Busmaster mode and wait for bit to go to zero. */
1419 hp100_page(HW_MAP);
1420 hp100_andb(~HP100_BM_MASTER, BM);
1421 /* 100 ms timeout */
1422 for (time = 0; time < 32000; time++) {
1423 if (0 == (hp100_inb(BM) & HP100_BM_MASTER))
1424 break;
1425 }
1426 } else { /* Shasta or Rainier Shutdown/Reset */
1427 /* To ensure all bus master inloading activity has ceased,
1428 * wait for no Rx PDAs or no Rx packets on card.
1429 */
1430 hp100_page(PERFORMANCE);
1431 /* 100 ms timeout */
1432 for (time = 0; time < 10000; time++) {
1433 /* RX_PDL: PDLs not executed. */
1434 /* RX_PKT_CNT: RX'd packets on card. */
1435 if ((hp100_inb(RX_PDL) == 0) && (hp100_inb(RX_PKT_CNT) == 0))
1436 break;
1437 }
1438
1439 if (time >= 10000)
1440 printk("hp100: %s: BM shutdown error.\n", dev->name);
1441
1442 /* To ensure all bus master outloading activity has ceased,
1443 * wait until the Tx PDA count goes to zero or no more Tx space
1444 * available in the Tx region of the card.
1445 */
1446 /* 100 ms timeout */
1447 for (time = 0; time < 10000; time++) {
1448 if ((0 == hp100_inb(TX_PKT_CNT)) &&
1449 (0 != (hp100_inb(TX_MEM_FREE) & HP100_AUTO_COMPARE)))
1450 break;
1451 }
1452
1453 /* Disable Busmaster mode */
1454 hp100_page(HW_MAP);
1455 hp100_andb(~HP100_BM_MASTER, BM);
1456 } /* end of shutdown procedure for non-etr parts */
1457
1458 hp100_cascade_reset(dev, 1);
1459 }
1460 hp100_page(PERFORMANCE);
1461 /* hp100_outw( HP100_BM_READ | HP100_BM_WRITE | HP100_RESET_HB, OPTION_LSW ); */
1462 /* Busmaster mode should be shut down now. */
1463}
1464
1465static int hp100_check_lan(struct net_device *dev)
1466{
1467 struct hp100_private *lp = netdev_priv(dev);
1468
1469 if (lp->lan_type < 0) { /* no LAN type detected yet? */
1470 hp100_stop_interface(dev);
1471 if ((lp->lan_type = hp100_sense_lan(dev)) < 0) {
1472 printk("hp100: %s: no connection found - check wire\n", dev->name);
1473 hp100_start_interface(dev); /* 10Mb/s RX packets maybe handled */
1474 return -EIO;
1475 }
1476 if (lp->lan_type == HP100_LAN_100)
1477 lp->hub_status = hp100_login_to_vg_hub(dev, 0); /* relogin */
1478 hp100_start_interface(dev);
1479 }
1480 return 0;
1481}
1482
1483/*
1484 * transmit functions
1485 */
1486
1487/* tx function for busmaster mode */
1488static netdev_tx_t hp100_start_xmit_bm(struct sk_buff *skb,
1489 struct net_device *dev)
1490{
1491 unsigned long flags;
1492 int i, ok_flag;
1493 int ioaddr = dev->base_addr;
1494 struct hp100_private *lp = netdev_priv(dev);
1495 hp100_ring_t *ringptr;
1496
1497#ifdef HP100_DEBUG_B
1498 hp100_outw(0x4210, TRACE);
1499 printk("hp100: %s: start_xmit_bm\n", dev->name);
1500#endif
1501 if (skb->len <= 0)
1502 goto drop;
1503
1504 if (lp->chip == HP100_CHIPID_SHASTA && skb_padto(skb, ETH_ZLEN))
1505 return NETDEV_TX_OK;
1506
1507 /* Get Tx ring tail pointer */
1508 if (lp->txrtail->next == lp->txrhead) {
1509 /* No memory. */
1510#ifdef HP100_DEBUG
1511 printk("hp100: %s: start_xmit_bm: No TX PDL available.\n", dev->name);
1512#endif
1513 /* not waited long enough since last tx? */
1514 if (time_before(jiffies, dev_trans_start(dev) + HZ))
1515 goto drop;
1516
1517 if (hp100_check_lan(dev))
1518 goto drop;
1519
1520 if (lp->lan_type == HP100_LAN_100 && lp->hub_status < 0) {
1521 /* we have a 100Mb/s adapter but it isn't connected to hub */
1522 printk("hp100: %s: login to 100Mb/s hub retry\n", dev->name);
1523 hp100_stop_interface(dev);
1524 lp->hub_status = hp100_login_to_vg_hub(dev, 0);
1525 hp100_start_interface(dev);
1526 } else {
1527 spin_lock_irqsave(&lp->lock, flags);
1528 hp100_ints_off(); /* Useful ? Jean II */
1529 i = hp100_sense_lan(dev);
1530 hp100_ints_on();
1531 spin_unlock_irqrestore(&lp->lock, flags);
1532 if (i == HP100_LAN_ERR)
1533 printk("hp100: %s: link down detected\n", dev->name);
1534 else if (lp->lan_type != i) { /* cable change! */
1535 /* it's very hard - all network settings must be changed!!! */
1536 printk("hp100: %s: cable change 10Mb/s <-> 100Mb/s detected\n", dev->name);
1537 lp->lan_type = i;
1538 hp100_stop_interface(dev);
1539 if (lp->lan_type == HP100_LAN_100)
1540 lp->hub_status = hp100_login_to_vg_hub(dev, 0);
1541 hp100_start_interface(dev);
1542 } else {
1543 printk("hp100: %s: interface reset\n", dev->name);
1544 hp100_stop_interface(dev);
1545 if (lp->lan_type == HP100_LAN_100)
1546 lp->hub_status = hp100_login_to_vg_hub(dev, 0);
1547 hp100_start_interface(dev);
1548 }
1549 }
1550
1551 goto drop;
1552 }
1553
1554 /*
1555 * we have to turn int's off before modifying this, otherwise
1556 * a tx_pdl_cleanup could occur at the same time
1557 */
1558 spin_lock_irqsave(&lp->lock, flags);
1559 ringptr = lp->txrtail;
1560 lp->txrtail = ringptr->next;
1561
1562 /* Check whether packet has minimal packet size */
1563 ok_flag = skb->len >= HP100_MIN_PACKET_SIZE;
1564 i = ok_flag ? skb->len : HP100_MIN_PACKET_SIZE;
1565
1566 ringptr->skb = skb;
1567 ringptr->pdl[0] = ((1 << 16) | i); /* PDH: 1 Fragment & length */
1568 if (lp->chip == HP100_CHIPID_SHASTA) {
1569 /* TODO:Could someone who has the EISA card please check if this works? */
1570 ringptr->pdl[2] = i;
1571 } else { /* Lassen */
1572 /* In the PDL, don't use the padded size but the real packet size: */
1573 ringptr->pdl[2] = skb->len; /* 1st Frag: Length of frag */
1574 }
1575 /* Conversion to new PCI API : map skbuf data to PCI bus.
1576 * Doc says it's OK for EISA as well - Jean II */
1577 ringptr->pdl[1] = ((u32) pci_map_single(lp->pci_dev, skb->data, ringptr->pdl[2], PCI_DMA_TODEVICE)); /* 1st Frag: Adr. of data */
1578
1579 /* Hand this PDL to the card. */
1580 hp100_outl(ringptr->pdl_paddr, TX_PDA_L); /* Low Prio. Queue */
1581
1582 lp->txrcommit++;
1583
1584 dev->stats.tx_packets++;
1585 dev->stats.tx_bytes += skb->len;
1586
1587 spin_unlock_irqrestore(&lp->lock, flags);
1588
1589 return NETDEV_TX_OK;
1590
1591drop:
1592 dev_kfree_skb(skb);
1593 return NETDEV_TX_OK;
1594}
1595
1596
1597/* clean_txring checks if packets have been sent by the card by reading
1598 * the TX_PDL register from the performance page and comparing it to the
1599 * number of committed packets. It then frees the skb's of the packets that
1600 * obviously have been sent to the network.
1601 *
1602 * Needs the PERFORMANCE page selected.
1603 */
1604static void hp100_clean_txring(struct net_device *dev)
1605{
1606 struct hp100_private *lp = netdev_priv(dev);
1607 int ioaddr = dev->base_addr;
1608 int donecount;
1609
1610#ifdef HP100_DEBUG_B
1611 hp100_outw(0x4211, TRACE);
1612 printk("hp100: %s: clean txring\n", dev->name);
1613#endif
1614
1615 /* How many PDLs have been transmitted? */
1616 donecount = (lp->txrcommit) - hp100_inb(TX_PDL);
1617
1618#ifdef HP100_DEBUG
1619 if (donecount > MAX_TX_PDL)
1620 printk("hp100: %s: Warning: More PDLs transmitted than committed to card???\n", dev->name);
1621#endif
1622
1623 for (; 0 != donecount; donecount--) {
1624#ifdef HP100_DEBUG_BM
1625 printk("hp100: %s: Free skb: data @0x%.8x txrcommit=0x%x TXPDL=0x%x, done=0x%x\n",
1626 dev->name, (u_int) lp->txrhead->skb->data,
1627 lp->txrcommit, hp100_inb(TX_PDL), donecount);
1628#endif
1629 /* Conversion to new PCI API : NOP */
1630 pci_unmap_single(lp->pci_dev, (dma_addr_t) lp->txrhead->pdl[1], lp->txrhead->pdl[2], PCI_DMA_TODEVICE);
1631 dev_kfree_skb_any(lp->txrhead->skb);
1632 lp->txrhead->skb = (void *) NULL;
1633 lp->txrhead = lp->txrhead->next;
1634 lp->txrcommit--;
1635 }
1636}
1637
1638/* tx function for slave modes */
1639static netdev_tx_t hp100_start_xmit(struct sk_buff *skb,
1640 struct net_device *dev)
1641{
1642 unsigned long flags;
1643 int i, ok_flag;
1644 int ioaddr = dev->base_addr;
1645 u_short val;
1646 struct hp100_private *lp = netdev_priv(dev);
1647
1648#ifdef HP100_DEBUG_B
1649 hp100_outw(0x4212, TRACE);
1650 printk("hp100: %s: start_xmit\n", dev->name);
1651#endif
1652 if (skb->len <= 0)
1653 goto drop;
1654
1655 if (hp100_check_lan(dev))
1656 goto drop;
1657
1658 /* If there is not enough free memory on the card... */
1659 i = hp100_inl(TX_MEM_FREE) & 0x7fffffff;
1660 if (!(((i / 2) - 539) > (skb->len + 16) && (hp100_inb(TX_PKT_CNT) < 255))) {
1661#ifdef HP100_DEBUG
1662 printk("hp100: %s: start_xmit: tx free mem = 0x%x\n", dev->name, i);
1663#endif
1664 /* not waited long enough since last failed tx try? */
1665 if (time_before(jiffies, dev_trans_start(dev) + HZ)) {
1666#ifdef HP100_DEBUG
1667 printk("hp100: %s: trans_start timing problem\n",
1668 dev->name);
1669#endif
1670 goto drop;
1671 }
1672 if (lp->lan_type == HP100_LAN_100 && lp->hub_status < 0) {
1673 /* we have a 100Mb/s adapter but it isn't connected to hub */
1674 printk("hp100: %s: login to 100Mb/s hub retry\n", dev->name);
1675 hp100_stop_interface(dev);
1676 lp->hub_status = hp100_login_to_vg_hub(dev, 0);
1677 hp100_start_interface(dev);
1678 } else {
1679 spin_lock_irqsave(&lp->lock, flags);
1680 hp100_ints_off(); /* Useful ? Jean II */
1681 i = hp100_sense_lan(dev);
1682 hp100_ints_on();
1683 spin_unlock_irqrestore(&lp->lock, flags);
1684 if (i == HP100_LAN_ERR)
1685 printk("hp100: %s: link down detected\n", dev->name);
1686 else if (lp->lan_type != i) { /* cable change! */
1687 /* it's very hard - all network setting must be changed!!! */
1688 printk("hp100: %s: cable change 10Mb/s <-> 100Mb/s detected\n", dev->name);
1689 lp->lan_type = i;
1690 hp100_stop_interface(dev);
1691 if (lp->lan_type == HP100_LAN_100)
1692 lp->hub_status = hp100_login_to_vg_hub(dev, 0);
1693 hp100_start_interface(dev);
1694 } else {
1695 printk("hp100: %s: interface reset\n", dev->name);
1696 hp100_stop_interface(dev);
1697 if (lp->lan_type == HP100_LAN_100)
1698 lp->hub_status = hp100_login_to_vg_hub(dev, 0);
1699 hp100_start_interface(dev);
1700 mdelay(1);
1701 }
1702 }
1703 goto drop;
1704 }
1705
1706 for (i = 0; i < 6000 && (hp100_inb(OPTION_MSW) & HP100_TX_CMD); i++) {
1707#ifdef HP100_DEBUG_TX
1708 printk("hp100: %s: start_xmit: busy\n", dev->name);
1709#endif
1710 }
1711
1712 spin_lock_irqsave(&lp->lock, flags);
1713 hp100_ints_off();
1714 val = hp100_inw(IRQ_STATUS);
1715 /* Ack / clear the interrupt TX_COMPLETE interrupt - this interrupt is set
1716 * when the current packet being transmitted on the wire is completed. */
1717 hp100_outw(HP100_TX_COMPLETE, IRQ_STATUS);
1718#ifdef HP100_DEBUG_TX
1719 printk("hp100: %s: start_xmit: irq_status=0x%.4x, irqmask=0x%.4x, len=%d\n",
1720 dev->name, val, hp100_inw(IRQ_MASK), (int) skb->len);
1721#endif
1722
1723 ok_flag = skb->len >= HP100_MIN_PACKET_SIZE;
1724 i = ok_flag ? skb->len : HP100_MIN_PACKET_SIZE;
1725
1726 hp100_outw(i, DATA32); /* tell card the total packet length */
1727 hp100_outw(i, FRAGMENT_LEN); /* and first/only fragment length */
1728
1729 if (lp->mode == 2) { /* memory mapped */
1730 /* Note: The J2585B needs alignment to 32bits here! */
1731 memcpy_toio(lp->mem_ptr_virt, skb->data, (skb->len + 3) & ~3);
1732 if (!ok_flag)
1733 memset_io(lp->mem_ptr_virt, 0, HP100_MIN_PACKET_SIZE - skb->len);
1734 } else { /* programmed i/o */
1735 outsl(ioaddr + HP100_REG_DATA32, skb->data,
1736 (skb->len + 3) >> 2);
1737 if (!ok_flag)
1738 for (i = (skb->len + 3) & ~3; i < HP100_MIN_PACKET_SIZE; i += 4)
1739 hp100_outl(0, DATA32);
1740 }
1741
1742 hp100_outb(HP100_TX_CMD | HP100_SET_LB, OPTION_MSW); /* send packet */
1743
1744 dev->stats.tx_packets++;
1745 dev->stats.tx_bytes += skb->len;
1746 hp100_ints_on();
1747 spin_unlock_irqrestore(&lp->lock, flags);
1748
1749 dev_kfree_skb_any(skb);
1750
1751#ifdef HP100_DEBUG_TX
1752 printk("hp100: %s: start_xmit: end\n", dev->name);
1753#endif
1754
1755 return NETDEV_TX_OK;
1756
1757drop:
1758 dev_kfree_skb(skb);
1759 return NETDEV_TX_OK;
1760
1761}
1762
1763
1764/*
1765 * Receive Function (Non-Busmaster mode)
1766 * Called when an "Receive Packet" interrupt occurs, i.e. the receive
1767 * packet counter is non-zero.
1768 * For non-busmaster, this function does the whole work of transferring
1769 * the packet to the host memory and then up to higher layers via skb
1770 * and netif_rx.
1771 */
1772
1773static void hp100_rx(struct net_device *dev)
1774{
1775 int packets, pkt_len;
1776 int ioaddr = dev->base_addr;
1777 struct hp100_private *lp = netdev_priv(dev);
1778 u_int header;
1779 struct sk_buff *skb;
1780
1781#ifdef DEBUG_B
1782 hp100_outw(0x4213, TRACE);
1783 printk("hp100: %s: rx\n", dev->name);
1784#endif
1785
1786 /* First get indication of received lan packet */
1787 /* RX_PKT_CND indicates the number of packets which have been fully */
1788 /* received onto the card but have not been fully transferred of the card */
1789 packets = hp100_inb(RX_PKT_CNT);
1790#ifdef HP100_DEBUG_RX
1791 if (packets > 1)
1792 printk("hp100: %s: rx: waiting packets = %d\n", dev->name, packets);
1793#endif
1794
1795 while (packets-- > 0) {
1796 /* If ADV_NXT_PKT is still set, we have to wait until the card has */
1797 /* really advanced to the next packet. */
1798 for (pkt_len = 0; pkt_len < 6000 && (hp100_inb(OPTION_MSW) & HP100_ADV_NXT_PKT); pkt_len++) {
1799#ifdef HP100_DEBUG_RX
1800 printk ("hp100: %s: rx: busy, remaining packets = %d\n", dev->name, packets);
1801#endif
1802 }
1803
1804 /* First we get the header, which contains information about the */
1805 /* actual length of the received packet. */
1806 if (lp->mode == 2) { /* memory mapped mode */
1807 header = readl(lp->mem_ptr_virt);
1808 } else /* programmed i/o */
1809 header = hp100_inl(DATA32);
1810
1811 pkt_len = ((header & HP100_PKT_LEN_MASK) + 3) & ~3;
1812
1813#ifdef HP100_DEBUG_RX
1814 printk("hp100: %s: rx: new packet - length=%d, errors=0x%x, dest=0x%x\n",
1815 dev->name, header & HP100_PKT_LEN_MASK,
1816 (header >> 16) & 0xfff8, (header >> 16) & 7);
1817#endif
1818
1819 /* Now we allocate the skb and transfer the data into it. */
1820 skb = dev_alloc_skb(pkt_len+2);
1821 if (skb == NULL) { /* Not enough memory->drop packet */
1822#ifdef HP100_DEBUG
1823 printk("hp100: %s: rx: couldn't allocate a sk_buff of size %d\n",
1824 dev->name, pkt_len);
1825#endif
1826 dev->stats.rx_dropped++;
1827 } else { /* skb successfully allocated */
1828
1829 u_char *ptr;
1830
1831 skb_reserve(skb,2);
1832
1833 /* ptr to start of the sk_buff data area */
1834 skb_put(skb, pkt_len);
1835 ptr = skb->data;
1836
1837 /* Now transfer the data from the card into that area */
1838 if (lp->mode == 2)
1839 memcpy_fromio(ptr, lp->mem_ptr_virt,pkt_len);
1840 else /* io mapped */
1841 insl(ioaddr + HP100_REG_DATA32, ptr, pkt_len >> 2);
1842
1843 skb->protocol = eth_type_trans(skb, dev);
1844
1845#ifdef HP100_DEBUG_RX
1846 printk("hp100: %s: rx: %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x\n",
1847 dev->name, ptr[0], ptr[1], ptr[2], ptr[3],
1848 ptr[4], ptr[5], ptr[6], ptr[7], ptr[8],
1849 ptr[9], ptr[10], ptr[11]);
1850#endif
1851 netif_rx(skb);
1852 dev->stats.rx_packets++;
1853 dev->stats.rx_bytes += pkt_len;
1854 }
1855
1856 /* Indicate the card that we have got the packet */
1857 hp100_outb(HP100_ADV_NXT_PKT | HP100_SET_LB, OPTION_MSW);
1858
1859 switch (header & 0x00070000) {
1860 case (HP100_MULTI_ADDR_HASH << 16):
1861 case (HP100_MULTI_ADDR_NO_HASH << 16):
1862 dev->stats.multicast++;
1863 break;
1864 }
1865 } /* end of while(there are packets) loop */
1866#ifdef HP100_DEBUG_RX
1867 printk("hp100_rx: %s: end\n", dev->name);
1868#endif
1869}
1870
1871/*
1872 * Receive Function for Busmaster Mode
1873 */
1874static void hp100_rx_bm(struct net_device *dev)
1875{
1876 int ioaddr = dev->base_addr;
1877 struct hp100_private *lp = netdev_priv(dev);
1878 hp100_ring_t *ptr;
1879 u_int header;
1880 int pkt_len;
1881
1882#ifdef HP100_DEBUG_B
1883 hp100_outw(0x4214, TRACE);
1884 printk("hp100: %s: rx_bm\n", dev->name);
1885#endif
1886
1887#ifdef HP100_DEBUG
1888 if (0 == lp->rxrcommit) {
1889 printk("hp100: %s: rx_bm called although no PDLs were committed to adapter?\n", dev->name);
1890 return;
1891 } else
1892 /* RX_PKT_CNT states how many PDLs are currently formatted and available to
1893 * the cards BM engine */
1894 if ((hp100_inw(RX_PKT_CNT) & 0x00ff) >= lp->rxrcommit) {
1895 printk("hp100: %s: More packets received than committed? RX_PKT_CNT=0x%x, commit=0x%x\n",
1896 dev->name, hp100_inw(RX_PKT_CNT) & 0x00ff,
1897 lp->rxrcommit);
1898 return;
1899 }
1900#endif
1901
1902 while ((lp->rxrcommit > hp100_inb(RX_PDL))) {
1903 /*
1904 * The packet was received into the pdl pointed to by lp->rxrhead (
1905 * the oldest pdl in the ring
1906 */
1907
1908 /* First we get the header, which contains information about the */
1909 /* actual length of the received packet. */
1910
1911 ptr = lp->rxrhead;
1912
1913 header = *(ptr->pdl - 1);
1914 pkt_len = (header & HP100_PKT_LEN_MASK);
1915
1916 /* Conversion to new PCI API : NOP */
1917 pci_unmap_single(lp->pci_dev, (dma_addr_t) ptr->pdl[3], MAX_ETHER_SIZE, PCI_DMA_FROMDEVICE);
1918
1919#ifdef HP100_DEBUG_BM
1920 printk("hp100: %s: rx_bm: header@0x%x=0x%x length=%d, errors=0x%x, dest=0x%x\n",
1921 dev->name, (u_int) (ptr->pdl - 1), (u_int) header,
1922 pkt_len, (header >> 16) & 0xfff8, (header >> 16) & 7);
1923 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",
1924 dev->name, hp100_inb(RX_PDL), hp100_inb(TX_PDL),
1925 hp100_inb(RX_PKT_CNT), (u_int) * (ptr->pdl),
1926 (u_int) * (ptr->pdl + 3), (u_int) * (ptr->pdl + 4));
1927#endif
1928
1929 if ((pkt_len >= MIN_ETHER_SIZE) &&
1930 (pkt_len <= MAX_ETHER_SIZE)) {
1931 if (ptr->skb == NULL) {
1932 printk("hp100: %s: rx_bm: skb null\n", dev->name);
1933 /* can happen if we only allocated room for the pdh due to memory shortage. */
1934 dev->stats.rx_dropped++;
1935 } else {
1936 skb_trim(ptr->skb, pkt_len); /* Shorten it */
1937 ptr->skb->protocol =
1938 eth_type_trans(ptr->skb, dev);
1939
1940 netif_rx(ptr->skb); /* Up and away... */
1941
1942 dev->stats.rx_packets++;
1943 dev->stats.rx_bytes += pkt_len;
1944 }
1945
1946 switch (header & 0x00070000) {
1947 case (HP100_MULTI_ADDR_HASH << 16):
1948 case (HP100_MULTI_ADDR_NO_HASH << 16):
1949 dev->stats.multicast++;
1950 break;
1951 }
1952 } else {
1953#ifdef HP100_DEBUG
1954 printk("hp100: %s: rx_bm: Received bad packet (length=%d)\n", dev->name, pkt_len);
1955#endif
1956 if (ptr->skb != NULL)
1957 dev_kfree_skb_any(ptr->skb);
1958 dev->stats.rx_errors++;
1959 }
1960
1961 lp->rxrhead = lp->rxrhead->next;
1962
1963 /* Allocate a new rx PDL (so lp->rxrcommit stays the same) */
1964 if (0 == hp100_build_rx_pdl(lp->rxrtail, dev)) {
1965 /* No space for skb, header can still be received. */
1966#ifdef HP100_DEBUG
1967 printk("hp100: %s: rx_bm: No space for new PDL.\n", dev->name);
1968#endif
1969 return;
1970 } else { /* successfully allocated new PDL - put it in ringlist at tail. */
1971 hp100_outl((u32) lp->rxrtail->pdl_paddr, RX_PDA);
1972 lp->rxrtail = lp->rxrtail->next;
1973 }
1974
1975 }
1976}
1977
1978/*
1979 * statistics
1980 */
1981static struct net_device_stats *hp100_get_stats(struct net_device *dev)
1982{
1983 unsigned long flags;
1984 int ioaddr = dev->base_addr;
1985 struct hp100_private *lp = netdev_priv(dev);
1986
1987#ifdef HP100_DEBUG_B
1988 hp100_outw(0x4215, TRACE);
1989#endif
1990
1991 spin_lock_irqsave(&lp->lock, flags);
1992 hp100_ints_off(); /* Useful ? Jean II */
1993 hp100_update_stats(dev);
1994 hp100_ints_on();
1995 spin_unlock_irqrestore(&lp->lock, flags);
1996 return &(dev->stats);
1997}
1998
1999static void hp100_update_stats(struct net_device *dev)
2000{
2001 int ioaddr = dev->base_addr;
2002 u_short val;
2003
2004#ifdef HP100_DEBUG_B
2005 hp100_outw(0x4216, TRACE);
2006 printk("hp100: %s: update-stats\n", dev->name);
2007#endif
2008
2009 /* Note: Statistics counters clear when read. */
2010 hp100_page(MAC_CTRL);
2011 val = hp100_inw(DROPPED) & 0x0fff;
2012 dev->stats.rx_errors += val;
2013 dev->stats.rx_over_errors += val;
2014 val = hp100_inb(CRC);
2015 dev->stats.rx_errors += val;
2016 dev->stats.rx_crc_errors += val;
2017 val = hp100_inb(ABORT);
2018 dev->stats.tx_errors += val;
2019 dev->stats.tx_aborted_errors += val;
2020 hp100_page(PERFORMANCE);
2021}
2022
2023static void hp100_misc_interrupt(struct net_device *dev)
2024{
2025#ifdef HP100_DEBUG_B
2026 int ioaddr = dev->base_addr;
2027#endif
2028
2029#ifdef HP100_DEBUG_B
2030 int ioaddr = dev->base_addr;
2031 hp100_outw(0x4216, TRACE);
2032 printk("hp100: %s: misc_interrupt\n", dev->name);
2033#endif
2034
2035 /* Note: Statistics counters clear when read. */
2036 dev->stats.rx_errors++;
2037 dev->stats.tx_errors++;
2038}
2039
2040static void hp100_clear_stats(struct hp100_private *lp, int ioaddr)
2041{
2042 unsigned long flags;
2043
2044#ifdef HP100_DEBUG_B
2045 hp100_outw(0x4217, TRACE);
2046 printk("hp100: %s: clear_stats\n", dev->name);
2047#endif
2048
2049 spin_lock_irqsave(&lp->lock, flags);
2050 hp100_page(MAC_CTRL); /* get all statistics bytes */
2051 hp100_inw(DROPPED);
2052 hp100_inb(CRC);
2053 hp100_inb(ABORT);
2054 hp100_page(PERFORMANCE);
2055 spin_unlock_irqrestore(&lp->lock, flags);
2056}
2057
2058
2059/*
2060 * multicast setup
2061 */
2062
2063/*
2064 * Set or clear the multicast filter for this adapter.
2065 */
2066
2067static void hp100_set_multicast_list(struct net_device *dev)
2068{
2069 unsigned long flags;
2070 int ioaddr = dev->base_addr;
2071 struct hp100_private *lp = netdev_priv(dev);
2072
2073#ifdef HP100_DEBUG_B
2074 hp100_outw(0x4218, TRACE);
2075 printk("hp100: %s: set_mc_list\n", dev->name);
2076#endif
2077
2078 spin_lock_irqsave(&lp->lock, flags);
2079 hp100_ints_off();
2080 hp100_page(MAC_CTRL);
2081 hp100_andb(~(HP100_RX_EN | HP100_TX_EN), MAC_CFG_1); /* stop rx/tx */
2082
2083 if (dev->flags & IFF_PROMISC) {
2084 lp->mac2_mode = HP100_MAC2MODE6; /* promiscuous mode = get all good */
2085 lp->mac1_mode = HP100_MAC1MODE6; /* packets on the net */
2086 memset(&lp->hash_bytes, 0xff, 8);
2087 } else if (!netdev_mc_empty(dev) || (dev->flags & IFF_ALLMULTI)) {
2088 lp->mac2_mode = HP100_MAC2MODE5; /* multicast mode = get packets for */
2089 lp->mac1_mode = HP100_MAC1MODE5; /* me, broadcasts and all multicasts */
2090#ifdef HP100_MULTICAST_FILTER /* doesn't work!!! */
2091 if (dev->flags & IFF_ALLMULTI) {
2092 /* set hash filter to receive all multicast packets */
2093 memset(&lp->hash_bytes, 0xff, 8);
2094 } else {
2095 int i, idx;
2096 u_char *addrs;
2097 struct netdev_hw_addr *ha;
2098
2099 memset(&lp->hash_bytes, 0x00, 8);
2100#ifdef HP100_DEBUG
2101 printk("hp100: %s: computing hash filter - mc_count = %i\n",
2102 dev->name, netdev_mc_count(dev));
2103#endif
2104 netdev_for_each_mc_addr(ha, dev) {
2105 addrs = ha->addr;
2106#ifdef HP100_DEBUG
2107 printk("hp100: %s: multicast = %pM, ",
2108 dev->name, addrs);
2109#endif
2110 for (i = idx = 0; i < 6; i++) {
2111 idx ^= *addrs++ & 0x3f;
2112 printk(":%02x:", idx);
2113 }
2114#ifdef HP100_DEBUG
2115 printk("idx = %i\n", idx);
2116#endif
2117 lp->hash_bytes[idx >> 3] |= (1 << (idx & 7));
2118 }
2119 }
2120#else
2121 memset(&lp->hash_bytes, 0xff, 8);
2122#endif
2123 } else {
2124 lp->mac2_mode = HP100_MAC2MODE3; /* normal mode = get packets for me */
2125 lp->mac1_mode = HP100_MAC1MODE3; /* and broadcasts */
2126 memset(&lp->hash_bytes, 0x00, 8);
2127 }
2128
2129 if (((hp100_inb(MAC_CFG_1) & 0x0f) != lp->mac1_mode) ||
2130 (hp100_inb(MAC_CFG_2) != lp->mac2_mode)) {
2131 int i;
2132
2133 hp100_outb(lp->mac2_mode, MAC_CFG_2);
2134 hp100_andb(HP100_MAC1MODEMASK, MAC_CFG_1); /* clear mac1 mode bits */
2135 hp100_orb(lp->mac1_mode, MAC_CFG_1); /* and set the new mode */
2136
2137 hp100_page(MAC_ADDRESS);
2138 for (i = 0; i < 8; i++)
2139 hp100_outb(lp->hash_bytes[i], HASH_BYTE0 + i);
2140#ifdef HP100_DEBUG
2141 printk("hp100: %s: mac1 = 0x%x, mac2 = 0x%x, multicast hash = %02x:%02x:%02x:%02x:%02x:%02x:%02x:%02x\n",
2142 dev->name, lp->mac1_mode, lp->mac2_mode,
2143 lp->hash_bytes[0], lp->hash_bytes[1],
2144 lp->hash_bytes[2], lp->hash_bytes[3],
2145 lp->hash_bytes[4], lp->hash_bytes[5],
2146 lp->hash_bytes[6], lp->hash_bytes[7]);
2147#endif
2148
2149 if (lp->lan_type == HP100_LAN_100) {
2150#ifdef HP100_DEBUG
2151 printk("hp100: %s: 100VG MAC settings have changed - relogin.\n", dev->name);
2152#endif
2153 lp->hub_status = hp100_login_to_vg_hub(dev, 1); /* force a relogin to the hub */
2154 }
2155 } else {
2156 int i;
2157 u_char old_hash_bytes[8];
2158
2159 hp100_page(MAC_ADDRESS);
2160 for (i = 0; i < 8; i++)
2161 old_hash_bytes[i] = hp100_inb(HASH_BYTE0 + i);
2162 if (memcmp(old_hash_bytes, &lp->hash_bytes, 8)) {
2163 for (i = 0; i < 8; i++)
2164 hp100_outb(lp->hash_bytes[i], HASH_BYTE0 + i);
2165#ifdef HP100_DEBUG
2166 printk("hp100: %s: multicast hash = %02x:%02x:%02x:%02x:%02x:%02x:%02x:%02x\n",
2167 dev->name, lp->hash_bytes[0],
2168 lp->hash_bytes[1], lp->hash_bytes[2],
2169 lp->hash_bytes[3], lp->hash_bytes[4],
2170 lp->hash_bytes[5], lp->hash_bytes[6],
2171 lp->hash_bytes[7]);
2172#endif
2173
2174 if (lp->lan_type == HP100_LAN_100) {
2175#ifdef HP100_DEBUG
2176 printk("hp100: %s: 100VG MAC settings have changed - relogin.\n", dev->name);
2177#endif
2178 lp->hub_status = hp100_login_to_vg_hub(dev, 1); /* force a relogin to the hub */
2179 }
2180 }
2181 }
2182
2183 hp100_page(MAC_CTRL);
2184 hp100_orb(HP100_RX_EN | HP100_RX_IDLE | /* enable rx */
2185 HP100_TX_EN | HP100_TX_IDLE, MAC_CFG_1); /* enable tx */
2186
2187 hp100_page(PERFORMANCE);
2188 hp100_ints_on();
2189 spin_unlock_irqrestore(&lp->lock, flags);
2190}
2191
2192/*
2193 * hardware interrupt handling
2194 */
2195
2196static irqreturn_t hp100_interrupt(int irq, void *dev_id)
2197{
2198 struct net_device *dev = (struct net_device *) dev_id;
2199 struct hp100_private *lp = netdev_priv(dev);
2200
2201 int ioaddr;
2202 u_int val;
2203
2204 if (dev == NULL)
2205 return IRQ_NONE;
2206 ioaddr = dev->base_addr;
2207
2208 spin_lock(&lp->lock);
2209
2210 hp100_ints_off();
2211
2212#ifdef HP100_DEBUG_B
2213 hp100_outw(0x4219, TRACE);
2214#endif
2215
2216 /* hp100_page( PERFORMANCE ); */
2217 val = hp100_inw(IRQ_STATUS);
2218#ifdef HP100_DEBUG_IRQ
2219 printk("hp100: %s: mode=%x,IRQ_STAT=0x%.4x,RXPKTCNT=0x%.2x RXPDL=0x%.2x TXPKTCNT=0x%.2x TXPDL=0x%.2x\n",
2220 dev->name, lp->mode, (u_int) val, hp100_inb(RX_PKT_CNT),
2221 hp100_inb(RX_PDL), hp100_inb(TX_PKT_CNT), hp100_inb(TX_PDL));
2222#endif
2223
2224 if (val == 0) { /* might be a shared interrupt */
2225 spin_unlock(&lp->lock);
2226 hp100_ints_on();
2227 return IRQ_NONE;
2228 }
2229 /* We're only interested in those interrupts we really enabled. */
2230 /* val &= hp100_inw( IRQ_MASK ); */
2231
2232 /*
2233 * RX_PDL_FILL_COMPL is set whenever a RX_PDL has been executed. A RX_PDL
2234 * is considered executed whenever the RX_PDL data structure is no longer
2235 * needed.
2236 */
2237 if (val & HP100_RX_PDL_FILL_COMPL) {
2238 if (lp->mode == 1)
2239 hp100_rx_bm(dev);
2240 else {
2241 printk("hp100: %s: rx_pdl_fill_compl interrupt although not busmaster?\n", dev->name);
2242 }
2243 }
2244
2245 /*
2246 * The RX_PACKET interrupt is set, when the receive packet counter is
2247 * non zero. We use this interrupt for receiving in slave mode. In
2248 * busmaster mode, we use it to make sure we did not miss any rx_pdl_fill
2249 * interrupts. If rx_pdl_fill_compl is not set and rx_packet is set, then
2250 * we somehow have missed a rx_pdl_fill_compl interrupt.
2251 */
2252
2253 if (val & HP100_RX_PACKET) { /* Receive Packet Counter is non zero */
2254 if (lp->mode != 1) /* non busmaster */
2255 hp100_rx(dev);
2256 else if (!(val & HP100_RX_PDL_FILL_COMPL)) {
2257 /* Shouldn't happen - maybe we missed a RX_PDL_FILL Interrupt? */
2258 hp100_rx_bm(dev);
2259 }
2260 }
2261
2262 /*
2263 * Ack. that we have noticed the interrupt and thereby allow next one.
2264 * Note that this is now done after the slave rx function, since first
2265 * acknowledging and then setting ADV_NXT_PKT caused an extra interrupt
2266 * on the J2573.
2267 */
2268 hp100_outw(val, IRQ_STATUS);
2269
2270 /*
2271 * RX_ERROR is set when a packet is dropped due to no memory resources on
2272 * the card or when a RCV_ERR occurs.
2273 * TX_ERROR is set when a TX_ABORT condition occurs in the MAC->exists
2274 * only in the 802.3 MAC and happens when 16 collisions occur during a TX
2275 */
2276 if (val & (HP100_TX_ERROR | HP100_RX_ERROR)) {
2277#ifdef HP100_DEBUG_IRQ
2278 printk("hp100: %s: TX/RX Error IRQ\n", dev->name);
2279#endif
2280 hp100_update_stats(dev);
2281 if (lp->mode == 1) {
2282 hp100_rxfill(dev);
2283 hp100_clean_txring(dev);
2284 }
2285 }
2286
2287 /*
2288 * RX_PDA_ZERO is set when the PDA count goes from non-zero to zero.
2289 */
2290 if ((lp->mode == 1) && (val & (HP100_RX_PDA_ZERO)))
2291 hp100_rxfill(dev);
2292
2293 /*
2294 * HP100_TX_COMPLETE interrupt occurs when packet transmitted on wire
2295 * is completed
2296 */
2297 if ((lp->mode == 1) && (val & (HP100_TX_COMPLETE)))
2298 hp100_clean_txring(dev);
2299
2300 /*
2301 * MISC_ERROR is set when either the LAN link goes down or a detected
2302 * bus error occurs.
2303 */
2304 if (val & HP100_MISC_ERROR) { /* New for J2585B */
2305#ifdef HP100_DEBUG_IRQ
2306 printk
2307 ("hp100: %s: Misc. Error Interrupt - Check cabling.\n",
2308 dev->name);
2309#endif
2310 if (lp->mode == 1) {
2311 hp100_clean_txring(dev);
2312 hp100_rxfill(dev);
2313 }
2314 hp100_misc_interrupt(dev);
2315 }
2316
2317 spin_unlock(&lp->lock);
2318 hp100_ints_on();
2319 return IRQ_HANDLED;
2320}
2321
2322/*
2323 * some misc functions
2324 */
2325
2326static void hp100_start_interface(struct net_device *dev)
2327{
2328 unsigned long flags;
2329 int ioaddr = dev->base_addr;
2330 struct hp100_private *lp = netdev_priv(dev);
2331
2332#ifdef HP100_DEBUG_B
2333 hp100_outw(0x4220, TRACE);
2334 printk("hp100: %s: hp100_start_interface\n", dev->name);
2335#endif
2336
2337 spin_lock_irqsave(&lp->lock, flags);
2338
2339 /* Ensure the adapter does not want to request an interrupt when */
2340 /* enabling the IRQ line to be active on the bus (i.e. not tri-stated) */
2341 hp100_page(PERFORMANCE);
2342 hp100_outw(0xfefe, IRQ_MASK); /* mask off all ints */
2343 hp100_outw(0xffff, IRQ_STATUS); /* ack all IRQs */
2344 hp100_outw(HP100_FAKE_INT | HP100_INT_EN | HP100_RESET_LB,
2345 OPTION_LSW);
2346 /* Un Tri-state int. TODO: Check if shared interrupts can be realised? */
2347 hp100_outw(HP100_TRI_INT | HP100_RESET_HB, OPTION_LSW);
2348
2349 if (lp->mode == 1) {
2350 /* Make sure BM bit is set... */
2351 hp100_page(HW_MAP);
2352 hp100_orb(HP100_BM_MASTER, BM);
2353 hp100_rxfill(dev);
2354 } else if (lp->mode == 2) {
2355 /* Enable memory mapping. Note: Don't do this when busmaster. */
2356 hp100_outw(HP100_MMAP_DIS | HP100_RESET_HB, OPTION_LSW);
2357 }
2358
2359 hp100_page(PERFORMANCE);
2360 hp100_outw(0xfefe, IRQ_MASK); /* mask off all ints */
2361 hp100_outw(0xffff, IRQ_STATUS); /* ack IRQ */
2362
2363 /* enable a few interrupts: */
2364 if (lp->mode == 1) { /* busmaster mode */
2365 hp100_outw(HP100_RX_PDL_FILL_COMPL |
2366 HP100_RX_PDA_ZERO | HP100_RX_ERROR |
2367 /* HP100_RX_PACKET | */
2368 /* HP100_RX_EARLY_INT | */ HP100_SET_HB |
2369 /* HP100_TX_PDA_ZERO | */
2370 HP100_TX_COMPLETE |
2371 /* HP100_MISC_ERROR | */
2372 HP100_TX_ERROR | HP100_SET_LB, IRQ_MASK);
2373 } else {
2374 hp100_outw(HP100_RX_PACKET |
2375 HP100_RX_ERROR | HP100_SET_HB |
2376 HP100_TX_ERROR | HP100_SET_LB, IRQ_MASK);
2377 }
2378
2379 /* Note : before hp100_set_multicast_list(), because it will play with
2380 * spinlock itself... Jean II */
2381 spin_unlock_irqrestore(&lp->lock, flags);
2382
2383 /* Enable MAC Tx and RX, set MAC modes, ... */
2384 hp100_set_multicast_list(dev);
2385}
2386
2387static void hp100_stop_interface(struct net_device *dev)
2388{
2389 struct hp100_private *lp = netdev_priv(dev);
2390 int ioaddr = dev->base_addr;
2391 u_int val;
2392
2393#ifdef HP100_DEBUG_B
2394 printk("hp100: %s: hp100_stop_interface\n", dev->name);
2395 hp100_outw(0x4221, TRACE);
2396#endif
2397
2398 if (lp->mode == 1)
2399 hp100_BM_shutdown(dev);
2400 else {
2401 /* Note: MMAP_DIS will be reenabled by start_interface */
2402 hp100_outw(HP100_INT_EN | HP100_RESET_LB |
2403 HP100_TRI_INT | HP100_MMAP_DIS | HP100_SET_HB,
2404 OPTION_LSW);
2405 val = hp100_inw(OPTION_LSW);
2406
2407 hp100_page(MAC_CTRL);
2408 hp100_andb(~(HP100_RX_EN | HP100_TX_EN), MAC_CFG_1);
2409
2410 if (!(val & HP100_HW_RST))
2411 return; /* If reset, imm. return ... */
2412 /* ... else: busy wait until idle */
2413 for (val = 0; val < 6000; val++)
2414 if ((hp100_inb(MAC_CFG_1) & (HP100_TX_IDLE | HP100_RX_IDLE)) == (HP100_TX_IDLE | HP100_RX_IDLE)) {
2415 hp100_page(PERFORMANCE);
2416 return;
2417 }
2418 printk("hp100: %s: hp100_stop_interface - timeout\n", dev->name);
2419 hp100_page(PERFORMANCE);
2420 }
2421}
2422
2423static void hp100_load_eeprom(struct net_device *dev, u_short probe_ioaddr)
2424{
2425 int i;
2426 int ioaddr = probe_ioaddr > 0 ? probe_ioaddr : dev->base_addr;
2427
2428#ifdef HP100_DEBUG_B
2429 hp100_outw(0x4222, TRACE);
2430#endif
2431
2432 hp100_page(EEPROM_CTRL);
2433 hp100_andw(~HP100_EEPROM_LOAD, EEPROM_CTRL);
2434 hp100_orw(HP100_EEPROM_LOAD, EEPROM_CTRL);
2435 for (i = 0; i < 10000; i++)
2436 if (!(hp100_inb(OPTION_MSW) & HP100_EE_LOAD))
2437 return;
2438 printk("hp100: %s: hp100_load_eeprom - timeout\n", dev->name);
2439}
2440
2441/* Sense connection status.
2442 * return values: LAN_10 - Connected to 10Mbit/s network
2443 * LAN_100 - Connected to 100Mbit/s network
2444 * LAN_ERR - not connected or 100Mbit/s Hub down
2445 */
2446static int hp100_sense_lan(struct net_device *dev)
2447{
2448 int ioaddr = dev->base_addr;
2449 u_short val_VG, val_10;
2450 struct hp100_private *lp = netdev_priv(dev);
2451
2452#ifdef HP100_DEBUG_B
2453 hp100_outw(0x4223, TRACE);
2454#endif
2455
2456 hp100_page(MAC_CTRL);
2457 val_10 = hp100_inb(10_LAN_CFG_1);
2458 val_VG = hp100_inb(VG_LAN_CFG_1);
2459 hp100_page(PERFORMANCE);
2460#ifdef HP100_DEBUG
2461 printk("hp100: %s: sense_lan: val_VG = 0x%04x, val_10 = 0x%04x\n",
2462 dev->name, val_VG, val_10);
2463#endif
2464
2465 if (val_10 & HP100_LINK_BEAT_ST) /* 10Mb connection is active */
2466 return HP100_LAN_10;
2467
2468 if (val_10 & HP100_AUI_ST) { /* have we BNC or AUI onboard? */
2469 /*
2470 * This can be overriden by dos utility, so if this has no effect,
2471 * perhaps you need to download that utility from HP and set card
2472 * back to "auto detect".
2473 */
2474 val_10 |= HP100_AUI_SEL | HP100_LOW_TH;
2475 hp100_page(MAC_CTRL);
2476 hp100_outb(val_10, 10_LAN_CFG_1);
2477 hp100_page(PERFORMANCE);
2478 return HP100_LAN_COAX;
2479 }
2480
2481 /* Those cards don't have a 100 Mbit connector */
2482 if ( !strcmp(lp->id, "HWP1920") ||
2483 (lp->pci_dev &&
2484 lp->pci_dev->vendor == PCI_VENDOR_ID &&
2485 (lp->pci_dev->device == PCI_DEVICE_ID_HP_J2970A ||
2486 lp->pci_dev->device == PCI_DEVICE_ID_HP_J2973A)))
2487 return HP100_LAN_ERR;
2488
2489 if (val_VG & HP100_LINK_CABLE_ST) /* Can hear the HUBs tone. */
2490 return HP100_LAN_100;
2491 return HP100_LAN_ERR;
2492}
2493
2494static int hp100_down_vg_link(struct net_device *dev)
2495{
2496 struct hp100_private *lp = netdev_priv(dev);
2497 int ioaddr = dev->base_addr;
2498 unsigned long time;
2499 long savelan, newlan;
2500
2501#ifdef HP100_DEBUG_B
2502 hp100_outw(0x4224, TRACE);
2503 printk("hp100: %s: down_vg_link\n", dev->name);
2504#endif
2505
2506 hp100_page(MAC_CTRL);
2507 time = jiffies + (HZ / 4);
2508 do {
2509 if (hp100_inb(VG_LAN_CFG_1) & HP100_LINK_CABLE_ST)
2510 break;
2511 if (!in_interrupt())
2512 schedule_timeout_interruptible(1);
2513 } while (time_after(time, jiffies));
2514
2515 if (time_after_eq(jiffies, time)) /* no signal->no logout */
2516 return 0;
2517
2518 /* Drop the VG Link by clearing the link up cmd and load addr. */
2519
2520 hp100_andb(~(HP100_LOAD_ADDR | HP100_LINK_CMD), VG_LAN_CFG_1);
2521 hp100_orb(HP100_VG_SEL, VG_LAN_CFG_1);
2522
2523 /* Conditionally stall for >250ms on Link-Up Status (to go down) */
2524 time = jiffies + (HZ / 2);
2525 do {
2526 if (!(hp100_inb(VG_LAN_CFG_1) & HP100_LINK_UP_ST))
2527 break;
2528 if (!in_interrupt())
2529 schedule_timeout_interruptible(1);
2530 } while (time_after(time, jiffies));
2531
2532#ifdef HP100_DEBUG
2533 if (time_after_eq(jiffies, time))
2534 printk("hp100: %s: down_vg_link: Link does not go down?\n", dev->name);
2535#endif
2536
2537 /* To prevent condition where Rev 1 VG MAC and old hubs do not complete */
2538 /* logout under traffic (even though all the status bits are cleared), */
2539 /* do this workaround to get the Rev 1 MAC in its idle state */
2540 if (lp->chip == HP100_CHIPID_LASSEN) {
2541 /* Reset VG MAC to insure it leaves the logoff state even if */
2542 /* the Hub is still emitting tones */
2543 hp100_andb(~HP100_VG_RESET, VG_LAN_CFG_1);
2544 udelay(1500); /* wait for >1ms */
2545 hp100_orb(HP100_VG_RESET, VG_LAN_CFG_1); /* Release Reset */
2546 udelay(1500);
2547 }
2548
2549 /* New: For lassen, switch to 10 Mbps mac briefly to clear training ACK */
2550 /* to get the VG mac to full reset. This is not req.d with later chips */
2551 /* Note: It will take the between 1 and 2 seconds for the VG mac to be */
2552 /* selected again! This will be left to the connect hub function to */
2553 /* perform if desired. */
2554 if (lp->chip == HP100_CHIPID_LASSEN) {
2555 /* Have to write to 10 and 100VG control registers simultaneously */
2556 savelan = newlan = hp100_inl(10_LAN_CFG_1); /* read 10+100 LAN_CFG regs */
2557 newlan &= ~(HP100_VG_SEL << 16);
2558 newlan |= (HP100_DOT3_MAC) << 8;
2559 hp100_andb(~HP100_AUTO_MODE, MAC_CFG_3); /* Autosel off */
2560 hp100_outl(newlan, 10_LAN_CFG_1);
2561
2562 /* Conditionally stall for 5sec on VG selected. */
2563 time = jiffies + (HZ * 5);
2564 do {
2565 if (!(hp100_inb(MAC_CFG_4) & HP100_MAC_SEL_ST))
2566 break;
2567 if (!in_interrupt())
2568 schedule_timeout_interruptible(1);
2569 } while (time_after(time, jiffies));
2570
2571 hp100_orb(HP100_AUTO_MODE, MAC_CFG_3); /* Autosel back on */
2572 hp100_outl(savelan, 10_LAN_CFG_1);
2573 }
2574
2575 time = jiffies + (3 * HZ); /* Timeout 3s */
2576 do {
2577 if ((hp100_inb(VG_LAN_CFG_1) & HP100_LINK_CABLE_ST) == 0)
2578 break;
2579 if (!in_interrupt())
2580 schedule_timeout_interruptible(1);
2581 } while (time_after(time, jiffies));
2582
2583 if (time_before_eq(time, jiffies)) {
2584#ifdef HP100_DEBUG
2585 printk("hp100: %s: down_vg_link: timeout\n", dev->name);
2586#endif
2587 return -EIO;
2588 }
2589
2590 time = jiffies + (2 * HZ); /* This seems to take a while.... */
2591 do {
2592 if (!in_interrupt())
2593 schedule_timeout_interruptible(1);
2594 } while (time_after(time, jiffies));
2595
2596 return 0;
2597}
2598
2599static int hp100_login_to_vg_hub(struct net_device *dev, u_short force_relogin)
2600{
2601 int ioaddr = dev->base_addr;
2602 struct hp100_private *lp = netdev_priv(dev);
2603 u_short val = 0;
2604 unsigned long time;
2605 int startst;
2606
2607#ifdef HP100_DEBUG_B
2608 hp100_outw(0x4225, TRACE);
2609 printk("hp100: %s: login_to_vg_hub\n", dev->name);
2610#endif
2611
2612 /* Initiate a login sequence iff VG MAC is enabled and either Load Address
2613 * bit is zero or the force relogin flag is set (e.g. due to MAC address or
2614 * promiscuous mode change)
2615 */
2616 hp100_page(MAC_CTRL);
2617 startst = hp100_inb(VG_LAN_CFG_1);
2618 if ((force_relogin == 1) || (hp100_inb(MAC_CFG_4) & HP100_MAC_SEL_ST)) {
2619#ifdef HP100_DEBUG_TRAINING
2620 printk("hp100: %s: Start training\n", dev->name);
2621#endif
2622
2623 /* Ensure VG Reset bit is 1 (i.e., do not reset) */
2624 hp100_orb(HP100_VG_RESET, VG_LAN_CFG_1);
2625
2626 /* If Lassen AND auto-select-mode AND VG tones were sensed on */
2627 /* entry then temporarily put them into force 100Mbit mode */
2628 if ((lp->chip == HP100_CHIPID_LASSEN) && (startst & HP100_LINK_CABLE_ST))
2629 hp100_andb(~HP100_DOT3_MAC, 10_LAN_CFG_2);
2630
2631 /* Drop the VG link by zeroing Link Up Command and Load Address */
2632 hp100_andb(~(HP100_LINK_CMD /* |HP100_LOAD_ADDR */ ), VG_LAN_CFG_1);
2633
2634#ifdef HP100_DEBUG_TRAINING
2635 printk("hp100: %s: Bring down the link\n", dev->name);
2636#endif
2637
2638 /* Wait for link to drop */
2639 time = jiffies + (HZ / 10);
2640 do {
2641 if (~(hp100_inb(VG_LAN_CFG_1) & HP100_LINK_UP_ST))
2642 break;
2643 if (!in_interrupt())
2644 schedule_timeout_interruptible(1);
2645 } while (time_after(time, jiffies));
2646
2647 /* Start an addressed training and optionally request promiscuous port */
2648 if ((dev->flags) & IFF_PROMISC) {
2649 hp100_orb(HP100_PROM_MODE, VG_LAN_CFG_2);
2650 if (lp->chip == HP100_CHIPID_LASSEN)
2651 hp100_orw(HP100_MACRQ_PROMSC, TRAIN_REQUEST);
2652 } else {
2653 hp100_andb(~HP100_PROM_MODE, VG_LAN_CFG_2);
2654 /* For ETR parts we need to reset the prom. bit in the training
2655 * register, otherwise promiscious mode won't be disabled.
2656 */
2657 if (lp->chip == HP100_CHIPID_LASSEN) {
2658 hp100_andw(~HP100_MACRQ_PROMSC, TRAIN_REQUEST);
2659 }
2660 }
2661
2662 /* With ETR parts, frame format request bits can be set. */
2663 if (lp->chip == HP100_CHIPID_LASSEN)
2664 hp100_orb(HP100_MACRQ_FRAMEFMT_EITHER, TRAIN_REQUEST);
2665
2666 hp100_orb(HP100_LINK_CMD | HP100_LOAD_ADDR | HP100_VG_RESET, VG_LAN_CFG_1);
2667
2668 /* Note: Next wait could be omitted for Hood and earlier chips under */
2669 /* certain circumstances */
2670 /* TODO: check if hood/earlier and skip wait. */
2671
2672 /* Wait for either short timeout for VG tones or long for login */
2673 /* Wait for the card hardware to signalise link cable status ok... */
2674 hp100_page(MAC_CTRL);
2675 time = jiffies + (1 * HZ); /* 1 sec timeout for cable st */
2676 do {
2677 if (hp100_inb(VG_LAN_CFG_1) & HP100_LINK_CABLE_ST)
2678 break;
2679 if (!in_interrupt())
2680 schedule_timeout_interruptible(1);
2681 } while (time_before(jiffies, time));
2682
2683 if (time_after_eq(jiffies, time)) {
2684#ifdef HP100_DEBUG_TRAINING
2685 printk("hp100: %s: Link cable status not ok? Training aborted.\n", dev->name);
2686#endif
2687 } else {
2688#ifdef HP100_DEBUG_TRAINING
2689 printk
2690 ("hp100: %s: HUB tones detected. Trying to train.\n",
2691 dev->name);
2692#endif
2693
2694 time = jiffies + (2 * HZ); /* again a timeout */
2695 do {
2696 val = hp100_inb(VG_LAN_CFG_1);
2697 if ((val & (HP100_LINK_UP_ST))) {
2698#ifdef HP100_DEBUG_TRAINING
2699 printk("hp100: %s: Passed training.\n", dev->name);
2700#endif
2701 break;
2702 }
2703 if (!in_interrupt())
2704 schedule_timeout_interruptible(1);
2705 } while (time_after(time, jiffies));
2706 }
2707
2708 /* If LINK_UP_ST is set, then we are logged into the hub. */
2709 if (time_before_eq(jiffies, time) && (val & HP100_LINK_UP_ST)) {
2710#ifdef HP100_DEBUG_TRAINING
2711 printk("hp100: %s: Successfully logged into the HUB.\n", dev->name);
2712 if (lp->chip == HP100_CHIPID_LASSEN) {
2713 val = hp100_inw(TRAIN_ALLOW);
2714 printk("hp100: %s: Card supports 100VG MAC Version \"%s\" ",
2715 dev->name, (hp100_inw(TRAIN_REQUEST) & HP100_CARD_MACVER) ? "802.12" : "Pre");
2716 printk("Driver will use MAC Version \"%s\"\n", (val & HP100_HUB_MACVER) ? "802.12" : "Pre");
2717 printk("hp100: %s: Frame format is %s.\n", dev->name, (val & HP100_MALLOW_FRAMEFMT) ? "802.5" : "802.3");
2718 }
2719#endif
2720 } else {
2721 /* If LINK_UP_ST is not set, login was not successful */
2722 printk("hp100: %s: Problem logging into the HUB.\n", dev->name);
2723 if (lp->chip == HP100_CHIPID_LASSEN) {
2724 /* Check allowed Register to find out why there is a problem. */
2725 val = hp100_inw(TRAIN_ALLOW); /* won't work on non-ETR card */
2726#ifdef HP100_DEBUG_TRAINING
2727 printk("hp100: %s: MAC Configuration requested: 0x%04x, HUB allowed: 0x%04x\n", dev->name, hp100_inw(TRAIN_REQUEST), val);
2728#endif
2729 if (val & HP100_MALLOW_ACCDENIED)
2730 printk("hp100: %s: HUB access denied.\n", dev->name);
2731 if (val & HP100_MALLOW_CONFIGURE)
2732 printk("hp100: %s: MAC Configuration is incompatible with the Network.\n", dev->name);
2733 if (val & HP100_MALLOW_DUPADDR)
2734 printk("hp100: %s: Duplicate MAC Address on the Network.\n", dev->name);
2735 }
2736 }
2737
2738 /* If we have put the chip into forced 100 Mbit mode earlier, go back */
2739 /* to auto-select mode */
2740
2741 if ((lp->chip == HP100_CHIPID_LASSEN) && (startst & HP100_LINK_CABLE_ST)) {
2742 hp100_page(MAC_CTRL);
2743 hp100_orb(HP100_DOT3_MAC, 10_LAN_CFG_2);
2744 }
2745
2746 val = hp100_inb(VG_LAN_CFG_1);
2747
2748 /* Clear the MISC_ERROR Interrupt, which might be generated when doing the relogin */
2749 hp100_page(PERFORMANCE);
2750 hp100_outw(HP100_MISC_ERROR, IRQ_STATUS);
2751
2752 if (val & HP100_LINK_UP_ST)
2753 return 0; /* login was ok */
2754 else {
2755 printk("hp100: %s: Training failed.\n", dev->name);
2756 hp100_down_vg_link(dev);
2757 return -EIO;
2758 }
2759 }
2760 /* no forced relogin & already link there->no training. */
2761 return -EIO;
2762}
2763
2764static void hp100_cascade_reset(struct net_device *dev, u_short enable)
2765{
2766 int ioaddr = dev->base_addr;
2767 struct hp100_private *lp = netdev_priv(dev);
2768
2769#ifdef HP100_DEBUG_B
2770 hp100_outw(0x4226, TRACE);
2771 printk("hp100: %s: cascade_reset\n", dev->name);
2772#endif
2773
2774 if (enable) {
2775 hp100_outw(HP100_HW_RST | HP100_RESET_LB, OPTION_LSW);
2776 if (lp->chip == HP100_CHIPID_LASSEN) {
2777 /* Lassen requires a PCI transmit fifo reset */
2778 hp100_page(HW_MAP);
2779 hp100_andb(~HP100_PCI_RESET, PCICTRL2);
2780 hp100_orb(HP100_PCI_RESET, PCICTRL2);
2781 /* Wait for min. 300 ns */
2782 /* we can't use jiffies here, because it may be */
2783 /* that we have disabled the timer... */
2784 udelay(400);
2785 hp100_andb(~HP100_PCI_RESET, PCICTRL2);
2786 hp100_page(PERFORMANCE);
2787 }
2788 } else { /* bring out of reset */
2789 hp100_outw(HP100_HW_RST | HP100_SET_LB, OPTION_LSW);
2790 udelay(400);
2791 hp100_page(PERFORMANCE);
2792 }
2793}
2794
2795#ifdef HP100_DEBUG
2796void hp100_RegisterDump(struct net_device *dev)
2797{
2798 int ioaddr = dev->base_addr;
2799 int Page;
2800 int Register;
2801
2802 /* Dump common registers */
2803 printk("hp100: %s: Cascade Register Dump\n", dev->name);
2804 printk("hardware id #1: 0x%.2x\n", hp100_inb(HW_ID));
2805 printk("hardware id #2/paging: 0x%.2x\n", hp100_inb(PAGING));
2806 printk("option #1: 0x%.4x\n", hp100_inw(OPTION_LSW));
2807 printk("option #2: 0x%.4x\n", hp100_inw(OPTION_MSW));
2808
2809 /* Dump paged registers */
2810 for (Page = 0; Page < 8; Page++) {
2811 /* Dump registers */
2812 printk("page: 0x%.2x\n", Page);
2813 outw(Page, ioaddr + 0x02);
2814 for (Register = 0x8; Register < 0x22; Register += 2) {
2815 /* Display Register contents except data port */
2816 if (((Register != 0x10) && (Register != 0x12)) || (Page > 0)) {
2817 printk("0x%.2x = 0x%.4x\n", Register, inw(ioaddr + Register));
2818 }
2819 }
2820 }
2821 hp100_page(PERFORMANCE);
2822}
2823#endif
2824
2825
2826static void cleanup_dev(struct net_device *d)
2827{
2828 struct hp100_private *p = netdev_priv(d);
2829
2830 unregister_netdev(d);
2831 release_region(d->base_addr, HP100_REGION_SIZE);
2832
2833 if (p->mode == 1) /* busmaster */
2834 pci_free_consistent(p->pci_dev, MAX_RINGSIZE + 0x0f,
2835 p->page_vaddr_algn,
2836 virt_to_whatever(d, p->page_vaddr_algn));
2837 if (p->mem_ptr_virt)
2838 iounmap(p->mem_ptr_virt);
2839
2840 free_netdev(d);
2841}
2842
2843#ifdef CONFIG_EISA
2844static int __init hp100_eisa_probe (struct device *gendev)
2845{
2846 struct net_device *dev = alloc_etherdev(sizeof(struct hp100_private));
2847 struct eisa_device *edev = to_eisa_device(gendev);
2848 int err;
2849
2850 if (!dev)
2851 return -ENOMEM;
2852
2853 SET_NETDEV_DEV(dev, &edev->dev);
2854
2855 err = hp100_probe1(dev, edev->base_addr + 0xC38, HP100_BUS_EISA, NULL);
2856 if (err)
2857 goto out1;
2858
2859#ifdef HP100_DEBUG
2860 printk("hp100: %s: EISA adapter found at 0x%x\n", dev->name,
2861 dev->base_addr);
2862#endif
2863 dev_set_drvdata(gendev, dev);
2864 return 0;
2865 out1:
2866 free_netdev(dev);
2867 return err;
2868}
2869
2870static int __devexit hp100_eisa_remove (struct device *gendev)
2871{
2872 struct net_device *dev = dev_get_drvdata(gendev);
2873 cleanup_dev(dev);
2874 return 0;
2875}
2876
2877static struct eisa_driver hp100_eisa_driver = {
2878 .id_table = hp100_eisa_tbl,
2879 .driver = {
2880 .name = "hp100",
2881 .probe = hp100_eisa_probe,
2882 .remove = __devexit_p (hp100_eisa_remove),
2883 }
2884};
2885#endif
2886
2887#ifdef CONFIG_PCI
2888static int __devinit hp100_pci_probe (struct pci_dev *pdev,
2889 const struct pci_device_id *ent)
2890{
2891 struct net_device *dev;
2892 int ioaddr;
2893 u_short pci_command;
2894 int err;
2895
2896 if (pci_enable_device(pdev))
2897 return -ENODEV;
2898
2899 dev = alloc_etherdev(sizeof(struct hp100_private));
2900 if (!dev) {
2901 err = -ENOMEM;
2902 goto out0;
2903 }
2904
2905 SET_NETDEV_DEV(dev, &pdev->dev);
2906
2907 pci_read_config_word(pdev, PCI_COMMAND, &pci_command);
2908 if (!(pci_command & PCI_COMMAND_IO)) {
2909#ifdef HP100_DEBUG
2910 printk("hp100: %s: PCI I/O Bit has not been set. Setting...\n", dev->name);
2911#endif
2912 pci_command |= PCI_COMMAND_IO;
2913 pci_write_config_word(pdev, PCI_COMMAND, pci_command);
2914 }
2915
2916 if (!(pci_command & PCI_COMMAND_MASTER)) {
2917#ifdef HP100_DEBUG
2918 printk("hp100: %s: PCI Master Bit has not been set. Setting...\n", dev->name);
2919#endif
2920 pci_command |= PCI_COMMAND_MASTER;
2921 pci_write_config_word(pdev, PCI_COMMAND, pci_command);
2922 }
2923
2924 ioaddr = pci_resource_start(pdev, 0);
2925 err = hp100_probe1(dev, ioaddr, HP100_BUS_PCI, pdev);
2926 if (err)
2927 goto out1;
2928
2929#ifdef HP100_DEBUG
2930 printk("hp100: %s: PCI adapter found at 0x%x\n", dev->name, ioaddr);
2931#endif
2932 pci_set_drvdata(pdev, dev);
2933 return 0;
2934 out1:
2935 free_netdev(dev);
2936 out0:
2937 pci_disable_device(pdev);
2938 return err;
2939}
2940
2941static void __devexit hp100_pci_remove (struct pci_dev *pdev)
2942{
2943 struct net_device *dev = pci_get_drvdata(pdev);
2944
2945 cleanup_dev(dev);
2946 pci_disable_device(pdev);
2947}
2948
2949
2950static struct pci_driver hp100_pci_driver = {
2951 .name = "hp100",
2952 .id_table = hp100_pci_tbl,
2953 .probe = hp100_pci_probe,
2954 .remove = __devexit_p(hp100_pci_remove),
2955};
2956#endif
2957
2958/*
2959 * module section
2960 */
2961
2962MODULE_LICENSE("GPL");
2963MODULE_AUTHOR("Jaroslav Kysela <perex@perex.cz>, "
2964 "Siegfried \"Frieder\" Loeffler (dg1sek) <floeff@mathematik.uni-stuttgart.de>");
2965MODULE_DESCRIPTION("HP CASCADE Architecture Driver for 100VG-AnyLan Network Adapters");
2966
2967/*
2968 * Note: to register three isa devices, use:
2969 * option hp100 hp100_port=0,0,0
2970 * to register one card at io 0x280 as eth239, use:
2971 * option hp100 hp100_port=0x280
2972 */
2973#if defined(MODULE) && defined(CONFIG_ISA)
2974#define HP100_DEVICES 5
2975/* Parameters set by insmod */
2976static int hp100_port[HP100_DEVICES] = { 0, [1 ... (HP100_DEVICES-1)] = -1 };
2977module_param_array(hp100_port, int, NULL, 0);
2978
2979/* List of devices */
2980static struct net_device *hp100_devlist[HP100_DEVICES];
2981
2982static int __init hp100_isa_init(void)
2983{
2984 struct net_device *dev;
2985 int i, err, cards = 0;
2986
2987 /* Don't autoprobe ISA bus */
2988 if (hp100_port[0] == 0)
2989 return -ENODEV;
2990
2991 /* Loop on all possible base addresses */
2992 for (i = 0; i < HP100_DEVICES && hp100_port[i] != -1; ++i) {
2993 dev = alloc_etherdev(sizeof(struct hp100_private));
2994 if (!dev) {
2995 printk(KERN_WARNING "hp100: no memory for network device\n");
2996 while (cards > 0)
2997 cleanup_dev(hp100_devlist[--cards]);
2998
2999 return -ENOMEM;
3000 }
3001
3002 err = hp100_isa_probe(dev, hp100_port[i]);
3003 if (!err)
3004 hp100_devlist[cards++] = dev;
3005 else
3006 free_netdev(dev);
3007 }
3008
3009 return cards > 0 ? 0 : -ENODEV;
3010}
3011
3012static void hp100_isa_cleanup(void)
3013{
3014 int i;
3015
3016 for (i = 0; i < HP100_DEVICES; i++) {
3017 struct net_device *dev = hp100_devlist[i];
3018 if (dev)
3019 cleanup_dev(dev);
3020 }
3021}
3022#else
3023#define hp100_isa_init() (0)
3024#define hp100_isa_cleanup() do { } while(0)
3025#endif
3026
3027static int __init hp100_module_init(void)
3028{
3029 int err;
3030
3031 err = hp100_isa_init();
3032 if (err && err != -ENODEV)
3033 goto out;
3034#ifdef CONFIG_EISA
3035 err = eisa_driver_register(&hp100_eisa_driver);
3036 if (err && err != -ENODEV)
3037 goto out2;
3038#endif
3039#ifdef CONFIG_PCI
3040 err = pci_register_driver(&hp100_pci_driver);
3041 if (err && err != -ENODEV)
3042 goto out3;
3043#endif
3044 out:
3045 return err;
3046 out3:
3047#ifdef CONFIG_EISA
3048 eisa_driver_unregister (&hp100_eisa_driver);
3049 out2:
3050#endif
3051 hp100_isa_cleanup();
3052 goto out;
3053}
3054
3055
3056static void __exit hp100_module_exit(void)
3057{
3058 hp100_isa_cleanup();
3059#ifdef CONFIG_EISA
3060 eisa_driver_unregister (&hp100_eisa_driver);
3061#endif
3062#ifdef CONFIG_PCI
3063 pci_unregister_driver (&hp100_pci_driver);
3064#endif
3065}
3066
3067module_init(hp100_module_init)
3068module_exit(hp100_module_exit)
diff --git a/drivers/net/ethernet/hp/hp100.h b/drivers/net/ethernet/hp/hp100.h
new file mode 100644
index 000000000000..b60e96fe38b4
--- /dev/null
+++ b/drivers/net/ethernet/hp/hp100.h
@@ -0,0 +1,615 @@
1/*
2 * hp100.h: Hewlett Packard HP10/100VG ANY LAN ethernet driver for Linux.
3 *
4 * $Id: hp100.h,v 1.51 1997/04/08 14:26:42 floeff Exp floeff $
5 *
6 * Authors: Jaroslav Kysela, <perex@pf.jcu.cz>
7 * Siegfried Loeffler <floeff@tunix.mathematik.uni-stuttgart.de>
8 *
9 * This driver is based on the 'hpfepkt' crynwr packet driver.
10 *
11 * This source/code is public free; you can distribute it and/or modify
12 * it under terms of the GNU General Public License (published by the
13 * Free Software Foundation) either version two of this License, or any
14 * later version.
15 */
16
17/****************************************************************************
18 * Hardware Constants
19 ****************************************************************************/
20
21/*
22 * Page Identifiers
23 * (Swap Paging Register, PAGING, bits 3:0, Offset 0x02)
24 */
25
26#define HP100_PAGE_PERFORMANCE 0x0 /* Page 0 */
27#define HP100_PAGE_MAC_ADDRESS 0x1 /* Page 1 */
28#define HP100_PAGE_HW_MAP 0x2 /* Page 2 */
29#define HP100_PAGE_EEPROM_CTRL 0x3 /* Page 3 */
30#define HP100_PAGE_MAC_CTRL 0x4 /* Page 4 */
31#define HP100_PAGE_MMU_CFG 0x5 /* Page 5 */
32#define HP100_PAGE_ID_MAC_ADDR 0x6 /* Page 6 */
33#define HP100_PAGE_MMU_POINTER 0x7 /* Page 7 */
34
35
36/* Registers that are present on all pages */
37
38#define HP100_REG_HW_ID 0x00 /* R: (16) Unique card ID */
39#define HP100_REG_TRACE 0x00 /* W: (16) Used for debug output */
40#define HP100_REG_PAGING 0x02 /* R: (16),15:4 Card ID */
41 /* W: (16),3:0 Switch pages */
42#define HP100_REG_OPTION_LSW 0x04 /* RW: (16) Select card functions */
43#define HP100_REG_OPTION_MSW 0x06 /* RW: (16) Select card functions */
44
45/* Page 0 - Performance */
46
47#define HP100_REG_IRQ_STATUS 0x08 /* RW: (16) Which ints are pending */
48#define HP100_REG_IRQ_MASK 0x0a /* RW: (16) Select ints to allow */
49#define HP100_REG_FRAGMENT_LEN 0x0c /* W: (16)12:0 Current fragment len */
50/* Note: For 32 bit systems, fragment len and offset registers are available */
51/* at offset 0x28 and 0x2c, where they can be written as 32bit values. */
52#define HP100_REG_OFFSET 0x0e /* RW: (16)12:0 Offset to start read */
53#define HP100_REG_DATA32 0x10 /* RW: (32) I/O mode data port */
54#define HP100_REG_DATA16 0x12 /* RW: WORDs must be read from here */
55#define HP100_REG_TX_MEM_FREE 0x14 /* RD: (32) Amount of free Tx mem */
56#define HP100_REG_TX_PDA_L 0x14 /* W: (32) BM: Ptr to PDL, Low Pri */
57#define HP100_REG_TX_PDA_H 0x1c /* W: (32) BM: Ptr to PDL, High Pri */
58#define HP100_REG_RX_PKT_CNT 0x18 /* RD: (8) Rx count of pkts on card */
59#define HP100_REG_TX_PKT_CNT 0x19 /* RD: (8) Tx count of pkts on card */
60#define HP100_REG_RX_PDL 0x1a /* R: (8) BM: # rx pdl not executed */
61#define HP100_REG_TX_PDL 0x1b /* R: (8) BM: # tx pdl not executed */
62#define HP100_REG_RX_PDA 0x18 /* W: (32) BM: Up to 31 addresses */
63 /* which point to a PDL */
64#define HP100_REG_SL_EARLY 0x1c /* (32) Enhanced Slave Early Rx */
65#define HP100_REG_STAT_DROPPED 0x20 /* R (12) Dropped Packet Counter */
66#define HP100_REG_STAT_ERRORED 0x22 /* R (8) Errored Packet Counter */
67#define HP100_REG_STAT_ABORT 0x23 /* R (8) Abort Counter/OW Coll. Flag */
68#define HP100_REG_RX_RING 0x24 /* W (32) Slave: RX Ring Pointers */
69#define HP100_REG_32_FRAGMENT_LEN 0x28 /* W (13) Slave: Fragment Length Reg */
70#define HP100_REG_32_OFFSET 0x2c /* W (16) Slave: Offset Register */
71
72/* Page 1 - MAC Address/Hash Table */
73
74#define HP100_REG_MAC_ADDR 0x08 /* RW: (8) Cards MAC address */
75#define HP100_REG_HASH_BYTE0 0x10 /* RW: (8) Cards multicast filter */
76
77/* Page 2 - Hardware Mapping */
78
79#define HP100_REG_MEM_MAP_LSW 0x08 /* RW: (16) LSW of cards mem addr */
80#define HP100_REG_MEM_MAP_MSW 0x0a /* RW: (16) MSW of cards mem addr */
81#define HP100_REG_IO_MAP 0x0c /* RW: (8) Cards I/O address */
82#define HP100_REG_IRQ_CHANNEL 0x0d /* RW: (8) IRQ and edge/level int */
83#define HP100_REG_SRAM 0x0e /* RW: (8) How much RAM on card */
84#define HP100_REG_BM 0x0f /* RW: (8) Controls BM functions */
85
86/* New on Page 2 for ETR chips: */
87#define HP100_REG_MODECTRL1 0x10 /* RW: (8) Mode Control 1 */
88#define HP100_REG_MODECTRL2 0x11 /* RW: (8) Mode Control 2 */
89#define HP100_REG_PCICTRL1 0x12 /* RW: (8) PCI Cfg 1 */
90#define HP100_REG_PCICTRL2 0x13 /* RW: (8) PCI Cfg 2 */
91#define HP100_REG_PCIBUSMLAT 0x15 /* RW: (8) PCI Bus Master Latency */
92#define HP100_REG_EARLYTXCFG 0x16 /* RW: (16) Early TX Cfg/Cntrl Reg */
93#define HP100_REG_EARLYRXCFG 0x18 /* RW: (8) Early RX Cfg/Cntrl Reg */
94#define HP100_REG_ISAPNPCFG1 0x1a /* RW: (8) ISA PnP Cfg/Cntrl Reg 1 */
95#define HP100_REG_ISAPNPCFG2 0x1b /* RW: (8) ISA PnP Cfg/Cntrl Reg 2 */
96
97/* Page 3 - EEPROM/Boot ROM */
98
99#define HP100_REG_EEPROM_CTRL 0x08 /* RW: (16) Used to load EEPROM */
100#define HP100_REG_BOOTROM_CTRL 0x0a
101
102/* Page 4 - LAN Configuration (MAC_CTRL) */
103
104#define HP100_REG_10_LAN_CFG_1 0x08 /* RW: (8) Set 10M XCVR functions */
105#define HP100_REG_10_LAN_CFG_2 0x09 /* RW: (8) 10M XCVR functions */
106#define HP100_REG_VG_LAN_CFG_1 0x0a /* RW: (8) Set 100M XCVR functions */
107#define HP100_REG_VG_LAN_CFG_2 0x0b /* RW: (8) 100M LAN Training cfgregs */
108#define HP100_REG_MAC_CFG_1 0x0c /* RW: (8) Types of pkts to accept */
109#define HP100_REG_MAC_CFG_2 0x0d /* RW: (8) Misc MAC functions */
110#define HP100_REG_MAC_CFG_3 0x0e /* RW: (8) Misc MAC functions */
111#define HP100_REG_MAC_CFG_4 0x0f /* R: (8) Misc MAC states */
112#define HP100_REG_DROPPED 0x10 /* R: (16),11:0 Pkts can't fit in mem */
113#define HP100_REG_CRC 0x12 /* R: (8) Pkts with CRC */
114#define HP100_REG_ABORT 0x13 /* R: (8) Aborted Tx pkts */
115#define HP100_REG_TRAIN_REQUEST 0x14 /* RW: (16) Endnode MAC register. */
116#define HP100_REG_TRAIN_ALLOW 0x16 /* R: (16) Hub allowed register */
117
118/* Page 5 - MMU */
119
120#define HP100_REG_RX_MEM_STOP 0x0c /* RW: (16) End of Rx ring addr */
121#define HP100_REG_TX_MEM_STOP 0x0e /* RW: (16) End of Tx ring addr */
122#define HP100_REG_PDL_MEM_STOP 0x10 /* Not used by 802.12 devices */
123#define HP100_REG_ECB_MEM_STOP 0x14 /* I've no idea what this is */
124
125/* Page 6 - Card ID/Physical LAN Address */
126
127#define HP100_REG_BOARD_ID 0x08 /* R: (8) EISA/ISA card ID */
128#define HP100_REG_BOARD_IO_CHCK 0x0c /* R: (8) Added to ID to get FFh */
129#define HP100_REG_SOFT_MODEL 0x0d /* R: (8) Config program defined */
130#define HP100_REG_LAN_ADDR 0x10 /* R: (8) MAC addr of card */
131#define HP100_REG_LAN_ADDR_CHCK 0x16 /* R: (8) Added to addr to get FFh */
132
133/* Page 7 - MMU Current Pointers */
134
135#define HP100_REG_PTR_RXSTART 0x08 /* R: (16) Current begin of Rx ring */
136#define HP100_REG_PTR_RXEND 0x0a /* R: (16) Current end of Rx ring */
137#define HP100_REG_PTR_TXSTART 0x0c /* R: (16) Current begin of Tx ring */
138#define HP100_REG_PTR_TXEND 0x0e /* R: (16) Current end of Rx ring */
139#define HP100_REG_PTR_RPDLSTART 0x10
140#define HP100_REG_PTR_RPDLEND 0x12
141#define HP100_REG_PTR_RINGPTRS 0x14
142#define HP100_REG_PTR_MEMDEBUG 0x1a
143/* ------------------------------------------------------------------------ */
144
145
146/*
147 * Hardware ID Register I (Always available, HW_ID, Offset 0x00)
148 */
149#define HP100_HW_ID_CASCADE 0x4850 /* Identifies Cascade Chip */
150
151/*
152 * Hardware ID Register 2 & Paging Register
153 * (Always available, PAGING, Offset 0x02)
154 * Bits 15:4 are for the Chip ID
155 */
156#define HP100_CHIPID_MASK 0xFFF0
157#define HP100_CHIPID_SHASTA 0x5350 /* Not 802.12 compliant */
158 /* EISA BM/SL, MCA16/32 SL, ISA SL */
159#define HP100_CHIPID_RAINIER 0x5360 /* Not 802.12 compliant EISA BM, */
160 /* PCI SL, MCA16/32 SL, ISA SL */
161#define HP100_CHIPID_LASSEN 0x5370 /* 802.12 compliant PCI BM, PCI SL */
162 /* LRF supported */
163
164/*
165 * Option Registers I and II
166 * (Always available, OPTION_LSW, Offset 0x04-0x05)
167 */
168#define HP100_DEBUG_EN 0x8000 /* 0:Dis., 1:Enable Debug Dump Ptr. */
169#define HP100_RX_HDR 0x4000 /* 0:Dis., 1:Enable putting pkt into */
170 /* system mem. before Rx interrupt */
171#define HP100_MMAP_DIS 0x2000 /* 0:Enable, 1:Disable mem.mapping. */
172 /* MMAP_DIS must be 0 and MEM_EN */
173 /* must be 1 for memory-mapped */
174 /* mode to be enabled */
175#define HP100_EE_EN 0x1000 /* 0:Disable,1:Enable EEPROM writing */
176#define HP100_BM_WRITE 0x0800 /* 0:Slave, 1:Bus Master for Tx data */
177#define HP100_BM_READ 0x0400 /* 0:Slave, 1:Bus Master for Rx data */
178#define HP100_TRI_INT 0x0200 /* 0:Don't, 1:Do tri-state the int */
179#define HP100_MEM_EN 0x0040 /* Config program set this to */
180 /* 0:Disable, 1:Enable mem map. */
181 /* See MMAP_DIS. */
182#define HP100_IO_EN 0x0020 /* 1:Enable I/O transfers */
183#define HP100_BOOT_EN 0x0010 /* 1:Enable boot ROM access */
184#define HP100_FAKE_INT 0x0008 /* 1:int */
185#define HP100_INT_EN 0x0004 /* 1:Enable ints from card */
186#define HP100_HW_RST 0x0002 /* 0:Reset, 1:Out of reset */
187 /* NIC reset on 0 to 1 transition */
188
189/*
190 * Option Register III
191 * (Always available, OPTION_MSW, Offset 0x06)
192 */
193#define HP100_PRIORITY_TX 0x0080 /* 1:Do all Tx pkts as priority */
194#define HP100_EE_LOAD 0x0040 /* 1:EEPROM loading, 0 when done */
195#define HP100_ADV_NXT_PKT 0x0004 /* 1:Advance to next pkt in Rx queue */
196 /* h/w will set to 0 when done */
197#define HP100_TX_CMD 0x0002 /* 1:Tell h/w download done, h/w */
198 /* will set to 0 when done */
199
200/*
201 * Interrupt Status Registers I and II
202 * (Page PERFORMANCE, IRQ_STATUS, Offset 0x08-0x09)
203 * Note: With old chips, these Registers will clear when 1 is written to them
204 * with new chips this depends on setting of CLR_ISMODE
205 */
206#define HP100_RX_EARLY_INT 0x2000
207#define HP100_RX_PDA_ZERO 0x1000
208#define HP100_RX_PDL_FILL_COMPL 0x0800
209#define HP100_RX_PACKET 0x0400 /* 0:No, 1:Yes pkt has been Rx */
210#define HP100_RX_ERROR 0x0200 /* 0:No, 1:Yes Rx pkt had error */
211#define HP100_TX_PDA_ZERO 0x0020 /* 1 when PDA count goes to zero */
212#define HP100_TX_SPACE_AVAIL 0x0010 /* 0:<8192, 1:>=8192 Tx free bytes */
213#define HP100_TX_COMPLETE 0x0008 /* 0:No, 1:Yes a Tx has completed */
214#define HP100_MISC_ERROR 0x0004 /* 0:No, 1:Lan Link down or bus error */
215#define HP100_TX_ERROR 0x0002 /* 0:No, 1:Yes Tx pkt had error */
216
217/*
218 * Xmit Memory Free Count
219 * (Page PERFORMANCE, TX_MEM_FREE, Offset 0x14) (Read only, 32bit)
220 */
221#define HP100_AUTO_COMPARE 0x80000000 /* Tx Space avail & pkts<255 */
222#define HP100_FREE_SPACE 0x7fffffe0 /* Tx free memory */
223
224/*
225 * IRQ Channel
226 * (Page HW_MAP, IRQ_CHANNEL, Offset 0x0d)
227 */
228#define HP100_ZERO_WAIT_EN 0x80 /* 0:No, 1:Yes asserts NOWS signal */
229#define HP100_IRQ_SCRAMBLE 0x40
230#define HP100_BOND_HP 0x20
231#define HP100_LEVEL_IRQ 0x10 /* 0:Edge, 1:Level type interrupts. */
232 /* (Only valid on EISA cards) */
233#define HP100_IRQMASK 0x0F /* Isolate the IRQ bits */
234
235/*
236 * SRAM Parameters
237 * (Page HW_MAP, SRAM, Offset 0x0e)
238 */
239#define HP100_RAM_SIZE_MASK 0xe0 /* AND to get SRAM size index */
240#define HP100_RAM_SIZE_SHIFT 0x05 /* Shift count(put index in lwr bits) */
241
242/*
243 * Bus Master Register
244 * (Page HW_MAP, BM, Offset 0x0f)
245 */
246#define HP100_BM_BURST_RD 0x01 /* EISA only: 1=Use burst trans. fm system */
247 /* memory to chip (tx) */
248#define HP100_BM_BURST_WR 0x02 /* EISA only: 1=Use burst trans. fm system */
249 /* memory to chip (rx) */
250#define HP100_BM_MASTER 0x04 /* 0:Slave, 1:BM mode */
251#define HP100_BM_PAGE_CK 0x08 /* This bit should be set whenever in */
252 /* an EISA system */
253#define HP100_BM_PCI_8CLK 0x40 /* ... cycles 8 clocks apart */
254
255
256/*
257 * Mode Control Register I
258 * (Page HW_MAP, MODECTRL1, Offset0x10)
259 */
260#define HP100_TX_DUALQ 0x10
261 /* If set and BM -> dual tx pda queues */
262#define HP100_ISR_CLRMODE 0x02 /* If set ISR will clear all pending */
263 /* interrupts on read (etr only?) */
264#define HP100_EE_NOLOAD 0x04 /* Status whether res will be loaded */
265 /* from the eeprom */
266#define HP100_TX_CNT_FLG 0x08 /* Controls Early TX Reg Cnt Field */
267#define HP100_PDL_USE3 0x10 /* If set BM engine will read only */
268 /* first three data elements of a PDL */
269 /* on the first access. */
270#define HP100_BUSTYPE_MASK 0xe0 /* Three bit bus type info */
271
272/*
273 * Mode Control Register II
274 * (Page HW_MAP, MODECTRL2, Offset0x11)
275 */
276#define HP100_EE_MASK 0x0f /* Tell EEPROM circuit not to load */
277 /* certain resources */
278#define HP100_DIS_CANCEL 0x20 /* For tx dualq mode operation */
279#define HP100_EN_PDL_WB 0x40 /* 1: Status of PDL completion may be */
280 /* written back to system mem */
281#define HP100_EN_BUS_FAIL 0x80 /* Enables bus-fail portion of misc */
282 /* interrupt */
283
284/*
285 * PCI Configuration and Control Register I
286 * (Page HW_MAP, PCICTRL1, Offset 0x12)
287 */
288#define HP100_LO_MEM 0x01 /* 1: Mapped Mem requested below 1MB */
289#define HP100_NO_MEM 0x02 /* 1: Disables Req for sysmem to PCI */
290 /* bios */
291#define HP100_USE_ISA 0x04 /* 1: isa type decodes will occur */
292 /* simultaneously with PCI decodes */
293#define HP100_IRQ_HI_MASK 0xf0 /* pgmed by pci bios */
294#define HP100_PCI_IRQ_HI_MASK 0x78 /* Isolate 4 bits for PCI IRQ */
295
296/*
297 * PCI Configuration and Control Register II
298 * (Page HW_MAP, PCICTRL2, Offset 0x13)
299 */
300#define HP100_RD_LINE_PDL 0x01 /* 1: PCI command Memory Read Line en */
301#define HP100_RD_TX_DATA_MASK 0x06 /* choose PCI memread cmds for TX */
302#define HP100_MWI 0x08 /* 1: en. PCI memory write invalidate */
303#define HP100_ARB_MODE 0x10 /* Select PCI arbitor type */
304#define HP100_STOP_EN 0x20 /* Enables PCI state machine to issue */
305 /* pci stop if cascade not ready */
306#define HP100_IGNORE_PAR 0x40 /* 1: PCI state machine ignores parity */
307#define HP100_PCI_RESET 0x80 /* 0->1: Reset PCI block */
308
309/*
310 * Early TX Configuration and Control Register
311 * (Page HW_MAP, EARLYTXCFG, Offset 0x16)
312 */
313#define HP100_EN_EARLY_TX 0x8000 /* 1=Enable Early TX */
314#define HP100_EN_ADAPTIVE 0x4000 /* 1=Enable adaptive mode */
315#define HP100_EN_TX_UR_IRQ 0x2000 /* reserved, must be 0 */
316#define HP100_EN_LOW_TX 0x1000 /* reserved, must be 0 */
317#define HP100_ET_CNT_MASK 0x0fff /* bits 11..0: ET counters */
318
319/*
320 * Early RX Configuration and Control Register
321 * (Page HW_MAP, EARLYRXCFG, Offset 0x18)
322 */
323#define HP100_EN_EARLY_RX 0x80 /* 1=Enable Early RX */
324#define HP100_EN_LOW_RX 0x40 /* reserved, must be 0 */
325#define HP100_RX_TRIP_MASK 0x1f /* bits 4..0: threshold at which the
326 * early rx circuit will start the
327 * dma of received packet into system
328 * memory for BM */
329
330/*
331 * Serial Devices Control Register
332 * (Page EEPROM_CTRL, EEPROM_CTRL, Offset 0x08)
333 */
334#define HP100_EEPROM_LOAD 0x0001 /* 0->1 loads EEPROM into registers. */
335 /* When it goes back to 0, load is */
336 /* complete. This should take ~600us. */
337
338/*
339 * 10MB LAN Control and Configuration Register I
340 * (Page MAC_CTRL, 10_LAN_CFG_1, Offset 0x08)
341 */
342#define HP100_MAC10_SEL 0xc0 /* Get bits to indicate MAC */
343#define HP100_AUI_SEL 0x20 /* Status of AUI selection */
344#define HP100_LOW_TH 0x10 /* 0:No, 1:Yes allow better cabling */
345#define HP100_LINK_BEAT_DIS 0x08 /* 0:Enable, 1:Disable link beat */
346#define HP100_LINK_BEAT_ST 0x04 /* 0:No, 1:Yes link beat being Rx */
347#define HP100_R_ROL_ST 0x02 /* 0:No, 1:Yes Rx twisted pair has */
348 /* been reversed */
349#define HP100_AUI_ST 0x01 /* 0:No, 1:Yes use AUI on TP card */
350
351/*
352 * 10 MB LAN Control and Configuration Register II
353 * (Page MAC_CTRL, 10_LAN_CFG_2, Offset 0x09)
354 */
355#define HP100_SQU_ST 0x01 /* 0:No, 1:Yes collision signal sent */
356 /* after Tx.Only used for AUI. */
357#define HP100_FULLDUP 0x02 /* 1: LXT901 XCVR fullduplx enabled */
358#define HP100_DOT3_MAC 0x04 /* 1: DOT 3 Mac sel. unless Autosel */
359
360/*
361 * MAC Selection, use with MAC10_SEL bits
362 */
363#define HP100_AUTO_SEL_10 0x0 /* Auto select */
364#define HP100_XCVR_LXT901_10 0x1 /* LXT901 10BaseT transceiver */
365#define HP100_XCVR_7213 0x2 /* 7213 transceiver */
366#define HP100_XCVR_82503 0x3 /* 82503 transceiver */
367
368/*
369 * 100MB LAN Training Register
370 * (Page MAC_CTRL, VG_LAN_CFG_2, Offset 0x0b) (old, pre 802.12)
371 */
372#define HP100_FRAME_FORMAT 0x08 /* 0:802.3, 1:802.5 frames */
373#define HP100_BRIDGE 0x04 /* 0:No, 1:Yes tell hub i am a bridge */
374#define HP100_PROM_MODE 0x02 /* 0:No, 1:Yes tell hub card is */
375 /* promiscuous */
376#define HP100_REPEATER 0x01 /* 0:No, 1:Yes tell hub MAC wants to */
377 /* be a cascaded repeater */
378
379/*
380 * 100MB LAN Control and Configuration Register
381 * (Page MAC_CTRL, VG_LAN_CFG_1, Offset 0x0a)
382 */
383#define HP100_VG_SEL 0x80 /* 0:No, 1:Yes use 100 Mbit MAC */
384#define HP100_LINK_UP_ST 0x40 /* 0:No, 1:Yes endnode logged in */
385#define HP100_LINK_CABLE_ST 0x20 /* 0:No, 1:Yes cable can hear tones */
386 /* from hub */
387#define HP100_LOAD_ADDR 0x10 /* 0->1 card addr will be sent */
388 /* 100ms later the link status */
389 /* bits are valid */
390#define HP100_LINK_CMD 0x08 /* 0->1 link will attempt to log in. */
391 /* 100ms later the link status */
392 /* bits are valid */
393#define HP100_TRN_DONE 0x04 /* NEW ETR-Chips only: Will be reset */
394 /* after LinkUp Cmd is given and set */
395 /* when training has completed. */
396#define HP100_LINK_GOOD_ST 0x02 /* 0:No, 1:Yes cable passed training */
397#define HP100_VG_RESET 0x01 /* 0:Yes, 1:No reset the 100VG MAC */
398
399
400/*
401 * MAC Configuration Register I
402 * (Page MAC_CTRL, MAC_CFG_1, Offset 0x0c)
403 */
404#define HP100_RX_IDLE 0x80 /* 0:Yes, 1:No currently receiving pkts */
405#define HP100_TX_IDLE 0x40 /* 0:Yes, 1:No currently Txing pkts */
406#define HP100_RX_EN 0x20 /* 1: allow receiving of pkts */
407#define HP100_TX_EN 0x10 /* 1: allow transmitting of pkts */
408#define HP100_ACC_ERRORED 0x08 /* 0:No, 1:Yes allow Rx of errored pkts */
409#define HP100_ACC_MC 0x04 /* 0:No, 1:Yes allow Rx of multicast pkts */
410#define HP100_ACC_BC 0x02 /* 0:No, 1:Yes allow Rx of broadcast pkts */
411#define HP100_ACC_PHY 0x01 /* 0:No, 1:Yes allow Rx of ALL phys. pkts */
412#define HP100_MAC1MODEMASK 0xf0 /* Hide ACC bits */
413#define HP100_MAC1MODE1 0x00 /* Receive nothing, must also disable RX */
414#define HP100_MAC1MODE2 0x00
415#define HP100_MAC1MODE3 HP100_MAC1MODE2 | HP100_ACC_BC
416#define HP100_MAC1MODE4 HP100_MAC1MODE3 | HP100_ACC_MC
417#define HP100_MAC1MODE5 HP100_MAC1MODE4 /* set mc hash to all ones also */
418#define HP100_MAC1MODE6 HP100_MAC1MODE5 | HP100_ACC_PHY /* Promiscuous */
419/* Note MODE6 will receive all GOOD packets on the LAN. This really needs
420 a mode 7 defined to be LAN Analyzer mode, which will receive errored and
421 runt packets, and keep the CRC bytes. */
422#define HP100_MAC1MODE7 HP100_MAC1MODE6 | HP100_ACC_ERRORED
423
424/*
425 * MAC Configuration Register II
426 * (Page MAC_CTRL, MAC_CFG_2, Offset 0x0d)
427 */
428#define HP100_TR_MODE 0x80 /* 0:No, 1:Yes support Token Ring formats */
429#define HP100_TX_SAME 0x40 /* 0:No, 1:Yes Tx same packet continuous */
430#define HP100_LBK_XCVR 0x20 /* 0:No, 1:Yes loopback through MAC & */
431 /* transceiver */
432#define HP100_LBK_MAC 0x10 /* 0:No, 1:Yes loopback through MAC */
433#define HP100_CRC_I 0x08 /* 0:No, 1:Yes inhibit CRC on Tx packets */
434#define HP100_ACCNA 0x04 /* 1: For 802.5: Accept only token ring
435 * group addr that maches NA mask */
436#define HP100_KEEP_CRC 0x02 /* 0:No, 1:Yes keep CRC on Rx packets. */
437 /* The length will reflect this. */
438#define HP100_ACCFA 0x01 /* 1: For 802.5: Accept only functional
439 * addrs that match FA mask (page1) */
440#define HP100_MAC2MODEMASK 0x02
441#define HP100_MAC2MODE1 0x00
442#define HP100_MAC2MODE2 0x00
443#define HP100_MAC2MODE3 0x00
444#define HP100_MAC2MODE4 0x00
445#define HP100_MAC2MODE5 0x00
446#define HP100_MAC2MODE6 0x00
447#define HP100_MAC2MODE7 KEEP_CRC
448
449/*
450 * MAC Configuration Register III
451 * (Page MAC_CTRL, MAC_CFG_3, Offset 0x0e)
452 */
453#define HP100_PACKET_PACE 0x03 /* Packet Pacing:
454 * 00: No packet pacing
455 * 01: 8 to 16 uS delay
456 * 10: 16 to 32 uS delay
457 * 11: 32 to 64 uS delay
458 */
459#define HP100_LRF_EN 0x04 /* 1: External LAN Rcv Filter and
460 * TCP/IP Checksumming enabled. */
461#define HP100_AUTO_MODE 0x10 /* 1: AutoSelect between 10/100 */
462
463/*
464 * MAC Configuration Register IV
465 * (Page MAC_CTRL, MAC_CFG_4, Offset 0x0f)
466 */
467#define HP100_MAC_SEL_ST 0x01 /* (R): Status of external VGSEL
468 * Signal, 1=100VG, 0=10Mbit sel. */
469#define HP100_LINK_FAIL_ST 0x02 /* (R): Status of Link Fail portion
470 * of the Misc. Interrupt */
471
472/*
473 * 100 MB LAN Training Request/Allowed Registers
474 * (Page MAC_CTRL, TRAIN_REQUEST and TRAIN_ALLOW, Offset 0x14-0x16)(ETR parts only)
475 */
476#define HP100_MACRQ_REPEATER 0x0001 /* 1: MAC tells HUB it wants to be
477 * a cascaded repeater
478 * 0: ... wants to be a DTE */
479#define HP100_MACRQ_PROMSC 0x0006 /* 2 bits: Promiscious mode
480 * 00: Rcv only unicast packets
481 * specifically addr to this
482 * endnode
483 * 10: Rcv all pckts fwded by
484 * the local repeater */
485#define HP100_MACRQ_FRAMEFMT_EITHER 0x0018 /* 11: either format allowed */
486#define HP100_MACRQ_FRAMEFMT_802_3 0x0000 /* 00: 802.3 is requested */
487#define HP100_MACRQ_FRAMEFMT_802_5 0x0010 /* 10: 802.5 format is requested */
488#define HP100_CARD_MACVER 0xe000 /* R: 3 bit Cards 100VG MAC version */
489#define HP100_MALLOW_REPEATER 0x0001 /* If reset, requested access as an
490 * end node is allowed */
491#define HP100_MALLOW_PROMSC 0x0004 /* 2 bits: Promiscious mode
492 * 00: Rcv only unicast packets
493 * specifically addr to this
494 * endnode
495 * 10: Rcv all pckts fwded by
496 * the local repeater */
497#define HP100_MALLOW_FRAMEFMT 0x00e0 /* 2 bits: Frame Format
498 * 00: 802.3 format will be used
499 * 10: 802.5 format will be used */
500#define HP100_MALLOW_ACCDENIED 0x0400 /* N bit */
501#define HP100_MALLOW_CONFIGURE 0x0f00 /* C bit */
502#define HP100_MALLOW_DUPADDR 0x1000 /* D bit */
503#define HP100_HUB_MACVER 0xe000 /* R: 3 bit 802.12 MAC/RMAC training */
504 /* protocol of repeater */
505
506/* ****************************************************************************** */
507
508/*
509 * Set/Reset bits
510 */
511#define HP100_SET_HB 0x0100 /* 0:Set fields to 0 whose mask is 1 */
512#define HP100_SET_LB 0x0001 /* HB sets upper byte, LB sets lower byte */
513#define HP100_RESET_HB 0x0000 /* For readability when resetting bits */
514#define HP100_RESET_LB 0x0000 /* For readability when resetting bits */
515
516/*
517 * Misc. Constants
518 */
519#define HP100_LAN_100 100 /* lan_type value for VG */
520#define HP100_LAN_10 10 /* lan_type value for 10BaseT */
521#define HP100_LAN_COAX 9 /* lan_type value for Coax */
522#define HP100_LAN_ERR (-1) /* lan_type value for link down */
523
524/*
525 * Bus Master Data Structures ----------------------------------------------
526 */
527
528#define MAX_RX_PDL 30 /* Card limit = 31 */
529#define MAX_RX_FRAG 2 /* Don't need more... */
530#define MAX_TX_PDL 29
531#define MAX_TX_FRAG 2 /* Limit = 31 */
532
533/* Define total PDL area size in bytes (should be 4096) */
534/* This is the size of kernel (dma) memory that will be allocated. */
535#define MAX_RINGSIZE ((MAX_RX_FRAG*8+4+4)*MAX_RX_PDL+(MAX_TX_FRAG*8+4+4)*MAX_TX_PDL)+16
536
537/* Ethernet Packet Sizes */
538#define MIN_ETHER_SIZE 60
539#define MAX_ETHER_SIZE 1514 /* Needed for preallocation of */
540 /* skb buffer when busmastering */
541
542/* Tx or Rx Ring Entry */
543typedef struct hp100_ring {
544 u_int *pdl; /* Address of PDLs PDH, dword before
545 * this address is used for rx hdr */
546 u_int pdl_paddr; /* Physical address of PDL */
547 struct sk_buff *skb;
548 struct hp100_ring *next;
549} hp100_ring_t;
550
551
552
553/* Mask for Header Descriptor */
554#define HP100_PKT_LEN_MASK 0x1FFF /* AND with RxLength to get length */
555
556
557/* Receive Packet Status. Note, the error bits are only valid if ACC_ERRORED
558 bit in the MAC Configuration Register 1 is set. */
559#define HP100_RX_PRI 0x8000 /* 0:No, 1:Yes packet is priority */
560#define HP100_SDF_ERR 0x4000 /* 0:No, 1:Yes start of frame error */
561#define HP100_SKEW_ERR 0x2000 /* 0:No, 1:Yes skew out of range */
562#define HP100_BAD_SYMBOL_ERR 0x1000 /* 0:No, 1:Yes invalid symbol received */
563#define HP100_RCV_IPM_ERR 0x0800 /* 0:No, 1:Yes pkt had an invalid packet */
564 /* marker */
565#define HP100_SYMBOL_BAL_ERR 0x0400 /* 0:No, 1:Yes symbol balance error */
566#define HP100_VG_ALN_ERR 0x0200 /* 0:No, 1:Yes non-octet received */
567#define HP100_TRUNC_ERR 0x0100 /* 0:No, 1:Yes the packet was truncated */
568#define HP100_RUNT_ERR 0x0040 /* 0:No, 1:Yes pkt length < Min Pkt */
569 /* Length Reg. */
570#define HP100_ALN_ERR 0x0010 /* 0:No, 1:Yes align error. */
571#define HP100_CRC_ERR 0x0008 /* 0:No, 1:Yes CRC occurred. */
572
573/* The last three bits indicate the type of destination address */
574
575#define HP100_MULTI_ADDR_HASH 0x0006 /* 110: Addr multicast, matched hash */
576#define HP100_BROADCAST_ADDR 0x0003 /* x11: Addr broadcast */
577#define HP100_MULTI_ADDR_NO_HASH 0x0002 /* 010: Addr multicast, didn't match hash */
578#define HP100_PHYS_ADDR_MATCH 0x0001 /* x01: Addr was physical and mine */
579#define HP100_PHYS_ADDR_NO_MATCH 0x0000 /* x00: Addr was physical but not mine */
580
581/*
582 * macros
583 */
584
585#define hp100_inb( reg ) \
586 inb( ioaddr + HP100_REG_##reg )
587#define hp100_inw( reg ) \
588 inw( ioaddr + HP100_REG_##reg )
589#define hp100_inl( reg ) \
590 inl( ioaddr + HP100_REG_##reg )
591#define hp100_outb( data, reg ) \
592 outb( data, ioaddr + HP100_REG_##reg )
593#define hp100_outw( data, reg ) \
594 outw( data, ioaddr + HP100_REG_##reg )
595#define hp100_outl( data, reg ) \
596 outl( data, ioaddr + HP100_REG_##reg )
597#define hp100_orb( data, reg ) \
598 outb( inb( ioaddr + HP100_REG_##reg ) | (data), ioaddr + HP100_REG_##reg )
599#define hp100_orw( data, reg ) \
600 outw( inw( ioaddr + HP100_REG_##reg ) | (data), ioaddr + HP100_REG_##reg )
601#define hp100_andb( data, reg ) \
602 outb( inb( ioaddr + HP100_REG_##reg ) & (data), ioaddr + HP100_REG_##reg )
603#define hp100_andw( data, reg ) \
604 outw( inw( ioaddr + HP100_REG_##reg ) & (data), ioaddr + HP100_REG_##reg )
605
606#define hp100_page( page ) \
607 outw( HP100_PAGE_##page, ioaddr + HP100_REG_PAGING )
608#define hp100_ints_off() \
609 outw( HP100_INT_EN | HP100_RESET_LB, ioaddr + HP100_REG_OPTION_LSW )
610#define hp100_ints_on() \
611 outw( HP100_INT_EN | HP100_SET_LB, ioaddr + HP100_REG_OPTION_LSW )
612#define hp100_mem_map_enable() \
613 outw( HP100_MMAP_DIS | HP100_RESET_HB, ioaddr + HP100_REG_OPTION_LSW )
614#define hp100_mem_map_disable() \
615 outw( HP100_MMAP_DIS | HP100_SET_HB, ioaddr + HP100_REG_OPTION_LSW )
generated by cgit v1.2.2 (git 2.25.0) at 2024-11-27 23:53:39 -0500