SAFE public projects git trees. - safe/jmp/linux-2.6/blob - 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 \f
 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         SET_MODULE_OWNER(dev);
 126
 127         if (base_addr > 0x1ff)          /* Check a single specified location. */
 128                 return hpp_probe1(dev, base_addr);
 129         else if (base_addr != 0)        /* Don't probe at all. */
 130                 return -ENXIO;
 131
 132         for (i = 0; hpplus_portlist[i]; i++) {
 133                 if (hpp_probe1(dev, hpplus_portlist[i]) == 0)
 134                         return 0;
 135                 dev->irq = irq;
 136         }
 137
 138         return -ENODEV;
 139 }
 140
 141 static void cleanup_card(struct net_device *dev)
 142 {
 143         /* NB: hpp_close() handles free_irq */
 144         release_region(dev->base_addr - NIC_OFFSET, HP_IO_EXTENT);
 145 }
 146
 147 #ifndef MODULE
 148 struct net_device * __init hp_plus_probe(int unit)
 149 {
 150         struct net_device *dev = alloc_ei_netdev();
 151         int err;
 152
 153         if (!dev)
 154                 return ERR_PTR(-ENOMEM);
 155
 156         sprintf(dev->name, "eth%d", unit);
 157         netdev_boot_setup_check(dev);
 158
 159         err = do_hpp_probe(dev);
 160         if (err)
 161                 goto out;
 162         return dev;
 163 out:
 164         free_netdev(dev);
 165         return ERR_PTR(err);
 166 }
 167 #endif
 168
 169 /* Do the interesting part of the probe at a single address. */
 170 static int __init hpp_probe1(struct net_device *dev, int ioaddr)
 171 {
 172         int i, retval;
 173         unsigned char checksum = 0;
 174         const char name[] = "HP-PC-LAN+";
 175         int mem_start;
 176         static unsigned version_printed;
 177
 178         if (!request_region(ioaddr, HP_IO_EXTENT, DRV_NAME))
 179                 return -EBUSY;
 180
 181         /* Check for the HP+ signature, 50 48 0x 53. */
 182         if (inw(ioaddr + HP_ID) != 0x4850
 183                 || (inw(ioaddr + HP_PAGING) & 0xfff0) != 0x5300) {
 184                 retval = -ENODEV;
 185                 goto out;
 186         }
 187
 188         if (ei_debug  &&  version_printed++ == 0)
 189                 printk(version);
 190
 191         printk("%s: %s at %#3x,", dev->name, name, ioaddr);
 192
 193         /* Retrieve and checksum the station address. */
 194         outw(MAC_Page, ioaddr + HP_PAGING);
 195
 196         for(i = 0; i < ETHER_ADDR_LEN; i++) {
 197                 unsigned char inval = inb(ioaddr + 8 + i);
 198                 dev->dev_addr[i] = inval;
 199                 checksum += inval;
 200                 printk(" %2.2x", inval);
 201         }
 202         checksum += inb(ioaddr + 14);
 203
 204         if (checksum != 0xff) {
 205                 printk(" bad checksum %2.2x.\n", checksum);
 206                 retval = -ENODEV;
 207                 goto out;
 208         } else {
 209                 /* Point at the Software Configuration Flags. */
 210                 outw(ID_Page, ioaddr + HP_PAGING);
 211                 printk(" ID %4.4x", inw(ioaddr + 12));
 212         }
 213
 214         /* Read the IRQ line. */
 215         outw(HW_Page, ioaddr + HP_PAGING);
 216         {
 217                 int irq = inb(ioaddr + 13) & 0x0f;
 218                 int option = inw(ioaddr + HPP_OPTION);
 219
 220                 dev->irq = irq;
 221                 if (option & MemEnable) {
 222                         mem_start = inw(ioaddr + 9) << 8;
 223                         printk(", IRQ %d, memory address %#x.\n", irq, mem_start);
 224                 } else {
 225                         mem_start = 0;
 226                         printk(", IRQ %d, programmed-I/O mode.\n", irq);
 227                 }
 228         }
 229
 230         /* Set the wrap registers for string I/O reads.   */
 231         outw((HP_START_PG + TX_PAGES/2) | ((HP_STOP_PG - 1) << 8), ioaddr + 14);
 232
 233         /* Set the base address to point to the NIC, not the "real" base! */
 234         dev->base_addr = ioaddr + NIC_OFFSET;
 235
 236         dev->open = &hpp_open;
 237         dev->stop = &hpp_close;
 238 #ifdef CONFIG_NET_POLL_CONTROLLER
 239         dev->poll_controller = ei_poll;
 240 #endif
 241
 242         ei_status.name = name;
 243         ei_status.word16 = 0;           /* Agggghhhhh! Debug time: 2 days! */
 244         ei_status.tx_start_page = HP_START_PG;
 245         ei_status.rx_start_page = HP_START_PG + TX_PAGES/2;
 246         ei_status.stop_page = HP_STOP_PG;
 247
 248         ei_status.reset_8390 = &hpp_reset_8390;
 249         ei_status.block_input = &hpp_io_block_input;
 250         ei_status.block_output = &hpp_io_block_output;
 251         ei_status.get_8390_hdr = &hpp_io_get_8390_hdr;
 252
 253         /* Check if the memory_enable flag is set in the option register. */
 254         if (mem_start) {
 255                 ei_status.block_input = &hpp_mem_block_input;
 256                 ei_status.block_output = &hpp_mem_block_output;
 257                 ei_status.get_8390_hdr = &hpp_mem_get_8390_hdr;
 258                 dev->mem_start = mem_start;
 259                 ei_status.rmem_start = dev->mem_start + TX_PAGES/2*256;
 260                 dev->mem_end = ei_status.rmem_end
 261                         = dev->mem_start + (HP_STOP_PG - HP_START_PG)*256;
 262         }
 263
 264         outw(Perf_Page, ioaddr + HP_PAGING);
 265         NS8390_init(dev, 0);
 266         /* Leave the 8390 and HP chip reset. */
 267         outw(inw(ioaddr + HPP_OPTION) & ~EnableIRQ, ioaddr + HPP_OPTION);
 268
 269         retval = register_netdev(dev);
 270         if (retval)
 271                 goto out;
 272         return 0;
 273 out:
 274         release_region(ioaddr, HP_IO_EXTENT);
 275         return retval;
 276 }
 277
 278 static int
 279 hpp_open(struct net_device *dev)
 280 {
 281         int ioaddr = dev->base_addr - NIC_OFFSET;
 282         int option_reg;
 283         int retval;
 284
 285         if ((retval = request_irq(dev->irq, ei_interrupt, 0, dev->name, dev))) {
 286             return retval;
 287         }
 288
 289         /* Reset the 8390 and HP chip. */
 290         option_reg = inw(ioaddr + HPP_OPTION);
 291         outw(option_reg & ~(NICReset + ChipReset), ioaddr + HPP_OPTION);
 292         udelay(5);
 293         /* Unreset the board and enable interrupts. */
 294         outw(option_reg | (EnableIRQ + NICReset + ChipReset), ioaddr + HPP_OPTION);
 295
 296         /* Set the wrap registers for programmed-I/O operation.   */
 297         outw(HW_Page, ioaddr + HP_PAGING);
 298         outw((HP_START_PG + TX_PAGES/2) | ((HP_STOP_PG - 1) << 8), ioaddr + 14);
 299
 300         /* Select the operational page. */
 301         outw(Perf_Page, ioaddr + HP_PAGING);
 302
 303         ei_open(dev);
 304         return 0;
 305 }
 306
 307 static int
 308 hpp_close(struct net_device *dev)
 309 {
 310         int ioaddr = dev->base_addr - NIC_OFFSET;
 311         int option_reg = inw(ioaddr + HPP_OPTION);
 312
 313         free_irq(dev->irq, dev);
 314         ei_close(dev);
 315         outw((option_reg & ~EnableIRQ) | MemDisable | NICReset | ChipReset,
 316                  ioaddr + HPP_OPTION);
 317
 318         return 0;
 319 }
 320
 321 static void
 322 hpp_reset_8390(struct net_device *dev)
 323 {
 324         int ioaddr = dev->base_addr - NIC_OFFSET;
 325         int option_reg = inw(ioaddr + HPP_OPTION);
 326
 327         if (ei_debug > 1) printk("resetting the 8390 time=%ld...", jiffies);
 328
 329         outw(option_reg & ~(NICReset + ChipReset), ioaddr + HPP_OPTION);
 330         /* Pause a few cycles for the hardware reset to take place. */
 331         udelay(5);
 332         ei_status.txing = 0;
 333         outw(option_reg | (EnableIRQ + NICReset + ChipReset), ioaddr + HPP_OPTION);
 334
 335         udelay(5);
 336
 337
 338         if ((inb_p(ioaddr+NIC_OFFSET+EN0_ISR) & ENISR_RESET) == 0)
 339                 printk("%s: hp_reset_8390() did not complete.\n", dev->name);
 340
 341         if (ei_debug > 1) printk("8390 reset done (%ld).", jiffies);
 342         return;
 343 }
 344
 345 /* The programmed-I/O version of reading the 4 byte 8390 specific header.
 346    Note that transfer with the EtherTwist+ must be on word boundaries. */
 347
 348 static void
 349 hpp_io_get_8390_hdr(struct net_device *dev, struct e8390_pkt_hdr *hdr, int ring_page)
 350 {
 351         int ioaddr = dev->base_addr - NIC_OFFSET;
 352
 353         outw((ring_page<<8), ioaddr + HPP_IN_ADDR);
 354         insw(ioaddr + HP_DATAPORT, hdr, sizeof(struct e8390_pkt_hdr)>>1);
 355 }
 356
 357 /* Block input and output, similar to the Crynwr packet driver. */
 358
 359 static void
 360 hpp_io_block_input(struct net_device *dev, int count, struct sk_buff *skb, int ring_offset)
 361 {
 362         int ioaddr = dev->base_addr - NIC_OFFSET;
 363         char *buf = skb->data;
 364
 365         outw(ring_offset, ioaddr + HPP_IN_ADDR);
 366         insw(ioaddr + HP_DATAPORT, buf, count>>1);
 367         if (count & 0x01)
 368         buf[count-1] = inw(ioaddr + HP_DATAPORT);
 369 }
 370
 371 /* The corresponding shared memory versions of the above 2 functions. */
 372
 373 static void
 374 hpp_mem_get_8390_hdr(struct net_device *dev, struct e8390_pkt_hdr *hdr, int ring_page)
 375 {
 376         int ioaddr = dev->base_addr - NIC_OFFSET;
 377         int option_reg = inw(ioaddr + HPP_OPTION);
 378
 379         outw((ring_page<<8), ioaddr + HPP_IN_ADDR);
 380         outw(option_reg & ~(MemDisable + BootROMEnb), ioaddr + HPP_OPTION);
 381         isa_memcpy_fromio(hdr, dev->mem_start, sizeof(struct e8390_pkt_hdr));
 382         outw(option_reg, ioaddr + HPP_OPTION);
 383         hdr->count = (le16_to_cpu(hdr->count) + 3) & ~3;        /* Round up allocation. */
 384 }
 385
 386 static void
 387 hpp_mem_block_input(struct net_device *dev, int count, struct sk_buff *skb, int ring_offset)
 388 {
 389         int ioaddr = dev->base_addr - NIC_OFFSET;
 390         int option_reg = inw(ioaddr + HPP_OPTION);
 391
 392         outw(ring_offset, ioaddr + HPP_IN_ADDR);
 393
 394         outw(option_reg & ~(MemDisable + BootROMEnb), ioaddr + HPP_OPTION);
 395
 396         /* Caution: this relies on get_8390_hdr() rounding up count!
 397            Also note that we *can't* use eth_io_copy_and_sum() because
 398            it will not always copy "count" bytes (e.g. padded IP).  */
 399
 400         isa_memcpy_fromio(skb->data, dev->mem_start, count);
 401         outw(option_reg, ioaddr + HPP_OPTION);
 402 }
 403
 404 /* A special note: we *must* always transfer >=16 bit words.
 405    It's always safe to round up, so we do. */
 406 static void
 407 hpp_io_block_output(struct net_device *dev, int count,
 408                                         const unsigned char *buf, int start_page)
 409 {
 410         int ioaddr = dev->base_addr - NIC_OFFSET;
 411         outw(start_page << 8, ioaddr + HPP_OUT_ADDR);
 412         outsl(ioaddr + HP_DATAPORT, buf, (count+3)>>2);
 413         return;
 414 }
 415
 416 static void
 417 hpp_mem_block_output(struct net_device *dev, int count,
 418                                 const unsigned char *buf, int start_page)
 419 {
 420         int ioaddr = dev->base_addr - NIC_OFFSET;
 421         int option_reg = inw(ioaddr + HPP_OPTION);
 422
 423         outw(start_page << 8, ioaddr + HPP_OUT_ADDR);
 424         outw(option_reg & ~(MemDisable + BootROMEnb), ioaddr + HPP_OPTION);
 425         isa_memcpy_toio(dev->mem_start, buf, (count + 3) & ~3);
 426         outw(option_reg, ioaddr + HPP_OPTION);
 427
 428         return;
 429 }
 430
 431 \f
 432 #ifdef MODULE
 433 #define MAX_HPP_CARDS   4       /* Max number of HPP cards per module */
 434 static struct net_device *dev_hpp[MAX_HPP_CARDS];
 435 static int io[MAX_HPP_CARDS];
 436 static int irq[MAX_HPP_CARDS];
 437
 438 module_param_array(io, int, NULL, 0);
 439 module_param_array(irq, int, NULL, 0);
 440 MODULE_PARM_DESC(io, "I/O port address(es)");
 441 MODULE_PARM_DESC(irq, "IRQ number(s); ignored if properly detected");
 442 MODULE_DESCRIPTION("HP PC-LAN+ ISA ethernet driver");
 443 MODULE_LICENSE("GPL");
 444
 445 /* This is set up so that only a single autoprobe takes place per call.
 446 ISA device autoprobes on a running machine are not recommended. */
 447 int
 448 init_module(void)
 449 {
 450         struct net_device *dev;
 451         int this_dev, found = 0;
 452
 453         for (this_dev = 0; this_dev < MAX_HPP_CARDS; this_dev++) {
 454                 if (io[this_dev] == 0)  {
 455                         if (this_dev != 0) break; /* only autoprobe 1st one */
 456                         printk(KERN_NOTICE "hp-plus.c: Presently autoprobing (not recommended) for a single card.\n");
 457                 }
 458                 dev = alloc_ei_netdev();
 459                 if (!dev)
 460                         break;
 461                 dev->irq = irq[this_dev];
 462                 dev->base_addr = io[this_dev];
 463                 if (do_hpp_probe(dev) == 0) {
 464                         dev_hpp[found++] = dev;
 465                         continue;
 466                 }
 467                 free_netdev(dev);
 468                 printk(KERN_WARNING "hp-plus.c: No HP-Plus card found (i/o = 0x%x).\n", io[this_dev]);
 469                 break;
 470         }
 471         if (found)
 472                 return 0;
 473         return -ENXIO;
 474 }
 475
 476 void
 477 cleanup_module(void)
 478 {
 479         int this_dev;
 480
 481         for (this_dev = 0; this_dev < MAX_HPP_CARDS; this_dev++) {
 482                 struct net_device *dev = dev_hpp[this_dev];
 483                 if (dev) {
 484                         unregister_netdev(dev);
 485                         cleanup_card(dev);
 486                         free_netdev(dev);
 487                 }
 488         }
 489 }
 490 #endif /* MODULE */