ariadne.c revision 720a43efd30f04a0a492c85fb997361c44fbae05
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 61int ariadne_debug = ARIADNE_DEBUG; 62#else 63int 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 86struct 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 98struct 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 105static 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 115static 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 160static 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 238static 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 391static 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 496static 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 521static 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 532static 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 542static 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 620static 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 */ 642static 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 684static 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 694static struct zorro_device_id ariadne_zorro_tbl[] = { 695 { ZORRO_PROD_VILLAGE_TRONIC_ARIADNE }, 696 { 0 } 697}; 698MODULE_DEVICE_TABLE(zorro, ariadne_zorro_tbl); 699 700static 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 712static 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 772static 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 779static int __init ariadne_init_module(void) 780{ 781 return zorro_register_driver(&ariadne_driver); 782} 783 784static void __exit ariadne_cleanup_module(void) 785{ 786 zorro_unregister_driver(&ariadne_driver); 787} 788 789module_init(ariadne_init_module); 790module_exit(ariadne_cleanup_module); 791 792MODULE_LICENSE("GPL"); 793