ia64/linux-2.6.18-xen.hg

view drivers/net/hp100.c @ 897:329ea0ccb344

balloon: try harder to balloon up under memory pressure.

Currently if the balloon driver is unable to increase the guest's
reservation it assumes the failure was due to reaching its full
allocation, gives up on the ballooning operation and records the limit
it reached as the "hard limit". The driver will not try again until
the target is set again (even to the same value).

However it is possible that ballooning has in fact failed due to
memory pressure in the host and therefore it is desirable to keep
attempting to reach the target in case memory becomes available. The
most likely scenario is that some guests are ballooning down while
others are ballooning up and therefore there is temporary memory
pressure while things stabilise. You would not expect a well behaved
toolstack to ask a domain to balloon to more than its allocation nor
would you expect it to deliberately over-commit memory by setting
balloon targets which exceed the total host memory.

This patch drops the concept of a hard limit and causes the balloon
driver to retry increasing the reservation on a timer in the same
manner as when decreasing the reservation.

Also if we partially succeed in increasing the reservation
(i.e. receive less pages than we asked for) then we may as well keep
those pages rather than returning them to Xen.

Signed-off-by: Ian Campbell <ian.campbell@citrix.com>
author Keir Fraser <keir.fraser@citrix.com>
date Fri Jun 05 14:01:20 2009 +0100 (2009-06-05)
parents 831230e53067
children
line source
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@suse.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 */
86 #define HP100_DEFAULT_PRIORITY_TX 0
88 #undef HP100_DEBUG
89 #undef HP100_DEBUG_B /* Trace */
90 #undef HP100_DEBUG_BM /* Debug busmaster code (PDL stuff) */
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
97 #undef HP100_MULTICAST_FILTER /* Need to be debugged... */
99 #include <linux/module.h>
100 #include <linux/kernel.h>
101 #include <linux/string.h>
102 #include <linux/errno.h>
103 #include <linux/ioport.h>
104 #include <linux/slab.h>
105 #include <linux/interrupt.h>
106 #include <linux/eisa.h>
107 #include <linux/pci.h>
108 #include <linux/dma-mapping.h>
109 #include <linux/spinlock.h>
110 #include <linux/netdevice.h>
111 #include <linux/etherdevice.h>
112 #include <linux/skbuff.h>
113 #include <linux/types.h>
114 #include <linux/config.h> /* for CONFIG_PCI */
115 #include <linux/delay.h>
116 #include <linux/init.h>
117 #include <linux/bitops.h>
118 #include <linux/jiffies.h>
120 #include <asm/io.h>
122 #include "hp100.h"
124 /*
125 * defines
126 */
128 #define HP100_BUS_ISA 0
129 #define HP100_BUS_EISA 1
130 #define HP100_BUS_PCI 2
132 #define HP100_REGION_SIZE 0x20 /* for ioports */
133 #define HP100_SIG_LEN 8 /* same as EISA_SIG_LEN */
135 #define HP100_MAX_PACKET_SIZE (1536+4)
136 #define HP100_MIN_PACKET_SIZE 60
138 #ifndef HP100_DEFAULT_RX_RATIO
139 /* default - 75% onboard memory on the card are used for RX packets */
140 #define HP100_DEFAULT_RX_RATIO 75
141 #endif
143 #ifndef HP100_DEFAULT_PRIORITY_TX
144 /* default - don't enable transmit outgoing packets as priority */
145 #define HP100_DEFAULT_PRIORITY_TX 0
146 #endif
148 /*
149 * structures
150 */
152 struct hp100_private {
153 spinlock_t lock;
154 char id[HP100_SIG_LEN];
155 u_short chip;
156 u_short soft_model;
157 u_int memory_size;
158 u_int virt_memory_size;
159 u_short rx_ratio; /* 1 - 99 */
160 u_short priority_tx; /* != 0 - priority tx */
161 u_short mode; /* PIO, Shared Mem or Busmaster */
162 u_char bus;
163 struct pci_dev *pci_dev;
164 short mem_mapped; /* memory mapped access */
165 void __iomem *mem_ptr_virt; /* virtual memory mapped area, maybe NULL */
166 unsigned long mem_ptr_phys; /* physical memory mapped area */
167 short lan_type; /* 10Mb/s, 100Mb/s or -1 (error) */
168 int hub_status; /* was login to hub successful? */
169 u_char mac1_mode;
170 u_char mac2_mode;
171 u_char hash_bytes[8];
172 struct net_device_stats stats;
174 /* Rings for busmaster mode: */
175 hp100_ring_t *rxrhead; /* Head (oldest) index into rxring */
176 hp100_ring_t *rxrtail; /* Tail (newest) index into rxring */
177 hp100_ring_t *txrhead; /* Head (oldest) index into txring */
178 hp100_ring_t *txrtail; /* Tail (newest) index into txring */
180 hp100_ring_t rxring[MAX_RX_PDL];
181 hp100_ring_t txring[MAX_TX_PDL];
183 u_int *page_vaddr_algn; /* Aligned virtual address of allocated page */
184 u_long whatever_offset; /* Offset to bus/phys/dma address */
185 int rxrcommit; /* # Rx PDLs commited to adapter */
186 int txrcommit; /* # Tx PDLs commited to adapter */
187 };
189 /*
190 * variables
191 */
192 static const char *hp100_isa_tbl[] = {
193 "HWPF150", /* HP J2573 rev A */
194 "HWP1950", /* HP J2573 */
195 };
197 #ifdef CONFIG_EISA
198 static 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 };
207 MODULE_DEVICE_TABLE(eisa, hp100_eisa_tbl);
208 #endif
210 #ifdef CONFIG_PCI
211 static struct pci_device_id 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 };
221 MODULE_DEVICE_TABLE(pci, hp100_pci_tbl);
222 #endif
224 static int hp100_rx_ratio = HP100_DEFAULT_RX_RATIO;
225 static int hp100_priority_tx = HP100_DEFAULT_PRIORITY_TX;
226 static int hp100_mode = 1;
228 module_param(hp100_rx_ratio, int, 0);
229 module_param(hp100_priority_tx, int, 0);
230 module_param(hp100_mode, int, 0);
232 /*
233 * prototypes
234 */
236 static int hp100_probe1(struct net_device *dev, int ioaddr, u_char bus,
237 struct pci_dev *pci_dev);
240 static int hp100_open(struct net_device *dev);
241 static int hp100_close(struct net_device *dev);
242 static int hp100_start_xmit(struct sk_buff *skb, struct net_device *dev);
243 static int hp100_start_xmit_bm(struct sk_buff *skb,
244 struct net_device *dev);
245 static void hp100_rx(struct net_device *dev);
246 static struct net_device_stats *hp100_get_stats(struct net_device *dev);
247 static void hp100_misc_interrupt(struct net_device *dev);
248 static void hp100_update_stats(struct net_device *dev);
249 static void hp100_clear_stats(struct hp100_private *lp, int ioaddr);
250 static void hp100_set_multicast_list(struct net_device *dev);
251 static irqreturn_t hp100_interrupt(int irq, void *dev_id, struct pt_regs *regs);
252 static void hp100_start_interface(struct net_device *dev);
253 static void hp100_stop_interface(struct net_device *dev);
254 static void hp100_load_eeprom(struct net_device *dev, u_short ioaddr);
255 static int hp100_sense_lan(struct net_device *dev);
256 static int hp100_login_to_vg_hub(struct net_device *dev,
257 u_short force_relogin);
258 static int hp100_down_vg_link(struct net_device *dev);
259 static void hp100_cascade_reset(struct net_device *dev, u_short enable);
260 static void hp100_BM_shutdown(struct net_device *dev);
261 static void hp100_mmuinit(struct net_device *dev);
262 static void hp100_init_pdls(struct net_device *dev);
263 static int hp100_init_rxpdl(struct net_device *dev,
264 register hp100_ring_t * ringptr,
265 register u_int * pdlptr);
266 static int hp100_init_txpdl(struct net_device *dev,
267 register hp100_ring_t * ringptr,
268 register u_int * pdlptr);
269 static void hp100_rxfill(struct net_device *dev);
270 static void hp100_hwinit(struct net_device *dev);
271 static void hp100_clean_txring(struct net_device *dev);
272 #ifdef HP100_DEBUG
273 static void hp100_RegisterDump(struct net_device *dev);
274 #endif
276 /* Conversion to new PCI API :
277 * Convert an address in a kernel buffer to a bus/phys/dma address.
278 * This work *only* for memory fragments part of lp->page_vaddr,
279 * because it was properly DMA allocated via pci_alloc_consistent(),
280 * so we just need to "retrieve" the original mapping to bus/phys/dma
281 * address - Jean II */
282 static inline dma_addr_t virt_to_whatever(struct net_device *dev, u32 * ptr)
283 {
284 struct hp100_private *lp = netdev_priv(dev);
285 return ((u_long) ptr) + lp->whatever_offset;
286 }
288 static inline u_int pdl_map_data(struct hp100_private *lp, void *data)
289 {
290 return pci_map_single(lp->pci_dev, data,
291 MAX_ETHER_SIZE, PCI_DMA_FROMDEVICE);
292 }
294 /* TODO: This function should not really be needed in a good design... */
295 static void wait(void)
296 {
297 mdelay(1);
298 }
300 /*
301 * probe functions
302 * These functions should - if possible - avoid doing write operations
303 * since this could cause problems when the card is not installed.
304 */
306 /*
307 * Read board id and convert to string.
308 * Effectively same code as decode_eisa_sig
309 */
310 static __devinit const char *hp100_read_id(int ioaddr)
311 {
312 int i;
313 static char str[HP100_SIG_LEN];
314 unsigned char sig[4], sum;
315 unsigned short rev;
317 hp100_page(ID_MAC_ADDR);
318 sum = 0;
319 for (i = 0; i < 4; i++) {
320 sig[i] = hp100_inb(BOARD_ID + i);
321 sum += sig[i];
322 }
324 sum += hp100_inb(BOARD_ID + i);
325 if (sum != 0xff)
326 return NULL; /* bad checksum */
328 str[0] = ((sig[0] >> 2) & 0x1f) + ('A' - 1);
329 str[1] = (((sig[0] & 3) << 3) | (sig[1] >> 5)) + ('A' - 1);
330 str[2] = (sig[1] & 0x1f) + ('A' - 1);
331 rev = (sig[2] << 8) | sig[3];
332 sprintf(str + 3, "%04X", rev);
334 return str;
335 }
337 static __init int hp100_isa_probe1(struct net_device *dev, int ioaddr)
338 {
339 const char *sig;
340 int i;
342 if (!request_region(ioaddr, HP100_REGION_SIZE, "hp100"))
343 goto err;
345 if (hp100_inw(HW_ID) != HP100_HW_ID_CASCADE) {
346 release_region(ioaddr, HP100_REGION_SIZE);
347 goto err;
348 }
350 sig = hp100_read_id(ioaddr);
351 release_region(ioaddr, HP100_REGION_SIZE);
353 if (sig == NULL)
354 goto err;
356 for (i = 0; i < ARRAY_SIZE(hp100_isa_tbl); i++) {
357 if (!strcmp(hp100_isa_tbl[i], sig))
358 break;
360 }
362 if (i < ARRAY_SIZE(hp100_isa_tbl))
363 return hp100_probe1(dev, ioaddr, HP100_BUS_ISA, NULL);
364 err:
365 return -ENODEV;
367 }
368 /*
369 * Probe for ISA board.
370 * EISA and PCI are handled by device infrastructure.
371 */
373 static int __init hp100_isa_probe(struct net_device *dev, int addr)
374 {
375 int err = -ENODEV;
377 /* Probe for a specific ISA address */
378 if (addr > 0xff && addr < 0x400)
379 err = hp100_isa_probe1(dev, addr);
381 else if (addr != 0)
382 err = -ENXIO;
384 else {
385 /* Probe all ISA possible port regions */
386 for (addr = 0x100; addr < 0x400; addr += 0x20) {
387 err = hp100_isa_probe1(dev, addr);
388 if (!err)
389 break;
390 }
391 }
392 return err;
393 }
396 #ifndef MODULE
397 struct net_device * __init hp100_probe(int unit)
398 {
399 struct net_device *dev = alloc_etherdev(sizeof(struct hp100_private));
400 int err;
402 if (!dev)
403 return ERR_PTR(-ENODEV);
405 SET_MODULE_OWNER(dev);
407 #ifdef HP100_DEBUG_B
408 hp100_outw(0x4200, TRACE);
409 printk("hp100: %s: probe\n", dev->name);
410 #endif
412 if (unit >= 0) {
413 sprintf(dev->name, "eth%d", unit);
414 netdev_boot_setup_check(dev);
415 }
417 err = hp100_isa_probe(dev, dev->base_addr);
418 if (err)
419 goto out;
421 return dev;
422 out:
423 free_netdev(dev);
424 return ERR_PTR(err);
425 }
426 #endif
428 static int __devinit hp100_probe1(struct net_device *dev, int ioaddr,
429 u_char bus, struct pci_dev *pci_dev)
430 {
431 int i;
432 int err = -ENODEV;
433 const char *eid;
434 u_int chip;
435 u_char uc;
436 u_int memory_size = 0, virt_memory_size = 0;
437 u_short local_mode, lsw;
438 short mem_mapped;
439 unsigned long mem_ptr_phys;
440 void __iomem *mem_ptr_virt;
441 struct hp100_private *lp;
443 #ifdef HP100_DEBUG_B
444 hp100_outw(0x4201, TRACE);
445 printk("hp100: %s: probe1\n", dev->name);
446 #endif
448 /* memory region for programmed i/o */
449 if (!request_region(ioaddr, HP100_REGION_SIZE, "hp100"))
450 goto out1;
452 if (hp100_inw(HW_ID) != HP100_HW_ID_CASCADE)
453 goto out2;
455 chip = hp100_inw(PAGING) & HP100_CHIPID_MASK;
456 #ifdef HP100_DEBUG
457 if (chip == HP100_CHIPID_SHASTA)
458 printk("hp100: %s: Shasta Chip detected. (This is a pre 802.12 chip)\n", dev->name);
459 else if (chip == HP100_CHIPID_RAINIER)
460 printk("hp100: %s: Rainier Chip detected. (This is a pre 802.12 chip)\n", dev->name);
461 else if (chip == HP100_CHIPID_LASSEN)
462 printk("hp100: %s: Lassen Chip detected.\n", dev->name);
463 else
464 printk("hp100: %s: Warning: Unknown CASCADE chip (id=0x%.4x).\n", dev->name, chip);
465 #endif
467 dev->base_addr = ioaddr;
469 eid = hp100_read_id(ioaddr);
470 if (eid == NULL) { /* bad checksum? */
471 printk(KERN_WARNING "hp100_probe: bad ID checksum at base port 0x%x\n", ioaddr);
472 goto out2;
473 }
475 hp100_page(ID_MAC_ADDR);
476 for (i = uc = 0; i < 7; i++)
477 uc += hp100_inb(LAN_ADDR + i);
478 if (uc != 0xff) {
479 printk(KERN_WARNING "hp100_probe: bad lan address checksum at port 0x%x)\n", ioaddr);
480 err = -EIO;
481 goto out2;
482 }
484 /* Make sure, that all registers are correctly updated... */
486 hp100_load_eeprom(dev, ioaddr);
487 wait();
489 /*
490 * Determine driver operation mode
491 *
492 * Use the variable "hp100_mode" upon insmod or as kernel parameter to
493 * force driver modes:
494 * hp100_mode=1 -> default, use busmaster mode if configured.
495 * hp100_mode=2 -> enable shared memory mode
496 * hp100_mode=3 -> force use of i/o mapped mode.
497 * hp100_mode=4 -> same as 1, but re-set the enable bit on the card.
498 */
500 /*
501 * LSW values:
502 * 0x2278 -> J2585B, PnP shared memory mode
503 * 0x2270 -> J2585B, shared memory mode, 0xdc000
504 * 0xa23c -> J2585B, I/O mapped mode
505 * 0x2240 -> EISA COMPEX, BusMaster (Shasta Chip)
506 * 0x2220 -> EISA HP, I/O (Shasta Chip)
507 * 0x2260 -> EISA HP, BusMaster (Shasta Chip)
508 */
510 #if 0
511 local_mode = 0x2270;
512 hp100_outw(0xfefe, OPTION_LSW);
513 hp100_outw(local_mode | HP100_SET_LB | HP100_SET_HB, OPTION_LSW);
514 #endif
516 /* hp100_mode value maybe used in future by another card */
517 local_mode = hp100_mode;
518 if (local_mode < 1 || local_mode > 4)
519 local_mode = 1; /* default */
520 #ifdef HP100_DEBUG
521 printk("hp100: %s: original LSW = 0x%x\n", dev->name,
522 hp100_inw(OPTION_LSW));
523 #endif
525 if (local_mode == 3) {
526 hp100_outw(HP100_MEM_EN | HP100_RESET_LB, OPTION_LSW);
527 hp100_outw(HP100_IO_EN | HP100_SET_LB, OPTION_LSW);
528 hp100_outw(HP100_BM_WRITE | HP100_BM_READ | HP100_RESET_HB, OPTION_LSW);
529 printk("hp100: IO mapped mode forced.\n");
530 } else if (local_mode == 2) {
531 hp100_outw(HP100_MEM_EN | HP100_SET_LB, OPTION_LSW);
532 hp100_outw(HP100_IO_EN | HP100_SET_LB, OPTION_LSW);
533 hp100_outw(HP100_BM_WRITE | HP100_BM_READ | HP100_RESET_HB, OPTION_LSW);
534 printk("hp100: Shared memory mode requested.\n");
535 } else if (local_mode == 4) {
536 if (chip == HP100_CHIPID_LASSEN) {
537 hp100_outw(HP100_BM_WRITE | HP100_BM_READ | HP100_SET_HB, OPTION_LSW);
538 hp100_outw(HP100_IO_EN | HP100_MEM_EN | HP100_RESET_LB, OPTION_LSW);
539 printk("hp100: Busmaster mode requested.\n");
540 }
541 local_mode = 1;
542 }
544 if (local_mode == 1) { /* default behaviour */
545 lsw = hp100_inw(OPTION_LSW);
547 if ((lsw & HP100_IO_EN) && (~lsw & HP100_MEM_EN) &&
548 (~lsw & (HP100_BM_WRITE | HP100_BM_READ))) {
549 #ifdef HP100_DEBUG
550 printk("hp100: %s: IO_EN bit is set on card.\n", dev->name);
551 #endif
552 local_mode = 3;
553 } else if (chip == HP100_CHIPID_LASSEN &&
554 (lsw & (HP100_BM_WRITE | HP100_BM_READ)) == (HP100_BM_WRITE | HP100_BM_READ)) {
555 /* Conversion to new PCI API :
556 * I don't have the doc, but I assume that the card
557 * can map the full 32bit address space.
558 * Also, we can have EISA Busmaster cards (not tested),
559 * so beware !!! - Jean II */
560 if((bus == HP100_BUS_PCI) &&
561 (pci_set_dma_mask(pci_dev, DMA_32BIT_MASK))) {
562 /* Gracefully fallback to shared memory */
563 goto busmasterfail;
564 }
565 printk("hp100: Busmaster mode enabled.\n");
566 hp100_outw(HP100_MEM_EN | HP100_IO_EN | HP100_RESET_LB, OPTION_LSW);
567 } else {
568 busmasterfail:
569 #ifdef HP100_DEBUG
570 printk("hp100: %s: Card not configured for BM or BM not supported with this card.\n", dev->name);
571 printk("hp100: %s: Trying shared memory mode.\n", dev->name);
572 #endif
573 /* In this case, try shared memory mode */
574 local_mode = 2;
575 hp100_outw(HP100_MEM_EN | HP100_SET_LB, OPTION_LSW);
576 /* hp100_outw(HP100_IO_EN|HP100_RESET_LB, OPTION_LSW); */
577 }
578 }
579 #ifdef HP100_DEBUG
580 printk("hp100: %s: new LSW = 0x%x\n", dev->name, hp100_inw(OPTION_LSW));
581 #endif
583 /* Check for shared memory on the card, eventually remap it */
584 hp100_page(HW_MAP);
585 mem_mapped = ((hp100_inw(OPTION_LSW) & (HP100_MEM_EN)) != 0);
586 mem_ptr_phys = 0UL;
587 mem_ptr_virt = NULL;
588 memory_size = (8192 << ((hp100_inb(SRAM) >> 5) & 0x07));
589 virt_memory_size = 0;
591 /* For memory mapped or busmaster mode, we want the memory address */
592 if (mem_mapped || (local_mode == 1)) {
593 mem_ptr_phys = (hp100_inw(MEM_MAP_LSW) | (hp100_inw(MEM_MAP_MSW) << 16));
594 mem_ptr_phys &= ~0x1fff; /* 8k alignment */
596 if (bus == HP100_BUS_ISA && (mem_ptr_phys & ~0xfffff) != 0) {
597 printk("hp100: Can only use programmed i/o mode.\n");
598 mem_ptr_phys = 0;
599 mem_mapped = 0;
600 local_mode = 3; /* Use programmed i/o */
601 }
603 /* We do not need access to shared memory in busmaster mode */
604 /* However in slave mode we need to remap high (>1GB) card memory */
605 if (local_mode != 1) { /* = not busmaster */
606 /* We try with smaller memory sizes, if ioremap fails */
607 for (virt_memory_size = memory_size; virt_memory_size > 16383; virt_memory_size >>= 1) {
608 if ((mem_ptr_virt = ioremap((u_long) mem_ptr_phys, virt_memory_size)) == NULL) {
609 #ifdef HP100_DEBUG
610 printk("hp100: %s: ioremap for 0x%x bytes high PCI memory at 0x%lx failed\n", dev->name, virt_memory_size, mem_ptr_phys);
611 #endif
612 } else {
613 #ifdef HP100_DEBUG
614 printk("hp100: %s: remapped 0x%x bytes high PCI memory at 0x%lx to %p.\n", dev->name, virt_memory_size, mem_ptr_phys, mem_ptr_virt);
615 #endif
616 break;
617 }
618 }
620 if (mem_ptr_virt == NULL) { /* all ioremap tries failed */
621 printk("hp100: Failed to ioremap the PCI card memory. Will have to use i/o mapped mode.\n");
622 local_mode = 3;
623 virt_memory_size = 0;
624 }
625 }
626 }
628 if (local_mode == 3) { /* io mapped forced */
629 mem_mapped = 0;
630 mem_ptr_phys = 0;
631 mem_ptr_virt = NULL;
632 printk("hp100: Using (slow) programmed i/o mode.\n");
633 }
635 /* Initialise the "private" data structure for this card. */
636 lp = netdev_priv(dev);
638 spin_lock_init(&lp->lock);
639 strlcpy(lp->id, eid, HP100_SIG_LEN);
640 lp->chip = chip;
641 lp->mode = local_mode;
642 lp->bus = bus;
643 lp->pci_dev = pci_dev;
644 lp->priority_tx = hp100_priority_tx;
645 lp->rx_ratio = hp100_rx_ratio;
646 lp->mem_ptr_phys = mem_ptr_phys;
647 lp->mem_ptr_virt = mem_ptr_virt;
648 hp100_page(ID_MAC_ADDR);
649 lp->soft_model = hp100_inb(SOFT_MODEL);
650 lp->mac1_mode = HP100_MAC1MODE3;
651 lp->mac2_mode = HP100_MAC2MODE3;
652 memset(&lp->hash_bytes, 0x00, 8);
654 dev->base_addr = ioaddr;
656 lp->memory_size = memory_size;
657 lp->virt_memory_size = virt_memory_size;
658 lp->rx_ratio = hp100_rx_ratio; /* can be conf'd with insmod */
660 dev->open = hp100_open;
661 dev->stop = hp100_close;
663 if (lp->mode == 1) /* busmaster */
664 dev->hard_start_xmit = hp100_start_xmit_bm;
665 else
666 dev->hard_start_xmit = hp100_start_xmit;
668 dev->get_stats = hp100_get_stats;
669 dev->set_multicast_list = &hp100_set_multicast_list;
671 /* Ask the card for which IRQ line it is configured */
672 if (bus == HP100_BUS_PCI) {
673 dev->irq = pci_dev->irq;
674 } else {
675 hp100_page(HW_MAP);
676 dev->irq = hp100_inb(IRQ_CHANNEL) & HP100_IRQMASK;
677 if (dev->irq == 2)
678 dev->irq = 9;
679 }
681 if (lp->mode == 1) /* busmaster */
682 dev->dma = 4;
684 /* Ask the card for its MAC address and store it for later use. */
685 hp100_page(ID_MAC_ADDR);
686 for (i = uc = 0; i < 6; i++)
687 dev->dev_addr[i] = hp100_inb(LAN_ADDR + i);
689 /* Reset statistics (counters) */
690 hp100_clear_stats(lp, ioaddr);
692 /* If busmaster mode is wanted, a dma-capable memory area is needed for
693 * the rx and tx PDLs
694 * PCI cards can access the whole PC memory. Therefore GFP_DMA is not
695 * needed for the allocation of the memory area.
696 */
698 /* TODO: We do not need this with old cards, where PDLs are stored
699 * in the cards shared memory area. But currently, busmaster has been
700 * implemented/tested only with the lassen chip anyway... */
701 if (lp->mode == 1) { /* busmaster */
702 dma_addr_t page_baddr;
703 /* Get physically continous memory for TX & RX PDLs */
704 /* Conversion to new PCI API :
705 * Pages are always aligned and zeroed, no need to it ourself.
706 * Doc says should be OK for EISA bus as well - Jean II */
707 if ((lp->page_vaddr_algn = pci_alloc_consistent(lp->pci_dev, MAX_RINGSIZE, &page_baddr)) == NULL) {
708 err = -ENOMEM;
709 goto out2;
710 }
711 lp->whatever_offset = ((u_long) page_baddr) - ((u_long) lp->page_vaddr_algn);
713 #ifdef HP100_DEBUG_BM
714 printk("hp100: %s: Reserved DMA memory from 0x%x to 0x%x\n", dev->name, (u_int) lp->page_vaddr_algn, (u_int) lp->page_vaddr_algn + MAX_RINGSIZE);
715 #endif
716 lp->rxrcommit = lp->txrcommit = 0;
717 lp->rxrhead = lp->rxrtail = &(lp->rxring[0]);
718 lp->txrhead = lp->txrtail = &(lp->txring[0]);
719 }
721 /* Initialise the card. */
722 /* (I'm not really sure if it's a good idea to do this during probing, but
723 * like this it's assured that the lan connection type can be sensed
724 * correctly)
725 */
726 hp100_hwinit(dev);
728 /* Try to find out which kind of LAN the card is connected to. */
729 lp->lan_type = hp100_sense_lan(dev);
731 /* Print out a message what about what we think we have probed. */
732 printk("hp100: at 0x%x, IRQ %d, ", ioaddr, dev->irq);
733 switch (bus) {
734 case HP100_BUS_EISA:
735 printk("EISA");
736 break;
737 case HP100_BUS_PCI:
738 printk("PCI");
739 break;
740 default:
741 printk("ISA");
742 break;
743 }
744 printk(" bus, %dk SRAM (rx/tx %d%%).\n", lp->memory_size >> 10, lp->rx_ratio);
746 if (lp->mode == 2) { /* memory mapped */
747 printk("hp100: Memory area at 0x%lx-0x%lx", mem_ptr_phys,
748 (mem_ptr_phys + (mem_ptr_phys > 0x100000 ? (u_long) lp->memory_size : 16 * 1024)) - 1);
749 if (mem_ptr_virt)
750 printk(" (virtual base %p)", mem_ptr_virt);
751 printk(".\n");
753 /* Set for info when doing ifconfig */
754 dev->mem_start = mem_ptr_phys;
755 dev->mem_end = mem_ptr_phys + lp->memory_size;
756 }
758 printk("hp100: ");
759 if (lp->lan_type != HP100_LAN_ERR)
760 printk("Adapter is attached to ");
761 switch (lp->lan_type) {
762 case HP100_LAN_100:
763 printk("100Mb/s Voice Grade AnyLAN network.\n");
764 break;
765 case HP100_LAN_10:
766 printk("10Mb/s network (10baseT).\n");
767 break;
768 case HP100_LAN_COAX:
769 printk("10Mb/s network (coax).\n");
770 break;
771 default:
772 printk("Warning! Link down.\n");
773 }
775 err = register_netdev(dev);
776 if (err)
777 goto out3;
779 return 0;
780 out3:
781 if (local_mode == 1)
782 pci_free_consistent(lp->pci_dev, MAX_RINGSIZE + 0x0f,
783 lp->page_vaddr_algn,
784 virt_to_whatever(dev, lp->page_vaddr_algn));
785 if (mem_ptr_virt)
786 iounmap(mem_ptr_virt);
787 out2:
788 release_region(ioaddr, HP100_REGION_SIZE);
789 out1:
790 return err;
791 }
793 /* This procedure puts the card into a stable init state */
794 static void hp100_hwinit(struct net_device *dev)
795 {
796 int ioaddr = dev->base_addr;
797 struct hp100_private *lp = netdev_priv(dev);
799 #ifdef HP100_DEBUG_B
800 hp100_outw(0x4202, TRACE);
801 printk("hp100: %s: hwinit\n", dev->name);
802 #endif
804 /* Initialise the card. -------------------------------------------- */
806 /* Clear all pending Ints and disable Ints */
807 hp100_page(PERFORMANCE);
808 hp100_outw(0xfefe, IRQ_MASK); /* mask off all ints */
809 hp100_outw(0xffff, IRQ_STATUS); /* clear all pending ints */
811 hp100_outw(HP100_INT_EN | HP100_RESET_LB, OPTION_LSW);
812 hp100_outw(HP100_TRI_INT | HP100_SET_HB, OPTION_LSW);
814 if (lp->mode == 1) {
815 hp100_BM_shutdown(dev); /* disables BM, puts cascade in reset */
816 wait();
817 } else {
818 hp100_outw(HP100_INT_EN | HP100_RESET_LB, OPTION_LSW);
819 hp100_cascade_reset(dev, 1);
820 hp100_page(MAC_CTRL);
821 hp100_andb(~(HP100_RX_EN | HP100_TX_EN), MAC_CFG_1);
822 }
824 /* Initiate EEPROM reload */
825 hp100_load_eeprom(dev, 0);
827 wait();
829 /* Go into reset again. */
830 hp100_cascade_reset(dev, 1);
832 /* Set Option Registers to a safe state */
833 hp100_outw(HP100_DEBUG_EN |
834 HP100_RX_HDR |
835 HP100_EE_EN |
836 HP100_BM_WRITE |
837 HP100_BM_READ | HP100_RESET_HB |
838 HP100_FAKE_INT |
839 HP100_INT_EN |
840 HP100_MEM_EN |
841 HP100_IO_EN | HP100_RESET_LB, OPTION_LSW);
843 hp100_outw(HP100_TRI_INT |
844 HP100_MMAP_DIS | HP100_SET_HB, OPTION_LSW);
846 hp100_outb(HP100_PRIORITY_TX |
847 HP100_ADV_NXT_PKT |
848 HP100_TX_CMD | HP100_RESET_LB, OPTION_MSW);
850 /* TODO: Configure MMU for Ram Test. */
851 /* TODO: Ram Test. */
853 /* Re-check if adapter is still at same i/o location */
854 /* (If the base i/o in eeprom has been changed but the */
855 /* registers had not been changed, a reload of the eeprom */
856 /* would move the adapter to the address stored in eeprom */
858 /* TODO: Code to implement. */
860 /* Until here it was code from HWdiscover procedure. */
861 /* Next comes code from mmuinit procedure of SCO BM driver which is
862 * called from HWconfigure in the SCO driver. */
864 /* Initialise MMU, eventually switch on Busmaster Mode, initialise
865 * multicast filter...
866 */
867 hp100_mmuinit(dev);
869 /* We don't turn the interrupts on here - this is done by start_interface. */
870 wait(); /* TODO: Do we really need this? */
872 /* Enable Hardware (e.g. unreset) */
873 hp100_cascade_reset(dev, 0);
875 /* ------- initialisation complete ----------- */
877 /* Finally try to log in the Hub if there may be a VG connection. */
878 if ((lp->lan_type == HP100_LAN_100) || (lp->lan_type == HP100_LAN_ERR))
879 hp100_login_to_vg_hub(dev, 0); /* relogin */
881 }
884 /*
885 * mmuinit - Reinitialise Cascade MMU and MAC settings.
886 * Note: Must already be in reset and leaves card in reset.
887 */
888 static void hp100_mmuinit(struct net_device *dev)
889 {
890 int ioaddr = dev->base_addr;
891 struct hp100_private *lp = netdev_priv(dev);
892 int i;
894 #ifdef HP100_DEBUG_B
895 hp100_outw(0x4203, TRACE);
896 printk("hp100: %s: mmuinit\n", dev->name);
897 #endif
899 #ifdef HP100_DEBUG
900 if (0 != (hp100_inw(OPTION_LSW) & HP100_HW_RST)) {
901 printk("hp100: %s: Not in reset when entering mmuinit. Fix me.\n", dev->name);
902 return;
903 }
904 #endif
906 /* Make sure IRQs are masked off and ack'ed. */
907 hp100_page(PERFORMANCE);
908 hp100_outw(0xfefe, IRQ_MASK); /* mask off all ints */
909 hp100_outw(0xffff, IRQ_STATUS); /* ack IRQ */
911 /*
912 * Enable Hardware
913 * - Clear Debug En, Rx Hdr Pipe, EE En, I/O En, Fake Int and Intr En
914 * - Set Tri-State Int, Bus Master Rd/Wr, and Mem Map Disable
915 * - Clear Priority, Advance Pkt and Xmit Cmd
916 */
918 hp100_outw(HP100_DEBUG_EN |
919 HP100_RX_HDR |
920 HP100_EE_EN | HP100_RESET_HB |
921 HP100_IO_EN |
922 HP100_FAKE_INT |
923 HP100_INT_EN | HP100_RESET_LB, OPTION_LSW);
925 hp100_outw(HP100_TRI_INT | HP100_SET_HB, OPTION_LSW);
927 if (lp->mode == 1) { /* busmaster */
928 hp100_outw(HP100_BM_WRITE |
929 HP100_BM_READ |
930 HP100_MMAP_DIS | HP100_SET_HB, OPTION_LSW);
931 } else if (lp->mode == 2) { /* memory mapped */
932 hp100_outw(HP100_BM_WRITE |
933 HP100_BM_READ | HP100_RESET_HB, OPTION_LSW);
934 hp100_outw(HP100_MMAP_DIS | HP100_RESET_HB, OPTION_LSW);
935 hp100_outw(HP100_MEM_EN | HP100_SET_LB, OPTION_LSW);
936 hp100_outw(HP100_IO_EN | HP100_SET_LB, OPTION_LSW);
937 } else if (lp->mode == 3) { /* i/o mapped mode */
938 hp100_outw(HP100_MMAP_DIS | HP100_SET_HB |
939 HP100_IO_EN | HP100_SET_LB, OPTION_LSW);
940 }
942 hp100_page(HW_MAP);
943 hp100_outb(0, EARLYRXCFG);
944 hp100_outw(0, EARLYTXCFG);
946 /*
947 * Enable Bus Master mode
948 */
949 if (lp->mode == 1) { /* busmaster */
950 /* Experimental: Set some PCI configuration bits */
951 hp100_page(HW_MAP);
952 hp100_andb(~HP100_PDL_USE3, MODECTRL1); /* BM engine read maximum */
953 hp100_andb(~HP100_TX_DUALQ, MODECTRL1); /* No Queue for Priority TX */
955 /* PCI Bus failures should result in a Misc. Interrupt */
956 hp100_orb(HP100_EN_BUS_FAIL, MODECTRL2);
958 hp100_outw(HP100_BM_READ | HP100_BM_WRITE | HP100_SET_HB, OPTION_LSW);
959 hp100_page(HW_MAP);
960 /* Use Burst Mode and switch on PAGE_CK */
961 hp100_orb(HP100_BM_BURST_RD | HP100_BM_BURST_WR, BM);
962 if ((lp->chip == HP100_CHIPID_RAINIER) || (lp->chip == HP100_CHIPID_SHASTA))
963 hp100_orb(HP100_BM_PAGE_CK, BM);
964 hp100_orb(HP100_BM_MASTER, BM);
965 } else { /* not busmaster */
967 hp100_page(HW_MAP);
968 hp100_andb(~HP100_BM_MASTER, BM);
969 }
971 /*
972 * Divide card memory into regions for Rx, Tx and, if non-ETR chip, PDLs
973 */
974 hp100_page(MMU_CFG);
975 if (lp->mode == 1) { /* only needed for Busmaster */
976 int xmit_stop, recv_stop;
978 if ((lp->chip == HP100_CHIPID_RAINIER)
979 || (lp->chip == HP100_CHIPID_SHASTA)) {
980 int pdl_stop;
982 /*
983 * Each pdl is 508 bytes long. (63 frags * 4 bytes for address and
984 * 4 bytes for header). We will leave NUM_RXPDLS * 508 (rounded
985 * to the next higher 1k boundary) bytes for the rx-pdl's
986 * Note: For non-etr chips the transmit stop register must be
987 * programmed on a 1k boundary, i.e. bits 9:0 must be zero.
988 */
989 pdl_stop = lp->memory_size;
990 xmit_stop = (pdl_stop - 508 * (MAX_RX_PDL) - 16) & ~(0x03ff);
991 recv_stop = (xmit_stop * (lp->rx_ratio) / 100) & ~(0x03ff);
992 hp100_outw((pdl_stop >> 4) - 1, PDL_MEM_STOP);
993 #ifdef HP100_DEBUG_BM
994 printk("hp100: %s: PDL_STOP = 0x%x\n", dev->name, pdl_stop);
995 #endif
996 } else {
997 /* ETR chip (Lassen) in busmaster mode */
998 xmit_stop = (lp->memory_size) - 1;
999 recv_stop = ((lp->memory_size * lp->rx_ratio) / 100) & ~(0x03ff);
1002 hp100_outw(xmit_stop >> 4, TX_MEM_STOP);
1003 hp100_outw(recv_stop >> 4, RX_MEM_STOP);
1004 #ifdef HP100_DEBUG_BM
1005 printk("hp100: %s: TX_STOP = 0x%x\n", dev->name, xmit_stop >> 4);
1006 printk("hp100: %s: RX_STOP = 0x%x\n", dev->name, recv_stop >> 4);
1007 #endif
1008 } else {
1009 /* Slave modes (memory mapped and programmed io) */
1010 hp100_outw((((lp->memory_size * lp->rx_ratio) / 100) >> 4), RX_MEM_STOP);
1011 hp100_outw(((lp->memory_size - 1) >> 4), TX_MEM_STOP);
1012 #ifdef HP100_DEBUG
1013 printk("hp100: %s: TX_MEM_STOP: 0x%x\n", dev->name, hp100_inw(TX_MEM_STOP));
1014 printk("hp100: %s: RX_MEM_STOP: 0x%x\n", dev->name, hp100_inw(RX_MEM_STOP));
1015 #endif
1018 /* Write MAC address into page 1 */
1019 hp100_page(MAC_ADDRESS);
1020 for (i = 0; i < 6; i++)
1021 hp100_outb(dev->dev_addr[i], MAC_ADDR + i);
1023 /* Zero the multicast hash registers */
1024 for (i = 0; i < 8; i++)
1025 hp100_outb(0x0, HASH_BYTE0 + i);
1027 /* Set up MAC defaults */
1028 hp100_page(MAC_CTRL);
1030 /* Go to LAN Page and zero all filter bits */
1031 /* Zero accept error, accept multicast, accept broadcast and accept */
1032 /* all directed packet bits */
1033 hp100_andb(~(HP100_RX_EN |
1034 HP100_TX_EN |
1035 HP100_ACC_ERRORED |
1036 HP100_ACC_MC |
1037 HP100_ACC_BC | HP100_ACC_PHY), MAC_CFG_1);
1039 hp100_outb(0x00, MAC_CFG_2);
1041 /* Zero the frame format bit. This works around a training bug in the */
1042 /* new hubs. */
1043 hp100_outb(0x00, VG_LAN_CFG_2); /* (use 802.3) */
1045 if (lp->priority_tx)
1046 hp100_outb(HP100_PRIORITY_TX | HP100_SET_LB, OPTION_MSW);
1047 else
1048 hp100_outb(HP100_PRIORITY_TX | HP100_RESET_LB, OPTION_MSW);
1050 hp100_outb(HP100_ADV_NXT_PKT |
1051 HP100_TX_CMD | HP100_RESET_LB, OPTION_MSW);
1053 /* If busmaster, initialize the PDLs */
1054 if (lp->mode == 1)
1055 hp100_init_pdls(dev);
1057 /* Go to performance page and initalize isr and imr registers */
1058 hp100_page(PERFORMANCE);
1059 hp100_outw(0xfefe, IRQ_MASK); /* mask off all ints */
1060 hp100_outw(0xffff, IRQ_STATUS); /* ack IRQ */
1063 /*
1064 * open/close functions
1065 */
1067 static int hp100_open(struct net_device *dev)
1069 struct hp100_private *lp = netdev_priv(dev);
1070 #ifdef HP100_DEBUG_B
1071 int ioaddr = dev->base_addr;
1072 #endif
1074 #ifdef HP100_DEBUG_B
1075 hp100_outw(0x4204, TRACE);
1076 printk("hp100: %s: open\n", dev->name);
1077 #endif
1079 /* New: if bus is PCI or EISA, interrupts might be shared interrupts */
1080 if (request_irq(dev->irq, hp100_interrupt,
1081 lp->bus == HP100_BUS_PCI || lp->bus ==
1082 HP100_BUS_EISA ? IRQF_SHARED : IRQF_DISABLED,
1083 "hp100", dev)) {
1084 printk("hp100: %s: unable to get IRQ %d\n", dev->name, dev->irq);
1085 return -EAGAIN;
1088 dev->trans_start = jiffies;
1089 netif_start_queue(dev);
1091 lp->lan_type = hp100_sense_lan(dev);
1092 lp->mac1_mode = HP100_MAC1MODE3;
1093 lp->mac2_mode = HP100_MAC2MODE3;
1094 memset(&lp->hash_bytes, 0x00, 8);
1096 hp100_stop_interface(dev);
1098 hp100_hwinit(dev);
1100 hp100_start_interface(dev); /* sets mac modes, enables interrupts */
1102 return 0;
1105 /* The close function is called when the interface is to be brought down */
1106 static int hp100_close(struct net_device *dev)
1108 int ioaddr = dev->base_addr;
1109 struct hp100_private *lp = netdev_priv(dev);
1111 #ifdef HP100_DEBUG_B
1112 hp100_outw(0x4205, TRACE);
1113 printk("hp100: %s: close\n", dev->name);
1114 #endif
1116 hp100_page(PERFORMANCE);
1117 hp100_outw(0xfefe, IRQ_MASK); /* mask off all IRQs */
1119 hp100_stop_interface(dev);
1121 if (lp->lan_type == HP100_LAN_100)
1122 lp->hub_status = hp100_login_to_vg_hub(dev, 0);
1124 netif_stop_queue(dev);
1126 free_irq(dev->irq, dev);
1128 #ifdef HP100_DEBUG
1129 printk("hp100: %s: close LSW = 0x%x\n", dev->name,
1130 hp100_inw(OPTION_LSW));
1131 #endif
1133 return 0;
1137 /*
1138 * Configure the PDL Rx rings and LAN
1139 */
1140 static void hp100_init_pdls(struct net_device *dev)
1142 struct hp100_private *lp = netdev_priv(dev);
1143 hp100_ring_t *ringptr;
1144 u_int *pageptr; /* Warning : increment by 4 - Jean II */
1145 int i;
1147 #ifdef HP100_DEBUG_B
1148 int ioaddr = dev->base_addr;
1149 #endif
1151 #ifdef HP100_DEBUG_B
1152 hp100_outw(0x4206, TRACE);
1153 printk("hp100: %s: init pdls\n", dev->name);
1154 #endif
1156 if (0 == lp->page_vaddr_algn)
1157 printk("hp100: %s: Warning: lp->page_vaddr_algn not initialised!\n", dev->name);
1158 else {
1159 /* pageptr shall point into the DMA accessible memory region */
1160 /* we use this pointer to status the upper limit of allocated */
1161 /* memory in the allocated page. */
1162 /* note: align the pointers to the pci cache line size */
1163 memset(lp->page_vaddr_algn, 0, MAX_RINGSIZE); /* Zero Rx/Tx ring page */
1164 pageptr = lp->page_vaddr_algn;
1166 lp->rxrcommit = 0;
1167 ringptr = lp->rxrhead = lp->rxrtail = &(lp->rxring[0]);
1169 /* Initialise Rx Ring */
1170 for (i = MAX_RX_PDL - 1; i >= 0; i--) {
1171 lp->rxring[i].next = ringptr;
1172 ringptr = &(lp->rxring[i]);
1173 pageptr += hp100_init_rxpdl(dev, ringptr, pageptr);
1176 /* Initialise Tx Ring */
1177 lp->txrcommit = 0;
1178 ringptr = lp->txrhead = lp->txrtail = &(lp->txring[0]);
1179 for (i = MAX_TX_PDL - 1; i >= 0; i--) {
1180 lp->txring[i].next = ringptr;
1181 ringptr = &(lp->txring[i]);
1182 pageptr += hp100_init_txpdl(dev, ringptr, pageptr);
1188 /* These functions "format" the entries in the pdl structure */
1189 /* They return how much memory the fragments need. */
1190 static int hp100_init_rxpdl(struct net_device *dev,
1191 register hp100_ring_t * ringptr,
1192 register u32 * pdlptr)
1194 /* pdlptr is starting address for this pdl */
1196 if (0 != (((unsigned long) pdlptr) & 0xf))
1197 printk("hp100: %s: Init rxpdl: Unaligned pdlptr 0x%lx.\n",
1198 dev->name, (unsigned long) pdlptr);
1200 ringptr->pdl = pdlptr + 1;
1201 ringptr->pdl_paddr = virt_to_whatever(dev, pdlptr + 1);
1202 ringptr->skb = (void *) NULL;
1204 /*
1205 * Write address and length of first PDL Fragment (which is used for
1206 * storing the RX-Header
1207 * We use the 4 bytes _before_ the PDH in the pdl memory area to
1208 * store this information. (PDH is at offset 0x04)
1209 */
1210 /* Note that pdlptr+1 and not pdlptr is the pointer to the PDH */
1212 *(pdlptr + 2) = (u_int) virt_to_whatever(dev, pdlptr); /* Address Frag 1 */
1213 *(pdlptr + 3) = 4; /* Length Frag 1 */
1215 return ((((MAX_RX_FRAG * 2 + 2) + 3) / 4) * 4);
1219 static int hp100_init_txpdl(struct net_device *dev,
1220 register hp100_ring_t * ringptr,
1221 register u32 * pdlptr)
1223 if (0 != (((unsigned long) pdlptr) & 0xf))
1224 printk("hp100: %s: Init txpdl: Unaligned pdlptr 0x%lx.\n", dev->name, (unsigned long) pdlptr);
1226 ringptr->pdl = pdlptr; /* +1; */
1227 ringptr->pdl_paddr = virt_to_whatever(dev, pdlptr); /* +1 */
1228 ringptr->skb = (void *) NULL;
1230 return ((((MAX_TX_FRAG * 2 + 2) + 3) / 4) * 4);
1233 /*
1234 * hp100_build_rx_pdl allocates an skb_buff of maximum size plus two bytes
1235 * for possible odd word alignment rounding up to next dword and set PDL
1236 * address for fragment#2
1237 * Returns: 0 if unable to allocate skb_buff
1238 * 1 if successful
1239 */
1240 static int hp100_build_rx_pdl(hp100_ring_t * ringptr,
1241 struct net_device *dev)
1243 #ifdef HP100_DEBUG_B
1244 int ioaddr = dev->base_addr;
1245 #endif
1246 #ifdef HP100_DEBUG_BM
1247 u_int *p;
1248 #endif
1250 #ifdef HP100_DEBUG_B
1251 hp100_outw(0x4207, TRACE);
1252 printk("hp100: %s: build rx pdl\n", dev->name);
1253 #endif
1255 /* Allocate skb buffer of maximum size */
1256 /* Note: This depends on the alloc_skb functions allocating more
1257 * space than requested, i.e. aligning to 16bytes */
1259 ringptr->skb = dev_alloc_skb(((MAX_ETHER_SIZE + 2 + 3) / 4) * 4);
1261 if (NULL != ringptr->skb) {
1262 /*
1263 * Reserve 2 bytes at the head of the buffer to land the IP header
1264 * on a long word boundary (According to the Network Driver section
1265 * in the Linux KHG, this should help to increase performance.)
1266 */
1267 skb_reserve(ringptr->skb, 2);
1269 ringptr->skb->dev = dev;
1270 ringptr->skb->data = (u_char *) skb_put(ringptr->skb, MAX_ETHER_SIZE);
1272 /* ringptr->pdl points to the beginning of the PDL, i.e. the PDH */
1273 /* Note: 1st Fragment is used for the 4 byte packet status
1274 * (receive header). Its PDL entries are set up by init_rxpdl. So
1275 * here we only have to set up the PDL fragment entries for the data
1276 * part. Those 4 bytes will be stored in the DMA memory region
1277 * directly before the PDL.
1278 */
1279 #ifdef HP100_DEBUG_BM
1280 printk("hp100: %s: build_rx_pdl: PDH@0x%x, skb->data (len %d) at 0x%x\n",
1281 dev->name, (u_int) ringptr->pdl,
1282 ((MAX_ETHER_SIZE + 2 + 3) / 4) * 4,
1283 (unsigned int) ringptr->skb->data);
1284 #endif
1286 /* Conversion to new PCI API : map skbuf data to PCI bus.
1287 * Doc says it's OK for EISA as well - Jean II */
1288 ringptr->pdl[0] = 0x00020000; /* Write PDH */
1289 ringptr->pdl[3] = pdl_map_data(netdev_priv(dev),
1290 ringptr->skb->data);
1291 ringptr->pdl[4] = MAX_ETHER_SIZE; /* Length of Data */
1293 #ifdef HP100_DEBUG_BM
1294 for (p = (ringptr->pdl); p < (ringptr->pdl + 5); p++)
1295 printk("hp100: %s: Adr 0x%.8x = 0x%.8x\n", dev->name, (u_int) p, (u_int) * p);
1296 #endif
1297 return (1);
1299 /* else: */
1300 /* alloc_skb failed (no memory) -> still can receive the header
1301 * fragment into PDL memory. make PDL safe by clearing msgptr and
1302 * making the PDL only 1 fragment (i.e. the 4 byte packet status)
1303 */
1304 #ifdef HP100_DEBUG_BM
1305 printk("hp100: %s: build_rx_pdl: PDH@0x%x, No space for skb.\n", dev->name, (u_int) ringptr->pdl);
1306 #endif
1308 ringptr->pdl[0] = 0x00010000; /* PDH: Count=1 Fragment */
1310 return (0);
1313 /*
1314 * hp100_rxfill - attempt to fill the Rx Ring will empty skb's
1316 * Makes assumption that skb's are always contiguous memory areas and
1317 * therefore PDLs contain only 2 physical fragments.
1318 * - While the number of Rx PDLs with buffers is less than maximum
1319 * a. Get a maximum packet size skb
1320 * b. Put the physical address of the buffer into the PDL.
1321 * c. Output physical address of PDL to adapter.
1322 */
1323 static void hp100_rxfill(struct net_device *dev)
1325 int ioaddr = dev->base_addr;
1327 struct hp100_private *lp = netdev_priv(dev);
1328 hp100_ring_t *ringptr;
1330 #ifdef HP100_DEBUG_B
1331 hp100_outw(0x4208, TRACE);
1332 printk("hp100: %s: rxfill\n", dev->name);
1333 #endif
1335 hp100_page(PERFORMANCE);
1337 while (lp->rxrcommit < MAX_RX_PDL) {
1338 /*
1339 ** Attempt to get a buffer and build a Rx PDL.
1340 */
1341 ringptr = lp->rxrtail;
1342 if (0 == hp100_build_rx_pdl(ringptr, dev)) {
1343 return; /* None available, return */
1346 /* Hand this PDL over to the card */
1347 /* Note: This needs performance page selected! */
1348 #ifdef HP100_DEBUG_BM
1349 printk("hp100: %s: rxfill: Hand to card: pdl #%d @0x%x phys:0x%x, buffer: 0x%x\n",
1350 dev->name, lp->rxrcommit, (u_int) ringptr->pdl,
1351 (u_int) ringptr->pdl_paddr, (u_int) ringptr->pdl[3]);
1352 #endif
1354 hp100_outl((u32) ringptr->pdl_paddr, RX_PDA);
1356 lp->rxrcommit += 1;
1357 lp->rxrtail = ringptr->next;
1361 /*
1362 * BM_shutdown - shutdown bus mastering and leave chip in reset state
1363 */
1365 static void hp100_BM_shutdown(struct net_device *dev)
1367 int ioaddr = dev->base_addr;
1368 struct hp100_private *lp = netdev_priv(dev);
1369 unsigned long time;
1371 #ifdef HP100_DEBUG_B
1372 hp100_outw(0x4209, TRACE);
1373 printk("hp100: %s: bm shutdown\n", dev->name);
1374 #endif
1376 hp100_page(PERFORMANCE);
1377 hp100_outw(0xfefe, IRQ_MASK); /* mask off all ints */
1378 hp100_outw(0xffff, IRQ_STATUS); /* Ack all ints */
1380 /* Ensure Interrupts are off */
1381 hp100_outw(HP100_INT_EN | HP100_RESET_LB, OPTION_LSW);
1383 /* Disable all MAC activity */
1384 hp100_page(MAC_CTRL);
1385 hp100_andb(~(HP100_RX_EN | HP100_TX_EN), MAC_CFG_1); /* stop rx/tx */
1387 /* If cascade MMU is not already in reset */
1388 if (0 != (hp100_inw(OPTION_LSW) & HP100_HW_RST)) {
1389 /* Wait 1.3ms (10Mb max packet time) to ensure MAC is idle so
1390 * MMU pointers will not be reset out from underneath
1391 */
1392 hp100_page(MAC_CTRL);
1393 for (time = 0; time < 5000; time++) {
1394 if ((hp100_inb(MAC_CFG_1) & (HP100_TX_IDLE | HP100_RX_IDLE)) == (HP100_TX_IDLE | HP100_RX_IDLE))
1395 break;
1398 /* Shutdown algorithm depends on the generation of Cascade */
1399 if (lp->chip == HP100_CHIPID_LASSEN) { /* ETR shutdown/reset */
1400 /* Disable Busmaster mode and wait for bit to go to zero. */
1401 hp100_page(HW_MAP);
1402 hp100_andb(~HP100_BM_MASTER, BM);
1403 /* 100 ms timeout */
1404 for (time = 0; time < 32000; time++) {
1405 if (0 == (hp100_inb(BM) & HP100_BM_MASTER))
1406 break;
1408 } else { /* Shasta or Rainier Shutdown/Reset */
1409 /* To ensure all bus master inloading activity has ceased,
1410 * wait for no Rx PDAs or no Rx packets on card.
1411 */
1412 hp100_page(PERFORMANCE);
1413 /* 100 ms timeout */
1414 for (time = 0; time < 10000; time++) {
1415 /* RX_PDL: PDLs not executed. */
1416 /* RX_PKT_CNT: RX'd packets on card. */
1417 if ((hp100_inb(RX_PDL) == 0) && (hp100_inb(RX_PKT_CNT) == 0))
1418 break;
1421 if (time >= 10000)
1422 printk("hp100: %s: BM shutdown error.\n", dev->name);
1424 /* To ensure all bus master outloading activity has ceased,
1425 * wait until the Tx PDA count goes to zero or no more Tx space
1426 * available in the Tx region of the card.
1427 */
1428 /* 100 ms timeout */
1429 for (time = 0; time < 10000; time++) {
1430 if ((0 == hp100_inb(TX_PKT_CNT)) &&
1431 (0 != (hp100_inb(TX_MEM_FREE) & HP100_AUTO_COMPARE)))
1432 break;
1435 /* Disable Busmaster mode */
1436 hp100_page(HW_MAP);
1437 hp100_andb(~HP100_BM_MASTER, BM);
1438 } /* end of shutdown procedure for non-etr parts */
1440 hp100_cascade_reset(dev, 1);
1442 hp100_page(PERFORMANCE);
1443 /* hp100_outw( HP100_BM_READ | HP100_BM_WRITE | HP100_RESET_HB, OPTION_LSW ); */
1444 /* Busmaster mode should be shut down now. */
1447 static int hp100_check_lan(struct net_device *dev)
1449 struct hp100_private *lp = netdev_priv(dev);
1451 if (lp->lan_type < 0) { /* no LAN type detected yet? */
1452 hp100_stop_interface(dev);
1453 if ((lp->lan_type = hp100_sense_lan(dev)) < 0) {
1454 printk("hp100: %s: no connection found - check wire\n", dev->name);
1455 hp100_start_interface(dev); /* 10Mb/s RX packets maybe handled */
1456 return -EIO;
1458 if (lp->lan_type == HP100_LAN_100)
1459 lp->hub_status = hp100_login_to_vg_hub(dev, 0); /* relogin */
1460 hp100_start_interface(dev);
1462 return 0;
1465 /*
1466 * transmit functions
1467 */
1469 /* tx function for busmaster mode */
1470 static int hp100_start_xmit_bm(struct sk_buff *skb, struct net_device *dev)
1472 unsigned long flags;
1473 int i, ok_flag;
1474 int ioaddr = dev->base_addr;
1475 struct hp100_private *lp = netdev_priv(dev);
1476 hp100_ring_t *ringptr;
1478 #ifdef HP100_DEBUG_B
1479 hp100_outw(0x4210, TRACE);
1480 printk("hp100: %s: start_xmit_bm\n", dev->name);
1481 #endif
1483 if (skb == NULL) {
1484 return 0;
1487 if (skb->len <= 0)
1488 return 0;
1490 if (lp->chip == HP100_CHIPID_SHASTA && skb_padto(skb, ETH_ZLEN))
1491 return 0;
1493 /* Get Tx ring tail pointer */
1494 if (lp->txrtail->next == lp->txrhead) {
1495 /* No memory. */
1496 #ifdef HP100_DEBUG
1497 printk("hp100: %s: start_xmit_bm: No TX PDL available.\n", dev->name);
1498 #endif
1499 /* not waited long enough since last tx? */
1500 if (time_before(jiffies, dev->trans_start + HZ))
1501 return -EAGAIN;
1503 if (hp100_check_lan(dev))
1504 return -EIO;
1506 if (lp->lan_type == HP100_LAN_100 && lp->hub_status < 0) {
1507 /* we have a 100Mb/s adapter but it isn't connected to hub */
1508 printk("hp100: %s: login to 100Mb/s hub retry\n", dev->name);
1509 hp100_stop_interface(dev);
1510 lp->hub_status = hp100_login_to_vg_hub(dev, 0);
1511 hp100_start_interface(dev);
1512 } else {
1513 spin_lock_irqsave(&lp->lock, flags);
1514 hp100_ints_off(); /* Useful ? Jean II */
1515 i = hp100_sense_lan(dev);
1516 hp100_ints_on();
1517 spin_unlock_irqrestore(&lp->lock, flags);
1518 if (i == HP100_LAN_ERR)
1519 printk("hp100: %s: link down detected\n", dev->name);
1520 else if (lp->lan_type != i) { /* cable change! */
1521 /* it's very hard - all network settings must be changed!!! */
1522 printk("hp100: %s: cable change 10Mb/s <-> 100Mb/s detected\n", dev->name);
1523 lp->lan_type = i;
1524 hp100_stop_interface(dev);
1525 if (lp->lan_type == HP100_LAN_100)
1526 lp->hub_status = hp100_login_to_vg_hub(dev, 0);
1527 hp100_start_interface(dev);
1528 } else {
1529 printk("hp100: %s: interface reset\n", dev->name);
1530 hp100_stop_interface(dev);
1531 if (lp->lan_type == HP100_LAN_100)
1532 lp->hub_status = hp100_login_to_vg_hub(dev, 0);
1533 hp100_start_interface(dev);
1537 dev->trans_start = jiffies;
1538 return -EAGAIN;
1541 /*
1542 * we have to turn int's off before modifying this, otherwise
1543 * a tx_pdl_cleanup could occur at the same time
1544 */
1545 spin_lock_irqsave(&lp->lock, flags);
1546 ringptr = lp->txrtail;
1547 lp->txrtail = ringptr->next;
1549 /* Check whether packet has minimal packet size */
1550 ok_flag = skb->len >= HP100_MIN_PACKET_SIZE;
1551 i = ok_flag ? skb->len : HP100_MIN_PACKET_SIZE;
1553 ringptr->skb = skb;
1554 ringptr->pdl[0] = ((1 << 16) | i); /* PDH: 1 Fragment & length */
1555 if (lp->chip == HP100_CHIPID_SHASTA) {
1556 /* TODO:Could someone who has the EISA card please check if this works? */
1557 ringptr->pdl[2] = i;
1558 } else { /* Lassen */
1559 /* In the PDL, don't use the padded size but the real packet size: */
1560 ringptr->pdl[2] = skb->len; /* 1st Frag: Length of frag */
1562 /* Conversion to new PCI API : map skbuf data to PCI bus.
1563 * Doc says it's OK for EISA as well - Jean II */
1564 ringptr->pdl[1] = ((u32) pci_map_single(lp->pci_dev, skb->data, ringptr->pdl[2], PCI_DMA_TODEVICE)); /* 1st Frag: Adr. of data */
1566 /* Hand this PDL to the card. */
1567 hp100_outl(ringptr->pdl_paddr, TX_PDA_L); /* Low Prio. Queue */
1569 lp->txrcommit++;
1570 spin_unlock_irqrestore(&lp->lock, flags);
1572 /* Update statistics */
1573 lp->stats.tx_packets++;
1574 lp->stats.tx_bytes += skb->len;
1575 dev->trans_start = jiffies;
1577 return 0;
1581 /* clean_txring checks if packets have been sent by the card by reading
1582 * the TX_PDL register from the performance page and comparing it to the
1583 * number of commited packets. It then frees the skb's of the packets that
1584 * obviously have been sent to the network.
1586 * Needs the PERFORMANCE page selected.
1587 */
1588 static void hp100_clean_txring(struct net_device *dev)
1590 struct hp100_private *lp = netdev_priv(dev);
1591 int ioaddr = dev->base_addr;
1592 int donecount;
1594 #ifdef HP100_DEBUG_B
1595 hp100_outw(0x4211, TRACE);
1596 printk("hp100: %s: clean txring\n", dev->name);
1597 #endif
1599 /* How many PDLs have been transmitted? */
1600 donecount = (lp->txrcommit) - hp100_inb(TX_PDL);
1602 #ifdef HP100_DEBUG
1603 if (donecount > MAX_TX_PDL)
1604 printk("hp100: %s: Warning: More PDLs transmitted than commited to card???\n", dev->name);
1605 #endif
1607 for (; 0 != donecount; donecount--) {
1608 #ifdef HP100_DEBUG_BM
1609 printk("hp100: %s: Free skb: data @0x%.8x txrcommit=0x%x TXPDL=0x%x, done=0x%x\n",
1610 dev->name, (u_int) lp->txrhead->skb->data,
1611 lp->txrcommit, hp100_inb(TX_PDL), donecount);
1612 #endif
1613 /* Conversion to new PCI API : NOP */
1614 pci_unmap_single(lp->pci_dev, (dma_addr_t) lp->txrhead->pdl[1], lp->txrhead->pdl[2], PCI_DMA_TODEVICE);
1615 dev_kfree_skb_any(lp->txrhead->skb);
1616 lp->txrhead->skb = (void *) NULL;
1617 lp->txrhead = lp->txrhead->next;
1618 lp->txrcommit--;
1622 /* tx function for slave modes */
1623 static int hp100_start_xmit(struct sk_buff *skb, struct net_device *dev)
1625 unsigned long flags;
1626 int i, ok_flag;
1627 int ioaddr = dev->base_addr;
1628 u_short val;
1629 struct hp100_private *lp = netdev_priv(dev);
1631 #ifdef HP100_DEBUG_B
1632 hp100_outw(0x4212, TRACE);
1633 printk("hp100: %s: start_xmit\n", dev->name);
1634 #endif
1636 if (skb == NULL) {
1637 return 0;
1640 if (skb->len <= 0)
1641 return 0;
1643 if (hp100_check_lan(dev))
1644 return -EIO;
1646 /* If there is not enough free memory on the card... */
1647 i = hp100_inl(TX_MEM_FREE) & 0x7fffffff;
1648 if (!(((i / 2) - 539) > (skb->len + 16) && (hp100_inb(TX_PKT_CNT) < 255))) {
1649 #ifdef HP100_DEBUG
1650 printk("hp100: %s: start_xmit: tx free mem = 0x%x\n", dev->name, i);
1651 #endif
1652 /* not waited long enough since last failed tx try? */
1653 if (time_before(jiffies, dev->trans_start + HZ)) {
1654 #ifdef HP100_DEBUG
1655 printk("hp100: %s: trans_start timing problem\n",
1656 dev->name);
1657 #endif
1658 return -EAGAIN;
1660 if (lp->lan_type == HP100_LAN_100 && lp->hub_status < 0) {
1661 /* we have a 100Mb/s adapter but it isn't connected to hub */
1662 printk("hp100: %s: login to 100Mb/s hub retry\n", dev->name);
1663 hp100_stop_interface(dev);
1664 lp->hub_status = hp100_login_to_vg_hub(dev, 0);
1665 hp100_start_interface(dev);
1666 } else {
1667 spin_lock_irqsave(&lp->lock, flags);
1668 hp100_ints_off(); /* Useful ? Jean II */
1669 i = hp100_sense_lan(dev);
1670 hp100_ints_on();
1671 spin_unlock_irqrestore(&lp->lock, flags);
1672 if (i == HP100_LAN_ERR)
1673 printk("hp100: %s: link down detected\n", dev->name);
1674 else if (lp->lan_type != i) { /* cable change! */
1675 /* it's very hard - all network setting must be changed!!! */
1676 printk("hp100: %s: cable change 10Mb/s <-> 100Mb/s detected\n", dev->name);
1677 lp->lan_type = i;
1678 hp100_stop_interface(dev);
1679 if (lp->lan_type == HP100_LAN_100)
1680 lp->hub_status = hp100_login_to_vg_hub(dev, 0);
1681 hp100_start_interface(dev);
1682 } else {
1683 printk("hp100: %s: interface reset\n", dev->name);
1684 hp100_stop_interface(dev);
1685 if (lp->lan_type == HP100_LAN_100)
1686 lp->hub_status = hp100_login_to_vg_hub(dev, 0);
1687 hp100_start_interface(dev);
1688 mdelay(1);
1691 dev->trans_start = jiffies;
1692 return -EAGAIN;
1695 for (i = 0; i < 6000 && (hp100_inb(OPTION_MSW) & HP100_TX_CMD); i++) {
1696 #ifdef HP100_DEBUG_TX
1697 printk("hp100: %s: start_xmit: busy\n", dev->name);
1698 #endif
1701 spin_lock_irqsave(&lp->lock, flags);
1702 hp100_ints_off();
1703 val = hp100_inw(IRQ_STATUS);
1704 /* Ack / clear the interrupt TX_COMPLETE interrupt - this interrupt is set
1705 * when the current packet being transmitted on the wire is completed. */
1706 hp100_outw(HP100_TX_COMPLETE, IRQ_STATUS);
1707 #ifdef HP100_DEBUG_TX
1708 printk("hp100: %s: start_xmit: irq_status=0x%.4x, irqmask=0x%.4x, len=%d\n",
1709 dev->name, val, hp100_inw(IRQ_MASK), (int) skb->len);
1710 #endif
1712 ok_flag = skb->len >= HP100_MIN_PACKET_SIZE;
1713 i = ok_flag ? skb->len : HP100_MIN_PACKET_SIZE;
1715 hp100_outw(i, DATA32); /* tell card the total packet length */
1716 hp100_outw(i, FRAGMENT_LEN); /* and first/only fragment length */
1718 if (lp->mode == 2) { /* memory mapped */
1719 /* Note: The J2585B needs alignment to 32bits here! */
1720 memcpy_toio(lp->mem_ptr_virt, skb->data, (skb->len + 3) & ~3);
1721 if (!ok_flag)
1722 memset_io(lp->mem_ptr_virt, 0, HP100_MIN_PACKET_SIZE - skb->len);
1723 } else { /* programmed i/o */
1724 outsl(ioaddr + HP100_REG_DATA32, skb->data,
1725 (skb->len + 3) >> 2);
1726 if (!ok_flag)
1727 for (i = (skb->len + 3) & ~3; i < HP100_MIN_PACKET_SIZE; i += 4)
1728 hp100_outl(0, DATA32);
1731 hp100_outb(HP100_TX_CMD | HP100_SET_LB, OPTION_MSW); /* send packet */
1733 lp->stats.tx_packets++;
1734 lp->stats.tx_bytes += skb->len;
1735 dev->trans_start = jiffies;
1736 hp100_ints_on();
1737 spin_unlock_irqrestore(&lp->lock, flags);
1739 dev_kfree_skb_any(skb);
1741 #ifdef HP100_DEBUG_TX
1742 printk("hp100: %s: start_xmit: end\n", dev->name);
1743 #endif
1745 return 0;
1749 /*
1750 * Receive Function (Non-Busmaster mode)
1751 * Called when an "Receive Packet" interrupt occurs, i.e. the receive
1752 * packet counter is non-zero.
1753 * For non-busmaster, this function does the whole work of transfering
1754 * the packet to the host memory and then up to higher layers via skb
1755 * and netif_rx.
1756 */
1758 static void hp100_rx(struct net_device *dev)
1760 int packets, pkt_len;
1761 int ioaddr = dev->base_addr;
1762 struct hp100_private *lp = netdev_priv(dev);
1763 u_int header;
1764 struct sk_buff *skb;
1766 #ifdef DEBUG_B
1767 hp100_outw(0x4213, TRACE);
1768 printk("hp100: %s: rx\n", dev->name);
1769 #endif
1771 /* First get indication of received lan packet */
1772 /* RX_PKT_CND indicates the number of packets which have been fully */
1773 /* received onto the card but have not been fully transferred of the card */
1774 packets = hp100_inb(RX_PKT_CNT);
1775 #ifdef HP100_DEBUG_RX
1776 if (packets > 1)
1777 printk("hp100: %s: rx: waiting packets = %d\n", dev->name, packets);
1778 #endif
1780 while (packets-- > 0) {
1781 /* If ADV_NXT_PKT is still set, we have to wait until the card has */
1782 /* really advanced to the next packet. */
1783 for (pkt_len = 0; pkt_len < 6000 && (hp100_inb(OPTION_MSW) & HP100_ADV_NXT_PKT); pkt_len++) {
1784 #ifdef HP100_DEBUG_RX
1785 printk ("hp100: %s: rx: busy, remaining packets = %d\n", dev->name, packets);
1786 #endif
1789 /* First we get the header, which contains information about the */
1790 /* actual length of the received packet. */
1791 if (lp->mode == 2) { /* memory mapped mode */
1792 header = readl(lp->mem_ptr_virt);
1793 } else /* programmed i/o */
1794 header = hp100_inl(DATA32);
1796 pkt_len = ((header & HP100_PKT_LEN_MASK) + 3) & ~3;
1798 #ifdef HP100_DEBUG_RX
1799 printk("hp100: %s: rx: new packet - length=%d, errors=0x%x, dest=0x%x\n",
1800 dev->name, header & HP100_PKT_LEN_MASK,
1801 (header >> 16) & 0xfff8, (header >> 16) & 7);
1802 #endif
1804 /* Now we allocate the skb and transfer the data into it. */
1805 skb = dev_alloc_skb(pkt_len+2);
1806 if (skb == NULL) { /* Not enough memory->drop packet */
1807 #ifdef HP100_DEBUG
1808 printk("hp100: %s: rx: couldn't allocate a sk_buff of size %d\n",
1809 dev->name, pkt_len);
1810 #endif
1811 lp->stats.rx_dropped++;
1812 } else { /* skb successfully allocated */
1814 u_char *ptr;
1816 skb_reserve(skb,2);
1817 skb->dev = dev;
1819 /* ptr to start of the sk_buff data area */
1820 skb_put(skb, pkt_len);
1821 ptr = skb->data;
1823 /* Now transfer the data from the card into that area */
1824 if (lp->mode == 2)
1825 memcpy_fromio(ptr, lp->mem_ptr_virt,pkt_len);
1826 else /* io mapped */
1827 insl(ioaddr + HP100_REG_DATA32, ptr, pkt_len >> 2);
1829 skb->protocol = eth_type_trans(skb, dev);
1831 #ifdef HP100_DEBUG_RX
1832 printk("hp100: %s: rx: %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x\n",
1833 dev->name, ptr[0], ptr[1], ptr[2], ptr[3],
1834 ptr[4], ptr[5], ptr[6], ptr[7], ptr[8],
1835 ptr[9], ptr[10], ptr[11]);
1836 #endif
1837 netif_rx(skb);
1838 dev->last_rx = jiffies;
1839 lp->stats.rx_packets++;
1840 lp->stats.rx_bytes += pkt_len;
1843 /* Indicate the card that we have got the packet */
1844 hp100_outb(HP100_ADV_NXT_PKT | HP100_SET_LB, OPTION_MSW);
1846 switch (header & 0x00070000) {
1847 case (HP100_MULTI_ADDR_HASH << 16):
1848 case (HP100_MULTI_ADDR_NO_HASH << 16):
1849 lp->stats.multicast++;
1850 break;
1852 } /* end of while(there are packets) loop */
1853 #ifdef HP100_DEBUG_RX
1854 printk("hp100_rx: %s: end\n", dev->name);
1855 #endif
1858 /*
1859 * Receive Function for Busmaster Mode
1860 */
1861 static void hp100_rx_bm(struct net_device *dev)
1863 int ioaddr = dev->base_addr;
1864 struct hp100_private *lp = netdev_priv(dev);
1865 hp100_ring_t *ptr;
1866 u_int header;
1867 int pkt_len;
1869 #ifdef HP100_DEBUG_B
1870 hp100_outw(0x4214, TRACE);
1871 printk("hp100: %s: rx_bm\n", dev->name);
1872 #endif
1874 #ifdef HP100_DEBUG
1875 if (0 == lp->rxrcommit) {
1876 printk("hp100: %s: rx_bm called although no PDLs were committed to adapter?\n", dev->name);
1877 return;
1878 } else
1879 /* RX_PKT_CNT states how many PDLs are currently formatted and available to
1880 * the cards BM engine */
1881 if ((hp100_inw(RX_PKT_CNT) & 0x00ff) >= lp->rxrcommit) {
1882 printk("hp100: %s: More packets received than commited? RX_PKT_CNT=0x%x, commit=0x%x\n",
1883 dev->name, hp100_inw(RX_PKT_CNT) & 0x00ff,
1884 lp->rxrcommit);
1885 return;
1887 #endif
1889 while ((lp->rxrcommit > hp100_inb(RX_PDL))) {
1890 /*
1891 * The packet was received into the pdl pointed to by lp->rxrhead (
1892 * the oldest pdl in the ring
1893 */
1895 /* First we get the header, which contains information about the */
1896 /* actual length of the received packet. */
1898 ptr = lp->rxrhead;
1900 header = *(ptr->pdl - 1);
1901 pkt_len = (header & HP100_PKT_LEN_MASK);
1903 /* Conversion to new PCI API : NOP */
1904 pci_unmap_single(lp->pci_dev, (dma_addr_t) ptr->pdl[3], MAX_ETHER_SIZE, PCI_DMA_FROMDEVICE);
1906 #ifdef HP100_DEBUG_BM
1907 printk("hp100: %s: rx_bm: header@0x%x=0x%x length=%d, errors=0x%x, dest=0x%x\n",
1908 dev->name, (u_int) (ptr->pdl - 1), (u_int) header,
1909 pkt_len, (header >> 16) & 0xfff8, (header >> 16) & 7);
1910 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",
1911 dev->name, hp100_inb(RX_PDL), hp100_inb(TX_PDL),
1912 hp100_inb(RX_PKT_CNT), (u_int) * (ptr->pdl),
1913 (u_int) * (ptr->pdl + 3), (u_int) * (ptr->pdl + 4));
1914 #endif
1916 if ((pkt_len >= MIN_ETHER_SIZE) &&
1917 (pkt_len <= MAX_ETHER_SIZE)) {
1918 if (ptr->skb == NULL) {
1919 printk("hp100: %s: rx_bm: skb null\n", dev->name);
1920 /* can happen if we only allocated room for the pdh due to memory shortage. */
1921 lp->stats.rx_dropped++;
1922 } else {
1923 skb_trim(ptr->skb, pkt_len); /* Shorten it */
1924 ptr->skb->protocol =
1925 eth_type_trans(ptr->skb, dev);
1927 netif_rx(ptr->skb); /* Up and away... */
1929 dev->last_rx = jiffies;
1930 lp->stats.rx_packets++;
1931 lp->stats.rx_bytes += pkt_len;
1934 switch (header & 0x00070000) {
1935 case (HP100_MULTI_ADDR_HASH << 16):
1936 case (HP100_MULTI_ADDR_NO_HASH << 16):
1937 lp->stats.multicast++;
1938 break;
1940 } else {
1941 #ifdef HP100_DEBUG
1942 printk("hp100: %s: rx_bm: Received bad packet (length=%d)\n", dev->name, pkt_len);
1943 #endif
1944 if (ptr->skb != NULL)
1945 dev_kfree_skb_any(ptr->skb);
1946 lp->stats.rx_errors++;
1949 lp->rxrhead = lp->rxrhead->next;
1951 /* Allocate a new rx PDL (so lp->rxrcommit stays the same) */
1952 if (0 == hp100_build_rx_pdl(lp->rxrtail, dev)) {
1953 /* No space for skb, header can still be received. */
1954 #ifdef HP100_DEBUG
1955 printk("hp100: %s: rx_bm: No space for new PDL.\n", dev->name);
1956 #endif
1957 return;
1958 } else { /* successfully allocated new PDL - put it in ringlist at tail. */
1959 hp100_outl((u32) lp->rxrtail->pdl_paddr, RX_PDA);
1960 lp->rxrtail = lp->rxrtail->next;
1966 /*
1967 * statistics
1968 */
1969 static struct net_device_stats *hp100_get_stats(struct net_device *dev)
1971 unsigned long flags;
1972 int ioaddr = dev->base_addr;
1973 struct hp100_private *lp = netdev_priv(dev);
1975 #ifdef HP100_DEBUG_B
1976 hp100_outw(0x4215, TRACE);
1977 #endif
1979 spin_lock_irqsave(&lp->lock, flags);
1980 hp100_ints_off(); /* Useful ? Jean II */
1981 hp100_update_stats(dev);
1982 hp100_ints_on();
1983 spin_unlock_irqrestore(&lp->lock, flags);
1984 return &(lp->stats);
1987 static void hp100_update_stats(struct net_device *dev)
1989 int ioaddr = dev->base_addr;
1990 u_short val;
1991 struct hp100_private *lp = netdev_priv(dev);
1993 #ifdef HP100_DEBUG_B
1994 hp100_outw(0x4216, TRACE);
1995 printk("hp100: %s: update-stats\n", dev->name);
1996 #endif
1998 /* Note: Statistics counters clear when read. */
1999 hp100_page(MAC_CTRL);
2000 val = hp100_inw(DROPPED) & 0x0fff;
2001 lp->stats.rx_errors += val;
2002 lp->stats.rx_over_errors += val;
2003 val = hp100_inb(CRC);
2004 lp->stats.rx_errors += val;
2005 lp->stats.rx_crc_errors += val;
2006 val = hp100_inb(ABORT);
2007 lp->stats.tx_errors += val;
2008 lp->stats.tx_aborted_errors += val;
2009 hp100_page(PERFORMANCE);
2012 static void hp100_misc_interrupt(struct net_device *dev)
2014 #ifdef HP100_DEBUG_B
2015 int ioaddr = dev->base_addr;
2016 #endif
2017 struct hp100_private *lp = netdev_priv(dev);
2019 #ifdef HP100_DEBUG_B
2020 int ioaddr = dev->base_addr;
2021 hp100_outw(0x4216, TRACE);
2022 printk("hp100: %s: misc_interrupt\n", dev->name);
2023 #endif
2025 /* Note: Statistics counters clear when read. */
2026 lp->stats.rx_errors++;
2027 lp->stats.tx_errors++;
2030 static void hp100_clear_stats(struct hp100_private *lp, int ioaddr)
2032 unsigned long flags;
2034 #ifdef HP100_DEBUG_B
2035 hp100_outw(0x4217, TRACE);
2036 printk("hp100: %s: clear_stats\n", dev->name);
2037 #endif
2039 spin_lock_irqsave(&lp->lock, flags);
2040 hp100_page(MAC_CTRL); /* get all statistics bytes */
2041 hp100_inw(DROPPED);
2042 hp100_inb(CRC);
2043 hp100_inb(ABORT);
2044 hp100_page(PERFORMANCE);
2045 spin_unlock_irqrestore(&lp->lock, flags);
2049 /*
2050 * multicast setup
2051 */
2053 /*
2054 * Set or clear the multicast filter for this adapter.
2055 */
2057 static void hp100_set_multicast_list(struct net_device *dev)
2059 unsigned long flags;
2060 int ioaddr = dev->base_addr;
2061 struct hp100_private *lp = netdev_priv(dev);
2063 #ifdef HP100_DEBUG_B
2064 hp100_outw(0x4218, TRACE);
2065 printk("hp100: %s: set_mc_list\n", dev->name);
2066 #endif
2068 spin_lock_irqsave(&lp->lock, flags);
2069 hp100_ints_off();
2070 hp100_page(MAC_CTRL);
2071 hp100_andb(~(HP100_RX_EN | HP100_TX_EN), MAC_CFG_1); /* stop rx/tx */
2073 if (dev->flags & IFF_PROMISC) {
2074 lp->mac2_mode = HP100_MAC2MODE6; /* promiscuous mode = get all good */
2075 lp->mac1_mode = HP100_MAC1MODE6; /* packets on the net */
2076 memset(&lp->hash_bytes, 0xff, 8);
2077 } else if (dev->mc_count || (dev->flags & IFF_ALLMULTI)) {
2078 lp->mac2_mode = HP100_MAC2MODE5; /* multicast mode = get packets for */
2079 lp->mac1_mode = HP100_MAC1MODE5; /* me, broadcasts and all multicasts */
2080 #ifdef HP100_MULTICAST_FILTER /* doesn't work!!! */
2081 if (dev->flags & IFF_ALLMULTI) {
2082 /* set hash filter to receive all multicast packets */
2083 memset(&lp->hash_bytes, 0xff, 8);
2084 } else {
2085 int i, j, idx;
2086 u_char *addrs;
2087 struct dev_mc_list *dmi;
2089 memset(&lp->hash_bytes, 0x00, 8);
2090 #ifdef HP100_DEBUG
2091 printk("hp100: %s: computing hash filter - mc_count = %i\n", dev->name, dev->mc_count);
2092 #endif
2093 for (i = 0, dmi = dev->mc_list; i < dev->mc_count; i++, dmi = dmi->next) {
2094 addrs = dmi->dmi_addr;
2095 if ((*addrs & 0x01) == 0x01) { /* multicast address? */
2096 #ifdef HP100_DEBUG
2097 printk("hp100: %s: multicast = %02x:%02x:%02x:%02x:%02x:%02x, ",
2098 dev->name, addrs[0], addrs[1], addrs[2],
2099 addrs[3], addrs[4], addrs[5]);
2100 #endif
2101 for (j = idx = 0; j < 6; j++) {
2102 idx ^= *addrs++ & 0x3f;
2103 printk(":%02x:", idx);
2105 #ifdef HP100_DEBUG
2106 printk("idx = %i\n", idx);
2107 #endif
2108 lp->hash_bytes[idx >> 3] |= (1 << (idx & 7));
2112 #else
2113 memset(&lp->hash_bytes, 0xff, 8);
2114 #endif
2115 } else {
2116 lp->mac2_mode = HP100_MAC2MODE3; /* normal mode = get packets for me */
2117 lp->mac1_mode = HP100_MAC1MODE3; /* and broadcasts */
2118 memset(&lp->hash_bytes, 0x00, 8);
2121 if (((hp100_inb(MAC_CFG_1) & 0x0f) != lp->mac1_mode) ||
2122 (hp100_inb(MAC_CFG_2) != lp->mac2_mode)) {
2123 int i;
2125 hp100_outb(lp->mac2_mode, MAC_CFG_2);
2126 hp100_andb(HP100_MAC1MODEMASK, MAC_CFG_1); /* clear mac1 mode bits */
2127 hp100_orb(lp->mac1_mode, MAC_CFG_1); /* and set the new mode */
2129 hp100_page(MAC_ADDRESS);
2130 for (i = 0; i < 8; i++)
2131 hp100_outb(lp->hash_bytes[i], HASH_BYTE0 + i);
2132 #ifdef HP100_DEBUG
2133 printk("hp100: %s: mac1 = 0x%x, mac2 = 0x%x, multicast hash = %02x:%02x:%02x:%02x:%02x:%02x:%02x:%02x\n",
2134 dev->name, lp->mac1_mode, lp->mac2_mode,
2135 lp->hash_bytes[0], lp->hash_bytes[1],
2136 lp->hash_bytes[2], lp->hash_bytes[3],
2137 lp->hash_bytes[4], lp->hash_bytes[5],
2138 lp->hash_bytes[6], lp->hash_bytes[7]);
2139 #endif
2141 if (lp->lan_type == HP100_LAN_100) {
2142 #ifdef HP100_DEBUG
2143 printk("hp100: %s: 100VG MAC settings have changed - relogin.\n", dev->name);
2144 #endif
2145 lp->hub_status = hp100_login_to_vg_hub(dev, 1); /* force a relogin to the hub */
2147 } else {
2148 int i;
2149 u_char old_hash_bytes[8];
2151 hp100_page(MAC_ADDRESS);
2152 for (i = 0; i < 8; i++)
2153 old_hash_bytes[i] = hp100_inb(HASH_BYTE0 + i);
2154 if (memcmp(old_hash_bytes, &lp->hash_bytes, 8)) {
2155 for (i = 0; i < 8; i++)
2156 hp100_outb(lp->hash_bytes[i], HASH_BYTE0 + i);
2157 #ifdef HP100_DEBUG
2158 printk("hp100: %s: multicast hash = %02x:%02x:%02x:%02x:%02x:%02x:%02x:%02x\n",
2159 dev->name, lp->hash_bytes[0],
2160 lp->hash_bytes[1], lp->hash_bytes[2],
2161 lp->hash_bytes[3], lp->hash_bytes[4],
2162 lp->hash_bytes[5], lp->hash_bytes[6],
2163 lp->hash_bytes[7]);
2164 #endif
2166 if (lp->lan_type == HP100_LAN_100) {
2167 #ifdef HP100_DEBUG
2168 printk("hp100: %s: 100VG MAC settings have changed - relogin.\n", dev->name);
2169 #endif
2170 lp->hub_status = hp100_login_to_vg_hub(dev, 1); /* force a relogin to the hub */
2175 hp100_page(MAC_CTRL);
2176 hp100_orb(HP100_RX_EN | HP100_RX_IDLE | /* enable rx */
2177 HP100_TX_EN | HP100_TX_IDLE, MAC_CFG_1); /* enable tx */
2179 hp100_page(PERFORMANCE);
2180 hp100_ints_on();
2181 spin_unlock_irqrestore(&lp->lock, flags);
2184 /*
2185 * hardware interrupt handling
2186 */
2188 static irqreturn_t hp100_interrupt(int irq, void *dev_id, struct pt_regs *regs)
2190 struct net_device *dev = (struct net_device *) dev_id;
2191 struct hp100_private *lp = netdev_priv(dev);
2193 int ioaddr;
2194 u_int val;
2196 if (dev == NULL)
2197 return IRQ_NONE;
2198 ioaddr = dev->base_addr;
2200 spin_lock(&lp->lock);
2202 hp100_ints_off();
2204 #ifdef HP100_DEBUG_B
2205 hp100_outw(0x4219, TRACE);
2206 #endif
2208 /* hp100_page( PERFORMANCE ); */
2209 val = hp100_inw(IRQ_STATUS);
2210 #ifdef HP100_DEBUG_IRQ
2211 printk("hp100: %s: mode=%x,IRQ_STAT=0x%.4x,RXPKTCNT=0x%.2x RXPDL=0x%.2x TXPKTCNT=0x%.2x TXPDL=0x%.2x\n",
2212 dev->name, lp->mode, (u_int) val, hp100_inb(RX_PKT_CNT),
2213 hp100_inb(RX_PDL), hp100_inb(TX_PKT_CNT), hp100_inb(TX_PDL));
2214 #endif
2216 if (val == 0) { /* might be a shared interrupt */
2217 spin_unlock(&lp->lock);
2218 hp100_ints_on();
2219 return IRQ_NONE;
2221 /* We're only interested in those interrupts we really enabled. */
2222 /* val &= hp100_inw( IRQ_MASK ); */
2224 /*
2225 * RX_PDL_FILL_COMPL is set whenever a RX_PDL has been executed. A RX_PDL
2226 * is considered executed whenever the RX_PDL data structure is no longer
2227 * needed.
2228 */
2229 if (val & HP100_RX_PDL_FILL_COMPL) {
2230 if (lp->mode == 1)
2231 hp100_rx_bm(dev);
2232 else {
2233 printk("hp100: %s: rx_pdl_fill_compl interrupt although not busmaster?\n", dev->name);
2237 /*
2238 * The RX_PACKET interrupt is set, when the receive packet counter is
2239 * non zero. We use this interrupt for receiving in slave mode. In
2240 * busmaster mode, we use it to make sure we did not miss any rx_pdl_fill
2241 * interrupts. If rx_pdl_fill_compl is not set and rx_packet is set, then
2242 * we somehow have missed a rx_pdl_fill_compl interrupt.
2243 */
2245 if (val & HP100_RX_PACKET) { /* Receive Packet Counter is non zero */
2246 if (lp->mode != 1) /* non busmaster */
2247 hp100_rx(dev);
2248 else if (!(val & HP100_RX_PDL_FILL_COMPL)) {
2249 /* Shouldnt happen - maybe we missed a RX_PDL_FILL Interrupt? */
2250 hp100_rx_bm(dev);
2254 /*
2255 * Ack. that we have noticed the interrupt and thereby allow next one.
2256 * Note that this is now done after the slave rx function, since first
2257 * acknowledging and then setting ADV_NXT_PKT caused an extra interrupt
2258 * on the J2573.
2259 */
2260 hp100_outw(val, IRQ_STATUS);
2262 /*
2263 * RX_ERROR is set when a packet is dropped due to no memory resources on
2264 * the card or when a RCV_ERR occurs.
2265 * TX_ERROR is set when a TX_ABORT condition occurs in the MAC->exists
2266 * only in the 802.3 MAC and happens when 16 collisions occur during a TX
2267 */
2268 if (val & (HP100_TX_ERROR | HP100_RX_ERROR)) {
2269 #ifdef HP100_DEBUG_IRQ
2270 printk("hp100: %s: TX/RX Error IRQ\n", dev->name);
2271 #endif
2272 hp100_update_stats(dev);
2273 if (lp->mode == 1) {
2274 hp100_rxfill(dev);
2275 hp100_clean_txring(dev);
2279 /*
2280 * RX_PDA_ZERO is set when the PDA count goes from non-zero to zero.
2281 */
2282 if ((lp->mode == 1) && (val & (HP100_RX_PDA_ZERO)))
2283 hp100_rxfill(dev);
2285 /*
2286 * HP100_TX_COMPLETE interrupt occurs when packet transmitted on wire
2287 * is completed
2288 */
2289 if ((lp->mode == 1) && (val & (HP100_TX_COMPLETE)))
2290 hp100_clean_txring(dev);
2292 /*
2293 * MISC_ERROR is set when either the LAN link goes down or a detected
2294 * bus error occurs.
2295 */
2296 if (val & HP100_MISC_ERROR) { /* New for J2585B */
2297 #ifdef HP100_DEBUG_IRQ
2298 printk
2299 ("hp100: %s: Misc. Error Interrupt - Check cabling.\n",
2300 dev->name);
2301 #endif
2302 if (lp->mode == 1) {
2303 hp100_clean_txring(dev);
2304 hp100_rxfill(dev);
2306 hp100_misc_interrupt(dev);
2309 spin_unlock(&lp->lock);
2310 hp100_ints_on();
2311 return IRQ_HANDLED;
2314 /*
2315 * some misc functions
2316 */
2318 static void hp100_start_interface(struct net_device *dev)
2320 unsigned long flags;
2321 int ioaddr = dev->base_addr;
2322 struct hp100_private *lp = netdev_priv(dev);
2324 #ifdef HP100_DEBUG_B
2325 hp100_outw(0x4220, TRACE);
2326 printk("hp100: %s: hp100_start_interface\n", dev->name);
2327 #endif
2329 spin_lock_irqsave(&lp->lock, flags);
2331 /* Ensure the adapter does not want to request an interrupt when */
2332 /* enabling the IRQ line to be active on the bus (i.e. not tri-stated) */
2333 hp100_page(PERFORMANCE);
2334 hp100_outw(0xfefe, IRQ_MASK); /* mask off all ints */
2335 hp100_outw(0xffff, IRQ_STATUS); /* ack all IRQs */
2336 hp100_outw(HP100_FAKE_INT | HP100_INT_EN | HP100_RESET_LB,
2337 OPTION_LSW);
2338 /* Un Tri-state int. TODO: Check if shared interrupts can be realised? */
2339 hp100_outw(HP100_TRI_INT | HP100_RESET_HB, OPTION_LSW);
2341 if (lp->mode == 1) {
2342 /* Make sure BM bit is set... */
2343 hp100_page(HW_MAP);
2344 hp100_orb(HP100_BM_MASTER, BM);
2345 hp100_rxfill(dev);
2346 } else if (lp->mode == 2) {
2347 /* Enable memory mapping. Note: Don't do this when busmaster. */
2348 hp100_outw(HP100_MMAP_DIS | HP100_RESET_HB, OPTION_LSW);
2351 hp100_page(PERFORMANCE);
2352 hp100_outw(0xfefe, IRQ_MASK); /* mask off all ints */
2353 hp100_outw(0xffff, IRQ_STATUS); /* ack IRQ */
2355 /* enable a few interrupts: */
2356 if (lp->mode == 1) { /* busmaster mode */
2357 hp100_outw(HP100_RX_PDL_FILL_COMPL |
2358 HP100_RX_PDA_ZERO | HP100_RX_ERROR |
2359 /* HP100_RX_PACKET | */
2360 /* HP100_RX_EARLY_INT | */ HP100_SET_HB |
2361 /* HP100_TX_PDA_ZERO | */
2362 HP100_TX_COMPLETE |
2363 /* HP100_MISC_ERROR | */
2364 HP100_TX_ERROR | HP100_SET_LB, IRQ_MASK);
2365 } else {
2366 hp100_outw(HP100_RX_PACKET |
2367 HP100_RX_ERROR | HP100_SET_HB |
2368 HP100_TX_ERROR | HP100_SET_LB, IRQ_MASK);
2371 /* Note : before hp100_set_multicast_list(), because it will play with
2372 * spinlock itself... Jean II */
2373 spin_unlock_irqrestore(&lp->lock, flags);
2375 /* Enable MAC Tx and RX, set MAC modes, ... */
2376 hp100_set_multicast_list(dev);
2379 static void hp100_stop_interface(struct net_device *dev)
2381 struct hp100_private *lp = netdev_priv(dev);
2382 int ioaddr = dev->base_addr;
2383 u_int val;
2385 #ifdef HP100_DEBUG_B
2386 printk("hp100: %s: hp100_stop_interface\n", dev->name);
2387 hp100_outw(0x4221, TRACE);
2388 #endif
2390 if (lp->mode == 1)
2391 hp100_BM_shutdown(dev);
2392 else {
2393 /* Note: MMAP_DIS will be reenabled by start_interface */
2394 hp100_outw(HP100_INT_EN | HP100_RESET_LB |
2395 HP100_TRI_INT | HP100_MMAP_DIS | HP100_SET_HB,
2396 OPTION_LSW);
2397 val = hp100_inw(OPTION_LSW);
2399 hp100_page(MAC_CTRL);
2400 hp100_andb(~(HP100_RX_EN | HP100_TX_EN), MAC_CFG_1);
2402 if (!(val & HP100_HW_RST))
2403 return; /* If reset, imm. return ... */
2404 /* ... else: busy wait until idle */
2405 for (val = 0; val < 6000; val++)
2406 if ((hp100_inb(MAC_CFG_1) & (HP100_TX_IDLE | HP100_RX_IDLE)) == (HP100_TX_IDLE | HP100_RX_IDLE)) {
2407 hp100_page(PERFORMANCE);
2408 return;
2410 printk("hp100: %s: hp100_stop_interface - timeout\n", dev->name);
2411 hp100_page(PERFORMANCE);
2415 static void hp100_load_eeprom(struct net_device *dev, u_short probe_ioaddr)
2417 int i;
2418 int ioaddr = probe_ioaddr > 0 ? probe_ioaddr : dev->base_addr;
2420 #ifdef HP100_DEBUG_B
2421 hp100_outw(0x4222, TRACE);
2422 #endif
2424 hp100_page(EEPROM_CTRL);
2425 hp100_andw(~HP100_EEPROM_LOAD, EEPROM_CTRL);
2426 hp100_orw(HP100_EEPROM_LOAD, EEPROM_CTRL);
2427 for (i = 0; i < 10000; i++)
2428 if (!(hp100_inb(OPTION_MSW) & HP100_EE_LOAD))
2429 return;
2430 printk("hp100: %s: hp100_load_eeprom - timeout\n", dev->name);
2433 /* Sense connection status.
2434 * return values: LAN_10 - Connected to 10Mbit/s network
2435 * LAN_100 - Connected to 100Mbit/s network
2436 * LAN_ERR - not connected or 100Mbit/s Hub down
2437 */
2438 static int hp100_sense_lan(struct net_device *dev)
2440 int ioaddr = dev->base_addr;
2441 u_short val_VG, val_10;
2442 struct hp100_private *lp = netdev_priv(dev);
2444 #ifdef HP100_DEBUG_B
2445 hp100_outw(0x4223, TRACE);
2446 #endif
2448 hp100_page(MAC_CTRL);
2449 val_10 = hp100_inb(10_LAN_CFG_1);
2450 val_VG = hp100_inb(VG_LAN_CFG_1);
2451 hp100_page(PERFORMANCE);
2452 #ifdef HP100_DEBUG
2453 printk("hp100: %s: sense_lan: val_VG = 0x%04x, val_10 = 0x%04x\n",
2454 dev->name, val_VG, val_10);
2455 #endif
2457 if (val_10 & HP100_LINK_BEAT_ST) /* 10Mb connection is active */
2458 return HP100_LAN_10;
2460 if (val_10 & HP100_AUI_ST) { /* have we BNC or AUI onboard? */
2461 /*
2462 * This can be overriden by dos utility, so if this has no effect,
2463 * perhaps you need to download that utility from HP and set card
2464 * back to "auto detect".
2465 */
2466 val_10 |= HP100_AUI_SEL | HP100_LOW_TH;
2467 hp100_page(MAC_CTRL);
2468 hp100_outb(val_10, 10_LAN_CFG_1);
2469 hp100_page(PERFORMANCE);
2470 return HP100_LAN_COAX;
2473 /* Those cards don't have a 100 Mbit connector */
2474 if ( !strcmp(lp->id, "HWP1920") ||
2475 (lp->pci_dev &&
2476 lp->pci_dev->vendor == PCI_VENDOR_ID &&
2477 (lp->pci_dev->device == PCI_DEVICE_ID_HP_J2970A ||
2478 lp->pci_dev->device == PCI_DEVICE_ID_HP_J2973A)))
2479 return HP100_LAN_ERR;
2481 if (val_VG & HP100_LINK_CABLE_ST) /* Can hear the HUBs tone. */
2482 return HP100_LAN_100;
2483 return HP100_LAN_ERR;
2486 static int hp100_down_vg_link(struct net_device *dev)
2488 struct hp100_private *lp = netdev_priv(dev);
2489 int ioaddr = dev->base_addr;
2490 unsigned long time;
2491 long savelan, newlan;
2493 #ifdef HP100_DEBUG_B
2494 hp100_outw(0x4224, TRACE);
2495 printk("hp100: %s: down_vg_link\n", dev->name);
2496 #endif
2498 hp100_page(MAC_CTRL);
2499 time = jiffies + (HZ / 4);
2500 do {
2501 if (hp100_inb(VG_LAN_CFG_1) & HP100_LINK_CABLE_ST)
2502 break;
2503 if (!in_interrupt())
2504 schedule_timeout_interruptible(1);
2505 } while (time_after(time, jiffies));
2507 if (time_after_eq(jiffies, time)) /* no signal->no logout */
2508 return 0;
2510 /* Drop the VG Link by clearing the link up cmd and load addr. */
2512 hp100_andb(~(HP100_LOAD_ADDR | HP100_LINK_CMD), VG_LAN_CFG_1);
2513 hp100_orb(HP100_VG_SEL, VG_LAN_CFG_1);
2515 /* Conditionally stall for >250ms on Link-Up Status (to go down) */
2516 time = jiffies + (HZ / 2);
2517 do {
2518 if (!(hp100_inb(VG_LAN_CFG_1) & HP100_LINK_UP_ST))
2519 break;
2520 if (!in_interrupt())
2521 schedule_timeout_interruptible(1);
2522 } while (time_after(time, jiffies));
2524 #ifdef HP100_DEBUG
2525 if (time_after_eq(jiffies, time))
2526 printk("hp100: %s: down_vg_link: Link does not go down?\n", dev->name);
2527 #endif
2529 /* To prevent condition where Rev 1 VG MAC and old hubs do not complete */
2530 /* logout under traffic (even though all the status bits are cleared), */
2531 /* do this workaround to get the Rev 1 MAC in its idle state */
2532 if (lp->chip == HP100_CHIPID_LASSEN) {
2533 /* Reset VG MAC to insure it leaves the logoff state even if */
2534 /* the Hub is still emitting tones */
2535 hp100_andb(~HP100_VG_RESET, VG_LAN_CFG_1);
2536 udelay(1500); /* wait for >1ms */
2537 hp100_orb(HP100_VG_RESET, VG_LAN_CFG_1); /* Release Reset */
2538 udelay(1500);
2541 /* New: For lassen, switch to 10 Mbps mac briefly to clear training ACK */
2542 /* to get the VG mac to full reset. This is not req.d with later chips */
2543 /* Note: It will take the between 1 and 2 seconds for the VG mac to be */
2544 /* selected again! This will be left to the connect hub function to */
2545 /* perform if desired. */
2546 if (lp->chip == HP100_CHIPID_LASSEN) {
2547 /* Have to write to 10 and 100VG control registers simultaneously */
2548 savelan = newlan = hp100_inl(10_LAN_CFG_1); /* read 10+100 LAN_CFG regs */
2549 newlan &= ~(HP100_VG_SEL << 16);
2550 newlan |= (HP100_DOT3_MAC) << 8;
2551 hp100_andb(~HP100_AUTO_MODE, MAC_CFG_3); /* Autosel off */
2552 hp100_outl(newlan, 10_LAN_CFG_1);
2554 /* Conditionally stall for 5sec on VG selected. */
2555 time = jiffies + (HZ * 5);
2556 do {
2557 if (!(hp100_inb(MAC_CFG_4) & HP100_MAC_SEL_ST))
2558 break;
2559 if (!in_interrupt())
2560 schedule_timeout_interruptible(1);
2561 } while (time_after(time, jiffies));
2563 hp100_orb(HP100_AUTO_MODE, MAC_CFG_3); /* Autosel back on */
2564 hp100_outl(savelan, 10_LAN_CFG_1);
2567 time = jiffies + (3 * HZ); /* Timeout 3s */
2568 do {
2569 if ((hp100_inb(VG_LAN_CFG_1) & HP100_LINK_CABLE_ST) == 0)
2570 break;
2571 if (!in_interrupt())
2572 schedule_timeout_interruptible(1);
2573 } while (time_after(time, jiffies));
2575 if (time_before_eq(time, jiffies)) {
2576 #ifdef HP100_DEBUG
2577 printk("hp100: %s: down_vg_link: timeout\n", dev->name);
2578 #endif
2579 return -EIO;
2582 time = jiffies + (2 * HZ); /* This seems to take a while.... */
2583 do {
2584 if (!in_interrupt())
2585 schedule_timeout_interruptible(1);
2586 } while (time_after(time, jiffies));
2588 return 0;
2591 static int hp100_login_to_vg_hub(struct net_device *dev, u_short force_relogin)
2593 int ioaddr = dev->base_addr;
2594 struct hp100_private *lp = netdev_priv(dev);
2595 u_short val = 0;
2596 unsigned long time;
2597 int startst;
2599 #ifdef HP100_DEBUG_B
2600 hp100_outw(0x4225, TRACE);
2601 printk("hp100: %s: login_to_vg_hub\n", dev->name);
2602 #endif
2604 /* Initiate a login sequence iff VG MAC is enabled and either Load Address
2605 * bit is zero or the force relogin flag is set (e.g. due to MAC address or
2606 * promiscuous mode change)
2607 */
2608 hp100_page(MAC_CTRL);
2609 startst = hp100_inb(VG_LAN_CFG_1);
2610 if ((force_relogin == 1) || (hp100_inb(MAC_CFG_4) & HP100_MAC_SEL_ST)) {
2611 #ifdef HP100_DEBUG_TRAINING
2612 printk("hp100: %s: Start training\n", dev->name);
2613 #endif
2615 /* Ensure VG Reset bit is 1 (i.e., do not reset) */
2616 hp100_orb(HP100_VG_RESET, VG_LAN_CFG_1);
2618 /* If Lassen AND auto-select-mode AND VG tones were sensed on */
2619 /* entry then temporarily put them into force 100Mbit mode */
2620 if ((lp->chip == HP100_CHIPID_LASSEN) && (startst & HP100_LINK_CABLE_ST))
2621 hp100_andb(~HP100_DOT3_MAC, 10_LAN_CFG_2);
2623 /* Drop the VG link by zeroing Link Up Command and Load Address */
2624 hp100_andb(~(HP100_LINK_CMD /* |HP100_LOAD_ADDR */ ), VG_LAN_CFG_1);
2626 #ifdef HP100_DEBUG_TRAINING
2627 printk("hp100: %s: Bring down the link\n", dev->name);
2628 #endif
2630 /* Wait for link to drop */
2631 time = jiffies + (HZ / 10);
2632 do {
2633 if (~(hp100_inb(VG_LAN_CFG_1) & HP100_LINK_UP_ST))
2634 break;
2635 if (!in_interrupt())
2636 schedule_timeout_interruptible(1);
2637 } while (time_after(time, jiffies));
2639 /* Start an addressed training and optionally request promiscuous port */
2640 if ((dev->flags) & IFF_PROMISC) {
2641 hp100_orb(HP100_PROM_MODE, VG_LAN_CFG_2);
2642 if (lp->chip == HP100_CHIPID_LASSEN)
2643 hp100_orw(HP100_MACRQ_PROMSC, TRAIN_REQUEST);
2644 } else {
2645 hp100_andb(~HP100_PROM_MODE, VG_LAN_CFG_2);
2646 /* For ETR parts we need to reset the prom. bit in the training
2647 * register, otherwise promiscious mode won't be disabled.
2648 */
2649 if (lp->chip == HP100_CHIPID_LASSEN) {
2650 hp100_andw(~HP100_MACRQ_PROMSC, TRAIN_REQUEST);
2654 /* With ETR parts, frame format request bits can be set. */
2655 if (lp->chip == HP100_CHIPID_LASSEN)
2656 hp100_orb(HP100_MACRQ_FRAMEFMT_EITHER, TRAIN_REQUEST);
2658 hp100_orb(HP100_LINK_CMD | HP100_LOAD_ADDR | HP100_VG_RESET, VG_LAN_CFG_1);
2660 /* Note: Next wait could be omitted for Hood and earlier chips under */
2661 /* certain circumstances */
2662 /* TODO: check if hood/earlier and skip wait. */
2664 /* Wait for either short timeout for VG tones or long for login */
2665 /* Wait for the card hardware to signalise link cable status ok... */
2666 hp100_page(MAC_CTRL);
2667 time = jiffies + (1 * HZ); /* 1 sec timeout for cable st */
2668 do {
2669 if (hp100_inb(VG_LAN_CFG_1) & HP100_LINK_CABLE_ST)
2670 break;
2671 if (!in_interrupt())
2672 schedule_timeout_interruptible(1);
2673 } while (time_before(jiffies, time));
2675 if (time_after_eq(jiffies, time)) {
2676 #ifdef HP100_DEBUG_TRAINING
2677 printk("hp100: %s: Link cable status not ok? Training aborted.\n", dev->name);
2678 #endif
2679 } else {
2680 #ifdef HP100_DEBUG_TRAINING
2681 printk
2682 ("hp100: %s: HUB tones detected. Trying to train.\n",
2683 dev->name);
2684 #endif
2686 time = jiffies + (2 * HZ); /* again a timeout */
2687 do {
2688 val = hp100_inb(VG_LAN_CFG_1);
2689 if ((val & (HP100_LINK_UP_ST))) {
2690 #ifdef HP100_DEBUG_TRAINING
2691 printk("hp100: %s: Passed training.\n", dev->name);
2692 #endif
2693 break;
2695 if (!in_interrupt())
2696 schedule_timeout_interruptible(1);
2697 } while (time_after(time, jiffies));
2700 /* If LINK_UP_ST is set, then we are logged into the hub. */
2701 if (time_before_eq(jiffies, time) && (val & HP100_LINK_UP_ST)) {
2702 #ifdef HP100_DEBUG_TRAINING
2703 printk("hp100: %s: Successfully logged into the HUB.\n", dev->name);
2704 if (lp->chip == HP100_CHIPID_LASSEN) {
2705 val = hp100_inw(TRAIN_ALLOW);
2706 printk("hp100: %s: Card supports 100VG MAC Version \"%s\" ",
2707 dev->name, (hp100_inw(TRAIN_REQUEST) & HP100_CARD_MACVER) ? "802.12" : "Pre");
2708 printk("Driver will use MAC Version \"%s\"\n", (val & HP100_HUB_MACVER) ? "802.12" : "Pre");
2709 printk("hp100: %s: Frame format is %s.\n", dev->name, (val & HP100_MALLOW_FRAMEFMT) ? "802.5" : "802.3");
2711 #endif
2712 } else {
2713 /* If LINK_UP_ST is not set, login was not successful */
2714 printk("hp100: %s: Problem logging into the HUB.\n", dev->name);
2715 if (lp->chip == HP100_CHIPID_LASSEN) {
2716 /* Check allowed Register to find out why there is a problem. */
2717 val = hp100_inw(TRAIN_ALLOW); /* won't work on non-ETR card */
2718 #ifdef HP100_DEBUG_TRAINING
2719 printk("hp100: %s: MAC Configuration requested: 0x%04x, HUB allowed: 0x%04x\n", dev->name, hp100_inw(TRAIN_REQUEST), val);
2720 #endif
2721 if (val & HP100_MALLOW_ACCDENIED)
2722 printk("hp100: %s: HUB access denied.\n", dev->name);
2723 if (val & HP100_MALLOW_CONFIGURE)
2724 printk("hp100: %s: MAC Configuration is incompatible with the Network.\n", dev->name);
2725 if (val & HP100_MALLOW_DUPADDR)
2726 printk("hp100: %s: Duplicate MAC Address on the Network.\n", dev->name);
2730 /* If we have put the chip into forced 100 Mbit mode earlier, go back */
2731 /* to auto-select mode */
2733 if ((lp->chip == HP100_CHIPID_LASSEN) && (startst & HP100_LINK_CABLE_ST)) {
2734 hp100_page(MAC_CTRL);
2735 hp100_orb(HP100_DOT3_MAC, 10_LAN_CFG_2);
2738 val = hp100_inb(VG_LAN_CFG_1);
2740 /* Clear the MISC_ERROR Interrupt, which might be generated when doing the relogin */
2741 hp100_page(PERFORMANCE);
2742 hp100_outw(HP100_MISC_ERROR, IRQ_STATUS);
2744 if (val & HP100_LINK_UP_ST)
2745 return (0); /* login was ok */
2746 else {
2747 printk("hp100: %s: Training failed.\n", dev->name);
2748 hp100_down_vg_link(dev);
2749 return -EIO;
2752 /* no forced relogin & already link there->no training. */
2753 return -EIO;
2756 static void hp100_cascade_reset(struct net_device *dev, u_short enable)
2758 int ioaddr = dev->base_addr;
2759 struct hp100_private *lp = netdev_priv(dev);
2761 #ifdef HP100_DEBUG_B
2762 hp100_outw(0x4226, TRACE);
2763 printk("hp100: %s: cascade_reset\n", dev->name);
2764 #endif
2766 if (enable) {
2767 hp100_outw(HP100_HW_RST | HP100_RESET_LB, OPTION_LSW);
2768 if (lp->chip == HP100_CHIPID_LASSEN) {
2769 /* Lassen requires a PCI transmit fifo reset */
2770 hp100_page(HW_MAP);
2771 hp100_andb(~HP100_PCI_RESET, PCICTRL2);
2772 hp100_orb(HP100_PCI_RESET, PCICTRL2);
2773 /* Wait for min. 300 ns */
2774 /* we can't use jiffies here, because it may be */
2775 /* that we have disabled the timer... */
2776 udelay(400);
2777 hp100_andb(~HP100_PCI_RESET, PCICTRL2);
2778 hp100_page(PERFORMANCE);
2780 } else { /* bring out of reset */
2781 hp100_outw(HP100_HW_RST | HP100_SET_LB, OPTION_LSW);
2782 udelay(400);
2783 hp100_page(PERFORMANCE);
2787 #ifdef HP100_DEBUG
2788 void hp100_RegisterDump(struct net_device *dev)
2790 int ioaddr = dev->base_addr;
2791 int Page;
2792 int Register;
2794 /* Dump common registers */
2795 printk("hp100: %s: Cascade Register Dump\n", dev->name);
2796 printk("hardware id #1: 0x%.2x\n", hp100_inb(HW_ID));
2797 printk("hardware id #2/paging: 0x%.2x\n", hp100_inb(PAGING));
2798 printk("option #1: 0x%.4x\n", hp100_inw(OPTION_LSW));
2799 printk("option #2: 0x%.4x\n", hp100_inw(OPTION_MSW));
2801 /* Dump paged registers */
2802 for (Page = 0; Page < 8; Page++) {
2803 /* Dump registers */
2804 printk("page: 0x%.2x\n", Page);
2805 outw(Page, ioaddr + 0x02);
2806 for (Register = 0x8; Register < 0x22; Register += 2) {
2807 /* Display Register contents except data port */
2808 if (((Register != 0x10) && (Register != 0x12)) || (Page > 0)) {
2809 printk("0x%.2x = 0x%.4x\n", Register, inw(ioaddr + Register));
2813 hp100_page(PERFORMANCE);
2815 #endif
2818 static void cleanup_dev(struct net_device *d)
2820 struct hp100_private *p = netdev_priv(d);
2822 unregister_netdev(d);
2823 release_region(d->base_addr, HP100_REGION_SIZE);
2825 if (p->mode == 1) /* busmaster */
2826 pci_free_consistent(p->pci_dev, MAX_RINGSIZE + 0x0f,
2827 p->page_vaddr_algn,
2828 virt_to_whatever(d, p->page_vaddr_algn));
2829 if (p->mem_ptr_virt)
2830 iounmap(p->mem_ptr_virt);
2832 free_netdev(d);
2835 #ifdef CONFIG_EISA
2836 static int __init hp100_eisa_probe (struct device *gendev)
2838 struct net_device *dev = alloc_etherdev(sizeof(struct hp100_private));
2839 struct eisa_device *edev = to_eisa_device(gendev);
2840 int err;
2842 if (!dev)
2843 return -ENOMEM;
2845 SET_MODULE_OWNER(dev);
2846 SET_NETDEV_DEV(dev, &edev->dev);
2848 err = hp100_probe1(dev, edev->base_addr + 0xC38, HP100_BUS_EISA, NULL);
2849 if (err)
2850 goto out1;
2852 #ifdef HP100_DEBUG
2853 printk("hp100: %s: EISA adapter found at 0x%x\n", dev->name,
2854 dev->base_addr);
2855 #endif
2856 gendev->driver_data = dev;
2857 return 0;
2858 out1:
2859 free_netdev(dev);
2860 return err;
2863 static int __devexit hp100_eisa_remove (struct device *gendev)
2865 struct net_device *dev = gendev->driver_data;
2866 cleanup_dev(dev);
2867 return 0;
2870 static struct eisa_driver hp100_eisa_driver = {
2871 .id_table = hp100_eisa_tbl,
2872 .driver = {
2873 .name = "hp100",
2874 .probe = hp100_eisa_probe,
2875 .remove = __devexit_p (hp100_eisa_remove),
2877 };
2878 #endif
2880 #ifdef CONFIG_PCI
2881 static int __devinit hp100_pci_probe (struct pci_dev *pdev,
2882 const struct pci_device_id *ent)
2884 struct net_device *dev;
2885 int ioaddr;
2886 u_short pci_command;
2887 int err;
2889 if (pci_enable_device(pdev))
2890 return -ENODEV;
2892 dev = alloc_etherdev(sizeof(struct hp100_private));
2893 if (!dev) {
2894 err = -ENOMEM;
2895 goto out0;
2898 SET_MODULE_OWNER(dev);
2899 SET_NETDEV_DEV(dev, &pdev->dev);
2901 pci_read_config_word(pdev, PCI_COMMAND, &pci_command);
2902 if (!(pci_command & PCI_COMMAND_IO)) {
2903 #ifdef HP100_DEBUG
2904 printk("hp100: %s: PCI I/O Bit has not been set. Setting...\n", dev->name);
2905 #endif
2906 pci_command |= PCI_COMMAND_IO;
2907 pci_write_config_word(pdev, PCI_COMMAND, pci_command);
2910 if (!(pci_command & PCI_COMMAND_MASTER)) {
2911 #ifdef HP100_DEBUG
2912 printk("hp100: %s: PCI Master Bit has not been set. Setting...\n", dev->name);
2913 #endif
2914 pci_command |= PCI_COMMAND_MASTER;
2915 pci_write_config_word(pdev, PCI_COMMAND, pci_command);
2918 ioaddr = pci_resource_start(pdev, 0);
2919 err = hp100_probe1(dev, ioaddr, HP100_BUS_PCI, pdev);
2920 if (err)
2921 goto out1;
2923 #ifdef HP100_DEBUG
2924 printk("hp100: %s: PCI adapter found at 0x%x\n", dev->name, ioaddr);
2925 #endif
2926 pci_set_drvdata(pdev, dev);
2927 return 0;
2928 out1:
2929 free_netdev(dev);
2930 out0:
2931 pci_disable_device(pdev);
2932 return err;
2935 static void __devexit hp100_pci_remove (struct pci_dev *pdev)
2937 struct net_device *dev = pci_get_drvdata(pdev);
2939 cleanup_dev(dev);
2940 pci_disable_device(pdev);
2944 static struct pci_driver hp100_pci_driver = {
2945 .name = "hp100",
2946 .id_table = hp100_pci_tbl,
2947 .probe = hp100_pci_probe,
2948 .remove = __devexit_p(hp100_pci_remove),
2949 };
2950 #endif
2952 /*
2953 * module section
2954 */
2956 MODULE_LICENSE("GPL");
2957 MODULE_AUTHOR("Jaroslav Kysela <perex@suse.cz>, "
2958 "Siegfried \"Frieder\" Loeffler (dg1sek) <floeff@mathematik.uni-stuttgart.de>");
2959 MODULE_DESCRIPTION("HP CASCADE Architecture Driver for 100VG-AnyLan Network Adapters");
2961 /*
2962 * Note: to register three isa devices, use:
2963 * option hp100 hp100_port=0,0,0
2964 * to register one card at io 0x280 as eth239, use:
2965 * option hp100 hp100_port=0x280
2966 */
2967 #if defined(MODULE) && defined(CONFIG_ISA)
2968 #define HP100_DEVICES 5
2969 /* Parameters set by insmod */
2970 static int hp100_port[HP100_DEVICES] = { 0, [1 ... (HP100_DEVICES-1)] = -1 };
2971 module_param_array(hp100_port, int, NULL, 0);
2973 /* List of devices */
2974 static struct net_device *hp100_devlist[HP100_DEVICES];
2976 static int __init hp100_isa_init(void)
2978 struct net_device *dev;
2979 int i, err, cards = 0;
2981 /* Don't autoprobe ISA bus */
2982 if (hp100_port[0] == 0)
2983 return -ENODEV;
2985 /* Loop on all possible base addresses */
2986 for (i = 0; i < HP100_DEVICES && hp100_port[i] != -1; ++i) {
2987 dev = alloc_etherdev(sizeof(struct hp100_private));
2988 if (!dev) {
2989 printk(KERN_WARNING "hp100: no memory for network device\n");
2990 while (cards > 0)
2991 cleanup_dev(hp100_devlist[--cards]);
2993 return -ENOMEM;
2995 SET_MODULE_OWNER(dev);
2997 err = hp100_isa_probe(dev, hp100_port[i]);
2998 if (!err)
2999 hp100_devlist[cards++] = dev;
3000 else
3001 free_netdev(dev);
3004 return cards > 0 ? 0 : -ENODEV;
3007 static void __exit hp100_isa_cleanup(void)
3009 int i;
3011 for (i = 0; i < HP100_DEVICES; i++) {
3012 struct net_device *dev = hp100_devlist[i];
3013 if (dev)
3014 cleanup_dev(dev);
3017 #else
3018 #define hp100_isa_init() (0)
3019 #define hp100_isa_cleanup() do { } while(0)
3020 #endif
3022 static int __init hp100_module_init(void)
3024 int err;
3026 err = hp100_isa_init();
3027 if (err && err != -ENODEV)
3028 goto out;
3029 #ifdef CONFIG_EISA
3030 err = eisa_driver_register(&hp100_eisa_driver);
3031 if (err && err != -ENODEV)
3032 goto out2;
3033 #endif
3034 #ifdef CONFIG_PCI
3035 err = pci_module_init(&hp100_pci_driver);
3036 if (err && err != -ENODEV)
3037 goto out3;
3038 #endif
3039 out:
3040 return err;
3041 out3:
3042 #ifdef CONFIG_EISA
3043 eisa_driver_unregister (&hp100_eisa_driver);
3044 out2:
3045 #endif
3046 hp100_isa_cleanup();
3047 goto out;
3051 static void __exit hp100_module_exit(void)
3053 hp100_isa_cleanup();
3054 #ifdef CONFIG_EISA
3055 eisa_driver_unregister (&hp100_eisa_driver);
3056 #endif
3057 #ifdef CONFIG_PCI
3058 pci_unregister_driver (&hp100_pci_driver);
3059 #endif
3062 module_init(hp100_module_init)
3063 module_exit(hp100_module_exit)
3066 /*
3067 * Local variables:
3068 * compile-command: "gcc -D__KERNEL__ -I/usr/src/linux/net/inet -Wall -Wstrict-prototypes -O6 -m486 -c hp100.c"
3069 * c-indent-level: 2
3070 * tab-width: 8
3071 * End:
3072 */