![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to interrup.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [WindowsNT SDKs] / ntddk / src / network / sonic|
Return to interrup.c CVS log | Up to [WindowsNT SDKs] / ntddk / src / network / sonic |
1.1 ! root 1: /*++ ! 2: ! 3: Copyright (c) 1990-1992 Microsoft Corporation ! 4: ! 5: Module Name: ! 6: ! 7: interrup.c ! 8: ! 9: Abstract: ! 10: ! 11: This is a part of the driver for the National Semiconductor SONIC ! 12: Ethernet controller. It contains the interrupt-handling routines. ! 13: This driver conforms to the NDIS 3.0 interface. ! 14: ! 15: The overall structure and much of the code is taken from ! 16: the Lance NDIS driver by Tony Ercolano. ! 17: ! 18: Author: ! 19: ! 20: Adam Barr (adamba) 16-Jan-1991 ! 21: ! 22: Environment: ! 23: ! 24: Kernel Mode - Or whatever is the equivalent. ! 25: ! 26: Revision History: ! 27: ! 28: ! 29: --*/ ! 30: ! 31: #include <ndis.h> ! 32: ! 33: ! 34: #include <efilter.h> ! 35: #include <sonichrd.h> ! 36: #include <sonicsft.h> ! 37: ! 38: #undef DPR_INTERRUPTS ! 39: ! 40: // ! 41: // We use the #define DPR_INTERRUPTS to determine how we handle ! 42: // disabling interrupts during the ISR and DPR ! 43: // ! 44: // If DPR_INTERRUPTS is not defined, then we mask off all interrupts ! 45: // in the ISR and reenable them when the DPR has run. If it is ! 46: // defined, then we keep interrupts enabled during the DPR. ! 47: // ! 48: // With DPR_INTERRUPTS undefined, there will only be one DPR running ! 49: // at one time time, and in addition the ISR and DPR will never be ! 50: // running at the same time. This saves us interrupts and calls to ! 51: // NdisSynchronizeWithInterrupt, but prevents parallelism on MP. It ! 52: // is also good programming practice for drivers that can cause the ! 53: // interrupt line to drop during the DPR, to prevent the "short interrupt" ! 54: // problem on some steppings of the 486 (the sonic driver as structured ! 55: // does not have this problem). ! 56: // ! 57: ! 58: ! 59: #ifdef DPR_INTERRUPTS ! 60: ! 61: // ! 62: // We need this structures to call NdisSynchronizeWithInterrupt ! 63: // because it only takes one parameter. ! 64: // ! 65: ! 66: typedef struct _SONIC_SYNCH_CONTEXT { ! 67: ! 68: // ! 69: // Pointer to the sonic adapter for which interrupts are ! 70: // being synchronized. ! 71: // ! 72: PSONIC_ADAPTER Adapter; ! 73: ! 74: // ! 75: // Pointer used differently depending on the call; ! 76: // ! 77: // For GET_ISR_SINCE_LAST_PROCESSED, it points ! 78: // to a local variable that will receive the value ! 79: // of the adapter's IsrValue. ! 80: // For REMOVE_EOL_AND_ACK, it points to the Link ! 81: // field to remove the EOL bit from. ! 82: // For WRITE_RWP_AND_ACK, it holds the value ! 83: // to be written to the Current Write Pointer register. ! 84: // ! 85: PVOID Local; ! 86: ! 87: // ! 88: // Pointer used by GET_ISR_SINCE_LAST_PROCESSED, it ! 89: // determines which bits in the ISR we care about. ! 90: // ! 91: USHORT Parameter; ! 92: ! 93: } SONIC_SYNCH_CONTEXT,*PSONIC_SYNCH_CONTEXT; ! 94: ! 95: // ! 96: // NOTE: This macro is to synchronize execution with interrupts. It ! 97: // gets the stored value of the ISR and clears the old value, ! 98: // only dealing with the bits specified by M. ! 99: // ! 100: #define GET_ISR_SINCE_LAST_PROCESSED(A,V,M) \ ! 101: { \ ! 102: PSONIC_ADAPTER _A = A; \ ! 103: SONIC_SYNCH_CONTEXT _C; \ ! 104: _C.Adapter = _A; \ ! 105: _C.Local = (PVOID)(V); \ ! 106: _C.Parameter = (M); \ ! 107: NdisSynchronizeWithInterrupt( \ ! 108: &_A->Interrupt, \ ! 109: SonicSynchGetIsr, \ ! 110: &_C \ ! 111: ); \ ! 112: } ! 113: ! 114: ! 115: // ! 116: // NOTE: This macro is to synchronize execution with interrupts. ! 117: // It clears the EOL bit in the Link field and acknowledges ! 118: // the ReceiveDescriptorsExhausted interrupt. ! 119: // ! 120: #define REMOVE_EOL_AND_ACK(A,L) \ ! 121: { \ ! 122: PSONIC_ADAPTER _A = A; \ ! 123: SONIC_SYNCH_CONTEXT _C; \ ! 124: _C.Adapter = _A; \ ! 125: _C.Local = (PVOID)(L); \ ! 126: NdisSynchronizeWithInterrupt( \ ! 127: &_A->Interrupt, \ ! 128: SonicSynchRemoveEol, \ ! 129: &_C \ ! 130: ); \ ! 131: } ! 132: ! 133: ! 134: // ! 135: // NOTE: This macro is to synchronize execution with interrupts. ! 136: // It writes the specified value to the RWP register and ! 137: // acknowledges the ReceiveBuffersExhausted interrupt. ! 138: // ! 139: #define WRITE_RWP_AND_ACK(A,RWP) \ ! 140: { \ ! 141: PSONIC_ADAPTER _A = A; \ ! 142: SONIC_SYNCH_CONTEXT _C; \ ! 143: _C.Adapter = _A; \ ! 144: _C.Local = (PVOID)(RWP); \ ! 145: NdisSynchronizeWithInterrupt( \ ! 146: &_A->Interrupt, \ ! 147: SonicSynchWriteRwp, \ ! 148: &_C \ ! 149: ); \ ! 150: } ! 151: ! 152: #else // DPR_INTERRUPTS ! 153: ! 154: // ! 155: // Define the macros to do what the functions do directly, ! 156: // since the ISR and DPR won't be running concurrently. We ! 157: // also don't write to the interrupt mask register since it ! 158: // will be set to 0 when these calls are made (from the DPR). ! 159: // ! 160: ! 161: #define GET_ISR_SINCE_LAST_PROCESSED(A,V,M) \ ! 162: { \ ! 163: PSONIC_ADAPTER _A = A; \ ! 164: *(V) |= ((_A)->IsrValue & (M)); \ ! 165: (_A)->IsrValue &= (USHORT)~(M); \ ! 166: } ! 167: ! 168: #define REMOVE_EOL_AND_ACK(A,L) \ ! 169: { \ ! 170: PSONIC_ADAPTER _A = A; \ ! 171: SONIC_REMOVE_END_OF_LIST(L); \ ! 172: if ((_A)->ReceiveDescriptorsExhausted) { \ ! 173: SONIC_WRITE_PORT((_A), SONIC_INTERRUPT_STATUS, \ ! 174: SONIC_INT_RECEIVE_DESCRIPTORS \ ! 175: ); \ ! 176: (_A)->InterruptMaskRegister |= SONIC_INT_RECEIVE_DESCRIPTORS; \ ! 177: (_A)->ReceiveDescriptorsExhausted = FALSE; \ ! 178: } \ ! 179: } ! 180: ! 181: #define WRITE_RWP_AND_ACK(A,RWP) \ ! 182: { \ ! 183: PSONIC_ADAPTER _A = A; \ ! 184: SONIC_WRITE_PORT((_A), SONIC_RESOURCE_WRITE, (RWP)); \ ! 185: if ((_A)->ReceiveBuffersExhausted) { \ ! 186: SONIC_WRITE_PORT((_A), SONIC_INTERRUPT_STATUS, \ ! 187: SONIC_INT_RECEIVE_BUFFERS \ ! 188: ); \ ! 189: (_A)->InterruptMaskRegister |= SONIC_INT_RECEIVE_BUFFERS; \ ! 190: (_A)->ReceiveBuffersExhausted = FALSE; \ ! 191: } \ ! 192: } ! 193: ! 194: #endif // DPR_INTERRUPTS ! 195: ! 196: ! 197: ! 198: STATIC ! 199: BOOLEAN ! 200: ProcessReceiveInterrupts( ! 201: IN PSONIC_ADAPTER Adapter ! 202: ); ! 203: ! 204: STATIC ! 205: BOOLEAN ! 206: ProcessTransmitInterrupts( ! 207: IN PSONIC_ADAPTER Adapter ! 208: ); ! 209: ! 210: #ifdef DPR_INTERRUPTS ! 211: ! 212: STATIC ! 213: BOOLEAN ! 214: SonicSynchGetIsr( ! 215: IN PVOID Context ! 216: ); ! 217: ! 218: STATIC ! 219: BOOLEAN ! 220: SonicSynchRemoveEol( ! 221: IN PVOID Context ! 222: ); ! 223: ! 224: STATIC ! 225: BOOLEAN ! 226: SonicSynchWriteRwp( ! 227: IN PVOID Context ! 228: ); ! 229: ! 230: #endif // DPR_INTERRUPTS ! 231: ! 232: STATIC ! 233: VOID ! 234: ProcessInterrupt( ! 235: IN PSONIC_ADAPTER Adapter ! 236: ); ! 237: ! 238: ! 239: #ifdef DPR_INTERRUPTS ! 240: ! 241: // ! 242: // These functions are for use with NdisSynchronizeWithInterrupt. ! 243: // ! 244: ! 245: ! 246: STATIC ! 247: BOOLEAN ! 248: SonicSynchGetIsr( ! 249: IN PVOID Context ! 250: ) ! 251: ! 252: /*++ ! 253: ! 254: Routine Description: ! 255: ! 256: This routine is used by the normal interrupt processing routine ! 257: to synchronize with interrupts from the card. It will or ! 258: the value of the stored ISR into the other passed address ! 259: in the context and clear the stored ISR value. It only ! 260: returns and clears the bits specified in the parameter ! 261: field of the context. ! 262: ! 263: Arguments: ! 264: ! 265: Context - This is really a pointer to a record type peculiar ! 266: to this routine. The record contains a pointer to the adapter ! 267: and a pointer to an address in which to place the contents ! 268: of the ISR. ! 269: ! 270: Return Value: ! 271: ! 272: Always returns true. ! 273: ! 274: --*/ ! 275: ! 276: { ! 277: ! 278: PSONIC_SYNCH_CONTEXT C = Context; ! 279: USHORT Mask = C->Parameter; ! 280: ! 281: *((PUSHORT)C->Local) = *((PUSHORT)C->Local) | ! 282: (C->Adapter->IsrValue & Mask); ! 283: ! 284: C->Adapter->IsrValue &= (USHORT)~Mask; ! 285: ! 286: return TRUE; ! 287: ! 288: } ! 289: ! 290: STATIC ! 291: BOOLEAN ! 292: SonicSynchRemoveEol( ! 293: IN PVOID Context ! 294: ) ! 295: ! 296: /*++ ! 297: ! 298: Routine Description: ! 299: ! 300: This routine is used by the normal interrupt processing routine ! 301: to synchronize with interrupts from the card. It will clear ! 302: the EOL bit from the specified link field in the receive ! 303: descriptor, acknowledge the RDE interrupt, and reenable the ! 304: interrupt. ! 305: ! 306: Arguments: ! 307: ! 308: Context - This is really a pointer to a record type peculiar ! 309: to this routine. The record contains a pointer to the adapter ! 310: and a pointer to the address of the link field. ! 311: ! 312: Return Value: ! 313: ! 314: Always returns true. ! 315: ! 316: --*/ ! 317: ! 318: { ! 319: ! 320: PSONIC_SYNCH_CONTEXT C = Context; ! 321: ! 322: SONIC_REMOVE_END_OF_LIST( ! 323: (PSONIC_PHYSICAL_ADDRESS)C->Local ! 324: ); ! 325: ! 326: if (C->Adapter->ReceiveDescriptorsExhausted) { ! 327: ! 328: SONIC_WRITE_PORT(C->Adapter, SONIC_INTERRUPT_STATUS, ! 329: SONIC_INT_RECEIVE_DESCRIPTORS ! 330: ); ! 331: ! 332: C->Adapter->InterruptMaskRegister |= SONIC_INT_RECEIVE_DESCRIPTORS; ! 333: SONIC_WRITE_PORT(C->Adapter, SONIC_INTERRUPT_MASK, ! 334: C->Adapter->InterruptMaskRegister ! 335: ); ! 336: ! 337: C->Adapter->ReceiveDescriptorsExhausted = FALSE; ! 338: ! 339: } ! 340: ! 341: return TRUE; ! 342: ! 343: } ! 344: ! 345: STATIC ! 346: BOOLEAN ! 347: SonicSynchWriteRwp( ! 348: IN PVOID Context ! 349: ) ! 350: ! 351: /*++ ! 352: ! 353: Routine Description: ! 354: ! 355: This routine is used by the normal interrupt processing routine ! 356: to synchronize with interrupts from the card. It will write ! 357: the specified value to the Current Write Pointer register ! 358: (effectively adding a receive buffer), acknowledge the RBE ! 359: interrupt, and reenable that interrupt. ! 360: ! 361: Arguments: ! 362: ! 363: Context - This is really a pointer to a record type peculiar ! 364: to this routine. The record contains a pointer to the adapter ! 365: and the new value of the RWP register. ! 366: ! 367: Return Value: ! 368: ! 369: Always returns true. ! 370: ! 371: --*/ ! 372: ! 373: { ! 374: ! 375: PSONIC_SYNCH_CONTEXT C = Context; ! 376: ! 377: SONIC_WRITE_PORT(C->Adapter, SONIC_RESOURCE_WRITE, ! 378: (USHORT)C->Local ! 379: ); ! 380: ! 381: if (C->Adapter->ReceiveBuffersExhausted) { ! 382: ! 383: SONIC_WRITE_PORT(C->Adapter, SONIC_INTERRUPT_STATUS, ! 384: SONIC_INT_RECEIVE_BUFFERS ! 385: ); ! 386: ! 387: C->Adapter->InterruptMaskRegister |= SONIC_INT_RECEIVE_BUFFERS; ! 388: SONIC_WRITE_PORT(C->Adapter, SONIC_INTERRUPT_MASK, ! 389: C->Adapter->InterruptMaskRegister ! 390: ); ! 391: ! 392: C->Adapter->ReceiveBuffersExhausted = FALSE; ! 393: ! 394: } ! 395: ! 396: return TRUE; ! 397: ! 398: } ! 399: #endif // DPR_INTERRUPTS ! 400: ! 401: extern ! 402: BOOLEAN ! 403: SonicInterruptService( ! 404: IN PVOID Context ! 405: ) ! 406: ! 407: /*++ ! 408: ! 409: Routine Description: ! 410: ! 411: Interrupt service routine for the sonic. It's main job is ! 412: to get the value of ISR and record the changes in the ! 413: adapters own list of interrupt reasons. ! 414: ! 415: Arguments: ! 416: ! 417: Context - Really a pointer to the adapter. ! 418: ! 419: Return Value: ! 420: ! 421: Returns true if the card ISR is non-zero. ! 422: ! 423: --*/ ! 424: ! 425: { ! 426: ! 427: // ! 428: // Will hold the value from the ISR. ! 429: // ! 430: USHORT LocalIsrValue; ! 431: ! 432: // ! 433: // Holds the pointer to the adapter. ! 434: // ! 435: PSONIC_ADAPTER Adapter = Context; ! 436: ! 437: ! 438: SONIC_READ_PORT(Adapter, SONIC_INTERRUPT_STATUS, &LocalIsrValue); ! 439: ! 440: if (LocalIsrValue != 0x0000) { ! 441: ! 442: #if DBG ! 443: if (SonicDbg) { ! 444: if (LocalIsrValue & ( ! 445: SONIC_INT_BUS_RETRY | ! 446: SONIC_INT_LOAD_CAM_DONE | ! 447: SONIC_INT_PROG_INTERRUPT | ! 448: SONIC_INT_TRANSMIT_ERROR | ! 449: SONIC_INT_RECEIVE_DESCRIPTORS | ! 450: SONIC_INT_RECEIVE_BUFFERS | ! 451: SONIC_INT_RECEIVE_OVERFLOW | ! 452: SONIC_INT_CRC_TALLY_ROLLOVER | ! 453: SONIC_INT_FAE_TALLY_ROLLOVER | ! 454: SONIC_INT_MP_TALLY_ROLLOVER ! 455: )) { ! 456: DbgPrint("ISR %x\n", LocalIsrValue); ! 457: } ! 458: } ! 459: #endif ! 460: // ! 461: // It's our interrupt. Clear only those bits that we got ! 462: // in this read of ISR. We do it this way in case any new ! 463: // reasons for interrupts occur between the time that we ! 464: // read ISR and the time that we clear the bits. ! 465: // ! 466: // Also, we don't clear the RDE or RBE bits, but set ! 467: // the flags for later acknowledgement. ! 468: // ! 469: ! 470: #ifndef DPR_INTERRUPTS ! 471: // ! 472: // If desired, mask off all interrupts here. Do this ! 473: // before acking them in the status register to remove ! 474: // the possibility of another interrupt being generated. ! 475: // ! 476: ! 477: SONIC_WRITE_PORT(Adapter, SONIC_INTERRUPT_MASK, 0); ! 478: #endif ! 479: ! 480: SONIC_WRITE_PORT( ! 481: Adapter, ! 482: SONIC_INTERRUPT_STATUS, ! 483: (USHORT)(LocalIsrValue & SONIC_INT_IMMEDIATE_ACK) ! 484: ); ! 485: ! 486: ! 487: // ! 488: // See if we have a new RDE or RBE interrupt, if so ! 489: // set the flag and mask that interrupt (otherwise, ! 490: // since we don't ack it, we would get reinterrupted ! 491: // right away). ! 492: // ! 493: ! 494: if (LocalIsrValue & SONIC_INT_RECEIVE_DESCRIPTORS) { ! 495: ! 496: if (!Adapter->ReceiveDescriptorsExhausted) { ! 497: ! 498: Adapter->ReceiveDescriptorsExhausted = TRUE; ! 499: ! 500: Adapter->InterruptMaskRegister &= ! 501: ~SONIC_INT_RECEIVE_DESCRIPTORS; ! 502: #ifdef DPR_INTERRUPTS ! 503: // ! 504: // Update the interrupt mask register unless we ! 505: // have it masked off completely. ! 506: // ! 507: SONIC_WRITE_PORT(Adapter, SONIC_INTERRUPT_MASK, ! 508: Adapter->InterruptMaskRegister ! 509: ); ! 510: #endif ! 511: ! 512: } ! 513: ! 514: } ! 515: ! 516: if (LocalIsrValue & SONIC_INT_RECEIVE_BUFFERS) { ! 517: ! 518: if (!Adapter->ReceiveBuffersExhausted) { ! 519: ! 520: Adapter->ReceiveBuffersExhausted = TRUE; ! 521: ! 522: Adapter->InterruptMaskRegister &= ! 523: ~SONIC_INT_RECEIVE_BUFFERS; ! 524: #ifdef DPR_INTERRUPTS ! 525: // ! 526: // Update the interrupt mask register unless we ! 527: // have it masked off completely. ! 528: // ! 529: SONIC_WRITE_PORT(Adapter, SONIC_INTERRUPT_MASK, ! 530: Adapter->InterruptMaskRegister ! 531: ); ! 532: #endif ! 533: ! 534: } ! 535: ! 536: } ! 537: ! 538: ! 539: // ! 540: // If we got a LOAD_CAM_DONE interrupt, it may be ! 541: // because our first initialization is complete. ! 542: // We check this here because on some systems the ! 543: // DeferredProcessing call might not interrupt ! 544: // the initialization process. ! 545: // ! 546: ! 547: if (LocalIsrValue & SONIC_INT_LOAD_CAM_DONE) { ! 548: ! 549: if (Adapter->FirstInitialization) { ! 550: ! 551: Adapter->FirstInitialization = FALSE; ! 552: ! 553: #if DBG ! 554: { ! 555: USHORT PortValue; ! 556: ! 557: SONIC_READ_PORT(Adapter, SONIC_SILICON_REVISION, &PortValue); ! 558: if (SonicDbg) { ! 559: DbgPrint("SONIC Initialized: Revision %d\n", PortValue); ! 560: } ! 561: } ! 562: #endif ! 563: ! 564: #ifndef DPR_INTERRUPTS ! 565: // ! 566: // Re-enable the interrupts we just disabled. ! 567: // ! 568: ! 569: SONIC_WRITE_PORT(Adapter, SONIC_INTERRUPT_MASK, ! 570: Adapter->InterruptMaskRegister ! 571: ); ! 572: #endif ! 573: // ! 574: // No deferred processing is needed. ! 575: // ! 576: ! 577: return FALSE; ! 578: ! 579: } ! 580: } ! 581: ! 582: ! 583: // ! 584: // Or the ISR value into the adapter version of the ISR. ! 585: // ! 586: ! 587: Adapter->IsrValue |= LocalIsrValue; ! 588: ! 589: ! 590: #ifdef DPR_INTERRUPTS ! 591: // ! 592: // For latched interrupts, we want to force an edge ! 593: // in the case where interrupts appeared between when we ! 594: // read the ISR and when we wrote it back out. We mask ! 595: // the IMR off here, then reenable it during the ! 596: // deferred processing routine. ! 597: // ! 598: ! 599: if (Adapter->InterruptLatched) { ! 600: SONIC_WRITE_PORT(Adapter, SONIC_INTERRUPT_MASK, 0); ! 601: } ! 602: #endif ! 603: ! 604: return TRUE; ! 605: ! 606: } else { ! 607: ! 608: return FALSE; ! 609: ! 610: } ! 611: ! 612: } ! 613: ! 614: extern ! 615: VOID ! 616: SonicDeferredProcessing( ! 617: IN PVOID SystemSpecific1, ! 618: IN PVOID Context, ! 619: IN PVOID SystemSpecific2, ! 620: IN PVOID SystemSpecific3 ! 621: ) ! 622: ! 623: /*++ ! 624: ! 625: Routine Description: ! 626: ! 627: This DPR routine is queued by the interrupt service routine ! 628: and other routines within the driver that notice that ! 629: some deferred processing needs to be done. It's main ! 630: job is to call the interrupt processing code. ! 631: ! 632: Arguments: ! 633: ! 634: Context - Really a pointer to the adapter. ! 635: ! 636: SystemSpecific123 - None of these arguments is used. ! 637: ! 638: Return Value: ! 639: ! 640: None. ! 641: ! 642: --*/ ! 643: ! 644: { ! 645: ! 646: // ! 647: // A pointer to the adapter object. ! 648: // ! 649: PSONIC_ADAPTER Adapter = (PSONIC_ADAPTER)Context; ! 650: ! 651: // ! 652: // Holds a value of the Interrupt Status register. ! 653: // ! 654: USHORT Isr = 0; ! 655: ! 656: // ! 657: // TRUE if the main loop did something. ! 658: // ! 659: BOOLEAN DidSomething = TRUE; ! 660: ! 661: // ! 662: // TRUE if ReceiveComplete needs to be indicated. ! 663: // ! 664: BOOLEAN IndicateReceiveComplete = FALSE; ! 665: ! 666: UNREFERENCED_PARAMETER(SystemSpecific1); ! 667: UNREFERENCED_PARAMETER(SystemSpecific2); ! 668: UNREFERENCED_PARAMETER(SystemSpecific3); ! 669: ! 670: ! 671: #ifdef DPR_INTERRUPTS ! 672: // ! 673: // For latched interrupts, unmask the IMR to force ! 674: // an edge. ! 675: // ! 676: ! 677: if (Adapter->InterruptLatched) { ! 678: SONIC_WRITE_PORT(Adapter, SONIC_INTERRUPT_MASK, ! 679: Adapter->InterruptMaskRegister ! 680: ); ! 681: } ! 682: #endif ! 683: ! 684: ! 685: // ! 686: // Loop until there are no more processing sources. ! 687: // ! 688: ! 689: NdisDprAcquireSpinLock(&Adapter->Lock); ! 690: ! 691: #if DBG ! 692: if (SonicDbg) { ! 693: ! 694: DbgPrint("In Dpr\n"); ! 695: } ! 696: #endif ! 697: ! 698: while (DidSomething) { ! 699: ! 700: // ! 701: // Set this FALSE now, so if nothing happens we ! 702: // will exit. ! 703: // ! 704: ! 705: DidSomething = FALSE; ! 706: ! 707: // ! 708: // Check for receive interrupts. ! 709: // ! 710: ! 711: if (Adapter->ProcessingReceiveInterrupt) { ! 712: ! 713: goto DoneProcessingReceives; ! 714: ! 715: } else { ! 716: ! 717: GET_ISR_SINCE_LAST_PROCESSED( ! 718: Adapter, ! 719: &Isr, ! 720: SONIC_INT_PACKET_RECEIVED ! 721: ); ! 722: ! 723: if (Isr & SONIC_INT_PACKET_RECEIVED) { ! 724: ! 725: Adapter->References++; ! 726: Adapter->ProcessingReceiveInterrupt = TRUE; ! 727: DidSomething = TRUE; ! 728: ! 729: } else { ! 730: ! 731: goto DoneProcessingReceives; ! 732: ! 733: } ! 734: ! 735: } ! 736: ! 737: NdisDprReleaseSpinLock(&Adapter->Lock); ! 738: ! 739: // ! 740: // After we process any ! 741: // other interrupt source we always come back to the top ! 742: // of the loop to check if any more receive packets have ! 743: // come in. This is to lessen the probability that we ! 744: // drop a receive. ! 745: // ! 746: // ProcessReceiveInterrupts may exit early if it has ! 747: // processed too many receives in a row. In this case ! 748: // it returns FALSE, we don't clear the PACKET_RECEIVED ! 749: // bit, and we will loop through here again. ! 750: // ! 751: ! 752: if (ProcessReceiveInterrupts(Adapter)) { ! 753: Isr &= ~SONIC_INT_PACKET_RECEIVED; ! 754: } ! 755: ! 756: IndicateReceiveComplete = TRUE; ! 757: ! 758: // ! 759: // We set ProcessingReceiveInterrupt to FALSE here so ! 760: // that we can issue new receive indications while ! 761: // the rest of the loop is proceeding. ! 762: // ! 763: ! 764: NdisDprAcquireSpinLock(&Adapter->Lock); ! 765: ! 766: Adapter->ProcessingReceiveInterrupt = FALSE; ! 767: Adapter->References--; ! 768: ! 769: DoneProcessingReceives:; ! 770: ! 771: // ! 772: // NOTE: We have the spinlock here. ! 773: // ! 774: ! 775: if (Adapter->ProcessingGeneralInterrupt) { ! 776: ! 777: goto DoneProcessingGeneral; ! 778: ! 779: } else { ! 780: ! 781: GET_ISR_SINCE_LAST_PROCESSED( ! 782: Adapter, ! 783: &Isr, ! 784: (USHORT)~SONIC_INT_PACKET_RECEIVED ! 785: ); ! 786: ! 787: // ! 788: // Check the interrupt source and other reasons ! 789: // for processing. If there are no reasons to ! 790: // process then exit this loop. ! 791: // ! 792: ! 793: if ((Isr & (SONIC_INT_LOAD_CAM_DONE | ! 794: SONIC_INT_PROG_INTERRUPT | ! 795: SONIC_INT_PACKET_TRANSMITTED | ! 796: SONIC_INT_TRANSMIT_ERROR | ! 797: SONIC_INT_CRC_TALLY_ROLLOVER | ! 798: SONIC_INT_FAE_TALLY_ROLLOVER | ! 799: SONIC_INT_MP_TALLY_ROLLOVER))) { ! 800: ! 801: Adapter->References++; ! 802: Adapter->ProcessingGeneralInterrupt = TRUE; ! 803: DidSomething = TRUE; ! 804: ! 805: } else { ! 806: ! 807: goto DoneProcessingGeneral; ! 808: ! 809: } ! 810: ! 811: } ! 812: ! 813: ! 814: // ! 815: // Check for a Load CAM completing. ! 816: // ! 817: // This can happen due to a change in the CAM, due to ! 818: // initialization (in which case we won't save the bit ! 819: // and will not come through this code), or a reset ! 820: // (in which case ResetInProgress will be TRUE). ! 821: // ! 822: // Note that we come out of the synchronization above holding ! 823: // the spinlock. ! 824: // ! 825: ! 826: ! 827: // ! 828: // Check for non-packet related happenings. ! 829: // ! 830: ! 831: if (Isr & SONIC_INT_LOAD_CAM_DONE) { ! 832: ! 833: Isr &= ~SONIC_INT_LOAD_CAM_DONE; ! 834: ! 835: if (Adapter->ResetInProgress) { ! 836: ! 837: PSONIC_OPEN Open; ! 838: PLIST_ENTRY CurrentLink; ! 839: ! 840: // ! 841: // This initialization is from a reset. ! 842: // ! 843: ! 844: // ! 845: // This will point to the open that ! 846: // initiated the reset. ! 847: // ! 848: PSONIC_OPEN ResettingOpen; ! 849: ! 850: Adapter->ResetInProgress = FALSE; ! 851: Adapter->IndicatingResetEnd = TRUE; ! 852: ! 853: // ! 854: // Restart the chip. ! 855: // ! 856: ! 857: SonicStartChip(Adapter); ! 858: ! 859: // ! 860: // We save off the open that caused this reset incase ! 861: // we get *another* reset while we're indicating the ! 862: // last reset is done; that would overwrite ! 863: // Adapter->ResettingOpen. ! 864: // ! 865: ! 866: ResettingOpen = Adapter->ResettingOpen; ! 867: ! 868: // ! 869: // If anything queued up while we were resetting ! 870: // (in practice that could only be close requests) ! 871: // then restart them now. ! 872: // ! 873: ! 874: if (Adapter->FirstRequest) { ! 875: SonicProcessRequestQueue(Adapter); ! 876: } ! 877: ! 878: // ! 879: // We need to signal every open binding that the ! 880: // reset is complete. We increment the reference ! 881: // count on the open binding while we're doing indications ! 882: // so that the open can't be deleted out from under ! 883: // us while we're indicating (recall that we can't own ! 884: // the lock during the indication). ! 885: // ! 886: ! 887: CurrentLink = Adapter->OpenBindings.Flink; ! 888: ! 889: while (CurrentLink != &Adapter->OpenBindings) { ! 890: ! 891: Open = CONTAINING_RECORD( ! 892: CurrentLink, ! 893: SONIC_OPEN, ! 894: OpenList ! 895: ); ! 896: ! 897: Open->References++; ! 898: NdisDprReleaseSpinLock(&Adapter->Lock); ! 899: ! 900: NdisIndicateStatus( ! 901: Open->NdisBindingContext, ! 902: NDIS_STATUS_RESET_END, ! 903: NULL, ! 904: 0 ! 905: ); ! 906: ! 907: NdisIndicateStatusComplete(Open->NdisBindingContext); ! 908: ! 909: NdisDprAcquireSpinLock(&Adapter->Lock); ! 910: Open->References--; ! 911: ! 912: CurrentLink = CurrentLink->Flink; ! 913: ! 914: } ! 915: ! 916: // ! 917: // Look to see which open initiated the reset. ! 918: // ! 919: ! 920: NdisDprReleaseSpinLock(&Adapter->Lock); ! 921: ! 922: NdisCompleteReset( ! 923: ResettingOpen->NdisBindingContext, ! 924: NDIS_STATUS_SUCCESS ! 925: ); ! 926: NdisDprAcquireSpinLock(&Adapter->Lock); ! 927: ! 928: ResettingOpen->References--; ! 929: Adapter->IndicatingResetEnd = FALSE; ! 930: ! 931: if (Adapter->IndicatingResetStart) { ! 932: ! 933: // ! 934: // Somebody has started a reset while we were ! 935: // indicating the reset end. ! 936: // ! 937: ! 938: // ! 939: // Indicate Reset Start ! 940: // ! 941: ! 942: CurrentLink = Adapter->OpenBindings.Flink; ! 943: ! 944: while (CurrentLink != &Adapter->OpenBindings) { ! 945: ! 946: Open = CONTAINING_RECORD( ! 947: CurrentLink, ! 948: SONIC_OPEN, ! 949: OpenList ! 950: ); ! 951: ! 952: Open->References++; ! 953: NdisDprReleaseSpinLock(&Adapter->Lock); ! 954: ! 955: NdisIndicateStatus( ! 956: Open->NdisBindingContext, ! 957: NDIS_STATUS_RESET_START, ! 958: NULL, ! 959: 0 ! 960: ); ! 961: ! 962: NdisIndicateStatusComplete(Open->NdisBindingContext); ! 963: ! 964: NdisDprAcquireSpinLock(&Adapter->Lock); ! 965: ! 966: Open->References--; ! 967: ! 968: CurrentLink = CurrentLink->Flink; ! 969: ! 970: } ! 971: ! 972: Adapter->IndicatingResetStart = FALSE; ! 973: ! 974: SetupForReset( ! 975: Adapter, ! 976: Adapter->ResettingOpen ! 977: ); ! 978: ! 979: } ! 980: ! 981: } else { // ResetInProgress FALSE ! 982: ! 983: PNDIS_REQUEST Request; ! 984: PSONIC_REQUEST_RESERVED Reserved; ! 985: PSONIC_OPEN Open; ! 986: ! 987: Request = Adapter->FirstRequest; ! 988: Reserved = PSONIC_RESERVED_FROM_REQUEST(Request); ! 989: ! 990: switch (Request->RequestType) { ! 991: ! 992: case NdisRequestQueryInformation: ! 993: case NdisRequestSetInformation: ! 994: ! 995: Adapter->FirstRequest = Reserved->Next; ! 996: Open = Reserved->OpenBlock; ! 997: ! 998: NdisDprReleaseSpinLock(&Adapter->Lock); ! 999: ! 1000: NdisCompleteRequest( ! 1001: Open->NdisBindingContext, ! 1002: Request, ! 1003: NDIS_STATUS_SUCCESS); ! 1004: ! 1005: NdisDprAcquireSpinLock(&Adapter->Lock); ! 1006: ! 1007: --Open->References; ! 1008: ! 1009: break; ! 1010: ! 1011: case NdisRequestQueryStatistics: ! 1012: ! 1013: Adapter->FirstRequest = Reserved->Next; ! 1014: ! 1015: NdisDprReleaseSpinLock(&Adapter->Lock); ! 1016: ! 1017: NdisCompleteQueryStatistics( ! 1018: Adapter->NdisAdapterHandle, ! 1019: Request, ! 1020: NDIS_STATUS_SUCCESS); ! 1021: ! 1022: NdisDprAcquireSpinLock(&Adapter->Lock); ! 1023: ! 1024: break; ! 1025: ! 1026: case NdisRequestClose: ! 1027: ! 1028: Adapter->FirstRequest = Reserved->Next; ! 1029: Open = Reserved->OpenBlock; ! 1030: ! 1031: // ! 1032: // The close will get completed when the ! 1033: // reference count goes to 0. ! 1034: // ! 1035: ! 1036: --Open->References; ! 1037: ! 1038: } ! 1039: ! 1040: // ! 1041: // Now continue processing requests if needed ! 1042: // (this is called with the lock held). ! 1043: // ! 1044: ! 1045: SonicProcessRequestQueue(Adapter); ! 1046: ! 1047: } ! 1048: ! 1049: } ! 1050: ! 1051: // ! 1052: // We hold the spinlock here. ! 1053: // ! 1054: ! 1055: if (Isr & (SONIC_INT_CRC_TALLY_ROLLOVER | ! 1056: SONIC_INT_FAE_TALLY_ROLLOVER | ! 1057: SONIC_INT_MP_TALLY_ROLLOVER)) { ! 1058: ! 1059: // ! 1060: // If any of the counters overflowed, then we update ! 1061: // the counter by adding one to the high sixteen bits ! 1062: // and reading the register for the low sixteen bits. ! 1063: // ! 1064: ! 1065: if (Isr & SONIC_INT_CRC_TALLY_ROLLOVER) { ! 1066: ! 1067: USHORT CrcError; ! 1068: SONIC_READ_PORT(Adapter, SONIC_CRC_ERROR, &CrcError); ! 1069: ! 1070: Adapter->GeneralOptional[GO_RECEIVE_CRC - GO_ARRAY_START] = ! 1071: (Adapter->GeneralOptional[GO_RECEIVE_CRC - GO_ARRAY_START] & 0xffff0000) + ! 1072: 0x10000 + ! 1073: CrcError; ! 1074: ! 1075: } ! 1076: ! 1077: if (Isr & SONIC_INT_FAE_TALLY_ROLLOVER) { ! 1078: ! 1079: USHORT FaError; ! 1080: SONIC_READ_PORT(Adapter, SONIC_FRAME_ALIGNMENT_ERROR, &FaError); ! 1081: ! 1082: Adapter->MediaMandatory[MM_RECEIVE_ERROR_ALIGNMENT] = ! 1083: (Adapter->MediaMandatory[MM_RECEIVE_ERROR_ALIGNMENT] & 0xffff0000) + ! 1084: 0x10000 + ! 1085: FaError; ! 1086: ! 1087: } ! 1088: ! 1089: if (Isr & SONIC_INT_MP_TALLY_ROLLOVER) { ! 1090: ! 1091: USHORT MissedPacket; ! 1092: SONIC_READ_PORT(Adapter, SONIC_MISSED_PACKET, &MissedPacket); ! 1093: ! 1094: Adapter->GeneralMandatory[GM_RECEIVE_NO_BUFFER] = ! 1095: (Adapter->GeneralMandatory[GM_RECEIVE_NO_BUFFER] & 0xffff0000) + ! 1096: 0x10000 + ! 1097: MissedPacket; ! 1098: ! 1099: } ! 1100: ! 1101: Isr &= ~(SONIC_INT_CRC_TALLY_ROLLOVER | ! 1102: SONIC_INT_FAE_TALLY_ROLLOVER | ! 1103: SONIC_INT_MP_TALLY_ROLLOVER); ! 1104: ! 1105: } ! 1106: ! 1107: // ! 1108: // Process the transmit interrupts if there are any. ! 1109: // ! 1110: ! 1111: if (Isr & (SONIC_INT_PROG_INTERRUPT | ! 1112: SONIC_INT_PACKET_TRANSMITTED | ! 1113: SONIC_INT_TRANSMIT_ERROR)) { ! 1114: ! 1115: { ! 1116: ! 1117: if (!ProcessTransmitInterrupts(Adapter)) { ! 1118: ! 1119: // ! 1120: // Process interrupts returns false if it ! 1121: // finds no more work to do. If this so we ! 1122: // turn off the transmitter interrupt source. ! 1123: // ! 1124: ! 1125: Isr &= ~ (SONIC_INT_PROG_INTERRUPT | ! 1126: SONIC_INT_PACKET_TRANSMITTED | ! 1127: SONIC_INT_TRANSMIT_ERROR); ! 1128: ! 1129: } ! 1130: ! 1131: } ! 1132: ! 1133: } ! 1134: ! 1135: ! 1136: Adapter->ProcessingGeneralInterrupt = FALSE; ! 1137: Adapter->References--; ! 1138: ! 1139: ! 1140: DoneProcessingGeneral:; ! 1141: ! 1142: // ! 1143: // Note that when we check the for processing sources ! 1144: // that we "carefully" check to see if we are already ! 1145: // processing the stage queue. We do this ! 1146: // by checking the "AlreadyProcessingSendStage" variable ! 1147: // in the adapter. If this is true then ! 1148: // we let whoever set that boolean take care of pushing ! 1149: // the packet through the stage queue. ! 1150: // ! 1151: ! 1152: if ((!Adapter->AlreadyProcessingSendStage) && ! 1153: Adapter->FirstSendStagePacket && ! 1154: Adapter->SendStageOpen) { ! 1155: ! 1156: Adapter->References++; ! 1157: DidSomething = TRUE; ! 1158: ! 1159: } else { ! 1160: ! 1161: goto DoneProcessingSend; ! 1162: ! 1163: } ! 1164: ! 1165: // ! 1166: // This routine is called with and returns with the ! 1167: // spinlock held, but may release it internally. ! 1168: // ! 1169: ! 1170: SonicStagedAllocation(Adapter); ! 1171: ! 1172: Adapter->References--; ! 1173: ! 1174: ! 1175: DoneProcessingSend:; ! 1176: ! 1177: // ! 1178: // NOTE: We have the spinlock here. ! 1179: // ! 1180: ! 1181: ! 1182: if ((!Adapter->ProcessingDeferredOperations) && ! 1183: (Adapter->FirstLoopBack || ! 1184: (Adapter->ResetInProgress && (Adapter->References == 1)) || ! 1185: (!IsListEmpty(&Adapter->CloseList)))) { ! 1186: ! 1187: Adapter->ProcessingDeferredOperations = TRUE; ! 1188: Adapter->References++; ! 1189: ! 1190: NdisSetTimer( ! 1191: &Adapter->DeferredTimer, ! 1192: 0); ! 1193: ! 1194: DidSomething = TRUE; ! 1195: ! 1196: } ! 1197: ! 1198: ! 1199: // ! 1200: // NOTE: This code assumes that the above code left ! 1201: // the spinlock held, since the while loop assumes ! 1202: // it is held at the beginning. ! 1203: // ! 1204: ! 1205: #ifndef DPR_INTERRUPTS ! 1206: ! 1207: // ! 1208: // If we have interrups disabled, then we won't get another ! 1209: // InterruptServiceRoutine, so we check here for any new ! 1210: // bits that are on. We don't worry about receive buffers ! 1211: // or descriptors being exhausted, we'll catch that case ! 1212: // with another interrupt. ! 1213: // ! 1214: ! 1215: { ! 1216: USHORT LocalIsrValue; ! 1217: ! 1218: SONIC_READ_PORT(Adapter, SONIC_INTERRUPT_STATUS, &LocalIsrValue); ! 1219: LocalIsrValue &= SONIC_INT_IMMEDIATE_ACK; ! 1220: ! 1221: if (LocalIsrValue != 0x0000) { ! 1222: ! 1223: // ! 1224: // Ack the bits and set DidSomething so we force ! 1225: // a loop back to the top. ! 1226: // ! 1227: ! 1228: SONIC_WRITE_PORT( ! 1229: Adapter, ! 1230: SONIC_INTERRUPT_STATUS, ! 1231: LocalIsrValue ! 1232: ); ! 1233: ! 1234: Adapter->IsrValue |= LocalIsrValue; ! 1235: DidSomething = TRUE; ! 1236: } ! 1237: } ! 1238: ! 1239: #endif ! 1240: ! 1241: } ! 1242: ! 1243: #ifndef DPR_INTERRUPTS ! 1244: // ! 1245: // If we have had interrupts disabled this whole time, ! 1246: // then reenable them here to permit future interrupts. ! 1247: // ! 1248: SONIC_WRITE_PORT(Adapter, SONIC_INTERRUPT_MASK, ! 1249: Adapter->InterruptMaskRegister ! 1250: ); ! 1251: #endif ! 1252: ! 1253: NdisDprReleaseSpinLock(&Adapter->Lock); ! 1254: ! 1255: if (IndicateReceiveComplete) { ! 1256: ! 1257: // ! 1258: // We have indicated at least one packet, we now ! 1259: // need to signal every open binding that the ! 1260: // receives are complete. ! 1261: // ! 1262: ! 1263: EthFilterIndicateReceiveComplete(Adapter->FilterDB); ! 1264: ! 1265: } ! 1266: ! 1267: } ! 1268: ! 1269: extern ! 1270: VOID ! 1271: SonicTimerProcess( ! 1272: IN PVOID SystemSpecific1, ! 1273: IN PVOID Context, ! 1274: IN PVOID SystemSpecific2, ! 1275: IN PVOID SystemSpecific3 ! 1276: ) ! 1277: ! 1278: /*++ ! 1279: ! 1280: Routine Description: ! 1281: ! 1282: Process the operations that are deferred by SonicDeferredProcessing. ! 1283: ! 1284: Arguments: ! 1285: ! 1286: Context - A pointer to the adapter. ! 1287: ! 1288: Return Value: ! 1289: ! 1290: None. ! 1291: ! 1292: --*/ ! 1293: ! 1294: { ! 1295: ! 1296: PSONIC_ADAPTER Adapter = (PSONIC_ADAPTER)Context; ! 1297: ! 1298: UNREFERENCED_PARAMETER(SystemSpecific1); ! 1299: UNREFERENCED_PARAMETER(SystemSpecific2); ! 1300: UNREFERENCED_PARAMETER(SystemSpecific3); ! 1301: ! 1302: NdisDprAcquireSpinLock(&Adapter->Lock); ! 1303: ! 1304: while ((Adapter->FirstLoopBack || ! 1305: (Adapter->ResetInProgress && (Adapter->References == 2)) || ! 1306: (!IsListEmpty(&Adapter->CloseList)))) { ! 1307: ! 1308: // ! 1309: // Note that the following code depends on the fact that ! 1310: // code above left the spinlock held. ! 1311: // ! 1312: ! 1313: // ! 1314: // If we have a reset in progress and the adapters reference ! 1315: // count is 1 (meaning no routine is in the interface and ! 1316: // we are the only "active" interrupt processing routine) then ! 1317: // it is safe to start the reset. ! 1318: // ! 1319: ! 1320: if (Adapter->ResetInProgress && (Adapter->References == 2)) { ! 1321: ! 1322: Adapter->ProcessingDeferredOperations = FALSE; ! 1323: Adapter->References--; ! 1324: NdisDprReleaseSpinLock(&Adapter->Lock); ! 1325: ! 1326: StartAdapterReset(Adapter); ! 1327: return; ! 1328: ! 1329: } ! 1330: ! 1331: // ! 1332: // Process the loopback queue. ! 1333: // ! 1334: // NOTE: Incase anyone ever figures out how to make this ! 1335: // loop more reentriant, special care needs to be taken that ! 1336: // loopback packets and regular receive packets are NOT being ! 1337: // indicated at the same time. While the filter indication ! 1338: // routines can handle this, I doubt that the transport can. ! 1339: // ! 1340: ! 1341: if (Adapter->FirstLoopBack != NULL ) { ! 1342: ! 1343: SonicProcessLoopback(Adapter); ! 1344: ! 1345: } ! 1346: ! 1347: // ! 1348: // If there are any opens on the closing list and their ! 1349: // reference counts are zero then complete the close and ! 1350: // delete them from the list. ! 1351: // ! 1352: ! 1353: if (!IsListEmpty(&Adapter->CloseList)) { ! 1354: ! 1355: PSONIC_OPEN Open; ! 1356: ! 1357: Open = CONTAINING_RECORD( ! 1358: Adapter->CloseList.Flink, ! 1359: SONIC_OPEN, ! 1360: OpenList ! 1361: ); ! 1362: ! 1363: if (!Open->References) { ! 1364: ! 1365: NDIS_HANDLE OpenBindingContext = Open->NdisBindingContext; ! 1366: ! 1367: RemoveEntryList(&Open->OpenList); ! 1368: SONIC_FREE_MEMORY(Open, sizeof(SONIC_OPEN)); ! 1369: ! 1370: --Adapter->OpenCount; ! 1371: ! 1372: NdisDprReleaseSpinLock(&Adapter->Lock); ! 1373: ! 1374: NdisCompleteCloseAdapter( ! 1375: OpenBindingContext, ! 1376: NDIS_STATUS_SUCCESS ! 1377: ); ! 1378: ! 1379: NdisDprAcquireSpinLock(&Adapter->Lock); ! 1380: ! 1381: } ! 1382: ! 1383: } ! 1384: ! 1385: // ! 1386: // NOTE: We hold the spinlock here. ! 1387: // ! 1388: ! 1389: } ! 1390: ! 1391: Adapter->ProcessingDeferredOperations = FALSE; ! 1392: Adapter->References--; ! 1393: NdisDprReleaseSpinLock(&Adapter->Lock); ! 1394: ! 1395: } ! 1396: ! 1397: #define SONIC_RECEIVE_LIMIT 10 ! 1398: ! 1399: ! 1400: STATIC ! 1401: BOOLEAN ! 1402: ProcessReceiveInterrupts( ! 1403: IN PSONIC_ADAPTER Adapter ! 1404: ) ! 1405: ! 1406: /*++ ! 1407: ! 1408: Routine Description: ! 1409: ! 1410: Process the packets that have finished receiving. ! 1411: ! 1412: NOTE: This routine assumes that no other thread of execution ! 1413: is processing receives! ! 1414: ! 1415: Arguments: ! 1416: ! 1417: Adapter - The adapter to indicate to. ! 1418: ! 1419: Return Value: ! 1420: ! 1421: FALSE if we exit because we have indicated SONIC_RECEIVE_LIMIT ! 1422: packets, TRUE if there are no more packets. ! 1423: ! 1424: --*/ ! 1425: ! 1426: { ! 1427: ! 1428: // ! 1429: // We don't get here unless there was a receive. Loop through ! 1430: // the receive descriptors starting at the last known descriptor ! 1431: // owned by the hardware that begins a packet. ! 1432: // ! 1433: // Examine each receive ring descriptor for errors. ! 1434: // ! 1435: // We keep an array whose elements are indexed by the ring ! 1436: // index of the receive descriptors. The arrays elements are ! 1437: // the virtual addresses of the buffers pointed to by ! 1438: // each ring descriptor. ! 1439: // ! 1440: // When we have the entire packet (and error processing doesn't ! 1441: // prevent us from indicating it), we give the routine that ! 1442: // processes the packet through the filter, the buffers virtual ! 1443: // address (which is always the lookahead size) and as the ! 1444: // MAC context the index to the first and last ring descriptors ! 1445: // comprising the packet. ! 1446: // ! 1447: ! 1448: ! 1449: // ! 1450: // Pointer to the receive descriptor being examined. ! 1451: // ! 1452: PSONIC_RECEIVE_DESCRIPTOR CurrentDescriptor = ! 1453: &Adapter->ReceiveDescriptorArea[ ! 1454: Adapter->CurrentReceiveDescriptorIndex]; ! 1455: ! 1456: // ! 1457: // Index of the RBA that the next packet should ! 1458: // come out of. ! 1459: // ! 1460: UINT CurrentRbaIndex = Adapter->CurrentReceiveBufferIndex; ! 1461: ! 1462: // ! 1463: // Virtual address of the start of that RBA. ! 1464: // ! 1465: PVOID CurrentRbaVa = Adapter->ReceiveBufferArea[CurrentRbaIndex]; ! 1466: ! 1467: // ! 1468: // Physical address of the start of that RBA. ! 1469: // ! 1470: SONIC_PHYSICAL_ADDRESS CurrentRbaPhysical = ! 1471: SONIC_GET_RECEIVE_RESOURCE_ADDRESS(&Adapter->ReceiveResourceArea[CurrentRbaIndex]); ! 1472: ! 1473: // ! 1474: // The size of the packet. ! 1475: // ! 1476: UINT PacketSize; ! 1477: ! 1478: // ! 1479: // The amount of data received in the RBA (will be PacketSize + ! 1480: // 4 for the CRC). ! 1481: ! 1482: USHORT ByteCount; ! 1483: ! 1484: // ! 1485: // The amount of lookahead data to indicate. ! 1486: // ! 1487: UINT LookAheadSize; ! 1488: ! 1489: // ! 1490: // The offset of the start of the packet in its receive buffer. ! 1491: // ! 1492: UINT PacketOffsetInRba; ! 1493: ! 1494: // ! 1495: // The Physical address of the packet. ! 1496: // ! 1497: SONIC_PHYSICAL_ADDRESS PacketPhysical; ! 1498: ! 1499: // ! 1500: // A pointer to the link field at the end of the receive ! 1501: // descriptor before the one we are processing. ! 1502: // ! 1503: PSONIC_PHYSICAL_ADDRESS PrevLinkFieldAddr; ! 1504: ! 1505: // ! 1506: // The virtual address of the packet. ! 1507: // ! 1508: PVOID PacketVa; ! 1509: ! 1510: // ! 1511: // The status of the packet. ! 1512: // ! 1513: USHORT ReceiveStatus; ! 1514: ! 1515: // ! 1516: // Is the descriptor in use by the sonic. ! 1517: // ! 1518: ULONG InUse; ! 1519: ! 1520: // ! 1521: // Used tempoerarily to determine PacketPhysical. ! 1522: // ! 1523: USHORT PacketAddress; ! 1524: ! 1525: // ! 1526: // How many packets we have indicated this time. ! 1527: // ! 1528: UINT PacketsIndicated = 0; ! 1529: ! 1530: #if DBG ! 1531: // ! 1532: // For debugging, save the previous receive descriptor. ! 1533: // ! 1534: static SONIC_RECEIVE_DESCRIPTOR PreviousDescriptor; ! 1535: #endif ! 1536: ! 1537: ! 1538: do { ! 1539: ! 1540: // ! 1541: // Ensure that the system memory copy of the ! 1542: // receive descriptor is up-to-date. ! 1543: // ! 1544: ! 1545: NdisUpdateSharedMemory( ! 1546: Adapter->NdisAdapterHandle, ! 1547: sizeof(SONIC_RECEIVE_DESCRIPTOR) * ! 1548: Adapter->NumberOfReceiveDescriptors, ! 1549: Adapter->ReceiveDescriptorArea, ! 1550: Adapter->ReceiveDescriptorAreaPhysical ! 1551: ); ! 1552: ! 1553: ! 1554: // ! 1555: // Check to see whether we own the packet. If ! 1556: // we don't then simply return to the caller. ! 1557: // ! 1558: ! 1559: NdisReadRegisterUlong(&CurrentDescriptor->InUse, &InUse); ! 1560: ! 1561: if (InUse != SONIC_OWNED_BY_SYSTEM) { ! 1562: ! 1563: return TRUE; ! 1564: ! 1565: } ! 1566: ! 1567: ! 1568: // ! 1569: // Figure out the virtual address of the packet. ! 1570: // ! 1571: ! 1572: NdisReadRegisterUshort(&CurrentDescriptor->LowPacketAddress, &PacketAddress); ! 1573: PacketPhysical = PacketAddress; ! 1574: NdisReadRegisterUshort(&CurrentDescriptor->HighPacketAddress, &PacketAddress); ! 1575: PacketPhysical += PacketAddress << 16; ! 1576: ! 1577: if ((PacketPhysical < CurrentRbaPhysical) || ! 1578: (PacketPhysical > ! 1579: (CurrentRbaPhysical + SONIC_SIZE_OF_RECEIVE_BUFFERS))) { ! 1580: ! 1581: // ! 1582: // Something is wrong, the packet is not in the ! 1583: // receive buffer that we expect it in. ! 1584: // ! 1585: ! 1586: SONIC_PHYSICAL_ADDRESS ResourcePhysical; ! 1587: PSONIC_RECEIVE_RESOURCE CurrentReceiveResource; ! 1588: UINT i; ! 1589: ! 1590: if (Adapter->WrongRbaErrorLogCount++ < 5) { ! 1591: ! 1592: // ! 1593: // Log an error the first five times this happens. ! 1594: // ! 1595: ! 1596: NdisWriteErrorLogEntry( ! 1597: Adapter->NdisAdapterHandle, ! 1598: NDIS_ERROR_CODE_HARDWARE_FAILURE, ! 1599: 6, ! 1600: processReceiveInterrupts, ! 1601: SONIC_ERRMSG_WRONG_RBA, ! 1602: (ULONG)CurrentRbaPhysical, ! 1603: (ULONG)PacketPhysical, ! 1604: (ULONG)CurrentDescriptor, ! 1605: (ULONG)Adapter->ReceiveDescriptorArea ! 1606: ); ! 1607: ! 1608: #if DBG ! 1609: DbgPrint("SONIC: RBA at %lx [%lx], Packet at %lx\n", CurrentRbaPhysical, CurrentRbaVa, PacketPhysical); ! 1610: DbgPrint("descriptor %lx, start %lx, prev %lx\n", ! 1611: (ULONG)CurrentDescriptor, ! 1612: (ULONG)Adapter->ReceiveDescriptorArea, ! 1613: &PreviousDescriptor); ! 1614: #endif ! 1615: } ! 1616: ! 1617: // ! 1618: // Attempt to recover by advancing the relevant pointers ! 1619: // to where the SONIC thinks the packet is. First we need ! 1620: // to find the receive buffer that matches the indicated ! 1621: // physical address. ! 1622: // ! 1623: ! 1624: for ( ! 1625: i = 0, CurrentReceiveResource = Adapter->ReceiveResourceArea; ! 1626: i < Adapter->NumberOfReceiveBuffers; ! 1627: i++,CurrentReceiveResource++ ! 1628: ) { ! 1629: ! 1630: ResourcePhysical = SONIC_GET_RECEIVE_RESOURCE_ADDRESS(CurrentReceiveResource); ! 1631: if ((PacketPhysical >= ResourcePhysical) && ! 1632: (PacketPhysical < ! 1633: (ResourcePhysical + SONIC_SIZE_OF_RECEIVE_BUFFERS))) { ! 1634: ! 1635: // ! 1636: // We found the receive resource. ! 1637: // ! 1638: break; ! 1639: ! 1640: } ! 1641: ! 1642: } ! 1643: ! 1644: #ifdef NDIS_NT ! 1645: if (i == Adapter->NumberOfReceiveBuffers) { ! 1646: KeBugCheck(NDIS_INTERNAL_ERROR); ! 1647: } ! 1648: #endif ! 1649: ! 1650: // ! 1651: // Update our pointers. ! 1652: // ! 1653: ! 1654: Adapter->CurrentReceiveBufferIndex = i; ! 1655: CurrentRbaIndex = i; ! 1656: ! 1657: CurrentRbaVa = Adapter->ReceiveBufferArea[i]; ! 1658: CurrentRbaPhysical = ! 1659: SONIC_GET_RECEIVE_RESOURCE_ADDRESS(&Adapter->ReceiveResourceArea[i]); ! 1660: ! 1661: // ! 1662: // Ensure that we release buffers before this one ! 1663: // back to the sonic. ! 1664: // ! 1665: ! 1666: WRITE_RWP_AND_ACK( ! 1667: Adapter, ! 1668: (USHORT)(CurrentRbaPhysical & 0xffff) ! 1669: ); ! 1670: ! 1671: } ! 1672: ! 1673: ! 1674: PacketOffsetInRba = PacketPhysical - CurrentRbaPhysical; ! 1675: ! 1676: ! 1677: // ! 1678: // Check that the packet was received correctly...note that ! 1679: // we always compute PacketOffsetInRba and ByteCount, ! 1680: // which are needed to skip the packet even if we do not ! 1681: // indicate it. ! 1682: // ! 1683: ! 1684: NdisReadRegisterUshort(&CurrentDescriptor->ReceiveStatus, &ReceiveStatus); ! 1685: ! 1686: NdisReadRegisterUshort(&CurrentDescriptor->ByteCount, &ByteCount); ! 1687: ! 1688: if (!(ReceiveStatus & SONIC_RCR_PACKET_RECEIVED_OK)) { ! 1689: ! 1690: #if DBG ! 1691: if (SonicDbg) { ! 1692: DbgPrint("SONIC: Skipping %lx\n", ReceiveStatus); ! 1693: } ! 1694: #endif ! 1695: ! 1696: goto SkipIndication; ! 1697: ! 1698: } ! 1699: ! 1700: // ! 1701: // Prepare to indicate the packet. ! 1702: // ! 1703: ! 1704: PacketSize = ByteCount - 4; ! 1705: ! 1706: if (PacketSize > 1514) { ! 1707: #if DBG ! 1708: DbgPrint("SONIC: Skipping packet, length %d\n", PacketSize); ! 1709: #endif ! 1710: goto SkipIndication; ! 1711: } ! 1712: ! 1713: ! 1714: if (PacketSize < SONIC_INDICATE_MAXIMUM) { ! 1715: ! 1716: LookAheadSize = PacketSize; ! 1717: ! 1718: } else { ! 1719: ! 1720: LookAheadSize = SONIC_INDICATE_MAXIMUM; ! 1721: ! 1722: } ! 1723: ! 1724: PacketVa = (PUCHAR)CurrentRbaVa + PacketOffsetInRba; ! 1725: ! 1726: ! 1727: // ! 1728: // Check just before we do indications that we aren't ! 1729: // resetting. ! 1730: // ! 1731: ! 1732: if (Adapter->ResetInProgress) { ! 1733: return TRUE; ! 1734: } ! 1735: ! 1736: // ! 1737: // Ensure that the system memory version of this RBA is ! 1738: // up-to-date. ! 1739: // ! 1740: ! 1741: { ! 1742: NDIS_PHYSICAL_ADDRESS TempAddress; ! 1743: ! 1744: NdisSetPhysicalAddressLow (TempAddress, ! 1745: SONIC_GET_RECEIVE_RESOURCE_ADDRESS(&Adapter->ReceiveResourceArea[CurrentRbaIndex])); ! 1746: NdisSetPhysicalAddressHigh (TempAddress, 0); ! 1747: ! 1748: NdisUpdateSharedMemory( ! 1749: Adapter->NdisAdapterHandle, ! 1750: SONIC_SIZE_OF_RECEIVE_BUFFERS, ! 1751: Adapter->ReceiveBufferArea[CurrentRbaIndex], ! 1752: TempAddress ! 1753: ); ! 1754: ! 1755: } ! 1756: ! 1757: if (PacketSize < 14) { ! 1758: ! 1759: // ! 1760: // Must have at least the destination address ! 1761: // ! 1762: ! 1763: if (PacketSize >= ETH_LENGTH_OF_ADDRESS) { ! 1764: ! 1765: // ! 1766: // Runt packet ! 1767: // ! 1768: ! 1769: EthFilterIndicateReceive( ! 1770: Adapter->FilterDB, ! 1771: (NDIS_HANDLE)((PUCHAR)PacketVa + 14), // context ! 1772: PacketVa, // destination address ! 1773: PacketVa, // header buffer ! 1774: PacketSize, // header buffer size ! 1775: NULL, // lookahead buffer ! 1776: 0, // lookahead buffer size ! 1777: 0 // packet size ! 1778: ); ! 1779: ! 1780: } ! 1781: ! 1782: } else { ! 1783: ! 1784: EthFilterIndicateReceive( ! 1785: Adapter->FilterDB, ! 1786: (NDIS_HANDLE)((PUCHAR)PacketVa + 14), // context ! 1787: PacketVa, // destination address ! 1788: PacketVa, // header buffer ! 1789: 14, // header buffer size ! 1790: (PUCHAR)PacketVa + 14, // lookahead buffer ! 1791: LookAheadSize - 14, // lookahead buffer size ! 1792: PacketSize - 14 // packet size ! 1793: ); ! 1794: ! 1795: } ! 1796: ! 1797: SkipIndication:; ! 1798: ! 1799: #if DBG ! 1800: SONIC_MOVE_MEMORY (&PreviousDescriptor, CurrentDescriptor, sizeof(SONIC_RECEIVE_DESCRIPTOR)); ! 1801: #endif ! 1802: ! 1803: // ! 1804: // Give the packet back to the hardware. ! 1805: // ! 1806: ! 1807: NdisWriteRegisterUlong(&CurrentDescriptor->InUse, SONIC_OWNED_BY_SONIC); ! 1808: ! 1809: // ! 1810: // And re-set the EOL fields correctly. ! 1811: // ! 1812: ! 1813: SONIC_SET_END_OF_LIST( ! 1814: &(CurrentDescriptor->Link) ! 1815: ); ! 1816: ! 1817: ! 1818: ! 1819: if (CurrentDescriptor == Adapter->ReceiveDescriptorArea) { ! 1820: ! 1821: // ! 1822: // we are at the first one ! 1823: // ! 1824: ! 1825: PrevLinkFieldAddr = &(Adapter->LastReceiveDescriptor->Link); ! 1826: ! 1827: } else { ! 1828: ! 1829: PrevLinkFieldAddr = &((CurrentDescriptor-1)->Link); ! 1830: ! 1831: } ! 1832: ! 1833: ! 1834: REMOVE_EOL_AND_ACK( ! 1835: Adapter, ! 1836: PrevLinkFieldAddr ! 1837: ); ! 1838: ! 1839: ! 1840: ! 1841: // ! 1842: // Now figure out if the RBA is done with. ! 1843: // ! 1844: ! 1845: if (ReceiveStatus & SONIC_RCR_LAST_PACKET_IN_RBA) { ! 1846: ! 1847: // ! 1848: // Advance which RBA we are looking at. ! 1849: // ! 1850: ! 1851: ++CurrentRbaIndex; ! 1852: ! 1853: if (CurrentRbaIndex == Adapter->NumberOfReceiveBuffers) { ! 1854: ! 1855: CurrentRbaIndex = 0; ! 1856: ! 1857: } ! 1858: ! 1859: Adapter->CurrentReceiveBufferIndex = CurrentRbaIndex; ! 1860: ! 1861: CurrentRbaVa = Adapter->ReceiveBufferArea[CurrentRbaIndex]; ! 1862: CurrentRbaPhysical = ! 1863: SONIC_GET_RECEIVE_RESOURCE_ADDRESS(&Adapter->ReceiveResourceArea[CurrentRbaIndex]); ! 1864: ! 1865: ! 1866: WRITE_RWP_AND_ACK( ! 1867: Adapter, ! 1868: (USHORT)(CurrentRbaPhysical & 0xffff) ! 1869: ); ! 1870: ! 1871: } ! 1872: ! 1873: // ! 1874: // Update statistics now based on the receive status. ! 1875: // ! 1876: ! 1877: if (ReceiveStatus & SONIC_RCR_PACKET_RECEIVED_OK) { ! 1878: ! 1879: ++Adapter->GeneralMandatory[GM_RECEIVE_GOOD]; ! 1880: ! 1881: if (ReceiveStatus & SONIC_RCR_BROADCAST_RECEIVED) { ! 1882: ! 1883: ++Adapter->GeneralOptionalFrameCount[GO_BROADCAST_RECEIVES]; ! 1884: SonicAddUlongToLargeInteger( ! 1885: &Adapter->GeneralOptionalByteCount[GO_BROADCAST_RECEIVES], ! 1886: PacketSize); ! 1887: ! 1888: } else if (ReceiveStatus & SONIC_RCR_MULTICAST_RECEIVED) { ! 1889: ! 1890: ++Adapter->GeneralOptionalFrameCount[GO_MULTICAST_RECEIVES]; ! 1891: SonicAddUlongToLargeInteger( ! 1892: &Adapter->GeneralOptionalByteCount[GO_MULTICAST_RECEIVES], ! 1893: PacketSize); ! 1894: ! 1895: } else { ! 1896: ! 1897: ++Adapter->GeneralOptionalFrameCount[GO_DIRECTED_RECEIVES]; ! 1898: SonicAddUlongToLargeInteger( ! 1899: &Adapter->GeneralOptionalByteCount[GO_DIRECTED_RECEIVES], ! 1900: PacketSize); ! 1901: ! 1902: } ! 1903: ! 1904: } else { ! 1905: ! 1906: ++Adapter->GeneralMandatory[GM_RECEIVE_BAD]; ! 1907: ! 1908: if (ReceiveStatus & SONIC_RCR_CRC_ERROR) { ! 1909: ++Adapter->GeneralOptional[GO_RECEIVE_CRC - GO_ARRAY_START]; ! 1910: } else if (ReceiveStatus & SONIC_RCR_FRAME_ALIGNMENT) { ! 1911: ++Adapter->MediaMandatory[MM_RECEIVE_ERROR_ALIGNMENT]; ! 1912: } ! 1913: ! 1914: } ! 1915: ! 1916: // ! 1917: // Advance our pointers to the next packet. ! 1918: ! 1919: if (CurrentDescriptor == Adapter->LastReceiveDescriptor) { ! 1920: ! 1921: Adapter->CurrentReceiveDescriptorIndex = 0; ! 1922: ! 1923: } else { ! 1924: ! 1925: ++(Adapter->CurrentReceiveDescriptorIndex); ! 1926: ! 1927: } ! 1928: ! 1929: CurrentDescriptor = &Adapter->ReceiveDescriptorArea[ ! 1930: Adapter->CurrentReceiveDescriptorIndex]; ! 1931: ! 1932: ++PacketsIndicated; ! 1933: ! 1934: } while (PacketsIndicated < SONIC_RECEIVE_LIMIT); ! 1935: ! 1936: // ! 1937: // Indicate that we returned because we indicated SONIC_RECEIVE_ ! 1938: // LIMIT packets, not because we ran out of packets to indicate. ! 1939: // ! 1940: ! 1941: return FALSE; ! 1942: ! 1943: } ! 1944: ! 1945: STATIC ! 1946: BOOLEAN ! 1947: ProcessTransmitInterrupts( ! 1948: IN PSONIC_ADAPTER Adapter ! 1949: ) ! 1950: ! 1951: /*++ ! 1952: ! 1953: Routine Description: ! 1954: ! 1955: Process the packets that have finished transmitting. ! 1956: ! 1957: NOTE: Called with the lock held! ! 1958: ! 1959: Arguments: ! 1960: ! 1961: Adapter - The adapter that was sent from. ! 1962: ! 1963: Return Value: ! 1964: ! 1965: This function will return TRUE if it finished up the ! 1966: send on a packet. It will return FALSE if for some ! 1967: reason there was no packet to process. ! 1968: ! 1969: --*/ ! 1970: ! 1971: { ! 1972: // ! 1973: // Index into the ring to packet structure. This index points ! 1974: // to the first ring entry for the first buffer used for transmitting ! 1975: // the packet. ! 1976: // ! 1977: UINT DescriptorIndex; ! 1978: ! 1979: // ! 1980: // The transmit desctiptor for the packet at Transmitting Descriptor ! 1981: // ! 1982: PSONIC_TRANSMIT_DESCRIPTOR TransmitDescriptor; ! 1983: ! 1984: // ! 1985: // Temporarily holds the transmit descriptor after TransmitDescriptor ! 1986: // ! 1987: PSONIC_TRANSMIT_DESCRIPTOR NextTransmitDescriptor; ! 1988: ! 1989: // ! 1990: // Pointer to the packet that started this transmission. ! 1991: // ! 1992: PNDIS_PACKET OwningPacket; ! 1993: ! 1994: // ! 1995: // Points to the reserved part of the OwningPacket. ! 1996: // ! 1997: PSONIC_PACKET_RESERVED Reserved; ! 1998: ! 1999: // ! 2000: // Used to hold the ring to packet mapping information so that ! 2001: // we can release the ring entries as quickly as possible. ! 2002: // ! 2003: SONIC_DESCRIPTOR_TO_PACKET SavedDescriptorMapping; ! 2004: ! 2005: // ! 2006: // The status of the transmit. ! 2007: // ! 2008: USHORT TransmitStatus; ! 2009: ! 2010: // ! 2011: // Hold the first Ndis buffer; ! 2012: // ! 2013: PNDIS_BUFFER FirstBuffer; ! 2014: ! 2015: // ! 2016: // Holds the address of the data in the first buffer ! 2017: // ! 2018: PVOID BufferVirtualAddress; ! 2019: ! 2020: // ! 2021: // Number of bytes in the first buffer. ! 2022: // ! 2023: UINT BufferLength; ! 2024: ! 2025: ! 2026: // ! 2027: // Get hold of the first transmitted packet. ! 2028: // ! 2029: ! 2030: // ! 2031: // First we check that this is a packet that was transmitted ! 2032: // but not already processed. Recall that this routine ! 2033: // will be called repeatedly until this tests false, Or we ! 2034: // hit a packet that we don't completely own. ! 2035: // ! 2036: ! 2037: if (Adapter->TransmittingDescriptor != ! 2038: Adapter->FirstUncommittedDescriptor) { ! 2039: ! 2040: DescriptorIndex = ! 2041: Adapter->TransmittingDescriptor - Adapter->TransmitDescriptorArea; ! 2042: ! 2043: } else { ! 2044: ! 2045: return FALSE; ! 2046: ! 2047: } ! 2048: ! 2049: // ! 2050: // We put the mapping into a local variable so that we ! 2051: // can return the mapping as soon as possible. ! 2052: // ! 2053: ! 2054: SavedDescriptorMapping = Adapter->DescriptorToPacket[DescriptorIndex]; ! 2055: ! 2056: // ! 2057: // Get a pointer to the transmit descriptor for this packet. ! 2058: // ! 2059: ! 2060: TransmitDescriptor = Adapter->TransmitDescriptorArea + DescriptorIndex; ! 2061: ! 2062: // ! 2063: // Get a pointer to the owning packet and the reserved part of ! 2064: // the packet. ! 2065: // ! 2066: ! 2067: OwningPacket = SavedDescriptorMapping.OwningPacket; ! 2068: ! 2069: Reserved = PSONIC_RESERVED_FROM_PACKET(OwningPacket); ! 2070: ! 2071: ! 2072: // ! 2073: // Check that status bits were written into the transmit ! 2074: // descriptor. ! 2075: // ! 2076: ! 2077: NdisReadRegisterUshort(&TransmitDescriptor->TransmitStatus, &TransmitStatus); ! 2078: ! 2079: if (!(TransmitStatus & SONIC_TCR_STATUS_MASK)) { ! 2080: ! 2081: // ! 2082: // The transmit has not completed. ! 2083: // ! 2084: ! 2085: return FALSE; ! 2086: ! 2087: } else { ! 2088: ! 2089: // ! 2090: // Holds whether the packet successfully transmitted or not. ! 2091: // ! 2092: BOOLEAN Successful = TRUE; ! 2093: ! 2094: Adapter->WakeUpTimeout = FALSE; ! 2095: ! 2096: if (SavedDescriptorMapping.UsedSonicBuffer) { ! 2097: ! 2098: // ! 2099: // This packet used adapter buffers. We can ! 2100: // now return these buffers to the adapter. ! 2101: // ! 2102: ! 2103: // ! 2104: // The adapter buffer descriptor that was allocated to this packet. ! 2105: // ! 2106: PSONIC_BUFFER_DESCRIPTOR BufferDescriptor = Adapter->SonicBuffers + ! 2107: SavedDescriptorMapping.SonicBuffersIndex; ! 2108: ! 2109: // ! 2110: // Index of the listhead that heads the list that the adapter ! 2111: // buffer descriptor belongs too. ! 2112: // ! 2113: INT ListHeadIndex = BufferDescriptor->Next; ! 2114: ! 2115: ! 2116: // ! 2117: // Put the adapter buffer back on the free list. ! 2118: // ! 2119: ! 2120: BufferDescriptor->Next = Adapter->SonicBufferListHeads[ListHeadIndex]; ! 2121: Adapter->SonicBufferListHeads[ListHeadIndex] = SavedDescriptorMapping.SonicBuffersIndex; ! 2122: ! 2123: } else { ! 2124: ! 2125: // ! 2126: // Points to the current ndis buffer being walked. ! 2127: // ! 2128: PNDIS_BUFFER CurrentBuffer; ! 2129: ! 2130: // ! 2131: // Which map register we use for this buffer. ! 2132: // ! 2133: UINT CurMapRegister; ! 2134: ! 2135: // ! 2136: // The transmit is finished, so we can release ! 2137: // the physical mapping used for it. ! 2138: // ! 2139: ! 2140: NdisQueryPacket( ! 2141: OwningPacket, ! 2142: NULL, ! 2143: NULL, ! 2144: &CurrentBuffer, ! 2145: NULL ! 2146: ); ! 2147: ! 2148: CurMapRegister = DescriptorIndex * SONIC_MAX_FRAGMENTS; ! 2149: ! 2150: while (CurrentBuffer) { ! 2151: ! 2152: NdisCompleteBufferPhysicalMapping( ! 2153: Adapter->NdisAdapterHandle, ! 2154: CurrentBuffer, ! 2155: CurMapRegister ! 2156: ); ! 2157: ! 2158: ++CurMapRegister; ! 2159: ! 2160: NdisGetNextBuffer( ! 2161: CurrentBuffer, ! 2162: &CurrentBuffer ! 2163: ); ! 2164: ! 2165: } ! 2166: ! 2167: } ! 2168: ! 2169: ! 2170: // ! 2171: // Now release the transmit descriptor, since we have ! 2172: // gotten all the information we need from it. ! 2173: // ! 2174: ! 2175: if (TransmitDescriptor == Adapter->LastTransmitDescriptor) { ! 2176: ! 2177: NextTransmitDescriptor = Adapter->TransmitDescriptorArea; ! 2178: ! 2179: } else { ! 2180: ! 2181: NextTransmitDescriptor = Adapter->TransmittingDescriptor + 1; ! 2182: ! 2183: } ! 2184: ! 2185: if (TransmitStatus & ! 2186: (SONIC_TCR_EXCESSIVE_DEFERRAL | ! 2187: SONIC_TCR_EXCESSIVE_COLLISIONS | ! 2188: SONIC_TCR_FIFO_UNDERRUN | ! 2189: SONIC_TCR_BYTE_COUNT_MISMATCH)) { ! 2190: ! 2191: // ! 2192: // If the packet completed with an abort state, then we ! 2193: // need to restart the transmitter unless we are the ! 2194: // last transmit queued up. We set CTDA to point after ! 2195: // this descriptor in any case. ! 2196: // ! 2197: ! 2198: #if DBG ! 2199: if (SonicDbg) { ! 2200: DbgPrint ("SONIC: Advancing CTDA after abort\n"); ! 2201: } ! 2202: #endif ! 2203: ! 2204: SONIC_WRITE_PORT(Adapter, SONIC_CURR_TRANSMIT_DESCRIPTOR, ! 2205: SONIC_GET_LOW_PART_ADDRESS( ! 2206: NdisGetPhysicalAddressLow(Adapter->TransmitDescriptorAreaPhysical) + ! 2207: ((PUCHAR)NextTransmitDescriptor - ! 2208: (PUCHAR)Adapter->TransmitDescriptorArea)) ! 2209: ); ! 2210: ! 2211: if (Adapter->FirstUncommittedDescriptor != NextTransmitDescriptor) { ! 2212: #if DBG ! 2213: if (SonicDbg) { ! 2214: DbgPrint ("SONIC: Restarting transmit after abort\n"); ! 2215: } ! 2216: #endif ! 2217: SONIC_WRITE_PORT(Adapter, SONIC_COMMAND, SONIC_CR_TRANSMIT_PACKETS); ! 2218: } ! 2219: ! 2220: } ! 2221: ! 2222: Adapter->TransmittingDescriptor = NextTransmitDescriptor; ! 2223: Adapter->NumberOfAvailableDescriptors++; ! 2224: ! 2225: // ! 2226: // Check if the packet completed OK, and update statistics. ! 2227: // ! 2228: ! 2229: if (!(TransmitStatus & SONIC_TCR_PACKET_TRANSMITTED_OK)) { ! 2230: ! 2231: #if DBG ! 2232: if (SonicDbg) { ! 2233: DbgPrint("SONIC: Transmit failed: %lx\n", TransmitStatus); ! 2234: } ! 2235: #endif ! 2236: Successful = FALSE; ! 2237: ! 2238: ++Adapter->GeneralMandatory[GM_TRANSMIT_BAD]; ! 2239: ! 2240: if (TransmitStatus & SONIC_TCR_EXCESSIVE_COLLISIONS) { ! 2241: ++Adapter->MediaOptional[MO_TRANSMIT_MAX_COLLISIONS]; ! 2242: } ! 2243: ! 2244: if (TransmitStatus & SONIC_TCR_FIFO_UNDERRUN) { ! 2245: ++Adapter->MediaOptional[MO_TRANSMIT_UNDERRUN]; ! 2246: } ! 2247: ! 2248: } else { ! 2249: ! 2250: INT Collisions = (TransmitStatus & SONIC_TCR_COLLISIONS_MASK) >> SONIC_TCR_COLLISIONS_SHIFT; ! 2251: ! 2252: Successful = TRUE; ! 2253: ! 2254: ++Adapter->GeneralMandatory[GM_TRANSMIT_GOOD]; ! 2255: ! 2256: if (Collisions > 0) { ! 2257: if (Collisions == 1) { ! 2258: ++Adapter->MediaMandatory[MM_TRANSMIT_ONE_COLLISION]; ! 2259: } else { ! 2260: ++Adapter->MediaMandatory[MM_TRANSMIT_MORE_COLLISIONS]; ! 2261: } ! 2262: } ! 2263: ! 2264: if (TransmitStatus & ! 2265: (SONIC_TCR_DEFERRED_TRANSMISSION | ! 2266: SONIC_TCR_NO_CARRIER_SENSE | ! 2267: SONIC_TCR_CARRIER_LOST | ! 2268: SONIC_TCR_OUT_OF_WINDOW)) { ! 2269: ! 2270: if (TransmitStatus & SONIC_TCR_DEFERRED_TRANSMISSION) { ! 2271: ++Adapter->MediaOptional[MO_TRANSMIT_DEFERRED]; ! 2272: } ! 2273: if (TransmitStatus & SONIC_TCR_NO_CARRIER_SENSE) { ! 2274: ++Adapter->MediaOptional[MO_TRANSMIT_HEARTBEAT_FAILURE]; ! 2275: } ! 2276: if (TransmitStatus & SONIC_TCR_CARRIER_LOST) { ! 2277: ++Adapter->MediaOptional[MO_TRANSMIT_TIMES_CRS_LOST]; ! 2278: } ! 2279: if (TransmitStatus & SONIC_TCR_OUT_OF_WINDOW) { ! 2280: ++Adapter->MediaOptional[MO_TRANSMIT_LATE_COLLISIONS]; ! 2281: } ! 2282: } ! 2283: ! 2284: switch (Reserved->PacketType) { ! 2285: ! 2286: case SONIC_DIRECTED: ! 2287: ! 2288: ++Adapter->GeneralOptionalFrameCount[GO_DIRECTED_TRANSMITS]; ! 2289: SonicAddUlongToLargeInteger( ! 2290: &Adapter->GeneralOptionalByteCount[GO_DIRECTED_TRANSMITS], ! 2291: Reserved->PacketLength); ! 2292: break; ! 2293: ! 2294: case SONIC_MULTICAST: ! 2295: ! 2296: ++Adapter->GeneralOptionalFrameCount[GO_MULTICAST_TRANSMITS]; ! 2297: SonicAddUlongToLargeInteger( ! 2298: &Adapter->GeneralOptionalByteCount[GO_MULTICAST_TRANSMITS], ! 2299: Reserved->PacketLength); ! 2300: break; ! 2301: ! 2302: case SONIC_BROADCAST: ! 2303: ! 2304: ++Adapter->GeneralOptionalFrameCount[GO_BROADCAST_TRANSMITS]; ! 2305: SonicAddUlongToLargeInteger( ! 2306: &Adapter->GeneralOptionalByteCount[GO_BROADCAST_TRANSMITS], ! 2307: Reserved->PacketLength); ! 2308: break; ! 2309: ! 2310: } ! 2311: ! 2312: } ! 2313: ! 2314: // ! 2315: // Remove packet from queue. ! 2316: // ! 2317: ! 2318: if (Adapter->LastFinishTransmit == OwningPacket) { ! 2319: ! 2320: Adapter->FirstFinishTransmit = NULL; ! 2321: Adapter->LastFinishTransmit = NULL; ! 2322: ! 2323: } else { ! 2324: ! 2325: Adapter->FirstFinishTransmit = Reserved->Next; ! 2326: } ! 2327: ! 2328: #ifdef CHECK_DUP_SENDS ! 2329: { ! 2330: VOID SonicRemovePacketFromList(PSONIC_ADAPTER, PNDIS_PACKET); ! 2331: SonicRemovePacketFromList(Adapter, OwningPacket); ! 2332: } ! 2333: #endif ! 2334: ! 2335: // ! 2336: // Now check if the packet needs to be loopbacked as well. If not, ! 2337: // then we complete the send, else after it is loopbacked it will ! 2338: // get completed there. ! 2339: // ! 2340: ! 2341: NdisQueryPacket( ! 2342: OwningPacket, ! 2343: NULL, ! 2344: NULL, ! 2345: &FirstBuffer, ! 2346: NULL ! 2347: ); ! 2348: ! 2349: // ! 2350: // Get VA of first buffer ! 2351: // ! 2352: ! 2353: NdisQueryBuffer( ! 2354: FirstBuffer, ! 2355: &BufferVirtualAddress, ! 2356: &BufferLength ! 2357: ); ! 2358: ! 2359: if (!EthShouldAddressLoopBack( ! 2360: Adapter->FilterDB, ! 2361: BufferVirtualAddress ! 2362: )) { ! 2363: ! 2364: // ! 2365: // The binding that is submitting this packet. ! 2366: // ! 2367: PSONIC_OPEN Open = ! 2368: PSONIC_OPEN_FROM_BINDING_HANDLE(Reserved->MacBindingHandle); ! 2369: ! 2370: // ! 2371: // Along with at least one reference because of the coming ! 2372: // indication there should be a reference because of the ! 2373: // packet to indicate. ! 2374: // ! 2375: ! 2376: ASSERT(Open->References > 1); ! 2377: ! 2378: ! 2379: NdisDprReleaseSpinLock(&Adapter->Lock); ! 2380: ! 2381: NdisCompleteSend( ! 2382: Open->NdisBindingContext, ! 2383: OwningPacket, ! 2384: ((Successful)?(NDIS_STATUS_SUCCESS):(NDIS_STATUS_FAILURE)) ! 2385: ); ! 2386: ! 2387: NdisDprAcquireSpinLock(&Adapter->Lock); ! 2388: ! 2389: // ! 2390: // We reduce the count by two to account for the fact ! 2391: // that we aren't indicating to the open and that one ! 2392: // less packet is owned by this open. ! 2393: // ! 2394: ! 2395: Open->References--; ! 2396: ! 2397: } else { ! 2398: ! 2399: // ! 2400: // Put it on the loopback queue. ! 2401: // ! 2402: ! 2403: SonicPutPacketOnLoopBack( ! 2404: Adapter, ! 2405: OwningPacket, ! 2406: Successful ! 2407: ); ! 2408: ! 2409: } ! 2410: ! 2411: // ! 2412: // Since we've given back some ring entries we should ! 2413: // open the send stage if it was closed and we are not resetting. ! 2414: // ! 2415: ! 2416: if ((!Adapter->SendStageOpen) && (!Adapter->ResetInProgress)) { ! 2417: ! 2418: Adapter->SendStageOpen = TRUE; ! 2419: ! 2420: } ! 2421: ! 2422: Adapter->PacketsSinceLastInterrupt = 0; ! 2423: ! 2424: return TRUE; ! 2425: } ! 2426: ! 2427: } ! 2428: ! 2429: VOID ! 2430: SonicWakeUpDpc( ! 2431: IN PVOID SystemSpecific1, ! 2432: IN PVOID Context, ! 2433: IN PVOID SystemSpecific2, ! 2434: IN PVOID SystemSpecific3 ! 2435: ) ! 2436: ! 2437: /*++ ! 2438: ! 2439: Routine Description: ! 2440: ! 2441: This DPC routine is queued every 5 seconds to check on the ! 2442: transmit descriptor ring. This is to solve problems where ! 2443: no status is written into the currently transmitting transmit ! 2444: descriptor, which hangs our transmit completion processing. ! 2445: If we detect this state, we simulate a transmit interrupt. ! 2446: ! 2447: Arguments: ! 2448: ! 2449: Context - Really a pointer to the adapter. ! 2450: ! 2451: Return Value: ! 2452: ! 2453: None. ! 2454: ! 2455: --*/ ! 2456: { ! 2457: PSONIC_ADAPTER Adapter = (PSONIC_ADAPTER)Context; ! 2458: UINT DescriptorIndex; ! 2459: PSONIC_TRANSMIT_DESCRIPTOR TransmitDescriptor; ! 2460: USHORT TransmitStatus; ! 2461: ! 2462: ! 2463: UNREFERENCED_PARAMETER(SystemSpecific1); ! 2464: UNREFERENCED_PARAMETER(SystemSpecific2); ! 2465: UNREFERENCED_PARAMETER(SystemSpecific3); ! 2466: ! 2467: NdisDprAcquireSpinLock(&Adapter->Lock); ! 2468: ! 2469: if (Adapter->WakeUpTimeout) { ! 2470: ! 2471: // ! 2472: // We had a pending send the last time we ran, ! 2473: // and it has not been completed...we need to fake ! 2474: // its completion. ! 2475: // ! 2476: ! 2477: ASSERT (Adapter->TransmittingDescriptor != ! 2478: Adapter->FirstUncommittedDescriptor); ! 2479: ! 2480: DescriptorIndex = ! 2481: Adapter->TransmittingDescriptor - Adapter->TransmitDescriptorArea; ! 2482: ! 2483: TransmitDescriptor = Adapter->TransmitDescriptorArea + DescriptorIndex; ! 2484: NdisReadRegisterUshort(&TransmitDescriptor->TransmitStatus, &TransmitStatus); ! 2485: ! 2486: if (!(TransmitStatus & SONIC_TCR_STATUS_MASK)) { ! 2487: ! 2488: NdisWriteRegisterUshort (&TransmitDescriptor->TransmitStatus, ! 2489: SONIC_TCR_PACKET_TRANSMITTED_OK); ! 2490: ! 2491: #if DBG ! 2492: DbgPrint ("SONIC: Woke up descriptor at %lx\n", TransmitDescriptor); ! 2493: #endif ! 2494: ! 2495: } ! 2496: ! 2497: Adapter->IsrValue |= SONIC_INT_PACKET_TRANSMITTED; ! 2498: ! 2499: Adapter->WakeUpTimeout = FALSE; ! 2500: ! 2501: NdisWriteErrorLogEntry( ! 2502: Adapter->NdisAdapterHandle, ! 2503: NDIS_ERROR_CODE_HARDWARE_FAILURE, ! 2504: 0 ! 2505: ); ! 2506: ! 2507: } else if (Adapter->TransmittingDescriptor != ! 2508: Adapter->FirstUncommittedDescriptor) { ! 2509: ! 2510: DescriptorIndex = ! 2511: Adapter->TransmittingDescriptor - Adapter->TransmitDescriptorArea; ! 2512: ! 2513: TransmitDescriptor = Adapter->TransmitDescriptorArea + DescriptorIndex; ! 2514: NdisReadRegisterUshort(&TransmitDescriptor->TransmitStatus, &TransmitStatus); ! 2515: ! 2516: if (!(TransmitStatus & SONIC_TCR_STATUS_MASK)) { ! 2517: ! 2518: Adapter->WakeUpTimeout = TRUE; ! 2519: ! 2520: } ! 2521: ! 2522: } ! 2523: ! 2524: NdisDprReleaseSpinLock(&Adapter->Lock); ! 2525: ! 2526: // ! 2527: // Fire off another Dpc to execute after 5 seconds ! 2528: // ! 2529: ! 2530: NdisSetTimer( ! 2531: &Adapter->WakeUpTimer, ! 2532: 5000 ! 2533: ); ! 2534: ! 2535: } ! 2536:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.