drivers/net/ethernet/amd/sun3lance.c

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