![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to alloc.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 alloc.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: alloc.c ! 8: ! 9: Abstract: ! 10: ! 11: This file contains the code for allocating and freeing adapter ! 12: resources for the National Semiconductor SONIC Ethernet controller. ! 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: Anthony V. Ercolano (Tonye) 20-Jul-1990 ! 21: Adam Barr (adamba) 14-Nov-1990 ! 22: ! 23: Environment: ! 24: ! 25: Kernel Mode - Or whatever is the equivalent. ! 26: ! 27: Revision History: ! 28: ! 29: ! 30: --*/ ! 31: ! 32: #include <ndis.h> ! 33: ! 34: ! 35: #include <efilter.h> ! 36: #include <sonichrd.h> ! 37: #include <sonicsft.h> ! 38: ! 39: ! 40: ! 41: STATIC ! 42: PNDIS_BUFFER ! 43: AllocateFlushBuffer( ! 44: IN PSONIC_ADAPTER Adapter, ! 45: IN PVOID VirtualAddress, ! 46: IN ULONG Length ! 47: ); ! 48: ! 49: ! 50: // ! 51: // Use the alloc_text pragma to specify the driver initialization routines ! 52: // (they can be paged out). ! 53: // ! 54: ! 55: #ifdef ALLOC_PRAGMA ! 56: #pragma alloc_text(init,AllocateAdapterMemory) ! 57: #pragma alloc_text(init,AllocateFlushBuffer) ! 58: #endif ! 59: ! 60: ! 61: ! 62: STATIC ! 63: PNDIS_BUFFER ! 64: AllocateFlushBuffer( ! 65: IN PSONIC_ADAPTER Adapter, ! 66: IN PVOID VirtualAddress, ! 67: IN ULONG Length ! 68: ) ! 69: ! 70: /*++ ! 71: ! 72: Routine Description: ! 73: ! 74: Allocates an NDIS_BUFFER for the specified address and length. ! 75: This function is intended to create NDIS_BUFFERs for flushing. ! 76: ! 77: Arguments: ! 78: ! 79: Adapter - The adapter the buffer is for. It must have a ! 80: FlushBufferPoolHandle that points to a valid buffer pool. ! 81: ! 82: VirtualAddress - A pointer to the buffer to describe. ! 83: ! 84: Length - The length of the buffer. ! 85: ! 86: Return Value: ! 87: ! 88: The NDIS_BUFFER if one was allocated. ! 89: NULL if an NDIS_BUFFER could not be allocated. ! 90: ! 91: --*/ ! 92: ! 93: { ! 94: PNDIS_BUFFER ReturnBuffer; ! 95: NDIS_STATUS Status; ! 96: ! 97: NdisAllocateBuffer( ! 98: &Status, ! 99: &ReturnBuffer, ! 100: Adapter->FlushBufferPoolHandle, ! 101: VirtualAddress, ! 102: Length ! 103: ); ! 104: ! 105: if (Status != NDIS_STATUS_SUCCESS) { ! 106: ! 107: #if DBG ! 108: DbgPrint("SONIC: Could not allocate flush buffer, %x\n", Status); ! 109: #endif ! 110: ReturnBuffer = (PNDIS_BUFFER)NULL; ! 111: } ! 112: ! 113: ! 114: return ReturnBuffer; ! 115: } ! 116: ! 117: extern ! 118: BOOLEAN ! 119: AllocateAdapterMemory( ! 120: IN PSONIC_ADAPTER Adapter ! 121: ) ! 122: ! 123: /*++ ! 124: ! 125: Routine Description: ! 126: ! 127: This routine allocates memory for: ! 128: ! 129: - Transmit ring entries ! 130: ! 131: - Receive ring entries ! 132: ! 133: - Receive buffers ! 134: ! 135: - Adapter buffers for use if user transmit buffers don't meet hardware ! 136: contraints ! 137: ! 138: - Structures to map transmit ring entries back to the packets. ! 139: ! 140: Arguments: ! 141: ! 142: Adapter - The adapter to allocate memory for. ! 143: ! 144: Return Value: ! 145: ! 146: Returns FALSE if some memory needed for the adapter could not ! 147: be allocated. It does NOT call DeleteAdapterMemory in this ! 148: case. ! 149: ! 150: --*/ ! 151: ! 152: { ! 153: ! 154: // ! 155: // Pointer to a transmit ring entry. Used while initializing ! 156: // the TDA. ! 157: // ! 158: PSONIC_TRANSMIT_DESCRIPTOR CurrentTransmitDescriptor; ! 159: ! 160: // ! 161: // Pointer to a receive buffer. Used while allocated the ! 162: // RBAs. ! 163: // ! 164: PVOID * CurrentReceiveBuffer; ! 165: ! 166: // ! 167: // Pointer to a receive descriptor. Used while initialing ! 168: // the RDA. ! 169: // ! 170: PSONIC_RECEIVE_DESCRIPTOR CurrentReceiveDescriptor; ! 171: ! 172: // ! 173: // Used for determining physical addresses. ! 174: // ! 175: SONIC_PHYSICAL_ADDRESS SonicPhysicalAdr; ! 176: ! 177: // ! 178: // Used for NDIS allocation routines that return an NDIS_PHYSICAL_ADDRESS ! 179: // ! 180: NDIS_PHYSICAL_ADDRESS NdisPhysicalAdr; ! 181: ! 182: // ! 183: // Simple iteration variable. ! 184: // ! 185: UINT i; ! 186: ! 187: // ! 188: // Used to flush buffers that only need to be flushed once. ! 189: // ! 190: PNDIS_BUFFER FlushBuffer; ! 191: ! 192: // ! 193: // The size of the buffer pool needed. ! 194: // ! 195: UINT PoolBuffersNeeded; ! 196: ! 197: // ! 198: // Holds the result of calls to SONIC_ALLOC_MEMORY ! 199: // ! 200: NDIS_STATUS AllocStatus; ! 201: ! 202: ! 203: ! 204: // ! 205: // We need some NDIS_BUFFERs to describe memory that we ! 206: // allocate (generally either to flush the buffer, or ! 207: // because we need its physical address). To do this ! 208: // we need a buffer pool, so we have to determine how ! 209: // many buffers we need. ! 210: // ! 211: PoolBuffersNeeded = ! 212: 1 + // for CamDescriptorArea ! 213: 1 + // for ReceiveResourceArea ! 214: 1 + // for BlankBuffer ! 215: SONIC_NUMBER_OF_SMALL_BUFFERS + ! 216: SONIC_NUMBER_OF_MEDIUM_BUFFERS + ! 217: SONIC_NUMBER_OF_LARGE_BUFFERS; ! 218: ! 219: NdisAllocateBufferPool( ! 220: &AllocStatus, ! 221: &Adapter->FlushBufferPoolHandle, ! 222: PoolBuffersNeeded ! 223: ); ! 224: ! 225: if (AllocStatus != NDIS_STATUS_SUCCESS) { ! 226: ! 227: #if DBG ! 228: DbgPrint("SONIC: Could not allocate flush buffer pool\n"); ! 229: #endif ! 230: return FALSE; ! 231: ! 232: } ! 233: ! 234: ! 235: ! 236: // ! 237: // Allocate the transmit ring descriptors. ! 238: // ! 239: ! 240: NdisAllocateSharedMemory( ! 241: Adapter->NdisAdapterHandle, ! 242: sizeof(SONIC_TRANSMIT_DESCRIPTOR)* ! 243: Adapter->NumberOfTransmitDescriptors, ! 244: FALSE, // non-cached ! 245: (PVOID *)&Adapter->TransmitDescriptorArea, ! 246: &Adapter->TransmitDescriptorAreaPhysical ! 247: ); ! 248: ! 249: if (Adapter->TransmitDescriptorArea == NULL) { ! 250: ! 251: #if DBG ! 252: DbgPrint("SONIC: TransmitDescriptorArea memory invalid\n"); ! 253: #endif ! 254: return FALSE; ! 255: ! 256: } ! 257: ! 258: if (NdisGetPhysicalAddressHigh(Adapter->TransmitDescriptorAreaPhysical) != 0) { ! 259: ! 260: #if DBG ! 261: DbgPrint("SONIC: TransmitDescriptorArea memory too high\n"); ! 262: #endif ! 263: return FALSE; ! 264: } ! 265: ! 266: ! 267: ! 268: // ! 269: // Clean the above memory ! 270: // ! 271: ! 272: SONIC_ZERO_MEMORY( ! 273: Adapter->TransmitDescriptorArea, ! 274: (sizeof(SONIC_TRANSMIT_DESCRIPTOR)*Adapter->NumberOfTransmitDescriptors) ! 275: ); ! 276: ! 277: ! 278: // ! 279: // We have the transmit ring descriptors. Initialize the Link ! 280: // fields. ! 281: // ! 282: ! 283: for ( ! 284: i = 0, CurrentTransmitDescriptor = Adapter->TransmitDescriptorArea; ! 285: i < Adapter->NumberOfTransmitDescriptors; ! 286: i++,CurrentTransmitDescriptor++ ! 287: ) { ! 288: ! 289: SonicPhysicalAdr = NdisGetPhysicalAddressLow(Adapter->TransmitDescriptorAreaPhysical) + ! 290: (i * sizeof(SONIC_TRANSMIT_DESCRIPTOR)); ! 291: ! 292: if (i == 0) { ! 293: ! 294: Adapter->TransmitDescriptorArea[Adapter->NumberOfTransmitDescriptors-1].Link = SonicPhysicalAdr; ! 295: ! 296: } else { ! 297: ! 298: (CurrentTransmitDescriptor-1)->Link = SonicPhysicalAdr; ! 299: ! 300: } ! 301: ! 302: } ! 303: ! 304: ! 305: // ! 306: // Allocate the ring to packet structure. ! 307: // ! 308: ! 309: SONIC_ALLOC_MEMORY( ! 310: &AllocStatus, ! 311: &Adapter->DescriptorToPacket, ! 312: sizeof(SONIC_DESCRIPTOR_TO_PACKET) ! 313: *Adapter->NumberOfTransmitDescriptors ! 314: ); ! 315: ! 316: if (AllocStatus != NDIS_STATUS_SUCCESS) { ! 317: return FALSE; ! 318: } ! 319: ! 320: ! 321: // ! 322: // We have to do this now. The PrevLinkPointer field is used ! 323: // to point to where the Link field of the previous transmit ! 324: // descriptor is; it is normally set when the previous ! 325: // transmit descriptor is filled. For the very first packet ! 326: // transmitted there will have been no previous transmit ! 327: // descriptor, so we fill it in ourselves. We use the ! 328: // Link field of the last transmit descriptor (the actual ! 329: // location used doesn't really matter, as long as it is ! 330: // a valid address). ! 331: // ! 332: ! 333: Adapter->DescriptorToPacket->PrevLinkPointer = ! 334: &(Adapter->TransmitDescriptorArea[ ! 335: Adapter->NumberOfTransmitDescriptors-1].Link); ! 336: ! 337: ! 338: // ! 339: // Allocate the receive resource area and the ! 340: // CAM descriptor area. These are allocated together ! 341: // since they must have the same high 16 bits in ! 342: // their addresses. ! 343: // ! 344: ! 345: NdisAllocateSharedMemory( ! 346: Adapter->NdisAdapterHandle, ! 347: (sizeof(SONIC_RECEIVE_RESOURCE)*Adapter->NumberOfReceiveBuffers) + ! 348: sizeof(SONIC_CAM_DESCRIPTOR_AREA), ! 349: TRUE, // cached ! 350: (PVOID *)&Adapter->ReceiveResourceArea, ! 351: &Adapter->ReceiveResourceAreaPhysical ! 352: ); ! 353: ! 354: ! 355: if (Adapter->ReceiveResourceArea == NULL) { ! 356: ! 357: #if DBG ! 358: DbgPrint("SONIC: ReceiveResourceArea memory invalid\n"); ! 359: #endif ! 360: return FALSE; ! 361: ! 362: } ! 363: ! 364: if (NdisGetPhysicalAddressHigh(Adapter->ReceiveResourceAreaPhysical) != 0) { ! 365: ! 366: #if DBG ! 367: DbgPrint("SONIC: ReceiveResourceArea memory too high\n"); ! 368: #endif ! 369: return FALSE; ! 370: ! 371: } ! 372: ! 373: ! 374: // ! 375: // The CAM Descriptor Area is immediately after the RRA. ! 376: // ! 377: ! 378: Adapter->CamDescriptorArea = (PSONIC_CAM_DESCRIPTOR_AREA) ! 379: (Adapter->ReceiveResourceArea + Adapter->NumberOfReceiveBuffers); ! 380: ! 381: Adapter->CamDescriptorAreaPhysical = ! 382: NdisGetPhysicalAddressLow(Adapter->ReceiveResourceAreaPhysical) + ! 383: ((PUCHAR)Adapter->CamDescriptorArea - ! 384: (PUCHAR)Adapter->ReceiveResourceArea); ! 385: ! 386: ! 387: // ! 388: // Allocate the NDIS_BUFFER to flush the CAM Descriptor Area. ! 389: // ! 390: Adapter->CamDescriptorAreaFlushBuffer = AllocateFlushBuffer( ! 391: Adapter, ! 392: Adapter->CamDescriptorArea, ! 393: sizeof(SONIC_CAM_DESCRIPTOR_AREA) ! 394: ); ! 395: ! 396: if (!Adapter->CamDescriptorAreaFlushBuffer) { ! 397: return FALSE; ! 398: } ! 399: ! 400: SONIC_ZERO_MEMORY( ! 401: Adapter->CamDescriptorArea, ! 402: sizeof(SONIC_CAM_DESCRIPTOR_AREA) ! 403: ); ! 404: ! 405: SONIC_FLUSH_WRITE_BUFFER(Adapter->CamDescriptorAreaFlushBuffer); ! 406: ! 407: ! 408: #if DBG ! 409: if (SonicDbg) { ! 410: DbgPrint("SONIC: Cam Descriptor Area: %lx physical: %lx\n", ! 411: Adapter->CamDescriptorArea, ! 412: Adapter->CamDescriptorAreaPhysical); ! 413: } ! 414: #endif ! 415: ! 416: // ! 417: // Allocate the array to hold pointers to the RBAs. ! 418: // ! 419: ! 420: SONIC_ALLOC_MEMORY( ! 421: &AllocStatus, ! 422: &Adapter->ReceiveBufferArea, ! 423: sizeof(PVOID) * Adapter->NumberOfReceiveBuffers ! 424: ); ! 425: ! 426: if (AllocStatus != NDIS_STATUS_SUCCESS) { ! 427: return FALSE; ! 428: } ! 429: ! 430: #if DBG ! 431: if (SonicDbg) { ! 432: DbgPrint("SONIC: Receive Buffer Area: %lx\n", ! 433: (ULONG)Adapter->ReceiveBufferArea); ! 434: } ! 435: #endif ! 436: ! 437: ! 438: // ! 439: // We have the receive buffer pointers. Allocate the buffer ! 440: // for each entry and zero them. ! 441: // ! 442: // For each receive buffer, the Physical address and length ! 443: // will be in Adapter->ReceiveResourceArea[i], while the ! 444: // virtual address will be in Adapter->ReceiveBufferArea[i]. ! 445: // ! 446: ! 447: for ( ! 448: i = 0, CurrentReceiveBuffer = Adapter->ReceiveBufferArea; ! 449: i < Adapter->NumberOfReceiveBuffers; ! 450: i++,CurrentReceiveBuffer++ ! 451: ) { ! 452: ! 453: NdisAllocateSharedMemory( ! 454: Adapter->NdisAdapterHandle, ! 455: SONIC_SIZE_OF_RECEIVE_BUFFERS, ! 456: FALSE, // non-cached ! 457: CurrentReceiveBuffer, ! 458: &NdisPhysicalAdr ! 459: ); ! 460: ! 461: ! 462: if (*CurrentReceiveBuffer == NULL) { ! 463: return FALSE; ! 464: } ! 465: ! 466: if (NdisGetPhysicalAddressHigh(NdisPhysicalAdr) != 0) { ! 467: return FALSE; ! 468: } ! 469: ! 470: ! 471: SONIC_ZERO_MEMORY( ! 472: *CurrentReceiveBuffer, ! 473: SONIC_SIZE_OF_RECEIVE_BUFFERS ! 474: ); ! 475: ! 476: SONIC_SET_RECEIVE_RESOURCE_ADDRESS( ! 477: &Adapter->ReceiveResourceArea[i], ! 478: NdisGetPhysicalAddressLow(NdisPhysicalAdr) ! 479: ); ! 480: ! 481: SONIC_SET_RECEIVE_RESOURCE_LENGTH( ! 482: &Adapter->ReceiveResourceArea[i], ! 483: SONIC_SIZE_OF_RECEIVE_BUFFERS ! 484: ); ! 485: ! 486: ! 487: } ! 488: ! 489: // ! 490: // The Receive Resource Area is set up, we can flush ! 491: // it now since it does not change. ! 492: // ! 493: ! 494: FlushBuffer = AllocateFlushBuffer( ! 495: Adapter, ! 496: (PVOID)Adapter->ReceiveResourceArea, ! 497: (sizeof(SONIC_RECEIVE_RESOURCE)*Adapter->NumberOfReceiveBuffers) ! 498: ); ! 499: ! 500: if (!FlushBuffer) { ! 501: return FALSE; ! 502: } ! 503: ! 504: SONIC_FLUSH_WRITE_BUFFER(FlushBuffer); ! 505: ! 506: NdisFreeBuffer(FlushBuffer); ! 507: ! 508: // ! 509: // Allocate memory to hold the receive descriptor pointers. ! 510: // ! 511: ! 512: NdisAllocateSharedMemory( ! 513: Adapter->NdisAdapterHandle, ! 514: sizeof(SONIC_RECEIVE_DESCRIPTOR) * ! 515: Adapter->NumberOfReceiveDescriptors, ! 516: FALSE, // non-cached ! 517: (PVOID *)&Adapter->ReceiveDescriptorArea, ! 518: &Adapter->ReceiveDescriptorAreaPhysical ! 519: ); ! 520: ! 521: ! 522: if (Adapter->ReceiveDescriptorArea == NULL) { ! 523: ! 524: #if DBG ! 525: DbgPrint("SONIC: ReceiveDescriptorArea memory invalid\n"); ! 526: #endif ! 527: return FALSE; ! 528: ! 529: } ! 530: ! 531: if (NdisGetPhysicalAddressHigh(Adapter->ReceiveDescriptorAreaPhysical) != 0) { ! 532: ! 533: #if DBG ! 534: DbgPrint("SONIC: ReceiveDescriptorArea memory too high\n"); ! 535: #endif ! 536: return FALSE; ! 537: ! 538: } ! 539: ! 540: ! 541: ! 542: // ! 543: // Clean the above memory ! 544: // ! 545: ! 546: SONIC_ZERO_MEMORY( ! 547: Adapter->ReceiveDescriptorArea, ! 548: (sizeof(SONIC_RECEIVE_DESCRIPTOR)*Adapter->NumberOfReceiveDescriptors) ! 549: ); ! 550: ! 551: ! 552: // ! 553: // Now set up the Link fields in the receive descriptors. ! 554: // ! 555: ! 556: for ( ! 557: i = 0, CurrentReceiveDescriptor = Adapter->ReceiveDescriptorArea; ! 558: i < Adapter->NumberOfReceiveDescriptors; ! 559: i++,CurrentReceiveDescriptor++ ! 560: ) { ! 561: ! 562: // ! 563: // belongs to SONIC. ! 564: // ! 565: ! 566: CurrentReceiveDescriptor->InUse = SONIC_OWNED_BY_SONIC; ! 567: ! 568: SonicPhysicalAdr = NdisGetPhysicalAddressLow(Adapter->ReceiveDescriptorAreaPhysical) + ! 569: (i * sizeof(SONIC_RECEIVE_DESCRIPTOR)); ! 570: ! 571: if (i == 0) { ! 572: ! 573: Adapter->ReceiveDescriptorArea[ ! 574: Adapter->NumberOfReceiveDescriptors-1].Link = ! 575: SonicPhysicalAdr | SONIC_END_OF_LIST; ! 576: ! 577: } else { ! 578: ! 579: Adapter->ReceiveDescriptorArea[i-1].Link = SonicPhysicalAdr; ! 580: ! 581: } ! 582: ! 583: } ! 584: ! 585: ! 586: // ! 587: // Allocate the array of buffer descriptors. ! 588: // ! 589: ! 590: SONIC_ALLOC_MEMORY( ! 591: &AllocStatus, ! 592: &Adapter->SonicBuffers, ! 593: sizeof(SONIC_BUFFER_DESCRIPTOR)* ! 594: (SONIC_NUMBER_OF_SMALL_BUFFERS + ! 595: SONIC_NUMBER_OF_MEDIUM_BUFFERS + ! 596: SONIC_NUMBER_OF_LARGE_BUFFERS) ! 597: ); ! 598: ! 599: if (AllocStatus != NDIS_STATUS_SUCCESS) { ! 600: return FALSE; ! 601: } ! 602: ! 603: // ! 604: // Zero the memory of all the descriptors so that we can ! 605: // know which buffers wern't allocated incase we can't allocate ! 606: // them all. ! 607: // ! 608: SONIC_ZERO_MEMORY( ! 609: Adapter->SonicBuffers, ! 610: sizeof(SONIC_BUFFER_DESCRIPTOR)* ! 611: (SONIC_NUMBER_OF_SMALL_BUFFERS + ! 612: SONIC_NUMBER_OF_MEDIUM_BUFFERS + ! 613: SONIC_NUMBER_OF_LARGE_BUFFERS) ! 614: ); ! 615: ! 616: ! 617: // ! 618: // Allocate space for the small sonic buffers and fill in the ! 619: // buffer descriptors. ! 620: // ! 621: ! 622: Adapter->SonicBufferListHeads[0] = -1; ! 623: Adapter->SonicBufferListHeads[1] = 0; ! 624: ! 625: NdisAllocateSharedMemory( ! 626: Adapter->NdisAdapterHandle, ! 627: SONIC_SMALL_BUFFER_SIZE * SONIC_NUMBER_OF_SMALL_BUFFERS, ! 628: TRUE, // cached ! 629: &Adapter->SmallSonicBuffers, ! 630: &NdisPhysicalAdr ! 631: ); ! 632: ! 633: if (NdisGetPhysicalAddressHigh(NdisPhysicalAdr) != 0) { ! 634: return FALSE; ! 635: } ! 636: ! 637: ! 638: if (Adapter->SmallSonicBuffers == NULL) { ! 639: return FALSE; ! 640: } ! 641: ! 642: for ( ! 643: i = 0; ! 644: i < SONIC_NUMBER_OF_SMALL_BUFFERS; ! 645: i++ ! 646: ) { ! 647: ! 648: Adapter->SonicBuffers[i].VirtualSonicBuffer = (PVOID) ! 649: ((PUCHAR)Adapter->SmallSonicBuffers + ! 650: (i * SONIC_SMALL_BUFFER_SIZE)); ! 651: ! 652: NdisSetPhysicalAddressHigh( ! 653: Adapter->SonicBuffers[i].PhysicalSonicBuffer, ! 654: 0); ! 655: ! 656: NdisSetPhysicalAddressLow( ! 657: Adapter->SonicBuffers[i].PhysicalSonicBuffer, ! 658: NdisGetPhysicalAddressLow(NdisPhysicalAdr) + ! 659: (i * SONIC_SMALL_BUFFER_SIZE)); ! 660: ! 661: Adapter->SonicBuffers[i].FlushBuffer = ! 662: AllocateFlushBuffer( ! 663: Adapter, ! 664: Adapter->SonicBuffers[i].VirtualSonicBuffer, ! 665: SONIC_SMALL_BUFFER_SIZE ! 666: ); ! 667: ! 668: if (!Adapter->SonicBuffers[i].FlushBuffer) { ! 669: return FALSE; ! 670: } ! 671: ! 672: Adapter->SonicBuffers[i].Next = i+1; ! 673: ! 674: } ! 675: ! 676: // ! 677: // Make sure that the last buffer correctly terminates the free list. ! 678: // ! 679: ! 680: Adapter->SonicBuffers[i-1].Next = -1; ! 681: ! 682: // ! 683: // Do the medium buffers now. ! 684: // ! 685: ! 686: Adapter->SonicBufferListHeads[2] = i; ! 687: ! 688: NdisAllocateSharedMemory( ! 689: Adapter->NdisAdapterHandle, ! 690: SONIC_MEDIUM_BUFFER_SIZE * SONIC_NUMBER_OF_MEDIUM_BUFFERS, ! 691: TRUE, // cached ! 692: &Adapter->MediumSonicBuffers, ! 693: &NdisPhysicalAdr ! 694: ); ! 695: ! 696: ! 697: if (Adapter->MediumSonicBuffers == NULL) { ! 698: return FALSE; ! 699: } ! 700: ! 701: if (NdisGetPhysicalAddressHigh(NdisPhysicalAdr) != 0) { ! 702: return FALSE; ! 703: } ! 704: ! 705: ! 706: ! 707: for ( ! 708: ; ! 709: i < SONIC_NUMBER_OF_SMALL_BUFFERS + SONIC_NUMBER_OF_MEDIUM_BUFFERS; ! 710: i++ ! 711: ) { ! 712: ! 713: Adapter->SonicBuffers[i].VirtualSonicBuffer = (PVOID) ! 714: ((PUCHAR)Adapter->MediumSonicBuffers + ! 715: ((i - SONIC_NUMBER_OF_SMALL_BUFFERS) * SONIC_MEDIUM_BUFFER_SIZE)); ! 716: ! 717: NdisSetPhysicalAddressHigh( ! 718: Adapter->SonicBuffers[i].PhysicalSonicBuffer, ! 719: 0); ! 720: ! 721: NdisSetPhysicalAddressLow( ! 722: Adapter->SonicBuffers[i].PhysicalSonicBuffer, ! 723: NdisGetPhysicalAddressLow(NdisPhysicalAdr) + ! 724: ((i - SONIC_NUMBER_OF_SMALL_BUFFERS) * SONIC_MEDIUM_BUFFER_SIZE)); ! 725: ! 726: ! 727: Adapter->SonicBuffers[i].FlushBuffer = ! 728: AllocateFlushBuffer( ! 729: Adapter, ! 730: Adapter->SonicBuffers[i].VirtualSonicBuffer, ! 731: SONIC_MEDIUM_BUFFER_SIZE ! 732: ); ! 733: ! 734: if (!Adapter->SonicBuffers[i].FlushBuffer) { ! 735: return FALSE; ! 736: } ! 737: ! 738: ! 739: Adapter->SonicBuffers[i].Next = i+1; ! 740: ! 741: } ! 742: ! 743: // ! 744: // Make sure that the last buffer correctly terminates the free list. ! 745: // ! 746: ! 747: Adapter->SonicBuffers[i-1].Next = -1; ! 748: ! 749: // ! 750: // Now do the large buffers; note that they have one ! 751: // Physical address per buffer. ! 752: // ! 753: ! 754: Adapter->SonicBufferListHeads[3] = i; ! 755: ! 756: for ( ! 757: ; ! 758: i < SONIC_NUMBER_OF_SMALL_BUFFERS + ! 759: SONIC_NUMBER_OF_MEDIUM_BUFFERS + ! 760: SONIC_NUMBER_OF_LARGE_BUFFERS; ! 761: i++ ! 762: ) { ! 763: ! 764: ! 765: NdisAllocateSharedMemory( ! 766: Adapter->NdisAdapterHandle, ! 767: SONIC_LARGE_BUFFER_SIZE, ! 768: TRUE, // cached ! 769: (PVOID *)&Adapter->SonicBuffers[i].VirtualSonicBuffer, ! 770: &Adapter->SonicBuffers[i].PhysicalSonicBuffer ! 771: ); ! 772: ! 773: ! 774: if (Adapter->SonicBuffers[i].VirtualSonicBuffer == NULL) { ! 775: return FALSE; ! 776: } ! 777: ! 778: if (NdisGetPhysicalAddressHigh(Adapter->SonicBuffers[i].PhysicalSonicBuffer) != 0) { ! 779: return FALSE; ! 780: } ! 781: ! 782: ! 783: Adapter->SonicBuffers[i].FlushBuffer = ! 784: AllocateFlushBuffer( ! 785: Adapter, ! 786: Adapter->SonicBuffers[i].VirtualSonicBuffer, ! 787: SONIC_LARGE_BUFFER_SIZE ! 788: ); ! 789: ! 790: if (!Adapter->SonicBuffers[i].FlushBuffer) { ! 791: return FALSE; ! 792: } ! 793: ! 794: ! 795: Adapter->SonicBuffers[i].Next = i+1; ! 796: ! 797: } ! 798: ! 799: // ! 800: // Make sure that the last buffer correctly terminates the free list. ! 801: // ! 802: ! 803: Adapter->SonicBuffers[i-1].Next = -1; ! 804: ! 805: ! 806: // ! 807: // Allocate the BlankBuffer ! 808: // ! 809: ! 810: NdisAllocateSharedMemory( ! 811: Adapter->NdisAdapterHandle, ! 812: SONIC_SMALL_BUFFER_SIZE, ! 813: TRUE, // cached ! 814: (PVOID *)&Adapter->BlankBuffer, ! 815: &Adapter->BlankBufferAddress ! 816: ); ! 817: ! 818: ! 819: if (Adapter->BlankBuffer == NULL) { ! 820: return FALSE; ! 821: } ! 822: ! 823: if (NdisGetPhysicalAddressHigh(Adapter->BlankBufferAddress) != 0) { ! 824: return FALSE; ! 825: } ! 826: ! 827: for (i=0; i < SONIC_SMALL_BUFFER_SIZE; i++) { ! 828: ! 829: Adapter->BlankBuffer[i] = ' '; ! 830: ! 831: } ! 832: ! 833: ! 834: // ! 835: // Flush the blank buffer now, it never changes. ! 836: // ! 837: ! 838: FlushBuffer = AllocateFlushBuffer( ! 839: Adapter, ! 840: Adapter->BlankBuffer, ! 841: SONIC_SMALL_BUFFER_SIZE ! 842: ); ! 843: ! 844: if (!FlushBuffer) { ! 845: return FALSE; ! 846: } ! 847: ! 848: SONIC_FLUSH_WRITE_BUFFER(FlushBuffer); ! 849: ! 850: // ! 851: // We are done with the FlushBuffer. ! 852: // ! 853: ! 854: NdisFreeBuffer(FlushBuffer); ! 855: ! 856: ! 857: return TRUE; ! 858: ! 859: } ! 860: ! 861: extern ! 862: VOID ! 863: DeleteAdapterMemory( ! 864: IN PSONIC_ADAPTER Adapter ! 865: ) ! 866: ! 867: /*++ ! 868: ! 869: Routine Description: ! 870: ! 871: This routine deallocates memory for: ! 872: ! 873: - Transmit ring entries ! 874: ! 875: - Receive ring entries ! 876: ! 877: - Receive buffers ! 878: ! 879: - Adapter buffers for use if user transmit buffers don't meet hardware ! 880: contraints ! 881: ! 882: - Structures to map transmit ring entries back to the packets. ! 883: ! 884: Arguments: ! 885: ! 886: Adapter - The adapter to deallocate memory for. ! 887: ! 888: Return Value: ! 889: ! 890: None. ! 891: ! 892: --*/ ! 893: ! 894: { ! 895: ! 896: if (Adapter->FlushBufferPoolHandle) { ! 897: ! 898: NdisFreeBufferPool(Adapter->FlushBufferPoolHandle); ! 899: ! 900: } ! 901: ! 902: if (Adapter->TransmitDescriptorArea) { ! 903: ! 904: NdisFreeSharedMemory( ! 905: Adapter->NdisAdapterHandle, ! 906: sizeof(SONIC_TRANSMIT_DESCRIPTOR)* ! 907: Adapter->NumberOfTransmitDescriptors, ! 908: FALSE, ! 909: Adapter->TransmitDescriptorArea, ! 910: Adapter->TransmitDescriptorAreaPhysical ! 911: ); ! 912: ! 913: } ! 914: ! 915: if (Adapter->CamDescriptorAreaFlushBuffer) { ! 916: ! 917: NdisFreeBuffer(Adapter->CamDescriptorAreaFlushBuffer); ! 918: ! 919: } ! 920: ! 921: if (Adapter->ReceiveBufferArea) { ! 922: ! 923: UINT i; ! 924: NDIS_PHYSICAL_ADDRESS PhysicalAddr; ! 925: ! 926: for ( ! 927: i = 0; ! 928: i < Adapter->NumberOfReceiveBuffers; ! 929: i++ ! 930: ) { ! 931: ! 932: if (Adapter->ReceiveBufferArea[i]) { ! 933: ! 934: NdisSetPhysicalAddressHigh(PhysicalAddr, 0); ! 935: NdisSetPhysicalAddressLow( ! 936: PhysicalAddr, ! 937: SONIC_GET_RECEIVE_RESOURCE_ADDRESS(&Adapter->ReceiveResourceArea[i])); ! 938: ! 939: NdisFreeSharedMemory( ! 940: Adapter->NdisAdapterHandle, ! 941: SONIC_SIZE_OF_RECEIVE_BUFFERS, ! 942: FALSE, ! 943: Adapter->ReceiveBufferArea[i], ! 944: PhysicalAddr ! 945: ); ! 946: ! 947: } else { ! 948: ! 949: break; ! 950: ! 951: } ! 952: ! 953: } ! 954: ! 955: SONIC_FREE_MEMORY(Adapter->ReceiveBufferArea, ! 956: sizeof(PVOID) * Adapter->NumberOfReceiveBuffers); ! 957: ! 958: } ! 959: ! 960: if (Adapter->ReceiveResourceArea) { ! 961: ! 962: NdisFreeSharedMemory( ! 963: Adapter->NdisAdapterHandle, ! 964: (sizeof(SONIC_RECEIVE_RESOURCE)*Adapter->NumberOfReceiveBuffers) + ! 965: sizeof(SONIC_CAM_DESCRIPTOR_AREA), ! 966: TRUE, ! 967: Adapter->ReceiveResourceArea, ! 968: Adapter->ReceiveResourceAreaPhysical ! 969: ); ! 970: ! 971: } ! 972: ! 973: if (Adapter->ReceiveDescriptorArea) { ! 974: ! 975: NdisFreeSharedMemory( ! 976: Adapter->NdisAdapterHandle, ! 977: sizeof(SONIC_RECEIVE_DESCRIPTOR) * ! 978: Adapter->NumberOfReceiveDescriptors, ! 979: FALSE, ! 980: Adapter->ReceiveDescriptorArea, ! 981: Adapter->ReceiveDescriptorAreaPhysical ! 982: ); ! 983: ! 984: } ! 985: ! 986: if (Adapter->DescriptorToPacket) { ! 987: ! 988: SONIC_FREE_MEMORY(Adapter->DescriptorToPacket, ! 989: sizeof(SONIC_DESCRIPTOR_TO_PACKET) ! 990: *Adapter->NumberOfTransmitDescriptors); ! 991: ! 992: } ! 993: ! 994: ! 995: if (Adapter->SmallSonicBuffers) { ! 996: ! 997: NdisFreeSharedMemory( ! 998: Adapter->NdisAdapterHandle, ! 999: SONIC_SMALL_BUFFER_SIZE * SONIC_NUMBER_OF_SMALL_BUFFERS, ! 1000: TRUE, ! 1001: Adapter->SmallSonicBuffers, ! 1002: Adapter->SonicBuffers[0].PhysicalSonicBuffer ! 1003: ); ! 1004: ! 1005: } ! 1006: ! 1007: if (Adapter->MediumSonicBuffers) { ! 1008: ! 1009: NdisFreeSharedMemory( ! 1010: Adapter->NdisAdapterHandle, ! 1011: SONIC_MEDIUM_BUFFER_SIZE * SONIC_NUMBER_OF_MEDIUM_BUFFERS, ! 1012: TRUE, ! 1013: Adapter->MediumSonicBuffers, ! 1014: Adapter->SonicBuffers[SONIC_NUMBER_OF_SMALL_BUFFERS].PhysicalSonicBuffer ! 1015: ); ! 1016: ! 1017: } ! 1018: ! 1019: if (Adapter->SonicBuffers) { ! 1020: ! 1021: UINT i; ! 1022: ! 1023: // ! 1024: // First free the large buffers. ! 1025: // ! 1026: ! 1027: for ( ! 1028: i = SONIC_NUMBER_OF_SMALL_BUFFERS + ! 1029: SONIC_NUMBER_OF_MEDIUM_BUFFERS; ! 1030: i < SONIC_NUMBER_OF_SMALL_BUFFERS + ! 1031: SONIC_NUMBER_OF_MEDIUM_BUFFERS + ! 1032: SONIC_NUMBER_OF_LARGE_BUFFERS; ! 1033: i++) { ! 1034: ! 1035: if (Adapter->SonicBuffers[i].VirtualSonicBuffer) { ! 1036: ! 1037: NdisFreeSharedMemory( ! 1038: Adapter->NdisAdapterHandle, ! 1039: SONIC_LARGE_BUFFER_SIZE, ! 1040: TRUE, ! 1041: Adapter->SonicBuffers[i].VirtualSonicBuffer, ! 1042: Adapter->SonicBuffers[i].PhysicalSonicBuffer ! 1043: ); ! 1044: ! 1045: } else { ! 1046: ! 1047: break; ! 1048: ! 1049: } ! 1050: ! 1051: } ! 1052: ! 1053: // ! 1054: // Now free the flush buffers. ! 1055: // ! 1056: ! 1057: for ( ! 1058: i = 0; ! 1059: i < SONIC_NUMBER_OF_SMALL_BUFFERS + ! 1060: SONIC_NUMBER_OF_MEDIUM_BUFFERS + ! 1061: SONIC_NUMBER_OF_LARGE_BUFFERS; ! 1062: i++) { ! 1063: ! 1064: if (Adapter->SonicBuffers[i].FlushBuffer) { ! 1065: NdisFreeBuffer(Adapter->SonicBuffers[i].FlushBuffer); ! 1066: } ! 1067: ! 1068: } ! 1069: ! 1070: SONIC_FREE_MEMORY(Adapter->SonicBuffers, ! 1071: sizeof(SONIC_BUFFER_DESCRIPTOR)* ! 1072: (SONIC_NUMBER_OF_SMALL_BUFFERS + ! 1073: SONIC_NUMBER_OF_MEDIUM_BUFFERS + ! 1074: SONIC_NUMBER_OF_LARGE_BUFFERS) ! 1075: ); ! 1076: ! 1077: } ! 1078: ! 1079: ! 1080: if (Adapter->BlankBuffer) { ! 1081: ! 1082: NdisFreeSharedMemory( ! 1083: Adapter->NdisAdapterHandle, ! 1084: SONIC_SMALL_BUFFER_SIZE, ! 1085: TRUE, ! 1086: Adapter->BlankBuffer, ! 1087: Adapter->BlankBufferAddress ! 1088: ); ! 1089: ! 1090: } ! 1091: ! 1092: ! 1093: if (Adapter->FlushBufferPoolHandle) { ! 1094: ! 1095: NdisFreeBufferPool(Adapter->FlushBufferPoolHandle); ! 1096: ! 1097: } ! 1098: ! 1099: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.