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