/drivers/net/ethernet/hp/hp100.c
C | 3051 lines | 2052 code | 449 blank | 550 comment | 438 complexity | b901a00119206b4fadfbd29636fa37ae MD5 | raw file
Large files files are truncated, but you can click here to view the full file
1/* 2** hp100.c 3** HP CASCADE Architecture Driver for 100VG-AnyLan Network Adapters 4** 5** $Id: hp100.c,v 1.58 2001/09/24 18:03:01 perex Exp perex $ 6** 7** Based on the HP100 driver written by Jaroslav Kysela <perex@jcu.cz> 8** Extended for new busmaster capable chipsets by 9** Siegfried "Frieder" Loeffler (dg1sek) <floeff@mathematik.uni-stuttgart.de> 10** 11** Maintained by: Jaroslav Kysela <perex@perex.cz> 12** 13** This driver has only been tested with 14** -- HP J2585B 10/100 Mbit/s PCI Busmaster 15** -- HP J2585A 10/100 Mbit/s PCI 16** -- HP J2970A 10 Mbit/s PCI Combo 10base-T/BNC 17** -- HP J2973A 10 Mbit/s PCI 10base-T 18** -- HP J2573 10/100 ISA 19** -- Compex ReadyLink ENET100-VG4 10/100 Mbit/s PCI / EISA 20** -- Compex FreedomLine 100/VG 10/100 Mbit/s ISA / EISA / PCI 21** 22** but it should also work with the other CASCADE based adapters. 23** 24** TODO: 25** - J2573 seems to hang sometimes when in shared memory mode. 26** - Mode for Priority TX 27** - Check PCI registers, performance might be improved? 28** - To reduce interrupt load in busmaster, one could switch off 29** the interrupts that are used to refill the queues whenever the 30** queues are filled up to more than a certain threshold. 31** - some updates for EISA version of card 32** 33** 34** This code is free software; you can redistribute it and/or modify 35** it under the terms of the GNU General Public License as published by 36** the Free Software Foundation; either version 2 of the License, or 37** (at your option) any later version. 38** 39** This code is distributed in the hope that it will be useful, 40** but WITHOUT ANY WARRANTY; without even the implied warranty of 41** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 42** GNU General Public License for more details. 43** 44** You should have received a copy of the GNU General Public License 45** along with this program; if not, write to the Free Software 46** Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. 47** 48** 1.57c -> 1.58 49** - used indent to change coding-style 50** - added KTI DP-200 EISA ID 51** - ioremap is also used for low (<1MB) memory (multi-architecture support) 52** 53** 1.57b -> 1.57c - Arnaldo Carvalho de Melo <acme@conectiva.com.br> 54** - release resources on failure in init_module 55** 56** 1.57 -> 1.57b - Jean II 57** - fix spinlocks, SMP is now working ! 58** 59** 1.56 -> 1.57 60** - updates for new PCI interface for 2.1 kernels 61** 62** 1.55 -> 1.56 63** - removed printk in misc. interrupt and update statistics to allow 64** monitoring of card status 65** - timing changes in xmit routines, relogin to 100VG hub added when 66** driver does reset 67** - included fix for Compex FreedomLine PCI adapter 68** 69** 1.54 -> 1.55 70** - fixed bad initialization in init_module 71** - added Compex FreedomLine adapter 72** - some fixes in card initialization 73** 74** 1.53 -> 1.54 75** - added hardware multicast filter support (doesn't work) 76** - little changes in hp100_sense_lan routine 77** - added support for Coax and AUI (J2970) 78** - fix for multiple cards and hp100_mode parameter (insmod) 79** - fix for shared IRQ 80** 81** 1.52 -> 1.53 82** - fixed bug in multicast support 83** 84*/ 85 86#define HP100_DEFAULT_PRIORITY_TX 0 87 88#undef HP100_DEBUG 89#undef HP100_DEBUG_B /* Trace */ 90#undef HP100_DEBUG_BM /* Debug busmaster code (PDL stuff) */ 91 92#undef HP100_DEBUG_TRAINING /* Debug login-to-hub procedure */ 93#undef HP100_DEBUG_TX 94#undef HP100_DEBUG_IRQ 95#undef HP100_DEBUG_RX 96 97#undef HP100_MULTICAST_FILTER /* Need to be debugged... */ 98 99#include <linux/module.h> 100#include <linux/kernel.h> 101#include <linux/sched.h> 102#include <linux/string.h> 103#include <linux/errno.h> 104#include <linux/ioport.h> 105#include <linux/interrupt.h> 106#include <linux/eisa.h> 107#include <linux/pci.h> 108#include <linux/dma-mapping.h> 109#include <linux/spinlock.h> 110#include <linux/netdevice.h> 111#include <linux/etherdevice.h> 112#include <linux/skbuff.h> 113#include <linux/types.h> 114#include <linux/delay.h> 115#include <linux/init.h> 116#include <linux/bitops.h> 117#include <linux/jiffies.h> 118 119#include <asm/io.h> 120 121#include "hp100.h" 122 123/* 124 * defines 125 */ 126 127#define HP100_BUS_ISA 0 128#define HP100_BUS_EISA 1 129#define HP100_BUS_PCI 2 130 131#define HP100_REGION_SIZE 0x20 /* for ioports */ 132#define HP100_SIG_LEN 8 /* same as EISA_SIG_LEN */ 133 134#define HP100_MAX_PACKET_SIZE (1536+4) 135#define HP100_MIN_PACKET_SIZE 60 136 137#ifndef HP100_DEFAULT_RX_RATIO 138/* default - 75% onboard memory on the card are used for RX packets */ 139#define HP100_DEFAULT_RX_RATIO 75 140#endif 141 142#ifndef HP100_DEFAULT_PRIORITY_TX 143/* default - don't enable transmit outgoing packets as priority */ 144#define HP100_DEFAULT_PRIORITY_TX 0 145#endif 146 147/* 148 * structures 149 */ 150 151struct hp100_private { 152 spinlock_t lock; 153 char id[HP100_SIG_LEN]; 154 u_short chip; 155 u_short soft_model; 156 u_int memory_size; 157 u_int virt_memory_size; 158 u_short rx_ratio; /* 1 - 99 */ 159 u_short priority_tx; /* != 0 - priority tx */ 160 u_short mode; /* PIO, Shared Mem or Busmaster */ 161 u_char bus; 162 struct pci_dev *pci_dev; 163 short mem_mapped; /* memory mapped access */ 164 void __iomem *mem_ptr_virt; /* virtual memory mapped area, maybe NULL */ 165 unsigned long mem_ptr_phys; /* physical memory mapped area */ 166 short lan_type; /* 10Mb/s, 100Mb/s or -1 (error) */ 167 int hub_status; /* was login to hub successful? */ 168 u_char mac1_mode; 169 u_char mac2_mode; 170 u_char hash_bytes[8]; 171 172 /* Rings for busmaster mode: */ 173 hp100_ring_t *rxrhead; /* Head (oldest) index into rxring */ 174 hp100_ring_t *rxrtail; /* Tail (newest) index into rxring */ 175 hp100_ring_t *txrhead; /* Head (oldest) index into txring */ 176 hp100_ring_t *txrtail; /* Tail (newest) index into txring */ 177 178 hp100_ring_t rxring[MAX_RX_PDL]; 179 hp100_ring_t txring[MAX_TX_PDL]; 180 181 u_int *page_vaddr_algn; /* Aligned virtual address of allocated page */ 182 u_long whatever_offset; /* Offset to bus/phys/dma address */ 183 int rxrcommit; /* # Rx PDLs committed to adapter */ 184 int txrcommit; /* # Tx PDLs committed to adapter */ 185}; 186 187/* 188 * variables 189 */ 190#ifdef CONFIG_ISA 191static const char *hp100_isa_tbl[] = { 192 "HWPF150", /* HP J2573 rev A */ 193 "HWP1950", /* HP J2573 */ 194}; 195#endif 196 197static struct eisa_device_id hp100_eisa_tbl[] = { 198 { "HWPF180" }, /* HP J2577 rev A */ 199 { "HWP1920" }, /* HP 27248B */ 200 { "HWP1940" }, /* HP J2577 */ 201 { "HWP1990" }, /* HP J2577 */ 202 { "CPX0301" }, /* ReadyLink ENET100-VG4 */ 203 { "CPX0401" }, /* FreedomLine 100/VG */ 204 { "" } /* Mandatory final entry ! */ 205}; 206MODULE_DEVICE_TABLE(eisa, hp100_eisa_tbl); 207 208static const struct pci_device_id hp100_pci_tbl[] = { 209 {PCI_VENDOR_ID_HP, PCI_DEVICE_ID_HP_J2585A, PCI_ANY_ID, PCI_ANY_ID,}, 210 {PCI_VENDOR_ID_HP, PCI_DEVICE_ID_HP_J2585B, PCI_ANY_ID, PCI_ANY_ID,}, 211 {PCI_VENDOR_ID_HP, PCI_DEVICE_ID_HP_J2970A, PCI_ANY_ID, PCI_ANY_ID,}, 212 {PCI_VENDOR_ID_HP, PCI_DEVICE_ID_HP_J2973A, PCI_ANY_ID, PCI_ANY_ID,}, 213 {PCI_VENDOR_ID_COMPEX, PCI_DEVICE_ID_COMPEX_ENET100VG4, PCI_ANY_ID, PCI_ANY_ID,}, 214 {PCI_VENDOR_ID_COMPEX2, PCI_DEVICE_ID_COMPEX2_100VG, PCI_ANY_ID, PCI_ANY_ID,}, 215/* {PCI_VENDOR_ID_KTI, PCI_DEVICE_ID_KTI_DP200, PCI_ANY_ID, PCI_ANY_ID }, */ 216 {} /* Terminating entry */ 217}; 218MODULE_DEVICE_TABLE(pci, hp100_pci_tbl); 219 220static int hp100_rx_ratio = HP100_DEFAULT_RX_RATIO; 221static int hp100_priority_tx = HP100_DEFAULT_PRIORITY_TX; 222static int hp100_mode = 1; 223 224module_param(hp100_rx_ratio, int, 0); 225module_param(hp100_priority_tx, int, 0); 226module_param(hp100_mode, int, 0); 227 228/* 229 * prototypes 230 */ 231 232static int hp100_probe1(struct net_device *dev, int ioaddr, u_char bus, 233 struct pci_dev *pci_dev); 234 235 236static int hp100_open(struct net_device *dev); 237static int hp100_close(struct net_device *dev); 238static netdev_tx_t hp100_start_xmit(struct sk_buff *skb, 239 struct net_device *dev); 240static netdev_tx_t hp100_start_xmit_bm(struct sk_buff *skb, 241 struct net_device *dev); 242static void hp100_rx(struct net_device *dev); 243static struct net_device_stats *hp100_get_stats(struct net_device *dev); 244static void hp100_misc_interrupt(struct net_device *dev); 245static void hp100_update_stats(struct net_device *dev); 246static void hp100_clear_stats(struct hp100_private *lp, int ioaddr); 247static void hp100_set_multicast_list(struct net_device *dev); 248static irqreturn_t hp100_interrupt(int irq, void *dev_id); 249static void hp100_start_interface(struct net_device *dev); 250static void hp100_stop_interface(struct net_device *dev); 251static void hp100_load_eeprom(struct net_device *dev, u_short ioaddr); 252static int hp100_sense_lan(struct net_device *dev); 253static int hp100_login_to_vg_hub(struct net_device *dev, 254 u_short force_relogin); 255static int hp100_down_vg_link(struct net_device *dev); 256static void hp100_cascade_reset(struct net_device *dev, u_short enable); 257static void hp100_BM_shutdown(struct net_device *dev); 258static void hp100_mmuinit(struct net_device *dev); 259static void hp100_init_pdls(struct net_device *dev); 260static int hp100_init_rxpdl(struct net_device *dev, 261 register hp100_ring_t * ringptr, 262 register u_int * pdlptr); 263static int hp100_init_txpdl(struct net_device *dev, 264 register hp100_ring_t * ringptr, 265 register u_int * pdlptr); 266static void hp100_rxfill(struct net_device *dev); 267static void hp100_hwinit(struct net_device *dev); 268static void hp100_clean_txring(struct net_device *dev); 269#ifdef HP100_DEBUG 270static void hp100_RegisterDump(struct net_device *dev); 271#endif 272 273/* Conversion to new PCI API : 274 * Convert an address in a kernel buffer to a bus/phys/dma address. 275 * This work *only* for memory fragments part of lp->page_vaddr, 276 * because it was properly DMA allocated via pci_alloc_consistent(), 277 * so we just need to "retrieve" the original mapping to bus/phys/dma 278 * address - Jean II */ 279static inline dma_addr_t virt_to_whatever(struct net_device *dev, u32 * ptr) 280{ 281 struct hp100_private *lp = netdev_priv(dev); 282 return ((u_long) ptr) + lp->whatever_offset; 283} 284 285static inline u_int pdl_map_data(struct hp100_private *lp, void *data) 286{ 287 return pci_map_single(lp->pci_dev, data, 288 MAX_ETHER_SIZE, PCI_DMA_FROMDEVICE); 289} 290 291/* TODO: This function should not really be needed in a good design... */ 292static void wait(void) 293{ 294 mdelay(1); 295} 296 297/* 298 * probe functions 299 * These functions should - if possible - avoid doing write operations 300 * since this could cause problems when the card is not installed. 301 */ 302 303/* 304 * Read board id and convert to string. 305 * Effectively same code as decode_eisa_sig 306 */ 307static const char *hp100_read_id(int ioaddr) 308{ 309 int i; 310 static char str[HP100_SIG_LEN]; 311 unsigned char sig[4], sum; 312 unsigned short rev; 313 314 hp100_page(ID_MAC_ADDR); 315 sum = 0; 316 for (i = 0; i < 4; i++) { 317 sig[i] = hp100_inb(BOARD_ID + i); 318 sum += sig[i]; 319 } 320 321 sum += hp100_inb(BOARD_ID + i); 322 if (sum != 0xff) 323 return NULL; /* bad checksum */ 324 325 str[0] = ((sig[0] >> 2) & 0x1f) + ('A' - 1); 326 str[1] = (((sig[0] & 3) << 3) | (sig[1] >> 5)) + ('A' - 1); 327 str[2] = (sig[1] & 0x1f) + ('A' - 1); 328 rev = (sig[2] << 8) | sig[3]; 329 sprintf(str + 3, "%04X", rev); 330 331 return str; 332} 333 334#ifdef CONFIG_ISA 335static __init int hp100_isa_probe1(struct net_device *dev, int ioaddr) 336{ 337 const char *sig; 338 int i; 339 340 if (!request_region(ioaddr, HP100_REGION_SIZE, "hp100")) 341 goto err; 342 343 if (hp100_inw(HW_ID) != HP100_HW_ID_CASCADE) { 344 release_region(ioaddr, HP100_REGION_SIZE); 345 goto err; 346 } 347 348 sig = hp100_read_id(ioaddr); 349 release_region(ioaddr, HP100_REGION_SIZE); 350 351 if (sig == NULL) 352 goto err; 353 354 for (i = 0; i < ARRAY_SIZE(hp100_isa_tbl); i++) { 355 if (!strcmp(hp100_isa_tbl[i], sig)) 356 break; 357 358 } 359 360 if (i < ARRAY_SIZE(hp100_isa_tbl)) 361 return hp100_probe1(dev, ioaddr, HP100_BUS_ISA, NULL); 362 err: 363 return -ENODEV; 364 365} 366/* 367 * Probe for ISA board. 368 * EISA and PCI are handled by device infrastructure. 369 */ 370 371static int __init hp100_isa_probe(struct net_device *dev, int addr) 372{ 373 int err = -ENODEV; 374 375 /* Probe for a specific ISA address */ 376 if (addr > 0xff && addr < 0x400) 377 err = hp100_isa_probe1(dev, addr); 378 379 else if (addr != 0) 380 err = -ENXIO; 381 382 else { 383 /* Probe all ISA possible port regions */ 384 for (addr = 0x100; addr < 0x400; addr += 0x20) { 385 err = hp100_isa_probe1(dev, addr); 386 if (!err) 387 break; 388 } 389 } 390 return err; 391} 392#endif /* CONFIG_ISA */ 393 394#if !defined(MODULE) && defined(CONFIG_ISA) 395struct net_device * __init hp100_probe(int unit) 396{ 397 struct net_device *dev = alloc_etherdev(sizeof(struct hp100_private)); 398 int err; 399 400 if (!dev) 401 return ERR_PTR(-ENODEV); 402 403#ifdef HP100_DEBUG_B 404 hp100_outw(0x4200, TRACE); 405 printk("hp100: %s: probe\n", dev->name); 406#endif 407 408 if (unit >= 0) { 409 sprintf(dev->name, "eth%d", unit); 410 netdev_boot_setup_check(dev); 411 } 412 413 err = hp100_isa_probe(dev, dev->base_addr); 414 if (err) 415 goto out; 416 417 return dev; 418 out: 419 free_netdev(dev); 420 return ERR_PTR(err); 421} 422#endif /* !MODULE && CONFIG_ISA */ 423 424static const struct net_device_ops hp100_bm_netdev_ops = { 425 .ndo_open = hp100_open, 426 .ndo_stop = hp100_close, 427 .ndo_start_xmit = hp100_start_xmit_bm, 428 .ndo_get_stats = hp100_get_stats, 429 .ndo_set_rx_mode = hp100_set_multicast_list, 430 .ndo_change_mtu = eth_change_mtu, 431 .ndo_set_mac_address = eth_mac_addr, 432 .ndo_validate_addr = eth_validate_addr, 433}; 434 435static const struct net_device_ops hp100_netdev_ops = { 436 .ndo_open = hp100_open, 437 .ndo_stop = hp100_close, 438 .ndo_start_xmit = hp100_start_xmit, 439 .ndo_get_stats = hp100_get_stats, 440 .ndo_set_rx_mode = hp100_set_multicast_list, 441 .ndo_change_mtu = eth_change_mtu, 442 .ndo_set_mac_address = eth_mac_addr, 443 .ndo_validate_addr = eth_validate_addr, 444}; 445 446static int hp100_probe1(struct net_device *dev, int ioaddr, u_char bus, 447 struct pci_dev *pci_dev) 448{ 449 int i; 450 int err = -ENODEV; 451 const char *eid; 452 u_int chip; 453 u_char uc; 454 u_int memory_size = 0, virt_memory_size = 0; 455 u_short local_mode, lsw; 456 short mem_mapped; 457 unsigned long mem_ptr_phys; 458 void __iomem *mem_ptr_virt; 459 struct hp100_private *lp; 460 461#ifdef HP100_DEBUG_B 462 hp100_outw(0x4201, TRACE); 463 printk("hp100: %s: probe1\n", dev->name); 464#endif 465 466 /* memory region for programmed i/o */ 467 if (!request_region(ioaddr, HP100_REGION_SIZE, "hp100")) 468 goto out1; 469 470 if (hp100_inw(HW_ID) != HP100_HW_ID_CASCADE) 471 goto out2; 472 473 chip = hp100_inw(PAGING) & HP100_CHIPID_MASK; 474#ifdef HP100_DEBUG 475 if (chip == HP100_CHIPID_SHASTA) 476 printk("hp100: %s: Shasta Chip detected. (This is a pre 802.12 chip)\n", dev->name); 477 else if (chip == HP100_CHIPID_RAINIER) 478 printk("hp100: %s: Rainier Chip detected. (This is a pre 802.12 chip)\n", dev->name); 479 else if (chip == HP100_CHIPID_LASSEN) 480 printk("hp100: %s: Lassen Chip detected.\n", dev->name); 481 else 482 printk("hp100: %s: Warning: Unknown CASCADE chip (id=0x%.4x).\n", dev->name, chip); 483#endif 484 485 dev->base_addr = ioaddr; 486 487 eid = hp100_read_id(ioaddr); 488 if (eid == NULL) { /* bad checksum? */ 489 printk(KERN_WARNING "%s: bad ID checksum at base port 0x%x\n", 490 __func__, ioaddr); 491 goto out2; 492 } 493 494 hp100_page(ID_MAC_ADDR); 495 for (i = uc = 0; i < 7; i++) 496 uc += hp100_inb(LAN_ADDR + i); 497 if (uc != 0xff) { 498 printk(KERN_WARNING 499 "%s: bad lan address checksum at port 0x%x)\n", 500 __func__, ioaddr); 501 err = -EIO; 502 goto out2; 503 } 504 505 /* Make sure, that all registers are correctly updated... */ 506 507 hp100_load_eeprom(dev, ioaddr); 508 wait(); 509 510 /* 511 * Determine driver operation mode 512 * 513 * Use the variable "hp100_mode" upon insmod or as kernel parameter to 514 * force driver modes: 515 * hp100_mode=1 -> default, use busmaster mode if configured. 516 * hp100_mode=2 -> enable shared memory mode 517 * hp100_mode=3 -> force use of i/o mapped mode. 518 * hp100_mode=4 -> same as 1, but re-set the enable bit on the card. 519 */ 520 521 /* 522 * LSW values: 523 * 0x2278 -> J2585B, PnP shared memory mode 524 * 0x2270 -> J2585B, shared memory mode, 0xdc000 525 * 0xa23c -> J2585B, I/O mapped mode 526 * 0x2240 -> EISA COMPEX, BusMaster (Shasta Chip) 527 * 0x2220 -> EISA HP, I/O (Shasta Chip) 528 * 0x2260 -> EISA HP, BusMaster (Shasta Chip) 529 */ 530 531#if 0 532 local_mode = 0x2270; 533 hp100_outw(0xfefe, OPTION_LSW); 534 hp100_outw(local_mode | HP100_SET_LB | HP100_SET_HB, OPTION_LSW); 535#endif 536 537 /* hp100_mode value maybe used in future by another card */ 538 local_mode = hp100_mode; 539 if (local_mode < 1 || local_mode > 4) 540 local_mode = 1; /* default */ 541#ifdef HP100_DEBUG 542 printk("hp100: %s: original LSW = 0x%x\n", dev->name, 543 hp100_inw(OPTION_LSW)); 544#endif 545 546 if (local_mode == 3) { 547 hp100_outw(HP100_MEM_EN | HP100_RESET_LB, OPTION_LSW); 548 hp100_outw(HP100_IO_EN | HP100_SET_LB, OPTION_LSW); 549 hp100_outw(HP100_BM_WRITE | HP100_BM_READ | HP100_RESET_HB, OPTION_LSW); 550 printk("hp100: IO mapped mode forced.\n"); 551 } else if (local_mode == 2) { 552 hp100_outw(HP100_MEM_EN | HP100_SET_LB, OPTION_LSW); 553 hp100_outw(HP100_IO_EN | HP100_SET_LB, OPTION_LSW); 554 hp100_outw(HP100_BM_WRITE | HP100_BM_READ | HP100_RESET_HB, OPTION_LSW); 555 printk("hp100: Shared memory mode requested.\n"); 556 } else if (local_mode == 4) { 557 if (chip == HP100_CHIPID_LASSEN) { 558 hp100_outw(HP100_BM_WRITE | HP100_BM_READ | HP100_SET_HB, OPTION_LSW); 559 hp100_outw(HP100_IO_EN | HP100_MEM_EN | HP100_RESET_LB, OPTION_LSW); 560 printk("hp100: Busmaster mode requested.\n"); 561 } 562 local_mode = 1; 563 } 564 565 if (local_mode == 1) { /* default behaviour */ 566 lsw = hp100_inw(OPTION_LSW); 567 568 if ((lsw & HP100_IO_EN) && (~lsw & HP100_MEM_EN) && 569 (~lsw & (HP100_BM_WRITE | HP100_BM_READ))) { 570#ifdef HP100_DEBUG 571 printk("hp100: %s: IO_EN bit is set on card.\n", dev->name); 572#endif 573 local_mode = 3; 574 } else if (chip == HP100_CHIPID_LASSEN && 575 (lsw & (HP100_BM_WRITE | HP100_BM_READ)) == (HP100_BM_WRITE | HP100_BM_READ)) { 576 /* Conversion to new PCI API : 577 * I don't have the doc, but I assume that the card 578 * can map the full 32bit address space. 579 * Also, we can have EISA Busmaster cards (not tested), 580 * so beware !!! - Jean II */ 581 if((bus == HP100_BUS_PCI) && 582 (pci_set_dma_mask(pci_dev, DMA_BIT_MASK(32)))) { 583 /* Gracefully fallback to shared memory */ 584 goto busmasterfail; 585 } 586 printk("hp100: Busmaster mode enabled.\n"); 587 hp100_outw(HP100_MEM_EN | HP100_IO_EN | HP100_RESET_LB, OPTION_LSW); 588 } else { 589 busmasterfail: 590#ifdef HP100_DEBUG 591 printk("hp100: %s: Card not configured for BM or BM not supported with this card.\n", dev->name); 592 printk("hp100: %s: Trying shared memory mode.\n", dev->name); 593#endif 594 /* In this case, try shared memory mode */ 595 local_mode = 2; 596 hp100_outw(HP100_MEM_EN | HP100_SET_LB, OPTION_LSW); 597 /* hp100_outw(HP100_IO_EN|HP100_RESET_LB, OPTION_LSW); */ 598 } 599 } 600#ifdef HP100_DEBUG 601 printk("hp100: %s: new LSW = 0x%x\n", dev->name, hp100_inw(OPTION_LSW)); 602#endif 603 604 /* Check for shared memory on the card, eventually remap it */ 605 hp100_page(HW_MAP); 606 mem_mapped = ((hp100_inw(OPTION_LSW) & (HP100_MEM_EN)) != 0); 607 mem_ptr_phys = 0UL; 608 mem_ptr_virt = NULL; 609 memory_size = (8192 << ((hp100_inb(SRAM) >> 5) & 0x07)); 610 virt_memory_size = 0; 611 612 /* For memory mapped or busmaster mode, we want the memory address */ 613 if (mem_mapped || (local_mode == 1)) { 614 mem_ptr_phys = (hp100_inw(MEM_MAP_LSW) | (hp100_inw(MEM_MAP_MSW) << 16)); 615 mem_ptr_phys &= ~0x1fff; /* 8k alignment */ 616 617 if (bus == HP100_BUS_ISA && (mem_ptr_phys & ~0xfffff) != 0) { 618 printk("hp100: Can only use programmed i/o mode.\n"); 619 mem_ptr_phys = 0; 620 mem_mapped = 0; 621 local_mode = 3; /* Use programmed i/o */ 622 } 623 624 /* We do not need access to shared memory in busmaster mode */ 625 /* However in slave mode we need to remap high (>1GB) card memory */ 626 if (local_mode != 1) { /* = not busmaster */ 627 /* We try with smaller memory sizes, if ioremap fails */ 628 for (virt_memory_size = memory_size; virt_memory_size > 16383; virt_memory_size >>= 1) { 629 if ((mem_ptr_virt = ioremap((u_long) mem_ptr_phys, virt_memory_size)) == NULL) { 630#ifdef HP100_DEBUG 631 printk("hp100: %s: ioremap for 0x%x bytes high PCI memory at 0x%lx failed\n", dev->name, virt_memory_size, mem_ptr_phys); 632#endif 633 } else { 634#ifdef HP100_DEBUG 635 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); 636#endif 637 break; 638 } 639 } 640 641 if (mem_ptr_virt == NULL) { /* all ioremap tries failed */ 642 printk("hp100: Failed to ioremap the PCI card memory. Will have to use i/o mapped mode.\n"); 643 local_mode = 3; 644 virt_memory_size = 0; 645 } 646 } 647 } 648 649 if (local_mode == 3) { /* io mapped forced */ 650 mem_mapped = 0; 651 mem_ptr_phys = 0; 652 mem_ptr_virt = NULL; 653 printk("hp100: Using (slow) programmed i/o mode.\n"); 654 } 655 656 /* Initialise the "private" data structure for this card. */ 657 lp = netdev_priv(dev); 658 659 spin_lock_init(&lp->lock); 660 strlcpy(lp->id, eid, HP100_SIG_LEN); 661 lp->chip = chip; 662 lp->mode = local_mode; 663 lp->bus = bus; 664 lp->pci_dev = pci_dev; 665 lp->priority_tx = hp100_priority_tx; 666 lp->rx_ratio = hp100_rx_ratio; 667 lp->mem_ptr_phys = mem_ptr_phys; 668 lp->mem_ptr_virt = mem_ptr_virt; 669 hp100_page(ID_MAC_ADDR); 670 lp->soft_model = hp100_inb(SOFT_MODEL); 671 lp->mac1_mode = HP100_MAC1MODE3; 672 lp->mac2_mode = HP100_MAC2MODE3; 673 memset(&lp->hash_bytes, 0x00, 8); 674 675 dev->base_addr = ioaddr; 676 677 lp->memory_size = memory_size; 678 lp->virt_memory_size = virt_memory_size; 679 lp->rx_ratio = hp100_rx_ratio; /* can be conf'd with insmod */ 680 681 if (lp->mode == 1) /* busmaster */ 682 dev->netdev_ops = &hp100_bm_netdev_ops; 683 else 684 dev->netdev_ops = &hp100_netdev_ops; 685 686 /* Ask the card for which IRQ line it is configured */ 687 if (bus == HP100_BUS_PCI) { 688 dev->irq = pci_dev->irq; 689 } else { 690 hp100_page(HW_MAP); 691 dev->irq = hp100_inb(IRQ_CHANNEL) & HP100_IRQMASK; 692 if (dev->irq == 2) 693 dev->irq = 9; 694 } 695 696 if (lp->mode == 1) /* busmaster */ 697 dev->dma = 4; 698 699 /* Ask the card for its MAC address and store it for later use. */ 700 hp100_page(ID_MAC_ADDR); 701 for (i = uc = 0; i < 6; i++) 702 dev->dev_addr[i] = hp100_inb(LAN_ADDR + i); 703 704 /* Reset statistics (counters) */ 705 hp100_clear_stats(lp, ioaddr); 706 707 /* If busmaster mode is wanted, a dma-capable memory area is needed for 708 * the rx and tx PDLs 709 * PCI cards can access the whole PC memory. Therefore GFP_DMA is not 710 * needed for the allocation of the memory area. 711 */ 712 713 /* TODO: We do not need this with old cards, where PDLs are stored 714 * in the cards shared memory area. But currently, busmaster has been 715 * implemented/tested only with the lassen chip anyway... */ 716 if (lp->mode == 1) { /* busmaster */ 717 dma_addr_t page_baddr; 718 /* Get physically continuous memory for TX & RX PDLs */ 719 /* Conversion to new PCI API : 720 * Pages are always aligned and zeroed, no need to it ourself. 721 * Doc says should be OK for EISA bus as well - Jean II */ 722 lp->page_vaddr_algn = pci_alloc_consistent(lp->pci_dev, MAX_RINGSIZE, &page_baddr); 723 if (!lp->page_vaddr_algn) { 724 err = -ENOMEM; 725 goto out_mem_ptr; 726 } 727 lp->whatever_offset = ((u_long) page_baddr) - ((u_long) lp->page_vaddr_algn); 728 729#ifdef HP100_DEBUG_BM 730 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); 731#endif 732 lp->rxrcommit = lp->txrcommit = 0; 733 lp->rxrhead = lp->rxrtail = &(lp->rxring[0]); 734 lp->txrhead = lp->txrtail = &(lp->txring[0]); 735 } 736 737 /* Initialise the card. */ 738 /* (I'm not really sure if it's a good idea to do this during probing, but 739 * like this it's assured that the lan connection type can be sensed 740 * correctly) 741 */ 742 hp100_hwinit(dev); 743 744 /* Try to find out which kind of LAN the card is connected to. */ 745 lp->lan_type = hp100_sense_lan(dev); 746 747 /* Print out a message what about what we think we have probed. */ 748 printk("hp100: at 0x%x, IRQ %d, ", ioaddr, dev->irq); 749 switch (bus) { 750 case HP100_BUS_EISA: 751 printk("EISA"); 752 break; 753 case HP100_BUS_PCI: 754 printk("PCI"); 755 break; 756 default: 757 printk("ISA"); 758 break; 759 } 760 printk(" bus, %dk SRAM (rx/tx %d%%).\n", lp->memory_size >> 10, lp->rx_ratio); 761 762 if (lp->mode == 2) { /* memory mapped */ 763 printk("hp100: Memory area at 0x%lx-0x%lx", mem_ptr_phys, 764 (mem_ptr_phys + (mem_ptr_phys > 0x100000 ? (u_long) lp->memory_size : 16 * 1024)) - 1); 765 if (mem_ptr_virt) 766 printk(" (virtual base %p)", mem_ptr_virt); 767 printk(".\n"); 768 769 /* Set for info when doing ifconfig */ 770 dev->mem_start = mem_ptr_phys; 771 dev->mem_end = mem_ptr_phys + lp->memory_size; 772 } 773 774 printk("hp100: "); 775 if (lp->lan_type != HP100_LAN_ERR) 776 printk("Adapter is attached to "); 777 switch (lp->lan_type) { 778 case HP100_LAN_100: 779 printk("100Mb/s Voice Grade AnyLAN network.\n"); 780 break; 781 case HP100_LAN_10: 782 printk("10Mb/s network (10baseT).\n"); 783 break; 784 case HP100_LAN_COAX: 785 printk("10Mb/s network (coax).\n"); 786 break; 787 default: 788 printk("Warning! Link down.\n"); 789 } 790 791 err = register_netdev(dev); 792 if (err) 793 goto out3; 794 795 return 0; 796out3: 797 if (local_mode == 1) 798 pci_free_consistent(lp->pci_dev, MAX_RINGSIZE + 0x0f, 799 lp->page_vaddr_algn, 800 virt_to_whatever(dev, lp->page_vaddr_algn)); 801out_mem_ptr: 802 if (mem_ptr_virt) 803 iounmap(mem_ptr_virt); 804out2: 805 release_region(ioaddr, HP100_REGION_SIZE); 806out1: 807 return err; 808} 809 810/* This procedure puts the card into a stable init state */ 811static void hp100_hwinit(struct net_device *dev) 812{ 813 int ioaddr = dev->base_addr; 814 struct hp100_private *lp = netdev_priv(dev); 815 816#ifdef HP100_DEBUG_B 817 hp100_outw(0x4202, TRACE); 818 printk("hp100: %s: hwinit\n", dev->name); 819#endif 820 821 /* Initialise the card. -------------------------------------------- */ 822 823 /* Clear all pending Ints and disable Ints */ 824 hp100_page(PERFORMANCE); 825 hp100_outw(0xfefe, IRQ_MASK); /* mask off all ints */ 826 hp100_outw(0xffff, IRQ_STATUS); /* clear all pending ints */ 827 828 hp100_outw(HP100_INT_EN | HP100_RESET_LB, OPTION_LSW); 829 hp100_outw(HP100_TRI_INT | HP100_SET_HB, OPTION_LSW); 830 831 if (lp->mode == 1) { 832 hp100_BM_shutdown(dev); /* disables BM, puts cascade in reset */ 833 wait(); 834 } else { 835 hp100_outw(HP100_INT_EN | HP100_RESET_LB, OPTION_LSW); 836 hp100_cascade_reset(dev, 1); 837 hp100_page(MAC_CTRL); 838 hp100_andb(~(HP100_RX_EN | HP100_TX_EN), MAC_CFG_1); 839 } 840 841 /* Initiate EEPROM reload */ 842 hp100_load_eeprom(dev, 0); 843 844 wait(); 845 846 /* Go into reset again. */ 847 hp100_cascade_reset(dev, 1); 848 849 /* Set Option Registers to a safe state */ 850 hp100_outw(HP100_DEBUG_EN | 851 HP100_RX_HDR | 852 HP100_EE_EN | 853 HP100_BM_WRITE | 854 HP100_BM_READ | HP100_RESET_HB | 855 HP100_FAKE_INT | 856 HP100_INT_EN | 857 HP100_MEM_EN | 858 HP100_IO_EN | HP100_RESET_LB, OPTION_LSW); 859 860 hp100_outw(HP100_TRI_INT | 861 HP100_MMAP_DIS | HP100_SET_HB, OPTION_LSW); 862 863 hp100_outb(HP100_PRIORITY_TX | 864 HP100_ADV_NXT_PKT | 865 HP100_TX_CMD | HP100_RESET_LB, OPTION_MSW); 866 867 /* TODO: Configure MMU for Ram Test. */ 868 /* TODO: Ram Test. */ 869 870 /* Re-check if adapter is still at same i/o location */ 871 /* (If the base i/o in eeprom has been changed but the */ 872 /* registers had not been changed, a reload of the eeprom */ 873 /* would move the adapter to the address stored in eeprom */ 874 875 /* TODO: Code to implement. */ 876 877 /* Until here it was code from HWdiscover procedure. */ 878 /* Next comes code from mmuinit procedure of SCO BM driver which is 879 * called from HWconfigure in the SCO driver. */ 880 881 /* Initialise MMU, eventually switch on Busmaster Mode, initialise 882 * multicast filter... 883 */ 884 hp100_mmuinit(dev); 885 886 /* We don't turn the interrupts on here - this is done by start_interface. */ 887 wait(); /* TODO: Do we really need this? */ 888 889 /* Enable Hardware (e.g. unreset) */ 890 hp100_cascade_reset(dev, 0); 891 892 /* ------- initialisation complete ----------- */ 893 894 /* Finally try to log in the Hub if there may be a VG connection. */ 895 if ((lp->lan_type == HP100_LAN_100) || (lp->lan_type == HP100_LAN_ERR)) 896 hp100_login_to_vg_hub(dev, 0); /* relogin */ 897 898} 899 900 901/* 902 * mmuinit - Reinitialise Cascade MMU and MAC settings. 903 * Note: Must already be in reset and leaves card in reset. 904 */ 905static void hp100_mmuinit(struct net_device *dev) 906{ 907 int ioaddr = dev->base_addr; 908 struct hp100_private *lp = netdev_priv(dev); 909 int i; 910 911#ifdef HP100_DEBUG_B 912 hp100_outw(0x4203, TRACE); 913 printk("hp100: %s: mmuinit\n", dev->name); 914#endif 915 916#ifdef HP100_DEBUG 917 if (0 != (hp100_inw(OPTION_LSW) & HP100_HW_RST)) { 918 printk("hp100: %s: Not in reset when entering mmuinit. Fix me.\n", dev->name); 919 return; 920 } 921#endif 922 923 /* Make sure IRQs are masked off and ack'ed. */ 924 hp100_page(PERFORMANCE); 925 hp100_outw(0xfefe, IRQ_MASK); /* mask off all ints */ 926 hp100_outw(0xffff, IRQ_STATUS); /* ack IRQ */ 927 928 /* 929 * Enable Hardware 930 * - Clear Debug En, Rx Hdr Pipe, EE En, I/O En, Fake Int and Intr En 931 * - Set Tri-State Int, Bus Master Rd/Wr, and Mem Map Disable 932 * - Clear Priority, Advance Pkt and Xmit Cmd 933 */ 934 935 hp100_outw(HP100_DEBUG_EN | 936 HP100_RX_HDR | 937 HP100_EE_EN | HP100_RESET_HB | 938 HP100_IO_EN | 939 HP100_FAKE_INT | 940 HP100_INT_EN | HP100_RESET_LB, OPTION_LSW); 941 942 hp100_outw(HP100_TRI_INT | HP100_SET_HB, OPTION_LSW); 943 944 if (lp->mode == 1) { /* busmaster */ 945 hp100_outw(HP100_BM_WRITE | 946 HP100_BM_READ | 947 HP100_MMAP_DIS | HP100_SET_HB, OPTION_LSW); 948 } else if (lp->mode == 2) { /* memory mapped */ 949 hp100_outw(HP100_BM_WRITE | 950 HP100_BM_READ | HP100_RESET_HB, OPTION_LSW); 951 hp100_outw(HP100_MMAP_DIS | HP100_RESET_HB, OPTION_LSW); 952 hp100_outw(HP100_MEM_EN | HP100_SET_LB, OPTION_LSW); 953 hp100_outw(HP100_IO_EN | HP100_SET_LB, OPTION_LSW); 954 } else if (lp->mode == 3) { /* i/o mapped mode */ 955 hp100_outw(HP100_MMAP_DIS | HP100_SET_HB | 956 HP100_IO_EN | HP100_SET_LB, OPTION_LSW); 957 } 958 959 hp100_page(HW_MAP); 960 hp100_outb(0, EARLYRXCFG); 961 hp100_outw(0, EARLYTXCFG); 962 963 /* 964 * Enable Bus Master mode 965 */ 966 if (lp->mode == 1) { /* busmaster */ 967 /* Experimental: Set some PCI configuration bits */ 968 hp100_page(HW_MAP); 969 hp100_andb(~HP100_PDL_USE3, MODECTRL1); /* BM engine read maximum */ 970 hp100_andb(~HP100_TX_DUALQ, MODECTRL1); /* No Queue for Priority TX */ 971 972 /* PCI Bus failures should result in a Misc. Interrupt */ 973 hp100_orb(HP100_EN_BUS_FAIL, MODECTRL2); 974 975 hp100_outw(HP100_BM_READ | HP100_BM_WRITE | HP100_SET_HB, OPTION_LSW); 976 hp100_page(HW_MAP); 977 /* Use Burst Mode and switch on PAGE_CK */ 978 hp100_orb(HP100_BM_BURST_RD | HP100_BM_BURST_WR, BM); 979 if ((lp->chip == HP100_CHIPID_RAINIER) || (lp->chip == HP100_CHIPID_SHASTA)) 980 hp100_orb(HP100_BM_PAGE_CK, BM); 981 hp100_orb(HP100_BM_MASTER, BM); 982 } else { /* not busmaster */ 983 984 hp100_page(HW_MAP); 985 hp100_andb(~HP100_BM_MASTER, BM); 986 } 987 988 /* 989 * Divide card memory into regions for Rx, Tx and, if non-ETR chip, PDLs 990 */ 991 hp100_page(MMU_CFG); 992 if (lp->mode == 1) { /* only needed for Busmaster */ 993 int xmit_stop, recv_stop; 994 995 if ((lp->chip == HP100_CHIPID_RAINIER) || 996 (lp->chip == HP100_CHIPID_SHASTA)) { 997 int pdl_stop; 998 999 /* 1000 * Each pdl is 508 bytes long. (63 frags * 4 bytes for address and 1001 * 4 bytes for header). We will leave NUM_RXPDLS * 508 (rounded 1002 * to the next higher 1k boundary) bytes for the rx-pdl's 1003 * Note: For non-etr chips the transmit stop register must be 1004 * programmed on a 1k boundary, i.e. bits 9:0 must be zero. 1005 */ 1006 pdl_stop = lp->memory_size; 1007 xmit_stop = (pdl_stop - 508 * (MAX_RX_PDL) - 16) & ~(0x03ff); 1008 recv_stop = (xmit_stop * (lp->rx_ratio) / 100) & ~(0x03ff); 1009 hp100_outw((pdl_stop >> 4) - 1, PDL_MEM_STOP); 1010#ifdef HP100_DEBUG_BM 1011 printk("hp100: %s: PDL_STOP = 0x%x\n", dev->name, pdl_stop); 1012#endif 1013 } else { 1014 /* ETR chip (Lassen) in busmaster mode */ 1015 xmit_stop = (lp->memory_size) - 1; 1016 recv_stop = ((lp->memory_size * lp->rx_ratio) / 100) & ~(0x03ff); 1017 } 1018 1019 hp100_outw(xmit_stop >> 4, TX_MEM_STOP); 1020 hp100_outw(recv_stop >> 4, RX_MEM_STOP); 1021#ifdef HP100_DEBUG_BM 1022 printk("hp100: %s: TX_STOP = 0x%x\n", dev->name, xmit_stop >> 4); 1023 printk("hp100: %s: RX_STOP = 0x%x\n", dev->name, recv_stop >> 4); 1024#endif 1025 } else { 1026 /* Slave modes (memory mapped and programmed io) */ 1027 hp100_outw((((lp->memory_size * lp->rx_ratio) / 100) >> 4), RX_MEM_STOP); 1028 hp100_outw(((lp->memory_size - 1) >> 4), TX_MEM_STOP); 1029#ifdef HP100_DEBUG 1030 printk("hp100: %s: TX_MEM_STOP: 0x%x\n", dev->name, hp100_inw(TX_MEM_STOP)); 1031 printk("hp100: %s: RX_MEM_STOP: 0x%x\n", dev->name, hp100_inw(RX_MEM_STOP)); 1032#endif 1033 } 1034 1035 /* Write MAC address into page 1 */ 1036 hp100_page(MAC_ADDRESS); 1037 for (i = 0; i < 6; i++) 1038 hp100_outb(dev->dev_addr[i], MAC_ADDR + i); 1039 1040 /* Zero the multicast hash registers */ 1041 for (i = 0; i < 8; i++) 1042 hp100_outb(0x0, HASH_BYTE0 + i); 1043 1044 /* Set up MAC defaults */ 1045 hp100_page(MAC_CTRL); 1046 1047 /* Go to LAN Page and zero all filter bits */ 1048 /* Zero accept error, accept multicast, accept broadcast and accept */ 1049 /* all directed packet bits */ 1050 hp100_andb(~(HP100_RX_EN | 1051 HP100_TX_EN | 1052 HP100_ACC_ERRORED | 1053 HP100_ACC_MC | 1054 HP100_ACC_BC | HP100_ACC_PHY), MAC_CFG_1); 1055 1056 hp100_outb(0x00, MAC_CFG_2); 1057 1058 /* Zero the frame format bit. This works around a training bug in the */ 1059 /* new hubs. */ 1060 hp100_outb(0x00, VG_LAN_CFG_2); /* (use 802.3) */ 1061 1062 if (lp->priority_tx) 1063 hp100_outb(HP100_PRIORITY_TX | HP100_SET_LB, OPTION_MSW); 1064 else 1065 hp100_outb(HP100_PRIORITY_TX | HP100_RESET_LB, OPTION_MSW); 1066 1067 hp100_outb(HP100_ADV_NXT_PKT | 1068 HP100_TX_CMD | HP100_RESET_LB, OPTION_MSW); 1069 1070 /* If busmaster, initialize the PDLs */ 1071 if (lp->mode == 1) 1072 hp100_init_pdls(dev); 1073 1074 /* Go to performance page and initialize isr and imr registers */ 1075 hp100_page(PERFORMANCE); 1076 hp100_outw(0xfefe, IRQ_MASK); /* mask off all ints */ 1077 hp100_outw(0xffff, IRQ_STATUS); /* ack IRQ */ 1078} 1079 1080/* 1081 * open/close functions 1082 */ 1083 1084static int hp100_open(struct net_device *dev) 1085{ 1086 struct hp100_private *lp = netdev_priv(dev); 1087#ifdef HP100_DEBUG_B 1088 int ioaddr = dev->base_addr; 1089#endif 1090 1091#ifdef HP100_DEBUG_B 1092 hp100_outw(0x4204, TRACE); 1093 printk("hp100: %s: open\n", dev->name); 1094#endif 1095 1096 /* New: if bus is PCI or EISA, interrupts might be shared interrupts */ 1097 if (request_irq(dev->irq, hp100_interrupt, 1098 lp->bus == HP100_BUS_PCI || lp->bus == 1099 HP100_BUS_EISA ? IRQF_SHARED : 0, 1100 dev->name, dev)) { 1101 printk("hp100: %s: unable to get IRQ %d\n", dev->name, dev->irq); 1102 return -EAGAIN; 1103 } 1104 1105 netif_trans_update(dev); /* prevent tx timeout */ 1106 netif_start_queue(dev); 1107 1108 lp->lan_type = hp100_sense_lan(dev); 1109 lp->mac1_mode = HP100_MAC1MODE3; 1110 lp->mac2_mode = HP100_MAC2MODE3; 1111 memset(&lp->hash_bytes, 0x00, 8); 1112 1113 hp100_stop_interface(dev); 1114 1115 hp100_hwinit(dev); 1116 1117 hp100_start_interface(dev); /* sets mac modes, enables interrupts */ 1118 1119 return 0; 1120} 1121 1122/* The close function is called when the interface is to be brought down */ 1123static int hp100_close(struct net_device *dev) 1124{ 1125 int ioaddr = dev->base_addr; 1126 struct hp100_private *lp = netdev_priv(dev); 1127 1128#ifdef HP100_DEBUG_B 1129 hp100_outw(0x4205, TRACE); 1130 printk("hp100: %s: close\n", dev->name); 1131#endif 1132 1133 hp100_page(PERFORMANCE); 1134 hp100_outw(0xfefe, IRQ_MASK); /* mask off all IRQs */ 1135 1136 hp100_stop_interface(dev); 1137 1138 if (lp->lan_type == HP100_LAN_100) 1139 lp->hub_status = hp100_login_to_vg_hub(dev, 0); 1140 1141 netif_stop_queue(dev); 1142 1143 free_irq(dev->irq, dev); 1144 1145#ifdef HP100_DEBUG 1146 printk("hp100: %s: close LSW = 0x%x\n", dev->name, 1147 hp100_inw(OPTION_LSW)); 1148#endif 1149 1150 return 0; 1151} 1152 1153 1154/* 1155 * Configure the PDL Rx rings and LAN 1156 */ 1157static void hp100_init_pdls(struct net_device *dev) 1158{ 1159 struct hp100_private *lp = netdev_priv(dev); 1160 hp100_ring_t *ringptr; 1161 u_int *pageptr; /* Warning : increment by 4 - Jean II */ 1162 int i; 1163 1164#ifdef HP100_DEBUG_B 1165 int ioaddr = dev->base_addr; 1166#endif 1167 1168#ifdef HP100_DEBUG_B 1169 hp100_outw(0x4206, TRACE); 1170 printk("hp100: %s: init pdls\n", dev->name); 1171#endif 1172 1173 if (!lp->page_vaddr_algn) 1174 printk("hp100: %s: Warning: lp->page_vaddr_algn not initialised!\n", dev->name); 1175 else { 1176 /* pageptr shall point into the DMA accessible memory region */ 1177 /* we use this pointer to status the upper limit of allocated */ 1178 /* memory in the allocated page. */ 1179 /* note: align the pointers to the pci cache line size */ 1180 memset(lp->page_vaddr_algn, 0, MAX_RINGSIZE); /* Zero Rx/Tx ring page */ 1181 pageptr = lp->page_vaddr_algn; 1182 1183 lp->rxrcommit = 0; 1184 ringptr = lp->rxrhead = lp->rxrtail = &(lp->rxring[0]); 1185 1186 /* Initialise Rx Ring */ 1187 for (i = MAX_RX_PDL - 1; i >= 0; i--) { 1188 lp->rxring[i].next = ringptr; 1189 ringptr = &(lp->rxring[i]); 1190 pageptr += hp100_init_rxpdl(dev, ringptr, pageptr); 1191 } 1192 1193 /* Initialise Tx Ring */ 1194 lp->txrcommit = 0; 1195 ringptr = lp->txrhead = lp->txrtail = &(lp->txring[0]); 1196 for (i = MAX_TX_PDL - 1; i >= 0; i--) { 1197 lp->txring[i].next = ringptr; 1198 ringptr = &(lp->txring[i]); 1199 pageptr += hp100_init_txpdl(dev, ringptr, pageptr); 1200 } 1201 } 1202} 1203 1204 1205/* These functions "format" the entries in the pdl structure */ 1206/* They return how much memory the fragments need. */ 1207static int hp100_init_rxpdl(struct net_device *dev, 1208 register hp100_ring_t * ringptr, 1209 register u32 * pdlptr) 1210{ 1211 /* pdlptr is starting address for this pdl */ 1212 1213 if (0 != (((unsigned long) pdlptr) & 0xf)) 1214 printk("hp100: %s: Init rxpdl: Unaligned pdlptr 0x%lx.\n", 1215 dev->name, (unsigned long) pdlptr); 1216 1217 ringptr->pdl = pdlptr + 1; 1218 ringptr->pdl_paddr = virt_to_whatever(dev, pdlptr + 1); 1219 ringptr->skb = NULL; 1220 1221 /* 1222 * Write address and length of first PDL Fragment (which is used for 1223 * storing the RX-Header 1224 * We use the 4 bytes _before_ the PDH in the pdl memory area to 1225 * store this information. (PDH is at offset 0x04) 1226 */ 1227 /* Note that pdlptr+1 and not pdlptr is the pointer to the PDH */ 1228 1229 *(pdlptr + 2) = (u_int) virt_to_whatever(dev, pdlptr); /* Address Frag 1 */ 1230 *(pdlptr + 3) = 4; /* Length Frag 1 */ 1231 1232 return roundup(MAX_RX_FRAG * 2 + 2, 4); 1233} 1234 1235 1236static int hp100_init_txpdl(struct net_device *dev, 1237 register hp100_ring_t * ringptr, 1238 register u32 * pdlptr) 1239{ 1240 if (0 != (((unsigned long) pdlptr) & 0xf)) 1241 printk("hp100: %s: Init txpdl: Unaligned pdlptr 0x%lx.\n", dev->name, (unsigned long) pdlptr); 1242 1243 ringptr->pdl = pdlptr; /* +1; */ 1244 ringptr->pdl_paddr = virt_to_whatever(dev, pdlptr); /* +1 */ 1245 ringptr->skb = NULL; 1246 1247 return roundup(MAX_TX_FRAG * 2 + 2, 4); 1248} 1249 1250/* 1251 * hp100_build_rx_pdl allocates an skb_buff of maximum size plus two bytes 1252 * for possible odd word alignment rounding up to next dword and set PDL 1253 * address for fragment#2 1254 * Returns: 0 if unable to allocate skb_buff 1255 * 1 if successful 1256 */ 1257static int hp100_build_rx_pdl(hp100_ring_t * ringptr, 1258 struct net_device *dev) 1259{ 1260#ifdef HP100_DEBUG_B 1261 int ioaddr = dev->base_addr; 1262#endif 1263#ifdef HP100_DEBUG_BM 1264 u_int *p; 1265#endif 1266 1267#ifdef HP100_DEBUG_B 1268 hp100_outw(0x4207, TRACE); 1269 printk("hp100: %s: build rx pdl\n", dev->name); 1270#endif 1271 1272 /* Allocate skb buffer of maximum size */ 1273 /* Note: This depends on the alloc_skb functions allocating more 1274 * space than requested, i.e. aligning to 16bytes */ 1275 1276 ringptr->skb = netdev_alloc_skb(dev, roundup(MAX_ETHER_SIZE + 2, 4)); 1277 1278 if (NULL != ringptr->skb) { 1279 /* 1280 * Reserve 2 bytes at the head of the buffer to land the IP header 1281 * on a long word boundary (According to the Network Driver section 1282 * in the Linux KHG, this should help to increase performance.) 1283 */ 1284 skb_reserve(ringptr->skb, 2); 1285 1286 ringptr->skb->data = (u_char *) skb_put(ringptr->skb, MAX_ETHER_SIZE); 1287 1288 /* ringptr->pdl points to the beginning of the PDL, i.e. the PDH */ 1289 /* Note: 1st Fragment is used for the 4 byte packet status 1290 * (receive header). Its PDL entries are set up by init_rxpdl. So 1291 * here we only have to set up the PDL fragment entries for the data 1292 * part. Those 4 bytes will be stored in the DMA memory region 1293 * directly before the PDL. 1294 */ 1295#ifdef HP100_DEBUG_BM 1296 printk("hp100: %s: build_rx_pdl: PDH@0x%x, skb->data (len %d) at 0x%x\n", 1297 dev->name, (u_int) ringptr->pdl, 1298 roundup(MAX_ETHER_SIZE + 2, 4), 1299 (unsigned int) ringptr->skb->data); 1300#endif 1301 1302 /* Conversion to new PCI API : map skbuf data to PCI bus. 1303 * Doc says it's OK for EISA as well - Jean II */ 1304 ringptr->pdl[0] = 0x00020000; /* Write PDH */ 1305 ringptr->pdl[3] = pdl_map_data(netdev_priv(dev), 1306 ringptr->skb->data); 1307 ringptr->pdl[4] = MAX_ETHER_SIZE; /* Length of Data */ 1308 1309#ifdef HP100_DEBUG_BM 1310 for (p = (ringptr->pdl); p < (ringptr->pdl + 5); p++) 1311 printk("hp100: %s: Adr 0x%.8x = 0x%.8x\n", dev->name, (u_int) p, (u_int) * p); 1312#endif 1313 return 1; 1314 } 1315 /* else: */ 1316 /* alloc_skb failed (no memory) -> still can receive the header 1317 * fragment into PDL memory. make PDL safe by clearing msgptr and 1318 * making the PDL only 1 fragment (i.e. the 4 byte packet status) 1319 */ 1320#ifdef HP100_DEBUG_BM 1321 printk("hp100: %s: build_rx_pdl: PDH@0x%x, No space for skb.\n", dev->name, (u_int) ringptr->pdl); 1322#endif 1323 1324 ringptr->pdl[0] = 0x00010000; /* PDH: Count=1 Fragment */ 1325 1326 return 0; 1327} 1328 1329/* 1330 * hp100_rxfill - attempt to fill the Rx Ring will empty skb's 1331 * 1332 * Makes assumption that skb's are always contiguous memory areas and 1333 * therefore PDLs contain only 2 physical fragments. 1334 * - While the number of Rx PDLs with buffers is less than maximum 1335 * a. Get a maximum packet size skb 1336 * b. Put the physical address of the buffer into the PDL. 1337 * c. Output physical address of PDL to adapter. 1338 */ 1339static void hp100_rxfill(struct net_device *dev) 1340{ 1341 int ioaddr = dev->base_addr; 1342 1343 struct hp100_private *lp = netdev_priv(dev); 1344 hp100_ring_t *ringptr; 1345 1346#ifdef HP100_DEBUG_B 1347 hp100_outw(0x4208, TRACE); 1348 printk("hp100: %s: rxfill\n", dev->name); 1349#endif 1350 1351 hp100_page(PERFORMANCE); 1352 1353 while (lp->rxrcommit < MAX_RX_PDL) { 1354 /* 1355 ** Attempt to get a buffer and build a Rx PDL. 1356 */ 1357 ringptr = lp->rxrtail; 1358 if (0 == hp100_build_rx_pdl(ringptr, dev)) { 1359 return; /* None available, return */ 1360 } 1361 1362 /* Hand this PDL over to the card */ 1363 /* Note: This needs performance page selected! */ 1364#ifdef HP100_DEBUG_BM 1365 printk("hp100: %s: rxfill: Hand to card: pdl #%d @0x%x phys:0x%x, buffer: 0x%x\n", 1366 dev->name, lp->rxrcommit, (u_int) ringptr->pdl, 1367 (u_int) ringptr->pdl_paddr, (u_int) ringptr->pdl[3]); 1368#endif 1369 1370 hp100_outl((u32) ringptr->pdl_paddr, RX_PDA); 1371 1372 lp->rxrcommit += 1; 1373 lp->rxrtail = ringptr->next; 1374 } 1375} 1376 1377/* 1378 * BM_shutdown - shutdown bus mastering and leave chip in reset state 1379 */ 1380 1381static void hp100_BM_shutdown(struct net_device *dev) 1382{ 1383 int ioaddr = dev->base_addr; 1384 struct hp100_private *lp = netdev_priv(dev); 1385 unsigned long time; 1386 1387#ifdef HP100_DEBUG_B 1388 hp100_outw(0x4209, TRACE); 1389 printk("hp100: %s: bm shutdown\n", dev->name); 1390#endif 1391 1392 hp100_page(PERFORMANCE); 1393 hp100_outw(0xfefe, IRQ_MASK); /* mask off all ints */ 1394 hp100_outw(0xffff, IRQ_STATUS); /* Ack all ints */ 1395 1396 /* Ensure Interrupts are off */ 1397 hp100_outw(HP100_INT_EN | HP100_RESET_LB, OPTION_LSW); 1398 1399 /* Disable all MAC activity */ 1400 hp100_page(MAC_CTRL); 1401 hp100_andb(~(HP100_RX_EN | HP100_TX_EN), MAC_CFG_1); /* stop rx/tx */ 1402 1403 /* If cascade MMU is not already in reset */ 1404 if (0 != (hp100_inw(OPTION_LSW) & HP100_HW_RST)) { 1405 /* Wait 1.3ms (10Mb max packet time) to ensure MAC is idle so 1406 * MMU pointers will not be reset out from underneath 1407 */ 1408 hp100_page(MAC_CTRL); 1409 for (time = 0; time < 5000; time++) { 1410 if ((hp100_inb(MAC_CFG_1) & (HP100_TX_IDLE | HP100_RX_IDLE)) == (HP100_TX_IDLE | HP100_RX_IDLE)) 1411 break; 1412 } 1413 1414 /* Shutdown algorithm depends on the generation of Cascade */ 1415 if (lp->chip == HP100_CHIPID_LASSEN) { /* ETR shutdown/reset */ 1416 /* Disable Busmaster mode and wait for bit to go to zero. */ 1417 hp100_page(HW_MAP); 1418 hp100_andb(~HP100_BM_MASTER, BM); 1419 /* 100 ms timeout */ 1420 for (time = 0; time < 32000; time++) { 1421 if (0 == (hp100_inb(BM) & HP100_BM_MASTER)) 1422 break; 1423 } 1424 } else { /* Shasta or Rainier Shutdown/Reset */ 1425 /* To ensure all bus master inloading activity has ceased, 1426 * wait for no Rx PDAs or no Rx packets on card. 1427 */ 1428 hp100_page(PERFORMANCE); 1429 /* 100 ms timeout */ 1430 for (time = 0; time < 10000; time++) { 1431 /* RX_PDL: PDLs not executed. */ 1432 /* RX_PKT_CNT: RX'd packets on card. */ 1433 if ((hp100_inb(RX_PDL) == 0) && (hp100_inb(RX_PKT_CNT) == 0)) 1434 break; 1435 } 1436 1437 if (time >= 10000) 1438 printk("hp100: %s: BM shutdown error.\n", dev->name); 1439 1440 /* To ensure all bus master outloading activity has ceased, 1441 * wait until the Tx PDA count goes to zero or no more Tx space 1442 * available in the Tx region of the card. 1443 */ 1444 /* 100 ms timeout */ 1445 for (time = 0; time < 10000; time++) { 1446 if ((0 == hp100_inb(TX_PKT_CNT)) && 1447 (0 != (hp100_inb(TX_MEM_FREE) & HP100_AUTO_COMPARE))) 1448 break; 1449 } 1450 1451 /* Disable Busmaster mode */ 1452 hp100_page(HW_MAP); 1453 hp100_andb(~HP100_BM_MASTER, BM); 1454 } /* end of shutdown procedure for non-etr parts */ 1455 1456 hp100_cascade_reset(dev, 1); 1457 } 1458 hp100_page(PERFORMANCE); 1459 /* hp100_outw( HP100_BM_READ | HP100_BM_WRITE | HP100_RESET_HB, OPTION_LSW ); */ 1460 /* Busmaster mode should be shut down now. */ 1461} 1462 1463static int hp100_check_lan(struct net_device *dev) 1464{ 1465 struct hp100_private *lp = netdev_priv(dev); 1466 1467 if (lp->lan_type < 0) { /* no LAN type detected yet? */ 1468 hp100_stop_interface(dev); 1469 if ((lp->lan_type = hp100_sense_lan(dev)) < 0) { 1470 printk("hp100: %s: no connection found - check wire\n", dev->name); 1471 hp100_start_interface(dev); /* 10Mb/s RX packets maybe handled */ 1472 return -EIO; 1473 } 1474 if (lp->lan_type == HP100_LAN_100) 1475 lp->hub_status = hp100_login_to_vg_hub(dev, 0); /* relogin */ 1476 hp100_start_interface(dev); 1477 } 1478 return 0; 1479} 1480 1481/* 1482 * transmit functions 1483 */ 1484 1485/* tx function for busmaster mode */ 1486static netdev_tx_t hp100_start_xmit_bm(struct sk_buff *skb, 1487 struct net_device *dev) 1488{ 1489 unsigned long flags; 1490 int i, ok_flag; 1491 int ioaddr = dev->base_addr; 1492 struct hp100_private *lp = netdev_priv(dev); 1493 hp100_ring_t *ringptr; 1494 1495#ifdef HP100_DEBUG_B 1496 hp100_outw(0x4210, TRACE); 1497 printk("hp100: %s: start_xmit_bm\n", dev->name); 1498#endif 1499 if (skb->len <= 0) 1500 goto drop; 1501 1502 if (lp->chip == HP100_CHIPID_SHASTA && skb_padto(skb, ETH_ZLEN)) 1503 return NETDEV_TX_OK; 1504 1505 /* Get Tx ring tail pointer */ 1506 if (lp->txrtail->next == lp->txrhead) { 1507 /* No memory. */ 1508#ifdef HP100_DEBUG 1509 printk("hp100: %s: start_xmit_bm: No TX PDL available.\n", dev->name); 1510#endif 1511 /* not waited long enough since last tx? */ 1512 if (time_before(jiffies, dev_trans_start(dev) + HZ)) 1513 goto drop; 1514 1515 if (hp100_check_lan(dev)) 1516 goto drop; 1517 1518 if (lp->lan_type == HP100_LAN_100 && lp->hub_status < 0) { 1519 /* we have a 100Mb/s adapter but it isn't connected to hub */ 1520 printk("hp100: %s: login to 100Mb/s hub retry\n", dev->name); 1521 hp100_stop_interface(dev); 1522 lp->hub_status = hp100_login_to_vg_hub(dev, 0); 1523 hp100_start_interface(dev); 1524 } else { 1525 spin_lock_irqsave(&lp->lock, flags); 1526 hp100_ints_off(); /* Useful ? Jean II */ 1527 i = hp100_sense_lan(dev); 1528 hp100_ints_on(); 1529 spin_unlock_irqrestore(&lp->lock, flags); 1530 if (i == HP100_LAN_ERR) 1531 printk("hp100: %s: link down detected\n", dev->name); 1532 else if (lp->lan_type != i) { /* cable change! */ 1533 /* it's very hard - all network settings must be changed!!! */ 1534 printk("hp100: %s: cable change 10Mb/s <-> 100Mb/s detected\n", dev->name); 1535 lp->lan_type = i; 1536 hp100_stop_interface(dev); 1537 if (lp->lan_type == HP100_LAN_100) 1538 lp->hub_status = hp100_login_to_vg_hub(dev, 0); 1539 hp100_start_interface(dev); 1540 } else { 1541 printk("hp100: %s: interface reset\n", dev->name); 1542 hp100_stop_interface(dev); 1543 if (lp->lan_type == HP100_LAN_100) 1544 lp->hub_status = hp100_login_to_vg_hub(dev, 0); 1545 hp100_start_interface(dev); 1546 } 1547 } 1548 1549 goto drop; 1550 } 1551 1552 /* 1553 * we have to turn int's off before modifying this, otherwise 1554 * a tx_pdl_cleanup could occur at the same time 1555 */ 1556 spin_lock_irqsave(&lp->lock, flags); 1557 ringptr = lp->txrtail; 1558 lp->txrtail = ringptr->next; 1559 1560 /* Check whether packet has minimal packet size */ 1561 ok_flag = skb->len >= HP100_MIN_PACKET_SIZE; 1562 i = ok_flag ? skb->len : HP100_MIN_PACKET_SIZE; 1563 1564 ringptr->skb = skb; 1565 ringptr->pdl[0] = ((1 << 16) | i); /* PDH: 1 Fragment & length */ 1566 if (lp->chip == HP100_CHIPID_SHASTA) { 1567 /* TODO:Could someone who has the EISA card please check if this works? */ 1568 ringptr->pdl[2] = i; 1569 } else { /* Lassen */ 1570 /* In the PDL, don't use the padded size but the real packet size: */ 1571 ringptr->pdl[2] = skb->len; /* 1st Frag: Length of frag */ 1572 } 1573 /* Conversion to new PCI API : map skbuf data to PCI bus. 1574 * Doc says it's OK for EISA as well - Jean II */ 1575 ringptr->pdl[1] = ((u32) pci_map_single(lp->pci_dev, skb->data, ringptr->pdl[2], PCI_DMA_TODEVICE)); /* 1st Frag: Adr. of data */ 1576 1577 /* Hand this PDL to the card. */ 1578 hp100_outl(ringptr->pdl_paddr, TX_PDA_L); /* Low Prio. Queue */ 1579 1580 lp->txrcommit++; 1581 1582 dev->stats.tx_packets++; 1583 dev->stats.tx_bytes += skb->len; 1584 1585 spin_unlock_irqrestore(&lp->lock, flags); 1586 1587 return NETDEV_TX_OK; 1588 1589drop: 1590 dev_kfree_skb(skb); 1591 return NETDEV_TX_OK; 1592} 1593 1594 1595/* clean_txring checks if packets have been sent by the card by reading 1596 * the TX_PDL register from the performance page and comparing it to the 1597 * number of committed packets. It then frees the skb's of the packets that 1598 * obviously have been sent to the network. 1599 * 1600 * Needs the PERFORMANCE page selected. 1601 */ 1602static void hp100_clean_txring(struct net_device *dev) 1603{ 1604 struct hp100_private *lp = netdev_priv(dev); 1605 int ioaddr = dev->base_addr; 1606 int donecount; 1607 1608#ifdef HP100_DEBUG_B 1609 hp100_outw(0x4211, TRACE); 1610 printk("hp100: %s: clean txring\n", dev->name); 1611#endif 1612 1613 /* How many PDLs have been transmitted? */ 1614 donecount = (lp->txrcommit) - hp100_inb(TX_PDL); 1615 1616#ifdef HP100_DEBUG 1617 if (donecount > MAX_TX_PDL) 1618 printk("hp100: %s: Warning: More PDLs transmitted than committed to card???\n", dev->name); 1619#endif 1620 1621 for (; 0 != donecount; donecount--) { 1622#ifdef HP100_DEBUG_BM 1623 printk("hp100: %s: Free skb: data @0x%.8x txrcommit=0x%x TXPDL=0x%x, done=0x%x\n", 1624 dev->name, (u_int) lp->txrhead->skb->data, 1625 lp->txrcommit, hp100_inb(TX_PDL), donecount); 1626#endif 1627 /* Conversion to new PCI API : NOP */ 1628 pci_unmap_single(lp->pci_dev, (dma_addr_t) lp->txrhead->pdl[1], lp->txrhead->pdl[2], PCI_DMA_TODEVICE); 1629 dev_consume_skb_any(lp->txrhead->skb); 1630 lp->txrhead->skb = NULL; 1631 lp->txrhead = lp->txrhead->next; 1632 lp->txrcommit--; 1633 } 1634} 1635 1636/* tx function for slave modes */ 1637static netdev_tx_t hp100_start_xmit(struct sk_buff *skb, 1638 struct net_device *dev) 1639{ 1640 unsigned long flags; 1641 int i, ok_flag; 1642 int ioaddr = dev->base_addr; 1643 u_short val; 1644 struct hp100_private *lp = netdev_priv(dev); 1645 1646#ifdef HP100_DEBUG_B 1647 hp100_outw(0x4212, TRACE); 1648 printk("hp100: %s: start_xmit\n", dev->name); 1649#endif 1650 if (skb->len <= 0) 1651 goto drop; 1652 1653 if (hp100_check_lan(dev)) 1654 goto drop; 1655 1656 /* If there is not enough free memory on the card... */ 1657 i = hp100_i…
Large files files are truncated, but you can click here to view the full file