1/* 2 * linux/drivers/acorn/net/ether1.c 3 * 4 * Copyright (C) 1996-2000 Russell King 5 * 6 * This program is free software; you can redistribute it and/or modify 7 * it under the terms of the GNU General Public License version 2 as 8 * published by the Free Software Foundation. 9 * 10 * Acorn ether1 driver (82586 chip) for Acorn machines 11 * 12 * We basically keep two queues in the cards memory - one for transmit 13 * and one for receive. Each has a head and a tail. The head is where 14 * we/the chip adds packets to be transmitted/received, and the tail 15 * is where the transmitter has got to/where the receiver will stop. 16 * Both of these queues are circular, and since the chip is running 17 * all the time, we have to be careful when we modify the pointers etc 18 * so that the buffer memory contents is valid all the time. 19 * 20 * Change log: 21 * 1.00 RMK Released 22 * 1.01 RMK 19/03/1996 Transfers the last odd byte onto/off of the card now. 23 * 1.02 RMK 25/05/1997 Added code to restart RU if it goes not ready 24 * 1.03 RMK 14/09/1997 Cleaned up the handling of a reset during the TX interrupt. 25 * Should prevent lockup. 26 * 1.04 RMK 17/09/1997 Added more info when initialsation of chip goes wrong. 27 * TDR now only reports failure when chip reports non-zero 28 * TDR time-distance. 29 * 1.05 RMK 31/12/1997 Removed calls to dev_tint for 2.1 30 * 1.06 RMK 10/02/2000 Updated for 2.3.43 31 * 1.07 RMK 13/05/2000 Updated for 2.3.99-pre8 32 */ 33 34#include <linux/module.h> 35#include <linux/kernel.h> 36#include <linux/types.h> 37#include <linux/fcntl.h> 38#include <linux/interrupt.h> 39#include <linux/ptrace.h> 40#include <linux/ioport.h> 41#include <linux/in.h> 42#include <linux/slab.h> 43#include <linux/string.h> 44#include <linux/errno.h> 45#include <linux/device.h> 46#include <linux/init.h> 47#include <linux/netdevice.h> 48#include <linux/etherdevice.h> 49#include <linux/skbuff.h> 50#include <linux/bitops.h> 51 52#include <asm/system.h> 53#include <asm/io.h> 54#include <asm/dma.h> 55#include <asm/ecard.h> 56 57#define __ETHER1_C 58#include "ether1.h" 59 60static unsigned int net_debug = NET_DEBUG; 61 62#define BUFFER_SIZE 0x10000 63#define TX_AREA_START 0x00100 64#define TX_AREA_END 0x05000 65#define RX_AREA_START 0x05000 66#define RX_AREA_END 0x0fc00 67 68static int ether1_open(struct net_device *dev); 69static int ether1_sendpacket(struct sk_buff *skb, struct net_device *dev); 70static irqreturn_t ether1_interrupt(int irq, void *dev_id); 71static int ether1_close(struct net_device *dev); 72static struct net_device_stats *ether1_getstats(struct net_device *dev); 73static void ether1_setmulticastlist(struct net_device *dev); 74static void ether1_timeout(struct net_device *dev); 75 76/* ------------------------------------------------------------------------- */ 77 78static char version[] __initdata = "ether1 ethernet driver (c) 2000 Russell King v1.07\n"; 79 80#define BUS_16 16 81#define BUS_8 8 82 83/* ------------------------------------------------------------------------- */ 84 85#define DISABLEIRQS 1 86#define NORMALIRQS 0 87 88#define ether1_readw(dev, addr, type, offset, svflgs) ether1_inw_p (dev, addr + (int)(&((type *)0)->offset), svflgs) 89#define ether1_writew(dev, val, addr, type, offset, svflgs) ether1_outw_p (dev, val, addr + (int)(&((type *)0)->offset), svflgs) 90 91static inline unsigned short 92ether1_inw_p (struct net_device *dev, int addr, int svflgs) 93{ 94 unsigned long flags; 95 unsigned short ret; 96 97 if (svflgs) 98 local_irq_save (flags); 99 100 writeb(addr >> 12, REG_PAGE); 101 ret = readw(ETHER1_RAM + ((addr & 4095) << 1)); 102 if (svflgs) 103 local_irq_restore (flags); 104 return ret; 105} 106 107static inline void 108ether1_outw_p (struct net_device *dev, unsigned short val, int addr, int svflgs) 109{ 110 unsigned long flags; 111 112 if (svflgs) 113 local_irq_save (flags); 114 115 writeb(addr >> 12, REG_PAGE); 116 writew(val, ETHER1_RAM + ((addr & 4095) << 1)); 117 if (svflgs) 118 local_irq_restore (flags); 119} 120 121/* 122 * Some inline assembler to allow fast transfers on to/off of the card. 123 * Since this driver depends on some features presented by the ARM 124 * specific architecture, and that you can't configure this driver 125 * without specifiing ARM mode, this is not a problem. 126 * 127 * This routine is essentially an optimised memcpy from the card's 128 * onboard RAM to kernel memory. 129 */ 130static void 131ether1_writebuffer (struct net_device *dev, void *data, unsigned int start, unsigned int length) 132{ 133 unsigned int page, thislen, offset; 134 void __iomem *addr; 135 136 offset = start & 4095; 137 page = start >> 12; 138 addr = ETHER1_RAM + (offset << 1); 139 140 if (offset + length > 4096) 141 thislen = 4096 - offset; 142 else 143 thislen = length; 144 145 do { 146 int used; 147 148 writeb(page, REG_PAGE); 149 length -= thislen; 150 151 __asm__ __volatile__( 152 "subs %3, %3, #2\n\ 153 bmi 2f\n\ 1541: ldr %0, [%1], #2\n\ 155 mov %0, %0, lsl #16\n\ 156 orr %0, %0, %0, lsr #16\n\ 157 str %0, [%2], #4\n\ 158 subs %3, %3, #2\n\ 159 bmi 2f\n\ 160 ldr %0, [%1], #2\n\ 161 mov %0, %0, lsl #16\n\ 162 orr %0, %0, %0, lsr #16\n\ 163 str %0, [%2], #4\n\ 164 subs %3, %3, #2\n\ 165 bmi 2f\n\ 166 ldr %0, [%1], #2\n\ 167 mov %0, %0, lsl #16\n\ 168 orr %0, %0, %0, lsr #16\n\ 169 str %0, [%2], #4\n\ 170 subs %3, %3, #2\n\ 171 bmi 2f\n\ 172 ldr %0, [%1], #2\n\ 173 mov %0, %0, lsl #16\n\ 174 orr %0, %0, %0, lsr #16\n\ 175 str %0, [%2], #4\n\ 176 subs %3, %3, #2\n\ 177 bpl 1b\n\ 1782: adds %3, %3, #1\n\ 179 ldreqb %0, [%1]\n\ 180 streqb %0, [%2]" 181 : "=&r" (used), "=&r" (data) 182 : "r" (addr), "r" (thislen), "1" (data)); 183 184 addr = ETHER1_RAM; 185 186 thislen = length; 187 if (thislen > 4096) 188 thislen = 4096; 189 page++; 190 } while (thislen); 191} 192 193static void 194ether1_readbuffer (struct net_device *dev, void *data, unsigned int start, unsigned int length) 195{ 196 unsigned int page, thislen, offset; 197 void __iomem *addr; 198 199 offset = start & 4095; 200 page = start >> 12; 201 addr = ETHER1_RAM + (offset << 1); 202 203 if (offset + length > 4096) 204 thislen = 4096 - offset; 205 else 206 thislen = length; 207 208 do { 209 int used; 210 211 writeb(page, REG_PAGE); 212 length -= thislen; 213 214 __asm__ __volatile__( 215 "subs %3, %3, #2\n\ 216 bmi 2f\n\ 2171: ldr %0, [%2], #4\n\ 218 strb %0, [%1], #1\n\ 219 mov %0, %0, lsr #8\n\ 220 strb %0, [%1], #1\n\ 221 subs %3, %3, #2\n\ 222 bmi 2f\n\ 223 ldr %0, [%2], #4\n\ 224 strb %0, [%1], #1\n\ 225 mov %0, %0, lsr #8\n\ 226 strb %0, [%1], #1\n\ 227 subs %3, %3, #2\n\ 228 bmi 2f\n\ 229 ldr %0, [%2], #4\n\ 230 strb %0, [%1], #1\n\ 231 mov %0, %0, lsr #8\n\ 232 strb %0, [%1], #1\n\ 233 subs %3, %3, #2\n\ 234 bmi 2f\n\ 235 ldr %0, [%2], #4\n\ 236 strb %0, [%1], #1\n\ 237 mov %0, %0, lsr #8\n\ 238 strb %0, [%1], #1\n\ 239 subs %3, %3, #2\n\ 240 bpl 1b\n\ 2412: adds %3, %3, #1\n\ 242 ldreqb %0, [%2]\n\ 243 streqb %0, [%1]" 244 : "=&r" (used), "=&r" (data) 245 : "r" (addr), "r" (thislen), "1" (data)); 246 247 addr = ETHER1_RAM; 248 249 thislen = length; 250 if (thislen > 4096) 251 thislen = 4096; 252 page++; 253 } while (thislen); 254} 255 256static int __devinit 257ether1_ramtest(struct net_device *dev, unsigned char byte) 258{ 259 unsigned char *buffer = kmalloc (BUFFER_SIZE, GFP_KERNEL); 260 int i, ret = BUFFER_SIZE; 261 int max_errors = 15; 262 int bad = -1; 263 int bad_start = 0; 264 265 if (!buffer) 266 return 1; 267 268 memset (buffer, byte, BUFFER_SIZE); 269 ether1_writebuffer (dev, buffer, 0, BUFFER_SIZE); 270 memset (buffer, byte ^ 0xff, BUFFER_SIZE); 271 ether1_readbuffer (dev, buffer, 0, BUFFER_SIZE); 272 273 for (i = 0; i < BUFFER_SIZE; i++) { 274 if (buffer[i] != byte) { 275 if (max_errors >= 0 && bad != buffer[i]) { 276 if (bad != -1) 277 printk ("\n"); 278 printk (KERN_CRIT "%s: RAM failed with (%02X instead of %02X) at 0x%04X", 279 dev->name, buffer[i], byte, i); 280 ret = -ENODEV; 281 max_errors --; 282 bad = buffer[i]; 283 bad_start = i; 284 } 285 } else { 286 if (bad != -1) { 287 if (bad_start == i - 1) 288 printk ("\n"); 289 else 290 printk (" - 0x%04X\n", i - 1); 291 bad = -1; 292 } 293 } 294 } 295 296 if (bad != -1) 297 printk (" - 0x%04X\n", BUFFER_SIZE); 298 kfree (buffer); 299 300 return ret; 301} 302 303static int 304ether1_reset (struct net_device *dev) 305{ 306 writeb(CTRL_RST|CTRL_ACK, REG_CONTROL); 307 return BUS_16; 308} 309 310static int __devinit 311ether1_init_2(struct net_device *dev) 312{ 313 int i; 314 dev->mem_start = 0; 315 316 i = ether1_ramtest (dev, 0x5a); 317 318 if (i > 0) 319 i = ether1_ramtest (dev, 0x1e); 320 321 if (i <= 0) 322 return -ENODEV; 323 324 dev->mem_end = i; 325 return 0; 326} 327 328/* 329 * These are the structures that are loaded into the ether RAM card to 330 * initialise the 82586 331 */ 332 333/* at 0x0100 */ 334#define NOP_ADDR (TX_AREA_START) 335#define NOP_SIZE (0x06) 336static nop_t init_nop = { 337 0, 338 CMD_NOP, 339 NOP_ADDR 340}; 341 342/* at 0x003a */ 343#define TDR_ADDR (0x003a) 344#define TDR_SIZE (0x08) 345static tdr_t init_tdr = { 346 0, 347 CMD_TDR | CMD_INTR, 348 NOP_ADDR, 349 0 350}; 351 352/* at 0x002e */ 353#define MC_ADDR (0x002e) 354#define MC_SIZE (0x0c) 355static mc_t init_mc = { 356 0, 357 CMD_SETMULTICAST, 358 TDR_ADDR, 359 0, 360 { { 0, } } 361}; 362 363/* at 0x0022 */ 364#define SA_ADDR (0x0022) 365#define SA_SIZE (0x0c) 366static sa_t init_sa = { 367 0, 368 CMD_SETADDRESS, 369 MC_ADDR, 370 { 0, } 371}; 372 373/* at 0x0010 */ 374#define CFG_ADDR (0x0010) 375#define CFG_SIZE (0x12) 376static cfg_t init_cfg = { 377 0, 378 CMD_CONFIG, 379 SA_ADDR, 380 8, 381 8, 382 CFG8_SRDY, 383 CFG9_PREAMB8 | CFG9_ADDRLENBUF | CFG9_ADDRLEN(6), 384 0, 385 0x60, 386 0, 387 CFG13_RETRY(15) | CFG13_SLOTH(2), 388 0, 389}; 390 391/* at 0x0000 */ 392#define SCB_ADDR (0x0000) 393#define SCB_SIZE (0x10) 394static scb_t init_scb = { 395 0, 396 SCB_CMDACKRNR | SCB_CMDACKCNA | SCB_CMDACKFR | SCB_CMDACKCX, 397 CFG_ADDR, 398 RX_AREA_START, 399 0, 400 0, 401 0, 402 0 403}; 404 405/* at 0xffee */ 406#define ISCP_ADDR (0xffee) 407#define ISCP_SIZE (0x08) 408static iscp_t init_iscp = { 409 1, 410 SCB_ADDR, 411 0x0000, 412 0x0000 413}; 414 415/* at 0xfff6 */ 416#define SCP_ADDR (0xfff6) 417#define SCP_SIZE (0x0a) 418static scp_t init_scp = { 419 SCP_SY_16BBUS, 420 { 0, 0 }, 421 ISCP_ADDR, 422 0 423}; 424 425#define RFD_SIZE (0x16) 426static rfd_t init_rfd = { 427 0, 428 0, 429 0, 430 0, 431 { 0, }, 432 { 0, }, 433 0 434}; 435 436#define RBD_SIZE (0x0a) 437static rbd_t init_rbd = { 438 0, 439 0, 440 0, 441 0, 442 ETH_FRAME_LEN + 8 443}; 444 445#define TX_SIZE (0x08) 446#define TBD_SIZE (0x08) 447 448static int 449ether1_init_for_open (struct net_device *dev) 450{ 451 int i, status, addr, next, next2; 452 int failures = 0; 453 unsigned long timeout; 454 455 writeb(CTRL_RST|CTRL_ACK, REG_CONTROL); 456 457 for (i = 0; i < 6; i++) 458 init_sa.sa_addr[i] = dev->dev_addr[i]; 459 460 /* load data structures into ether1 RAM */ 461 ether1_writebuffer (dev, &init_scp, SCP_ADDR, SCP_SIZE); 462 ether1_writebuffer (dev, &init_iscp, ISCP_ADDR, ISCP_SIZE); 463 ether1_writebuffer (dev, &init_scb, SCB_ADDR, SCB_SIZE); 464 ether1_writebuffer (dev, &init_cfg, CFG_ADDR, CFG_SIZE); 465 ether1_writebuffer (dev, &init_sa, SA_ADDR, SA_SIZE); 466 ether1_writebuffer (dev, &init_mc, MC_ADDR, MC_SIZE); 467 ether1_writebuffer (dev, &init_tdr, TDR_ADDR, TDR_SIZE); 468 ether1_writebuffer (dev, &init_nop, NOP_ADDR, NOP_SIZE); 469 470 if (ether1_readw(dev, CFG_ADDR, cfg_t, cfg_command, NORMALIRQS) != CMD_CONFIG) { 471 printk (KERN_ERR "%s: detected either RAM fault or compiler bug\n", 472 dev->name); 473 return 1; 474 } 475 476 /* 477 * setup circularly linked list of { rfd, rbd, buffer }, with 478 * all rfds circularly linked, rbds circularly linked. 479 * First rfd is linked to scp, first rbd is linked to first 480 * rfd. Last rbd has a suspend command. 481 */ 482 addr = RX_AREA_START; 483 do { 484 next = addr + RFD_SIZE + RBD_SIZE + ETH_FRAME_LEN + 10; 485 next2 = next + RFD_SIZE + RBD_SIZE + ETH_FRAME_LEN + 10; 486 487 if (next2 >= RX_AREA_END) { 488 next = RX_AREA_START; 489 init_rfd.rfd_command = RFD_CMDEL | RFD_CMDSUSPEND; 490 priv(dev)->rx_tail = addr; 491 } else 492 init_rfd.rfd_command = 0; 493 if (addr == RX_AREA_START) 494 init_rfd.rfd_rbdoffset = addr + RFD_SIZE; 495 else 496 init_rfd.rfd_rbdoffset = 0; 497 init_rfd.rfd_link = next; 498 init_rbd.rbd_link = next + RFD_SIZE; 499 init_rbd.rbd_bufl = addr + RFD_SIZE + RBD_SIZE; 500 501 ether1_writebuffer (dev, &init_rfd, addr, RFD_SIZE); 502 ether1_writebuffer (dev, &init_rbd, addr + RFD_SIZE, RBD_SIZE); 503 addr = next; 504 } while (next2 < RX_AREA_END); 505 506 priv(dev)->tx_link = NOP_ADDR; 507 priv(dev)->tx_head = NOP_ADDR + NOP_SIZE; 508 priv(dev)->tx_tail = TDR_ADDR; 509 priv(dev)->rx_head = RX_AREA_START; 510 511 /* release reset & give 586 a prod */ 512 priv(dev)->resetting = 1; 513 priv(dev)->initialising = 1; 514 writeb(CTRL_RST, REG_CONTROL); 515 writeb(0, REG_CONTROL); 516 writeb(CTRL_CA, REG_CONTROL); 517 518 /* 586 should now unset iscp.busy */ 519 timeout = jiffies + HZ/2; 520 while (ether1_readw(dev, ISCP_ADDR, iscp_t, iscp_busy, DISABLEIRQS) == 1) { 521 if (time_after(jiffies, timeout)) { 522 printk (KERN_WARNING "%s: can't initialise 82586: iscp is busy\n", dev->name); 523 return 1; 524 } 525 } 526 527 /* check status of commands that we issued */ 528 timeout += HZ/10; 529 while (((status = ether1_readw(dev, CFG_ADDR, cfg_t, cfg_status, DISABLEIRQS)) 530 & STAT_COMPLETE) == 0) { 531 if (time_after(jiffies, timeout)) 532 break; 533 } 534 535 if ((status & (STAT_COMPLETE | STAT_OK)) != (STAT_COMPLETE | STAT_OK)) { 536 printk (KERN_WARNING "%s: can't initialise 82586: config status %04X\n", dev->name, status); 537 printk (KERN_DEBUG "%s: SCB=[STS=%04X CMD=%04X CBL=%04X RFA=%04X]\n", dev->name, 538 ether1_readw(dev, SCB_ADDR, scb_t, scb_status, NORMALIRQS), 539 ether1_readw(dev, SCB_ADDR, scb_t, scb_command, NORMALIRQS), 540 ether1_readw(dev, SCB_ADDR, scb_t, scb_cbl_offset, NORMALIRQS), 541 ether1_readw(dev, SCB_ADDR, scb_t, scb_rfa_offset, NORMALIRQS)); 542 failures += 1; 543 } 544 545 timeout += HZ/10; 546 while (((status = ether1_readw(dev, SA_ADDR, sa_t, sa_status, DISABLEIRQS)) 547 & STAT_COMPLETE) == 0) { 548 if (time_after(jiffies, timeout)) 549 break; 550 } 551 552 if ((status & (STAT_COMPLETE | STAT_OK)) != (STAT_COMPLETE | STAT_OK)) { 553 printk (KERN_WARNING "%s: can't initialise 82586: set address status %04X\n", dev->name, status); 554 printk (KERN_DEBUG "%s: SCB=[STS=%04X CMD=%04X CBL=%04X RFA=%04X]\n", dev->name, 555 ether1_readw(dev, SCB_ADDR, scb_t, scb_status, NORMALIRQS), 556 ether1_readw(dev, SCB_ADDR, scb_t, scb_command, NORMALIRQS), 557 ether1_readw(dev, SCB_ADDR, scb_t, scb_cbl_offset, NORMALIRQS), 558 ether1_readw(dev, SCB_ADDR, scb_t, scb_rfa_offset, NORMALIRQS)); 559 failures += 1; 560 } 561 562 timeout += HZ/10; 563 while (((status = ether1_readw(dev, MC_ADDR, mc_t, mc_status, DISABLEIRQS)) 564 & STAT_COMPLETE) == 0) { 565 if (time_after(jiffies, timeout)) 566 break; 567 } 568 569 if ((status & (STAT_COMPLETE | STAT_OK)) != (STAT_COMPLETE | STAT_OK)) { 570 printk (KERN_WARNING "%s: can't initialise 82586: set multicast status %04X\n", dev->name, status); 571 printk (KERN_DEBUG "%s: SCB=[STS=%04X CMD=%04X CBL=%04X RFA=%04X]\n", dev->name, 572 ether1_readw(dev, SCB_ADDR, scb_t, scb_status, NORMALIRQS), 573 ether1_readw(dev, SCB_ADDR, scb_t, scb_command, NORMALIRQS), 574 ether1_readw(dev, SCB_ADDR, scb_t, scb_cbl_offset, NORMALIRQS), 575 ether1_readw(dev, SCB_ADDR, scb_t, scb_rfa_offset, NORMALIRQS)); 576 failures += 1; 577 } 578 579 timeout += HZ; 580 while (((status = ether1_readw(dev, TDR_ADDR, tdr_t, tdr_status, DISABLEIRQS)) 581 & STAT_COMPLETE) == 0) { 582 if (time_after(jiffies, timeout)) 583 break; 584 } 585 586 if ((status & (STAT_COMPLETE | STAT_OK)) != (STAT_COMPLETE | STAT_OK)) { 587 printk (KERN_WARNING "%s: can't tdr (ignored)\n", dev->name); 588 printk (KERN_DEBUG "%s: SCB=[STS=%04X CMD=%04X CBL=%04X RFA=%04X]\n", dev->name, 589 ether1_readw(dev, SCB_ADDR, scb_t, scb_status, NORMALIRQS), 590 ether1_readw(dev, SCB_ADDR, scb_t, scb_command, NORMALIRQS), 591 ether1_readw(dev, SCB_ADDR, scb_t, scb_cbl_offset, NORMALIRQS), 592 ether1_readw(dev, SCB_ADDR, scb_t, scb_rfa_offset, NORMALIRQS)); 593 } else { 594 status = ether1_readw(dev, TDR_ADDR, tdr_t, tdr_result, DISABLEIRQS); 595 if (status & TDR_XCVRPROB) 596 printk (KERN_WARNING "%s: i/f failed tdr: transceiver problem\n", dev->name); 597 else if ((status & (TDR_SHORT|TDR_OPEN)) && (status & TDR_TIME)) { 598#ifdef FANCY 599 printk (KERN_WARNING "%s: i/f failed tdr: cable %s %d.%d us away\n", dev->name, 600 status & TDR_SHORT ? "short" : "open", (status & TDR_TIME) / 10, 601 (status & TDR_TIME) % 10); 602#else 603 printk (KERN_WARNING "%s: i/f failed tdr: cable %s %d clks away\n", dev->name, 604 status & TDR_SHORT ? "short" : "open", (status & TDR_TIME)); 605#endif 606 } 607 } 608 609 if (failures) 610 ether1_reset (dev); 611 return failures ? 1 : 0; 612} 613 614/* ------------------------------------------------------------------------- */ 615 616static int 617ether1_txalloc (struct net_device *dev, int size) 618{ 619 int start, tail; 620 621 size = (size + 1) & ~1; 622 tail = priv(dev)->tx_tail; 623 624 if (priv(dev)->tx_head + size > TX_AREA_END) { 625 if (tail > priv(dev)->tx_head) 626 return -1; 627 start = TX_AREA_START; 628 if (start + size > tail) 629 return -1; 630 priv(dev)->tx_head = start + size; 631 } else { 632 if (priv(dev)->tx_head < tail && (priv(dev)->tx_head + size) > tail) 633 return -1; 634 start = priv(dev)->tx_head; 635 priv(dev)->tx_head += size; 636 } 637 638 return start; 639} 640 641static int 642ether1_open (struct net_device *dev) 643{ 644 if (!is_valid_ether_addr(dev->dev_addr)) { 645 printk(KERN_WARNING "%s: invalid ethernet MAC address\n", 646 dev->name); 647 return -EINVAL; 648 } 649 650 if (request_irq(dev->irq, ether1_interrupt, 0, "ether1", dev)) 651 return -EAGAIN; 652 653 memset (&priv(dev)->stats, 0, sizeof (struct net_device_stats)); 654 655 if (ether1_init_for_open (dev)) { 656 free_irq (dev->irq, dev); 657 return -EAGAIN; 658 } 659 660 netif_start_queue(dev); 661 662 return 0; 663} 664 665static void 666ether1_timeout(struct net_device *dev) 667{ 668 printk(KERN_WARNING "%s: transmit timeout, network cable problem?\n", 669 dev->name); 670 printk(KERN_WARNING "%s: resetting device\n", dev->name); 671 672 ether1_reset (dev); 673 674 if (ether1_init_for_open (dev)) 675 printk (KERN_ERR "%s: unable to restart interface\n", dev->name); 676 677 priv(dev)->stats.tx_errors++; 678 netif_wake_queue(dev); 679} 680 681static int 682ether1_sendpacket (struct sk_buff *skb, struct net_device *dev) 683{ 684 int tmp, tst, nopaddr, txaddr, tbdaddr, dataddr; 685 unsigned long flags; 686 tx_t tx; 687 tbd_t tbd; 688 nop_t nop; 689 690 if (priv(dev)->restart) { 691 printk(KERN_WARNING "%s: resetting device\n", dev->name); 692 693 ether1_reset(dev); 694 695 if (ether1_init_for_open(dev)) 696 printk(KERN_ERR "%s: unable to restart interface\n", dev->name); 697 else 698 priv(dev)->restart = 0; 699 } 700 701 if (skb->len < ETH_ZLEN) { 702 if (skb_padto(skb, ETH_ZLEN)) 703 goto out; 704 } 705 706 /* 707 * insert packet followed by a nop 708 */ 709 txaddr = ether1_txalloc (dev, TX_SIZE); 710 tbdaddr = ether1_txalloc (dev, TBD_SIZE); 711 dataddr = ether1_txalloc (dev, skb->len); 712 nopaddr = ether1_txalloc (dev, NOP_SIZE); 713 714 tx.tx_status = 0; 715 tx.tx_command = CMD_TX | CMD_INTR; 716 tx.tx_link = nopaddr; 717 tx.tx_tbdoffset = tbdaddr; 718 tbd.tbd_opts = TBD_EOL | skb->len; 719 tbd.tbd_link = I82586_NULL; 720 tbd.tbd_bufl = dataddr; 721 tbd.tbd_bufh = 0; 722 nop.nop_status = 0; 723 nop.nop_command = CMD_NOP; 724 nop.nop_link = nopaddr; 725 726 local_irq_save(flags); 727 ether1_writebuffer (dev, &tx, txaddr, TX_SIZE); 728 ether1_writebuffer (dev, &tbd, tbdaddr, TBD_SIZE); 729 ether1_writebuffer (dev, skb->data, dataddr, skb->len); 730 ether1_writebuffer (dev, &nop, nopaddr, NOP_SIZE); 731 tmp = priv(dev)->tx_link; 732 priv(dev)->tx_link = nopaddr; 733 734 /* now reset the previous nop pointer */ 735 ether1_writew(dev, txaddr, tmp, nop_t, nop_link, NORMALIRQS); 736 737 local_irq_restore(flags); 738 739 /* handle transmit */ 740 dev->trans_start = jiffies; 741 742 /* check to see if we have room for a full sized ether frame */ 743 tmp = priv(dev)->tx_head; 744 tst = ether1_txalloc (dev, TX_SIZE + TBD_SIZE + NOP_SIZE + ETH_FRAME_LEN); 745 priv(dev)->tx_head = tmp; 746 dev_kfree_skb (skb); 747 748 if (tst == -1) 749 netif_stop_queue(dev); 750 751 out: 752 return 0; 753} 754 755static void 756ether1_xmit_done (struct net_device *dev) 757{ 758 nop_t nop; 759 int caddr, tst; 760 761 caddr = priv(dev)->tx_tail; 762 763again: 764 ether1_readbuffer (dev, &nop, caddr, NOP_SIZE); 765 766 switch (nop.nop_command & CMD_MASK) { 767 case CMD_TDR: 768 /* special case */ 769 if (ether1_readw(dev, SCB_ADDR, scb_t, scb_cbl_offset, NORMALIRQS) 770 != (unsigned short)I82586_NULL) { 771 ether1_writew(dev, SCB_CMDCUCSTART | SCB_CMDRXSTART, SCB_ADDR, scb_t, 772 scb_command, NORMALIRQS); 773 writeb(CTRL_CA, REG_CONTROL); 774 } 775 priv(dev)->tx_tail = NOP_ADDR; 776 return; 777 778 case CMD_NOP: 779 if (nop.nop_link == caddr) { 780 if (priv(dev)->initialising == 0) 781 printk (KERN_WARNING "%s: strange command complete with no tx command!\n", dev->name); 782 else 783 priv(dev)->initialising = 0; 784 return; 785 } 786 if (caddr == nop.nop_link) 787 return; 788 caddr = nop.nop_link; 789 goto again; 790 791 case CMD_TX: 792 if (nop.nop_status & STAT_COMPLETE) 793 break; 794 printk (KERN_ERR "%s: strange command complete without completed command\n", dev->name); 795 priv(dev)->restart = 1; 796 return; 797 798 default: 799 printk (KERN_WARNING "%s: strange command %d complete! (offset %04X)", dev->name, 800 nop.nop_command & CMD_MASK, caddr); 801 priv(dev)->restart = 1; 802 return; 803 } 804 805 while (nop.nop_status & STAT_COMPLETE) { 806 if (nop.nop_status & STAT_OK) { 807 priv(dev)->stats.tx_packets ++; 808 priv(dev)->stats.collisions += (nop.nop_status & STAT_COLLISIONS); 809 } else { 810 priv(dev)->stats.tx_errors ++; 811 812 if (nop.nop_status & STAT_COLLAFTERTX) 813 priv(dev)->stats.collisions ++; 814 if (nop.nop_status & STAT_NOCARRIER) 815 priv(dev)->stats.tx_carrier_errors ++; 816 if (nop.nop_status & STAT_TXLOSTCTS) 817 printk (KERN_WARNING "%s: cts lost\n", dev->name); 818 if (nop.nop_status & STAT_TXSLOWDMA) 819 priv(dev)->stats.tx_fifo_errors ++; 820 if (nop.nop_status & STAT_COLLEXCESSIVE) 821 priv(dev)->stats.collisions += 16; 822 } 823 824 if (nop.nop_link == caddr) { 825 printk (KERN_ERR "%s: tx buffer chaining error: tx command points to itself\n", dev->name); 826 break; 827 } 828 829 caddr = nop.nop_link; 830 ether1_readbuffer (dev, &nop, caddr, NOP_SIZE); 831 if ((nop.nop_command & CMD_MASK) != CMD_NOP) { 832 printk (KERN_ERR "%s: tx buffer chaining error: no nop after tx command\n", dev->name); 833 break; 834 } 835 836 if (caddr == nop.nop_link) 837 break; 838 839 caddr = nop.nop_link; 840 ether1_readbuffer (dev, &nop, caddr, NOP_SIZE); 841 if ((nop.nop_command & CMD_MASK) != CMD_TX) { 842 printk (KERN_ERR "%s: tx buffer chaining error: no tx command after nop\n", dev->name); 843 break; 844 } 845 } 846 priv(dev)->tx_tail = caddr; 847 848 caddr = priv(dev)->tx_head; 849 tst = ether1_txalloc (dev, TX_SIZE + TBD_SIZE + NOP_SIZE + ETH_FRAME_LEN); 850 priv(dev)->tx_head = caddr; 851 if (tst != -1) 852 netif_wake_queue(dev); 853} 854 855static void 856ether1_recv_done (struct net_device *dev) 857{ 858 int status; 859 int nexttail, rbdaddr; 860 rbd_t rbd; 861 862 do { 863 status = ether1_readw(dev, priv(dev)->rx_head, rfd_t, rfd_status, NORMALIRQS); 864 if ((status & RFD_COMPLETE) == 0) 865 break; 866 867 rbdaddr = ether1_readw(dev, priv(dev)->rx_head, rfd_t, rfd_rbdoffset, NORMALIRQS); 868 ether1_readbuffer (dev, &rbd, rbdaddr, RBD_SIZE); 869 870 if ((rbd.rbd_status & (RBD_EOF | RBD_ACNTVALID)) == (RBD_EOF | RBD_ACNTVALID)) { 871 int length = rbd.rbd_status & RBD_ACNT; 872 struct sk_buff *skb; 873 874 length = (length + 1) & ~1; 875 skb = dev_alloc_skb (length + 2); 876 877 if (skb) { 878 skb_reserve (skb, 2); 879 880 ether1_readbuffer (dev, skb_put (skb, length), rbd.rbd_bufl, length); 881 882 skb->protocol = eth_type_trans (skb, dev); 883 netif_rx (skb); 884 priv(dev)->stats.rx_packets ++; 885 } else 886 priv(dev)->stats.rx_dropped ++; 887 } else { 888 printk(KERN_WARNING "%s: %s\n", dev->name, 889 (rbd.rbd_status & RBD_EOF) ? "oversized packet" : "acnt not valid"); 890 priv(dev)->stats.rx_dropped ++; 891 } 892 893 nexttail = ether1_readw(dev, priv(dev)->rx_tail, rfd_t, rfd_link, NORMALIRQS); 894 /* nexttail should be rx_head */ 895 if (nexttail != priv(dev)->rx_head) 896 printk(KERN_ERR "%s: receiver buffer chaining error (%04X != %04X)\n", 897 dev->name, nexttail, priv(dev)->rx_head); 898 ether1_writew(dev, RFD_CMDEL | RFD_CMDSUSPEND, nexttail, rfd_t, rfd_command, NORMALIRQS); 899 ether1_writew(dev, 0, priv(dev)->rx_tail, rfd_t, rfd_command, NORMALIRQS); 900 ether1_writew(dev, 0, priv(dev)->rx_tail, rfd_t, rfd_status, NORMALIRQS); 901 ether1_writew(dev, 0, priv(dev)->rx_tail, rfd_t, rfd_rbdoffset, NORMALIRQS); 902 903 priv(dev)->rx_tail = nexttail; 904 priv(dev)->rx_head = ether1_readw(dev, priv(dev)->rx_head, rfd_t, rfd_link, NORMALIRQS); 905 } while (1); 906} 907 908static irqreturn_t 909ether1_interrupt (int irq, void *dev_id) 910{ 911 struct net_device *dev = (struct net_device *)dev_id; 912 int status; 913 914 status = ether1_readw(dev, SCB_ADDR, scb_t, scb_status, NORMALIRQS); 915 916 if (status) { 917 ether1_writew(dev, status & (SCB_STRNR | SCB_STCNA | SCB_STFR | SCB_STCX), 918 SCB_ADDR, scb_t, scb_command, NORMALIRQS); 919 writeb(CTRL_CA | CTRL_ACK, REG_CONTROL); 920 if (status & SCB_STCX) { 921 ether1_xmit_done (dev); 922 } 923 if (status & SCB_STCNA) { 924 if (priv(dev)->resetting == 0) 925 printk (KERN_WARNING "%s: CU went not ready ???\n", dev->name); 926 else 927 priv(dev)->resetting += 1; 928 if (ether1_readw(dev, SCB_ADDR, scb_t, scb_cbl_offset, NORMALIRQS) 929 != (unsigned short)I82586_NULL) { 930 ether1_writew(dev, SCB_CMDCUCSTART, SCB_ADDR, scb_t, scb_command, NORMALIRQS); 931 writeb(CTRL_CA, REG_CONTROL); 932 } 933 if (priv(dev)->resetting == 2) 934 priv(dev)->resetting = 0; 935 } 936 if (status & SCB_STFR) { 937 ether1_recv_done (dev); 938 } 939 if (status & SCB_STRNR) { 940 if (ether1_readw(dev, SCB_ADDR, scb_t, scb_status, NORMALIRQS) & SCB_STRXSUSP) { 941 printk (KERN_WARNING "%s: RU went not ready: RU suspended\n", dev->name); 942 ether1_writew(dev, SCB_CMDRXRESUME, SCB_ADDR, scb_t, scb_command, NORMALIRQS); 943 writeb(CTRL_CA, REG_CONTROL); 944 priv(dev)->stats.rx_dropped ++; /* we suspended due to lack of buffer space */ 945 } else 946 printk(KERN_WARNING "%s: RU went not ready: %04X\n", dev->name, 947 ether1_readw(dev, SCB_ADDR, scb_t, scb_status, NORMALIRQS)); 948 printk (KERN_WARNING "RU ptr = %04X\n", ether1_readw(dev, SCB_ADDR, scb_t, scb_rfa_offset, 949 NORMALIRQS)); 950 } 951 } else 952 writeb(CTRL_ACK, REG_CONTROL); 953 954 return IRQ_HANDLED; 955} 956 957static int 958ether1_close (struct net_device *dev) 959{ 960 ether1_reset (dev); 961 962 free_irq(dev->irq, dev); 963 964 return 0; 965} 966 967static struct net_device_stats * 968ether1_getstats (struct net_device *dev) 969{ 970 return &priv(dev)->stats; 971} 972 973/* 974 * Set or clear the multicast filter for this adaptor. 975 * num_addrs == -1 Promiscuous mode, receive all packets. 976 * num_addrs == 0 Normal mode, clear multicast list. 977 * num_addrs > 0 Multicast mode, receive normal and MC packets, and do 978 * best-effort filtering. 979 */ 980static void 981ether1_setmulticastlist (struct net_device *dev) 982{ 983} 984 985/* ------------------------------------------------------------------------- */ 986 987static void __devinit ether1_banner(void) 988{ 989 static unsigned int version_printed = 0; 990 991 if (net_debug && version_printed++ == 0) 992 printk(KERN_INFO "%s", version); 993} 994 995static int __devinit 996ether1_probe(struct expansion_card *ec, const struct ecard_id *id) 997{ 998 struct net_device *dev; 999 int i, ret = 0; 1000 1001 ether1_banner(); 1002 1003 ret = ecard_request_resources(ec); 1004 if (ret) 1005 goto out; 1006 1007 dev = alloc_etherdev(sizeof(struct ether1_priv)); 1008 if (!dev) { 1009 ret = -ENOMEM; 1010 goto release; 1011 } 1012 1013 SET_MODULE_OWNER(dev); 1014 SET_NETDEV_DEV(dev, &ec->dev); 1015 1016 dev->irq = ec->irq; 1017 priv(dev)->base = ecardm_iomap(ec, ECARD_RES_IOCFAST, 0, 0); 1018 if (!priv(dev)->base) { 1019 ret = -ENOMEM; 1020 goto free; 1021 } 1022 1023 if ((priv(dev)->bus_type = ether1_reset(dev)) == 0) { 1024 ret = -ENODEV; 1025 goto free; 1026 } 1027 1028 for (i = 0; i < 6; i++) 1029 dev->dev_addr[i] = readb(IDPROM_ADDRESS + (i << 2)); 1030 1031 if (ether1_init_2(dev)) { 1032 ret = -ENODEV; 1033 goto free; 1034 } 1035 1036 dev->open = ether1_open; 1037 dev->stop = ether1_close; 1038 dev->hard_start_xmit = ether1_sendpacket; 1039 dev->get_stats = ether1_getstats; 1040 dev->set_multicast_list = ether1_setmulticastlist; 1041 dev->tx_timeout = ether1_timeout; 1042 dev->watchdog_timeo = 5 * HZ / 100; 1043 1044 ret = register_netdev(dev); 1045 if (ret) 1046 goto free; 1047 1048 printk(KERN_INFO "%s: ether1 in slot %d, ", 1049 dev->name, ec->slot_no); 1050 1051 for (i = 0; i < 6; i++) 1052 printk ("%2.2x%c", dev->dev_addr[i], i == 5 ? '\n' : ':'); 1053 1054 ecard_set_drvdata(ec, dev); 1055 return 0; 1056 1057 free: 1058 free_netdev(dev); 1059 release: 1060 ecard_release_resources(ec); 1061 out: 1062 return ret; 1063} 1064 1065static void __devexit ether1_remove(struct expansion_card *ec) 1066{ 1067 struct net_device *dev = ecard_get_drvdata(ec); 1068 1069 ecard_set_drvdata(ec, NULL); 1070 1071 unregister_netdev(dev); 1072 free_netdev(dev); 1073 ecard_release_resources(ec); 1074} 1075 1076static const struct ecard_id ether1_ids[] = { 1077 { MANU_ACORN, PROD_ACORN_ETHER1 }, 1078 { 0xffff, 0xffff } 1079}; 1080 1081static struct ecard_driver ether1_driver = { 1082 .probe = ether1_probe, 1083 .remove = __devexit_p(ether1_remove), 1084 .id_table = ether1_ids, 1085 .drv = { 1086 .name = "ether1", 1087 }, 1088}; 1089 1090static int __init ether1_init(void) 1091{ 1092 return ecard_register_driver(ðer1_driver); 1093} 1094 1095static void __exit ether1_exit(void) 1096{ 1097 ecard_remove_driver(ðer1_driver); 1098} 1099 1100module_init(ether1_init); 1101module_exit(ether1_exit); 1102 1103MODULE_LICENSE("GPL"); 1104