Linux kernel mirror (for testing) git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel os linux

drivers/net: delete the really obsolete 8390 based 10Mbit ISA drivers

This is an area I know all too well, after being author of several 8390
drivers, and maintainer of all 8390 drivers during a large part of their
active lifecycle.

To that end, I can say this with a reasonable degree of confidence.
The drivers deleted here represent the earliest (as in early 1990)
hardware and/or rare hardware. The remaining hardware not deleted
here is the more modern/sane of the lot, with ISA-PnP and jumperless
"soft configuration" like the wd and smc cards had.

The original ne2000 driver (ne.c) gets a pass at this time since
AT/LANTIC based cards that could be both ne2000 or wd-like (with
shared memory) and with jumperless configuration were made in the
mid to late 1990's, and performed reasonably well for their era.

Signed-off-by: Paul Gortmaker <paul.gortmaker@windriver.com>

-2369
-16
drivers/net/Space.c
··· 40 40 extern struct net_device *hp100_probe(int unit); 41 41 extern struct net_device *ultra_probe(int unit); 42 42 extern struct net_device *wd_probe(int unit); 43 - extern struct net_device *el2_probe(int unit); 44 43 extern struct net_device *ne_probe(int unit); 45 - extern struct net_device *hp_probe(int unit); 46 - extern struct net_device *hp_plus_probe(int unit); 47 44 extern struct net_device *fmv18x_probe(int unit); 48 45 extern struct net_device *i82596_probe(int unit); 49 46 extern struct net_device *ewrk3_probe(int unit); 50 - extern struct net_device *e2100_probe(int unit); 51 47 extern struct net_device *ni65_probe(int unit); 52 48 extern struct net_device *sonic_probe(int unit); 53 49 extern struct net_device *seeq8005_probe(int unit); ··· 103 107 #endif 104 108 #ifdef CONFIG_WD80x3 105 109 {wd_probe, 0}, 106 - #endif 107 - #ifdef CONFIG_EL2 /* 3c503 */ 108 - {el2_probe, 0}, 109 - #endif 110 - #ifdef CONFIG_HPLAN 111 - {hp_probe, 0}, 112 - #endif 113 - #ifdef CONFIG_HPLAN_PLUS 114 - {hp_plus_probe, 0}, 115 - #endif 116 - #ifdef CONFIG_E2100 /* Cabletron E21xx series. */ 117 - {e2100_probe, 0}, 118 110 #endif 119 111 #if defined(CONFIG_NE2000) || \ 120 112 defined(CONFIG_NE_H8300) /* ISA (use ne2k-pci for PCI cards) */
-778
drivers/net/ethernet/8390/3c503.c
··· 1 - /* 3c503.c: A shared-memory NS8390 ethernet driver for linux. */ 2 - /* 3 - Written 1992-94 by Donald Becker. 4 - 5 - Copyright 1993 United States Government as represented by the 6 - Director, National Security Agency. This software may be used and 7 - distributed according to the terms of the GNU General Public License, 8 - incorporated herein by reference. 9 - 10 - The author may be reached as becker@scyld.com, or C/O 11 - Scyld Computing Corporation 12 - 410 Severn Ave., Suite 210 13 - Annapolis MD 21403 14 - 15 - 16 - This driver should work with the 3c503 and 3c503/16. It should be used 17 - in shared memory mode for best performance, although it may also work 18 - in programmed-I/O mode. 19 - 20 - Sources: 21 - EtherLink II Technical Reference Manual, 22 - EtherLink II/16 Technical Reference Manual Supplement, 23 - 3Com Corporation, 5400 Bayfront Plaza, Santa Clara CA 95052-8145 24 - 25 - The Crynwr 3c503 packet driver. 26 - 27 - Changelog: 28 - 29 - Paul Gortmaker : add support for the 2nd 8kB of RAM on 16 bit cards. 30 - Paul Gortmaker : multiple card support for module users. 31 - rjohnson@analogic.com : Fix up PIO interface for efficient operation. 32 - Jeff Garzik : ethtool support 33 - 34 - */ 35 - 36 - #define DRV_NAME "3c503" 37 - #define DRV_VERSION "1.10a" 38 - #define DRV_RELDATE "11/17/2001" 39 - 40 - 41 - static const char version[] = 42 - DRV_NAME ".c:v" DRV_VERSION " " DRV_RELDATE " Donald Becker (becker@scyld.com)\n"; 43 - 44 - #include <linux/module.h> 45 - #include <linux/kernel.h> 46 - #include <linux/errno.h> 47 - #include <linux/string.h> 48 - #include <linux/delay.h> 49 - #include <linux/netdevice.h> 50 - #include <linux/etherdevice.h> 51 - #include <linux/init.h> 52 - #include <linux/interrupt.h> 53 - #include <linux/ethtool.h> 54 - 55 - #include <asm/uaccess.h> 56 - #include <asm/io.h> 57 - #include <asm/byteorder.h> 58 - 59 - #include "8390.h" 60 - #include "3c503.h" 61 - #define WRD_COUNT 4 62 - 63 - static int el2_pio_probe(struct net_device *dev); 64 - static int el2_probe1(struct net_device *dev, int ioaddr); 65 - 66 - /* A zero-terminated list of I/O addresses to be probed in PIO mode. */ 67 - static unsigned int netcard_portlist[] __initdata = 68 - { 0x300,0x310,0x330,0x350,0x250,0x280,0x2a0,0x2e0,0}; 69 - 70 - #define EL2_IO_EXTENT 16 71 - 72 - static int el2_open(struct net_device *dev); 73 - static int el2_close(struct net_device *dev); 74 - static void el2_reset_8390(struct net_device *dev); 75 - static void el2_init_card(struct net_device *dev); 76 - static void el2_block_output(struct net_device *dev, int count, 77 - const unsigned char *buf, int start_page); 78 - static void el2_block_input(struct net_device *dev, int count, struct sk_buff *skb, 79 - int ring_offset); 80 - static void el2_get_8390_hdr(struct net_device *dev, struct e8390_pkt_hdr *hdr, 81 - int ring_page); 82 - static const struct ethtool_ops netdev_ethtool_ops; 83 - 84 - 85 - /* This routine probes for a memory-mapped 3c503 board by looking for 86 - the "location register" at the end of the jumpered boot PROM space. 87 - This works even if a PROM isn't there. 88 - 89 - If the ethercard isn't found there is an optional probe for 90 - ethercard jumpered to programmed-I/O mode. 91 - */ 92 - static int __init do_el2_probe(struct net_device *dev) 93 - { 94 - int *addr, addrs[] = { 0xddffe, 0xd9ffe, 0xcdffe, 0xc9ffe, 0}; 95 - int base_addr = dev->base_addr; 96 - int irq = dev->irq; 97 - 98 - if (base_addr > 0x1ff) /* Check a single specified location. */ 99 - return el2_probe1(dev, base_addr); 100 - else if (base_addr != 0) /* Don't probe at all. */ 101 - return -ENXIO; 102 - 103 - for (addr = addrs; *addr; addr++) { 104 - void __iomem *p = ioremap(*addr, 1); 105 - unsigned base_bits; 106 - int i; 107 - 108 - if (!p) 109 - continue; 110 - base_bits = readb(p); 111 - iounmap(p); 112 - i = ffs(base_bits) - 1; 113 - if (i == -1 || base_bits != (1 << i)) 114 - continue; 115 - if (el2_probe1(dev, netcard_portlist[i]) == 0) 116 - return 0; 117 - dev->irq = irq; 118 - } 119 - #if ! defined(no_probe_nonshared_memory) 120 - return el2_pio_probe(dev); 121 - #else 122 - return -ENODEV; 123 - #endif 124 - } 125 - 126 - /* Try all of the locations that aren't obviously empty. This touches 127 - a lot of locations, and is much riskier than the code above. */ 128 - static int __init 129 - el2_pio_probe(struct net_device *dev) 130 - { 131 - int i; 132 - int base_addr = dev->base_addr; 133 - int irq = dev->irq; 134 - 135 - if (base_addr > 0x1ff) /* Check a single specified location. */ 136 - return el2_probe1(dev, base_addr); 137 - else if (base_addr != 0) /* Don't probe at all. */ 138 - return -ENXIO; 139 - 140 - for (i = 0; netcard_portlist[i]; i++) { 141 - if (el2_probe1(dev, netcard_portlist[i]) == 0) 142 - return 0; 143 - dev->irq = irq; 144 - } 145 - 146 - return -ENODEV; 147 - } 148 - 149 - #ifndef MODULE 150 - struct net_device * __init el2_probe(int unit) 151 - { 152 - struct net_device *dev = alloc_eip_netdev(); 153 - int err; 154 - 155 - if (!dev) 156 - return ERR_PTR(-ENOMEM); 157 - 158 - sprintf(dev->name, "eth%d", unit); 159 - netdev_boot_setup_check(dev); 160 - 161 - err = do_el2_probe(dev); 162 - if (err) 163 - goto out; 164 - return dev; 165 - out: 166 - free_netdev(dev); 167 - return ERR_PTR(err); 168 - } 169 - #endif 170 - 171 - static const struct net_device_ops el2_netdev_ops = { 172 - .ndo_open = el2_open, 173 - .ndo_stop = el2_close, 174 - 175 - .ndo_start_xmit = eip_start_xmit, 176 - .ndo_tx_timeout = eip_tx_timeout, 177 - .ndo_get_stats = eip_get_stats, 178 - .ndo_set_rx_mode = eip_set_multicast_list, 179 - .ndo_validate_addr = eth_validate_addr, 180 - .ndo_set_mac_address = eth_mac_addr, 181 - .ndo_change_mtu = eth_change_mtu, 182 - #ifdef CONFIG_NET_POLL_CONTROLLER 183 - .ndo_poll_controller = eip_poll, 184 - #endif 185 - }; 186 - 187 - /* Probe for the Etherlink II card at I/O port base IOADDR, 188 - returning non-zero on success. If found, set the station 189 - address and memory parameters in DEVICE. */ 190 - static int __init 191 - el2_probe1(struct net_device *dev, int ioaddr) 192 - { 193 - int i, iobase_reg, membase_reg, saved_406, wordlength, retval; 194 - static unsigned version_printed; 195 - unsigned long vendor_id; 196 - 197 - if (!request_region(ioaddr, EL2_IO_EXTENT, DRV_NAME)) 198 - return -EBUSY; 199 - 200 - if (!request_region(ioaddr + 0x400, 8, DRV_NAME)) { 201 - retval = -EBUSY; 202 - goto out; 203 - } 204 - 205 - /* Reset and/or avoid any lurking NE2000 */ 206 - if (inb(ioaddr + 0x408) == 0xff) { 207 - mdelay(1); 208 - retval = -ENODEV; 209 - goto out1; 210 - } 211 - 212 - /* We verify that it's a 3C503 board by checking the first three octets 213 - of its ethernet address. */ 214 - iobase_reg = inb(ioaddr+0x403); 215 - membase_reg = inb(ioaddr+0x404); 216 - /* ASIC location registers should be 0 or have only a single bit set. */ 217 - if ((iobase_reg & (iobase_reg - 1)) || 218 - (membase_reg & (membase_reg - 1))) { 219 - retval = -ENODEV; 220 - goto out1; 221 - } 222 - saved_406 = inb_p(ioaddr + 0x406); 223 - outb_p(ECNTRL_RESET|ECNTRL_THIN, ioaddr + 0x406); /* Reset it... */ 224 - outb_p(ECNTRL_THIN, ioaddr + 0x406); 225 - /* Map the station addr PROM into the lower I/O ports. We now check 226 - for both the old and new 3Com prefix */ 227 - outb(ECNTRL_SAPROM|ECNTRL_THIN, ioaddr + 0x406); 228 - vendor_id = inb(ioaddr)*0x10000 + inb(ioaddr + 1)*0x100 + inb(ioaddr + 2); 229 - if ((vendor_id != OLD_3COM_ID) && (vendor_id != NEW_3COM_ID)) { 230 - /* Restore the register we frobbed. */ 231 - outb(saved_406, ioaddr + 0x406); 232 - retval = -ENODEV; 233 - goto out1; 234 - } 235 - 236 - if (ei_debug && version_printed++ == 0) 237 - pr_debug("%s", version); 238 - 239 - dev->base_addr = ioaddr; 240 - 241 - pr_info("%s: 3c503 at i/o base %#3x, node ", dev->name, ioaddr); 242 - 243 - /* Retrieve and print the ethernet address. */ 244 - for (i = 0; i < 6; i++) 245 - dev->dev_addr[i] = inb(ioaddr + i); 246 - pr_cont("%pM", dev->dev_addr); 247 - 248 - /* Map the 8390 back into the window. */ 249 - outb(ECNTRL_THIN, ioaddr + 0x406); 250 - 251 - /* Check for EL2/16 as described in tech. man. */ 252 - outb_p(E8390_PAGE0, ioaddr + E8390_CMD); 253 - outb_p(0, ioaddr + EN0_DCFG); 254 - outb_p(E8390_PAGE2, ioaddr + E8390_CMD); 255 - wordlength = inb_p(ioaddr + EN0_DCFG) & ENDCFG_WTS; 256 - outb_p(E8390_PAGE0, ioaddr + E8390_CMD); 257 - 258 - /* Probe for, turn on and clear the board's shared memory. */ 259 - if (ei_debug > 2) 260 - pr_cont(" memory jumpers %2.2x ", membase_reg); 261 - outb(EGACFR_NORM, ioaddr + 0x405); /* Enable RAM */ 262 - 263 - /* This should be probed for (or set via an ioctl()) at run-time. 264 - Right now we use a sleazy hack to pass in the interface number 265 - at boot-time via the low bits of the mem_end field. That value is 266 - unused, and the low bits would be discarded even if it was used. */ 267 - #if defined(EI8390_THICK) || defined(EL2_AUI) 268 - ei_status.interface_num = 1; 269 - #else 270 - ei_status.interface_num = dev->mem_end & 0xf; 271 - #endif 272 - pr_cont(", using %sternal xcvr.\n", ei_status.interface_num == 0 ? "in" : "ex"); 273 - 274 - if ((membase_reg & 0xf0) == 0) { 275 - dev->mem_start = 0; 276 - ei_status.name = "3c503-PIO"; 277 - ei_status.mem = NULL; 278 - } else { 279 - dev->mem_start = ((membase_reg & 0xc0) ? 0xD8000 : 0xC8000) + 280 - ((membase_reg & 0xA0) ? 0x4000 : 0); 281 - #define EL2_MEMSIZE (EL2_MB1_STOP_PG - EL2_MB1_START_PG)*256 282 - ei_status.mem = ioremap(dev->mem_start, EL2_MEMSIZE); 283 - 284 - #ifdef EL2MEMTEST 285 - /* This has never found an error, but someone might care. 286 - Note that it only tests the 2nd 8kB on 16kB 3c503/16 287 - cards between card addr. 0x2000 and 0x3fff. */ 288 - { /* Check the card's memory. */ 289 - void __iomem *mem_base = ei_status.mem; 290 - unsigned int test_val = 0xbbadf00d; 291 - writel(0xba5eba5e, mem_base); 292 - for (i = sizeof(test_val); i < EL2_MEMSIZE; i+=sizeof(test_val)) { 293 - writel(test_val, mem_base + i); 294 - if (readl(mem_base) != 0xba5eba5e || 295 - readl(mem_base + i) != test_val) { 296 - pr_warning("3c503: memory failure or memory address conflict.\n"); 297 - dev->mem_start = 0; 298 - ei_status.name = "3c503-PIO"; 299 - iounmap(mem_base); 300 - ei_status.mem = NULL; 301 - break; 302 - } 303 - test_val += 0x55555555; 304 - writel(0, mem_base + i); 305 - } 306 - } 307 - #endif /* EL2MEMTEST */ 308 - 309 - if (dev->mem_start) 310 - dev->mem_end = dev->mem_start + EL2_MEMSIZE; 311 - 312 - if (wordlength) { /* No Tx pages to skip over to get to Rx */ 313 - ei_status.priv = 0; 314 - ei_status.name = "3c503/16"; 315 - } else { 316 - ei_status.priv = TX_PAGES * 256; 317 - ei_status.name = "3c503"; 318 - } 319 - } 320 - 321 - /* 322 - Divide up the memory on the card. This is the same regardless of 323 - whether shared-mem or PIO is used. For 16 bit cards (16kB RAM), 324 - we use the entire 8k of bank1 for an Rx ring. We only use 3k 325 - of the bank0 for 2 full size Tx packet slots. For 8 bit cards, 326 - (8kB RAM) we use 3kB of bank1 for two Tx slots, and the remaining 327 - 5kB for an Rx ring. */ 328 - 329 - if (wordlength) { 330 - ei_status.tx_start_page = EL2_MB0_START_PG; 331 - ei_status.rx_start_page = EL2_MB1_START_PG; 332 - } else { 333 - ei_status.tx_start_page = EL2_MB1_START_PG; 334 - ei_status.rx_start_page = EL2_MB1_START_PG + TX_PAGES; 335 - } 336 - 337 - /* Finish setting the board's parameters. */ 338 - ei_status.stop_page = EL2_MB1_STOP_PG; 339 - ei_status.word16 = wordlength; 340 - ei_status.reset_8390 = el2_reset_8390; 341 - ei_status.get_8390_hdr = el2_get_8390_hdr; 342 - ei_status.block_input = el2_block_input; 343 - ei_status.block_output = el2_block_output; 344 - 345 - if (dev->irq == 2) 346 - dev->irq = 9; 347 - else if (dev->irq > 5 && dev->irq != 9) { 348 - pr_warning("3c503: configured interrupt %d invalid, will use autoIRQ.\n", 349 - dev->irq); 350 - dev->irq = 0; 351 - } 352 - 353 - ei_status.saved_irq = dev->irq; 354 - 355 - dev->netdev_ops = &el2_netdev_ops; 356 - dev->ethtool_ops = &netdev_ethtool_ops; 357 - 358 - retval = register_netdev(dev); 359 - if (retval) 360 - goto out1; 361 - 362 - if (dev->mem_start) 363 - pr_info("%s: %s - %dkB RAM, 8kB shared mem window at %#6lx-%#6lx.\n", 364 - dev->name, ei_status.name, (wordlength+1)<<3, 365 - dev->mem_start, dev->mem_end-1); 366 - 367 - else 368 - { 369 - ei_status.tx_start_page = EL2_MB1_START_PG; 370 - ei_status.rx_start_page = EL2_MB1_START_PG + TX_PAGES; 371 - pr_info("%s: %s, %dkB RAM, using programmed I/O (REJUMPER for SHARED MEMORY).\n", 372 - dev->name, ei_status.name, (wordlength+1)<<3); 373 - } 374 - release_region(ioaddr + 0x400, 8); 375 - return 0; 376 - out1: 377 - release_region(ioaddr + 0x400, 8); 378 - out: 379 - release_region(ioaddr, EL2_IO_EXTENT); 380 - return retval; 381 - } 382 - 383 - static irqreturn_t el2_probe_interrupt(int irq, void *seen) 384 - { 385 - *(bool *)seen = true; 386 - return IRQ_HANDLED; 387 - } 388 - 389 - static int 390 - el2_open(struct net_device *dev) 391 - { 392 - int retval; 393 - 394 - if (dev->irq < 2) { 395 - static const int irqlist[] = {5, 9, 3, 4, 0}; 396 - const int *irqp = irqlist; 397 - 398 - outb(EGACFR_NORM, E33G_GACFR); /* Enable RAM and interrupts. */ 399 - do { 400 - bool seen; 401 - 402 - retval = request_irq(*irqp, el2_probe_interrupt, 0, 403 - dev->name, &seen); 404 - if (retval == -EBUSY) 405 - continue; 406 - if (retval < 0) 407 - goto err_disable; 408 - 409 - /* Twinkle the interrupt, and check if it's seen. */ 410 - seen = false; 411 - smp_wmb(); 412 - outb_p(0x04 << ((*irqp == 9) ? 2 : *irqp), E33G_IDCFR); 413 - outb_p(0x00, E33G_IDCFR); 414 - msleep(1); 415 - free_irq(*irqp, &seen); 416 - if (!seen) 417 - continue; 418 - 419 - retval = request_irq(dev->irq = *irqp, eip_interrupt, 0, 420 - dev->name, dev); 421 - if (retval == -EBUSY) 422 - continue; 423 - if (retval < 0) 424 - goto err_disable; 425 - break; 426 - } while (*++irqp); 427 - 428 - if (*irqp == 0) { 429 - err_disable: 430 - outb(EGACFR_IRQOFF, E33G_GACFR); /* disable interrupts. */ 431 - return -EAGAIN; 432 - } 433 - } else { 434 - if ((retval = request_irq(dev->irq, eip_interrupt, 0, dev->name, dev))) { 435 - return retval; 436 - } 437 - } 438 - 439 - el2_init_card(dev); 440 - eip_open(dev); 441 - return 0; 442 - } 443 - 444 - static int 445 - el2_close(struct net_device *dev) 446 - { 447 - free_irq(dev->irq, dev); 448 - dev->irq = ei_status.saved_irq; 449 - outb(EGACFR_IRQOFF, E33G_GACFR); /* disable interrupts. */ 450 - 451 - eip_close(dev); 452 - return 0; 453 - } 454 - 455 - /* This is called whenever we have a unrecoverable failure: 456 - transmit timeout 457 - Bad ring buffer packet header 458 - */ 459 - static void 460 - el2_reset_8390(struct net_device *dev) 461 - { 462 - if (ei_debug > 1) { 463 - pr_debug("%s: Resetting the 3c503 board...", dev->name); 464 - pr_cont(" %#lx=%#02x %#lx=%#02x %#lx=%#02x...", E33G_IDCFR, inb(E33G_IDCFR), 465 - E33G_CNTRL, inb(E33G_CNTRL), E33G_GACFR, inb(E33G_GACFR)); 466 - } 467 - outb_p(ECNTRL_RESET|ECNTRL_THIN, E33G_CNTRL); 468 - ei_status.txing = 0; 469 - outb_p(ei_status.interface_num==0 ? ECNTRL_THIN : ECNTRL_AUI, E33G_CNTRL); 470 - el2_init_card(dev); 471 - if (ei_debug > 1) 472 - pr_cont("done\n"); 473 - } 474 - 475 - /* Initialize the 3c503 GA registers after a reset. */ 476 - static void 477 - el2_init_card(struct net_device *dev) 478 - { 479 - /* Unmap the station PROM and select the DIX or BNC connector. */ 480 - outb_p(ei_status.interface_num==0 ? ECNTRL_THIN : ECNTRL_AUI, E33G_CNTRL); 481 - 482 - /* Set ASIC copy of rx's first and last+1 buffer pages */ 483 - /* These must be the same as in the 8390. */ 484 - outb(ei_status.rx_start_page, E33G_STARTPG); 485 - outb(ei_status.stop_page, E33G_STOPPG); 486 - 487 - /* Point the vector pointer registers somewhere ?harmless?. */ 488 - outb(0xff, E33G_VP2); /* Point at the ROM restart location 0xffff0 */ 489 - outb(0xff, E33G_VP1); 490 - outb(0x00, E33G_VP0); 491 - /* Turn off all interrupts until we're opened. */ 492 - outb_p(0x00, dev->base_addr + EN0_IMR); 493 - /* Enable IRQs iff started. */ 494 - outb(EGACFR_NORM, E33G_GACFR); 495 - 496 - /* Set the interrupt line. */ 497 - outb_p((0x04 << (dev->irq == 9 ? 2 : dev->irq)), E33G_IDCFR); 498 - outb_p((WRD_COUNT << 1), E33G_DRQCNT); /* Set burst size to 8 */ 499 - outb_p(0x20, E33G_DMAAH); /* Put a valid addr in the GA DMA */ 500 - outb_p(0x00, E33G_DMAAL); 501 - return; /* We always succeed */ 502 - } 503 - 504 - /* 505 - * Either use the shared memory (if enabled on the board) or put the packet 506 - * out through the ASIC FIFO. 507 - */ 508 - static void 509 - el2_block_output(struct net_device *dev, int count, 510 - const unsigned char *buf, int start_page) 511 - { 512 - unsigned short int *wrd; 513 - int boguscount; /* timeout counter */ 514 - unsigned short word; /* temporary for better machine code */ 515 - void __iomem *base = ei_status.mem; 516 - 517 - if (ei_status.word16) /* Tx packets go into bank 0 on EL2/16 card */ 518 - outb(EGACFR_RSEL|EGACFR_TCM, E33G_GACFR); 519 - else 520 - outb(EGACFR_NORM, E33G_GACFR); 521 - 522 - if (base) { /* Shared memory transfer */ 523 - memcpy_toio(base + ((start_page - ei_status.tx_start_page) << 8), 524 - buf, count); 525 - outb(EGACFR_NORM, E33G_GACFR); /* Back to bank1 in case on bank0 */ 526 - return; 527 - } 528 - 529 - /* 530 - * No shared memory, put the packet out the other way. 531 - * Set up then start the internal memory transfer to Tx Start Page 532 - */ 533 - 534 - word = (unsigned short)start_page; 535 - outb(word&0xFF, E33G_DMAAH); 536 - outb(word>>8, E33G_DMAAL); 537 - 538 - outb_p((ei_status.interface_num ? ECNTRL_AUI : ECNTRL_THIN ) | ECNTRL_OUTPUT 539 - | ECNTRL_START, E33G_CNTRL); 540 - 541 - /* 542 - * Here I am going to write data to the FIFO as quickly as possible. 543 - * Note that E33G_FIFOH is defined incorrectly. It is really 544 - * E33G_FIFOL, the lowest port address for both the byte and 545 - * word write. Variable 'count' is NOT checked. Caller must supply a 546 - * valid count. Note that I may write a harmless extra byte to the 547 - * 8390 if the byte-count was not even. 548 - */ 549 - wrd = (unsigned short int *) buf; 550 - count = (count + 1) >> 1; 551 - for(;;) 552 - { 553 - boguscount = 0x1000; 554 - while ((inb(E33G_STATUS) & ESTAT_DPRDY) == 0) 555 - { 556 - if(!boguscount--) 557 - { 558 - pr_notice("%s: FIFO blocked in el2_block_output.\n", dev->name); 559 - el2_reset_8390(dev); 560 - goto blocked; 561 - } 562 - } 563 - if(count > WRD_COUNT) 564 - { 565 - outsw(E33G_FIFOH, wrd, WRD_COUNT); 566 - wrd += WRD_COUNT; 567 - count -= WRD_COUNT; 568 - } 569 - else 570 - { 571 - outsw(E33G_FIFOH, wrd, count); 572 - break; 573 - } 574 - } 575 - blocked:; 576 - outb_p(ei_status.interface_num==0 ? ECNTRL_THIN : ECNTRL_AUI, E33G_CNTRL); 577 - } 578 - 579 - /* Read the 4 byte, page aligned 8390 specific header. */ 580 - static void 581 - el2_get_8390_hdr(struct net_device *dev, struct e8390_pkt_hdr *hdr, int ring_page) 582 - { 583 - int boguscount; 584 - void __iomem *base = ei_status.mem; 585 - unsigned short word; 586 - 587 - if (base) { /* Use the shared memory. */ 588 - void __iomem *hdr_start = base + ((ring_page - EL2_MB1_START_PG)<<8); 589 - memcpy_fromio(hdr, hdr_start, sizeof(struct e8390_pkt_hdr)); 590 - hdr->count = le16_to_cpu(hdr->count); 591 - return; 592 - } 593 - 594 - /* 595 - * No shared memory, use programmed I/O. 596 - */ 597 - 598 - word = (unsigned short)ring_page; 599 - outb(word&0xFF, E33G_DMAAH); 600 - outb(word>>8, E33G_DMAAL); 601 - 602 - outb_p((ei_status.interface_num == 0 ? ECNTRL_THIN : ECNTRL_AUI) | ECNTRL_INPUT 603 - | ECNTRL_START, E33G_CNTRL); 604 - boguscount = 0x1000; 605 - while ((inb(E33G_STATUS) & ESTAT_DPRDY) == 0) 606 - { 607 - if(!boguscount--) 608 - { 609 - pr_notice("%s: FIFO blocked in el2_get_8390_hdr.\n", dev->name); 610 - memset(hdr, 0x00, sizeof(struct e8390_pkt_hdr)); 611 - el2_reset_8390(dev); 612 - goto blocked; 613 - } 614 - } 615 - insw(E33G_FIFOH, hdr, (sizeof(struct e8390_pkt_hdr))>> 1); 616 - blocked:; 617 - outb_p(ei_status.interface_num == 0 ? ECNTRL_THIN : ECNTRL_AUI, E33G_CNTRL); 618 - } 619 - 620 - 621 - static void 622 - el2_block_input(struct net_device *dev, int count, struct sk_buff *skb, int ring_offset) 623 - { 624 - int boguscount = 0; 625 - void __iomem *base = ei_status.mem; 626 - unsigned short int *buf; 627 - unsigned short word; 628 - 629 - /* Maybe enable shared memory just be to be safe... nahh.*/ 630 - if (base) { /* Use the shared memory. */ 631 - ring_offset -= (EL2_MB1_START_PG<<8); 632 - if (ring_offset + count > EL2_MEMSIZE) { 633 - /* We must wrap the input move. */ 634 - int semi_count = EL2_MEMSIZE - ring_offset; 635 - memcpy_fromio(skb->data, base + ring_offset, semi_count); 636 - count -= semi_count; 637 - memcpy_fromio(skb->data + semi_count, base + ei_status.priv, count); 638 - } else { 639 - memcpy_fromio(skb->data, base + ring_offset, count); 640 - } 641 - return; 642 - } 643 - 644 - /* 645 - * No shared memory, use programmed I/O. 646 - */ 647 - word = (unsigned short) ring_offset; 648 - outb(word>>8, E33G_DMAAH); 649 - outb(word&0xFF, E33G_DMAAL); 650 - 651 - outb_p((ei_status.interface_num == 0 ? ECNTRL_THIN : ECNTRL_AUI) | ECNTRL_INPUT 652 - | ECNTRL_START, E33G_CNTRL); 653 - 654 - /* 655 - * Here I also try to get data as fast as possible. I am betting that I 656 - * can read one extra byte without clobbering anything in the kernel because 657 - * this would only occur on an odd byte-count and allocation of skb->data 658 - * is word-aligned. Variable 'count' is NOT checked. Caller must check 659 - * for a valid count. 660 - * [This is currently quite safe.... but if one day the 3c503 explodes 661 - * you know where to come looking ;)] 662 - */ 663 - 664 - buf = (unsigned short int *) skb->data; 665 - count = (count + 1) >> 1; 666 - for(;;) 667 - { 668 - boguscount = 0x1000; 669 - while ((inb(E33G_STATUS) & ESTAT_DPRDY) == 0) 670 - { 671 - if(!boguscount--) 672 - { 673 - pr_notice("%s: FIFO blocked in el2_block_input.\n", dev->name); 674 - el2_reset_8390(dev); 675 - goto blocked; 676 - } 677 - } 678 - if(count > WRD_COUNT) 679 - { 680 - insw(E33G_FIFOH, buf, WRD_COUNT); 681 - buf += WRD_COUNT; 682 - count -= WRD_COUNT; 683 - } 684 - else 685 - { 686 - insw(E33G_FIFOH, buf, count); 687 - break; 688 - } 689 - } 690 - blocked:; 691 - outb_p(ei_status.interface_num == 0 ? ECNTRL_THIN : ECNTRL_AUI, E33G_CNTRL); 692 - } 693 - 694 - 695 - static void netdev_get_drvinfo(struct net_device *dev, 696 - struct ethtool_drvinfo *info) 697 - { 698 - strlcpy(info->driver, DRV_NAME, sizeof(info->driver)); 699 - strlcpy(info->version, DRV_VERSION, sizeof(info->version)); 700 - snprintf(info->bus_info, sizeof(info->bus_info), "ISA 0x%lx", 701 - dev->base_addr); 702 - } 703 - 704 - static const struct ethtool_ops netdev_ethtool_ops = { 705 - .get_drvinfo = netdev_get_drvinfo, 706 - }; 707 - 708 - #ifdef MODULE 709 - #define MAX_EL2_CARDS 4 /* Max number of EL2 cards per module */ 710 - 711 - static struct net_device *dev_el2[MAX_EL2_CARDS]; 712 - static int io[MAX_EL2_CARDS]; 713 - static int irq[MAX_EL2_CARDS]; 714 - static int xcvr[MAX_EL2_CARDS]; /* choose int. or ext. xcvr */ 715 - module_param_array(io, int, NULL, 0); 716 - module_param_array(irq, int, NULL, 0); 717 - module_param_array(xcvr, int, NULL, 0); 718 - MODULE_PARM_DESC(io, "I/O base address(es)"); 719 - MODULE_PARM_DESC(irq, "IRQ number(s) (assigned)"); 720 - MODULE_PARM_DESC(xcvr, "transceiver(s) (0=internal, 1=external)"); 721 - MODULE_DESCRIPTION("3Com ISA EtherLink II, II/16 (3c503, 3c503/16) driver"); 722 - MODULE_LICENSE("GPL"); 723 - 724 - /* This is set up so that only a single autoprobe takes place per call. 725 - ISA device autoprobes on a running machine are not recommended. */ 726 - int __init 727 - init_module(void) 728 - { 729 - struct net_device *dev; 730 - int this_dev, found = 0; 731 - 732 - for (this_dev = 0; this_dev < MAX_EL2_CARDS; this_dev++) { 733 - if (io[this_dev] == 0) { 734 - if (this_dev != 0) break; /* only autoprobe 1st one */ 735 - pr_notice("3c503.c: Presently autoprobing (not recommended) for a single card.\n"); 736 - } 737 - dev = alloc_eip_netdev(); 738 - if (!dev) 739 - break; 740 - dev->irq = irq[this_dev]; 741 - dev->base_addr = io[this_dev]; 742 - dev->mem_end = xcvr[this_dev]; /* low 4bits = xcvr sel. */ 743 - if (do_el2_probe(dev) == 0) { 744 - dev_el2[found++] = dev; 745 - continue; 746 - } 747 - free_netdev(dev); 748 - pr_warning("3c503.c: No 3c503 card found (i/o = 0x%x).\n", io[this_dev]); 749 - break; 750 - } 751 - if (found) 752 - return 0; 753 - return -ENXIO; 754 - } 755 - 756 - static void cleanup_card(struct net_device *dev) 757 - { 758 - /* NB: el2_close() handles free_irq */ 759 - release_region(dev->base_addr, EL2_IO_EXTENT); 760 - if (ei_status.mem) 761 - iounmap(ei_status.mem); 762 - } 763 - 764 - void __exit 765 - cleanup_module(void) 766 - { 767 - int this_dev; 768 - 769 - for (this_dev = 0; this_dev < MAX_EL2_CARDS; this_dev++) { 770 - struct net_device *dev = dev_el2[this_dev]; 771 - if (dev) { 772 - unregister_netdev(dev); 773 - cleanup_card(dev); 774 - free_netdev(dev); 775 - } 776 - } 777 - } 778 - #endif /* MODULE */
-91
drivers/net/ethernet/8390/3c503.h
··· 1 - /* Definitions for the 3Com 3c503 Etherlink 2. */ 2 - /* This file is distributed under the GPL. 3 - Many of these names and comments are directly from the Crynwr packet 4 - drivers, which are released under the GPL. */ 5 - 6 - #define EL2H (dev->base_addr + 0x400) 7 - #define EL2L (dev->base_addr) 8 - 9 - /* Vendor unique hardware addr. prefix. 3Com has 2 because they ran 10 - out of available addresses on the first one... */ 11 - 12 - #define OLD_3COM_ID 0x02608c 13 - #define NEW_3COM_ID 0x0020af 14 - 15 - /* Shared memory management parameters. NB: The 8 bit cards have only 16 - one bank (MB1) which serves both Tx and Rx packet space. The 16bit 17 - cards have 2 banks, MB0 for Tx packets, and MB1 for Rx packets. 18 - You choose which bank appears in the sh. mem window with EGACFR_MBSn */ 19 - 20 - #define EL2_MB0_START_PG (0x00) /* EL2/16 Tx packets go in bank 0 */ 21 - #define EL2_MB1_START_PG (0x20) /* First page of bank 1 */ 22 - #define EL2_MB1_STOP_PG (0x40) /* Last page +1 of bank 1 */ 23 - 24 - /* 3Com 3c503 ASIC registers */ 25 - #define E33G_STARTPG (EL2H+0) /* Start page, matching EN0_STARTPG */ 26 - #define E33G_STOPPG (EL2H+1) /* Stop page, must match EN0_STOPPG */ 27 - #define E33G_DRQCNT (EL2H+2) /* DMA burst count */ 28 - #define E33G_IOBASE (EL2H+3) /* Read of I/O base jumpers. */ 29 - /* (non-useful, but it also appears at the end of EPROM space) */ 30 - #define E33G_ROMBASE (EL2H+4) /* Read of memory base jumpers. */ 31 - #define E33G_GACFR (EL2H+5) /* Config/setup bits for the ASIC GA */ 32 - #define E33G_CNTRL (EL2H+6) /* Board's main control register */ 33 - #define E33G_STATUS (EL2H+7) /* Status on completions. */ 34 - #define E33G_IDCFR (EL2H+8) /* Interrupt/DMA config register */ 35 - /* (Which IRQ to assert, DMA chan to use) */ 36 - #define E33G_DMAAH (EL2H+9) /* High byte of DMA address reg */ 37 - #define E33G_DMAAL (EL2H+10) /* Low byte of DMA address reg */ 38 - /* "Vector pointer" - if this address matches a read, the EPROM (rather than 39 - shared RAM) is mapped into memory space. */ 40 - #define E33G_VP2 (EL2H+11) 41 - #define E33G_VP1 (EL2H+12) 42 - #define E33G_VP0 (EL2H+13) 43 - #define E33G_FIFOH (EL2H+14) /* FIFO for programmed I/O moves */ 44 - #define E33G_FIFOL (EL2H+15) /* ... low byte of above. */ 45 - 46 - /* Bits in E33G_CNTRL register: */ 47 - 48 - #define ECNTRL_RESET (0x01) /* Software reset of the ASIC and 8390 */ 49 - #define ECNTRL_THIN (0x02) /* Onboard xcvr enable, AUI disable */ 50 - #define ECNTRL_AUI (0x00) /* Onboard xcvr disable, AUI enable */ 51 - #define ECNTRL_SAPROM (0x04) /* Map the station address prom */ 52 - #define ECNTRL_DBLBFR (0x20) /* FIFO configuration bit */ 53 - #define ECNTRL_OUTPUT (0x40) /* PC-to-3C503 direction if 1 */ 54 - #define ECNTRL_INPUT (0x00) /* 3C503-to-PC direction if 0 */ 55 - #define ECNTRL_START (0x80) /* Start the DMA logic */ 56 - 57 - /* Bits in E33G_STATUS register: */ 58 - 59 - #define ESTAT_DPRDY (0x80) /* Data port (of FIFO) ready */ 60 - #define ESTAT_UFLW (0x40) /* Tried to read FIFO when it was empty */ 61 - #define ESTAT_OFLW (0x20) /* Tried to write FIFO when it was full */ 62 - #define ESTAT_DTC (0x10) /* Terminal Count from PC bus DMA logic */ 63 - #define ESTAT_DIP (0x08) /* DMA In Progress */ 64 - 65 - /* Bits in E33G_GACFR register: */ 66 - 67 - #define EGACFR_NIM (0x80) /* NIC interrupt mask */ 68 - #define EGACFR_TCM (0x40) /* DMA term. count interrupt mask */ 69 - #define EGACFR_RSEL (0x08) /* Map a bank of card mem into system mem */ 70 - #define EGACFR_MBS2 (0x04) /* Memory bank select, bit 2. */ 71 - #define EGACFR_MBS1 (0x02) /* Memory bank select, bit 1. */ 72 - #define EGACFR_MBS0 (0x01) /* Memory bank select, bit 0. */ 73 - 74 - #define EGACFR_NORM (0x49) /* TCM | RSEL | MBS0 */ 75 - #define EGACFR_IRQOFF (0xc9) /* TCM | RSEL | MBS0 | NIM */ 76 - 77 - /* 78 - MBS2 MBS1 MBS0 Sh. mem windows card mem at: 79 - ---- ---- ---- ----------------------------- 80 - 0 0 0 0x0000 -- bank 0 81 - 0 0 1 0x2000 -- bank 1 (only choice for 8bit card) 82 - 0 1 0 0x4000 -- bank 2, not used 83 - 0 1 1 0x6000 -- bank 3, not used 84 - 85 - There was going to be a 32k card that used bank 2 and 3, but it 86 - never got produced. 87 - 88 - */ 89 - 90 - 91 - /* End of 3C503 parameter definitions */
-48
drivers/net/ethernet/8390/Kconfig
··· 21 21 22 22 if NET_VENDOR_8390 23 23 24 - config EL2 25 - tristate "3c503 \"EtherLink II\" support" 26 - depends on ISA 27 - select CRC32 28 - ---help--- 29 - If you have a network (Ethernet) card of this type, say Y and read 30 - the Ethernet-HOWTO, available from 31 - <http://www.tldp.org/docs.html#howto>. 32 - 33 - To compile this driver as a module, choose M here. The module 34 - will be called 3c503. 35 - 36 24 config PCMCIA_AXNET 37 25 tristate "Asix AX88190 PCMCIA support" 38 26 depends on PCMCIA ··· 49 61 select EEPROM_93CX6 50 62 ---help--- 51 63 Select this if your platform comes with an external 93CX6 eeprom. 52 - 53 - config E2100 54 - tristate "Cabletron E21xx support" 55 - depends on ISA 56 - select CRC32 57 - ---help--- 58 - If you have a network (Ethernet) card of this type, say Y and read 59 - the Ethernet-HOWTO, available from 60 - <http://www.tldp.org/docs.html#howto>. 61 - 62 - To compile this driver as a module, choose M here. The module 63 - will be called e2100. 64 - 65 - config HPLAN_PLUS 66 - tristate "HP PCLAN+ (27247B and 27252A) support" 67 - depends on ISA 68 - select CRC32 69 - ---help--- 70 - If you have a network (Ethernet) card of this type, say Y and read 71 - the Ethernet-HOWTO, available from 72 - <http://www.tldp.org/docs.html#howto>. 73 - 74 - To compile this driver as a module, choose M here. The module 75 - will be called hp-plus. 76 - 77 - config HPLAN 78 - tristate "HP PCLAN (27245 and other 27xxx series) support" 79 - depends on ISA 80 - select CRC32 81 - ---help--- 82 - If you have a network (Ethernet) card of this type, say Y and read 83 - the Ethernet-HOWTO, available from 84 - <http://www.tldp.org/docs.html#howto>. 85 - 86 - To compile this driver as a module, choose M here. The module 87 - will be called hp. 88 64 89 65 config HYDRA 90 66 tristate "Hydra support"
-4
drivers/net/ethernet/8390/Makefile
··· 6 6 obj-$(CONFIG_APNE) += apne.o 8390.o 7 7 obj-$(CONFIG_ARM_ETHERH) += etherh.o 8 8 obj-$(CONFIG_AX88796) += ax88796.o 9 - obj-$(CONFIG_E2100) += e2100.o 8390.o 10 - obj-$(CONFIG_EL2) += 3c503.o 8390p.o 11 - obj-$(CONFIG_HPLAN_PLUS) += hp-plus.o 8390p.o 12 - obj-$(CONFIG_HPLAN) += hp.o 8390p.o 13 9 obj-$(CONFIG_HYDRA) += hydra.o 8390.o 14 10 obj-$(CONFIG_MCF8390) += mcf8390.o 8390.o 15 11 obj-$(CONFIG_NE2000) += ne.o 8390p.o
-489
drivers/net/ethernet/8390/e2100.c
··· 1 - /* e2100.c: A Cabletron E2100 series ethernet driver for linux. */ 2 - /* 3 - Written 1993-1994 by Donald Becker. 4 - 5 - Copyright 1994 by Donald Becker. 6 - Copyright 1993 United States Government as represented by the 7 - Director, National Security Agency. This software may be used and 8 - distributed according to the terms of the GNU General Public License, 9 - incorporated herein by reference. 10 - 11 - This is a driver for the Cabletron E2100 series ethercards. 12 - 13 - The Author may be reached as becker@scyld.com, or C/O 14 - Scyld Computing Corporation 15 - 410 Severn Ave., Suite 210 16 - Annapolis MD 21403 17 - 18 - The E2100 series ethercard is a fairly generic shared memory 8390 19 - implementation. The only unusual aspect is the way the shared memory 20 - registers are set: first you do an inb() in what is normally the 21 - station address region, and the low three bits of next outb() *address* 22 - is used as the write value for that register. Either someone wasn't 23 - too used to dem bit en bites, or they were trying to obfuscate the 24 - programming interface. 25 - 26 - There is an additional complication when setting the window on the packet 27 - buffer. You must first do a read into the packet buffer region with the 28 - low 8 address bits the address setting the page for the start of the packet 29 - buffer window, and then do the above operation. See mem_on() for details. 30 - 31 - One bug on the chip is that even a hard reset won't disable the memory 32 - window, usually resulting in a hung machine if mem_off() isn't called. 33 - If this happens, you must power down the machine for about 30 seconds. 34 - */ 35 - 36 - static const char version[] = 37 - "e2100.c:v1.01 7/21/94 Donald Becker (becker@cesdis.gsfc.nasa.gov)\n"; 38 - 39 - #include <linux/module.h> 40 - #include <linux/kernel.h> 41 - #include <linux/errno.h> 42 - #include <linux/string.h> 43 - #include <linux/ioport.h> 44 - #include <linux/netdevice.h> 45 - #include <linux/etherdevice.h> 46 - #include <linux/init.h> 47 - #include <linux/interrupt.h> 48 - #include <linux/delay.h> 49 - 50 - #include <asm/io.h> 51 - 52 - #include "8390.h" 53 - 54 - #define DRV_NAME "e2100" 55 - 56 - static int e21_probe_list[] = {0x300, 0x280, 0x380, 0x220, 0}; 57 - 58 - /* Offsets from the base_addr. 59 - Read from the ASIC register, and the low three bits of the next outb() 60 - address is used to set the corresponding register. */ 61 - #define E21_NIC_OFFSET 0 /* Offset to the 8390 NIC. */ 62 - #define E21_ASIC 0x10 63 - #define E21_MEM_ENABLE 0x10 64 - #define E21_MEM_ON 0x05 /* Enable memory in 16 bit mode. */ 65 - #define E21_MEM_ON_8 0x07 /* Enable memory in 8 bit mode. */ 66 - #define E21_MEM_BASE 0x11 67 - #define E21_IRQ_LOW 0x12 /* The low three bits of the IRQ number. */ 68 - #define E21_IRQ_HIGH 0x14 /* The high IRQ bit and media select ... */ 69 - #define E21_MEDIA 0x14 /* (alias). */ 70 - #define E21_ALT_IFPORT 0x02 /* Set to use the other (BNC,AUI) port. */ 71 - #define E21_BIG_MEM 0x04 /* Use a bigger (64K) buffer (we don't) */ 72 - #define E21_SAPROM 0x10 /* Offset to station address data. */ 73 - #define E21_IO_EXTENT 0x20 74 - 75 - static inline void mem_on(short port, volatile char __iomem *mem_base, 76 - unsigned char start_page ) 77 - { 78 - /* This is a little weird: set the shared memory window by doing a 79 - read. The low address bits specify the starting page. */ 80 - readb(mem_base+start_page); 81 - inb(port + E21_MEM_ENABLE); 82 - outb(E21_MEM_ON, port + E21_MEM_ENABLE + E21_MEM_ON); 83 - } 84 - 85 - static inline void mem_off(short port) 86 - { 87 - inb(port + E21_MEM_ENABLE); 88 - outb(0x00, port + E21_MEM_ENABLE); 89 - } 90 - 91 - /* In other drivers I put the TX pages first, but the E2100 window circuitry 92 - is designed to have a 4K Tx region last. The windowing circuitry wraps the 93 - window at 0x2fff->0x0000 so that the packets at e.g. 0x2f00 in the RX ring 94 - appear contiguously in the window. */ 95 - #define E21_RX_START_PG 0x00 /* First page of RX buffer */ 96 - #define E21_RX_STOP_PG 0x30 /* Last page +1 of RX ring */ 97 - #define E21_BIG_RX_STOP_PG 0xF0 /* Last page +1 of RX ring */ 98 - #define E21_TX_START_PG E21_RX_STOP_PG /* First page of TX buffer */ 99 - 100 - static int e21_probe1(struct net_device *dev, int ioaddr); 101 - 102 - static int e21_open(struct net_device *dev); 103 - static void e21_reset_8390(struct net_device *dev); 104 - static void e21_block_input(struct net_device *dev, int count, 105 - struct sk_buff *skb, int ring_offset); 106 - static void e21_block_output(struct net_device *dev, int count, 107 - const unsigned char *buf, int start_page); 108 - static void e21_get_8390_hdr(struct net_device *dev, struct e8390_pkt_hdr *hdr, 109 - int ring_page); 110 - static int e21_open(struct net_device *dev); 111 - static int e21_close(struct net_device *dev); 112 - 113 - 114 - /* Probe for the E2100 series ethercards. These cards have an 8390 at the 115 - base address and the station address at both offset 0x10 and 0x18. I read 116 - the station address from offset 0x18 to avoid the dataport of NE2000 117 - ethercards, and look for Ctron's unique ID (first three octets of the 118 - station address). 119 - */ 120 - 121 - static int __init do_e2100_probe(struct net_device *dev) 122 - { 123 - int *port; 124 - int base_addr = dev->base_addr; 125 - int irq = dev->irq; 126 - 127 - if (base_addr > 0x1ff) /* Check a single specified location. */ 128 - return e21_probe1(dev, base_addr); 129 - else if (base_addr != 0) /* Don't probe at all. */ 130 - return -ENXIO; 131 - 132 - for (port = e21_probe_list; *port; port++) { 133 - dev->irq = irq; 134 - if (e21_probe1(dev, *port) == 0) 135 - return 0; 136 - } 137 - 138 - return -ENODEV; 139 - } 140 - 141 - #ifndef MODULE 142 - struct net_device * __init e2100_probe(int unit) 143 - { 144 - struct net_device *dev = alloc_ei_netdev(); 145 - int err; 146 - 147 - if (!dev) 148 - return ERR_PTR(-ENOMEM); 149 - 150 - sprintf(dev->name, "eth%d", unit); 151 - netdev_boot_setup_check(dev); 152 - 153 - err = do_e2100_probe(dev); 154 - if (err) 155 - goto out; 156 - return dev; 157 - out: 158 - free_netdev(dev); 159 - return ERR_PTR(err); 160 - } 161 - #endif 162 - 163 - static const struct net_device_ops e21_netdev_ops = { 164 - .ndo_open = e21_open, 165 - .ndo_stop = e21_close, 166 - 167 - .ndo_start_xmit = ei_start_xmit, 168 - .ndo_tx_timeout = ei_tx_timeout, 169 - .ndo_get_stats = ei_get_stats, 170 - .ndo_set_rx_mode = ei_set_multicast_list, 171 - .ndo_validate_addr = eth_validate_addr, 172 - .ndo_set_mac_address = eth_mac_addr, 173 - .ndo_change_mtu = eth_change_mtu, 174 - #ifdef CONFIG_NET_POLL_CONTROLLER 175 - .ndo_poll_controller = ei_poll, 176 - #endif 177 - }; 178 - 179 - static int __init e21_probe1(struct net_device *dev, int ioaddr) 180 - { 181 - int i, status, retval; 182 - unsigned char *station_addr = dev->dev_addr; 183 - static unsigned version_printed; 184 - 185 - if (!request_region(ioaddr, E21_IO_EXTENT, DRV_NAME)) 186 - return -EBUSY; 187 - 188 - /* First check the station address for the Ctron prefix. */ 189 - if (inb(ioaddr + E21_SAPROM + 0) != 0x00 || 190 - inb(ioaddr + E21_SAPROM + 1) != 0x00 || 191 - inb(ioaddr + E21_SAPROM + 2) != 0x1d) { 192 - retval = -ENODEV; 193 - goto out; 194 - } 195 - 196 - /* Verify by making certain that there is a 8390 at there. */ 197 - outb(E8390_NODMA + E8390_STOP, ioaddr); 198 - udelay(1); /* we want to delay one I/O cycle - which is 2MHz */ 199 - status = inb(ioaddr); 200 - if (status != 0x21 && status != 0x23) { 201 - retval = -ENODEV; 202 - goto out; 203 - } 204 - 205 - /* Read the station address PROM. */ 206 - for (i = 0; i < 6; i++) 207 - station_addr[i] = inb(ioaddr + E21_SAPROM + i); 208 - 209 - inb(ioaddr + E21_MEDIA); /* Point to media selection. */ 210 - outb(0, ioaddr + E21_ASIC); /* and disable the secondary interface. */ 211 - 212 - if (ei_debug && version_printed++ == 0) 213 - printk(version); 214 - 215 - for (i = 0; i < 6; i++) 216 - printk(" %02X", station_addr[i]); 217 - 218 - if (dev->irq < 2) { 219 - static const int irqlist[] = {15, 11, 10, 12, 5, 9, 3, 4}; 220 - for (i = 0; i < ARRAY_SIZE(irqlist); i++) 221 - if (request_irq (irqlist[i], NULL, 0, "bogus", NULL) != -EBUSY) { 222 - dev->irq = irqlist[i]; 223 - break; 224 - } 225 - if (i >= ARRAY_SIZE(irqlist)) { 226 - printk(" unable to get IRQ %d.\n", dev->irq); 227 - retval = -EAGAIN; 228 - goto out; 229 - } 230 - } else if (dev->irq == 2) /* Fixup luser bogosity: IRQ2 is really IRQ9 */ 231 - dev->irq = 9; 232 - 233 - /* The 8390 is at the base address. */ 234 - dev->base_addr = ioaddr; 235 - 236 - ei_status.name = "E2100"; 237 - ei_status.word16 = 1; 238 - ei_status.tx_start_page = E21_TX_START_PG; 239 - ei_status.rx_start_page = E21_RX_START_PG; 240 - ei_status.stop_page = E21_RX_STOP_PG; 241 - ei_status.saved_irq = dev->irq; 242 - 243 - /* Check the media port used. The port can be passed in on the 244 - low mem_end bits. */ 245 - if (dev->mem_end & 15) 246 - dev->if_port = dev->mem_end & 7; 247 - else { 248 - dev->if_port = 0; 249 - inb(ioaddr + E21_MEDIA); /* Turn automatic media detection on. */ 250 - for(i = 0; i < 6; i++) 251 - if (station_addr[i] != inb(ioaddr + E21_SAPROM + 8 + i)) { 252 - dev->if_port = 1; 253 - break; 254 - } 255 - } 256 - 257 - /* Never map in the E21 shared memory unless you are actively using it. 258 - Also, the shared memory has effective only one setting -- spread all 259 - over the 128K region! */ 260 - if (dev->mem_start == 0) 261 - dev->mem_start = 0xd0000; 262 - 263 - ei_status.mem = ioremap(dev->mem_start, 2*1024); 264 - if (!ei_status.mem) { 265 - printk("unable to remap memory\n"); 266 - retval = -EAGAIN; 267 - goto out; 268 - } 269 - 270 - #ifdef notdef 271 - /* These values are unused. The E2100 has a 2K window into the packet 272 - buffer. The window can be set to start on any page boundary. */ 273 - ei_status.rmem_start = dev->mem_start + TX_PAGES*256; 274 - dev->mem_end = ei_status.rmem_end = dev->mem_start + 2*1024; 275 - #endif 276 - 277 - printk(", IRQ %d, %s media, memory @ %#lx.\n", dev->irq, 278 - dev->if_port ? "secondary" : "primary", dev->mem_start); 279 - 280 - ei_status.reset_8390 = &e21_reset_8390; 281 - ei_status.block_input = &e21_block_input; 282 - ei_status.block_output = &e21_block_output; 283 - ei_status.get_8390_hdr = &e21_get_8390_hdr; 284 - 285 - dev->netdev_ops = &e21_netdev_ops; 286 - NS8390_init(dev, 0); 287 - 288 - retval = register_netdev(dev); 289 - if (retval) 290 - goto out; 291 - return 0; 292 - out: 293 - release_region(ioaddr, E21_IO_EXTENT); 294 - return retval; 295 - } 296 - 297 - static int 298 - e21_open(struct net_device *dev) 299 - { 300 - short ioaddr = dev->base_addr; 301 - int retval; 302 - 303 - if ((retval = request_irq(dev->irq, ei_interrupt, 0, dev->name, dev))) 304 - return retval; 305 - 306 - /* Set the interrupt line and memory base on the hardware. */ 307 - inb(ioaddr + E21_IRQ_LOW); 308 - outb(0, ioaddr + E21_ASIC + (dev->irq & 7)); 309 - inb(ioaddr + E21_IRQ_HIGH); /* High IRQ bit, and if_port. */ 310 - outb(0, ioaddr + E21_ASIC + (dev->irq > 7 ? 1:0) 311 - + (dev->if_port ? E21_ALT_IFPORT : 0)); 312 - inb(ioaddr + E21_MEM_BASE); 313 - outb(0, ioaddr + E21_ASIC + ((dev->mem_start >> 17) & 7)); 314 - 315 - ei_open(dev); 316 - return 0; 317 - } 318 - 319 - static void 320 - e21_reset_8390(struct net_device *dev) 321 - { 322 - short ioaddr = dev->base_addr; 323 - 324 - outb(0x01, ioaddr); 325 - if (ei_debug > 1) printk("resetting the E2180x3 t=%ld...", jiffies); 326 - ei_status.txing = 0; 327 - 328 - /* Set up the ASIC registers, just in case something changed them. */ 329 - 330 - if (ei_debug > 1) printk("reset done\n"); 331 - } 332 - 333 - /* Grab the 8390 specific header. We put the 2k window so the header page 334 - appears at the start of the shared memory. */ 335 - 336 - static void 337 - e21_get_8390_hdr(struct net_device *dev, struct e8390_pkt_hdr *hdr, int ring_page) 338 - { 339 - 340 - short ioaddr = dev->base_addr; 341 - char __iomem *shared_mem = ei_status.mem; 342 - 343 - mem_on(ioaddr, shared_mem, ring_page); 344 - 345 - #ifdef notdef 346 - /* Officially this is what we are doing, but the readl() is faster */ 347 - memcpy_fromio(hdr, shared_mem, sizeof(struct e8390_pkt_hdr)); 348 - #else 349 - ((unsigned int*)hdr)[0] = readl(shared_mem); 350 - #endif 351 - 352 - /* Turn off memory access: we would need to reprogram the window anyway. */ 353 - mem_off(ioaddr); 354 - 355 - } 356 - 357 - /* Block input and output are easy on shared memory ethercards. 358 - The E21xx makes block_input() especially easy by wrapping the top 359 - ring buffer to the bottom automatically. */ 360 - static void 361 - e21_block_input(struct net_device *dev, int count, struct sk_buff *skb, int ring_offset) 362 - { 363 - short ioaddr = dev->base_addr; 364 - char __iomem *shared_mem = ei_status.mem; 365 - 366 - mem_on(ioaddr, shared_mem, (ring_offset>>8)); 367 - 368 - memcpy_fromio(skb->data, ei_status.mem + (ring_offset & 0xff), count); 369 - 370 - mem_off(ioaddr); 371 - } 372 - 373 - static void 374 - e21_block_output(struct net_device *dev, int count, const unsigned char *buf, 375 - int start_page) 376 - { 377 - short ioaddr = dev->base_addr; 378 - volatile char __iomem *shared_mem = ei_status.mem; 379 - 380 - /* Set the shared memory window start by doing a read, with the low address 381 - bits specifying the starting page. */ 382 - readb(shared_mem + start_page); 383 - mem_on(ioaddr, shared_mem, start_page); 384 - 385 - memcpy_toio(shared_mem, buf, count); 386 - mem_off(ioaddr); 387 - } 388 - 389 - static int 390 - e21_close(struct net_device *dev) 391 - { 392 - short ioaddr = dev->base_addr; 393 - 394 - if (ei_debug > 1) 395 - printk("%s: Shutting down ethercard.\n", dev->name); 396 - 397 - free_irq(dev->irq, dev); 398 - dev->irq = ei_status.saved_irq; 399 - 400 - /* Shut off the interrupt line and secondary interface. */ 401 - inb(ioaddr + E21_IRQ_LOW); 402 - outb(0, ioaddr + E21_ASIC); 403 - inb(ioaddr + E21_IRQ_HIGH); /* High IRQ bit, and if_port. */ 404 - outb(0, ioaddr + E21_ASIC); 405 - 406 - ei_close(dev); 407 - 408 - /* Double-check that the memory has been turned off, because really 409 - really bad things happen if it isn't. */ 410 - mem_off(ioaddr); 411 - 412 - return 0; 413 - } 414 - 415 - 416 - #ifdef MODULE 417 - #define MAX_E21_CARDS 4 /* Max number of E21 cards per module */ 418 - static struct net_device *dev_e21[MAX_E21_CARDS]; 419 - static int io[MAX_E21_CARDS]; 420 - static int irq[MAX_E21_CARDS]; 421 - static int mem[MAX_E21_CARDS]; 422 - static int xcvr[MAX_E21_CARDS]; /* choose int. or ext. xcvr */ 423 - 424 - module_param_array(io, int, NULL, 0); 425 - module_param_array(irq, int, NULL, 0); 426 - module_param_array(mem, int, NULL, 0); 427 - module_param_array(xcvr, int, NULL, 0); 428 - MODULE_PARM_DESC(io, "I/O base address(es)"); 429 - MODULE_PARM_DESC(irq, "IRQ number(s)"); 430 - MODULE_PARM_DESC(mem, " memory base address(es)"); 431 - MODULE_PARM_DESC(xcvr, "transceiver(s) (0=internal, 1=external)"); 432 - MODULE_DESCRIPTION("Cabletron E2100 ISA ethernet driver"); 433 - MODULE_LICENSE("GPL"); 434 - 435 - /* This is set up so that only a single autoprobe takes place per call. 436 - ISA device autoprobes on a running machine are not recommended. */ 437 - 438 - int __init init_module(void) 439 - { 440 - struct net_device *dev; 441 - int this_dev, found = 0; 442 - 443 - for (this_dev = 0; this_dev < MAX_E21_CARDS; this_dev++) { 444 - if (io[this_dev] == 0) { 445 - if (this_dev != 0) break; /* only autoprobe 1st one */ 446 - printk(KERN_NOTICE "e2100.c: Presently autoprobing (not recommended) for a single card.\n"); 447 - } 448 - dev = alloc_ei_netdev(); 449 - if (!dev) 450 - break; 451 - dev->irq = irq[this_dev]; 452 - dev->base_addr = io[this_dev]; 453 - dev->mem_start = mem[this_dev]; 454 - dev->mem_end = xcvr[this_dev]; /* low 4bits = xcvr sel. */ 455 - if (do_e2100_probe(dev) == 0) { 456 - dev_e21[found++] = dev; 457 - continue; 458 - } 459 - free_netdev(dev); 460 - printk(KERN_WARNING "e2100.c: No E2100 card found (i/o = 0x%x).\n", io[this_dev]); 461 - break; 462 - } 463 - if (found) 464 - return 0; 465 - return -ENXIO; 466 - } 467 - 468 - static void cleanup_card(struct net_device *dev) 469 - { 470 - /* NB: e21_close() handles free_irq */ 471 - iounmap(ei_status.mem); 472 - release_region(dev->base_addr, E21_IO_EXTENT); 473 - } 474 - 475 - void __exit 476 - cleanup_module(void) 477 - { 478 - int this_dev; 479 - 480 - for (this_dev = 0; this_dev < MAX_E21_CARDS; this_dev++) { 481 - struct net_device *dev = dev_e21[this_dev]; 482 - if (dev) { 483 - unregister_netdev(dev); 484 - cleanup_card(dev); 485 - free_netdev(dev); 486 - } 487 - } 488 - } 489 - #endif /* MODULE */
-505
drivers/net/ethernet/8390/hp-plus.c
··· 1 - /* hp-plus.c: A HP PCLAN/plus ethernet driver for linux. */ 2 - /* 3 - Written 1994 by Donald Becker. 4 - 5 - This driver is for the Hewlett Packard PC LAN (27***) plus ethercards. 6 - These cards are sold under several model numbers, usually 2724*. 7 - 8 - This software may be used and distributed according to the terms 9 - of the GNU General Public License, incorporated herein by reference. 10 - 11 - The author may be reached as becker@scyld.com, or C/O 12 - Scyld Computing Corporation 13 - 410 Severn Ave., Suite 210 14 - Annapolis MD 21403 15 - 16 - As is often the case, a great deal of credit is owed to Russ Nelson. 17 - The Crynwr packet driver was my primary source of HP-specific 18 - programming information. 19 - */ 20 - 21 - static const char version[] = 22 - "hp-plus.c:v1.10 9/24/94 Donald Becker (becker@cesdis.gsfc.nasa.gov)\n"; 23 - 24 - #include <linux/module.h> 25 - 26 - #include <linux/string.h> /* Important -- this inlines word moves. */ 27 - #include <linux/kernel.h> 28 - #include <linux/errno.h> 29 - #include <linux/ioport.h> 30 - #include <linux/netdevice.h> 31 - #include <linux/etherdevice.h> 32 - #include <linux/init.h> 33 - #include <linux/interrupt.h> 34 - #include <linux/delay.h> 35 - 36 - #include <asm/io.h> 37 - 38 - #include "8390.h" 39 - 40 - #define DRV_NAME "hp-plus" 41 - 42 - /* A zero-terminated list of I/O addresses to be probed. */ 43 - static unsigned int hpplus_portlist[] __initdata = 44 - {0x200, 0x240, 0x280, 0x2C0, 0x300, 0x320, 0x340, 0}; 45 - 46 - /* 47 - The HP EtherTwist chip implementation is a fairly routine DP8390 48 - implementation. It allows both shared memory and programmed-I/O buffer 49 - access, using a custom interface for both. The programmed-I/O mode is 50 - entirely implemented in the HP EtherTwist chip, bypassing the problem 51 - ridden built-in 8390 facilities used on NE2000 designs. The shared 52 - memory mode is likewise special, with an offset register used to make 53 - packets appear at the shared memory base. Both modes use a base and bounds 54 - page register to hide the Rx ring buffer wrap -- a packet that spans the 55 - end of physical buffer memory appears continuous to the driver. (c.f. the 56 - 3c503 and Cabletron E2100) 57 - 58 - A special note: the internal buffer of the board is only 8 bits wide. 59 - This lays several nasty traps for the unaware: 60 - - the 8390 must be programmed for byte-wide operations 61 - - all I/O and memory operations must work on whole words (the access 62 - latches are serially preloaded and have no byte-swapping ability). 63 - 64 - This board is laid out in I/O space much like the earlier HP boards: 65 - the first 16 locations are for the board registers, and the second 16 are 66 - for the 8390. The board is easy to identify, with both a dedicated 16 bit 67 - ID register and a constant 0x530* value in the upper bits of the paging 68 - register. 69 - */ 70 - 71 - #define HP_ID 0x00 /* ID register, always 0x4850. */ 72 - #define HP_PAGING 0x02 /* Registers visible @ 8-f, see PageName. */ 73 - #define HPP_OPTION 0x04 /* Bitmapped options, see HP_Option. */ 74 - #define HPP_OUT_ADDR 0x08 /* I/O output location in Perf_Page. */ 75 - #define HPP_IN_ADDR 0x0A /* I/O input location in Perf_Page. */ 76 - #define HP_DATAPORT 0x0c /* I/O data transfer in Perf_Page. */ 77 - #define NIC_OFFSET 0x10 /* Offset to the 8390 registers. */ 78 - #define HP_IO_EXTENT 32 79 - 80 - #define HP_START_PG 0x00 /* First page of TX buffer */ 81 - #define HP_STOP_PG 0x80 /* Last page +1 of RX ring */ 82 - 83 - /* The register set selected in HP_PAGING. */ 84 - enum PageName { 85 - Perf_Page = 0, /* Normal operation. */ 86 - MAC_Page = 1, /* The ethernet address (+checksum). */ 87 - HW_Page = 2, /* EEPROM-loaded hardware parameters. */ 88 - LAN_Page = 4, /* Transceiver selection, testing, etc. */ 89 - ID_Page = 6 }; 90 - 91 - /* The bit definitions for the HPP_OPTION register. */ 92 - enum HP_Option { 93 - NICReset = 1, ChipReset = 2, /* Active low, really UNreset. */ 94 - EnableIRQ = 4, FakeIntr = 8, BootROMEnb = 0x10, IOEnb = 0x20, 95 - MemEnable = 0x40, ZeroWait = 0x80, MemDisable = 0x1000, }; 96 - 97 - static int hpp_probe1(struct net_device *dev, int ioaddr); 98 - 99 - static void hpp_reset_8390(struct net_device *dev); 100 - static int hpp_open(struct net_device *dev); 101 - static int hpp_close(struct net_device *dev); 102 - static void hpp_mem_block_input(struct net_device *dev, int count, 103 - struct sk_buff *skb, int ring_offset); 104 - static void hpp_mem_block_output(struct net_device *dev, int count, 105 - const unsigned char *buf, int start_page); 106 - static void hpp_mem_get_8390_hdr(struct net_device *dev, struct e8390_pkt_hdr *hdr, 107 - int ring_page); 108 - static void hpp_io_block_input(struct net_device *dev, int count, 109 - struct sk_buff *skb, int ring_offset); 110 - static void hpp_io_block_output(struct net_device *dev, int count, 111 - const unsigned char *buf, int start_page); 112 - static void hpp_io_get_8390_hdr(struct net_device *dev, struct e8390_pkt_hdr *hdr, 113 - int ring_page); 114 - 115 - 116 - /* Probe a list of addresses for an HP LAN+ adaptor. 117 - This routine is almost boilerplate. */ 118 - 119 - static int __init do_hpp_probe(struct net_device *dev) 120 - { 121 - int i; 122 - int base_addr = dev->base_addr; 123 - int irq = dev->irq; 124 - 125 - if (base_addr > 0x1ff) /* Check a single specified location. */ 126 - return hpp_probe1(dev, base_addr); 127 - else if (base_addr != 0) /* Don't probe at all. */ 128 - return -ENXIO; 129 - 130 - for (i = 0; hpplus_portlist[i]; i++) { 131 - if (hpp_probe1(dev, hpplus_portlist[i]) == 0) 132 - return 0; 133 - dev->irq = irq; 134 - } 135 - 136 - return -ENODEV; 137 - } 138 - 139 - #ifndef MODULE 140 - struct net_device * __init hp_plus_probe(int unit) 141 - { 142 - struct net_device *dev = alloc_eip_netdev(); 143 - int err; 144 - 145 - if (!dev) 146 - return ERR_PTR(-ENOMEM); 147 - 148 - sprintf(dev->name, "eth%d", unit); 149 - netdev_boot_setup_check(dev); 150 - 151 - err = do_hpp_probe(dev); 152 - if (err) 153 - goto out; 154 - return dev; 155 - out: 156 - free_netdev(dev); 157 - return ERR_PTR(err); 158 - } 159 - #endif 160 - 161 - static const struct net_device_ops hpp_netdev_ops = { 162 - .ndo_open = hpp_open, 163 - .ndo_stop = hpp_close, 164 - .ndo_start_xmit = eip_start_xmit, 165 - .ndo_tx_timeout = eip_tx_timeout, 166 - .ndo_get_stats = eip_get_stats, 167 - .ndo_set_rx_mode = eip_set_multicast_list, 168 - .ndo_validate_addr = eth_validate_addr, 169 - .ndo_set_mac_address = eth_mac_addr, 170 - .ndo_change_mtu = eth_change_mtu, 171 - #ifdef CONFIG_NET_POLL_CONTROLLER 172 - .ndo_poll_controller = eip_poll, 173 - #endif 174 - }; 175 - 176 - 177 - /* Do the interesting part of the probe at a single address. */ 178 - static int __init hpp_probe1(struct net_device *dev, int ioaddr) 179 - { 180 - int i, retval; 181 - unsigned char checksum = 0; 182 - const char name[] = "HP-PC-LAN+"; 183 - int mem_start; 184 - static unsigned version_printed; 185 - 186 - if (!request_region(ioaddr, HP_IO_EXTENT, DRV_NAME)) 187 - return -EBUSY; 188 - 189 - /* Check for the HP+ signature, 50 48 0x 53. */ 190 - if (inw(ioaddr + HP_ID) != 0x4850 || 191 - (inw(ioaddr + HP_PAGING) & 0xfff0) != 0x5300) { 192 - retval = -ENODEV; 193 - goto out; 194 - } 195 - 196 - if (ei_debug && version_printed++ == 0) 197 - printk(version); 198 - 199 - printk("%s: %s at %#3x, ", dev->name, name, ioaddr); 200 - 201 - /* Retrieve and checksum the station address. */ 202 - outw(MAC_Page, ioaddr + HP_PAGING); 203 - 204 - for(i = 0; i < ETH_ALEN; i++) { 205 - unsigned char inval = inb(ioaddr + 8 + i); 206 - dev->dev_addr[i] = inval; 207 - checksum += inval; 208 - } 209 - checksum += inb(ioaddr + 14); 210 - 211 - printk("%pM", dev->dev_addr); 212 - 213 - if (checksum != 0xff) { 214 - printk(" bad checksum %2.2x.\n", checksum); 215 - retval = -ENODEV; 216 - goto out; 217 - } else { 218 - /* Point at the Software Configuration Flags. */ 219 - outw(ID_Page, ioaddr + HP_PAGING); 220 - printk(" ID %4.4x", inw(ioaddr + 12)); 221 - } 222 - 223 - /* Read the IRQ line. */ 224 - outw(HW_Page, ioaddr + HP_PAGING); 225 - { 226 - int irq = inb(ioaddr + 13) & 0x0f; 227 - int option = inw(ioaddr + HPP_OPTION); 228 - 229 - dev->irq = irq; 230 - if (option & MemEnable) { 231 - mem_start = inw(ioaddr + 9) << 8; 232 - printk(", IRQ %d, memory address %#x.\n", irq, mem_start); 233 - } else { 234 - mem_start = 0; 235 - printk(", IRQ %d, programmed-I/O mode.\n", irq); 236 - } 237 - } 238 - 239 - /* Set the wrap registers for string I/O reads. */ 240 - outw((HP_START_PG + TX_PAGES/2) | ((HP_STOP_PG - 1) << 8), ioaddr + 14); 241 - 242 - /* Set the base address to point to the NIC, not the "real" base! */ 243 - dev->base_addr = ioaddr + NIC_OFFSET; 244 - 245 - dev->netdev_ops = &hpp_netdev_ops; 246 - 247 - ei_status.name = name; 248 - ei_status.word16 = 0; /* Agggghhhhh! Debug time: 2 days! */ 249 - ei_status.tx_start_page = HP_START_PG; 250 - ei_status.rx_start_page = HP_START_PG + TX_PAGES/2; 251 - ei_status.stop_page = HP_STOP_PG; 252 - 253 - ei_status.reset_8390 = &hpp_reset_8390; 254 - ei_status.block_input = &hpp_io_block_input; 255 - ei_status.block_output = &hpp_io_block_output; 256 - ei_status.get_8390_hdr = &hpp_io_get_8390_hdr; 257 - 258 - /* Check if the memory_enable flag is set in the option register. */ 259 - if (mem_start) { 260 - ei_status.block_input = &hpp_mem_block_input; 261 - ei_status.block_output = &hpp_mem_block_output; 262 - ei_status.get_8390_hdr = &hpp_mem_get_8390_hdr; 263 - dev->mem_start = mem_start; 264 - ei_status.mem = ioremap(mem_start, 265 - (HP_STOP_PG - HP_START_PG)*256); 266 - if (!ei_status.mem) { 267 - retval = -ENOMEM; 268 - goto out; 269 - } 270 - ei_status.rmem_start = dev->mem_start + TX_PAGES/2*256; 271 - dev->mem_end = ei_status.rmem_end 272 - = dev->mem_start + (HP_STOP_PG - HP_START_PG)*256; 273 - } 274 - 275 - outw(Perf_Page, ioaddr + HP_PAGING); 276 - NS8390p_init(dev, 0); 277 - /* Leave the 8390 and HP chip reset. */ 278 - outw(inw(ioaddr + HPP_OPTION) & ~EnableIRQ, ioaddr + HPP_OPTION); 279 - 280 - retval = register_netdev(dev); 281 - if (retval) 282 - goto out1; 283 - return 0; 284 - out1: 285 - iounmap(ei_status.mem); 286 - out: 287 - release_region(ioaddr, HP_IO_EXTENT); 288 - return retval; 289 - } 290 - 291 - static int 292 - hpp_open(struct net_device *dev) 293 - { 294 - int ioaddr = dev->base_addr - NIC_OFFSET; 295 - int option_reg; 296 - int retval; 297 - 298 - if ((retval = request_irq(dev->irq, eip_interrupt, 0, dev->name, dev))) { 299 - return retval; 300 - } 301 - 302 - /* Reset the 8390 and HP chip. */ 303 - option_reg = inw(ioaddr + HPP_OPTION); 304 - outw(option_reg & ~(NICReset + ChipReset), ioaddr + HPP_OPTION); 305 - udelay(5); 306 - /* Unreset the board and enable interrupts. */ 307 - outw(option_reg | (EnableIRQ + NICReset + ChipReset), ioaddr + HPP_OPTION); 308 - 309 - /* Set the wrap registers for programmed-I/O operation. */ 310 - outw(HW_Page, ioaddr + HP_PAGING); 311 - outw((HP_START_PG + TX_PAGES/2) | ((HP_STOP_PG - 1) << 8), ioaddr + 14); 312 - 313 - /* Select the operational page. */ 314 - outw(Perf_Page, ioaddr + HP_PAGING); 315 - 316 - return eip_open(dev); 317 - } 318 - 319 - static int 320 - hpp_close(struct net_device *dev) 321 - { 322 - int ioaddr = dev->base_addr - NIC_OFFSET; 323 - int option_reg = inw(ioaddr + HPP_OPTION); 324 - 325 - free_irq(dev->irq, dev); 326 - eip_close(dev); 327 - outw((option_reg & ~EnableIRQ) | MemDisable | NICReset | ChipReset, 328 - ioaddr + HPP_OPTION); 329 - 330 - return 0; 331 - } 332 - 333 - static void 334 - hpp_reset_8390(struct net_device *dev) 335 - { 336 - int ioaddr = dev->base_addr - NIC_OFFSET; 337 - int option_reg = inw(ioaddr + HPP_OPTION); 338 - 339 - if (ei_debug > 1) printk("resetting the 8390 time=%ld...", jiffies); 340 - 341 - outw(option_reg & ~(NICReset + ChipReset), ioaddr + HPP_OPTION); 342 - /* Pause a few cycles for the hardware reset to take place. */ 343 - udelay(5); 344 - ei_status.txing = 0; 345 - outw(option_reg | (EnableIRQ + NICReset + ChipReset), ioaddr + HPP_OPTION); 346 - 347 - udelay(5); 348 - 349 - 350 - if ((inb_p(ioaddr+NIC_OFFSET+EN0_ISR) & ENISR_RESET) == 0) 351 - printk("%s: hp_reset_8390() did not complete.\n", dev->name); 352 - 353 - if (ei_debug > 1) printk("8390 reset done (%ld).", jiffies); 354 - } 355 - 356 - /* The programmed-I/O version of reading the 4 byte 8390 specific header. 357 - Note that transfer with the EtherTwist+ must be on word boundaries. */ 358 - 359 - static void 360 - hpp_io_get_8390_hdr(struct net_device *dev, struct e8390_pkt_hdr *hdr, int ring_page) 361 - { 362 - int ioaddr = dev->base_addr - NIC_OFFSET; 363 - 364 - outw((ring_page<<8), ioaddr + HPP_IN_ADDR); 365 - insw(ioaddr + HP_DATAPORT, hdr, sizeof(struct e8390_pkt_hdr)>>1); 366 - } 367 - 368 - /* Block input and output, similar to the Crynwr packet driver. */ 369 - 370 - static void 371 - hpp_io_block_input(struct net_device *dev, int count, struct sk_buff *skb, int ring_offset) 372 - { 373 - int ioaddr = dev->base_addr - NIC_OFFSET; 374 - char *buf = skb->data; 375 - 376 - outw(ring_offset, ioaddr + HPP_IN_ADDR); 377 - insw(ioaddr + HP_DATAPORT, buf, count>>1); 378 - if (count & 0x01) 379 - buf[count-1] = inw(ioaddr + HP_DATAPORT); 380 - } 381 - 382 - /* The corresponding shared memory versions of the above 2 functions. */ 383 - 384 - static void 385 - hpp_mem_get_8390_hdr(struct net_device *dev, struct e8390_pkt_hdr *hdr, int ring_page) 386 - { 387 - int ioaddr = dev->base_addr - NIC_OFFSET; 388 - int option_reg = inw(ioaddr + HPP_OPTION); 389 - 390 - outw((ring_page<<8), ioaddr + HPP_IN_ADDR); 391 - outw(option_reg & ~(MemDisable + BootROMEnb), ioaddr + HPP_OPTION); 392 - memcpy_fromio(hdr, ei_status.mem, sizeof(struct e8390_pkt_hdr)); 393 - outw(option_reg, ioaddr + HPP_OPTION); 394 - hdr->count = (le16_to_cpu(hdr->count) + 3) & ~3; /* Round up allocation. */ 395 - } 396 - 397 - static void 398 - hpp_mem_block_input(struct net_device *dev, int count, struct sk_buff *skb, int ring_offset) 399 - { 400 - int ioaddr = dev->base_addr - NIC_OFFSET; 401 - int option_reg = inw(ioaddr + HPP_OPTION); 402 - 403 - outw(ring_offset, ioaddr + HPP_IN_ADDR); 404 - 405 - outw(option_reg & ~(MemDisable + BootROMEnb), ioaddr + HPP_OPTION); 406 - 407 - /* Caution: this relies on get_8390_hdr() rounding up count! 408 - Also note that we *can't* use eth_io_copy_and_sum() because 409 - it will not always copy "count" bytes (e.g. padded IP). */ 410 - 411 - memcpy_fromio(skb->data, ei_status.mem, count); 412 - outw(option_reg, ioaddr + HPP_OPTION); 413 - } 414 - 415 - /* A special note: we *must* always transfer >=16 bit words. 416 - It's always safe to round up, so we do. */ 417 - static void 418 - hpp_io_block_output(struct net_device *dev, int count, 419 - const unsigned char *buf, int start_page) 420 - { 421 - int ioaddr = dev->base_addr - NIC_OFFSET; 422 - outw(start_page << 8, ioaddr + HPP_OUT_ADDR); 423 - outsl(ioaddr + HP_DATAPORT, buf, (count+3)>>2); 424 - } 425 - 426 - static void 427 - hpp_mem_block_output(struct net_device *dev, int count, 428 - const unsigned char *buf, int start_page) 429 - { 430 - int ioaddr = dev->base_addr - NIC_OFFSET; 431 - int option_reg = inw(ioaddr + HPP_OPTION); 432 - 433 - outw(start_page << 8, ioaddr + HPP_OUT_ADDR); 434 - outw(option_reg & ~(MemDisable + BootROMEnb), ioaddr + HPP_OPTION); 435 - memcpy_toio(ei_status.mem, buf, (count + 3) & ~3); 436 - outw(option_reg, ioaddr + HPP_OPTION); 437 - } 438 - 439 - 440 - #ifdef MODULE 441 - #define MAX_HPP_CARDS 4 /* Max number of HPP cards per module */ 442 - static struct net_device *dev_hpp[MAX_HPP_CARDS]; 443 - static int io[MAX_HPP_CARDS]; 444 - static int irq[MAX_HPP_CARDS]; 445 - 446 - module_param_array(io, int, NULL, 0); 447 - module_param_array(irq, int, NULL, 0); 448 - MODULE_PARM_DESC(io, "I/O port address(es)"); 449 - MODULE_PARM_DESC(irq, "IRQ number(s); ignored if properly detected"); 450 - MODULE_DESCRIPTION("HP PC-LAN+ ISA ethernet driver"); 451 - MODULE_LICENSE("GPL"); 452 - 453 - /* This is set up so that only a single autoprobe takes place per call. 454 - ISA device autoprobes on a running machine are not recommended. */ 455 - int __init 456 - init_module(void) 457 - { 458 - struct net_device *dev; 459 - int this_dev, found = 0; 460 - 461 - for (this_dev = 0; this_dev < MAX_HPP_CARDS; this_dev++) { 462 - if (io[this_dev] == 0) { 463 - if (this_dev != 0) break; /* only autoprobe 1st one */ 464 - printk(KERN_NOTICE "hp-plus.c: Presently autoprobing (not recommended) for a single card.\n"); 465 - } 466 - dev = alloc_eip_netdev(); 467 - if (!dev) 468 - break; 469 - dev->irq = irq[this_dev]; 470 - dev->base_addr = io[this_dev]; 471 - if (do_hpp_probe(dev) == 0) { 472 - dev_hpp[found++] = dev; 473 - continue; 474 - } 475 - free_netdev(dev); 476 - printk(KERN_WARNING "hp-plus.c: No HP-Plus card found (i/o = 0x%x).\n", io[this_dev]); 477 - break; 478 - } 479 - if (found) 480 - return 0; 481 - return -ENXIO; 482 - } 483 - 484 - static void cleanup_card(struct net_device *dev) 485 - { 486 - /* NB: hpp_close() handles free_irq */ 487 - iounmap(ei_status.mem); 488 - release_region(dev->base_addr - NIC_OFFSET, HP_IO_EXTENT); 489 - } 490 - 491 - void __exit 492 - cleanup_module(void) 493 - { 494 - int this_dev; 495 - 496 - for (this_dev = 0; this_dev < MAX_HPP_CARDS; this_dev++) { 497 - struct net_device *dev = dev_hpp[this_dev]; 498 - if (dev) { 499 - unregister_netdev(dev); 500 - cleanup_card(dev); 501 - free_netdev(dev); 502 - } 503 - } 504 - } 505 - #endif /* MODULE */
-438
drivers/net/ethernet/8390/hp.c
··· 1 - /* hp.c: A HP LAN ethernet driver for linux. */ 2 - /* 3 - Written 1993-94 by Donald Becker. 4 - 5 - Copyright 1993 United States Government as represented by the 6 - Director, National Security Agency. 7 - 8 - This software may be used and distributed according to the terms 9 - of the GNU General Public License, incorporated herein by reference. 10 - 11 - The author may be reached as becker@scyld.com, or C/O 12 - Scyld Computing Corporation 13 - 410 Severn Ave., Suite 210 14 - Annapolis MD 21403 15 - 16 - This is a driver for the HP PC-LAN adaptors. 17 - 18 - Sources: 19 - The Crynwr packet driver. 20 - */ 21 - 22 - static const char version[] = 23 - "hp.c:v1.10 9/23/94 Donald Becker (becker@cesdis.gsfc.nasa.gov)\n"; 24 - 25 - 26 - #include <linux/module.h> 27 - #include <linux/kernel.h> 28 - #include <linux/errno.h> 29 - #include <linux/ioport.h> 30 - #include <linux/netdevice.h> 31 - #include <linux/etherdevice.h> 32 - #include <linux/init.h> 33 - #include <linux/interrupt.h> 34 - #include <linux/delay.h> 35 - 36 - #include <asm/io.h> 37 - 38 - #include "8390.h" 39 - 40 - #define DRV_NAME "hp" 41 - 42 - /* A zero-terminated list of I/O addresses to be probed. */ 43 - static unsigned int hppclan_portlist[] __initdata = 44 - { 0x300, 0x320, 0x340, 0x280, 0x2C0, 0x200, 0x240, 0}; 45 - 46 - #define HP_IO_EXTENT 32 47 - 48 - #define HP_DATAPORT 0x0c /* "Remote DMA" data port. */ 49 - #define HP_ID 0x07 50 - #define HP_CONFIGURE 0x08 /* Configuration register. */ 51 - #define HP_RUN 0x01 /* 1 == Run, 0 == reset. */ 52 - #define HP_IRQ 0x0E /* Mask for software-configured IRQ line. */ 53 - #define HP_DATAON 0x10 /* Turn on dataport */ 54 - #define NIC_OFFSET 0x10 /* Offset the 8390 registers. */ 55 - 56 - #define HP_START_PG 0x00 /* First page of TX buffer */ 57 - #define HP_8BSTOP_PG 0x80 /* Last page +1 of RX ring */ 58 - #define HP_16BSTOP_PG 0xFF /* Same, for 16 bit cards. */ 59 - 60 - static int hp_probe1(struct net_device *dev, int ioaddr); 61 - 62 - static void hp_reset_8390(struct net_device *dev); 63 - static void hp_get_8390_hdr(struct net_device *dev, struct e8390_pkt_hdr *hdr, 64 - int ring_page); 65 - static void hp_block_input(struct net_device *dev, int count, 66 - struct sk_buff *skb , int ring_offset); 67 - static void hp_block_output(struct net_device *dev, int count, 68 - const unsigned char *buf, int start_page); 69 - 70 - static void hp_init_card(struct net_device *dev); 71 - 72 - /* The map from IRQ number to HP_CONFIGURE register setting. */ 73 - /* My default is IRQ5 0 1 2 3 4 5 6 7 8 9 10 11 */ 74 - static char irqmap[16] __initdata= { 0, 0, 4, 6, 8,10, 0,14, 0, 4, 2,12,0,0,0,0}; 75 - 76 - 77 - /* Probe for an HP LAN adaptor. 78 - Also initialize the card and fill in STATION_ADDR with the station 79 - address. */ 80 - 81 - static int __init do_hp_probe(struct net_device *dev) 82 - { 83 - int i; 84 - int base_addr = dev->base_addr; 85 - int irq = dev->irq; 86 - 87 - if (base_addr > 0x1ff) /* Check a single specified location. */ 88 - return hp_probe1(dev, base_addr); 89 - else if (base_addr != 0) /* Don't probe at all. */ 90 - return -ENXIO; 91 - 92 - for (i = 0; hppclan_portlist[i]; i++) { 93 - if (hp_probe1(dev, hppclan_portlist[i]) == 0) 94 - return 0; 95 - dev->irq = irq; 96 - } 97 - 98 - return -ENODEV; 99 - } 100 - 101 - #ifndef MODULE 102 - struct net_device * __init hp_probe(int unit) 103 - { 104 - struct net_device *dev = alloc_eip_netdev(); 105 - int err; 106 - 107 - if (!dev) 108 - return ERR_PTR(-ENOMEM); 109 - 110 - sprintf(dev->name, "eth%d", unit); 111 - netdev_boot_setup_check(dev); 112 - 113 - err = do_hp_probe(dev); 114 - if (err) 115 - goto out; 116 - return dev; 117 - out: 118 - free_netdev(dev); 119 - return ERR_PTR(err); 120 - } 121 - #endif 122 - 123 - static int __init hp_probe1(struct net_device *dev, int ioaddr) 124 - { 125 - int i, retval, board_id, wordmode; 126 - const char *name; 127 - static unsigned version_printed; 128 - 129 - if (!request_region(ioaddr, HP_IO_EXTENT, DRV_NAME)) 130 - return -EBUSY; 131 - 132 - /* Check for the HP physical address, 08 00 09 xx xx xx. */ 133 - /* This really isn't good enough: we may pick up HP LANCE boards 134 - also! Avoid the lance 0x5757 signature. */ 135 - if (inb(ioaddr) != 0x08 136 - || inb(ioaddr+1) != 0x00 137 - || inb(ioaddr+2) != 0x09 138 - || inb(ioaddr+14) == 0x57) { 139 - retval = -ENODEV; 140 - goto out; 141 - } 142 - 143 - /* Set up the parameters based on the board ID. 144 - If you have additional mappings, please mail them to me -djb. */ 145 - if ((board_id = inb(ioaddr + HP_ID)) & 0x80) { 146 - name = "HP27247"; 147 - wordmode = 1; 148 - } else { 149 - name = "HP27250"; 150 - wordmode = 0; 151 - } 152 - 153 - if (ei_debug && version_printed++ == 0) 154 - printk(version); 155 - 156 - printk("%s: %s (ID %02x) at %#3x,", dev->name, name, board_id, ioaddr); 157 - 158 - for(i = 0; i < ETH_ALEN; i++) 159 - dev->dev_addr[i] = inb(ioaddr + i); 160 - 161 - printk(" %pM", dev->dev_addr); 162 - 163 - /* Snarf the interrupt now. Someday this could be moved to open(). */ 164 - if (dev->irq < 2) { 165 - static const int irq_16list[] = { 11, 10, 5, 3, 4, 7, 9, 0}; 166 - static const int irq_8list[] = { 7, 5, 3, 4, 9, 0}; 167 - const int *irqp = wordmode ? irq_16list : irq_8list; 168 - do { 169 - int irq = *irqp; 170 - if (request_irq (irq, NULL, 0, "bogus", NULL) != -EBUSY) { 171 - unsigned long cookie = probe_irq_on(); 172 - /* Twinkle the interrupt, and check if it's seen. */ 173 - outb_p(irqmap[irq] | HP_RUN, ioaddr + HP_CONFIGURE); 174 - outb_p( 0x00 | HP_RUN, ioaddr + HP_CONFIGURE); 175 - if (irq == probe_irq_off(cookie) /* It's a good IRQ line! */ 176 - && request_irq (irq, eip_interrupt, 0, DRV_NAME, dev) == 0) { 177 - printk(" selecting IRQ %d.\n", irq); 178 - dev->irq = *irqp; 179 - break; 180 - } 181 - } 182 - } while (*++irqp); 183 - if (*irqp == 0) { 184 - printk(" no free IRQ lines.\n"); 185 - retval = -EBUSY; 186 - goto out; 187 - } 188 - } else { 189 - if (dev->irq == 2) 190 - dev->irq = 9; 191 - if ((retval = request_irq(dev->irq, eip_interrupt, 0, DRV_NAME, dev))) { 192 - printk (" unable to get IRQ %d.\n", dev->irq); 193 - goto out; 194 - } 195 - } 196 - 197 - /* Set the base address to point to the NIC, not the "real" base! */ 198 - dev->base_addr = ioaddr + NIC_OFFSET; 199 - dev->netdev_ops = &eip_netdev_ops; 200 - 201 - ei_status.name = name; 202 - ei_status.word16 = wordmode; 203 - ei_status.tx_start_page = HP_START_PG; 204 - ei_status.rx_start_page = HP_START_PG + TX_PAGES; 205 - ei_status.stop_page = wordmode ? HP_16BSTOP_PG : HP_8BSTOP_PG; 206 - 207 - ei_status.reset_8390 = hp_reset_8390; 208 - ei_status.get_8390_hdr = hp_get_8390_hdr; 209 - ei_status.block_input = hp_block_input; 210 - ei_status.block_output = hp_block_output; 211 - hp_init_card(dev); 212 - 213 - retval = register_netdev(dev); 214 - if (retval) 215 - goto out1; 216 - return 0; 217 - out1: 218 - free_irq(dev->irq, dev); 219 - out: 220 - release_region(ioaddr, HP_IO_EXTENT); 221 - return retval; 222 - } 223 - 224 - static void 225 - hp_reset_8390(struct net_device *dev) 226 - { 227 - int hp_base = dev->base_addr - NIC_OFFSET; 228 - int saved_config = inb_p(hp_base + HP_CONFIGURE); 229 - 230 - if (ei_debug > 1) printk("resetting the 8390 time=%ld...", jiffies); 231 - outb_p(0x00, hp_base + HP_CONFIGURE); 232 - ei_status.txing = 0; 233 - /* Pause just a few cycles for the hardware reset to take place. */ 234 - udelay(5); 235 - 236 - outb_p(saved_config, hp_base + HP_CONFIGURE); 237 - udelay(5); 238 - 239 - if ((inb_p(hp_base+NIC_OFFSET+EN0_ISR) & ENISR_RESET) == 0) 240 - printk("%s: hp_reset_8390() did not complete.\n", dev->name); 241 - 242 - if (ei_debug > 1) printk("8390 reset done (%ld).", jiffies); 243 - } 244 - 245 - static void 246 - hp_get_8390_hdr(struct net_device *dev, struct e8390_pkt_hdr *hdr, int ring_page) 247 - { 248 - int nic_base = dev->base_addr; 249 - int saved_config = inb_p(nic_base - NIC_OFFSET + HP_CONFIGURE); 250 - 251 - outb_p(saved_config | HP_DATAON, nic_base - NIC_OFFSET + HP_CONFIGURE); 252 - outb_p(E8390_NODMA+E8390_PAGE0+E8390_START, nic_base); 253 - outb_p(sizeof(struct e8390_pkt_hdr), nic_base + EN0_RCNTLO); 254 - outb_p(0, nic_base + EN0_RCNTHI); 255 - outb_p(0, nic_base + EN0_RSARLO); /* On page boundary */ 256 - outb_p(ring_page, nic_base + EN0_RSARHI); 257 - outb_p(E8390_RREAD+E8390_START, nic_base); 258 - 259 - if (ei_status.word16) 260 - insw(nic_base - NIC_OFFSET + HP_DATAPORT, hdr, sizeof(struct e8390_pkt_hdr)>>1); 261 - else 262 - insb(nic_base - NIC_OFFSET + HP_DATAPORT, hdr, sizeof(struct e8390_pkt_hdr)); 263 - 264 - outb_p(saved_config & (~HP_DATAON), nic_base - NIC_OFFSET + HP_CONFIGURE); 265 - } 266 - 267 - /* Block input and output, similar to the Crynwr packet driver. If you are 268 - porting to a new ethercard look at the packet driver source for hints. 269 - The HP LAN doesn't use shared memory -- we put the packet 270 - out through the "remote DMA" dataport. */ 271 - 272 - static void 273 - hp_block_input(struct net_device *dev, int count, struct sk_buff *skb, int ring_offset) 274 - { 275 - int nic_base = dev->base_addr; 276 - int saved_config = inb_p(nic_base - NIC_OFFSET + HP_CONFIGURE); 277 - int xfer_count = count; 278 - char *buf = skb->data; 279 - 280 - outb_p(saved_config | HP_DATAON, nic_base - NIC_OFFSET + HP_CONFIGURE); 281 - outb_p(E8390_NODMA+E8390_PAGE0+E8390_START, nic_base); 282 - outb_p(count & 0xff, nic_base + EN0_RCNTLO); 283 - outb_p(count >> 8, nic_base + EN0_RCNTHI); 284 - outb_p(ring_offset & 0xff, nic_base + EN0_RSARLO); 285 - outb_p(ring_offset >> 8, nic_base + EN0_RSARHI); 286 - outb_p(E8390_RREAD+E8390_START, nic_base); 287 - if (ei_status.word16) { 288 - insw(nic_base - NIC_OFFSET + HP_DATAPORT,buf,count>>1); 289 - if (count & 0x01) 290 - buf[count-1] = inb(nic_base - NIC_OFFSET + HP_DATAPORT), xfer_count++; 291 - } else { 292 - insb(nic_base - NIC_OFFSET + HP_DATAPORT, buf, count); 293 - } 294 - /* This is for the ALPHA version only, remove for later releases. */ 295 - if (ei_debug > 0) { /* DMA termination address check... */ 296 - int high = inb_p(nic_base + EN0_RSARHI); 297 - int low = inb_p(nic_base + EN0_RSARLO); 298 - int addr = (high << 8) + low; 299 - /* Check only the lower 8 bits so we can ignore ring wrap. */ 300 - if (((ring_offset + xfer_count) & 0xff) != (addr & 0xff)) 301 - printk("%s: RX transfer address mismatch, %#4.4x vs. %#4.4x (actual).\n", 302 - dev->name, ring_offset + xfer_count, addr); 303 - } 304 - outb_p(saved_config & (~HP_DATAON), nic_base - NIC_OFFSET + HP_CONFIGURE); 305 - } 306 - 307 - static void 308 - hp_block_output(struct net_device *dev, int count, 309 - const unsigned char *buf, int start_page) 310 - { 311 - int nic_base = dev->base_addr; 312 - int saved_config = inb_p(nic_base - NIC_OFFSET + HP_CONFIGURE); 313 - 314 - outb_p(saved_config | HP_DATAON, nic_base - NIC_OFFSET + HP_CONFIGURE); 315 - /* Round the count up for word writes. Do we need to do this? 316 - What effect will an odd byte count have on the 8390? 317 - I should check someday. */ 318 - if (ei_status.word16 && (count & 0x01)) 319 - count++; 320 - /* We should already be in page 0, but to be safe... */ 321 - outb_p(E8390_PAGE0+E8390_START+E8390_NODMA, nic_base); 322 - 323 - #ifdef NE8390_RW_BUGFIX 324 - /* Handle the read-before-write bug the same way as the 325 - Crynwr packet driver -- the NatSemi method doesn't work. */ 326 - outb_p(0x42, nic_base + EN0_RCNTLO); 327 - outb_p(0, nic_base + EN0_RCNTHI); 328 - outb_p(0xff, nic_base + EN0_RSARLO); 329 - outb_p(0x00, nic_base + EN0_RSARHI); 330 - #define NE_CMD 0x00 331 - outb_p(E8390_RREAD+E8390_START, nic_base + NE_CMD); 332 - /* Make certain that the dummy read has occurred. */ 333 - inb_p(0x61); 334 - inb_p(0x61); 335 - #endif 336 - 337 - outb_p(count & 0xff, nic_base + EN0_RCNTLO); 338 - outb_p(count >> 8, nic_base + EN0_RCNTHI); 339 - outb_p(0x00, nic_base + EN0_RSARLO); 340 - outb_p(start_page, nic_base + EN0_RSARHI); 341 - 342 - outb_p(E8390_RWRITE+E8390_START, nic_base); 343 - if (ei_status.word16) { 344 - /* Use the 'rep' sequence for 16 bit boards. */ 345 - outsw(nic_base - NIC_OFFSET + HP_DATAPORT, buf, count>>1); 346 - } else { 347 - outsb(nic_base - NIC_OFFSET + HP_DATAPORT, buf, count); 348 - } 349 - 350 - /* DON'T check for 'inb_p(EN0_ISR) & ENISR_RDC' here -- it's broken! */ 351 - 352 - /* This is for the ALPHA version only, remove for later releases. */ 353 - if (ei_debug > 0) { /* DMA termination address check... */ 354 - int high = inb_p(nic_base + EN0_RSARHI); 355 - int low = inb_p(nic_base + EN0_RSARLO); 356 - int addr = (high << 8) + low; 357 - if ((start_page << 8) + count != addr) 358 - printk("%s: TX Transfer address mismatch, %#4.4x vs. %#4.4x.\n", 359 - dev->name, (start_page << 8) + count, addr); 360 - } 361 - outb_p(saved_config & (~HP_DATAON), nic_base - NIC_OFFSET + HP_CONFIGURE); 362 - } 363 - 364 - /* This function resets the ethercard if something screws up. */ 365 - static void __init 366 - hp_init_card(struct net_device *dev) 367 - { 368 - int irq = dev->irq; 369 - NS8390p_init(dev, 0); 370 - outb_p(irqmap[irq&0x0f] | HP_RUN, 371 - dev->base_addr - NIC_OFFSET + HP_CONFIGURE); 372 - } 373 - 374 - #ifdef MODULE 375 - #define MAX_HP_CARDS 4 /* Max number of HP cards per module */ 376 - static struct net_device *dev_hp[MAX_HP_CARDS]; 377 - static int io[MAX_HP_CARDS]; 378 - static int irq[MAX_HP_CARDS]; 379 - 380 - module_param_array(io, int, NULL, 0); 381 - module_param_array(irq, int, NULL, 0); 382 - MODULE_PARM_DESC(io, "I/O base address(es)"); 383 - MODULE_PARM_DESC(irq, "IRQ number(s) (assigned)"); 384 - MODULE_DESCRIPTION("HP PC-LAN ISA ethernet driver"); 385 - MODULE_LICENSE("GPL"); 386 - 387 - /* This is set up so that only a single autoprobe takes place per call. 388 - ISA device autoprobes on a running machine are not recommended. */ 389 - int __init 390 - init_module(void) 391 - { 392 - struct net_device *dev; 393 - int this_dev, found = 0; 394 - 395 - for (this_dev = 0; this_dev < MAX_HP_CARDS; this_dev++) { 396 - if (io[this_dev] == 0) { 397 - if (this_dev != 0) break; /* only autoprobe 1st one */ 398 - printk(KERN_NOTICE "hp.c: Presently autoprobing (not recommended) for a single card.\n"); 399 - } 400 - dev = alloc_eip_netdev(); 401 - if (!dev) 402 - break; 403 - dev->irq = irq[this_dev]; 404 - dev->base_addr = io[this_dev]; 405 - if (do_hp_probe(dev) == 0) { 406 - dev_hp[found++] = dev; 407 - continue; 408 - } 409 - free_netdev(dev); 410 - printk(KERN_WARNING "hp.c: No HP card found (i/o = 0x%x).\n", io[this_dev]); 411 - break; 412 - } 413 - if (found) 414 - return 0; 415 - return -ENXIO; 416 - } 417 - 418 - static void cleanup_card(struct net_device *dev) 419 - { 420 - free_irq(dev->irq, dev); 421 - release_region(dev->base_addr - NIC_OFFSET, HP_IO_EXTENT); 422 - } 423 - 424 - void __exit 425 - cleanup_module(void) 426 - { 427 - int this_dev; 428 - 429 - for (this_dev = 0; this_dev < MAX_HP_CARDS; this_dev++) { 430 - struct net_device *dev = dev_hp[this_dev]; 431 - if (dev) { 432 - unregister_netdev(dev); 433 - cleanup_card(dev); 434 - free_netdev(dev); 435 - } 436 - } 437 - } 438 - #endif /* MODULE */