git.oblomov.eu Git - linux-2.6/blob - drivers/net/sun3lance.c

   1 /* sun3lance.c: Ethernet driver for SUN3 Lance chip */
   2 /*
   3
   4   Sun3 Lance ethernet driver, by Sam Creasey (sammy@users.qual.net).
   5   This driver is a part of the linux kernel, and is thus distributed
   6   under the GNU General Public License.
   7
   8   The values used in LANCE_OBIO and LANCE_IRQ seem to be empirically
   9   true for the correct IRQ and address of the lance registers.  They
  10   have not been widely tested, however.  What we probably need is a
  11   "proper" way to search for a device in the sun3's prom, but, alas,
  12   linux has no such thing.
  13
  14   This driver is largely based on atarilance.c, by Roman Hodek.  Other
  15   sources of inspiration were the NetBSD sun3 am7990 driver, and the
  16   linux sparc lance driver (sunlance.c).
  17
  18   There are more assumptions made throughout this driver, it almost
  19   certainly still needs work, but it does work at least for RARP/BOOTP and
  20   mounting the root NFS filesystem.
  21
  22 */
  23
  24 static char *version = "sun3lance.c: v1.2 1/12/2001  Sam Creasey (sammy@sammy.net)\n";
  25
  26 #include <linux/module.h>
  27 #include <linux/stddef.h>
  28 #include <linux/kernel.h>
  29 #include <linux/string.h>
  30 #include <linux/errno.h>
  31 #include <linux/slab.h>
  32 #include <linux/interrupt.h>
  33 #include <linux/init.h>
  34 #include <linux/ioport.h>
  35 #include <linux/delay.h>
  36 #include <linux/netdevice.h>
  37 #include <linux/etherdevice.h>
  38 #include <linux/skbuff.h>
  39 #include <linux/bitops.h>
  40
  41 #include <asm/setup.h>
  42 #include <asm/irq.h>
  43 #include <asm/io.h>
  44 #include <asm/pgtable.h>
  45 #include <asm/dvma.h>
  46 #include <asm/idprom.h>
  47 #include <asm/machines.h>
  48
  49 #ifdef CONFIG_SUN3
  50 #include <asm/sun3mmu.h>
  51 #else
  52 #include <asm/sun3xprom.h>
  53 #endif
  54
  55 /* sun3/60 addr/irq for the lance chip.  If your sun is different,
  56    change this. */
  57 #define LANCE_OBIO 0x120000
  58 #define LANCE_IRQ IRQ_AUTO_3
  59
  60 /* Debug level:
  61  *  0 = silent, print only serious errors
  62  *  1 = normal, print error messages
  63  *  2 = debug, print debug infos
  64  *  3 = debug, print even more debug infos (packet data)
  65  */
  66
  67 #define LANCE_DEBUG     0
  68
  69 #ifdef LANCE_DEBUG
  70 static int lance_debug = LANCE_DEBUG;
  71 #else
  72 static int lance_debug = 1;
  73 #endif
  74 module_param(lance_debug, int, 0);
  75 MODULE_PARM_DESC(lance_debug, "SUN3 Lance debug level (0-3)");
  76 MODULE_LICENSE("GPL");
  77
  78 #define DPRINTK(n,a) \
  79         do {  \
  80                 if (lance_debug >= n)  \
  81                         printk a; \
  82         } while( 0 )
  83
  84
  85 /* we're only using 32k of memory, so we use 4 TX
  86    buffers and 16 RX buffers.  These values are expressed as log2. */
  87
  88 #define TX_LOG_RING_SIZE                        3
  89 #define RX_LOG_RING_SIZE                        5
  90
  91 /* These are the derived values */
  92
  93 #define TX_RING_SIZE                    (1 << TX_LOG_RING_SIZE)
  94 #define TX_RING_LEN_BITS                (TX_LOG_RING_SIZE << 5)
  95 #define TX_RING_MOD_MASK                (TX_RING_SIZE - 1)
  96
  97 #define RX_RING_SIZE                    (1 << RX_LOG_RING_SIZE)
  98 #define RX_RING_LEN_BITS                (RX_LOG_RING_SIZE << 5)
  99 #define RX_RING_MOD_MASK                (RX_RING_SIZE - 1)
 100
 101 /* Definitions for packet buffer access: */
 102 #define PKT_BUF_SZ              1544
 103
 104 /* Get the address of a packet buffer corresponding to a given buffer head */
 105 #define PKTBUF_ADDR(head)       (void *)((unsigned long)(MEM) | (head)->base)
 106
 107
 108 /* The LANCE Rx and Tx ring descriptors. */
 109 struct lance_rx_head {
 110         unsigned short  base;           /* Low word of base addr */
 111         volatile unsigned char  flag;
 112         unsigned char  base_hi; /* High word of base addr (unused) */
 113         short buf_length;       /* This length is 2s complement! */
 114         volatile short msg_length;      /* This length is "normal". */
 115 };
 116
 117 struct lance_tx_head {
 118         unsigned short base;            /* Low word of base addr */
 119         volatile unsigned char  flag;
 120         unsigned char base_hi;  /* High word of base addr (unused) */
 121         short length;           /* Length is 2s complement! */
 122         volatile short misc;
 123 };
 124
 125 /* The LANCE initialization block, described in databook. */
 126 struct lance_init_block {
 127         unsigned short  mode;           /* Pre-set mode */
 128         unsigned char   hwaddr[6];      /* Physical ethernet address */
 129         unsigned int    filter[2];      /* Multicast filter (unused). */
 130         /* Receive and transmit ring base, along with length bits. */
 131         unsigned short rdra;
 132         unsigned short rlen;
 133         unsigned short tdra;
 134         unsigned short tlen;
 135         unsigned short pad[4]; /* is thie needed? */
 136 };
 137
 138 /* The whole layout of the Lance shared memory */
 139 struct lance_memory {
 140         struct lance_init_block init;
 141         struct lance_tx_head    tx_head[TX_RING_SIZE];
 142         struct lance_rx_head    rx_head[RX_RING_SIZE];
 143         char   rx_data[RX_RING_SIZE][PKT_BUF_SZ];
 144         char   tx_data[TX_RING_SIZE][PKT_BUF_SZ];
 145 };
 146
 147 /* The driver's private device structure */
 148
 149 struct lance_private {
 150         volatile unsigned short *iobase;
 151         struct lance_memory     *mem;
 152         int new_rx, new_tx;     /* The next free ring entry */
 153         int old_tx, old_rx;     /* ring entry to be processed */
 154         struct net_device_stats stats;
 155 /* These two must be longs for set_bit() */
 156         long        tx_full;
 157         long        lock;
 158 };
 159
 160 /* I/O register access macros */
 161
 162 #define MEM     lp->mem
 163 #define DREG    lp->iobase[0]
 164 #define AREG    lp->iobase[1]
 165 #define REGA(a) (*( AREG = (a), &DREG ))
 166
 167 /* Definitions for the Lance */
 168
 169 /* tx_head flags */
 170 #define TMD1_ENP                0x01    /* end of packet */
 171 #define TMD1_STP                0x02    /* start of packet */
 172 #define TMD1_DEF                0x04    /* deferred */
 173 #define TMD1_ONE                0x08    /* one retry needed */
 174 #define TMD1_MORE               0x10    /* more than one retry needed */
 175 #define TMD1_ERR                0x40    /* error summary */
 176 #define TMD1_OWN                0x80    /* ownership (set: chip owns) */
 177
 178 #define TMD1_OWN_CHIP   TMD1_OWN
 179 #define TMD1_OWN_HOST   0
 180
 181 /* tx_head misc field */
 182 #define TMD3_TDR                0x03FF  /* Time Domain Reflectometry counter */
 183 #define TMD3_RTRY               0x0400  /* failed after 16 retries */
 184 #define TMD3_LCAR               0x0800  /* carrier lost */
 185 #define TMD3_LCOL               0x1000  /* late collision */
 186 #define TMD3_UFLO               0x4000  /* underflow (late memory) */
 187 #define TMD3_BUFF               0x8000  /* buffering error (no ENP) */
 188
 189 /* rx_head flags */
 190 #define RMD1_ENP                0x01    /* end of packet */
 191 #define RMD1_STP                0x02    /* start of packet */
 192 #define RMD1_BUFF               0x04    /* buffer error */
 193 #define RMD1_CRC                0x08    /* CRC error */
 194 #define RMD1_OFLO               0x10    /* overflow */
 195 #define RMD1_FRAM               0x20    /* framing error */
 196 #define RMD1_ERR                0x40    /* error summary */
 197 #define RMD1_OWN                0x80    /* ownership (set: ship owns) */
 198
 199 #define RMD1_OWN_CHIP   RMD1_OWN
 200 #define RMD1_OWN_HOST   0
 201
 202 /* register names */
 203 #define CSR0    0               /* mode/status */
 204 #define CSR1    1               /* init block addr (low) */
 205 #define CSR2    2               /* init block addr (high) */
 206 #define CSR3    3               /* misc */
 207 #define CSR8    8               /* address filter */
 208 #define CSR15   15              /* promiscuous mode */
 209
 210 /* CSR0 */
 211 /* (R=readable, W=writeable, S=set on write, C=clear on write) */
 212 #define CSR0_INIT       0x0001          /* initialize (RS) */
 213 #define CSR0_STRT       0x0002          /* start (RS) */
 214 #define CSR0_STOP       0x0004          /* stop (RS) */
 215 #define CSR0_TDMD       0x0008          /* transmit demand (RS) */
 216 #define CSR0_TXON       0x0010          /* transmitter on (R) */
 217 #define CSR0_RXON       0x0020          /* receiver on (R) */
 218 #define CSR0_INEA       0x0040          /* interrupt enable (RW) */
 219 #define CSR0_INTR       0x0080          /* interrupt active (R) */
 220 #define CSR0_IDON       0x0100          /* initialization done (RC) */
 221 #define CSR0_TINT       0x0200          /* transmitter interrupt (RC) */
 222 #define CSR0_RINT       0x0400          /* receiver interrupt (RC) */
 223 #define CSR0_MERR       0x0800          /* memory error (RC) */
 224 #define CSR0_MISS       0x1000          /* missed frame (RC) */
 225 #define CSR0_CERR       0x2000          /* carrier error (no heartbeat :-) (RC) */
 226 #define CSR0_BABL       0x4000          /* babble: tx-ed too many bits (RC) */
 227 #define CSR0_ERR        0x8000          /* error (RC) */
 228
 229 /* CSR3 */
 230 #define CSR3_BCON       0x0001          /* byte control */
 231 #define CSR3_ACON       0x0002          /* ALE control */
 232 #define CSR3_BSWP       0x0004          /* byte swap (1=big endian) */
 233
 234 /***************************** Prototypes *****************************/
 235
 236 static int lance_probe( struct net_device *dev);
 237 static int lance_open( struct net_device *dev );
 238 static void lance_init_ring( struct net_device *dev );
 239 static int lance_start_xmit( struct sk_buff *skb, struct net_device *dev );
 240 static irqreturn_t lance_interrupt( int irq, void *dev_id, struct pt_regs *fp );
 241 static int lance_rx( struct net_device *dev );
 242 static int lance_close( struct net_device *dev );
 243 static struct net_device_stats *lance_get_stats( struct net_device *dev );
 244 static void set_multicast_list( struct net_device *dev );
 245
 246 /************************* End of Prototypes **************************/
 247
 248 struct net_device * __init sun3lance_probe(int unit)
 249 {
 250         struct net_device *dev;
 251         static int found;
 252         int err = -ENODEV;
 253
 254         /* check that this machine has an onboard lance */
 255         switch(idprom->id_machtype) {
 256         case SM_SUN3|SM_3_50:
 257         case SM_SUN3|SM_3_60:
 258         case SM_SUN3X|SM_3_80:
 259                 /* these machines have lance */
 260                 break;
 261
 262         default:
 263                 return ERR_PTR(-ENODEV);
 264         }
 265
 266         if (found)
 267                 return ERR_PTR(-ENODEV);
 268
 269         dev = alloc_etherdev(sizeof(struct lance_private));
 270         if (!dev)
 271                 return ERR_PTR(-ENOMEM);
 272         if (unit >= 0) {
 273                 sprintf(dev->name, "eth%d", unit);
 274                 netdev_boot_setup_check(dev);
 275         }
 276         SET_MODULE_OWNER(dev);
 277
 278         if (!lance_probe(dev))
 279                 goto out;
 280
 281         err = register_netdev(dev);
 282         if (err)
 283                 goto out1;
 284         found = 1;
 285         return dev;
 286
 287 out1:
 288 #ifdef CONFIG_SUN3
 289         iounmap((void *)dev->base_addr);
 290 #endif
 291 out:
 292         free_netdev(dev);
 293         return ERR_PTR(err);
 294 }
 295
 296 static int __init lance_probe( struct net_device *dev)
 297 {
 298         unsigned long ioaddr;
 299
 300         struct lance_private    *lp;
 301         int                     i;
 302         static int              did_version;
 303         volatile unsigned short *ioaddr_probe;
 304         unsigned short tmp1, tmp2;
 305
 306 #ifdef CONFIG_SUN3
 307         ioaddr = (unsigned long)ioremap(LANCE_OBIO, PAGE_SIZE);
 308         if (!ioaddr)
 309                 return 0;
 310 #else
 311         ioaddr = SUN3X_LANCE;
 312 #endif
 313
 314         /* test to see if there's really a lance here */
 315         /* (CSRO_INIT shouldn't be readable) */
 316
 317         ioaddr_probe = (volatile unsigned short *)ioaddr;
 318         tmp1 = ioaddr_probe[0];
 319         tmp2 = ioaddr_probe[1];
 320
 321         ioaddr_probe[1] = CSR0;
 322         ioaddr_probe[0] = CSR0_INIT | CSR0_STOP;
 323
 324         if(ioaddr_probe[0] != CSR0_STOP) {
 325                 ioaddr_probe[0] = tmp1;
 326                 ioaddr_probe[1] = tmp2;
 327
 328 #ifdef CONFIG_SUN3
 329                 iounmap((void *)ioaddr);
 330 #endif
 331                 return 0;
 332         }
 333
 334         lp = netdev_priv(dev);
 335
 336         /* XXX - leak? */
 337         MEM = dvma_malloc_align(sizeof(struct lance_memory), 0x10000);
 338
 339         lp->iobase = (volatile unsigned short *)ioaddr;
 340         dev->base_addr = (unsigned long)ioaddr; /* informational only */
 341
 342         REGA(CSR0) = CSR0_STOP;
 343
 344         request_irq(LANCE_IRQ, lance_interrupt, SA_INTERRUPT, "SUN3 Lance", dev);
 345         dev->irq = (unsigned short)LANCE_IRQ;
 346
 347
 348         printk("%s: SUN3 Lance at io %#lx, mem %#lx, irq %d, hwaddr ",
 349                    dev->name,
 350                    (unsigned long)ioaddr,
 351                    (unsigned long)MEM,
 352                    dev->irq);
 353
 354         /* copy in the ethernet address from the prom */
 355         for(i = 0; i < 6 ; i++)
 356              dev->dev_addr[i] = idprom->id_ethaddr[i];
 357
 358         /* tell the card it's ether address, bytes swapped */
 359         MEM->init.hwaddr[0] = dev->dev_addr[1];
 360         MEM->init.hwaddr[1] = dev->dev_addr[0];
 361         MEM->init.hwaddr[2] = dev->dev_addr[3];
 362         MEM->init.hwaddr[3] = dev->dev_addr[2];
 363         MEM->init.hwaddr[4] = dev->dev_addr[5];
 364         MEM->init.hwaddr[5] = dev->dev_addr[4];
 365
 366         for( i = 0; i < 6; ++i )
 367                 printk( "%02x%s", dev->dev_addr[i], (i < 5) ? ":" : "\n" );
 368
 369         MEM->init.mode = 0x0000;
 370         MEM->init.filter[0] = 0x00000000;
 371         MEM->init.filter[1] = 0x00000000;
 372         MEM->init.rdra = dvma_vtob(MEM->rx_head);
 373         MEM->init.rlen    = (RX_LOG_RING_SIZE << 13) |
 374                 (dvma_vtob(MEM->rx_head) >> 16);
 375         MEM->init.tdra = dvma_vtob(MEM->tx_head);
 376         MEM->init.tlen    = (TX_LOG_RING_SIZE << 13) |
 377                 (dvma_vtob(MEM->tx_head) >> 16);
 378
 379         DPRINTK(2, ("initaddr: %08lx rx_ring: %08lx tx_ring: %08lx\n",
 380                dvma_vtob(&(MEM->init)), dvma_vtob(MEM->rx_head),
 381                (dvma_vtob(MEM->tx_head))));
 382
 383         if (did_version++ == 0)
 384                 printk( version );
 385
 386         /* The LANCE-specific entries in the device structure. */
 387         dev->open = &lance_open;
 388         dev->hard_start_xmit = &lance_start_xmit;
 389         dev->stop = &lance_close;
 390         dev->get_stats = &lance_get_stats;
 391         dev->set_multicast_list = &set_multicast_list;
 392         dev->set_mac_address = NULL;
 393 //      KLUDGE -- REMOVE ME
 394         set_bit(__LINK_STATE_PRESENT, &dev->state);
 395
 396
 397         memset( &lp->stats, 0, sizeof(lp->stats) );
 398
 399         return 1;
 400 }
 401
 402 static int lance_open( struct net_device *dev )
 403 {
 404         struct lance_private *lp = netdev_priv(dev);
 405         int i;
 406
 407         DPRINTK( 2, ( "%s: lance_open()\n", dev->name ));
 408
 409         REGA(CSR0) = CSR0_STOP;
 410
 411         lance_init_ring(dev);
 412
 413         /* From now on, AREG is kept to point to CSR0 */
 414         REGA(CSR0) = CSR0_INIT;
 415
 416         i = 1000000;
 417         while (--i > 0)
 418                 if (DREG & CSR0_IDON)
 419                         break;
 420         if (i < 0 || (DREG & CSR0_ERR)) {
 421                 DPRINTK( 2, ( "lance_open(): opening %s failed, i=%d, csr0=%04x\n",
 422                                           dev->name, i, DREG ));
 423                 DREG = CSR0_STOP;
 424                 return( -EIO );
 425         }
 426
 427         DREG = CSR0_IDON | CSR0_STRT | CSR0_INEA;
 428
 429         netif_start_queue(dev);
 430
 431         DPRINTK( 2, ( "%s: LANCE is open, csr0 %04x\n", dev->name, DREG ));
 432
 433         return( 0 );
 434 }
 435
 436
 437 /* Initialize the LANCE Rx and Tx rings. */
 438
 439 static void lance_init_ring( struct net_device *dev )
 440 {
 441         struct lance_private *lp = netdev_priv(dev);
 442         int i;
 443
 444         lp->lock = 0;
 445         lp->tx_full = 0;
 446         lp->new_rx = lp->new_tx = 0;
 447         lp->old_rx = lp->old_tx = 0;
 448
 449         for( i = 0; i < TX_RING_SIZE; i++ ) {
 450                 MEM->tx_head[i].base = dvma_vtob(MEM->tx_data[i]);
 451                 MEM->tx_head[i].flag = 0;
 452                 MEM->tx_head[i].base_hi =
 453                         (dvma_vtob(MEM->tx_data[i])) >>16;
 454                 MEM->tx_head[i].length = 0;
 455                 MEM->tx_head[i].misc = 0;
 456         }
 457
 458         for( i = 0; i < RX_RING_SIZE; i++ ) {
 459                 MEM->rx_head[i].base = dvma_vtob(MEM->rx_data[i]);
 460                 MEM->rx_head[i].flag = RMD1_OWN_CHIP;
 461                 MEM->rx_head[i].base_hi =
 462                         (dvma_vtob(MEM->rx_data[i])) >> 16;
 463                 MEM->rx_head[i].buf_length = -PKT_BUF_SZ | 0xf000;
 464                 MEM->rx_head[i].msg_length = 0;
 465         }
 466
 467         /* tell the card it's ether address, bytes swapped */
 468         MEM->init.hwaddr[0] = dev->dev_addr[1];
 469         MEM->init.hwaddr[1] = dev->dev_addr[0];
 470         MEM->init.hwaddr[2] = dev->dev_addr[3];
 471         MEM->init.hwaddr[3] = dev->dev_addr[2];
 472         MEM->init.hwaddr[4] = dev->dev_addr[5];
 473         MEM->init.hwaddr[5] = dev->dev_addr[4];
 474
 475         MEM->init.mode = 0x0000;
 476         MEM->init.filter[0] = 0x00000000;
 477         MEM->init.filter[1] = 0x00000000;
 478         MEM->init.rdra = dvma_vtob(MEM->rx_head);
 479         MEM->init.rlen    = (RX_LOG_RING_SIZE << 13) |
 480                 (dvma_vtob(MEM->rx_head) >> 16);
 481         MEM->init.tdra = dvma_vtob(MEM->tx_head);
 482         MEM->init.tlen    = (TX_LOG_RING_SIZE << 13) |
 483                 (dvma_vtob(MEM->tx_head) >> 16);
 484
 485
 486         /* tell the lance the address of its init block */
 487         REGA(CSR1) = dvma_vtob(&(MEM->init));
 488         REGA(CSR2) = dvma_vtob(&(MEM->init)) >> 16;
 489
 490 #ifdef CONFIG_SUN3X
 491         REGA(CSR3) = CSR3_BSWP | CSR3_ACON | CSR3_BCON;
 492 #else
 493         REGA(CSR3) = CSR3_BSWP;
 494 #endif
 495
 496 }
 497
 498
 499 static int lance_start_xmit( struct sk_buff *skb, struct net_device *dev )
 500 {
 501         struct lance_private *lp = netdev_priv(dev);
 502         int entry, len;
 503         struct lance_tx_head *head;
 504         unsigned long flags;
 505
 506         DPRINTK( 1, ( "%s: transmit start.\n",
 507                       dev->name));
 508
 509         /* Transmitter timeout, serious problems. */
 510         if (netif_queue_stopped(dev)) {
 511                 int tickssofar = jiffies - dev->trans_start;
 512                 if (tickssofar < 20)
 513                         return( 1 );
 514
 515                 DPRINTK( 1, ( "%s: transmit timed out, status %04x, resetting.\n",
 516                                           dev->name, DREG ));
 517                 DREG = CSR0_STOP;
 518                 /*
 519                  * Always set BSWP after a STOP as STOP puts it back into
 520                  * little endian mode.
 521                  */
 522                 REGA(CSR3) = CSR3_BSWP;
 523                 lp->stats.tx_errors++;
 524
 525                 if(lance_debug >= 2) {
 526                         int i;
 527                         printk("Ring data: old_tx %d new_tx %d%s new_rx %d\n",
 528                                lp->old_tx, lp->new_tx,
 529                                lp->tx_full ? " (full)" : "",
 530                                lp->new_rx );
 531                         for( i = 0 ; i < RX_RING_SIZE; i++ )
 532                                 printk( "rx #%d: base=%04x blen=%04x mlen=%04x\n",
 533                                         i, MEM->rx_head[i].base,
 534                                         -MEM->rx_head[i].buf_length,
 535                                         MEM->rx_head[i].msg_length);
 536                         for( i = 0 ; i < TX_RING_SIZE; i++ )
 537                                 printk("tx #%d: base=%04x len=%04x misc=%04x\n",
 538                                        i, MEM->tx_head[i].base,
 539                                        -MEM->tx_head[i].length,
 540                                        MEM->tx_head[i].misc );
 541                 }
 542
 543                 lance_init_ring(dev);
 544                 REGA( CSR0 ) = CSR0_INEA | CSR0_INIT | CSR0_STRT;
 545
 546                 netif_start_queue(dev);
 547                 dev->trans_start = jiffies;
 548
 549                 return 0;
 550         }
 551
 552
 553         /* Block a timer-based transmit from overlapping.  This could better be
 554            done with atomic_swap(1, dev->tbusy), but set_bit() works as well. */
 555
 556         /* Block a timer-based transmit from overlapping with us by
 557            stopping the queue for a bit... */
 558
 559         netif_stop_queue(dev);
 560
 561         if (test_and_set_bit( 0, (void*)&lp->lock ) != 0) {
 562                 printk( "%s: tx queue lock!.\n", dev->name);
 563                 /* don't clear dev->tbusy flag. */
 564                 return 1;
 565         }
 566
 567         AREG = CSR0;
 568         DPRINTK( 2, ( "%s: lance_start_xmit() called, csr0 %4.4x.\n",
 569                                   dev->name, DREG ));
 570
 571 #ifdef CONFIG_SUN3X
 572         /* this weirdness doesn't appear on sun3... */
 573         if(!(DREG & CSR0_INIT)) {
 574                 DPRINTK( 1, ("INIT not set, reinitializing...\n"));
 575                 REGA( CSR0 ) = CSR0_STOP;
 576                 lance_init_ring(dev);
 577                 REGA( CSR0 ) = CSR0_INIT | CSR0_STRT;
 578         }
 579 #endif
 580
 581         /* Fill in a Tx ring entry */
 582 #if 0
 583         if (lance_debug >= 2) {
 584                 u_char *p;
 585                 int i;
 586                 printk( "%s: TX pkt %d type 0x%04x from ", dev->name,
 587                         lp->new_tx, ((u_short *)skb->data)[6]);
 588                 for( p = &((u_char *)skb->data)[6], i = 0; i < 6; i++ )
 589                         printk("%02x%s", *p++, i != 5 ? ":" : "" );
 590                 printk(" to ");
 591                 for( p = (u_char *)skb->data, i = 0; i < 6; i++ )
 592                         printk("%02x%s", *p++, i != 5 ? ":" : "" );
 593                 printk(" data at 0x%08x len %d\n", (int)skb->data,
 594                        (int)skb->len );
 595         }
 596 #endif
 597         /* We're not prepared for the int until the last flags are set/reset.
 598          * And the int may happen already after setting the OWN_CHIP... */
 599         local_irq_save(flags);
 600
 601         /* Mask to ring buffer boundary. */
 602         entry = lp->new_tx;
 603         head  = &(MEM->tx_head[entry]);
 604
 605         /* Caution: the write order is important here, set the "ownership" bits
 606          * last.
 607          */
 608
 609         /* the sun3's lance needs it's buffer padded to the minimum
 610            size */
 611         len = (ETH_ZLEN < skb->len) ? skb->len : ETH_ZLEN;
 612
 613 //      head->length = -len;
 614         head->length = (-len) | 0xf000;
 615         head->misc = 0;
 616
 617         memcpy( PKTBUF_ADDR(head), (void *)skb->data, skb->len );
 618         if (len != skb->len)
 619                 memset(PKTBUF_ADDR(head) + skb->len, 0, len-skb->len);
 620
 621         head->flag = TMD1_OWN_CHIP | TMD1_ENP | TMD1_STP;
 622         lp->new_tx = (lp->new_tx + 1) & TX_RING_MOD_MASK;
 623         lp->stats.tx_bytes += skb->len;
 624
 625         /* Trigger an immediate send poll. */
 626         REGA(CSR0) = CSR0_INEA | CSR0_TDMD | CSR0_STRT;
 627         AREG = CSR0;
 628         DPRINTK( 2, ( "%s: lance_start_xmit() exiting, csr0 %4.4x.\n",
 629                                   dev->name, DREG ));
 630         dev->trans_start = jiffies;
 631         dev_kfree_skb( skb );
 632
 633         lp->lock = 0;
 634         if ((MEM->tx_head[(entry+1) & TX_RING_MOD_MASK].flag & TMD1_OWN) ==
 635             TMD1_OWN_HOST)
 636                 netif_start_queue(dev);
 637
 638         local_irq_restore(flags);
 639
 640         return 0;
 641 }
 642
 643 /* The LANCE interrupt handler. */
 644
 645 static irqreturn_t lance_interrupt( int irq, void *dev_id, struct pt_regs *fp)
 646 {
 647         struct net_device *dev = dev_id;
 648         struct lance_private *lp = netdev_priv(dev);
 649         int csr0;
 650         static int in_interrupt;
 651
 652         if (dev == NULL) {
 653                 DPRINTK( 1, ( "lance_interrupt(): invalid dev_id\n" ));
 654                 return IRQ_NONE;
 655         }
 656
 657         if (in_interrupt)
 658                 DPRINTK( 2, ( "%s: Re-entering the interrupt handler.\n", dev->name ));
 659         in_interrupt = 1;
 660
 661  still_more:
 662         flush_cache_all();
 663
 664         AREG = CSR0;
 665         csr0 = DREG;
 666
 667         /* ack interrupts */
 668         DREG = csr0 & (CSR0_TINT | CSR0_RINT | CSR0_IDON);
 669
 670         /* clear errors */
 671         if(csr0 & CSR0_ERR)
 672                 DREG = CSR0_BABL | CSR0_MERR | CSR0_CERR | CSR0_MISS;
 673
 674
 675         DPRINTK( 2, ( "%s: interrupt  csr0=%04x new csr=%04x.\n",
 676                       dev->name, csr0, DREG ));
 677
 678         if (csr0 & CSR0_TINT) {                 /* Tx-done interrupt */
 679                 int old_tx = lp->old_tx;
 680
 681 //              if(lance_debug >= 3) {
 682 //                      int i;
 683 //
 684 //                      printk("%s: tx int\n", dev->name);
 685 //
 686 //                      for(i = 0; i < TX_RING_SIZE; i++)
 687 //                              printk("ring %d flag=%04x\n", i,
 688 //                                     MEM->tx_head[i].flag);
 689 //              }
 690
 691                 while( old_tx != lp->new_tx) {
 692                         struct lance_tx_head *head = &(MEM->tx_head[old_tx]);
 693
 694                         DPRINTK(3, ("on tx_ring %d\n", old_tx));
 695
 696                         if (head->flag & TMD1_OWN_CHIP)
 697                                 break; /* It still hasn't been Txed */
 698
 699                         if (head->flag & TMD1_ERR) {
 700                                 int status = head->misc;
 701                                 lp->stats.tx_errors++;
 702                                 if (status & TMD3_RTRY) lp->stats.tx_aborted_errors++;
 703                                 if (status & TMD3_LCAR) lp->stats.tx_carrier_errors++;
 704                                 if (status & TMD3_LCOL) lp->stats.tx_window_errors++;
 705                                 if (status & (TMD3_UFLO | TMD3_BUFF)) {
 706                                         lp->stats.tx_fifo_errors++;
 707                                         printk("%s: Tx FIFO error\n",
 708                                                dev->name);
 709                                         REGA(CSR0) = CSR0_STOP;
 710                                         REGA(CSR3) = CSR3_BSWP;
 711                                         lance_init_ring(dev);
 712                                         REGA(CSR0) = CSR0_STRT | CSR0_INEA;
 713                                         return IRQ_HANDLED;
 714                                 }
 715                         } else if(head->flag & (TMD1_ENP | TMD1_STP)) {
 716
 717                                 head->flag &= ~(TMD1_ENP | TMD1_STP);
 718                                 if(head->flag & (TMD1_ONE | TMD1_MORE))
 719                                         lp->stats.collisions++;
 720
 721                                 lp->stats.tx_packets++;
 722                                 DPRINTK(3, ("cleared tx ring %d\n", old_tx));
 723                         }
 724                         old_tx = (old_tx +1) & TX_RING_MOD_MASK;
 725                 }
 726
 727                 lp->old_tx = old_tx;
 728         }
 729
 730
 731         if (netif_queue_stopped(dev)) {
 732                 /* The ring is no longer full, clear tbusy. */
 733                 netif_start_queue(dev);
 734                 netif_wake_queue(dev);
 735         }
 736
 737         if (csr0 & CSR0_RINT)                   /* Rx interrupt */
 738                 lance_rx( dev );
 739
 740         /* Log misc errors. */
 741         if (csr0 & CSR0_BABL) lp->stats.tx_errors++; /* Tx babble. */
 742         if (csr0 & CSR0_MISS) lp->stats.rx_errors++; /* Missed a Rx frame. */
 743         if (csr0 & CSR0_MERR) {
 744                 DPRINTK( 1, ( "%s: Bus master arbitration failure (?!?), "
 745                               "status %04x.\n", dev->name, csr0 ));
 746                 /* Restart the chip. */
 747                 REGA(CSR0) = CSR0_STOP;
 748                 REGA(CSR3) = CSR3_BSWP;
 749                 lance_init_ring(dev);
 750                 REGA(CSR0) = CSR0_STRT | CSR0_INEA;
 751         }
 752
 753
 754     /* Clear any other interrupt, and set interrupt enable. */
 755 //      DREG = CSR0_BABL | CSR0_CERR | CSR0_MISS | CSR0_MERR |
 756 //                 CSR0_IDON | CSR0_INEA;
 757
 758         REGA(CSR0) = CSR0_INEA;
 759
 760         if(DREG & (CSR0_RINT | CSR0_TINT)) {
 761              DPRINTK(2, ("restarting interrupt, csr0=%#04x\n", DREG));
 762              goto still_more;
 763         }
 764
 765         DPRINTK( 2, ( "%s: exiting interrupt, csr0=%#04x.\n",
 766                                   dev->name, DREG ));
 767         in_interrupt = 0;
 768         return IRQ_HANDLED;
 769 }
 770
 771 /* get packet, toss into skbuff */
 772 static int lance_rx( struct net_device *dev )
 773 {
 774         struct lance_private *lp = netdev_priv(dev);
 775         int entry = lp->new_rx;
 776
 777         /* If we own the next entry, it's a new packet. Send it up. */
 778         while( (MEM->rx_head[entry].flag & RMD1_OWN) == RMD1_OWN_HOST ) {
 779                 struct lance_rx_head *head = &(MEM->rx_head[entry]);
 780                 int status = head->flag;
 781
 782                 if (status != (RMD1_ENP|RMD1_STP)) {  /* There was an error. */
 783                         /* There is a tricky error noted by John Murphy,
 784                            <murf@perftech.com> to Russ Nelson: Even with
 785                            full-sized buffers it's possible for a jabber packet to use two
 786                            buffers, with only the last correctly noting the error. */
 787                         if (status & RMD1_ENP)  /* Only count a general error at the */
 788                                 lp->stats.rx_errors++; /* end of a packet.*/
 789                         if (status & RMD1_FRAM) lp->stats.rx_frame_errors++;
 790                         if (status & RMD1_OFLO) lp->stats.rx_over_errors++;
 791                         if (status & RMD1_CRC) lp->stats.rx_crc_errors++;
 792                         if (status & RMD1_BUFF) lp->stats.rx_fifo_errors++;
 793                         head->flag &= (RMD1_ENP|RMD1_STP);
 794                 } else {
 795                         /* Malloc up new buffer, compatible with net-3. */
 796 //                      short pkt_len = head->msg_length;// & 0xfff;
 797                         short pkt_len = (head->msg_length & 0xfff) - 4;
 798                         struct sk_buff *skb;
 799
 800                         if (pkt_len < 60) {
 801                                 printk( "%s: Runt packet!\n", dev->name );
 802                                 lp->stats.rx_errors++;
 803                         }
 804                         else {
 805                                 skb = dev_alloc_skb( pkt_len+2 );
 806                                 if (skb == NULL) {
 807                                         DPRINTK( 1, ( "%s: Memory squeeze, deferring packet.\n",
 808                                                       dev->name ));
 809
 810                                         lp->stats.rx_dropped++;
 811                                         head->msg_length = 0;
 812                                         head->flag |= RMD1_OWN_CHIP;
 813                                         lp->new_rx = (lp->new_rx+1) &
 814                                              RX_RING_MOD_MASK;
 815                                 }
 816
 817 #if 0
 818                                 if (lance_debug >= 3) {
 819                                         u_char *data = PKTBUF_ADDR(head), *p;
 820                                         printk( "%s: RX pkt %d type 0x%04x from ", dev->name, entry, ((u_short *)data)[6]);
 821                                         for( p = &data[6], i = 0; i < 6; i++ )
 822                                                 printk("%02x%s", *p++, i != 5 ? ":" : "" );
 823                                         printk(" to ");
 824                                         for( p = data, i = 0; i < 6; i++ )
 825                                                 printk("%02x%s", *p++, i != 5 ? ":" : "" );
 826                                         printk(" data %02x %02x %02x %02x %02x %02x %02x %02x "
 827                                                "len %d at %08x\n",
 828                                                data[15], data[16], data[17], data[18],
 829                                                data[19], data[20], data[21], data[22],
 830                                                pkt_len, data);
 831                                 }
 832 #endif
 833                                 if (lance_debug >= 3) {
 834                                         u_char *data = PKTBUF_ADDR(head);
 835                                         printk( "%s: RX pkt %d type 0x%04x len %d\n ", dev->name, entry, ((u_short *)data)[6], pkt_len);
 836                                 }
 837
 838
 839                                 skb->dev = dev;
 840                                 skb_reserve( skb, 2 );  /* 16 byte align */
 841                                 skb_put( skb, pkt_len );        /* Make room */
 842 //                              memcpy( skb->data, PKTBUF_ADDR(head), pkt_len );
 843                                 eth_copy_and_sum(skb,
 844                                                  PKTBUF_ADDR(head),
 845                                                  pkt_len, 0);
 846
 847                                 skb->protocol = eth_type_trans( skb, dev );
 848                                 netif_rx( skb );
 849                                 dev->last_rx = jiffies;
 850                                 lp->stats.rx_packets++;
 851                                 lp->stats.rx_bytes += pkt_len;
 852                         }
 853                 }
 854
 855 //              head->buf_length = -PKT_BUF_SZ | 0xf000;
 856                 head->msg_length = 0;
 857                 head->flag = RMD1_OWN_CHIP;
 858
 859                 entry = lp->new_rx = (lp->new_rx +1) & RX_RING_MOD_MASK;
 860         }
 861
 862         /* From lance.c (Donald Becker): */
 863         /* We should check that at least two ring entries are free.
 864            If not, we should free one and mark stats->rx_dropped++. */
 865
 866         return 0;
 867 }
 868
 869
 870 static int lance_close( struct net_device *dev )
 871 {
 872         struct lance_private *lp = netdev_priv(dev);
 873
 874         netif_stop_queue(dev);
 875
 876         AREG = CSR0;
 877
 878         DPRINTK( 2, ( "%s: Shutting down ethercard, status was %2.2x.\n",
 879                                   dev->name, DREG ));
 880
 881         /* We stop the LANCE here -- it occasionally polls
 882            memory if we don't. */
 883         DREG = CSR0_STOP;
 884         return 0;
 885 }
 886
 887
 888 static struct net_device_stats *lance_get_stats( struct net_device *dev )
 889 {
 890         struct lance_private *lp = netdev_priv(dev);
 891
 892         return &lp->stats;
 893 }
 894
 895
 896 /* Set or clear the multicast filter for this adaptor.
 897    num_addrs == -1              Promiscuous mode, receive all packets
 898    num_addrs == 0               Normal mode, clear multicast list
 899    num_addrs > 0                Multicast mode, receive normal and MC packets, and do
 900                                                 best-effort filtering.
 901  */
 902
 903 /* completely untested on a sun3 */
 904 static void set_multicast_list( struct net_device *dev )
 905 {
 906         struct lance_private *lp = netdev_priv(dev);
 907
 908         if(netif_queue_stopped(dev))
 909                 /* Only possible if board is already started */
 910                 return;
 911
 912         /* We take the simple way out and always enable promiscuous mode. */
 913         DREG = CSR0_STOP; /* Temporarily stop the lance. */
 914
 915         if (dev->flags & IFF_PROMISC) {
 916                 /* Log any net taps. */
 917                 DPRINTK( 1, ( "%s: Promiscuous mode enabled.\n", dev->name ));
 918                 REGA( CSR15 ) = 0x8000; /* Set promiscuous mode */
 919         } else {
 920                 short multicast_table[4];
 921                 int num_addrs = dev->mc_count;
 922                 int i;
 923                 /* We don't use the multicast table, but rely on upper-layer
 924                  * filtering. */
 925                 memset( multicast_table, (num_addrs == 0) ? 0 : -1,
 926                                 sizeof(multicast_table) );
 927                 for( i = 0; i < 4; i++ )
 928                         REGA( CSR8+i ) = multicast_table[i];
 929                 REGA( CSR15 ) = 0; /* Unset promiscuous mode */
 930         }
 931
 932         /*
 933          * Always set BSWP after a STOP as STOP puts it back into
 934          * little endian mode.
 935          */
 936         REGA( CSR3 ) = CSR3_BSWP;
 937
 938         /* Resume normal operation and reset AREG to CSR0 */
 939         REGA( CSR0 ) = CSR0_IDON | CSR0_INEA | CSR0_STRT;
 940 }
 941
 942
 943 #ifdef MODULE
 944
 945 static struct net_device *sun3lance_dev;
 946
 947 int init_module(void)
 948 {
 949         sun3lance_dev = sun3lance_probe(-1);
 950         if (IS_ERR(sun3lance_dev))
 951                 return PTR_ERR(sun3lance_dev);
 952         return 0;
 953 }
 954
 955 void cleanup_module(void)
 956 {
 957         unregister_netdev(sun3lance_dev);
 958 #ifdef CONFIG_SUN3
 959         iounmap((void *)sun3lance_dev->base_addr);
 960 #endif
 961         free_netdev(sun3lance_dev);
 962 }
 963
 964 #endif /* MODULE */
 965