1/* 2 * Sun3 i82586 Ethernet driver 3 * 4 * Cloned from ni52.c for the Sun3 by Sam Creasey (sammy@sammy.net) 5 * 6 * Original copyright follows: 7 * -------------------------- 8 * 9 * net-3-driver for the NI5210 card (i82586 Ethernet chip) 10 * 11 * This is an extension to the Linux operating system, and is covered by the 12 * same Gnu Public License that covers that work. 13 * 14 * Alphacode 0.82 (96/09/29) for Linux 2.0.0 (or later) 15 * Copyrights (c) 1994,1995,1996 by M.Hipp (hippm@informatik.uni-tuebingen.de) 16 * -------------------------- 17 * 18 * Consult ni52.c for further notes from the original driver. 19 * 20 * This incarnation currently supports the OBIO version of the i82586 chip 21 * used in certain sun3 models. It should be fairly doable to expand this 22 * to support VME if I should every acquire such a board. 23 * 24 */ 25 26static int debuglevel = 0; /* debug-printk 0: off 1: a few 2: more */ 27static int automatic_resume = 0; /* experimental .. better should be zero */ 28static int rfdadd = 0; /* rfdadd=1 may be better for 8K MEM cards */ 29static int fifo=0x8; /* don't change */ 30 31#include <linux/module.h> 32#include <linux/kernel.h> 33#include <linux/string.h> 34#include <linux/errno.h> 35#include <linux/ioport.h> 36#include <linux/interrupt.h> 37#include <linux/delay.h> 38#include <linux/init.h> 39#include <linux/bitops.h> 40#include <asm/io.h> 41#include <asm/idprom.h> 42#include <asm/machines.h> 43#include <asm/sun3mmu.h> 44#include <asm/dvma.h> 45#include <asm/byteorder.h> 46 47#include <linux/netdevice.h> 48#include <linux/etherdevice.h> 49#include <linux/skbuff.h> 50 51#include "sun3_82586.h" 52 53#define DRV_NAME "sun3_82586" 54 55#define DEBUG /* debug on */ 56#define SYSBUSVAL 0 /* 16 Bit */ 57#define SUN3_82586_TOTAL_SIZE PAGE_SIZE 58 59#define sun3_attn586() {*(volatile unsigned char *)(dev->base_addr) |= IEOB_ATTEN; *(volatile unsigned char *)(dev->base_addr) &= ~IEOB_ATTEN;} 60#define sun3_reset586() {*(volatile unsigned char *)(dev->base_addr) = 0; udelay(100); *(volatile unsigned char *)(dev->base_addr) = IEOB_NORSET;} 61#define sun3_disint() {*(volatile unsigned char *)(dev->base_addr) &= ~IEOB_IENAB;} 62#define sun3_enaint() {*(volatile unsigned char *)(dev->base_addr) |= IEOB_IENAB;} 63#define sun3_active() {*(volatile unsigned char *)(dev->base_addr) |= (IEOB_IENAB|IEOB_ONAIR|IEOB_NORSET);} 64 65#define make32(ptr16) (p->memtop + (swab16((unsigned short) (ptr16))) ) 66#define make24(ptr32) (char *)swab32(( ((unsigned long) (ptr32)) - p->base)) 67#define make16(ptr32) (swab16((unsigned short) ((unsigned long)(ptr32) - (unsigned long) p->memtop ))) 68 69/******************* how to calculate the buffers ***************************** 70 71 * IMPORTANT NOTE: if you configure only one NUM_XMIT_BUFFS, the driver works 72 * --------------- in a different (more stable?) mode. Only in this mode it's 73 * possible to configure the driver with 'NO_NOPCOMMANDS' 74 75sizeof(scp)=12; sizeof(scb)=16; sizeof(iscp)=8; 76sizeof(scp)+sizeof(iscp)+sizeof(scb) = 36 = INIT 77sizeof(rfd) = 24; sizeof(rbd) = 12; 78sizeof(tbd) = 8; sizeof(transmit_cmd) = 16; 79sizeof(nop_cmd) = 8; 80 81 * if you don't know the driver, better do not change these values: */ 82 83#define RECV_BUFF_SIZE 1536 /* slightly oversized */ 84#define XMIT_BUFF_SIZE 1536 /* slightly oversized */ 85#define NUM_XMIT_BUFFS 1 /* config for 32K shmem */ 86#define NUM_RECV_BUFFS_8 4 /* config for 32K shared mem */ 87#define NUM_RECV_BUFFS_16 9 /* config for 32K shared mem */ 88#define NUM_RECV_BUFFS_32 16 /* config for 32K shared mem */ 89#define NO_NOPCOMMANDS /* only possible with NUM_XMIT_BUFFS=1 */ 90 91/**************************************************************************/ 92 93/* different DELAYs */ 94#define DELAY(x) mdelay(32 * x); 95#define DELAY_16(); { udelay(16); } 96#define DELAY_18(); { udelay(4); } 97 98/* wait for command with timeout: */ 99#define WAIT_4_SCB_CMD() \ 100{ int i; \ 101 for(i=0;i<16384;i++) { \ 102 if(!p->scb->cmd_cuc) break; \ 103 DELAY_18(); \ 104 if(i == 16383) { \ 105 printk("%s: scb_cmd timed out: %04x,%04x .. disabling i82586!!\n",dev->name,p->scb->cmd_cuc,p->scb->cus); \ 106 if(!p->reseted) { p->reseted = 1; sun3_reset586(); } } } } 107 108#define WAIT_4_SCB_CMD_RUC() { int i; \ 109 for(i=0;i<16384;i++) { \ 110 if(!p->scb->cmd_ruc) break; \ 111 DELAY_18(); \ 112 if(i == 16383) { \ 113 printk("%s: scb_cmd (ruc) timed out: %04x,%04x .. disabling i82586!!\n",dev->name,p->scb->cmd_ruc,p->scb->rus); \ 114 if(!p->reseted) { p->reseted = 1; sun3_reset586(); } } } } 115 116#define WAIT_4_STAT_COMPL(addr) { int i; \ 117 for(i=0;i<32767;i++) { \ 118 if(swab16((addr)->cmd_status) & STAT_COMPL) break; \ 119 DELAY_16(); DELAY_16(); } } 120 121static int sun3_82586_probe1(struct net_device *dev,int ioaddr); 122static irqreturn_t sun3_82586_interrupt(int irq,void *dev_id); 123static int sun3_82586_open(struct net_device *dev); 124static int sun3_82586_close(struct net_device *dev); 125static int sun3_82586_send_packet(struct sk_buff *,struct net_device *); 126static struct net_device_stats *sun3_82586_get_stats(struct net_device *dev); 127static void set_multicast_list(struct net_device *dev); 128static void sun3_82586_timeout(struct net_device *dev); 129 130/* helper-functions */ 131static int init586(struct net_device *dev); 132static int check586(struct net_device *dev,char *where,unsigned size); 133static void alloc586(struct net_device *dev); 134static void startrecv586(struct net_device *dev); 135static void *alloc_rfa(struct net_device *dev,void *ptr); 136static void sun3_82586_rcv_int(struct net_device *dev); 137static void sun3_82586_xmt_int(struct net_device *dev); 138static void sun3_82586_rnr_int(struct net_device *dev); 139 140struct priv 141{ 142 unsigned long base; 143 char *memtop; 144 long int lock; 145 int reseted; 146 volatile struct rfd_struct *rfd_last,*rfd_top,*rfd_first; 147 volatile struct scp_struct *scp; /* volatile is important */ 148 volatile struct iscp_struct *iscp; /* volatile is important */ 149 volatile struct scb_struct *scb; /* volatile is important */ 150 volatile struct tbd_struct *xmit_buffs[NUM_XMIT_BUFFS]; 151 volatile struct transmit_cmd_struct *xmit_cmds[NUM_XMIT_BUFFS]; 152#if (NUM_XMIT_BUFFS == 1) 153 volatile struct nop_cmd_struct *nop_cmds[2]; 154#else 155 volatile struct nop_cmd_struct *nop_cmds[NUM_XMIT_BUFFS]; 156#endif 157 volatile int nop_point,num_recv_buffs; 158 volatile char *xmit_cbuffs[NUM_XMIT_BUFFS]; 159 volatile int xmit_count,xmit_last; 160}; 161 162/********************************************** 163 * close device 164 */ 165static int sun3_82586_close(struct net_device *dev) 166{ 167 free_irq(dev->irq, dev); 168 169 sun3_reset586(); /* the hard way to stop the receiver */ 170 171 netif_stop_queue(dev); 172 173 return 0; 174} 175 176/********************************************** 177 * open device 178 */ 179static int sun3_82586_open(struct net_device *dev) 180{ 181 int ret; 182 183 sun3_disint(); 184 alloc586(dev); 185 init586(dev); 186 startrecv586(dev); 187 sun3_enaint(); 188 189 ret = request_irq(dev->irq, sun3_82586_interrupt,0,dev->name,dev); 190 if (ret) 191 { 192 sun3_reset586(); 193 return ret; 194 } 195 196 netif_start_queue(dev); 197 198 return 0; /* most done by init */ 199} 200 201/********************************************** 202 * Check to see if there's an 82586 out there. 203 */ 204static int check586(struct net_device *dev,char *where,unsigned size) 205{ 206 struct priv pb; 207 struct priv *p = &pb; 208 char *iscp_addr; 209 int i; 210 211 p->base = (unsigned long) dvma_btov(0); 212 p->memtop = (char *)dvma_btov((unsigned long)where); 213 p->scp = (struct scp_struct *)(p->base + SCP_DEFAULT_ADDRESS); 214 memset((char *)p->scp,0, sizeof(struct scp_struct)); 215 for(i=0;i<sizeof(struct scp_struct);i++) /* memory was writeable? */ 216 if(((char *)p->scp)[i]) 217 return 0; 218 p->scp->sysbus = SYSBUSVAL; /* 1 = 8Bit-Bus, 0 = 16 Bit */ 219 if(p->scp->sysbus != SYSBUSVAL) 220 return 0; 221 222 iscp_addr = (char *)dvma_btov((unsigned long)where); 223 224 p->iscp = (struct iscp_struct *) iscp_addr; 225 memset((char *)p->iscp,0, sizeof(struct iscp_struct)); 226 227 p->scp->iscp = make24(p->iscp); 228 p->iscp->busy = 1; 229 230 sun3_reset586(); 231 sun3_attn586(); 232 DELAY(1); /* wait a while... */ 233 234 if(p->iscp->busy) /* i82586 clears 'busy' after successful init */ 235 return 0; 236 237 return 1; 238} 239 240/****************************************************************** 241 * set iscp at the right place, called by sun3_82586_probe1 and open586. 242 */ 243static void alloc586(struct net_device *dev) 244{ 245 struct priv *p = netdev_priv(dev); 246 247 sun3_reset586(); 248 DELAY(1); 249 250 p->scp = (struct scp_struct *) (p->base + SCP_DEFAULT_ADDRESS); 251 p->iscp = (struct iscp_struct *) dvma_btov(dev->mem_start); 252 p->scb = (struct scb_struct *) ((char *)p->iscp + sizeof(struct iscp_struct)); 253 254 memset((char *) p->iscp,0,sizeof(struct iscp_struct)); 255 memset((char *) p->scp ,0,sizeof(struct scp_struct)); 256 257 p->scp->iscp = make24(p->iscp); 258 p->scp->sysbus = SYSBUSVAL; 259 p->iscp->scb_offset = make16(p->scb); 260 p->iscp->scb_base = make24(dvma_btov(dev->mem_start)); 261 262 p->iscp->busy = 1; 263 sun3_reset586(); 264 sun3_attn586(); 265 266 DELAY(1); 267 268 if(p->iscp->busy) 269 printk("%s: Init-Problems (alloc).\n",dev->name); 270 271 p->reseted = 0; 272 273 memset((char *)p->scb,0,sizeof(struct scb_struct)); 274} 275 276struct net_device * __init sun3_82586_probe(int unit) 277{ 278 struct net_device *dev; 279 unsigned long ioaddr; 280 static int found = 0; 281 int err = -ENOMEM; 282 283 /* check that this machine has an onboard 82586 */ 284 switch(idprom->id_machtype) { 285 case SM_SUN3|SM_3_160: 286 case SM_SUN3|SM_3_260: 287 /* these machines have 82586 */ 288 break; 289 290 default: 291 return ERR_PTR(-ENODEV); 292 } 293 294 if (found) 295 return ERR_PTR(-ENODEV); 296 297 ioaddr = (unsigned long)ioremap(IE_OBIO, SUN3_82586_TOTAL_SIZE); 298 if (!ioaddr) 299 return ERR_PTR(-ENOMEM); 300 found = 1; 301 302 dev = alloc_etherdev(sizeof(struct priv)); 303 if (!dev) 304 goto out; 305 if (unit >= 0) { 306 sprintf(dev->name, "eth%d", unit); 307 netdev_boot_setup_check(dev); 308 } 309 310 dev->irq = IE_IRQ; 311 dev->base_addr = ioaddr; 312 err = sun3_82586_probe1(dev, ioaddr); 313 if (err) 314 goto out1; 315 err = register_netdev(dev); 316 if (err) 317 goto out2; 318 return dev; 319 320out2: 321 release_region(ioaddr, SUN3_82586_TOTAL_SIZE); 322out1: 323 free_netdev(dev); 324out: 325 iounmap((void __iomem *)ioaddr); 326 return ERR_PTR(err); 327} 328 329static const struct net_device_ops sun3_82586_netdev_ops = { 330 .ndo_open = sun3_82586_open, 331 .ndo_stop = sun3_82586_close, 332 .ndo_start_xmit = sun3_82586_send_packet, 333 .ndo_set_multicast_list = set_multicast_list, 334 .ndo_tx_timeout = sun3_82586_timeout, 335 .ndo_get_stats = sun3_82586_get_stats, 336 .ndo_validate_addr = eth_validate_addr, 337 .ndo_set_mac_address = eth_mac_addr, 338 .ndo_change_mtu = eth_change_mtu, 339}; 340 341static int __init sun3_82586_probe1(struct net_device *dev,int ioaddr) 342{ 343 int i, size, retval; 344 345 if (!request_region(ioaddr, SUN3_82586_TOTAL_SIZE, DRV_NAME)) 346 return -EBUSY; 347 348 /* copy in the ethernet address from the prom */ 349 for(i = 0; i < 6 ; i++) 350 dev->dev_addr[i] = idprom->id_ethaddr[i]; 351 352 printk("%s: SUN3 Intel 82586 found at %lx, ",dev->name,dev->base_addr); 353 354 /* 355 * check (or search) IO-Memory, 32K 356 */ 357 size = 0x8000; 358 359 dev->mem_start = (unsigned long)dvma_malloc_align(0x8000, 0x1000); 360 dev->mem_end = dev->mem_start + size; 361 362 if(size != 0x2000 && size != 0x4000 && size != 0x8000) { 363 printk("\n%s: Illegal memory size %d. Allowed is 0x2000 or 0x4000 or 0x8000 bytes.\n",dev->name,size); 364 retval = -ENODEV; 365 goto out; 366 } 367 if(!check586(dev,(char *) dev->mem_start,size)) { 368 printk("?memcheck, Can't find memory at 0x%lx with size %d!\n",dev->mem_start,size); 369 retval = -ENODEV; 370 goto out; 371 } 372 373 ((struct priv *)netdev_priv(dev))->memtop = 374 (char *)dvma_btov(dev->mem_start); 375 ((struct priv *)netdev_priv(dev))->base = (unsigned long) dvma_btov(0); 376 alloc586(dev); 377 378 /* set number of receive-buffs according to memsize */ 379 if(size == 0x2000) 380 ((struct priv *)netdev_priv(dev))->num_recv_buffs = 381 NUM_RECV_BUFFS_8; 382 else if(size == 0x4000) 383 ((struct priv *)netdev_priv(dev))->num_recv_buffs = 384 NUM_RECV_BUFFS_16; 385 else 386 ((struct priv *)netdev_priv(dev))->num_recv_buffs = 387 NUM_RECV_BUFFS_32; 388 389 printk("Memaddr: 0x%lx, Memsize: %d, IRQ %d\n",dev->mem_start,size, dev->irq); 390 391 dev->netdev_ops = &sun3_82586_netdev_ops; 392 dev->watchdog_timeo = HZ/20; 393 394 dev->if_port = 0; 395 return 0; 396out: 397 release_region(ioaddr, SUN3_82586_TOTAL_SIZE); 398 return retval; 399} 400 401 402static int init586(struct net_device *dev) 403{ 404 void *ptr; 405 int i,result=0; 406 struct priv *p = netdev_priv(dev); 407 volatile struct configure_cmd_struct *cfg_cmd; 408 volatile struct iasetup_cmd_struct *ias_cmd; 409 volatile struct tdr_cmd_struct *tdr_cmd; 410 volatile struct mcsetup_cmd_struct *mc_cmd; 411 struct netdev_hw_addr *ha; 412 int num_addrs=netdev_mc_count(dev); 413 414 ptr = (void *) ((char *)p->scb + sizeof(struct scb_struct)); 415 416 cfg_cmd = (struct configure_cmd_struct *)ptr; /* configure-command */ 417 cfg_cmd->cmd_status = 0; 418 cfg_cmd->cmd_cmd = swab16(CMD_CONFIGURE | CMD_LAST); 419 cfg_cmd->cmd_link = 0xffff; 420 421 cfg_cmd->byte_cnt = 0x0a; /* number of cfg bytes */ 422 cfg_cmd->fifo = fifo; /* fifo-limit (8=tx:32/rx:64) */ 423 cfg_cmd->sav_bf = 0x40; /* hold or discard bad recv frames (bit 7) */ 424 cfg_cmd->adr_len = 0x2e; /* addr_len |!src_insert |pre-len |loopback */ 425 cfg_cmd->priority = 0x00; 426 cfg_cmd->ifs = 0x60; 427 cfg_cmd->time_low = 0x00; 428 cfg_cmd->time_high = 0xf2; 429 cfg_cmd->promisc = 0; 430 if(dev->flags & IFF_ALLMULTI) { 431 int len = ((char *) p->iscp - (char *) ptr - 8) / 6; 432 if(num_addrs > len) { 433 printk("%s: switching to promisc. mode\n",dev->name); 434 cfg_cmd->promisc = 1; 435 } 436 } 437 if(dev->flags&IFF_PROMISC) 438 cfg_cmd->promisc = 1; 439 cfg_cmd->carr_coll = 0x00; 440 441 p->scb->cbl_offset = make16(cfg_cmd); 442 p->scb->cmd_ruc = 0; 443 444 p->scb->cmd_cuc = CUC_START; /* cmd.-unit start */ 445 sun3_attn586(); 446 447 WAIT_4_STAT_COMPL(cfg_cmd); 448 449 if((swab16(cfg_cmd->cmd_status) & (STAT_OK|STAT_COMPL)) != (STAT_COMPL|STAT_OK)) 450 { 451 printk("%s: configure command failed: %x\n",dev->name,swab16(cfg_cmd->cmd_status)); 452 return 1; 453 } 454 455 /* 456 * individual address setup 457 */ 458 459 ias_cmd = (struct iasetup_cmd_struct *)ptr; 460 461 ias_cmd->cmd_status = 0; 462 ias_cmd->cmd_cmd = swab16(CMD_IASETUP | CMD_LAST); 463 ias_cmd->cmd_link = 0xffff; 464 465 memcpy((char *)&ias_cmd->iaddr,(char *) dev->dev_addr,ETH_ALEN); 466 467 p->scb->cbl_offset = make16(ias_cmd); 468 469 p->scb->cmd_cuc = CUC_START; /* cmd.-unit start */ 470 sun3_attn586(); 471 472 WAIT_4_STAT_COMPL(ias_cmd); 473 474 if((swab16(ias_cmd->cmd_status) & (STAT_OK|STAT_COMPL)) != (STAT_OK|STAT_COMPL)) { 475 printk("%s (82586): individual address setup command failed: %04x\n",dev->name,swab16(ias_cmd->cmd_status)); 476 return 1; 477 } 478 479 /* 480 * TDR, wire check .. e.g. no resistor e.t.c 481 */ 482 483 tdr_cmd = (struct tdr_cmd_struct *)ptr; 484 485 tdr_cmd->cmd_status = 0; 486 tdr_cmd->cmd_cmd = swab16(CMD_TDR | CMD_LAST); 487 tdr_cmd->cmd_link = 0xffff; 488 tdr_cmd->status = 0; 489 490 p->scb->cbl_offset = make16(tdr_cmd); 491 p->scb->cmd_cuc = CUC_START; /* cmd.-unit start */ 492 sun3_attn586(); 493 494 WAIT_4_STAT_COMPL(tdr_cmd); 495 496 if(!(swab16(tdr_cmd->cmd_status) & STAT_COMPL)) 497 { 498 printk("%s: Problems while running the TDR.\n",dev->name); 499 } 500 else 501 { 502 DELAY_16(); /* wait for result */ 503 result = swab16(tdr_cmd->status); 504 505 p->scb->cmd_cuc = p->scb->cus & STAT_MASK; 506 sun3_attn586(); /* ack the interrupts */ 507 508 if(result & TDR_LNK_OK) 509 ; 510 else if(result & TDR_XCVR_PRB) 511 printk("%s: TDR: Transceiver problem. Check the cable(s)!\n",dev->name); 512 else if(result & TDR_ET_OPN) 513 printk("%s: TDR: No correct termination %d clocks away.\n",dev->name,result & TDR_TIMEMASK); 514 else if(result & TDR_ET_SRT) 515 { 516 if (result & TDR_TIMEMASK) /* time == 0 -> strange :-) */ 517 printk("%s: TDR: Detected a short circuit %d clocks away.\n",dev->name,result & TDR_TIMEMASK); 518 } 519 else 520 printk("%s: TDR: Unknown status %04x\n",dev->name,result); 521 } 522 523 /* 524 * Multicast setup 525 */ 526 if(num_addrs && !(dev->flags & IFF_PROMISC) ) 527 { 528 mc_cmd = (struct mcsetup_cmd_struct *) ptr; 529 mc_cmd->cmd_status = 0; 530 mc_cmd->cmd_cmd = swab16(CMD_MCSETUP | CMD_LAST); 531 mc_cmd->cmd_link = 0xffff; 532 mc_cmd->mc_cnt = swab16(num_addrs * 6); 533 534 i = 0; 535 netdev_for_each_mc_addr(ha, dev) 536 memcpy((char *) mc_cmd->mc_list[i++], 537 ha->addr, ETH_ALEN); 538 539 p->scb->cbl_offset = make16(mc_cmd); 540 p->scb->cmd_cuc = CUC_START; 541 sun3_attn586(); 542 543 WAIT_4_STAT_COMPL(mc_cmd); 544 545 if( (swab16(mc_cmd->cmd_status) & (STAT_COMPL|STAT_OK)) != (STAT_COMPL|STAT_OK) ) 546 printk("%s: Can't apply multicast-address-list.\n",dev->name); 547 } 548 549 /* 550 * alloc nop/xmit-cmds 551 */ 552#if (NUM_XMIT_BUFFS == 1) 553 for(i=0;i<2;i++) 554 { 555 p->nop_cmds[i] = (struct nop_cmd_struct *)ptr; 556 p->nop_cmds[i]->cmd_cmd = swab16(CMD_NOP); 557 p->nop_cmds[i]->cmd_status = 0; 558 p->nop_cmds[i]->cmd_link = make16((p->nop_cmds[i])); 559 ptr = (char *) ptr + sizeof(struct nop_cmd_struct); 560 } 561#else 562 for(i=0;i<NUM_XMIT_BUFFS;i++) 563 { 564 p->nop_cmds[i] = (struct nop_cmd_struct *)ptr; 565 p->nop_cmds[i]->cmd_cmd = swab16(CMD_NOP); 566 p->nop_cmds[i]->cmd_status = 0; 567 p->nop_cmds[i]->cmd_link = make16((p->nop_cmds[i])); 568 ptr = (char *) ptr + sizeof(struct nop_cmd_struct); 569 } 570#endif 571 572 ptr = alloc_rfa(dev,(void *)ptr); /* init receive-frame-area */ 573 574 /* 575 * alloc xmit-buffs / init xmit_cmds 576 */ 577 for(i=0;i<NUM_XMIT_BUFFS;i++) 578 { 579 p->xmit_cmds[i] = (struct transmit_cmd_struct *)ptr; /*transmit cmd/buff 0*/ 580 ptr = (char *) ptr + sizeof(struct transmit_cmd_struct); 581 p->xmit_cbuffs[i] = (char *)ptr; /* char-buffs */ 582 ptr = (char *) ptr + XMIT_BUFF_SIZE; 583 p->xmit_buffs[i] = (struct tbd_struct *)ptr; /* TBD */ 584 ptr = (char *) ptr + sizeof(struct tbd_struct); 585 if((void *)ptr > (void *)dev->mem_end) 586 { 587 printk("%s: not enough shared-mem for your configuration!\n",dev->name); 588 return 1; 589 } 590 memset((char *)(p->xmit_cmds[i]) ,0, sizeof(struct transmit_cmd_struct)); 591 memset((char *)(p->xmit_buffs[i]),0, sizeof(struct tbd_struct)); 592 p->xmit_cmds[i]->cmd_link = make16(p->nop_cmds[(i+1)%NUM_XMIT_BUFFS]); 593 p->xmit_cmds[i]->cmd_status = swab16(STAT_COMPL); 594 p->xmit_cmds[i]->cmd_cmd = swab16(CMD_XMIT | CMD_INT); 595 p->xmit_cmds[i]->tbd_offset = make16((p->xmit_buffs[i])); 596 p->xmit_buffs[i]->next = 0xffff; 597 p->xmit_buffs[i]->buffer = make24((p->xmit_cbuffs[i])); 598 } 599 600 p->xmit_count = 0; 601 p->xmit_last = 0; 602#ifndef NO_NOPCOMMANDS 603 p->nop_point = 0; 604#endif 605 606 /* 607 * 'start transmitter' 608 */ 609#ifndef NO_NOPCOMMANDS 610 p->scb->cbl_offset = make16(p->nop_cmds[0]); 611 p->scb->cmd_cuc = CUC_START; 612 sun3_attn586(); 613 WAIT_4_SCB_CMD(); 614#else 615 p->xmit_cmds[0]->cmd_link = make16(p->xmit_cmds[0]); 616 p->xmit_cmds[0]->cmd_cmd = swab16(CMD_XMIT | CMD_SUSPEND | CMD_INT); 617#endif 618 619 /* 620 * ack. interrupts 621 */ 622 p->scb->cmd_cuc = p->scb->cus & STAT_MASK; 623 sun3_attn586(); 624 DELAY_16(); 625 626 sun3_enaint(); 627 sun3_active(); 628 629 return 0; 630} 631 632/****************************************************** 633 * This is a helper routine for sun3_82586_rnr_int() and init586(). 634 * It sets up the Receive Frame Area (RFA). 635 */ 636 637static void *alloc_rfa(struct net_device *dev,void *ptr) 638{ 639 volatile struct rfd_struct *rfd = (struct rfd_struct *)ptr; 640 volatile struct rbd_struct *rbd; 641 int i; 642 struct priv *p = netdev_priv(dev); 643 644 memset((char *) rfd,0,sizeof(struct rfd_struct)*(p->num_recv_buffs+rfdadd)); 645 p->rfd_first = rfd; 646 647 for(i = 0; i < (p->num_recv_buffs+rfdadd); i++) { 648 rfd[i].next = make16(rfd + (i+1) % (p->num_recv_buffs+rfdadd) ); 649 rfd[i].rbd_offset = 0xffff; 650 } 651 rfd[p->num_recv_buffs-1+rfdadd].last = RFD_SUSP; /* RU suspend */ 652 653 ptr = (void *) (rfd + (p->num_recv_buffs + rfdadd) ); 654 655 rbd = (struct rbd_struct *) ptr; 656 ptr = (void *) (rbd + p->num_recv_buffs); 657 658 /* clr descriptors */ 659 memset((char *) rbd,0,sizeof(struct rbd_struct)*(p->num_recv_buffs)); 660 661 for(i=0;i<p->num_recv_buffs;i++) 662 { 663 rbd[i].next = make16((rbd + (i+1) % p->num_recv_buffs)); 664 rbd[i].size = swab16(RECV_BUFF_SIZE); 665 rbd[i].buffer = make24(ptr); 666 ptr = (char *) ptr + RECV_BUFF_SIZE; 667 } 668 669 p->rfd_top = p->rfd_first; 670 p->rfd_last = p->rfd_first + (p->num_recv_buffs - 1 + rfdadd); 671 672 p->scb->rfa_offset = make16(p->rfd_first); 673 p->rfd_first->rbd_offset = make16(rbd); 674 675 return ptr; 676} 677 678 679/************************************************** 680 * Interrupt Handler ... 681 */ 682 683static irqreturn_t sun3_82586_interrupt(int irq,void *dev_id) 684{ 685 struct net_device *dev = dev_id; 686 unsigned short stat; 687 int cnt=0; 688 struct priv *p; 689 690 if (!dev) { 691 printk ("sun3_82586-interrupt: irq %d for unknown device.\n",irq); 692 return IRQ_NONE; 693 } 694 p = netdev_priv(dev); 695 696 if(debuglevel > 1) 697 printk("I"); 698 699 WAIT_4_SCB_CMD(); /* wait for last command */ 700 701 while((stat=p->scb->cus & STAT_MASK)) 702 { 703 p->scb->cmd_cuc = stat; 704 sun3_attn586(); 705 706 if(stat & STAT_FR) /* received a frame */ 707 sun3_82586_rcv_int(dev); 708 709 if(stat & STAT_RNR) /* RU went 'not ready' */ 710 { 711 printk("(R)"); 712 if(p->scb->rus & RU_SUSPEND) /* special case: RU_SUSPEND */ 713 { 714 WAIT_4_SCB_CMD(); 715 p->scb->cmd_ruc = RUC_RESUME; 716 sun3_attn586(); 717 WAIT_4_SCB_CMD_RUC(); 718 } 719 else 720 { 721 printk("%s: Receiver-Unit went 'NOT READY': %04x/%02x.\n",dev->name,(int) stat,(int) p->scb->rus); 722 sun3_82586_rnr_int(dev); 723 } 724 } 725 726 if(stat & STAT_CX) /* command with I-bit set complete */ 727 sun3_82586_xmt_int(dev); 728 729#ifndef NO_NOPCOMMANDS 730 if(stat & STAT_CNA) /* CU went 'not ready' */ 731 { 732 if(netif_running(dev)) 733 printk("%s: oops! CU has left active state. stat: %04x/%02x.\n",dev->name,(int) stat,(int) p->scb->cus); 734 } 735#endif 736 737 if(debuglevel > 1) 738 printk("%d",cnt++); 739 740 WAIT_4_SCB_CMD(); /* wait for ack. (sun3_82586_xmt_int can be faster than ack!!) */ 741 if(p->scb->cmd_cuc) /* timed out? */ 742 { 743 printk("%s: Acknowledge timed out.\n",dev->name); 744 sun3_disint(); 745 break; 746 } 747 } 748 749 if(debuglevel > 1) 750 printk("i"); 751 return IRQ_HANDLED; 752} 753 754/******************************************************* 755 * receive-interrupt 756 */ 757 758static void sun3_82586_rcv_int(struct net_device *dev) 759{ 760 int status,cnt=0; 761 unsigned short totlen; 762 struct sk_buff *skb; 763 struct rbd_struct *rbd; 764 struct priv *p = netdev_priv(dev); 765 766 if(debuglevel > 0) 767 printk("R"); 768 769 for(;(status = p->rfd_top->stat_high) & RFD_COMPL;) 770 { 771 rbd = (struct rbd_struct *) make32(p->rfd_top->rbd_offset); 772 773 if(status & RFD_OK) /* frame received without error? */ 774 { 775 if( (totlen = swab16(rbd->status)) & RBD_LAST) /* the first and the last buffer? */ 776 { 777 totlen &= RBD_MASK; /* length of this frame */ 778 rbd->status = 0; 779 skb = (struct sk_buff *) dev_alloc_skb(totlen+2); 780 if(skb != NULL) 781 { 782 skb_reserve(skb,2); 783 skb_put(skb,totlen); 784 skb_copy_to_linear_data(skb,(char *) p->base+swab32((unsigned long) rbd->buffer),totlen); 785 skb->protocol=eth_type_trans(skb,dev); 786 netif_rx(skb); 787 dev->stats.rx_packets++; 788 } 789 else 790 dev->stats.rx_dropped++; 791 } 792 else 793 { 794 int rstat; 795 /* free all RBD's until RBD_LAST is set */ 796 totlen = 0; 797 while(!((rstat=swab16(rbd->status)) & RBD_LAST)) 798 { 799 totlen += rstat & RBD_MASK; 800 if(!rstat) 801 { 802 printk("%s: Whoops .. no end mark in RBD list\n",dev->name); 803 break; 804 } 805 rbd->status = 0; 806 rbd = (struct rbd_struct *) make32(rbd->next); 807 } 808 totlen += rstat & RBD_MASK; 809 rbd->status = 0; 810 printk("%s: received oversized frame! length: %d\n",dev->name,totlen); 811 dev->stats.rx_dropped++; 812 } 813 } 814 else /* frame !(ok), only with 'save-bad-frames' */ 815 { 816 printk("%s: oops! rfd-error-status: %04x\n",dev->name,status); 817 dev->stats.rx_errors++; 818 } 819 p->rfd_top->stat_high = 0; 820 p->rfd_top->last = RFD_SUSP; /* maybe exchange by RFD_LAST */ 821 p->rfd_top->rbd_offset = 0xffff; 822 p->rfd_last->last = 0; /* delete RFD_SUSP */ 823 p->rfd_last = p->rfd_top; 824 p->rfd_top = (struct rfd_struct *) make32(p->rfd_top->next); /* step to next RFD */ 825 p->scb->rfa_offset = make16(p->rfd_top); 826 827 if(debuglevel > 0) 828 printk("%d",cnt++); 829 } 830 831 if(automatic_resume) 832 { 833 WAIT_4_SCB_CMD(); 834 p->scb->cmd_ruc = RUC_RESUME; 835 sun3_attn586(); 836 WAIT_4_SCB_CMD_RUC(); 837 } 838 839#ifdef WAIT_4_BUSY 840 { 841 int i; 842 for(i=0;i<1024;i++) 843 { 844 if(p->rfd_top->status) 845 break; 846 DELAY_16(); 847 if(i == 1023) 848 printk("%s: RU hasn't fetched next RFD (not busy/complete)\n",dev->name); 849 } 850 } 851#endif 852 853 854 if(debuglevel > 0) 855 printk("r"); 856} 857 858/********************************************************** 859 * handle 'Receiver went not ready'. 860 */ 861 862static void sun3_82586_rnr_int(struct net_device *dev) 863{ 864 struct priv *p = netdev_priv(dev); 865 866 dev->stats.rx_errors++; 867 868 WAIT_4_SCB_CMD(); /* wait for the last cmd, WAIT_4_FULLSTAT?? */ 869 p->scb->cmd_ruc = RUC_ABORT; /* usually the RU is in the 'no resource'-state .. abort it now. */ 870 sun3_attn586(); 871 WAIT_4_SCB_CMD_RUC(); /* wait for accept cmd. */ 872 873 alloc_rfa(dev,(char *)p->rfd_first); 874/* maybe add a check here, before restarting the RU */ 875 startrecv586(dev); /* restart RU */ 876 877 printk("%s: Receive-Unit restarted. Status: %04x\n",dev->name,p->scb->rus); 878 879} 880 881/********************************************************** 882 * handle xmit - interrupt 883 */ 884 885static void sun3_82586_xmt_int(struct net_device *dev) 886{ 887 int status; 888 struct priv *p = netdev_priv(dev); 889 890 if(debuglevel > 0) 891 printk("X"); 892 893 status = swab16(p->xmit_cmds[p->xmit_last]->cmd_status); 894 if(!(status & STAT_COMPL)) 895 printk("%s: strange .. xmit-int without a 'COMPLETE'\n",dev->name); 896 897 if(status & STAT_OK) 898 { 899 dev->stats.tx_packets++; 900 dev->stats.collisions += (status & TCMD_MAXCOLLMASK); 901 } 902 else 903 { 904 dev->stats.tx_errors++; 905 if(status & TCMD_LATECOLL) { 906 printk("%s: late collision detected.\n",dev->name); 907 dev->stats.collisions++; 908 } 909 else if(status & TCMD_NOCARRIER) { 910 dev->stats.tx_carrier_errors++; 911 printk("%s: no carrier detected.\n",dev->name); 912 } 913 else if(status & TCMD_LOSTCTS) 914 printk("%s: loss of CTS detected.\n",dev->name); 915 else if(status & TCMD_UNDERRUN) { 916 dev->stats.tx_fifo_errors++; 917 printk("%s: DMA underrun detected.\n",dev->name); 918 } 919 else if(status & TCMD_MAXCOLL) { 920 printk("%s: Max. collisions exceeded.\n",dev->name); 921 dev->stats.collisions += 16; 922 } 923 } 924 925#if (NUM_XMIT_BUFFS > 1) 926 if( (++p->xmit_last) == NUM_XMIT_BUFFS) 927 p->xmit_last = 0; 928#endif 929 netif_wake_queue(dev); 930} 931 932/*********************************************************** 933 * (re)start the receiver 934 */ 935 936static void startrecv586(struct net_device *dev) 937{ 938 struct priv *p = netdev_priv(dev); 939 940 WAIT_4_SCB_CMD(); 941 WAIT_4_SCB_CMD_RUC(); 942 p->scb->rfa_offset = make16(p->rfd_first); 943 p->scb->cmd_ruc = RUC_START; 944 sun3_attn586(); /* start cmd. */ 945 WAIT_4_SCB_CMD_RUC(); /* wait for accept cmd. (no timeout!!) */ 946} 947 948static void sun3_82586_timeout(struct net_device *dev) 949{ 950 struct priv *p = netdev_priv(dev); 951#ifndef NO_NOPCOMMANDS 952 if(p->scb->cus & CU_ACTIVE) /* COMMAND-UNIT active? */ 953 { 954 netif_wake_queue(dev); 955#ifdef DEBUG 956 printk("%s: strange ... timeout with CU active?!?\n",dev->name); 957 printk("%s: X0: %04x N0: %04x N1: %04x %d\n",dev->name,(int)swab16(p->xmit_cmds[0]->cmd_status),(int)swab16(p->nop_cmds[0]->cmd_status),(int)swab16(p->nop_cmds[1]->cmd_status),(int)p->nop_point); 958#endif 959 p->scb->cmd_cuc = CUC_ABORT; 960 sun3_attn586(); 961 WAIT_4_SCB_CMD(); 962 p->scb->cbl_offset = make16(p->nop_cmds[p->nop_point]); 963 p->scb->cmd_cuc = CUC_START; 964 sun3_attn586(); 965 WAIT_4_SCB_CMD(); 966 dev->trans_start = jiffies; /* prevent tx timeout */ 967 return 0; 968 } 969#endif 970 { 971#ifdef DEBUG 972 printk("%s: xmitter timed out, try to restart! stat: %02x\n",dev->name,p->scb->cus); 973 printk("%s: command-stats: %04x %04x\n",dev->name,swab16(p->xmit_cmds[0]->cmd_status),swab16(p->xmit_cmds[1]->cmd_status)); 974 printk("%s: check, whether you set the right interrupt number!\n",dev->name); 975#endif 976 sun3_82586_close(dev); 977 sun3_82586_open(dev); 978 } 979 dev->trans_start = jiffies; /* prevent tx timeout */ 980} 981 982/****************************************************** 983 * send frame 984 */ 985 986static int sun3_82586_send_packet(struct sk_buff *skb, struct net_device *dev) 987{ 988 int len,i; 989#ifndef NO_NOPCOMMANDS 990 int next_nop; 991#endif 992 struct priv *p = netdev_priv(dev); 993 994 if(skb->len > XMIT_BUFF_SIZE) 995 { 996 printk("%s: Sorry, max. framelength is %d bytes. The length of your frame is %d bytes.\n",dev->name,XMIT_BUFF_SIZE,skb->len); 997 return NETDEV_TX_OK; 998 } 999 1000 netif_stop_queue(dev); 1001 1002#if(NUM_XMIT_BUFFS > 1) 1003 if(test_and_set_bit(0,(void *) &p->lock)) { 1004 printk("%s: Queue was locked\n",dev->name); 1005 return NETDEV_TX_BUSY; 1006 } 1007 else 1008#endif 1009 { 1010 len = skb->len; 1011 if (len < ETH_ZLEN) { 1012 memset((void *)p->xmit_cbuffs[p->xmit_count], 0, 1013 ETH_ZLEN); 1014 len = ETH_ZLEN; 1015 } 1016 skb_copy_from_linear_data(skb, (void *)p->xmit_cbuffs[p->xmit_count], skb->len); 1017 1018#if (NUM_XMIT_BUFFS == 1) 1019# ifdef NO_NOPCOMMANDS 1020 1021#ifdef DEBUG 1022 if(p->scb->cus & CU_ACTIVE) 1023 { 1024 printk("%s: Hmmm .. CU is still running and we wanna send a new packet.\n",dev->name); 1025 printk("%s: stat: %04x %04x\n",dev->name,p->scb->cus,swab16(p->xmit_cmds[0]->cmd_status)); 1026 } 1027#endif 1028 1029 p->xmit_buffs[0]->size = swab16(TBD_LAST | len); 1030 for(i=0;i<16;i++) 1031 { 1032 p->xmit_cmds[0]->cmd_status = 0; 1033 WAIT_4_SCB_CMD(); 1034 if( (p->scb->cus & CU_STATUS) == CU_SUSPEND) 1035 p->scb->cmd_cuc = CUC_RESUME; 1036 else 1037 { 1038 p->scb->cbl_offset = make16(p->xmit_cmds[0]); 1039 p->scb->cmd_cuc = CUC_START; 1040 } 1041 1042 sun3_attn586(); 1043 if(!i) 1044 dev_kfree_skb(skb); 1045 WAIT_4_SCB_CMD(); 1046 if( (p->scb->cus & CU_ACTIVE)) /* test it, because CU sometimes doesn't start immediately */ 1047 break; 1048 if(p->xmit_cmds[0]->cmd_status) 1049 break; 1050 if(i==15) 1051 printk("%s: Can't start transmit-command.\n",dev->name); 1052 } 1053# else 1054 next_nop = (p->nop_point + 1) & 0x1; 1055 p->xmit_buffs[0]->size = swab16(TBD_LAST | len); 1056 1057 p->xmit_cmds[0]->cmd_link = p->nop_cmds[next_nop]->cmd_link 1058 = make16((p->nop_cmds[next_nop])); 1059 p->xmit_cmds[0]->cmd_status = p->nop_cmds[next_nop]->cmd_status = 0; 1060 1061 p->nop_cmds[p->nop_point]->cmd_link = make16((p->xmit_cmds[0])); 1062 p->nop_point = next_nop; 1063 dev_kfree_skb(skb); 1064# endif 1065#else 1066 p->xmit_buffs[p->xmit_count]->size = swab16(TBD_LAST | len); 1067 if( (next_nop = p->xmit_count + 1) == NUM_XMIT_BUFFS ) 1068 next_nop = 0; 1069 1070 p->xmit_cmds[p->xmit_count]->cmd_status = 0; 1071 /* linkpointer of xmit-command already points to next nop cmd */ 1072 p->nop_cmds[next_nop]->cmd_link = make16((p->nop_cmds[next_nop])); 1073 p->nop_cmds[next_nop]->cmd_status = 0; 1074 1075 p->nop_cmds[p->xmit_count]->cmd_link = make16((p->xmit_cmds[p->xmit_count])); 1076 p->xmit_count = next_nop; 1077 1078 { 1079 unsigned long flags; 1080 local_irq_save(flags); 1081 if(p->xmit_count != p->xmit_last) 1082 netif_wake_queue(dev); 1083 p->lock = 0; 1084 local_irq_restore(flags); 1085 } 1086 dev_kfree_skb(skb); 1087#endif 1088 } 1089 return NETDEV_TX_OK; 1090} 1091 1092/******************************************* 1093 * Someone wanna have the statistics 1094 */ 1095 1096static struct net_device_stats *sun3_82586_get_stats(struct net_device *dev) 1097{ 1098 struct priv *p = netdev_priv(dev); 1099 unsigned short crc,aln,rsc,ovrn; 1100 1101 crc = swab16(p->scb->crc_errs); /* get error-statistic from the ni82586 */ 1102 p->scb->crc_errs = 0; 1103 aln = swab16(p->scb->aln_errs); 1104 p->scb->aln_errs = 0; 1105 rsc = swab16(p->scb->rsc_errs); 1106 p->scb->rsc_errs = 0; 1107 ovrn = swab16(p->scb->ovrn_errs); 1108 p->scb->ovrn_errs = 0; 1109 1110 dev->stats.rx_crc_errors += crc; 1111 dev->stats.rx_fifo_errors += ovrn; 1112 dev->stats.rx_frame_errors += aln; 1113 dev->stats.rx_dropped += rsc; 1114 1115 return &dev->stats; 1116} 1117 1118/******************************************************** 1119 * Set MC list .. 1120 */ 1121 1122static void set_multicast_list(struct net_device *dev) 1123{ 1124 netif_stop_queue(dev); 1125 sun3_disint(); 1126 alloc586(dev); 1127 init586(dev); 1128 startrecv586(dev); 1129 sun3_enaint(); 1130 netif_wake_queue(dev); 1131} 1132 1133#ifdef MODULE 1134#error This code is not currently supported as a module 1135static struct net_device *dev_sun3_82586; 1136 1137int init_module(void) 1138{ 1139 dev_sun3_82586 = sun3_82586_probe(-1); 1140 if (IS_ERR(dev_sun3_82586)) 1141 return PTR_ERR(dev_sun3_82586); 1142 return 0; 1143} 1144 1145void cleanup_module(void) 1146{ 1147 unsigned long ioaddr = dev_sun3_82586->base_addr; 1148 unregister_netdev(dev_sun3_82586); 1149 release_region(ioaddr, SUN3_82586_TOTAL_SIZE); 1150 iounmap((void *)ioaddr); 1151 free_netdev(dev_sun3_82586); 1152} 1153#endif /* MODULE */ 1154 1155 1156MODULE_LICENSE("GPL"); 1157