root/drivers/net/atp.c

/* [previous][next][first][last][top][bottom][index][help] */

DEFINITIONS

This source file includes following definitions.
  1. atp_init
  2. atp_probe1
  3. init_dev
  4. get_node_ID
  5. eeprom_op
  6. net_open
  7. hardware_init
  8. trigger_send
  9. write_packet
  10. net_send_packet
  11. net_interrupt
  12. net_rx
  13. read_block
  14. net_close
  15. net_get_stats
  16. set_multicast_list

   1 /* atp.c: Attached (pocket) ethernet adaptor driver for linux. */
   2 /*
   3         Written 1993 by Donald Becker.
   4         Copyright 1993 United States Government as represented by the Director,
   5         National Security Agency.  This software may only be used and distributed
   6         according to the terms of the GNU Public License as modified by SRC,
   7         incorported herein by reference.
   8 
   9         The author may be reached as becker@super.org or
  10         C/O Supercomputing Research Ctr., 17100 Science Dr., Bowie MD 20715
  11 
  12 */
  13 
  14 static char *version =
  15         "atp.c:v0.04 2/25/94 Donald Becker (becker@super.org)\n";
  16 
  17 /*
  18         This file is a device driver for the RealTek (aka AT-Lan-Tec) pocket
  19         ethernet adaptor.  This is a common low-cost OEM pocket ethernet
  20         adaptor, sold under many names.
  21 
  22   Sources:
  23         This driver was written from the packet driver assembly code provided by
  24         Vincent Bono of AT-Lan-Tec.      Ever try to figure out how a complicated
  25         device works just from the assembly code?  It ain't pretty.  The following
  26         description is written based on guesses and writing lots of special-purpose
  27         code to test my theorized operation.
  28 
  29                                         Theory of Operation
  30         
  31         The RTL8002 adaptor seems to be built around a custom spin of the SEEQ
  32         controller core.  It probably has a 16K or 64K internal packet buffer, of
  33         which the first 4K is devoted to transmit and the rest to receive.
  34         The controller maintains the queue of received packet and the packet buffer
  35         access pointer internally, with only 'reset to beginning' and 'skip to next
  36         packet' commands visible.  The transmit packet queue holds two (or more?)
  37         packets: both 'retransmit this packet' (due to collision) and 'transmit next
  38         packet' commands must be started by hand.
  39 
  40         The station address is stored in a standard bit-serial EEPROM which must be
  41         read (ughh) by the device driver.  (Provisions have been made for
  42         substituting a 74S288 PROM, but I haven't gotten reports of any models
  43         using it.)  Unlike built-in devices, a pocket adaptor can temporarily lose
  44         power without indication to the device driver.  The major effect is that
  45         the station address, receive filter (promiscuous, etc.) and transceiver
  46         must be reset.
  47 
  48         The controller itself has 16 registers, some of which use only the lower
  49         bits.  The registers are read and written 4 bits at a time.  The four bit
  50         register address is presented on the data lines along with a few additional
  51         timing and control bits.  The data is then read from status port or written
  52         to the data port.
  53 
  54         Since the bulk data transfer of the actual packets through the slow
  55         parallel port dominates the driver's running time, four distinct data
  56         (non-register) transfer modes are provided by the adaptor, two in each
  57         direction.  In the first mode timing for the nibble transfers is
  58         provided through the data port.  In the second mode the same timing is
  59         provided through the control port.  In either case the data is read from
  60         the status port and written to the data port, just as it is accessing
  61         registers.
  62 
  63         In addition to the basic data transfer methods, several more are modes are
  64         created by adding some delay by doing multiple reads of the data to allow
  65         it to stabilize.  This delay seems to be needed on most machines.
  66 
  67         The data transfer mode is stored in the 'dev->if_port' field.  Its default
  68         value is '4'.  It may be overriden at boot-time using the third parameter
  69         to the "ether=..." initialization.
  70 
  71         The header file <atp.h> provides inline functions that encapsulate the
  72         register and data access methods.  These functions are hand-tuned to
  73         generate reasonable object code.  This header file also documents my
  74         interpretations of the device registers.
  75 */
  76 
  77 #include <linux/config.h>               /* Used only to override default values. */
  78 #include <linux/kernel.h>
  79 #include <linux/sched.h>
  80 #include <linux/types.h>
  81 #include <linux/fcntl.h>
  82 #include <linux/interrupt.h>
  83 #include <linux/ptrace.h>
  84 #include <linux/ioport.h>
  85 #include <linux/in.h>
  86 #include <linux/malloc.h>
  87 #include <linux/string.h>
  88 #include <asm/system.h>
  89 #include <asm/bitops.h>
  90 #include <asm/io.h>
  91 #include <asm/dma.h>
  92 #include <errno.h>
  93 
  94 #include "dev.h"
  95 #include "eth.h"
  96 #include "skbuff.h"
  97 #include "arp.h"
  98 
  99 #include "atp.h"
 100 
 101 /* Compatibility definitions for earlier kernel versions. */
 102 #ifndef HAVE_AUTOIRQ
 103 /* From auto_irq.c, in ioport.h for later versions. */
 104 extern void autoirq_setup(int waittime);
 105 extern int autoirq_report(int waittime);
 106 /* The map from IRQ number (as passed to the interrupt handler) to
 107    'struct device'. */
 108 extern struct device *irq2dev_map[16];
 109 #endif
 110 
 111 #ifndef HAVE_ALLOC_SKB
 112 #define alloc_skb(size, priority) (struct sk_buff *) kmalloc(size,priority)
 113 #define kfree_skbmem(addr, size) kfree_s(addr,size);
 114 #endif
 115 
 116 #ifndef HAVE_PORTRESERVE
 117 #define check_region(ioaddr, size)              0
 118 #define snarf_region(ioaddr, size);             do ; while (0)
 119 #endif
 120 
 121 /* use 0 for production, 1 for verification, >2 for debug */
 122 #ifndef NET_DEBUG
 123 #define NET_DEBUG 4
 124 #endif
 125 static unsigned int net_debug = NET_DEBUG;
 126 
 127 /* The number of low I/O ports used by the ethercard. */
 128 #define ETHERCARD_TOTAL_SIZE    3
 129 
 130 /* Index to functions, as function prototypes. */
 131 
 132 extern int atp_probe(struct device *dev);
 133 
 134 static int atp_probe1(struct device *dev, short ioaddr);
 135 static void init_dev(struct device *dev);
 136 static void get_node_ID(struct device *dev);
 137 static unsigned short eeprom_op(short ioaddr, unsigned int cmd);
 138 static int net_open(struct device *dev);
 139 static void hardware_init(struct device *dev);
 140 static void write_packet(short ioaddr, int length, unsigned char *packet, int mode);
 141 static void trigger_send(short ioaddr, int length);
 142 static int      net_send_packet(struct sk_buff *skb, struct device *dev);
 143 static void net_interrupt(int reg_ptr);
 144 static void net_rx(struct device *dev);
 145 static void read_block(short ioaddr, int length, unsigned char *buffer, int data_mode);
 146 static int net_close(struct device *dev);
 147 static struct enet_statistics *net_get_stats(struct device *dev);
 148 #ifdef HAVE_MULTICAST
 149 static void set_multicast_list(struct device *dev, int num_addrs, void *addrs);
 150 #endif
 151 
 152 
 153 /* Check for a network adaptor of this type, and return '0' iff one exists.
 154    If dev->base_addr == 0, probe all likely locations.
 155    If dev->base_addr == 1, always return failure.
 156    If dev->base_addr == 2, alloate space for the device and return success
 157    (detachable devices only).
 158    */
 159 int
 160 atp_init(struct device *dev)
     /* [previous][next][first][last][top][bottom][index][help] */
 161 {
 162         int *port, ports[] = {0x378, 0x278, 0x3bc, 0};
 163         int base_addr = dev->base_addr;
 164 
 165         if (base_addr > 0x1ff)          /* Check a single specified location. */
 166                 return atp_probe1(dev, base_addr);
 167         else if (base_addr == 1)        /* Don't probe at all. */
 168                 return ENXIO;
 169 
 170         for (port = ports; *port; port++) {
 171                 int ioaddr = *port;
 172                 outb(0x57, ioaddr + PAR_DATA);
 173                 if (inb(ioaddr + PAR_DATA) != 0x57)
 174                         continue;
 175                 if (atp_probe1(dev, ioaddr) == 0)
 176                         return 0;
 177         }
 178 
 179         return ENODEV;
 180 }
 181 
 182 static int atp_probe1(struct device *dev, short ioaddr)
     /* [previous][next][first][last][top][bottom][index][help] */
 183 {
 184         int saved_ctrl_reg, status;
 185 
 186         outb(0xff, ioaddr + PAR_DATA);
 187         /* Save the original value of the Control register, in case we guessed
 188            wrong. */
 189         saved_ctrl_reg = inb(ioaddr + PAR_CONTROL);
 190         /* IRQEN=0, SLCTB=high INITB=high, AUTOFDB=high, STBB=high. */
 191         outb(0x04, ioaddr + PAR_CONTROL);
 192         write_reg_high(ioaddr, CMR1, CMR1h_RESET);
 193         eeprom_delay(2048);
 194         status = read_nibble(ioaddr, CMR1);
 195 
 196         if ((status & 0x78) != 0x08) {
 197                 /* The pocket adaptor probe failed, restore the control register. */
 198                 outb(saved_ctrl_reg, ioaddr + PAR_CONTROL);
 199                 return 1;
 200         }
 201         status = read_nibble(ioaddr, CMR2_h);
 202         if ((status & 0x78) != 0x10) {
 203                 outb(saved_ctrl_reg, ioaddr + PAR_CONTROL);
 204                 return 1;
 205         }
 206         /* Find the IRQ used by triggering an interrupt. */
 207         write_reg_byte(ioaddr, CMR2, 0x01);                     /* No accept mode, IRQ out. */
 208         write_reg_high(ioaddr, CMR1, CMR1h_RxENABLE | CMR1h_TxENABLE);  /* Enable Tx and Rx. */
 209 
 210         /* Omit autoIRQ routine for now. Use "table lookup" instead.  Uhgggh. */
 211         if (ioaddr == 0x378)
 212                 dev->irq = 7;
 213         else
 214                 dev->irq = 5;
 215         write_reg_high(ioaddr, CMR1, CMR1h_TxRxOFF); /* Diable Tx and Rx units. */
 216         write_reg(ioaddr, CMR2, CMR2_NULL);
 217 
 218         dev->base_addr = ioaddr;
 219 
 220         /* Read the station address PROM.  */
 221         get_node_ID(dev);
 222 
 223         printk("%s: Pocket adaptor found at %#3x, IRQ %d, SAPROM "
 224                    "%02X:%02X:%02X:%02X:%02X:%02X.\n", dev->name, dev->base_addr,
 225                    dev->irq, dev->dev_addr[0], dev->dev_addr[1], dev->dev_addr[2],
 226                    dev->dev_addr[3], dev->dev_addr[4], dev->dev_addr[5]);
 227 
 228         /* Leave the hardware in a reset state. */
 229     write_reg_high(ioaddr, CMR1, CMR1h_RESET);
 230 
 231         if (net_debug)
 232                 printk(version);
 233 
 234         /* Initialize the device structure. */
 235         init_dev(dev);
 236         dev->priv = kmalloc(sizeof(struct net_local), GFP_KERNEL);
 237         memset(dev->priv, 0, sizeof(struct net_local));
 238 
 239 
 240         {
 241                 struct net_local *lp = (struct net_local *)dev->priv;
 242                 lp->addr_mode = CMR2h_Normal;
 243         }
 244 
 245         /* For the ATP adaptor the "if_port" is really the data transfer mode. */
 246         dev->if_port = (dev->mem_start & 0xf) ? dev->mem_start & 0x7 : 4;
 247         if (dev->mem_end & 0xf)
 248                 net_debug = dev->mem_end & 7;
 249 
 250         dev->open               = net_open;
 251         dev->stop               = net_close;
 252         dev->hard_start_xmit = net_send_packet;
 253         dev->get_stats  = net_get_stats;
 254 #ifdef HAVE_MULTICAST
 255         dev->set_multicast_list = &set_multicast_list;
 256 #endif
 257 
 258         return 0;
 259 }
 260 
 261 /* Fill in the fields of the device structure with ethernet-generic values.
 262    This should be in a common file instead of per-driver.  */
 263 static void init_dev(struct device *dev)
     /* [previous][next][first][last][top][bottom][index][help] */
 264 {
 265         int i;
 266 
 267         for (i = 0; i < DEV_NUMBUFFS; i++)
 268                 dev->buffs[i] = NULL;
 269 
 270         dev->hard_header        = eth_header;
 271         dev->add_arp            = eth_add_arp;
 272         dev->queue_xmit         = dev_queue_xmit;
 273         dev->rebuild_header = eth_rebuild_header;
 274         dev->type_trans         = eth_type_trans;
 275 
 276         dev->type                       = ARPHRD_ETHER;
 277         dev->hard_header_len = ETH_HLEN;
 278         dev->mtu                        = 1500; /* eth_mtu */
 279         dev->addr_len           = ETH_ALEN;
 280         for (i = 0; i < ETH_ALEN; i++) {
 281                 dev->broadcast[i]=0xff;
 282         }
 283 
 284         /* New-style flags. */
 285         dev->flags                      = IFF_BROADCAST;
 286         dev->family                     = AF_INET;
 287         dev->pa_addr            = 0;
 288         dev->pa_brdaddr         = 0;
 289         dev->pa_mask            = 0;
 290         dev->pa_alen            = sizeof(unsigned long);
 291 }
 292 
 293 /* Read the station address PROM, usually a word-wide EEPROM. */
 294 static void get_node_ID(struct device *dev)
     /* [previous][next][first][last][top][bottom][index][help] */
 295 {
 296         short ioaddr = dev->base_addr;
 297         int sa_offset = 0;
 298         int i;
 299         
 300         write_reg(ioaddr, CMR2, CMR2_EEPROM);     /* Point to the EEPROM control registers. */
 301         
 302         /* Some adaptors have the station address at offset 15 instead of offset
 303            zero.  Check for it, and fix it if needed. */
 304         if (eeprom_op(ioaddr, EE_READ(0)) == 0xffff)
 305                 sa_offset = 15;
 306         
 307         for (i = 0; i < 3; i++)
 308                 ((unsigned short *)dev->dev_addr)[i] =
 309                         ntohs(eeprom_op(ioaddr, EE_READ(sa_offset + i)));
 310         
 311         write_reg(ioaddr, CMR2, CMR2_NULL);
 312 }
 313 
 314 /*
 315   An EEPROM read command starts by shifting out 0x60+address, and then
 316   shifting in the serial data. See the NatSemi databook for details.
 317  *                 ________________
 318  * CS : __|
 319  *                         ___     ___
 320  * CLK: ______|   |___|   |
 321  *               __ _______ _______
 322  * DI :  __X_______X_______X
 323  * DO :  _________X_______X
 324  */
 325 
 326 static unsigned short eeprom_op(short ioaddr, unsigned int cmd)
     /* [previous][next][first][last][top][bottom][index][help] */
 327 {
 328         unsigned eedata_out = 0;
 329         int num_bits = EE_CMD_SIZE;
 330         
 331         while (--num_bits >= 0) {
 332                 char outval = test_bit(num_bits, &cmd) ? EE_DATA_WRITE : 0;
 333                 write_reg_high(ioaddr, PROM_CMD, outval | EE_CLK_LOW);
 334                 eeprom_delay(5);
 335                 write_reg_high(ioaddr, PROM_CMD, outval | EE_CLK_HIGH);
 336                 eedata_out <<= 1;
 337                 if (read_nibble(ioaddr, PROM_DATA) & EE_DATA_READ)
 338                         eedata_out++;
 339                 eeprom_delay(5);
 340         }
 341         write_reg_high(ioaddr, PROM_CMD, EE_CLK_LOW & ~EE_CS);
 342         return eedata_out;
 343 }
 344 
 345 
 346 /* Open/initialize the board.  This is called (in the current kernel)
 347    sometime after booting when the 'ifconfig' program is run.
 348 
 349    This routine sets everything up anew at each open, even
 350    registers that "should" only need to be set once at boot, so that
 351    there is non-reboot way to recover if something goes wrong.
 352 
 353    This is an attachable device: if there is no dev->priv entry then it wasn't
 354    probed for at boot-time, and we need to probe for it again.
 355    */
 356 static int net_open(struct device *dev)
     /* [previous][next][first][last][top][bottom][index][help] */
 357 {
 358 
 359         /* The interrupt line is turned off (tri-stated) when the device isn't in
 360            use.  That's especially important for "attached" interfaces where the
 361            port or interrupt may be shared. */
 362         if (irq2dev_map[dev->irq] != 0
 363                 || (irq2dev_map[dev->irq] = dev) == 0
 364                 || request_irq(dev->irq, &net_interrupt)) {
 365                 return -EAGAIN;
 366         }
 367 
 368         hardware_init(dev);
 369         dev->start = 1;
 370         return 0;
 371 }
 372 
 373 /* This routine resets the hardware.  We initialize everything, assuming that
 374    the hardware may have been temporarily detacted. */
 375 static void hardware_init(struct device *dev)
     /* [previous][next][first][last][top][bottom][index][help] */
 376 {
 377         struct net_local *lp = (struct net_local *)dev->priv;
 378         int ioaddr = dev->base_addr;
 379     int i;
 380 
 381         write_reg_high(ioaddr, CMR1, CMR1h_RESET);
 382         
 383     for (i = 0; i < 6; i++)
 384                 write_reg_byte(ioaddr, PAR0 + i, dev->dev_addr[i]);
 385 
 386         write_reg_high(ioaddr, CMR2, lp->addr_mode);
 387 
 388         if (net_debug > 2) {
 389                 printk("%s: Reset: current Rx mode %d.\n", dev->name,
 390                            (read_nibble(ioaddr, CMR2_h) >> 3) & 0x0f);
 391         }
 392 
 393     write_reg(ioaddr, CMR2, CMR2_IRQOUT);
 394     write_reg_high(ioaddr, CMR1, CMR1h_RxENABLE | CMR1h_TxENABLE);
 395 
 396         /* Enable the interrupt line from the serial port. */
 397         outb(Ctrl_SelData + Ctrl_IRQEN, ioaddr + PAR_CONTROL);
 398 
 399         /* Unmask the interesting interrupts. */
 400     write_reg(ioaddr, IMR, ISR_RxOK | ISR_TxErr | ISR_TxOK);
 401     write_reg_high(ioaddr, IMR, ISRh_RxErr);
 402 
 403         lp->tx_unit_busy = 0;
 404     lp->pac_cnt_in_tx_buf = 0;
 405         lp->saved_tx_size = 0;
 406 
 407         dev->tbusy = 0;
 408         dev->interrupt = 0;
 409 }
 410 
 411 static void trigger_send(short ioaddr, int length)
     /* [previous][next][first][last][top][bottom][index][help] */
 412 {
 413         write_reg_byte(ioaddr, TxCNT0, length & 0xff);
 414         write_reg(ioaddr, TxCNT1, length >> 8);
 415         write_reg(ioaddr, CMR1, CMR1_Xmit);
 416 }
 417 
 418 static void write_packet(short ioaddr, int length, unsigned char *packet, int data_mode)
     /* [previous][next][first][last][top][bottom][index][help] */
 419 {
 420     length = (length + 1) & ~1;         /* Round up to word length. */
 421     outb(EOC+MAR, ioaddr + PAR_DATA);
 422     if ((data_mode & 1) == 0) {
 423                 /* Write the packet out, starting with the write addr. */
 424                 outb(WrAddr+MAR, ioaddr + PAR_DATA);
 425                 do {
 426                         write_byte_mode0(ioaddr, *packet++);
 427                 } while (--length > 0) ;
 428     } else {
 429                 /* Write the packet out in slow mode. */
 430                 unsigned char outbyte = *packet++;
 431 
 432                 outb(Ctrl_LNibWrite + Ctrl_IRQEN, ioaddr + PAR_CONTROL);
 433                 outb(WrAddr+MAR, ioaddr + PAR_DATA);
 434 
 435                 outb((outbyte & 0x0f)|0x40, ioaddr + PAR_DATA);
 436                 outb(outbyte & 0x0f, ioaddr + PAR_DATA);
 437                 outbyte >>= 4;
 438                 outb(outbyte & 0x0f, ioaddr + PAR_DATA);
 439                 outb(Ctrl_HNibWrite + Ctrl_IRQEN, ioaddr + PAR_CONTROL);
 440                 while (--length > 0)
 441                         write_byte_mode1(ioaddr, *packet++);
 442     }
 443     /* Terminate the Tx frame.  End of write: ECB. */
 444     outb(0xff, ioaddr + PAR_DATA);
 445     outb(Ctrl_HNibWrite | Ctrl_SelData | Ctrl_IRQEN, ioaddr + PAR_CONTROL);
 446 }
 447 
 448 static int
 449 net_send_packet(struct sk_buff *skb, struct device *dev)
     /* [previous][next][first][last][top][bottom][index][help] */
 450 {
 451         struct net_local *lp = (struct net_local *)dev->priv;
 452         int ioaddr = dev->base_addr;
 453 
 454         if (dev->tbusy) {
 455                 /* If we get here, some higher level has decided we are broken.
 456                    There should really be a "kick me" function call instead. */
 457                 int tickssofar = jiffies - dev->trans_start;
 458                 if (tickssofar < 5)
 459                         return 1;
 460                 printk("%s: transmit timed out, %s?\n", dev->name,
 461                            inb(ioaddr + PAR_CONTROL) & 0x10 ? "network cable problem"
 462                            :  "IRQ conflict");
 463                 lp->stats.tx_errors++;
 464                 /* Try to restart the adaptor. */
 465                 hardware_init(dev);
 466                 dev->tbusy=0;
 467                 dev->trans_start = jiffies;
 468         }
 469 
 470         /* If some higher layer thinks we've missed an tx-done interrupt
 471            we are passed NULL. Caution: dev_tint() handles the cli()/sti()
 472            itself. */
 473         if (skb == NULL) {
 474                 dev_tint(dev);
 475                 return 0;
 476         }
 477 
 478         /* For ethernet, fill in the header.  This should really be done by a
 479            higher level, rather than duplicated for each ethernet adaptor. */
 480         if (!skb->arp  &&  dev->rebuild_header(skb->data, dev)) {
 481                 skb->dev = dev;
 482                 arp_queue (skb);
 483                 return 0;
 484         }
 485         skb->arp=1;
 486 
 487         /* Block a timer-based transmit from overlapping.  This could better be
 488            done with atomic_swap(1, dev->tbusy), but set_bit() works as well. */
 489         if (set_bit(0, (void*)&dev->tbusy) != 0)
 490                 printk("%s: Transmitter access conflict.\n", dev->name);
 491         else {
 492                 short length = ETH_ZLEN < skb->len ? skb->len : ETH_ZLEN;
 493                 unsigned char *buf = skb->data;
 494                 int flags;
 495 
 496                 /* Disable interrupts by writing 0x00 to the Interrupt Mask Register.
 497                    This sequence must not be interrupted by an incoming packet. */
 498                 save_flags(flags);
 499                 cli();
 500                 write_reg(ioaddr, IMR, 0);
 501                 write_reg_high(ioaddr, IMR, 0);
 502                 restore_flags(flags);
 503 
 504                 write_packet(ioaddr, length, buf, dev->if_port);
 505 
 506                 lp->pac_cnt_in_tx_buf++;
 507                 if (lp->tx_unit_busy == 0) {
 508                         trigger_send(ioaddr, length);
 509                         lp->saved_tx_size = 0;                          /* Redundent */
 510                         lp->re_tx = 0;
 511                         lp->tx_unit_busy = 1;
 512                 } else
 513                         lp->saved_tx_size = length;
 514 
 515                 dev->trans_start = jiffies;
 516                 /* Re-enable the LPT interrupts. */
 517                 write_reg(ioaddr, IMR, ISR_RxOK | ISR_TxErr | ISR_TxOK);
 518                 write_reg_high(ioaddr, IMR, ISRh_RxErr);
 519         }
 520 
 521         if (skb->free)
 522                 kfree_skb (skb, FREE_WRITE);
 523 
 524         return 0;
 525 }
 526 
 527 /* The typical workload of the driver:
 528    Handle the network interface interrupts. */
 529 static void
 530 net_interrupt(int reg_ptr)
     /* [previous][next][first][last][top][bottom][index][help] */
 531 {
 532         int irq = -(((struct pt_regs *)reg_ptr)->orig_eax+2);
 533         struct device *dev = (struct device *)(irq2dev_map[irq]);
 534         struct net_local *lp;
 535         int ioaddr, status, boguscount = 20;
 536         static int num_tx_since_rx = 0;
 537 
 538         if (dev == NULL) {
 539                 printk ("ATP_interrupt(): irq %d for unknown device.\n", irq);
 540                 return;
 541         }
 542         dev->interrupt = 1;
 543 
 544         ioaddr = dev->base_addr;
 545         lp = (struct net_local *)dev->priv;
 546 
 547         /* Disable additional spurious interrupts. */
 548         outb(Ctrl_SelData, ioaddr + PAR_CONTROL);
 549 
 550         /* The adaptor's output is currently the IRQ line, switch it to data. */
 551         write_reg(ioaddr, CMR2, CMR2_NULL);
 552         write_reg(ioaddr, IMR, 0);
 553 
 554         if (net_debug > 5) printk("%s: In interrupt ", dev->name);
 555     while (--boguscount > 0) {
 556                 status = read_nibble(ioaddr, ISR);
 557                 if (net_debug > 5) printk("loop status %02x..", status);
 558 
 559                 if (status & (ISR_RxOK<<3)) {
 560                         write_reg(ioaddr, ISR, ISR_RxOK); /* Clear the Rx interrupt. */
 561                         do {
 562                                 int read_status = read_nibble(ioaddr, CMR1);
 563                                 if (net_debug > 6)
 564                                         printk("handling Rx packet %02x..", read_status);
 565                                 /* We acknowledged the normal Rx interrupt, so if the interrupt
 566                                    is still outstanding we must have a Rx error. */
 567                                 if (read_status & (CMR1_IRQ << 3)) { /* Overrun. */
 568                                         lp->stats.rx_over_errors++;
 569                                         /* Set to no-accept mode long enough to remove a packet. */
 570                                         write_reg_high(ioaddr, CMR2, CMR2h_OFF);
 571                                         net_rx(dev);
 572                                         /* Clear the interrupt and return to normal Rx mode. */
 573                                         write_reg_high(ioaddr, ISR, ISRh_RxErr);
 574                                         write_reg_high(ioaddr, CMR2, lp->addr_mode);
 575                                 } else if ((read_status & (CMR1_BufEnb << 3)) == 0) {
 576                                         net_rx(dev);
 577                                         dev->last_rx = jiffies;
 578                                         num_tx_since_rx = 0;
 579                                 } else
 580                                         break;
 581                         } while (--boguscount > 0);
 582                 } else if (status & ((ISR_TxErr + ISR_TxOK)<<3)) {
 583                         if (net_debug > 6)  printk("handling Tx done..");
 584                         /* Clear the Tx interrupt.  We should check for too many failures
 585                            and reinitialize the adaptor. */
 586                         write_reg(ioaddr, ISR, ISR_TxErr + ISR_TxOK);
 587                         if (status & (ISR_TxErr<<3)) {
 588                                 lp->stats.collisions++;
 589                                 if (++lp->re_tx > 15) {
 590                                         lp->stats.tx_aborted_errors++;
 591                                         hardware_init(dev);
 592                                         break;
 593                                 }
 594                                 /* Attempt to retransmit. */
 595                                 if (net_debug > 6)  printk("attempting to ReTx");
 596                                 write_reg(ioaddr, CMR1, CMR1_ReXmit + CMR1_Xmit);
 597                         } else {
 598                                 /* Finish up the transmit. */
 599                                 lp->stats.tx_packets++;
 600                                 lp->pac_cnt_in_tx_buf--;
 601                                 if ( lp->saved_tx_size) {
 602                                         trigger_send(ioaddr, lp->saved_tx_size);
 603                                         lp->saved_tx_size = 0;
 604                                         lp->re_tx = 0;
 605                                 } else
 606                                         lp->tx_unit_busy = 0;
 607                                 dev->tbusy = 0;
 608                                 mark_bh(INET_BH);       /* Inform upper layers. */
 609                         }
 610                         num_tx_since_rx++;
 611                 } else if (num_tx_since_rx > 8
 612                                    && jiffies > dev->last_rx + 100) {
 613                         if (net_debug > 2)
 614                                 printk("%s: Missed packet? No Rx after %d Tx and %ld jiffies"
 615                                            " status %02x  CMR1 %02x.\n", dev->name,
 616                                            num_tx_since_rx, jiffies - dev->last_rx, status,
 617                                            (read_nibble(ioaddr, CMR1) >> 3) & 15);
 618                         lp->stats.rx_missed_errors++;
 619                         hardware_init(dev);
 620                         num_tx_since_rx = 0;
 621                         break;
 622                 } else
 623                         break;
 624     }
 625 
 626         /* This following code fixes a rare (and very difficult to track down)
 627            problem where the adaptor forgets its ethernet address. */
 628         {
 629                 int i;
 630                 for (i = 0; i < 6; i++)
 631                         write_reg_byte(ioaddr, PAR0 + i, dev->dev_addr[i]);
 632         }
 633 
 634         /* Tell the adaptor that it can go back to using the output line as IRQ. */
 635     write_reg(ioaddr, CMR2, CMR2_IRQOUT);
 636         /* Enable the physical interrupt line, which is sure to be low until.. */
 637         outb(Ctrl_SelData + Ctrl_IRQEN, ioaddr + PAR_CONTROL);
 638         /* .. we enable the interrupt sources. */
 639         write_reg(ioaddr, IMR, ISR_RxOK | ISR_TxErr | ISR_TxOK);
 640         write_reg_high(ioaddr, IMR, ISRh_RxErr);                        /* Hmmm, really needed? */
 641 
 642         if (net_debug > 5) printk("exiting interrupt.\n");
 643 
 644         dev->interrupt = 0;
 645 
 646         return;
 647 }
 648 
 649 /* We have a good packet(s), get it/them out of the buffers. */
 650 static void net_rx(struct device *dev)
     /* [previous][next][first][last][top][bottom][index][help] */
 651 {
 652         struct net_local *lp = (struct net_local *)dev->priv;
 653         int ioaddr = dev->base_addr;
 654 #ifdef notdef
 655         ushort header[4];
 656 #else
 657         struct rx_header rx_head;
 658 #endif
 659 
 660         /* Process the received packet. */
 661         outb(EOC+MAR, ioaddr + PAR_DATA);
 662         read_block(ioaddr, 8, (unsigned char*)&rx_head, dev->if_port);
 663         if (net_debug > 5)
 664                 printk(" rx_count %04x %04x %04x %04x..", rx_head.pad,
 665                            rx_head.rx_count, rx_head.rx_status, rx_head.cur_addr);
 666         if ((rx_head.rx_status & 0x77) != 0x01) {
 667                 lp->stats.rx_errors++;
 668                 /* Ackkk!  I don't have any documentation on what the error bits mean!
 669                    The best I can do is slap the device around a bit. */
 670                 if (net_debug > 3) printk("%s: Unknown ATP Rx error %04x.\n",
 671                                                                   dev->name, rx_head.rx_status);
 672                 hardware_init(dev);
 673                 return;
 674         } else {
 675                 /* Malloc up new buffer. */
 676                 int pkt_len = (rx_head.rx_count & 0x7ff) - 4;           /* The "-4" is omits the FCS (CRC). */
 677                 int sksize = sizeof(struct sk_buff) + pkt_len;
 678                 struct sk_buff *skb;
 679                 
 680                 skb = alloc_skb(sksize, GFP_ATOMIC);
 681                 if (skb == NULL) {
 682                         printk("%s: Memory squeeze, dropping packet.\n", dev->name);
 683                         lp->stats.rx_dropped++;
 684                         goto done;
 685                 }
 686                 skb->mem_len = sksize;
 687                 skb->mem_addr = skb;
 688                 skb->len = pkt_len;
 689                 skb->dev = dev;
 690                 
 691                 read_block(ioaddr, pkt_len, skb->data, dev->if_port);
 692 
 693                 if (net_debug > 6) {
 694                         unsigned char *data = skb->data;
 695                         printk(" data %02x%02x%02x %02x%02x%02x %02x%02x%02x"
 696                                    "%02x%02x%02x %02x%02x..",
 697                                    data[0], data[1], data[2], data[3], data[4], data[5],
 698                                    data[6], data[7], data[8], data[9], data[10], data[11],
 699                                    data[12], data[13]);
 700                 }
 701                 
 702 #ifdef HAVE_NETIF_RX
 703                 netif_rx(skb);
 704 #else
 705                 skb->lock = 0;
 706                 if (dev_rint((unsigned char*)skb, pkt_len, IN_SKBUFF, dev) != 0) {
 707                         kfree_s(skb, sksize);
 708                         lp->stats.rx_dropped++;
 709                         break;
 710                 }
 711 #endif
 712                 lp->stats.rx_packets++;
 713         }
 714  done:
 715         write_reg(ioaddr, CMR1, CMR1_NextPkt);
 716         return;
 717 }
 718 
 719 static void read_block(short ioaddr, int length, unsigned char *p, int data_mode)
     /* [previous][next][first][last][top][bottom][index][help] */
 720 {
 721 
 722         if (data_mode <= 3) { /* Mode 0 or 1 */
 723                 outb(Ctrl_LNibRead, ioaddr + PAR_CONTROL);
 724                 outb(length == 8  ?  RdAddr | HNib | MAR  :  RdAddr | MAR,
 725                          ioaddr + PAR_DATA);
 726                 if (data_mode <= 1) { /* Mode 0 or 1 */
 727                         do  *p++ = read_byte_mode0(ioaddr);  while (--length > 0);
 728                 } else  /* Mode 2 or 3 */
 729                         do  *p++ = read_byte_mode2(ioaddr);  while (--length > 0);
 730         } else if (data_mode <= 5)
 731                 do      *p++ = read_byte_mode4(ioaddr);  while (--length > 0);
 732         else
 733                 do      *p++ = read_byte_mode6(ioaddr);  while (--length > 0);
 734 
 735     outb(EOC+HNib+MAR, ioaddr + PAR_DATA);
 736         outb(Ctrl_SelData, ioaddr + PAR_CONTROL);
 737 }
 738 
 739 /* The inverse routine to net_open(). */
 740 static int
 741 net_close(struct device *dev)
     /* [previous][next][first][last][top][bottom][index][help] */
 742 {
 743         struct net_local *lp = (struct net_local *)dev->priv;
 744         int ioaddr = dev->base_addr;
 745 
 746         dev->tbusy = 1;
 747         dev->start = 0;
 748 
 749         /* Flush the Tx and disable Rx here. */
 750         lp->addr_mode = CMR2h_OFF;
 751         write_reg_high(ioaddr, CMR2, CMR2h_OFF);
 752 
 753         /* Free the IRQ line. */
 754         outb(0x00, ioaddr + PAR_CONTROL);
 755         free_irq(dev->irq);
 756         irq2dev_map[dev->irq] = 0;
 757 
 758         /* Leave the hardware in a reset state. */
 759     write_reg_high(ioaddr, CMR1, CMR1h_RESET);
 760 
 761         return 0;
 762 }
 763 
 764 /* Get the current statistics.  This may be called with the card open or
 765    closed. */
 766 static struct enet_statistics *
 767 net_get_stats(struct device *dev)
     /* [previous][next][first][last][top][bottom][index][help] */
 768 {
 769         struct net_local *lp = (struct net_local *)dev->priv;
 770         return &lp->stats;
 771 }
 772 
 773 #ifdef HAVE_MULTICAST
 774 /* Set or clear the multicast filter for this adaptor.
 775    num_addrs == -1      Promiscuous mode, receive all packets
 776    num_addrs == 0       Normal mode, clear multicast list
 777    num_addrs > 0        Multicast mode, receive normal and MC packets, and do
 778                         best-effort filtering.
 779  */
 780 static void
 781 set_multicast_list(struct device *dev, int num_addrs, void *addrs)
     /* [previous][next][first][last][top][bottom][index][help] */
 782 {
 783         struct net_local *lp = (struct net_local *)dev->priv;
 784         short ioaddr = dev->base_addr;
 785         lp->addr_mode = num_addrs ? CMR2h_PROMISC : CMR2h_Normal;
 786         write_reg_high(ioaddr, CMR2, lp->addr_mode);
 787 }
 788 #endif
 789 
 790 /*
 791  * Local variables:
 792  *  compile-command: "gcc -D__KERNEL__ -I/usr/src/linux/net/inet -Wall -Wstrict-prototypes -O6 -m486 -c atp.c"
 793  *  version-control: t
 794  *  kept-new-versions: 5
 795  *  tab-width: 4
 796  * End:
 797  */

/* [previous][next][first][last][top][bottom][index][help] */