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. get_node_ID
  4. eeprom_op
  5. net_open
  6. hardware_init
  7. trigger_send
  8. write_packet
  9. net_send_packet
  10. net_interrupt
  11. atp_timed_checker
  12. net_rx
  13. read_block
  14. net_close
  15. net_get_stats
  16. set_multicast_list

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

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