1/* 2 * tms380tr.c: A network driver library for Texas Instruments TMS380-based 3 * Token Ring Adapters. 4 * 5 * Originally sktr.c: Written 1997 by Christoph Goos 6 * 7 * A fine result of the Linux Systems Network Architecture Project. 8 * http://www.linux-sna.org 9 * 10 * This software may be used and distributed according to the terms 11 * of the GNU General Public License, incorporated herein by reference. 12 * 13 * The following modules are currently available for card support: 14 * - tmspci (Generic PCI card support) 15 * - abyss (Madge PCI support) 16 * - tmsisa (SysKonnect TR4/16 ISA) 17 * 18 * Sources: 19 * - The hardware related parts of this driver are take from 20 * the SysKonnect Token Ring driver for Windows NT. 21 * - I used the IBM Token Ring driver 'ibmtr.c' as a base for this 22 * driver, as well as the 'skeleton.c' driver by Donald Becker. 23 * - Also various other drivers in the linux source tree were taken 24 * as samples for some tasks. 25 * - TI TMS380 Second-Generation Token Ring User's Guide 26 * - TI datasheets for respective chips 27 * - David Hein at Texas Instruments 28 * - Various Madge employees 29 * 30 * Maintainer(s): 31 * JS Jay Schulist jschlst@samba.org 32 * CG Christoph Goos cgoos@syskonnect.de 33 * AF Adam Fritzler mid@auk.cx 34 * MLP Mike Phillips phillim@amtrak.com 35 * JF Jochen Friedrich jochen@scram.de 36 * 37 * Modification History: 38 * 29-Aug-97 CG Created 39 * 04-Apr-98 CG Fixed problems caused by tok_timer_check 40 * 10-Apr-98 CG Fixed lockups at cable disconnection 41 * 27-May-98 JS Formated to Linux Kernel Format 42 * 31-May-98 JS Hacked in PCI support 43 * 16-Jun-98 JS Modulized for multiple cards with one driver 44 * Sep-99 AF Renamed to tms380tr (supports more than SK's) 45 * 23-Sep-99 AF Added Compaq and Thomas-Conrad PCI support 46 * Fixed a bug causing double copies on PCI 47 * Fixed for new multicast stuff (2.2/2.3) 48 * 25-Sep-99 AF Uped TPL_NUM from 3 to 9 49 * Removed extraneous 'No free TPL' 50 * 22-Dec-99 AF Added Madge PCI Mk2 support and generalized 51 * parts of the initilization procedure. 52 * 30-Dec-99 AF Turned tms380tr into a library ala 8390. 53 * Madge support is provided in the abyss module 54 * Generic PCI support is in the tmspci module. 55 * 30-Nov-00 JF Updated PCI code to support IO MMU via 56 * pci_map_static(). Alpha uses this MMU for ISA 57 * as well. 58 * 14-Jan-01 JF Fix DMA on ifdown/ifup sequences. Some 59 * cleanup. 60 * 13-Jan-02 JF Add spinlock to fix race condition. 61 * 09-Nov-02 JF Fixed printks to not SPAM the console during 62 * normal operation. 63 * 30-Dec-02 JF Removed incorrect __init from 64 * tms380tr_init_card. 65 * 22-Jul-05 JF Converted to dma-mapping. 66 * 67 * To do: 68 * 1. Multi/Broadcast packet handling (this may have fixed itself) 69 * 2. Write a sktrisa module that includes the old ISA support (done) 70 * 3. Allow modules to load their own microcode 71 * 4. Speed up the BUD process -- freezing the kernel for 3+sec is 72 * quite unacceptable. 73 * 5. Still a few remaining stalls when the cable is unplugged. 74 */ 75 76#ifdef MODULE 77static const char version[] = "tms380tr.c: v1.10 30/12/2002 by Christoph Goos, Adam Fritzler\n"; 78#endif 79 80#include <linux/module.h> 81#include <linux/kernel.h> 82#include <linux/types.h> 83#include <linux/fcntl.h> 84#include <linux/interrupt.h> 85#include <linux/ptrace.h> 86#include <linux/ioport.h> 87#include <linux/in.h> 88#include <linux/slab.h> 89#include <linux/string.h> 90#include <linux/time.h> 91#include <linux/errno.h> 92#include <linux/init.h> 93#include <linux/dma-mapping.h> 94#include <linux/delay.h> 95#include <linux/netdevice.h> 96#include <linux/etherdevice.h> 97#include <linux/skbuff.h> 98#include <linux/trdevice.h> 99#include <linux/firmware.h> 100#include <linux/bitops.h> 101 102#include <asm/system.h> 103#include <asm/io.h> 104#include <asm/dma.h> 105#include <asm/irq.h> 106#include <asm/uaccess.h> 107 108#include "tms380tr.h" /* Our Stuff */ 109 110/* Use 0 for production, 1 for verification, 2 for debug, and 111 * 3 for very verbose debug. 112 */ 113#ifndef TMS380TR_DEBUG 114#define TMS380TR_DEBUG 0 115#endif 116static unsigned int tms380tr_debug = TMS380TR_DEBUG; 117 118/* Index to functions, as function prototypes. 119 * Alphabetical by function name. 120 */ 121 122/* "A" */ 123/* "B" */ 124static int tms380tr_bringup_diags(struct net_device *dev); 125/* "C" */ 126static void tms380tr_cancel_tx_queue(struct net_local* tp); 127static int tms380tr_chipset_init(struct net_device *dev); 128static void tms380tr_chk_irq(struct net_device *dev); 129static void tms380tr_chk_outstanding_cmds(struct net_device *dev); 130static void tms380tr_chk_src_addr(unsigned char *frame, unsigned char *hw_addr); 131static unsigned char tms380tr_chk_ssb(struct net_local *tp, unsigned short IrqType); 132int tms380tr_close(struct net_device *dev); 133static void tms380tr_cmd_status_irq(struct net_device *dev); 134/* "D" */ 135static void tms380tr_disable_interrupts(struct net_device *dev); 136#if TMS380TR_DEBUG > 0 137static void tms380tr_dump(unsigned char *Data, int length); 138#endif 139/* "E" */ 140static void tms380tr_enable_interrupts(struct net_device *dev); 141static void tms380tr_exec_cmd(struct net_device *dev, unsigned short Command); 142static void tms380tr_exec_sifcmd(struct net_device *dev, unsigned int WriteValue); 143/* "F" */ 144/* "G" */ 145static struct net_device_stats *tms380tr_get_stats(struct net_device *dev); 146/* "H" */ 147static int tms380tr_hardware_send_packet(struct sk_buff *skb, 148 struct net_device *dev); 149/* "I" */ 150static int tms380tr_init_adapter(struct net_device *dev); 151static void tms380tr_init_ipb(struct net_local *tp); 152static void tms380tr_init_net_local(struct net_device *dev); 153static void tms380tr_init_opb(struct net_device *dev); 154/* "M" */ 155/* "O" */ 156int tms380tr_open(struct net_device *dev); 157static void tms380tr_open_adapter(struct net_device *dev); 158/* "P" */ 159/* "R" */ 160static void tms380tr_rcv_status_irq(struct net_device *dev); 161static int tms380tr_read_ptr(struct net_device *dev); 162static void tms380tr_read_ram(struct net_device *dev, unsigned char *Data, 163 unsigned short Address, int Length); 164static int tms380tr_reset_adapter(struct net_device *dev); 165static void tms380tr_reset_interrupt(struct net_device *dev); 166static void tms380tr_ring_status_irq(struct net_device *dev); 167/* "S" */ 168static int tms380tr_send_packet(struct sk_buff *skb, struct net_device *dev); 169static void tms380tr_set_multicast_list(struct net_device *dev); 170static int tms380tr_set_mac_address(struct net_device *dev, void *addr); 171/* "T" */ 172static void tms380tr_timer_chk(unsigned long data); 173static void tms380tr_timer_end_wait(unsigned long data); 174static void tms380tr_tx_status_irq(struct net_device *dev); 175/* "U" */ 176static void tms380tr_update_rcv_stats(struct net_local *tp, 177 unsigned char DataPtr[], unsigned int Length); 178/* "W" */ 179void tms380tr_wait(unsigned long time); 180static void tms380tr_write_rpl_status(RPL *rpl, unsigned int Status); 181static void tms380tr_write_tpl_status(TPL *tpl, unsigned int Status); 182 183#define SIFREADB(reg) (((struct net_local *)dev->priv)->sifreadb(dev, reg)) 184#define SIFWRITEB(val, reg) (((struct net_local *)dev->priv)->sifwriteb(dev, val, reg)) 185#define SIFREADW(reg) (((struct net_local *)dev->priv)->sifreadw(dev, reg)) 186#define SIFWRITEW(val, reg) (((struct net_local *)dev->priv)->sifwritew(dev, val, reg)) 187 188 189 190 191/* 192 * Open/initialize the board. This is called sometime after 193 * booting when the 'ifconfig' program is run. 194 * 195 * This routine should set everything up anew at each open, even 196 * registers that "should" only need to be set once at boot, so that 197 * there is non-reboot way to recover if something goes wrong. 198 */ 199int tms380tr_open(struct net_device *dev) 200{ 201 struct net_local *tp = netdev_priv(dev); 202 int err; 203 204 /* init the spinlock */ 205 spin_lock_init(&tp->lock); 206 init_timer(&tp->timer); 207 208 /* Reset the hardware here. Don't forget to set the station address. */ 209 210#ifdef CONFIG_ISA 211 if(dev->dma > 0) 212 { 213 unsigned long flags=claim_dma_lock(); 214 disable_dma(dev->dma); 215 set_dma_mode(dev->dma, DMA_MODE_CASCADE); 216 enable_dma(dev->dma); 217 release_dma_lock(flags); 218 } 219#endif 220 221 err = tms380tr_chipset_init(dev); 222 if(err) 223 { 224 printk(KERN_INFO "%s: Chipset initialization error\n", 225 dev->name); 226 return (-1); 227 } 228 229 tp->timer.expires = jiffies + 30*HZ; 230 tp->timer.function = tms380tr_timer_end_wait; 231 tp->timer.data = (unsigned long)dev; 232 add_timer(&tp->timer); 233 234 printk(KERN_DEBUG "%s: Adapter RAM size: %dK\n", 235 dev->name, tms380tr_read_ptr(dev)); 236 237 tms380tr_enable_interrupts(dev); 238 tms380tr_open_adapter(dev); 239 240 netif_start_queue(dev); 241 242 /* Wait for interrupt from hardware. If interrupt does not come, 243 * there will be a timeout from the timer. 244 */ 245 tp->Sleeping = 1; 246 interruptible_sleep_on(&tp->wait_for_tok_int); 247 del_timer(&tp->timer); 248 249 /* If AdapterVirtOpenFlag is 1, the adapter is now open for use */ 250 if(tp->AdapterVirtOpenFlag == 0) 251 { 252 tms380tr_disable_interrupts(dev); 253 return (-1); 254 } 255 256 tp->StartTime = jiffies; 257 258 /* Start function control timer */ 259 tp->timer.expires = jiffies + 2*HZ; 260 tp->timer.function = tms380tr_timer_chk; 261 tp->timer.data = (unsigned long)dev; 262 add_timer(&tp->timer); 263 264 return (0); 265} 266 267/* 268 * Timeout function while waiting for event 269 */ 270static void tms380tr_timer_end_wait(unsigned long data) 271{ 272 struct net_device *dev = (struct net_device*)data; 273 struct net_local *tp = netdev_priv(dev); 274 275 if(tp->Sleeping) 276 { 277 tp->Sleeping = 0; 278 wake_up_interruptible(&tp->wait_for_tok_int); 279 } 280 281 return; 282} 283 284/* 285 * Initialize the chipset 286 */ 287static int tms380tr_chipset_init(struct net_device *dev) 288{ 289 struct net_local *tp = netdev_priv(dev); 290 int err; 291 292 tms380tr_init_ipb(tp); 293 tms380tr_init_opb(dev); 294 tms380tr_init_net_local(dev); 295 296 if(tms380tr_debug > 3) 297 printk(KERN_DEBUG "%s: Resetting adapter...\n", dev->name); 298 err = tms380tr_reset_adapter(dev); 299 if(err < 0) 300 return (-1); 301 302 if(tms380tr_debug > 3) 303 printk(KERN_DEBUG "%s: Bringup diags...\n", dev->name); 304 err = tms380tr_bringup_diags(dev); 305 if(err < 0) 306 return (-1); 307 308 if(tms380tr_debug > 3) 309 printk(KERN_DEBUG "%s: Init adapter...\n", dev->name); 310 err = tms380tr_init_adapter(dev); 311 if(err < 0) 312 return (-1); 313 314 if(tms380tr_debug > 3) 315 printk(KERN_DEBUG "%s: Done!\n", dev->name); 316 return (0); 317} 318 319/* 320 * Initializes the net_local structure. 321 */ 322static void tms380tr_init_net_local(struct net_device *dev) 323{ 324 struct net_local *tp = netdev_priv(dev); 325 int i; 326 dma_addr_t dmabuf; 327 328 tp->scb.CMD = 0; 329 tp->scb.Parm[0] = 0; 330 tp->scb.Parm[1] = 0; 331 332 tp->ssb.STS = 0; 333 tp->ssb.Parm[0] = 0; 334 tp->ssb.Parm[1] = 0; 335 tp->ssb.Parm[2] = 0; 336 337 tp->CMDqueue = 0; 338 339 tp->AdapterOpenFlag = 0; 340 tp->AdapterVirtOpenFlag = 0; 341 tp->ScbInUse = 0; 342 tp->OpenCommandIssued = 0; 343 tp->ReOpenInProgress = 0; 344 tp->HaltInProgress = 0; 345 tp->TransmitHaltScheduled = 0; 346 tp->LobeWireFaultLogged = 0; 347 tp->LastOpenStatus = 0; 348 tp->MaxPacketSize = DEFAULT_PACKET_SIZE; 349 350 /* Create circular chain of transmit lists */ 351 for (i = 0; i < TPL_NUM; i++) 352 { 353 tp->Tpl[i].NextTPLAddr = htonl(((char *)(&tp->Tpl[(i+1) % TPL_NUM]) - (char *)tp) + tp->dmabuffer); /* DMA buffer may be MMU driven */ 354 tp->Tpl[i].Status = 0; 355 tp->Tpl[i].FrameSize = 0; 356 tp->Tpl[i].FragList[0].DataCount = 0; 357 tp->Tpl[i].FragList[0].DataAddr = 0; 358 tp->Tpl[i].NextTPLPtr = &tp->Tpl[(i+1) % TPL_NUM]; 359 tp->Tpl[i].MData = NULL; 360 tp->Tpl[i].TPLIndex = i; 361 tp->Tpl[i].DMABuff = 0; 362 tp->Tpl[i].BusyFlag = 0; 363 } 364 365 tp->TplFree = tp->TplBusy = &tp->Tpl[0]; 366 367 /* Create circular chain of receive lists */ 368 for (i = 0; i < RPL_NUM; i++) 369 { 370 tp->Rpl[i].NextRPLAddr = htonl(((char *)(&tp->Rpl[(i+1) % RPL_NUM]) - (char *)tp) + tp->dmabuffer); /* DMA buffer may be MMU driven */ 371 tp->Rpl[i].Status = (RX_VALID | RX_START_FRAME | RX_END_FRAME | RX_FRAME_IRQ); 372 tp->Rpl[i].FrameSize = 0; 373 tp->Rpl[i].FragList[0].DataCount = cpu_to_be16((unsigned short)tp->MaxPacketSize); 374 375 /* Alloc skb and point adapter to data area */ 376 tp->Rpl[i].Skb = dev_alloc_skb(tp->MaxPacketSize); 377 tp->Rpl[i].DMABuff = 0; 378 379 /* skb == NULL ? then use local buffer */ 380 if(tp->Rpl[i].Skb == NULL) 381 { 382 tp->Rpl[i].SkbStat = SKB_UNAVAILABLE; 383 tp->Rpl[i].FragList[0].DataAddr = htonl(((char *)tp->LocalRxBuffers[i] - (char *)tp) + tp->dmabuffer); 384 tp->Rpl[i].MData = tp->LocalRxBuffers[i]; 385 } 386 else /* SKB != NULL */ 387 { 388 tp->Rpl[i].Skb->dev = dev; 389 skb_put(tp->Rpl[i].Skb, tp->MaxPacketSize); 390 391 /* data unreachable for DMA ? then use local buffer */ 392 dmabuf = dma_map_single(tp->pdev, tp->Rpl[i].Skb->data, tp->MaxPacketSize, DMA_FROM_DEVICE); 393 if(tp->dmalimit && (dmabuf + tp->MaxPacketSize > tp->dmalimit)) 394 { 395 tp->Rpl[i].SkbStat = SKB_DATA_COPY; 396 tp->Rpl[i].FragList[0].DataAddr = htonl(((char *)tp->LocalRxBuffers[i] - (char *)tp) + tp->dmabuffer); 397 tp->Rpl[i].MData = tp->LocalRxBuffers[i]; 398 } 399 else /* DMA directly in skb->data */ 400 { 401 tp->Rpl[i].SkbStat = SKB_DMA_DIRECT; 402 tp->Rpl[i].FragList[0].DataAddr = htonl(dmabuf); 403 tp->Rpl[i].MData = tp->Rpl[i].Skb->data; 404 tp->Rpl[i].DMABuff = dmabuf; 405 } 406 } 407 408 tp->Rpl[i].NextRPLPtr = &tp->Rpl[(i+1) % RPL_NUM]; 409 tp->Rpl[i].RPLIndex = i; 410 } 411 412 tp->RplHead = &tp->Rpl[0]; 413 tp->RplTail = &tp->Rpl[RPL_NUM-1]; 414 tp->RplTail->Status = (RX_START_FRAME | RX_END_FRAME | RX_FRAME_IRQ); 415 416 return; 417} 418 419/* 420 * Initializes the initialisation parameter block. 421 */ 422static void tms380tr_init_ipb(struct net_local *tp) 423{ 424 tp->ipb.Init_Options = BURST_MODE; 425 tp->ipb.CMD_Status_IV = 0; 426 tp->ipb.TX_IV = 0; 427 tp->ipb.RX_IV = 0; 428 tp->ipb.Ring_Status_IV = 0; 429 tp->ipb.SCB_Clear_IV = 0; 430 tp->ipb.Adapter_CHK_IV = 0; 431 tp->ipb.RX_Burst_Size = BURST_SIZE; 432 tp->ipb.TX_Burst_Size = BURST_SIZE; 433 tp->ipb.DMA_Abort_Thrhld = DMA_RETRIES; 434 tp->ipb.SCB_Addr = 0; 435 tp->ipb.SSB_Addr = 0; 436 437 return; 438} 439 440/* 441 * Initializes the open parameter block. 442 */ 443static void tms380tr_init_opb(struct net_device *dev) 444{ 445 struct net_local *tp; 446 unsigned long Addr; 447 unsigned short RplSize = RPL_SIZE; 448 unsigned short TplSize = TPL_SIZE; 449 unsigned short BufferSize = BUFFER_SIZE; 450 int i; 451 452 tp = netdev_priv(dev); 453 454 tp->ocpl.OPENOptions = 0; 455 tp->ocpl.OPENOptions |= ENABLE_FULL_DUPLEX_SELECTION; 456 tp->ocpl.FullDuplex = 0; 457 tp->ocpl.FullDuplex |= OPEN_FULL_DUPLEX_OFF; 458 459 /* 460 * Set node address 461 * 462 * We go ahead and put it in the OPB even though on 463 * most of the generic adapters this isn't required. 464 * Its simpler this way. -- ASF 465 */ 466 for (i=0;i<6;i++) 467 tp->ocpl.NodeAddr[i] = ((unsigned char *)dev->dev_addr)[i]; 468 469 tp->ocpl.GroupAddr = 0; 470 tp->ocpl.FunctAddr = 0; 471 tp->ocpl.RxListSize = cpu_to_be16((unsigned short)RplSize); 472 tp->ocpl.TxListSize = cpu_to_be16((unsigned short)TplSize); 473 tp->ocpl.BufSize = cpu_to_be16((unsigned short)BufferSize); 474 tp->ocpl.Reserved = 0; 475 tp->ocpl.TXBufMin = TX_BUF_MIN; 476 tp->ocpl.TXBufMax = TX_BUF_MAX; 477 478 Addr = htonl(((char *)tp->ProductID - (char *)tp) + tp->dmabuffer); 479 480 tp->ocpl.ProdIDAddr[0] = LOWORD(Addr); 481 tp->ocpl.ProdIDAddr[1] = HIWORD(Addr); 482 483 return; 484} 485 486/* 487 * Send OPEN command to adapter 488 */ 489static void tms380tr_open_adapter(struct net_device *dev) 490{ 491 struct net_local *tp = netdev_priv(dev); 492 493 if(tp->OpenCommandIssued) 494 return; 495 496 tp->OpenCommandIssued = 1; 497 tms380tr_exec_cmd(dev, OC_OPEN); 498 499 return; 500} 501 502/* 503 * Clear the adapter's interrupt flag. Clear system interrupt enable 504 * (SINTEN): disable adapter to system interrupts. 505 */ 506static void tms380tr_disable_interrupts(struct net_device *dev) 507{ 508 SIFWRITEB(0, SIFACL); 509 510 return; 511} 512 513/* 514 * Set the adapter's interrupt flag. Set system interrupt enable 515 * (SINTEN): enable adapter to system interrupts. 516 */ 517static void tms380tr_enable_interrupts(struct net_device *dev) 518{ 519 SIFWRITEB(ACL_SINTEN, SIFACL); 520 521 return; 522} 523 524/* 525 * Put command in command queue, try to execute it. 526 */ 527static void tms380tr_exec_cmd(struct net_device *dev, unsigned short Command) 528{ 529 struct net_local *tp = netdev_priv(dev); 530 531 tp->CMDqueue |= Command; 532 tms380tr_chk_outstanding_cmds(dev); 533 534 return; 535} 536 537static void tms380tr_timeout(struct net_device *dev) 538{ 539 /* 540 * If we get here, some higher level has decided we are broken. 541 * There should really be a "kick me" function call instead. 542 * 543 * Resetting the token ring adapter takes a long time so just 544 * fake transmission time and go on trying. Our own timeout 545 * routine is in tms380tr_timer_chk() 546 */ 547 dev->trans_start = jiffies; 548 netif_wake_queue(dev); 549} 550 551/* 552 * Gets skb from system, queues it and checks if it can be sent 553 */ 554static int tms380tr_send_packet(struct sk_buff *skb, struct net_device *dev) 555{ 556 struct net_local *tp = netdev_priv(dev); 557 int err; 558 559 err = tms380tr_hardware_send_packet(skb, dev); 560 if(tp->TplFree->NextTPLPtr->BusyFlag) 561 netif_stop_queue(dev); 562 return (err); 563} 564 565/* 566 * Move frames into adapter tx queue 567 */ 568static int tms380tr_hardware_send_packet(struct sk_buff *skb, struct net_device *dev) 569{ 570 TPL *tpl; 571 short length; 572 unsigned char *buf; 573 unsigned long flags; 574 int i; 575 dma_addr_t dmabuf, newbuf; 576 struct net_local *tp = netdev_priv(dev); 577 578 /* Try to get a free TPL from the chain. 579 * 580 * NOTE: We *must* always leave one unused TPL in the chain, 581 * because otherwise the adapter might send frames twice. 582 */ 583 spin_lock_irqsave(&tp->lock, flags); 584 if(tp->TplFree->NextTPLPtr->BusyFlag) { /* No free TPL */ 585 if (tms380tr_debug > 0) 586 printk(KERN_DEBUG "%s: No free TPL\n", dev->name); 587 spin_unlock_irqrestore(&tp->lock, flags); 588 return 1; 589 } 590 591 dmabuf = 0; 592 593 /* Is buffer reachable for Busmaster-DMA? */ 594 595 length = skb->len; 596 dmabuf = dma_map_single(tp->pdev, skb->data, length, DMA_TO_DEVICE); 597 if(tp->dmalimit && (dmabuf + length > tp->dmalimit)) { 598 /* Copy frame to local buffer */ 599 dma_unmap_single(tp->pdev, dmabuf, length, DMA_TO_DEVICE); 600 dmabuf = 0; 601 i = tp->TplFree->TPLIndex; 602 buf = tp->LocalTxBuffers[i]; 603 skb_copy_from_linear_data(skb, buf, length); 604 newbuf = ((char *)buf - (char *)tp) + tp->dmabuffer; 605 } 606 else { 607 /* Send direct from skb->data */ 608 newbuf = dmabuf; 609 buf = skb->data; 610 } 611 /* Source address in packet? */ 612 tms380tr_chk_src_addr(buf, dev->dev_addr); 613 tp->LastSendTime = jiffies; 614 tpl = tp->TplFree; /* Get the "free" TPL */ 615 tpl->BusyFlag = 1; /* Mark TPL as busy */ 616 tp->TplFree = tpl->NextTPLPtr; 617 618 /* Save the skb for delayed return of skb to system */ 619 tpl->Skb = skb; 620 tpl->DMABuff = dmabuf; 621 tpl->FragList[0].DataCount = cpu_to_be16((unsigned short)length); 622 tpl->FragList[0].DataAddr = htonl(newbuf); 623 624 /* Write the data length in the transmit list. */ 625 tpl->FrameSize = cpu_to_be16((unsigned short)length); 626 tpl->MData = buf; 627 628 /* Transmit the frame and set the status values. */ 629 tms380tr_write_tpl_status(tpl, TX_VALID | TX_START_FRAME 630 | TX_END_FRAME | TX_PASS_SRC_ADDR 631 | TX_FRAME_IRQ); 632 633 /* Let adapter send the frame. */ 634 tms380tr_exec_sifcmd(dev, CMD_TX_VALID); 635 spin_unlock_irqrestore(&tp->lock, flags); 636 637 return 0; 638} 639 640/* 641 * Write the given value to the 'Status' field of the specified TPL. 642 * NOTE: This function should be used whenever the status of any TPL must be 643 * modified by the driver, because the compiler may otherwise change the 644 * order of instructions such that writing the TPL status may be executed at 645 * an undesireable time. When this function is used, the status is always 646 * written when the function is called. 647 */ 648static void tms380tr_write_tpl_status(TPL *tpl, unsigned int Status) 649{ 650 tpl->Status = Status; 651} 652 653static void tms380tr_chk_src_addr(unsigned char *frame, unsigned char *hw_addr) 654{ 655 unsigned char SRBit; 656 657 if((((unsigned long)frame[8]) & ~0x80) != 0) /* Compare 4 bytes */ 658 return; 659 if((unsigned short)frame[12] != 0) /* Compare 2 bytes */ 660 return; 661 662 SRBit = frame[8] & 0x80; 663 memcpy(&frame[8], hw_addr, 6); 664 frame[8] |= SRBit; 665 666 return; 667} 668 669/* 670 * The timer routine: Check if adapter still open and working, reopen if not. 671 */ 672static void tms380tr_timer_chk(unsigned long data) 673{ 674 struct net_device *dev = (struct net_device*)data; 675 struct net_local *tp = netdev_priv(dev); 676 677 if(tp->HaltInProgress) 678 return; 679 680 tms380tr_chk_outstanding_cmds(dev); 681 if(time_before(tp->LastSendTime + SEND_TIMEOUT, jiffies) 682 && (tp->TplFree != tp->TplBusy)) 683 { 684 /* Anything to send, but stalled too long */ 685 tp->LastSendTime = jiffies; 686 tms380tr_exec_cmd(dev, OC_CLOSE); /* Does reopen automatically */ 687 } 688 689 tp->timer.expires = jiffies + 2*HZ; 690 add_timer(&tp->timer); 691 692 if(tp->AdapterOpenFlag || tp->ReOpenInProgress) 693 return; 694 tp->ReOpenInProgress = 1; 695 tms380tr_open_adapter(dev); 696 697 return; 698} 699 700/* 701 * The typical workload of the driver: Handle the network interface interrupts. 702 */ 703irqreturn_t tms380tr_interrupt(int irq, void *dev_id) 704{ 705 struct net_device *dev = dev_id; 706 struct net_local *tp; 707 unsigned short irq_type; 708 int handled = 0; 709 710 tp = netdev_priv(dev); 711 712 irq_type = SIFREADW(SIFSTS); 713 714 while(irq_type & STS_SYSTEM_IRQ) { 715 handled = 1; 716 irq_type &= STS_IRQ_MASK; 717 718 if(!tms380tr_chk_ssb(tp, irq_type)) { 719 printk(KERN_DEBUG "%s: DATA LATE occurred\n", dev->name); 720 break; 721 } 722 723 switch(irq_type) { 724 case STS_IRQ_RECEIVE_STATUS: 725 tms380tr_reset_interrupt(dev); 726 tms380tr_rcv_status_irq(dev); 727 break; 728 729 case STS_IRQ_TRANSMIT_STATUS: 730 /* Check if TRANSMIT.HALT command is complete */ 731 if(tp->ssb.Parm[0] & COMMAND_COMPLETE) { 732 tp->TransmitCommandActive = 0; 733 tp->TransmitHaltScheduled = 0; 734 735 /* Issue a new transmit command. */ 736 tms380tr_exec_cmd(dev, OC_TRANSMIT); 737 } 738 739 tms380tr_reset_interrupt(dev); 740 tms380tr_tx_status_irq(dev); 741 break; 742 743 case STS_IRQ_COMMAND_STATUS: 744 /* The SSB contains status of last command 745 * other than receive/transmit. 746 */ 747 tms380tr_cmd_status_irq(dev); 748 break; 749 750 case STS_IRQ_SCB_CLEAR: 751 /* The SCB is free for another command. */ 752 tp->ScbInUse = 0; 753 tms380tr_chk_outstanding_cmds(dev); 754 break; 755 756 case STS_IRQ_RING_STATUS: 757 tms380tr_ring_status_irq(dev); 758 break; 759 760 case STS_IRQ_ADAPTER_CHECK: 761 tms380tr_chk_irq(dev); 762 break; 763 764 case STS_IRQ_LLC_STATUS: 765 printk(KERN_DEBUG "tms380tr: unexpected LLC status IRQ\n"); 766 break; 767 768 case STS_IRQ_TIMER: 769 printk(KERN_DEBUG "tms380tr: unexpected Timer IRQ\n"); 770 break; 771 772 case STS_IRQ_RECEIVE_PENDING: 773 printk(KERN_DEBUG "tms380tr: unexpected Receive Pending IRQ\n"); 774 break; 775 776 default: 777 printk(KERN_DEBUG "Unknown Token Ring IRQ (0x%04x)\n", irq_type); 778 break; 779 } 780 781 /* Reset system interrupt if not already done. */ 782 if(irq_type != STS_IRQ_TRANSMIT_STATUS 783 && irq_type != STS_IRQ_RECEIVE_STATUS) { 784 tms380tr_reset_interrupt(dev); 785 } 786 787 irq_type = SIFREADW(SIFSTS); 788 } 789 790 return IRQ_RETVAL(handled); 791} 792 793/* 794 * Reset the INTERRUPT SYSTEM bit and issue SSB CLEAR command. 795 */ 796static void tms380tr_reset_interrupt(struct net_device *dev) 797{ 798 struct net_local *tp = netdev_priv(dev); 799 SSB *ssb = &tp->ssb; 800 801 802 ssb->STS = (unsigned short) -1; 803 ssb->Parm[0] = (unsigned short) -1; 804 ssb->Parm[1] = (unsigned short) -1; 805 ssb->Parm[2] = (unsigned short) -1; 806 807 /* Free SSB by issuing SSB_CLEAR command after reading IRQ code 808 * and clear STS_SYSTEM_IRQ bit: enable adapter for further interrupts. 809 */ 810 tms380tr_exec_sifcmd(dev, CMD_SSB_CLEAR | CMD_CLEAR_SYSTEM_IRQ); 811 812 return; 813} 814 815/* 816 * Check if the SSB has actually been written by the adapter. 817 */ 818static unsigned char tms380tr_chk_ssb(struct net_local *tp, unsigned short IrqType) 819{ 820 SSB *ssb = &tp->ssb; /* The address of the SSB. */ 821 822 /* C 0 1 2 INTERRUPT CODE 823 * - - - - -------------- 824 * 1 1 1 1 TRANSMIT STATUS 825 * 1 1 1 1 RECEIVE STATUS 826 * 1 ? ? 0 COMMAND STATUS 827 * 0 0 0 0 SCB CLEAR 828 * 1 1 0 0 RING STATUS 829 * 0 0 0 0 ADAPTER CHECK 830 * 831 * 0 = SSB field not affected by interrupt 832 * 1 = SSB field is affected by interrupt 833 * 834 * C = SSB ADDRESS +0: COMMAND 835 * 0 = SSB ADDRESS +2: STATUS 0 836 * 1 = SSB ADDRESS +4: STATUS 1 837 * 2 = SSB ADDRESS +6: STATUS 2 838 */ 839 840 /* Check if this interrupt does use the SSB. */ 841 842 if(IrqType != STS_IRQ_TRANSMIT_STATUS 843 && IrqType != STS_IRQ_RECEIVE_STATUS 844 && IrqType != STS_IRQ_COMMAND_STATUS 845 && IrqType != STS_IRQ_RING_STATUS) 846 { 847 return (1); /* SSB not involved. */ 848 } 849 850 /* Note: All fields of the SSB have been set to all ones (-1) after it 851 * has last been used by the software (see DriverIsr()). 852 * 853 * Check if the affected SSB fields are still unchanged. 854 */ 855 856 if(ssb->STS == (unsigned short) -1) 857 return (0); /* Command field not yet available. */ 858 if(IrqType == STS_IRQ_COMMAND_STATUS) 859 return (1); /* Status fields not always affected. */ 860 if(ssb->Parm[0] == (unsigned short) -1) 861 return (0); /* Status 1 field not yet available. */ 862 if(IrqType == STS_IRQ_RING_STATUS) 863 return (1); /* Status 2 & 3 fields not affected. */ 864 865 /* Note: At this point, the interrupt is either TRANSMIT or RECEIVE. */ 866 if(ssb->Parm[1] == (unsigned short) -1) 867 return (0); /* Status 2 field not yet available. */ 868 if(ssb->Parm[2] == (unsigned short) -1) 869 return (0); /* Status 3 field not yet available. */ 870 871 return (1); /* All SSB fields have been written by the adapter. */ 872} 873 874/* 875 * Evaluates the command results status in the SSB status field. 876 */ 877static void tms380tr_cmd_status_irq(struct net_device *dev) 878{ 879 struct net_local *tp = netdev_priv(dev); 880 unsigned short ssb_cmd, ssb_parm_0; 881 unsigned short ssb_parm_1; 882 char *open_err = "Open error -"; 883 char *code_err = "Open code -"; 884 885 /* Copy the ssb values to local variables */ 886 ssb_cmd = tp->ssb.STS; 887 ssb_parm_0 = tp->ssb.Parm[0]; 888 ssb_parm_1 = tp->ssb.Parm[1]; 889 890 if(ssb_cmd == OPEN) 891 { 892 tp->Sleeping = 0; 893 if(!tp->ReOpenInProgress) 894 wake_up_interruptible(&tp->wait_for_tok_int); 895 896 tp->OpenCommandIssued = 0; 897 tp->ScbInUse = 0; 898 899 if((ssb_parm_0 & 0x00FF) == GOOD_COMPLETION) 900 { 901 /* Success, the adapter is open. */ 902 tp->LobeWireFaultLogged = 0; 903 tp->AdapterOpenFlag = 1; 904 tp->AdapterVirtOpenFlag = 1; 905 tp->TransmitCommandActive = 0; 906 tms380tr_exec_cmd(dev, OC_TRANSMIT); 907 tms380tr_exec_cmd(dev, OC_RECEIVE); 908 909 if(tp->ReOpenInProgress) 910 tp->ReOpenInProgress = 0; 911 912 return; 913 } 914 else /* The adapter did not open. */ 915 { 916 if(ssb_parm_0 & NODE_ADDR_ERROR) 917 printk(KERN_INFO "%s: Node address error\n", 918 dev->name); 919 if(ssb_parm_0 & LIST_SIZE_ERROR) 920 printk(KERN_INFO "%s: List size error\n", 921 dev->name); 922 if(ssb_parm_0 & BUF_SIZE_ERROR) 923 printk(KERN_INFO "%s: Buffer size error\n", 924 dev->name); 925 if(ssb_parm_0 & TX_BUF_COUNT_ERROR) 926 printk(KERN_INFO "%s: Tx buffer count error\n", 927 dev->name); 928 if(ssb_parm_0 & INVALID_OPEN_OPTION) 929 printk(KERN_INFO "%s: Invalid open option\n", 930 dev->name); 931 if(ssb_parm_0 & OPEN_ERROR) 932 { 933 /* Show the open phase. */ 934 switch(ssb_parm_0 & OPEN_PHASES_MASK) 935 { 936 case LOBE_MEDIA_TEST: 937 if(!tp->LobeWireFaultLogged) 938 { 939 tp->LobeWireFaultLogged = 1; 940 printk(KERN_INFO "%s: %s Lobe wire fault (check cable !).\n", dev->name, open_err); 941 } 942 tp->ReOpenInProgress = 1; 943 tp->AdapterOpenFlag = 0; 944 tp->AdapterVirtOpenFlag = 1; 945 tms380tr_open_adapter(dev); 946 return; 947 948 case PHYSICAL_INSERTION: 949 printk(KERN_INFO "%s: %s Physical insertion.\n", dev->name, open_err); 950 break; 951 952 case ADDRESS_VERIFICATION: 953 printk(KERN_INFO "%s: %s Address verification.\n", dev->name, open_err); 954 break; 955 956 case PARTICIPATION_IN_RING_POLL: 957 printk(KERN_INFO "%s: %s Participation in ring poll.\n", dev->name, open_err); 958 break; 959 960 case REQUEST_INITIALISATION: 961 printk(KERN_INFO "%s: %s Request initialisation.\n", dev->name, open_err); 962 break; 963 964 case FULLDUPLEX_CHECK: 965 printk(KERN_INFO "%s: %s Full duplex check.\n", dev->name, open_err); 966 break; 967 968 default: 969 printk(KERN_INFO "%s: %s Unknown open phase\n", dev->name, open_err); 970 break; 971 } 972 973 /* Show the open errors. */ 974 switch(ssb_parm_0 & OPEN_ERROR_CODES_MASK) 975 { 976 case OPEN_FUNCTION_FAILURE: 977 printk(KERN_INFO "%s: %s OPEN_FUNCTION_FAILURE", dev->name, code_err); 978 tp->LastOpenStatus = 979 OPEN_FUNCTION_FAILURE; 980 break; 981 982 case OPEN_SIGNAL_LOSS: 983 printk(KERN_INFO "%s: %s OPEN_SIGNAL_LOSS\n", dev->name, code_err); 984 tp->LastOpenStatus = 985 OPEN_SIGNAL_LOSS; 986 break; 987 988 case OPEN_TIMEOUT: 989 printk(KERN_INFO "%s: %s OPEN_TIMEOUT\n", dev->name, code_err); 990 tp->LastOpenStatus = 991 OPEN_TIMEOUT; 992 break; 993 994 case OPEN_RING_FAILURE: 995 printk(KERN_INFO "%s: %s OPEN_RING_FAILURE\n", dev->name, code_err); 996 tp->LastOpenStatus = 997 OPEN_RING_FAILURE; 998 break; 999 1000 case OPEN_RING_BEACONING: 1001 printk(KERN_INFO "%s: %s OPEN_RING_BEACONING\n", dev->name, code_err); 1002 tp->LastOpenStatus = 1003 OPEN_RING_BEACONING; 1004 break; 1005 1006 case OPEN_DUPLICATE_NODEADDR: 1007 printk(KERN_INFO "%s: %s OPEN_DUPLICATE_NODEADDR\n", dev->name, code_err); 1008 tp->LastOpenStatus = 1009 OPEN_DUPLICATE_NODEADDR; 1010 break; 1011 1012 case OPEN_REQUEST_INIT: 1013 printk(KERN_INFO "%s: %s OPEN_REQUEST_INIT\n", dev->name, code_err); 1014 tp->LastOpenStatus = 1015 OPEN_REQUEST_INIT; 1016 break; 1017 1018 case OPEN_REMOVE_RECEIVED: 1019 printk(KERN_INFO "%s: %s OPEN_REMOVE_RECEIVED", dev->name, code_err); 1020 tp->LastOpenStatus = 1021 OPEN_REMOVE_RECEIVED; 1022 break; 1023 1024 case OPEN_FULLDUPLEX_SET: 1025 printk(KERN_INFO "%s: %s OPEN_FULLDUPLEX_SET\n", dev->name, code_err); 1026 tp->LastOpenStatus = 1027 OPEN_FULLDUPLEX_SET; 1028 break; 1029 1030 default: 1031 printk(KERN_INFO "%s: %s Unknown open err code", dev->name, code_err); 1032 tp->LastOpenStatus = 1033 OPEN_FUNCTION_FAILURE; 1034 break; 1035 } 1036 } 1037 1038 tp->AdapterOpenFlag = 0; 1039 tp->AdapterVirtOpenFlag = 0; 1040 1041 return; 1042 } 1043 } 1044 else 1045 { 1046 if(ssb_cmd != READ_ERROR_LOG) 1047 return; 1048 1049 /* Add values from the error log table to the MAC 1050 * statistics counters and update the errorlogtable 1051 * memory. 1052 */ 1053 tp->MacStat.line_errors += tp->errorlogtable.Line_Error; 1054 tp->MacStat.burst_errors += tp->errorlogtable.Burst_Error; 1055 tp->MacStat.A_C_errors += tp->errorlogtable.ARI_FCI_Error; 1056 tp->MacStat.lost_frames += tp->errorlogtable.Lost_Frame_Error; 1057 tp->MacStat.recv_congest_count += tp->errorlogtable.Rx_Congest_Error; 1058 tp->MacStat.rx_errors += tp->errorlogtable.Rx_Congest_Error; 1059 tp->MacStat.frame_copied_errors += tp->errorlogtable.Frame_Copied_Error; 1060 tp->MacStat.token_errors += tp->errorlogtable.Token_Error; 1061 tp->MacStat.dummy1 += tp->errorlogtable.DMA_Bus_Error; 1062 tp->MacStat.dummy1 += tp->errorlogtable.DMA_Parity_Error; 1063 tp->MacStat.abort_delimiters += tp->errorlogtable.AbortDelimeters; 1064 tp->MacStat.frequency_errors += tp->errorlogtable.Frequency_Error; 1065 tp->MacStat.internal_errors += tp->errorlogtable.Internal_Error; 1066 } 1067 1068 return; 1069} 1070 1071/* 1072 * The inverse routine to tms380tr_open(). 1073 */ 1074int tms380tr_close(struct net_device *dev) 1075{ 1076 struct net_local *tp = netdev_priv(dev); 1077 netif_stop_queue(dev); 1078 1079 del_timer(&tp->timer); 1080 1081 /* Flush the Tx and disable Rx here. */ 1082 1083 tp->HaltInProgress = 1; 1084 tms380tr_exec_cmd(dev, OC_CLOSE); 1085 tp->timer.expires = jiffies + 1*HZ; 1086 tp->timer.function = tms380tr_timer_end_wait; 1087 tp->timer.data = (unsigned long)dev; 1088 add_timer(&tp->timer); 1089 1090 tms380tr_enable_interrupts(dev); 1091 1092 tp->Sleeping = 1; 1093 interruptible_sleep_on(&tp->wait_for_tok_int); 1094 tp->TransmitCommandActive = 0; 1095 1096 del_timer(&tp->timer); 1097 tms380tr_disable_interrupts(dev); 1098 1099#ifdef CONFIG_ISA 1100 if(dev->dma > 0) 1101 { 1102 unsigned long flags=claim_dma_lock(); 1103 disable_dma(dev->dma); 1104 release_dma_lock(flags); 1105 } 1106#endif 1107 1108 SIFWRITEW(0xFF00, SIFCMD); 1109 tms380tr_cancel_tx_queue(tp); 1110 1111 return (0); 1112} 1113 1114/* 1115 * Get the current statistics. This may be called with the card open 1116 * or closed. 1117 */ 1118static struct net_device_stats *tms380tr_get_stats(struct net_device *dev) 1119{ 1120 struct net_local *tp = netdev_priv(dev); 1121 1122 return ((struct net_device_stats *)&tp->MacStat); 1123} 1124 1125/* 1126 * Set or clear the multicast filter for this adapter. 1127 */ 1128static void tms380tr_set_multicast_list(struct net_device *dev) 1129{ 1130 struct net_local *tp = netdev_priv(dev); 1131 unsigned int OpenOptions; 1132 1133 OpenOptions = tp->ocpl.OPENOptions & 1134 ~(PASS_ADAPTER_MAC_FRAMES 1135 | PASS_ATTENTION_FRAMES 1136 | PASS_BEACON_MAC_FRAMES 1137 | COPY_ALL_MAC_FRAMES 1138 | COPY_ALL_NON_MAC_FRAMES); 1139 1140 tp->ocpl.FunctAddr = 0; 1141 1142 if(dev->flags & IFF_PROMISC) 1143 /* Enable promiscuous mode */ 1144 OpenOptions |= COPY_ALL_NON_MAC_FRAMES | 1145 COPY_ALL_MAC_FRAMES; 1146 else 1147 { 1148 if(dev->flags & IFF_ALLMULTI) 1149 { 1150 /* Disable promiscuous mode, use normal mode. */ 1151 tp->ocpl.FunctAddr = 0xFFFFFFFF; 1152 } 1153 else 1154 { 1155 int i; 1156 struct dev_mc_list *mclist = dev->mc_list; 1157 for (i=0; i< dev->mc_count; i++) 1158 { 1159 ((char *)(&tp->ocpl.FunctAddr))[0] |= 1160 mclist->dmi_addr[2]; 1161 ((char *)(&tp->ocpl.FunctAddr))[1] |= 1162 mclist->dmi_addr[3]; 1163 ((char *)(&tp->ocpl.FunctAddr))[2] |= 1164 mclist->dmi_addr[4]; 1165 ((char *)(&tp->ocpl.FunctAddr))[3] |= 1166 mclist->dmi_addr[5]; 1167 mclist = mclist->next; 1168 } 1169 } 1170 tms380tr_exec_cmd(dev, OC_SET_FUNCT_ADDR); 1171 } 1172 1173 tp->ocpl.OPENOptions = OpenOptions; 1174 tms380tr_exec_cmd(dev, OC_MODIFY_OPEN_PARMS); 1175 return; 1176} 1177 1178/* 1179 * Wait for some time (microseconds) 1180 */ 1181void tms380tr_wait(unsigned long time) 1182{ 1183 udelay(time); 1184 return; 1185} 1186 1187/* 1188 * Write a command value to the SIFCMD register 1189 */ 1190static void tms380tr_exec_sifcmd(struct net_device *dev, unsigned int WriteValue) 1191{ 1192 unsigned short cmd; 1193 unsigned short SifStsValue; 1194 unsigned long loop_counter; 1195 1196 WriteValue = ((WriteValue ^ CMD_SYSTEM_IRQ) | CMD_INTERRUPT_ADAPTER); 1197 cmd = (unsigned short)WriteValue; 1198 loop_counter = 0,5 * 800000; 1199 do { 1200 SifStsValue = SIFREADW(SIFSTS); 1201 } while((SifStsValue & CMD_INTERRUPT_ADAPTER) && loop_counter--); 1202 SIFWRITEW(cmd, SIFCMD); 1203 1204 return; 1205} 1206 1207/* 1208 * Processes adapter hardware reset, halts adapter and downloads firmware, 1209 * clears the halt bit. 1210 */ 1211static int tms380tr_reset_adapter(struct net_device *dev) 1212{ 1213 struct net_local *tp = netdev_priv(dev); 1214 unsigned short *fw_ptr; 1215 unsigned short count, c, count2; 1216 const struct firmware *fw_entry = NULL; 1217 1218 if (request_firmware(&fw_entry, "tms380tr.bin", tp->pdev) != 0) { 1219 printk(KERN_ALERT "%s: firmware %s is missing, cannot start.\n", 1220 dev->name, "tms380tr.bin"); 1221 return (-1); 1222 } 1223 1224 fw_ptr = (unsigned short *)fw_entry->data; 1225 count2 = fw_entry->size / 2; 1226 1227 /* Hardware adapter reset */ 1228 SIFWRITEW(ACL_ARESET, SIFACL); 1229 tms380tr_wait(40); 1230 1231 c = SIFREADW(SIFACL); 1232 tms380tr_wait(20); 1233 1234 if(dev->dma == 0) /* For PCI adapters */ 1235 { 1236 c &= ~(ACL_NSELOUT0 | ACL_NSELOUT1); /* Clear bits */ 1237 if(tp->setnselout) 1238 c |= (*tp->setnselout)(dev); 1239 } 1240 1241 /* In case a command is pending - forget it */ 1242 tp->ScbInUse = 0; 1243 1244 c &= ~ACL_ARESET; /* Clear adapter reset bit */ 1245 c |= ACL_CPHALT; /* Halt adapter CPU, allow download */ 1246 c |= ACL_BOOT; 1247 c |= ACL_SINTEN; 1248 c &= ~ACL_PSDMAEN; /* Clear pseudo dma bit */ 1249 SIFWRITEW(c, SIFACL); 1250 tms380tr_wait(40); 1251 1252 count = 0; 1253 /* Download firmware via DIO interface: */ 1254 do { 1255 if (count2 < 3) continue; 1256 1257 /* Download first address part */ 1258 SIFWRITEW(*fw_ptr, SIFADX); 1259 fw_ptr++; 1260 count2--; 1261 /* Download second address part */ 1262 SIFWRITEW(*fw_ptr, SIFADD); 1263 fw_ptr++; 1264 count2--; 1265 1266 if((count = *fw_ptr) != 0) /* Load loop counter */ 1267 { 1268 fw_ptr++; /* Download block data */ 1269 count2--; 1270 if (count > count2) continue; 1271 1272 for(; count > 0; count--) 1273 { 1274 SIFWRITEW(*fw_ptr, SIFINC); 1275 fw_ptr++; 1276 count2--; 1277 } 1278 } 1279 else /* Stop, if last block downloaded */ 1280 { 1281 c = SIFREADW(SIFACL); 1282 c &= (~ACL_CPHALT | ACL_SINTEN); 1283 1284 /* Clear CPHALT and start BUD */ 1285 SIFWRITEW(c, SIFACL); 1286 if (fw_entry) 1287 release_firmware(fw_entry); 1288 return (1); 1289 } 1290 } while(count == 0); 1291 1292 if (fw_entry) 1293 release_firmware(fw_entry); 1294 printk(KERN_INFO "%s: Adapter Download Failed\n", dev->name); 1295 return (-1); 1296} 1297 1298/* 1299 * Starts bring up diagnostics of token ring adapter and evaluates 1300 * diagnostic results. 1301 */ 1302static int tms380tr_bringup_diags(struct net_device *dev) 1303{ 1304 int loop_cnt, retry_cnt; 1305 unsigned short Status; 1306 1307 tms380tr_wait(HALF_SECOND); 1308 tms380tr_exec_sifcmd(dev, EXEC_SOFT_RESET); 1309 tms380tr_wait(HALF_SECOND); 1310 1311 retry_cnt = BUD_MAX_RETRIES; /* maximal number of retrys */ 1312 1313 do { 1314 retry_cnt--; 1315 if(tms380tr_debug > 3) 1316 printk(KERN_DEBUG "BUD-Status: "); 1317 loop_cnt = BUD_MAX_LOOPCNT; /* maximum: three seconds*/ 1318 do { /* Inspect BUD results */ 1319 loop_cnt--; 1320 tms380tr_wait(HALF_SECOND); 1321 Status = SIFREADW(SIFSTS); 1322 Status &= STS_MASK; 1323 1324 if(tms380tr_debug > 3) 1325 printk(KERN_DEBUG " %04X \n", Status); 1326 /* BUD successfully completed */ 1327 if(Status == STS_INITIALIZE) 1328 return (1); 1329 /* Unrecoverable hardware error, BUD not completed? */ 1330 } while((loop_cnt > 0) && ((Status & (STS_ERROR | STS_TEST)) 1331 != (STS_ERROR | STS_TEST))); 1332 1333 /* Error preventing completion of BUD */ 1334 if(retry_cnt > 0) 1335 { 1336 printk(KERN_INFO "%s: Adapter Software Reset.\n", 1337 dev->name); 1338 tms380tr_exec_sifcmd(dev, EXEC_SOFT_RESET); 1339 tms380tr_wait(HALF_SECOND); 1340 } 1341 } while(retry_cnt > 0); 1342 1343 Status = SIFREADW(SIFSTS); 1344 1345 printk(KERN_INFO "%s: Hardware error\n", dev->name); 1346 /* Hardware error occurred! */ 1347 Status &= 0x001f; 1348 if (Status & 0x0010) 1349 printk(KERN_INFO "%s: BUD Error: Timeout\n", dev->name); 1350 else if ((Status & 0x000f) > 6) 1351 printk(KERN_INFO "%s: BUD Error: Illegal Failure\n", dev->name); 1352 else 1353 printk(KERN_INFO "%s: Bring Up Diagnostics Error (%04X) occurred\n", dev->name, Status & 0x000f); 1354 1355 return (-1); 1356} 1357 1358/* 1359 * Copy initialisation data to adapter memory, beginning at address 1360 * 1:0A00; Starting DMA test and evaluating result bits. 1361 */ 1362static int tms380tr_init_adapter(struct net_device *dev) 1363{ 1364 struct net_local *tp = netdev_priv(dev); 1365 1366 const unsigned char SCB_Test[6] = {0x00, 0x00, 0xC1, 0xE2, 0xD4, 0x8B}; 1367 const unsigned char SSB_Test[8] = {0xFF, 0xFF, 0xD1, 0xD7, 1368 0xC5, 0xD9, 0xC3, 0xD4}; 1369 void *ptr = (void *)&tp->ipb; 1370 unsigned short *ipb_ptr = (unsigned short *)ptr; 1371 unsigned char *cb_ptr = (unsigned char *) &tp->scb; 1372 unsigned char *sb_ptr = (unsigned char *) &tp->ssb; 1373 unsigned short Status; 1374 int i, loop_cnt, retry_cnt; 1375 1376 /* Normalize: byte order low/high, word order high/low! (only IPB!) */ 1377 tp->ipb.SCB_Addr = SWAPW(((char *)&tp->scb - (char *)tp) + tp->dmabuffer); 1378 tp->ipb.SSB_Addr = SWAPW(((char *)&tp->ssb - (char *)tp) + tp->dmabuffer); 1379 1380 if(tms380tr_debug > 3) 1381 { 1382 printk(KERN_DEBUG "%s: buffer (real): %lx\n", dev->name, (long) &tp->scb); 1383 printk(KERN_DEBUG "%s: buffer (virt): %lx\n", dev->name, (long) ((char *)&tp->scb - (char *)tp) + (long) tp->dmabuffer); 1384 printk(KERN_DEBUG "%s: buffer (DMA) : %lx\n", dev->name, (long) tp->dmabuffer); 1385 printk(KERN_DEBUG "%s: buffer (tp) : %lx\n", dev->name, (long) tp); 1386 } 1387 /* Maximum: three initialization retries */ 1388 retry_cnt = INIT_MAX_RETRIES; 1389 1390 do { 1391 retry_cnt--; 1392 1393 /* Transfer initialization block */ 1394 SIFWRITEW(0x0001, SIFADX); 1395 1396 /* To address 0001:0A00 of adapter RAM */ 1397 SIFWRITEW(0x0A00, SIFADD); 1398 1399 /* Write 11 words to adapter RAM */ 1400 for(i = 0; i < 11; i++) 1401 SIFWRITEW(ipb_ptr[i], SIFINC); 1402 1403 /* Execute SCB adapter command */ 1404 tms380tr_exec_sifcmd(dev, CMD_EXECUTE); 1405 1406 loop_cnt = INIT_MAX_LOOPCNT; /* Maximum: 11 seconds */ 1407 1408 /* While remaining retries, no error and not completed */ 1409 do { 1410 Status = 0; 1411 loop_cnt--; 1412 tms380tr_wait(HALF_SECOND); 1413 1414 /* Mask interesting status bits */ 1415 Status = SIFREADW(SIFSTS); 1416 Status &= STS_MASK; 1417 } while(((Status &(STS_INITIALIZE | STS_ERROR | STS_TEST)) != 0) 1418 && ((Status & STS_ERROR) == 0) && (loop_cnt != 0)); 1419 1420 if((Status & (STS_INITIALIZE | STS_ERROR | STS_TEST)) == 0) 1421 { 1422 /* Initialization completed without error */ 1423 i = 0; 1424 do { /* Test if contents of SCB is valid */ 1425 if(SCB_Test[i] != *(cb_ptr + i)) 1426 { 1427 printk(KERN_INFO "%s: DMA failed\n", dev->name); 1428 /* DMA data error: wrong data in SCB */ 1429 return (-1); 1430 } 1431 i++; 1432 } while(i < 6); 1433 1434 i = 0; 1435 do { /* Test if contents of SSB is valid */ 1436 if(SSB_Test[i] != *(sb_ptr + i)) 1437 /* DMA data error: wrong data in SSB */ 1438 return (-1); 1439 i++; 1440 } while (i < 8); 1441 1442 return (1); /* Adapter successfully initialized */ 1443 } 1444 else 1445 { 1446 if((Status & STS_ERROR) != 0) 1447 { 1448 /* Initialization error occurred */ 1449 Status = SIFREADW(SIFSTS); 1450 Status &= STS_ERROR_MASK; 1451 /* ShowInitialisationErrorCode(Status); */ 1452 printk(KERN_INFO "%s: Status error: %d\n", dev->name, Status); 1453 return (-1); /* Unrecoverable error */ 1454 } 1455 else 1456 { 1457 if(retry_cnt > 0) 1458 { 1459 /* Reset adapter and try init again */ 1460 tms380tr_exec_sifcmd(dev, EXEC_SOFT_RESET); 1461 tms380tr_wait(HALF_SECOND); 1462 } 1463 } 1464 } 1465 } while(retry_cnt > 0); 1466 1467 printk(KERN_INFO "%s: Retry exceeded\n", dev->name); 1468 return (-1); 1469} 1470 1471/* 1472 * Check for outstanding commands in command queue and tries to execute 1473 * command immediately. Corresponding command flag in command queue is cleared. 1474 */ 1475static void tms380tr_chk_outstanding_cmds(struct net_device *dev) 1476{ 1477 struct net_local *tp = netdev_priv(dev); 1478 unsigned long Addr = 0; 1479 1480 if(tp->CMDqueue == 0) 1481 return; /* No command execution */ 1482 1483 /* If SCB in use: no command */ 1484 if(tp->ScbInUse == 1) 1485 return; 1486 1487 /* Check if adapter is opened, avoiding COMMAND_REJECT 1488 * interrupt by the adapter! 1489 */ 1490 if(tp->AdapterOpenFlag == 0) 1491 { 1492 if(tp->CMDqueue & OC_OPEN) 1493 { 1494 /* Execute OPEN command */ 1495 tp->CMDqueue ^= OC_OPEN; 1496 1497 Addr = htonl(((char *)&tp->ocpl - (char *)tp) + tp->dmabuffer); 1498 tp->scb.Parm[0] = LOWORD(Addr); 1499 tp->scb.Parm[1] = HIWORD(Addr); 1500 tp->scb.CMD = OPEN; 1501 } 1502 else 1503 /* No OPEN command queued, but adapter closed. Note: 1504 * We'll try to re-open the adapter in DriverPoll() 1505 */ 1506 return; /* No adapter command issued */ 1507 } 1508 else 1509 { 1510 /* Adapter is open; evaluate command queue: try to execute 1511 * outstanding commands (depending on priority!) CLOSE 1512 * command queued 1513 */ 1514 if(tp->CMDqueue & OC_CLOSE) 1515 { 1516 tp->CMDqueue ^= OC_CLOSE; 1517 tp->AdapterOpenFlag = 0; 1518 tp->scb.Parm[0] = 0; /* Parm[0], Parm[1] are ignored */ 1519 tp->scb.Parm[1] = 0; /* but should be set to zero! */ 1520 tp->scb.CMD = CLOSE; 1521 if(!tp->HaltInProgress) 1522 tp->CMDqueue |= OC_OPEN; /* re-open adapter */ 1523 else 1524 tp->CMDqueue = 0; /* no more commands */ 1525 } 1526 else 1527 { 1528 if(tp->CMDqueue & OC_RECEIVE) 1529 { 1530 tp->CMDqueue ^= OC_RECEIVE; 1531 Addr = htonl(((char *)tp->RplHead - (char *)tp) + tp->dmabuffer); 1532 tp->scb.Parm[0] = LOWORD(Addr); 1533 tp->scb.Parm[1] = HIWORD(Addr); 1534 tp->scb.CMD = RECEIVE; 1535 } 1536 else 1537 { 1538 if(tp->CMDqueue & OC_TRANSMIT_HALT) 1539 { 1540 /* NOTE: TRANSMIT.HALT must be checked 1541 * before TRANSMIT. 1542 */ 1543 tp->CMDqueue ^= OC_TRANSMIT_HALT; 1544 tp->scb.CMD = TRANSMIT_HALT; 1545 1546 /* Parm[0] and Parm[1] are ignored 1547 * but should be set to zero! 1548 */ 1549 tp->scb.Parm[0] = 0; 1550 tp->scb.Parm[1] = 0; 1551 } 1552 else 1553 { 1554 if(tp->CMDqueue & OC_TRANSMIT) 1555 { 1556 /* NOTE: TRANSMIT must be 1557 * checked after TRANSMIT.HALT 1558 */ 1559 if(tp->TransmitCommandActive) 1560 { 1561 if(!tp->TransmitHaltScheduled) 1562 { 1563 tp->TransmitHaltScheduled = 1; 1564 tms380tr_exec_cmd(dev, OC_TRANSMIT_HALT) ; 1565 } 1566 tp->TransmitCommandActive = 0; 1567 return; 1568 } 1569 1570 tp->CMDqueue ^= OC_TRANSMIT; 1571 tms380tr_cancel_tx_queue(tp); 1572 Addr = htonl(((char *)tp->TplBusy - (char *)tp) + tp->dmabuffer); 1573 tp->scb.Parm[0] = LOWORD(Addr); 1574 tp->scb.Parm[1] = HIWORD(Addr); 1575 tp->scb.CMD = TRANSMIT; 1576 tp->TransmitCommandActive = 1; 1577 } 1578 else 1579 { 1580 if(tp->CMDqueue & OC_MODIFY_OPEN_PARMS) 1581 { 1582 tp->CMDqueue ^= OC_MODIFY_OPEN_PARMS; 1583 tp->scb.Parm[0] = tp->ocpl.OPENOptions; /* new OPEN options*/ 1584 tp->scb.Parm[0] |= ENABLE_FULL_DUPLEX_SELECTION; 1585 tp->scb.Parm[1] = 0; /* is ignored but should be zero */ 1586 tp->scb.CMD = MODIFY_OPEN_PARMS; 1587 } 1588 else 1589 { 1590 if(tp->CMDqueue & OC_SET_FUNCT_ADDR) 1591 { 1592 tp->CMDqueue ^= OC_SET_FUNCT_ADDR; 1593 tp->scb.Parm[0] = LOWORD(tp->ocpl.FunctAddr); 1594 tp->scb.Parm[1] = HIWORD(tp->ocpl.FunctAddr); 1595 tp->scb.CMD = SET_FUNCT_ADDR; 1596 } 1597 else 1598 { 1599 if(tp->CMDqueue & OC_SET_GROUP_ADDR) 1600 { 1601 tp->CMDqueue ^= OC_SET_GROUP_ADDR; 1602 tp->scb.Parm[0] = LOWORD(tp->ocpl.GroupAddr); 1603 tp->scb.Parm[1] = HIWORD(tp->ocpl.GroupAddr); 1604 tp->scb.CMD = SET_GROUP_ADDR; 1605 } 1606 else 1607 { 1608 if(tp->CMDqueue & OC_READ_ERROR_LOG) 1609 { 1610 tp->CMDqueue ^= OC_READ_ERROR_LOG; 1611 Addr = htonl(((char *)&tp->errorlogtable - (char *)tp) + tp->dmabuffer); 1612 tp->scb.Parm[0] = LOWORD(Addr); 1613 tp->scb.Parm[1] = HIWORD(Addr); 1614 tp->scb.CMD = READ_ERROR_LOG; 1615 } 1616 else 1617 { 1618 printk(KERN_WARNING "CheckForOutstandingCommand: unknown Command\n"); 1619 tp->CMDqueue = 0; 1620 return; 1621 } 1622 } 1623 } 1624 } 1625 } 1626 } 1627 } 1628 } 1629 } 1630 1631 tp->ScbInUse = 1; /* Set semaphore: SCB in use. */ 1632 1633 /* Execute SCB and generate IRQ when done. */ 1634 tms380tr_exec_sifcmd(dev, CMD_EXECUTE | CMD_SCB_REQUEST); 1635 1636 return; 1637} 1638 1639/* 1640 * IRQ conditions: signal loss on the ring, transmit or receive of beacon 1641 * frames (disabled if bit 1 of OPEN option is set); report error MAC 1642 * frame transmit (disabled if bit 2 of OPEN option is set); open or short 1643 * circuit fault on the lobe is detected; remove MAC frame received; 1644 * error counter overflow (255); opened adapter is the only station in ring. 1645 * After some of the IRQs the adapter is closed! 1646 */ 1647static void tms380tr_ring_status_irq(struct net_device *dev) 1648{ 1649 struct net_local *tp = netdev_priv(dev); 1650 1651 tp->CurrentRingStatus = be16_to_cpu((unsigned short)tp->ssb.Parm[0]); 1652 1653 /* First: fill up statistics */ 1654 if(tp->ssb.Parm[0] & SIGNAL_LOSS) 1655 { 1656 printk(KERN_INFO "%s: Signal Loss\n", dev->name); 1657 tp->MacStat.line_errors++; 1658 } 1659 1660 /* Adapter is closed, but initialized */ 1661 if(tp->ssb.Parm[0] & LOBE_WIRE_FAULT) 1662 { 1663 printk(KERN_INFO "%s: Lobe Wire Fault, Reopen Adapter\n", 1664 dev->name); 1665 tp->MacStat.line_errors++; 1666 } 1667 1668 if(tp->ssb.Parm[0] & RING_RECOVERY) 1669 printk(KERN_INFO "%s: Ring Recovery\n", dev->name); 1670 1671 /* Counter overflow: read error log */ 1672 if(tp->ssb.Parm[0] & COUNTER_OVERFLOW) 1673 { 1674 printk(KERN_INFO "%s: Counter Overflow\n", dev->name); 1675 tms380tr_exec_cmd(dev, OC_READ_ERROR_LOG); 1676 } 1677 1678 /* Adapter is closed, but initialized */ 1679 if(tp->ssb.Parm[0] & REMOVE_RECEIVED) 1680 printk(KERN_INFO "%s: Remove Received, Reopen Adapter\n", 1681 dev->name); 1682 1683 /* Adapter is closed, but initialized */ 1684 if(tp->ssb.Parm[0] & AUTO_REMOVAL_ERROR) 1685 printk(KERN_INFO "%s: Auto Removal Error, Reopen Adapter\n", 1686 dev->name); 1687 1688 if(tp->ssb.Parm[0] & HARD_ERROR) 1689 printk(KERN_INFO "%s: Hard Error\n", dev->name); 1690 1691 if(tp->ssb.Parm[0] & SOFT_ERROR) 1692 printk(KERN_INFO "%s: Soft Error\n", dev->name); 1693 1694 if(tp->ssb.Parm[0] & TRANSMIT_BEACON) 1695 printk(KERN_INFO "%s: Transmit Beacon\n", dev->name); 1696 1697 if(tp->ssb.Parm[0] & SINGLE_STATION) 1698 printk(KERN_INFO "%s: Single Station\n", dev->name); 1699 1700 /* Check if adapter has been closed */ 1701 if(tp->ssb.Parm[0] & ADAPTER_CLOSED) 1702 { 1703 printk(KERN_INFO "%s: Adapter closed (Reopening)," 1704 "CurrentRingStat %x\n", 1705 dev->name, tp->CurrentRingStatus); 1706 tp->AdapterOpenFlag = 0; 1707 tms380tr_open_adapter(dev); 1708 } 1709 1710 return; 1711} 1712 1713/* 1714 * Issued if adapter has encountered an unrecoverable hardware 1715 * or software error. 1716 */ 1717static void tms380tr_chk_irq(struct net_device *dev) 1718{ 1719 int i; 1720 unsigned short AdapterCheckBlock[4]; 1721 struct net_local *tp = netdev_priv(dev); 1722 1723 tp->AdapterOpenFlag = 0; /* Adapter closed now */ 1724 1725 /* Page number of adapter memory */ 1726 SIFWRITEW(0x0001, SIFADX); 1727 /* Address offset */ 1728 SIFWRITEW(CHECKADDR, SIFADR); 1729 1730 /* Reading 8 byte adapter check block. */ 1731 for(i = 0; i < 4; i++) 1732 AdapterCheckBlock[i] = SIFREADW(SIFINC); 1733 1734 if(tms380tr_debug > 3) 1735 { 1736 printk(KERN_DEBUG "%s: AdapterCheckBlock: ", dev->name); 1737 for (i = 0; i < 4; i++) 1738 printk("%04X", AdapterCheckBlock[i]); 1739 printk("\n"); 1740 } 1741 1742 switch(AdapterCheckBlock[0]) 1743 { 1744 case DIO_PARITY: 1745 printk(KERN_INFO "%s: DIO parity error\n", dev->name); 1746 break; 1747 1748 case DMA_READ_ABORT: 1749 printk(KERN_INFO "%s DMA read operation aborted:\n", 1750 dev->name); 1751 switch (AdapterCheckBlock[1]) 1752 { 1753 case 0: 1754 printk(KERN_INFO "Timeout\n"); 1755 printk(KERN_INFO "Address: %04X %04X\n", 1756 AdapterCheckBlock[2], 1757 AdapterCheckBlock[3]); 1758 break; 1759 1760 case 1: 1761 printk(KERN_INFO "Parity error\n"); 1762 printk(KERN_INFO "Address: %04X %04X\n", 1763 AdapterCheckBlock[2], 1764 AdapterCheckBlock[3]); 1765 break; 1766 1767 case 2: 1768 printk(KERN_INFO "Bus error\n"); 1769 printk(KERN_INFO "Address: %04X %04X\n", 1770 AdapterCheckBlock[2], 1771 AdapterCheckBlock[3]); 1772 break; 1773 1774 default: 1775 printk(KERN_INFO "Unknown error.\n"); 1776 break; 1777 } 1778 break; 1779 1780 case DMA_WRITE_ABORT: 1781 printk(KERN_INFO "%s: DMA write operation aborted: \n", 1782 dev->name); 1783 switch (AdapterCheckBlock[1]) 1784 { 1785 case 0: 1786 printk(KERN_INFO "Timeout\n"); 1787 printk(KERN_INFO "Address: %04X %04X\n", 1788 AdapterCheckBlock[2], 1789 AdapterCheckBlock[3]); 1790 break; 1791 1792 case 1: 1793 printk(KERN_INFO "Parity error\n"); 1794 printk(KERN_INFO "Address: %04X %04X\n", 1795 AdapterCheckBlock[2], 1796 AdapterCheckBlock[3]); 1797 break; 1798 1799 case 2: 1800 printk(KERN_INFO "Bus error\n"); 1801 printk(KERN_INFO "Address: %04X %04X\n", 1802 AdapterCheckBlock[2], 1803 AdapterCheckBlock[3]); 1804 break; 1805 1806 default: 1807 printk(KERN_INFO "Unknown error.\n"); 1808 break; 1809 } 1810 break; 1811 1812 case ILLEGAL_OP_CODE: 1813 printk(KERN_INFO "%s: Illegal operation code in firmware\n", 1814 dev->name); 1815 /* Parm[0-3]: adapter internal register R13-R15 */ 1816 break; 1817 1818 case PARITY_ERRORS: 1819 printk(KERN_INFO "%s: Adapter internal bus parity error\n", 1820 dev->name); 1821 /* Parm[0-3]: adapter internal register R13-R15 */ 1822 break; 1823 1824 case RAM_DATA_ERROR: 1825 printk(KERN_INFO "%s: RAM data error\n", dev->name); 1826 /* Parm[0-1]: MSW/LSW address of RAM location. */ 1827 break; 1828 1829 case RAM_PARITY_ERROR: 1830 printk(KERN_INFO "%s: RAM parity error\n", dev->name); 1831 /* Parm[0-1]: MSW/LSW address of RAM location. */ 1832 break; 1833 1834 case RING_UNDERRUN: 1835 printk(KERN_INFO "%s: Internal DMA underrun detected\n", 1836 dev->name); 1837 break; 1838 1839 case INVALID_IRQ: 1840 printk(KERN_INFO "%s: Unrecognized interrupt detected\n", 1841 dev->name); 1842 /* Parm[0-3]: adapter internal register R13-R15 */ 1843 break; 1844 1845 case INVALID_ERROR_IRQ: 1846 printk(KERN_INFO "%s: Unrecognized error interrupt detected\n", 1847 dev->name); 1848 /* Parm[0-3]: adapter internal register R13-R15 */ 1849 break; 1850 1851 case INVALID_XOP: 1852 printk(KERN_INFO "%s: Unrecognized XOP request detected\n", 1853 dev->name); 1854 /* Parm[0-3]: adapter internal register R13-R15 */ 1855 break; 1856 1857 default: 1858 printk(KERN_INFO "%s: Unknown status", dev->name); 1859 break; 1860 } 1861 1862 if(tms380tr_chipset_init(dev) == 1) 1863 { 1864 /* Restart of firmware successful */ 1865 tp->AdapterOpenFlag = 1; 1866 } 1867 1868 return; 1869} 1870 1871/* 1872 * Internal adapter pointer to RAM data are copied from adapter into 1873 * host system. 1874 */ 1875static int tms380tr_read_ptr(struct net_device *dev) 1876{ 1877 struct net_local *tp = netdev_priv(dev); 1878 unsigned short adapterram; 1879 1880 tms380tr_read_ram(dev, (unsigned char *)&tp->intptrs.BurnedInAddrPtr, 1881 ADAPTER_INT_PTRS, 16); 1882 tms380tr_read_ram(dev, (unsigned char *)&adapterram, 1883 cpu_to_be16((unsigned short)tp->intptrs.AdapterRAMPtr), 2); 1884 return be16_to_cpu(adapterram); 1885} 1886 1887/* 1888 * Reads a number of bytes from adapter to system memory. 1889 */ 1890static void tms380tr_read_ram(struct net_device *dev, unsigned char *Data, 1891 unsigned short Address, int Length) 1892{ 1893 int i; 1894 unsigned short old_sifadx, old_sifadr, InWord; 1895 1896 /* Save the current values */ 1897 old_sifadx = SIFREADW(SIFADX); 1898 old_sifadr = SIFREADW(SIFADR); 1899 1900 /* Page number of adapter memory */ 1901 SIFWRITEW(0x0001, SIFADX); 1902 /* Address offset in adapter RAM */ 1903 SIFWRITEW(Address, SIFADR); 1904 1905 /* Copy len byte from adapter memory to system data area. */ 1906 i = 0; 1907 for(;;) 1908 { 1909 InWord = SIFREADW(SIFINC); 1910 1911 *(Data + i) = HIBYTE(InWord); /* Write first byte */ 1912 if(++i == Length) /* All is done break */ 1913 break; 1914 1915 *(Data + i) = LOBYTE(InWord); /* Write second byte */ 1916 if (++i == Length) /* All is done break */ 1917 break; 1918 } 1919 1920 /* Restore original values */ 1921 SIFWRITEW(old_sifadx, SIFADX); 1922 SIFWRITEW(old_sifadr, SIFADR); 1923 1924 return; 1925} 1926 1927/* 1928 * Cancel all queued packets in the transmission queue. 1929 */ 1930static void tms380tr_cancel_tx_queue(struct net_local* tp) 1931{ 1932 TPL *tpl; 1933 1934 /* 1935 * NOTE: There must not be an active TRANSMIT command pending, when 1936 * this function is called. 1937 */ 1938 if(tp->TransmitCommandActive) 1939 return; 1940 1941 for(;;) 1942 { 1943 tpl = tp->TplBusy; 1944 if(!tpl->BusyFlag) 1945 break; 1946 /* "Remove" TPL from busy list. */ 1947 tp->TplBusy = tpl->NextTPLPtr; 1948 tms380tr_write_tpl_status(tpl, 0); /* Clear VALID bit */ 1949 tpl->BusyFlag = 0; /* "free" TPL */ 1950 1951 printk(KERN_INFO "Cancel tx (%08lXh).\n", (unsigned long)tpl); 1952 if (tpl->DMABuff) 1953 dma_unmap_single(tp->pdev, tpl->DMABuff, tpl->Skb->len, DMA_TO_DEVICE); 1954 dev_kfree_skb_any(tpl->Skb); 1955 } 1956 1957 return; 1958} 1959 1960/* 1961 * This function is called whenever a transmit interrupt is generated by the 1962 * adapter. For a command complete interrupt, it is checked if we have to 1963 * issue a new transmit command or not. 1964 */ 1965static void tms380tr_tx_status_irq(struct net_device *dev) 1966{ 1967 struct net_local *tp = netdev_priv(dev); 1968 unsigned char HighByte, HighAc, LowAc; 1969 TPL *tpl; 1970 1971 /* NOTE: At this point the SSB from TRANSMIT STATUS is no longer 1972 * available, because the CLEAR SSB command has already been issued. 1973 * 1974 * Process all complete transmissions. 1975 */ 1976 1977 for(;;) 1978 { 1979 tpl = tp->TplBusy; 1980 if(!tpl->BusyFlag || (tpl->Status 1981 & (TX_VALID | TX_FRAME_COMPLETE)) 1982 != TX_FRAME_COMPLETE) 1983 { 1984 break; 1985 } 1986 1987 /* "Remove" TPL from busy list. */ 1988 tp->TplBusy = tpl->NextTPLPtr ; 1989 1990 /* Check the transmit status field only for directed frames*/ 1991 if(DIRECTED_FRAME(tpl) && (tpl->Status & TX_ERROR) == 0) 1992 { 1993 HighByte = GET_TRANSMIT_STATUS_HIGH_BYTE(tpl->Status); 1994 HighAc = GET_FRAME_STATUS_HIGH_AC(HighByte); 1995 LowAc = GET_FRAME_STATUS_LOW_AC(HighByte); 1996 1997 if((HighAc != LowAc) || (HighAc == AC_NOT_RECOGNIZED)) 1998 { 1999 printk(KERN_DEBUG "%s: (DA=%08lX not recognized)\n", 2000 dev->name, 2001 *(unsigned long *)&tpl->MData[2+2]); 2002 } 2003 else 2004 { 2005 if(tms380tr_debug > 3) 2006 printk(KERN_DEBUG "%s: Directed frame tx'd\n", 2007 dev->name); 2008 } 2009 } 2010 else 2011 { 2012 if(!DIRECTED_FRAME(tpl)) 2013 { 2014 if(tms380tr_debug > 3) 2015 printk(KERN_DEBUG "%s: Broadcast frame tx'd\n", 2016 dev->name); 2017 } 2018 } 2019 2020 tp->MacStat.tx_packets++; 2021 if (tpl->DMABuff) 2022 dma_unmap_single(tp->pdev, tpl->DMABuff, tpl->Skb->len, DMA_TO_DEVICE); 2023 dev_kfree_skb_irq(tpl->Skb); 2024 tpl->BusyFlag = 0; /* "free" TPL */ 2025 } 2026 2027 if(!tp->TplFree->NextTPLPtr->BusyFlag) 2028 netif_wake_queue(dev); 2029 return; 2030} 2031 2032/* 2033 * Called if a frame receive interrupt is generated by the adapter. 2034 * Check if the frame is valid and indicate it to system. 2035 */ 2036static void tms380tr_rcv_status_irq(struct net_device *dev) 2037{ 2038 struct net_local *tp = netdev_priv(dev); 2039 unsigned char *ReceiveDataPtr; 2040 struct sk_buff *skb; 2041 unsigned int Length, Length2; 2042 RPL *rpl; 2043 RPL *SaveHead; 2044 dma_addr_t dmabuf; 2045 2046 /* NOTE: At this point the SSB from RECEIVE STATUS is no longer 2047 * available, because the CLEAR SSB command has already been issued. 2048 * 2049 * Process all complete receives. 2050 */ 2051 2052 for(;;) 2053 { 2054 rpl = tp->RplHead; 2055 if(rpl->Status & RX_VALID) 2056 break; /* RPL still in use by adapter */ 2057 2058 /* Forward RPLHead pointer to next list. */ 2059 SaveHead = tp->RplHead; 2060 tp->RplHead = rpl->NextRPLPtr; 2061 2062 Length = be16_to_cpu((unsigned short)rpl->FrameSize); 2063 2064 /* Check if the Frame_Start, Frame_End and 2065 * Frame_Complete bits are set. 2066 */ 2067 if((rpl->Status & VALID_SINGLE_BUFFER_FRAME) 2068 == VALID_SINGLE_BUFFER_FRAME) 2069 { 2070 ReceiveDataPtr = rpl->MData; 2071 2072 Length2 = be16_to_cpu((unsigned short)rpl->FrameSize); 2073 2074 if(Length == 0 || Length != Length2) 2075 { 2076 tp->RplHead = SaveHead; 2077 break; /* Return to tms380tr_interrupt */ 2078 } 2079 tms380tr_update_rcv_stats(tp,ReceiveDataPtr,Length); 2080 2081 if(tms380tr_debug > 3) 2082 printk(KERN_DEBUG "%s: Packet Length %04X (%d)\n", 2083 dev->name, Length, Length); 2084 2085 /* Indicate the received frame to system the 2086 * adapter does the Source-Routing padding for 2087 * us. See: OpenOptions in tms380tr_init_opb() 2088 */ 2089 skb = rpl->Skb; 2090 if(rpl->SkbStat == SKB_UNAVAILABLE) 2091 { 2092 /* Try again to allocate skb */ 2093 skb = dev_alloc_skb(tp->MaxPacketSize); 2094 if(skb == NULL) 2095 { 2096 /* Update Stats ?? */ 2097 } 2098 else 2099 { 2100 skb_put(skb, tp->MaxPacketSize); 2101 rpl->SkbStat = SKB_DATA_COPY; 2102 ReceiveDataPtr = rpl->MData; 2103 } 2104 } 2105 2106 if(skb && (rpl->SkbStat == SKB_DATA_COPY 2107 || rpl->SkbStat == SKB_DMA_DIRECT)) 2108 { 2109 if(rpl->SkbStat == SKB_DATA_COPY) 2110 skb_copy_to_linear_data(skb, ReceiveDataPtr, 2111 Length); 2112 2113 /* Deliver frame to system */ 2114 rpl->Skb = NULL; 2115 skb_trim(skb,Length); 2116 skb->protocol = tr_type_trans(skb,dev); 2117 netif_rx(skb); 2118 dev->last_rx = jiffies; 2119 } 2120 } 2121 else /* Invalid frame */ 2122 { 2123 if(rpl->Skb != NULL) 2124 dev_kfree_skb_irq(rpl->Skb); 2125 2126 /* Skip list. */ 2127 if(rpl->Status & RX_START_FRAME) 2128 /* Frame start bit is set -> overflow. */ 2129 tp->MacStat.rx_errors++; 2130 } 2131 if (rpl->DMABuff) 2132 dma_unmap_single(tp->pdev, rpl->DMABuff, tp->MaxPacketSize, DMA_TO_DEVICE); 2133 rpl->DMABuff = 0; 2134 2135 /* Allocate new skb for rpl */ 2136 rpl->Skb = dev_alloc_skb(tp->MaxPacketSize); 2137 /* skb == NULL ? then use local buffer */ 2138 if(rpl->Skb == NULL) 2139 { 2140 rpl->SkbStat = SKB_UNAVAILABLE; 2141 rpl->FragList[0].DataAddr = htonl(((char *)tp->LocalRxBuffers[rpl->RPLIndex] - (char *)tp) + tp->dmabuffer); 2142 rpl->MData = tp->LocalRxBuffers[rpl->RPLIndex]; 2143 } 2144 else /* skb != NULL */ 2145 { 2146 rpl->Skb->dev = dev; 2147 skb_put(rpl->Skb, tp->MaxPacketSize); 2148 2149 /* Data unreachable for DMA ? then use local buffer */ 2150 dmabuf = dma_map_single(tp->pdev, rpl->Skb->data, tp->MaxPacketSize, DMA_FROM_DEVICE); 2151 if(tp->dmalimit && (dmabuf + tp->MaxPacketSize > tp->dmalimit)) 2152 { 2153 rpl->SkbStat = SKB_DATA_COPY; 2154 rpl->FragList[0].DataAddr = htonl(((char *)tp->LocalRxBuffers[rpl->RPLIndex] - (char *)tp) + tp->dmabuffer); 2155 rpl->MData = tp->LocalRxBuffers[rpl->RPLIndex]; 2156 } 2157 else 2158 { 2159 /* DMA directly in skb->data */ 2160 rpl->SkbStat = SKB_DMA_DIRECT; 2161 rpl->FragList[0].DataAddr = htonl(dmabuf); 2162 rpl->MData = rpl->Skb->data; 2163 rpl->DMABuff = dmabuf; 2164 } 2165 } 2166 2167 rpl->FragList[0].DataCount = cpu_to_be16((unsigned short)tp->MaxPacketSize); 2168 rpl->FrameSize = 0; 2169 2170 /* Pass the last RPL back to the adapter */ 2171 tp->RplTail->FrameSize = 0; 2172 2173 /* Reset the CSTAT field in the list. */ 2174 tms380tr_write_rpl_status(tp->RplTail, RX_VALID | RX_FRAME_IRQ); 2175 2176 /* Current RPL becomes last one in list. */ 2177 tp->RplTail = tp->RplTail->NextRPLPtr; 2178 2179 /* Inform adapter about RPL valid. */ 2180 tms380tr_exec_sifcmd(dev, CMD_RX_VALID); 2181 } 2182 2183 return; 2184} 2185 2186/* 2187 * This function should be used whenever the status of any RPL must be 2188 * modified by the driver, because the compiler may otherwise change the 2189 * order of instructions such that writing the RPL status may be executed 2190 * at an undesireable time. When this function is used, the status is 2191 * always written when the function is called. 2192 */ 2193static void tms380tr_write_rpl_status(RPL *rpl, unsigned int Status) 2194{ 2195 rpl->Status = Status; 2196 2197 return; 2198} 2199 2200/* 2201 * The function updates the statistic counters in mac->MacStat. 2202 * It differtiates between directed and broadcast/multicast ( ==functional) 2203 * frames. 2204 */ 2205static void tms380tr_update_rcv_stats(struct net_local *tp, unsigned char DataPtr[], 2206 unsigned int Length) 2207{ 2208 tp->MacStat.rx_packets++; 2209 tp->MacStat.rx_bytes += Length; 2210 2211 /* Test functional bit */ 2212 if(DataPtr[2] & GROUP_BIT) 2213 tp->MacStat.multicast++; 2214 2215 return; 2216} 2217 2218static int tms380tr_set_mac_address(struct net_device *dev, void *addr) 2219{ 2220 struct net_local *tp = netdev_priv(dev); 2221 struct sockaddr *saddr = addr; 2222 2223 if (tp->AdapterOpenFlag || tp->AdapterVirtOpenFlag) { 2224 printk(KERN_WARNING "%s: Cannot set MAC/LAA address while card is open\n", dev->name); 2225 return -EIO; 2226 } 2227 memcpy(dev->dev_addr, saddr->sa_data, dev->addr_len); 2228 return 0; 2229} 2230 2231#if TMS380TR_DEBUG > 0 2232/* 2233 * Dump Packet (data) 2234 */ 2235static void tms380tr_dump(unsigned char *Data, int length) 2236{ 2237 int i, j; 2238 2239 for (i = 0, j = 0; i < length / 8; i++, j += 8) 2240 { 2241 printk(KERN_DEBUG "%02x %02x %02x %02x %02x %02x %02x %02x\n", 2242 Data[j+0],Data[j+1],Data[j+2],Data[j+3], 2243 Data[j+4],Data[j+5],Data[j+6],Data[j+7]); 2244 } 2245 2246 return; 2247} 2248#endif 2249 2250void tmsdev_term(struct net_device *dev) 2251{ 2252 struct net_local *tp; 2253 2254 tp = netdev_priv(dev); 2255 dma_unmap_single(tp->pdev, tp->dmabuffer, sizeof(struct net_local), 2256 DMA_BIDIRECTIONAL); 2257} 2258 2259int tmsdev_init(struct net_device *dev, struct device *pdev) 2260{ 2261 struct net_local *tms_local; 2262 2263 memset(dev->priv, 0, sizeof(struct net_local)); 2264 tms_local = netdev_priv(dev); 2265 init_waitqueue_head(&tms_local->wait_for_tok_int); 2266 if (pdev->dma_mask) 2267 tms_local->dmalimit = *pdev->dma_mask; 2268 else 2269 return -ENOMEM; 2270 tms_local->pdev = pdev; 2271 tms_local->dmabuffer = dma_map_single(pdev, (void *)tms_local, 2272 sizeof(struct net_local), DMA_BIDIRECTIONAL); 2273 if (tms_local->dmabuffer + sizeof(struct net_local) > 2274 tms_local->dmalimit) 2275 { 2276 printk(KERN_INFO "%s: Memory not accessible for DMA\n", 2277 dev->name); 2278 tmsdev_term(dev); 2279 return -ENOMEM; 2280 } 2281 2282 /* These can be overridden by the card driver if needed */ 2283 dev->open = tms380tr_open; 2284 dev->stop = tms380tr_close; 2285 dev->do_ioctl = NULL; 2286 dev->hard_start_xmit = tms380tr_send_packet; 2287 dev->tx_timeout = tms380tr_timeout; 2288 dev->watchdog_timeo = HZ; 2289 dev->get_stats = tms380tr_get_stats; 2290 dev->set_multicast_list = &tms380tr_set_multicast_list; 2291 dev->set_mac_address = tms380tr_set_mac_address; 2292 2293 return 0; 2294} 2295 2296EXPORT_SYMBOL(tms380tr_open); 2297EXPORT_SYMBOL(tms380tr_close); 2298EXPORT_SYMBOL(tms380tr_interrupt); 2299EXPORT_SYMBOL(tmsdev_init); 2300EXPORT_SYMBOL(tmsdev_term); 2301EXPORT_SYMBOL(tms380tr_wait); 2302 2303#ifdef MODULE 2304 2305static struct module *TMS380_module = NULL; 2306 2307int init_module(void) 2308{ 2309 printk(KERN_DEBUG "%s", version); 2310 2311 TMS380_module = &__this_module; 2312 return 0; 2313} 2314 2315void cleanup_module(void) 2316{ 2317 TMS380_module = NULL; 2318} 2319#endif 2320 2321MODULE_LICENSE("GPL"); 2322