drivers/net/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/delay.h>
  34
  35 #include <asm/system.h>
  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_multicast_list = 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 < ETHER_ADDR_LEN; 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         return;
 355 }
 356
 357 /* The programmed-I/O version of reading the 4 byte 8390 specific header.
 358    Note that transfer with the EtherTwist+ must be on word boundaries. */
 359
 360 static void
 361 hpp_io_get_8390_hdr(struct net_device *dev, struct e8390_pkt_hdr *hdr, int ring_page)
 362 {
 363         int ioaddr = dev->base_addr - NIC_OFFSET;
 364
 365         outw((ring_page<<8), ioaddr + HPP_IN_ADDR);
 366         insw(ioaddr + HP_DATAPORT, hdr, sizeof(struct e8390_pkt_hdr)>>1);
 367 }
 368
 369 /* Block input and output, similar to the Crynwr packet driver. */
 370
 371 static void
 372 hpp_io_block_input(struct net_device *dev, int count, struct sk_buff *skb, int ring_offset)
 373 {
 374         int ioaddr = dev->base_addr - NIC_OFFSET;
 375         char *buf = skb->data;
 376
 377         outw(ring_offset, ioaddr + HPP_IN_ADDR);
 378         insw(ioaddr + HP_DATAPORT, buf, count>>1);
 379         if (count & 0x01)
 380         buf[count-1] = inw(ioaddr + HP_DATAPORT);
 381 }
 382
 383 /* The corresponding shared memory versions of the above 2 functions. */
 384
 385 static void
 386 hpp_mem_get_8390_hdr(struct net_device *dev, struct e8390_pkt_hdr *hdr, int ring_page)
 387 {
 388         int ioaddr = dev->base_addr - NIC_OFFSET;
 389         int option_reg = inw(ioaddr + HPP_OPTION);
 390
 391         outw((ring_page<<8), ioaddr + HPP_IN_ADDR);
 392         outw(option_reg & ~(MemDisable + BootROMEnb), ioaddr + HPP_OPTION);
 393         memcpy_fromio(hdr, ei_status.mem, sizeof(struct e8390_pkt_hdr));
 394         outw(option_reg, ioaddr + HPP_OPTION);
 395         hdr->count = (le16_to_cpu(hdr->count) + 3) & ~3;        /* Round up allocation. */
 396 }
 397
 398 static void
 399 hpp_mem_block_input(struct net_device *dev, int count, struct sk_buff *skb, int ring_offset)
 400 {
 401         int ioaddr = dev->base_addr - NIC_OFFSET;
 402         int option_reg = inw(ioaddr + HPP_OPTION);
 403
 404         outw(ring_offset, ioaddr + HPP_IN_ADDR);
 405
 406         outw(option_reg & ~(MemDisable + BootROMEnb), ioaddr + HPP_OPTION);
 407
 408         /* Caution: this relies on get_8390_hdr() rounding up count!
 409            Also note that we *can't* use eth_io_copy_and_sum() because
 410            it will not always copy "count" bytes (e.g. padded IP).  */
 411
 412         memcpy_fromio(skb->data, ei_status.mem, count);
 413         outw(option_reg, ioaddr + HPP_OPTION);
 414 }
 415
 416 /* A special note: we *must* always transfer >=16 bit words.
 417    It's always safe to round up, so we do. */
 418 static void
 419 hpp_io_block_output(struct net_device *dev, int count,
 420                                         const unsigned char *buf, int start_page)
 421 {
 422         int ioaddr = dev->base_addr - NIC_OFFSET;
 423         outw(start_page << 8, ioaddr + HPP_OUT_ADDR);
 424         outsl(ioaddr + HP_DATAPORT, buf, (count+3)>>2);
 425         return;
 426 }
 427
 428 static void
 429 hpp_mem_block_output(struct net_device *dev, int count,
 430                                 const unsigned char *buf, int start_page)
 431 {
 432         int ioaddr = dev->base_addr - NIC_OFFSET;
 433         int option_reg = inw(ioaddr + HPP_OPTION);
 434
 435         outw(start_page << 8, ioaddr + HPP_OUT_ADDR);
 436         outw(option_reg & ~(MemDisable + BootROMEnb), ioaddr + HPP_OPTION);
 437         memcpy_toio(ei_status.mem, buf, (count + 3) & ~3);
 438         outw(option_reg, ioaddr + HPP_OPTION);
 439
 440         return;
 441 }
 442
 443
 444 #ifdef MODULE
 445 #define MAX_HPP_CARDS   4       /* Max number of HPP cards per module */
 446 static struct net_device *dev_hpp[MAX_HPP_CARDS];
 447 static int io[MAX_HPP_CARDS];
 448 static int irq[MAX_HPP_CARDS];
 449
 450 module_param_array(io, int, NULL, 0);
 451 module_param_array(irq, int, NULL, 0);
 452 MODULE_PARM_DESC(io, "I/O port address(es)");
 453 MODULE_PARM_DESC(irq, "IRQ number(s); ignored if properly detected");
 454 MODULE_DESCRIPTION("HP PC-LAN+ ISA ethernet driver");
 455 MODULE_LICENSE("GPL");
 456
 457 /* This is set up so that only a single autoprobe takes place per call.
 458 ISA device autoprobes on a running machine are not recommended. */
 459 int __init
 460 init_module(void)
 461 {
 462         struct net_device *dev;
 463         int this_dev, found = 0;
 464
 465         for (this_dev = 0; this_dev < MAX_HPP_CARDS; this_dev++) {
 466                 if (io[this_dev] == 0)  {
 467                         if (this_dev != 0) break; /* only autoprobe 1st one */
 468                         printk(KERN_NOTICE "hp-plus.c: Presently autoprobing (not recommended) for a single card.\n");
 469                 }
 470                 dev = alloc_eip_netdev();
 471                 if (!dev)
 472                         break;
 473                 dev->irq = irq[this_dev];
 474                 dev->base_addr = io[this_dev];
 475                 if (do_hpp_probe(dev) == 0) {
 476                         dev_hpp[found++] = dev;
 477                         continue;
 478                 }
 479                 free_netdev(dev);
 480                 printk(KERN_WARNING "hp-plus.c: No HP-Plus card found (i/o = 0x%x).\n", io[this_dev]);
 481                 break;
 482         }
 483         if (found)
 484                 return 0;
 485         return -ENXIO;
 486 }
 487
 488 static void cleanup_card(struct net_device *dev)
 489 {
 490         /* NB: hpp_close() handles free_irq */
 491         iounmap(ei_status.mem);
 492         release_region(dev->base_addr - NIC_OFFSET, HP_IO_EXTENT);
 493 }
 494
 495 void __exit
 496 cleanup_module(void)
 497 {
 498         int this_dev;
 499
 500         for (this_dev = 0; this_dev < MAX_HPP_CARDS; this_dev++) {
 501                 struct net_device *dev = dev_hpp[this_dev];
 502                 if (dev) {
 503                         unregister_netdev(dev);
 504                         cleanup_card(dev);
 505                         free_netdev(dev);
 506                 }
 507         }
 508 }
 509 #endif /* MODULE */