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