Pileus Git - ~andy/linux/blob - drivers/net/ethernet/amd/ariadne.c

   1 /*
   2  *  Amiga Linux/m68k Ariadne Ethernet Driver
   3  *
   4  *  © Copyright 1995-2003 by Geert Uytterhoeven (geert@linux-m68k.org)
   5  *                           Peter De Schrijver (p2@mind.be)
   6  *
   7  *  ---------------------------------------------------------------------------
   8  *
   9  *  This program is based on
  10  *
  11  *      lance.c:        An AMD LANCE ethernet driver for linux.
  12  *                      Written 1993-94 by Donald Becker.
  13  *
  14  *      Am79C960:       PCnet(tm)-ISA Single-Chip Ethernet Controller
  15  *                      Advanced Micro Devices
  16  *                      Publication #16907, Rev. B, Amendment/0, May 1994
  17  *
  18  *      MC68230:        Parallel Interface/Timer (PI/T)
  19  *                      Motorola Semiconductors, December, 1983
  20  *
  21  *  ---------------------------------------------------------------------------
  22  *
  23  *  This file is subject to the terms and conditions of the GNU General Public
  24  *  License.  See the file COPYING in the main directory of the Linux
  25  *  distribution for more details.
  26  *
  27  *  ---------------------------------------------------------------------------
  28  *
  29  *  The Ariadne is a Zorro-II board made by Village Tronic. It contains:
  30  *
  31  *      - an Am79C960 PCnet-ISA Single-Chip Ethernet Controller with both
  32  *        10BASE-2 (thin coax) and 10BASE-T (UTP) connectors
  33  *
  34  *      - an MC68230 Parallel Interface/Timer configured as 2 parallel ports
  35  */
  36
  37 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
  38 /*#define DEBUG*/
  39
  40 #include <linux/module.h>
  41 #include <linux/stddef.h>
  42 #include <linux/kernel.h>
  43 #include <linux/string.h>
  44 #include <linux/errno.h>
  45 #include <linux/ioport.h>
  46 #include <linux/netdevice.h>
  47 #include <linux/etherdevice.h>
  48 #include <linux/interrupt.h>
  49 #include <linux/skbuff.h>
  50 #include <linux/init.h>
  51 #include <linux/zorro.h>
  52 #include <linux/bitops.h>
  53
  54 #include <asm/amigaints.h>
  55 #include <asm/amigahw.h>
  56 #include <asm/irq.h>
  57
  58 #include "ariadne.h"
  59
  60 #ifdef ARIADNE_DEBUG
  61 int ariadne_debug = ARIADNE_DEBUG;
  62 #else
  63 int ariadne_debug = 1;
  64 #endif
  65
  66 /* Macros to Fix Endianness problems */
  67
  68 /* Swap the Bytes in a WORD */
  69 #define swapw(x)        (((x >> 8) & 0x00ff) | ((x << 8) & 0xff00))
  70 /* Get the Low BYTE in a WORD */
  71 #define lowb(x)         (x & 0xff)
  72 /* Get the Swapped High WORD in a LONG */
  73 #define swhighw(x)      ((((x) >> 8) & 0xff00) | (((x) >> 24) & 0x00ff))
  74 /* Get the Swapped Low WORD in a LONG */
  75 #define swloww(x)       ((((x) << 8) & 0xff00) | (((x) >> 8) & 0x00ff))
  76
  77 /* Transmit/Receive Ring Definitions */
  78
  79 #define TX_RING_SIZE    5
  80 #define RX_RING_SIZE    16
  81
  82 #define PKT_BUF_SIZE    1520
  83
  84 /* Private Device Data */
  85
  86 struct ariadne_private {
  87         volatile struct TDRE *tx_ring[TX_RING_SIZE];
  88         volatile struct RDRE *rx_ring[RX_RING_SIZE];
  89         volatile u_short *tx_buff[TX_RING_SIZE];
  90         volatile u_short *rx_buff[RX_RING_SIZE];
  91         int cur_tx, cur_rx;             /* The next free ring entry */
  92         int dirty_tx;                   /* The ring entries to be free()ed */
  93         char tx_full;
  94 };
  95
  96 /* Structure Created in the Ariadne's RAM Buffer */
  97
  98 struct lancedata {
  99         struct TDRE tx_ring[TX_RING_SIZE];
 100         struct RDRE rx_ring[RX_RING_SIZE];
 101         u_short tx_buff[TX_RING_SIZE][PKT_BUF_SIZE / sizeof(u_short)];
 102         u_short rx_buff[RX_RING_SIZE][PKT_BUF_SIZE / sizeof(u_short)];
 103 };
 104
 105 static void memcpyw(volatile u_short *dest, u_short *src, int len)
 106 {
 107         while (len >= 2) {
 108                 *(dest++) = *(src++);
 109                 len -= 2;
 110         }
 111         if (len == 1)
 112                 *dest = (*(u_char *)src) << 8;
 113 }
 114
 115 static void ariadne_init_ring(struct net_device *dev)
 116 {
 117         struct ariadne_private *priv = netdev_priv(dev);
 118         volatile struct lancedata *lancedata = (struct lancedata *)dev->mem_start;
 119         int i;
 120
 121         netif_stop_queue(dev);
 122
 123         priv->tx_full = 0;
 124         priv->cur_rx = priv->cur_tx = 0;
 125         priv->dirty_tx = 0;
 126
 127         /* Set up TX Ring */
 128         for (i = 0; i < TX_RING_SIZE; i++) {
 129                 volatile struct TDRE *t = &lancedata->tx_ring[i];
 130                 t->TMD0 = swloww(ARIADNE_RAM +
 131                                  offsetof(struct lancedata, tx_buff[i]));
 132                 t->TMD1 = swhighw(ARIADNE_RAM +
 133                                   offsetof(struct lancedata, tx_buff[i])) |
 134                         TF_STP | TF_ENP;
 135                 t->TMD2 = swapw((u_short)-PKT_BUF_SIZE);
 136                 t->TMD3 = 0;
 137                 priv->tx_ring[i] = &lancedata->tx_ring[i];
 138                 priv->tx_buff[i] = lancedata->tx_buff[i];
 139                 netdev_dbg(dev, "TX Entry %2d at %p, Buf at %p\n",
 140                            i, &lancedata->tx_ring[i], lancedata->tx_buff[i]);
 141         }
 142
 143         /* Set up RX Ring */
 144         for (i = 0; i < RX_RING_SIZE; i++) {
 145                 volatile struct RDRE *r = &lancedata->rx_ring[i];
 146                 r->RMD0 = swloww(ARIADNE_RAM +
 147                                  offsetof(struct lancedata, rx_buff[i]));
 148                 r->RMD1 = swhighw(ARIADNE_RAM +
 149                                   offsetof(struct lancedata, rx_buff[i])) |
 150                         RF_OWN;
 151                 r->RMD2 = swapw((u_short)-PKT_BUF_SIZE);
 152                 r->RMD3 = 0x0000;
 153                 priv->rx_ring[i] = &lancedata->rx_ring[i];
 154                 priv->rx_buff[i] = lancedata->rx_buff[i];
 155                 netdev_dbg(dev, "RX Entry %2d at %p, Buf at %p\n",
 156                            i, &lancedata->rx_ring[i], lancedata->rx_buff[i]);
 157         }
 158 }
 159
 160 static int ariadne_rx(struct net_device *dev)
 161 {
 162         struct ariadne_private *priv = netdev_priv(dev);
 163         int entry = priv->cur_rx % RX_RING_SIZE;
 164         int i;
 165
 166         /* If we own the next entry, it's a new packet. Send it up */
 167         while (!(lowb(priv->rx_ring[entry]->RMD1) & RF_OWN)) {
 168                 int status = lowb(priv->rx_ring[entry]->RMD1);
 169
 170                 if (status != (RF_STP | RF_ENP)) {      /* There was an error */
 171                         /* There is a tricky error noted by
 172                          * John Murphy <murf@perftech.com> to Russ Nelson:
 173                          * Even with full-sized buffers it's possible for a
 174                          * jabber packet to use two buffers, with only the
 175                          * last correctly noting the error
 176                          */
 177                         /* Only count a general error at the end of a packet */
 178                         if (status & RF_ENP)
 179                                 dev->stats.rx_errors++;
 180                         if (status & RF_FRAM)
 181                                 dev->stats.rx_frame_errors++;
 182                         if (status & RF_OFLO)
 183                                 dev->stats.rx_over_errors++;
 184                         if (status & RF_CRC)
 185                                 dev->stats.rx_crc_errors++;
 186                         if (status & RF_BUFF)
 187                                 dev->stats.rx_fifo_errors++;
 188                         priv->rx_ring[entry]->RMD1 &= 0xff00 | RF_STP | RF_ENP;
 189                 } else {
 190                         /* Malloc up new buffer, compatible with net-3 */
 191                         short pkt_len = swapw(priv->rx_ring[entry]->RMD3);
 192                         struct sk_buff *skb;
 193
 194                         skb = netdev_alloc_skb(dev, pkt_len + 2);
 195                         if (skb == NULL) {
 196                                 for (i = 0; i < RX_RING_SIZE; i++)
 197                                         if (lowb(priv->rx_ring[(entry + i) % RX_RING_SIZE]->RMD1) & RF_OWN)
 198                                                 break;
 199
 200                                 if (i > RX_RING_SIZE - 2) {
 201                                         dev->stats.rx_dropped++;
 202                                         priv->rx_ring[entry]->RMD1 |= RF_OWN;
 203                                         priv->cur_rx++;
 204                                 }
 205                                 break;
 206                         }
 207
 208
 209                         skb_reserve(skb, 2);    /* 16 byte align */
 210                         skb_put(skb, pkt_len);  /* Make room */
 211                         skb_copy_to_linear_data(skb,
 212                                                 (const void *)priv->rx_buff[entry],
 213                                                 pkt_len);
 214                         skb->protocol = eth_type_trans(skb, dev);
 215                         netdev_dbg(dev, "RX pkt type 0x%04x from %pM to %pM data %p len %u\n",
 216                                    ((u_short *)skb->data)[6],
 217                                    skb->data + 6, skb->data,
 218                                    skb->data, skb->len);
 219
 220                         netif_rx(skb);
 221                         dev->stats.rx_packets++;
 222                         dev->stats.rx_bytes += pkt_len;
 223                 }
 224
 225                 priv->rx_ring[entry]->RMD1 |= RF_OWN;
 226                 entry = (++priv->cur_rx) % RX_RING_SIZE;
 227         }
 228
 229         priv->cur_rx = priv->cur_rx % RX_RING_SIZE;
 230
 231         /* We should check that at least two ring entries are free.
 232          * If not, we should free one and mark stats->rx_dropped++
 233          */
 234
 235         return 0;
 236 }
 237
 238 static irqreturn_t ariadne_interrupt(int irq, void *data)
 239 {
 240         struct net_device *dev = (struct net_device *)data;
 241         volatile struct Am79C960 *lance = (struct Am79C960 *)dev->base_addr;
 242         struct ariadne_private *priv;
 243         int csr0, boguscnt;
 244         int handled = 0;
 245
 246         lance->RAP = CSR0;              /* PCnet-ISA Controller Status */
 247
 248         if (!(lance->RDP & INTR))       /* Check if any interrupt has been */
 249                 return IRQ_NONE;        /* generated by the board */
 250
 251         priv = netdev_priv(dev);
 252
 253         boguscnt = 10;
 254         while ((csr0 = lance->RDP) & (ERR | RINT | TINT) && --boguscnt >= 0) {
 255                 /* Acknowledge all of the current interrupt sources ASAP */
 256                 lance->RDP = csr0 & ~(INEA | TDMD | STOP | STRT | INIT);
 257
 258 #ifdef DEBUG
 259                 if (ariadne_debug > 5) {
 260                         netdev_dbg(dev, "interrupt  csr0=%#02x new csr=%#02x [",
 261                                    csr0, lance->RDP);
 262                         if (csr0 & INTR)
 263                                 pr_cont(" INTR");
 264                         if (csr0 & INEA)
 265                                 pr_cont(" INEA");
 266                         if (csr0 & RXON)
 267                                 pr_cont(" RXON");
 268                         if (csr0 & TXON)
 269                                 pr_cont(" TXON");
 270                         if (csr0 & TDMD)
 271                                 pr_cont(" TDMD");
 272                         if (csr0 & STOP)
 273                                 pr_cont(" STOP");
 274                         if (csr0 & STRT)
 275                                 pr_cont(" STRT");
 276                         if (csr0 & INIT)
 277                                 pr_cont(" INIT");
 278                         if (csr0 & ERR)
 279                                 pr_cont(" ERR");
 280                         if (csr0 & BABL)
 281                                 pr_cont(" BABL");
 282                         if (csr0 & CERR)
 283                                 pr_cont(" CERR");
 284                         if (csr0 & MISS)
 285                                 pr_cont(" MISS");
 286                         if (csr0 & MERR)
 287                                 pr_cont(" MERR");
 288                         if (csr0 & RINT)
 289                                 pr_cont(" RINT");
 290                         if (csr0 & TINT)
 291                                 pr_cont(" TINT");
 292                         if (csr0 & IDON)
 293                                 pr_cont(" IDON");
 294                         pr_cont(" ]\n");
 295                 }
 296 #endif
 297
 298                 if (csr0 & RINT) {      /* Rx interrupt */
 299                         handled = 1;
 300                         ariadne_rx(dev);
 301                 }
 302
 303                 if (csr0 & TINT) {      /* Tx-done interrupt */
 304                         int dirty_tx = priv->dirty_tx;
 305
 306                         handled = 1;
 307                         while (dirty_tx < priv->cur_tx) {
 308                                 int entry = dirty_tx % TX_RING_SIZE;
 309                                 int status = lowb(priv->tx_ring[entry]->TMD1);
 310
 311                                 if (status & TF_OWN)
 312                                         break;  /* It still hasn't been Txed */
 313
 314                                 priv->tx_ring[entry]->TMD1 &= 0xff00;
 315
 316                                 if (status & TF_ERR) {
 317                                         /* There was an major error, log it */
 318                                         int err_status = priv->tx_ring[entry]->TMD3;
 319                                         dev->stats.tx_errors++;
 320                                         if (err_status & EF_RTRY)
 321                                                 dev->stats.tx_aborted_errors++;
 322                                         if (err_status & EF_LCAR)
 323                                                 dev->stats.tx_carrier_errors++;
 324                                         if (err_status & EF_LCOL)
 325                                                 dev->stats.tx_window_errors++;
 326                                         if (err_status & EF_UFLO) {
 327                                                 /* Ackk!  On FIFO errors the Tx unit is turned off! */
 328                                                 dev->stats.tx_fifo_errors++;
 329                                                 /* Remove this verbosity later! */
 330                                                 netdev_err(dev, "Tx FIFO error! Status %04x\n",
 331                                                            csr0);
 332                                                 /* Restart the chip */
 333                                                 lance->RDP = STRT;
 334                                         }
 335                                 } else {
 336                                         if (status & (TF_MORE | TF_ONE))
 337                                                 dev->stats.collisions++;
 338                                         dev->stats.tx_packets++;
 339                                 }
 340                                 dirty_tx++;
 341                         }
 342
 343 #ifndef final_version
 344                         if (priv->cur_tx - dirty_tx >= TX_RING_SIZE) {
 345                                 netdev_err(dev, "out-of-sync dirty pointer, %d vs. %d, full=%d\n",
 346                                            dirty_tx, priv->cur_tx,
 347                                            priv->tx_full);
 348                                 dirty_tx += TX_RING_SIZE;
 349                         }
 350 #endif
 351
 352                         if (priv->tx_full && netif_queue_stopped(dev) &&
 353                             dirty_tx > priv->cur_tx - TX_RING_SIZE + 2) {
 354                                 /* The ring is no longer full */
 355                                 priv->tx_full = 0;
 356                                 netif_wake_queue(dev);
 357                         }
 358
 359                         priv->dirty_tx = dirty_tx;
 360                 }
 361
 362                 /* Log misc errors */
 363                 if (csr0 & BABL) {
 364                         handled = 1;
 365                         dev->stats.tx_errors++; /* Tx babble */
 366                 }
 367                 if (csr0 & MISS) {
 368                         handled = 1;
 369                         dev->stats.rx_errors++; /* Missed a Rx frame */
 370                 }
 371                 if (csr0 & MERR) {
 372                         handled = 1;
 373                         netdev_err(dev, "Bus master arbitration failure, status %04x\n",
 374                                    csr0);
 375                         /* Restart the chip */
 376                         lance->RDP = STRT;
 377                 }
 378         }
 379
 380         /* Clear any other interrupt, and set interrupt enable */
 381         lance->RAP = CSR0;              /* PCnet-ISA Controller Status */
 382         lance->RDP = INEA | BABL | CERR | MISS | MERR | IDON;
 383
 384         if (ariadne_debug > 4)
 385                 netdev_dbg(dev, "exiting interrupt, csr%d=%#04x\n",
 386                            lance->RAP, lance->RDP);
 387
 388         return IRQ_RETVAL(handled);
 389 }
 390
 391 static int ariadne_open(struct net_device *dev)
 392 {
 393         volatile struct Am79C960 *lance = (struct Am79C960 *)dev->base_addr;
 394         u_short in;
 395         u_long version;
 396         int i;
 397
 398         /* Reset the LANCE */
 399         in = lance->Reset;
 400
 401         /* Stop the LANCE */
 402         lance->RAP = CSR0;              /* PCnet-ISA Controller Status */
 403         lance->RDP = STOP;
 404
 405         /* Check the LANCE version */
 406         lance->RAP = CSR88;             /* Chip ID */
 407         version = swapw(lance->RDP);
 408         lance->RAP = CSR89;             /* Chip ID */
 409         version |= swapw(lance->RDP) << 16;
 410         if ((version & 0x00000fff) != 0x00000003) {
 411                 pr_warn("Couldn't find AMD Ethernet Chip\n");
 412                 return -EAGAIN;
 413         }
 414         if ((version & 0x0ffff000) != 0x00003000) {
 415                 pr_warn("Couldn't find Am79C960 (Wrong part number = %ld)\n",
 416                        (version & 0x0ffff000) >> 12);
 417                 return -EAGAIN;
 418         }
 419
 420         netdev_dbg(dev, "Am79C960 (PCnet-ISA) Revision %ld\n",
 421                    (version & 0xf0000000) >> 28);
 422
 423         ariadne_init_ring(dev);
 424
 425         /* Miscellaneous Stuff */
 426         lance->RAP = CSR3;              /* Interrupt Masks and Deferral Control */
 427         lance->RDP = 0x0000;
 428         lance->RAP = CSR4;              /* Test and Features Control */
 429         lance->RDP = DPOLL | APAD_XMT | MFCOM | RCVCCOM | TXSTRTM | JABM;
 430
 431         /* Set the Multicast Table */
 432         lance->RAP = CSR8;              /* Logical Address Filter, LADRF[15:0] */
 433         lance->RDP = 0x0000;
 434         lance->RAP = CSR9;              /* Logical Address Filter, LADRF[31:16] */
 435         lance->RDP = 0x0000;
 436         lance->RAP = CSR10;             /* Logical Address Filter, LADRF[47:32] */
 437         lance->RDP = 0x0000;
 438         lance->RAP = CSR11;             /* Logical Address Filter, LADRF[63:48] */
 439         lance->RDP = 0x0000;
 440
 441         /* Set the Ethernet Hardware Address */
 442         lance->RAP = CSR12;             /* Physical Address Register, PADR[15:0] */
 443         lance->RDP = ((u_short *)&dev->dev_addr[0])[0];
 444         lance->RAP = CSR13;             /* Physical Address Register, PADR[31:16] */
 445         lance->RDP = ((u_short *)&dev->dev_addr[0])[1];
 446         lance->RAP = CSR14;             /* Physical Address Register, PADR[47:32] */
 447         lance->RDP = ((u_short *)&dev->dev_addr[0])[2];
 448
 449         /* Set the Init Block Mode */
 450         lance->RAP = CSR15;             /* Mode Register */
 451         lance->RDP = 0x0000;
 452
 453         /* Set the Transmit Descriptor Ring Pointer */
 454         lance->RAP = CSR30;             /* Base Address of Transmit Ring */
 455         lance->RDP = swloww(ARIADNE_RAM + offsetof(struct lancedata, tx_ring));
 456         lance->RAP = CSR31;             /* Base Address of transmit Ring */
 457         lance->RDP = swhighw(ARIADNE_RAM + offsetof(struct lancedata, tx_ring));
 458
 459         /* Set the Receive Descriptor Ring Pointer */
 460         lance->RAP = CSR24;             /* Base Address of Receive Ring */
 461         lance->RDP = swloww(ARIADNE_RAM + offsetof(struct lancedata, rx_ring));
 462         lance->RAP = CSR25;             /* Base Address of Receive Ring */
 463         lance->RDP = swhighw(ARIADNE_RAM + offsetof(struct lancedata, rx_ring));
 464
 465         /* Set the Number of RX and TX Ring Entries */
 466         lance->RAP = CSR76;             /* Receive Ring Length */
 467         lance->RDP = swapw(((u_short)-RX_RING_SIZE));
 468         lance->RAP = CSR78;             /* Transmit Ring Length */
 469         lance->RDP = swapw(((u_short)-TX_RING_SIZE));
 470
 471         /* Enable Media Interface Port Auto Select (10BASE-2/10BASE-T) */
 472         lance->RAP = ISACSR2;           /* Miscellaneous Configuration */
 473         lance->IDP = ASEL;
 474
 475         /* LED Control */
 476         lance->RAP = ISACSR5;           /* LED1 Status */
 477         lance->IDP = PSE|XMTE;
 478         lance->RAP = ISACSR6;   /* LED2 Status */
 479         lance->IDP = PSE|COLE;
 480         lance->RAP = ISACSR7;   /* LED3 Status */
 481         lance->IDP = PSE|RCVE;
 482
 483         netif_start_queue(dev);
 484
 485         i = request_irq(IRQ_AMIGA_PORTS, ariadne_interrupt, IRQF_SHARED,
 486                         dev->name, dev);
 487         if (i)
 488                 return i;
 489
 490         lance->RAP = CSR0;              /* PCnet-ISA Controller Status */
 491         lance->RDP = INEA | STRT;
 492
 493         return 0;
 494 }
 495
 496 static int ariadne_close(struct net_device *dev)
 497 {
 498         volatile struct Am79C960 *lance = (struct Am79C960 *)dev->base_addr;
 499
 500         netif_stop_queue(dev);
 501
 502         lance->RAP = CSR112;            /* Missed Frame Count */
 503         dev->stats.rx_missed_errors = swapw(lance->RDP);
 504         lance->RAP = CSR0;              /* PCnet-ISA Controller Status */
 505
 506         if (ariadne_debug > 1) {
 507                 netdev_dbg(dev, "Shutting down ethercard, status was %02x\n",
 508                            lance->RDP);
 509                 netdev_dbg(dev, "%lu packets missed\n",
 510                            dev->stats.rx_missed_errors);
 511         }
 512
 513         /* We stop the LANCE here -- it occasionally polls memory if we don't */
 514         lance->RDP = STOP;
 515
 516         free_irq(IRQ_AMIGA_PORTS, dev);
 517
 518         return 0;
 519 }
 520
 521 static inline void ariadne_reset(struct net_device *dev)
 522 {
 523         volatile struct Am79C960 *lance = (struct Am79C960 *)dev->base_addr;
 524
 525         lance->RAP = CSR0;      /* PCnet-ISA Controller Status */
 526         lance->RDP = STOP;
 527         ariadne_init_ring(dev);
 528         lance->RDP = INEA | STRT;
 529         netif_start_queue(dev);
 530 }
 531
 532 static void ariadne_tx_timeout(struct net_device *dev)
 533 {
 534         volatile struct Am79C960 *lance = (struct Am79C960 *)dev->base_addr;
 535
 536         netdev_err(dev, "transmit timed out, status %04x, resetting\n",
 537                    lance->RDP);
 538         ariadne_reset(dev);
 539         netif_wake_queue(dev);
 540 }
 541
 542 static netdev_tx_t ariadne_start_xmit(struct sk_buff *skb,
 543                                       struct net_device *dev)
 544 {
 545         struct ariadne_private *priv = netdev_priv(dev);
 546         volatile struct Am79C960 *lance = (struct Am79C960 *)dev->base_addr;
 547         int entry;
 548         unsigned long flags;
 549         int len = skb->len;
 550
 551 #if 0
 552         if (ariadne_debug > 3) {
 553                 lance->RAP = CSR0;      /* PCnet-ISA Controller Status */
 554                 netdev_dbg(dev, "%s: csr0 %04x\n", __func__, lance->RDP);
 555                 lance->RDP = 0x0000;
 556         }
 557 #endif
 558
 559         /* FIXME: is the 79C960 new enough to do its own padding right ? */
 560         if (skb->len < ETH_ZLEN) {
 561                 if (skb_padto(skb, ETH_ZLEN))
 562                         return NETDEV_TX_OK;
 563                 len = ETH_ZLEN;
 564         }
 565
 566         /* Fill in a Tx ring entry */
 567
 568         netdev_dbg(dev, "TX pkt type 0x%04x from %pM to %pM data %p len %u\n",
 569                    ((u_short *)skb->data)[6],
 570                    skb->data + 6, skb->data,
 571                    skb->data, skb->len);
 572
 573         local_irq_save(flags);
 574
 575         entry = priv->cur_tx % TX_RING_SIZE;
 576
 577         /* Caution: the write order is important here, set the base address with
 578            the "ownership" bits last */
 579
 580         priv->tx_ring[entry]->TMD2 = swapw((u_short)-skb->len);
 581         priv->tx_ring[entry]->TMD3 = 0x0000;
 582         memcpyw(priv->tx_buff[entry], (u_short *)skb->data, len);
 583
 584 #ifdef DEBUG
 585         print_hex_dump(KERN_DEBUG, "tx_buff: ", DUMP_PREFIX_OFFSET, 16, 1,
 586                        (void *)priv->tx_buff[entry],
 587                        skb->len > 64 ? 64 : skb->len, true);
 588 #endif
 589
 590         priv->tx_ring[entry]->TMD1 = (priv->tx_ring[entry]->TMD1 & 0xff00)
 591                 | TF_OWN | TF_STP | TF_ENP;
 592
 593         dev_kfree_skb(skb);
 594
 595         priv->cur_tx++;
 596         if ((priv->cur_tx >= TX_RING_SIZE) &&
 597             (priv->dirty_tx >= TX_RING_SIZE)) {
 598
 599                 netdev_dbg(dev, "*** Subtracting TX_RING_SIZE from cur_tx (%d) and dirty_tx (%d)\n",
 600                            priv->cur_tx, priv->dirty_tx);
 601
 602                 priv->cur_tx -= TX_RING_SIZE;
 603                 priv->dirty_tx -= TX_RING_SIZE;
 604         }
 605         dev->stats.tx_bytes += len;
 606
 607         /* Trigger an immediate send poll */
 608         lance->RAP = CSR0;              /* PCnet-ISA Controller Status */
 609         lance->RDP = INEA | TDMD;
 610
 611         if (lowb(priv->tx_ring[(entry + 1) % TX_RING_SIZE]->TMD1) != 0) {
 612                 netif_stop_queue(dev);
 613                 priv->tx_full = 1;
 614         }
 615         local_irq_restore(flags);
 616
 617         return NETDEV_TX_OK;
 618 }
 619
 620 static struct net_device_stats *ariadne_get_stats(struct net_device *dev)
 621 {
 622         volatile struct Am79C960 *lance = (struct Am79C960 *)dev->base_addr;
 623         short saved_addr;
 624         unsigned long flags;
 625
 626         local_irq_save(flags);
 627         saved_addr = lance->RAP;
 628         lance->RAP = CSR112;            /* Missed Frame Count */
 629         dev->stats.rx_missed_errors = swapw(lance->RDP);
 630         lance->RAP = saved_addr;
 631         local_irq_restore(flags);
 632
 633         return &dev->stats;
 634 }
 635
 636 /* Set or clear the multicast filter for this adaptor.
 637  * num_addrs == -1      Promiscuous mode, receive all packets
 638  * num_addrs == 0       Normal mode, clear multicast list
 639  * num_addrs > 0        Multicast mode, receive normal and MC packets,
 640  *                      and do best-effort filtering.
 641  */
 642 static void set_multicast_list(struct net_device *dev)
 643 {
 644         volatile struct Am79C960 *lance = (struct Am79C960 *)dev->base_addr;
 645
 646         if (!netif_running(dev))
 647                 return;
 648
 649         netif_stop_queue(dev);
 650
 651         /* We take the simple way out and always enable promiscuous mode */
 652         lance->RAP = CSR0;              /* PCnet-ISA Controller Status */
 653         lance->RDP = STOP;              /* Temporarily stop the lance */
 654         ariadne_init_ring(dev);
 655
 656         if (dev->flags & IFF_PROMISC) {
 657                 lance->RAP = CSR15;     /* Mode Register */
 658                 lance->RDP = PROM;      /* Set promiscuous mode */
 659         } else {
 660                 short multicast_table[4];
 661                 int num_addrs = netdev_mc_count(dev);
 662                 int i;
 663                 /* We don't use the multicast table,
 664                  * but rely on upper-layer filtering
 665                  */
 666                 memset(multicast_table, (num_addrs == 0) ? 0 : -1,
 667                        sizeof(multicast_table));
 668                 for (i = 0; i < 4; i++) {
 669                         lance->RAP = CSR8 + (i << 8);
 670                                         /* Logical Address Filter */
 671                         lance->RDP = swapw(multicast_table[i]);
 672                 }
 673                 lance->RAP = CSR15;     /* Mode Register */
 674                 lance->RDP = 0x0000;    /* Unset promiscuous mode */
 675         }
 676
 677         lance->RAP = CSR0;              /* PCnet-ISA Controller Status */
 678         lance->RDP = INEA | STRT | IDON;/* Resume normal operation */
 679
 680         netif_wake_queue(dev);
 681 }
 682
 683
 684 static void ariadne_remove_one(struct zorro_dev *z)
 685 {
 686         struct net_device *dev = zorro_get_drvdata(z);
 687
 688         unregister_netdev(dev);
 689         release_mem_region(ZTWO_PADDR(dev->base_addr), sizeof(struct Am79C960));
 690         release_mem_region(ZTWO_PADDR(dev->mem_start), ARIADNE_RAM_SIZE);
 691         free_netdev(dev);
 692 }
 693
 694 static struct zorro_device_id ariadne_zorro_tbl[] = {
 695         { ZORRO_PROD_VILLAGE_TRONIC_ARIADNE },
 696         { 0 }
 697 };
 698 MODULE_DEVICE_TABLE(zorro, ariadne_zorro_tbl);
 699
 700 static const struct net_device_ops ariadne_netdev_ops = {
 701         .ndo_open               = ariadne_open,
 702         .ndo_stop               = ariadne_close,
 703         .ndo_start_xmit         = ariadne_start_xmit,
 704         .ndo_tx_timeout         = ariadne_tx_timeout,
 705         .ndo_get_stats          = ariadne_get_stats,
 706         .ndo_set_rx_mode        = set_multicast_list,
 707         .ndo_validate_addr      = eth_validate_addr,
 708         .ndo_change_mtu         = eth_change_mtu,
 709         .ndo_set_mac_address    = eth_mac_addr,
 710 };
 711
 712 static int ariadne_init_one(struct zorro_dev *z,
 713                             const struct zorro_device_id *ent)
 714 {
 715         unsigned long board = z->resource.start;
 716         unsigned long base_addr = board + ARIADNE_LANCE;
 717         unsigned long mem_start = board + ARIADNE_RAM;
 718         struct resource *r1, *r2;
 719         struct net_device *dev;
 720         struct ariadne_private *priv;
 721         int err;
 722
 723         r1 = request_mem_region(base_addr, sizeof(struct Am79C960), "Am79C960");
 724         if (!r1)
 725                 return -EBUSY;
 726         r2 = request_mem_region(mem_start, ARIADNE_RAM_SIZE, "RAM");
 727         if (!r2) {
 728                 release_mem_region(base_addr, sizeof(struct Am79C960));
 729                 return -EBUSY;
 730         }
 731
 732         dev = alloc_etherdev(sizeof(struct ariadne_private));
 733         if (dev == NULL) {
 734                 release_mem_region(base_addr, sizeof(struct Am79C960));
 735                 release_mem_region(mem_start, ARIADNE_RAM_SIZE);
 736                 return -ENOMEM;
 737         }
 738
 739         priv = netdev_priv(dev);
 740
 741         r1->name = dev->name;
 742         r2->name = dev->name;
 743
 744         dev->dev_addr[0] = 0x00;
 745         dev->dev_addr[1] = 0x60;
 746         dev->dev_addr[2] = 0x30;
 747         dev->dev_addr[3] = (z->rom.er_SerialNumber >> 16) & 0xff;
 748         dev->dev_addr[4] = (z->rom.er_SerialNumber >> 8) & 0xff;
 749         dev->dev_addr[5] = z->rom.er_SerialNumber & 0xff;
 750         dev->base_addr = ZTWO_VADDR(base_addr);
 751         dev->mem_start = ZTWO_VADDR(mem_start);
 752         dev->mem_end = dev->mem_start + ARIADNE_RAM_SIZE;
 753
 754         dev->netdev_ops = &ariadne_netdev_ops;
 755         dev->watchdog_timeo = 5 * HZ;
 756
 757         err = register_netdev(dev);
 758         if (err) {
 759                 release_mem_region(base_addr, sizeof(struct Am79C960));
 760                 release_mem_region(mem_start, ARIADNE_RAM_SIZE);
 761                 free_netdev(dev);
 762                 return err;
 763         }
 764         zorro_set_drvdata(z, dev);
 765
 766         netdev_info(dev, "Ariadne at 0x%08lx, Ethernet Address %pM\n",
 767                     board, dev->dev_addr);
 768
 769         return 0;
 770 }
 771
 772 static struct zorro_driver ariadne_driver = {
 773         .name           = "ariadne",
 774         .id_table       = ariadne_zorro_tbl,
 775         .probe          = ariadne_init_one,
 776         .remove         = ariadne_remove_one,
 777 };
 778
 779 static int __init ariadne_init_module(void)
 780 {
 781         return zorro_register_driver(&ariadne_driver);
 782 }
 783
 784 static void __exit ariadne_cleanup_module(void)
 785 {
 786         zorro_unregister_driver(&ariadne_driver);
 787 }
 788
 789 module_init(ariadne_init_module);
 790 module_exit(ariadne_cleanup_module);
 791
 792 MODULE_LICENSE("GPL");