![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to deteisa.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [WindowsNT SDKs] / q_a / samples / ddk / detect|
Return to deteisa.c CVS log | Up to [WindowsNT SDKs] / q_a / samples / ddk / detect |
1.1 ! root 1: /*++ ! 2: ! 3: Copyright (c) 1992 Microsoft Corporation ! 4: ! 5: Module Name: ! 6: ! 7: deteisa.c ! 8: ! 9: Abstract: ! 10: ! 11: This is the main file for the autodetection DLL for all the EISA adapters ! 12: which MS is shipping with Windows NT. ! 13: ! 14: ! 15: --*/ ! 16: ! 17: #include <ntddk.h> ! 18: #include <ntddnetd.h> ! 19: ! 20: #include <windef.h> ! 21: #include <winerror.h> ! 22: ! 23: #include <stdio.h> ! 24: #include <stdlib.h> ! 25: #include <string.h> ! 26: #include "detect.h" ! 27: ! 28: ! 29: // Prototype "borrowed" from WINUSER.H ! 30: extern int WINAPIV wsprintfW(LPWSTR, LPCWSTR, ...); ! 31: // Prototype "borrowed" from WINBASE.H ! 32: VOID WINAPI Sleep( DWORD dwMilliseconds ); ! 33: ! 34: // ! 35: // Individual card detection routines ! 36: // ! 37: ! 38: ! 39: // ! 40: // Helper functions ! 41: // ! 42: ! 43: ULONG ! 44: FindEisaCard( ! 45: IN ULONG AdapterNumber, ! 46: IN ULONG BusNumber, ! 47: IN BOOLEAN First, ! 48: IN ULONG CompressedId, ! 49: OUT PULONG Confidence ! 50: ); ! 51: ! 52: #ifdef WORKAROUND ! 53: ! 54: UCHAR EisaFirstTime = 1; ! 55: ! 56: // ! 57: // List of all the adapters supported in this file, this cannot be > 256 ! 58: // because of the way tokens are generated. ! 59: // ! 60: // ! 61: // NOTE : If you change the index of an adapter, be sure the change it in ! 62: // EisaQueryCfgHandler(), EisaFirstNextHandler() and EisaVerifyCfgHandler() as ! 63: // well! ! 64: // ! 65: ! 66: static ADAPTER_INFO Adapters[] = { ! 67: ! 68: { ! 69: 1000, ! 70: L"NE3200", ! 71: L"SLOTNUMBER 1 100 ", ! 72: NULL, ! 73: 999 ! 74: ! 75: }, ! 76: ! 77: { ! 78: 1100, ! 79: L"DEC422", ! 80: L"SLOTNUMBER 1 100 ", ! 81: NULL, ! 82: 999 ! 83: ! 84: }, ! 85: ! 86: { ! 87: 1200, ! 88: L"P1990", ! 89: L"SLOTNUMBER 1 100 ", ! 90: NULL, ! 91: 999 ! 92: ! 93: }, ! 94: ! 95: { ! 96: 1300, ! 97: L"NETFLX", ! 98: L"SLOTNUMBER 1 100 ", ! 99: NULL, ! 100: 999 ! 101: ! 102: }, ! 103: ! 104: { ! 105: 1400, ! 106: L"CPQTOK", ! 107: L"SLOTNUMBER 1 100 ", ! 108: NULL, ! 109: 999 ! 110: ! 111: } ! 112: }; ! 113: ! 114: #else ! 115: ! 116: // ! 117: // List of all the adapters supported in this file, this cannot be > 256 ! 118: // because of the way tokens are generated. ! 119: // ! 120: // ! 121: // NOTE : If you change the index of an adapter, be sure the change it in ! 122: // EisaQueryCfgHandler(), EisaFirstNextHandler() and EisaVerifyCfgHandler() as ! 123: // well! ! 124: // ! 125: ! 126: static ADAPTER_INFO Adapters[] = { ! 127: ! 128: { ! 129: 1000, ! 130: L"NE3200", ! 131: L"SLOTNUMBER\0001\000100\0", ! 132: NULL, ! 133: 999 ! 134: ! 135: }, ! 136: ! 137: { ! 138: 1100, ! 139: L"DEC422", ! 140: L"SLOTNUMBER\0001\000100\0", ! 141: NULL, ! 142: 999 ! 143: ! 144: }, ! 145: ! 146: { ! 147: 1200, ! 148: L"P1990", ! 149: L"SLOTNUMBER\0001\000100\0", ! 150: NULL, ! 151: 999 ! 152: ! 153: }, ! 154: ! 155: { ! 156: 1300, ! 157: L"NETFLEX", ! 158: L"SLOTNUMBER\0001\000100\0", ! 159: NULL, ! 160: 999 ! 161: ! 162: }, ! 163: ! 164: { ! 165: 1400, ! 166: L"CPQTOK", ! 167: L"SLOTNUMBER\0001\000100\0", ! 168: NULL, ! 169: 999 ! 170: ! 171: } ! 172: ! 173: }; ! 174: ! 175: #endif ! 176: ! 177: // ! 178: // Structure for holding state of a search ! 179: // ! 180: ! 181: typedef struct _SEARCH_STATE { ! 182: ! 183: ULONG SlotNumber; ! 184: ! 185: } SEARCH_STATE, *PSEARCH_STATE; ! 186: ! 187: ! 188: // ! 189: // This is an array of search states. We need one state for each type ! 190: // of adapter supported. ! 191: // ! 192: ! 193: static SEARCH_STATE SearchStates[sizeof(Adapters) / sizeof(ADAPTER_INFO)] = {0}; ! 194: ! 195: ! 196: // ! 197: // Structure for holding a particular adapter's complete information ! 198: // ! 199: typedef struct _EISA_ADAPTER { ! 200: ! 201: LONG CardType; ! 202: INTERFACE_TYPE InterfaceType; ! 203: ULONG BusNumber; ! 204: ULONG SlotNumber; ! 205: ! 206: } EISA_ADAPTER, *PEISA_ADAPTER; ! 207: ! 208: ! 209: extern ! 210: LONG ! 211: EisaIdentifyHandler( ! 212: IN LONG Index, ! 213: IN WCHAR * Buffer, ! 214: IN LONG BuffSize ! 215: ) ! 216: ! 217: /*++ ! 218: ! 219: Routine Description: ! 220: ! 221: This routine returns information about the netcards supported by ! 222: this file. ! 223: ! 224: Arguments: ! 225: ! 226: Index - The index of the netcard being address. The first ! 227: cards information is at index 1000, the second at 1100, etc. ! 228: ! 229: Buffer - Buffer to store the result into. ! 230: ! 231: BuffSize - Number of bytes in Buffer ! 232: ! 233: Return Value: ! 234: ! 235: 0 if nothing went wrong, else the appropriate WINERROR.H value. ! 236: ! 237: --*/ ! 238: ! 239: ! 240: { ! 241: LONG NumberOfAdapters; ! 242: LONG Code = Index % 100; ! 243: LONG Length; ! 244: LONG i; ! 245: ! 246: NumberOfAdapters = sizeof(Adapters) / sizeof(ADAPTER_INFO); ! 247: ! 248: #ifdef WORKAROUND ! 249: ! 250: // ! 251: // We need to convert unicode spaces into unicode NULLs. ! 252: // ! 253: ! 254: if (EisaFirstTime) { ! 255: ! 256: EisaFirstTime = 0; ! 257: ! 258: for (i = 0; i < NumberOfAdapters; i++) { ! 259: ! 260: Length = UnicodeStrLen(Adapters[i].Parameters); ! 261: ! 262: for (; Length > 0; Length--) { ! 263: ! 264: if (Adapters[i].Parameters[Length] == L' ') { ! 265: ! 266: Adapters[i].Parameters[Length] = UNICODE_NULL; ! 267: ! 268: } ! 269: ! 270: } ! 271: ! 272: } ! 273: ! 274: } ! 275: ! 276: #endif ! 277: ! 278: Index = Index - Code; ! 279: ! 280: if (((Index / 100) - 10) < NumberOfAdapters) { ! 281: ! 282: // ! 283: // Find the correct adapter ID ! 284: // ! 285: ! 286: for (i=0; i < NumberOfAdapters; i++) { ! 287: ! 288: if (Adapters[i].Index == Index) { ! 289: ! 290: switch (Code) { ! 291: ! 292: case 0: ! 293: ! 294: // ! 295: // Find the string length ! 296: // ! 297: ! 298: Length = UnicodeStrLen(Adapters[i].InfId); ! 299: ! 300: Length ++; ! 301: ! 302: if (BuffSize < Length) { ! 303: ! 304: return(ERROR_INSUFFICIENT_BUFFER); ! 305: ! 306: } ! 307: ! 308: memcpy((PVOID)Buffer, Adapters[i].InfId, Length * sizeof(WCHAR)); ! 309: break; ! 310: ! 311: case 3: ! 312: ! 313: // ! 314: // Maximum value is 1000 ! 315: // ! 316: ! 317: if (BuffSize < 5) { ! 318: ! 319: return(ERROR_INSUFFICIENT_BUFFER); ! 320: ! 321: } ! 322: ! 323: wsprintfW((PVOID)Buffer, L"%d", Adapters[i].SearchOrder); ! 324: ! 325: break; ! 326: ! 327: default: ! 328: ! 329: return(ERROR_INVALID_PARAMETER); ! 330: ! 331: } ! 332: ! 333: return(0); ! 334: ! 335: } ! 336: ! 337: } ! 338: ! 339: return(ERROR_INVALID_PARAMETER); ! 340: ! 341: } ! 342: ! 343: return(ERROR_NO_MORE_ITEMS); ! 344: ! 345: } ! 346: ! 347: ! 348: extern ! 349: LONG ! 350: EisaFirstNextHandler( ! 351: IN LONG NetcardId, ! 352: IN INTERFACE_TYPE InterfaceType, ! 353: IN ULONG BusNumber, ! 354: IN BOOL First, ! 355: OUT PVOID *Token, ! 356: OUT LONG *Confidence ! 357: ) ! 358: ! 359: /*++ ! 360: ! 361: Routine Description: ! 362: ! 363: This routine finds the instances of a physical adapter identified ! 364: by the NetcardId. ! 365: ! 366: Arguments: ! 367: ! 368: NetcardId - The index of the netcard being address. The first ! 369: cards information is id 1000, the second id 1100, etc. ! 370: ! 371: InterfaceType - Microchannel ! 372: ! 373: BusNumber - The bus number of the bus to search. ! 374: ! 375: First - TRUE is we are to search for the first instance of an ! 376: adapter, FALSE if we are to continue search from a previous stopping ! 377: point. ! 378: ! 379: Token - A pointer to a handle to return to identify the found ! 380: instance ! 381: ! 382: Confidence - A pointer to a long for storing the confidence factor ! 383: that the card exists. ! 384: ! 385: Return Value: ! 386: ! 387: 0 if nothing went wrong, else the appropriate WINERROR.H value. ! 388: ! 389: --*/ ! 390: ! 391: { ! 392: ULONG CompressedId; ! 393: ULONG ReturnValue; ! 394: ! 395: if (InterfaceType != Eisa) { ! 396: ! 397: *Confidence = 0; ! 398: return(0); ! 399: ! 400: } ! 401: ! 402: // ! 403: // Get CompressedId ! 404: // ! 405: ! 406: switch (NetcardId) { ! 407: ! 408: // ! 409: // NE3200 ! 410: // ! 411: ! 412: case 1000: ! 413: ! 414: CompressedId = 0x07CC3A; ! 415: break; ! 416: ! 417: // ! 418: // DEC422 ! 419: // ! 420: ! 421: case 1100: ! 422: ! 423: CompressedId = 0x42A310; ! 424: break; ! 425: ! 426: // ! 427: // PROTEON 1990 ! 428: // ! 429: ! 430: case 1200: ! 431: ! 432: CompressedId = 0x604F42; ! 433: break; ! 434: ! 435: // ! 436: // NET FLEX ! 437: // ! 438: ! 439: case 1300: ! 440: ! 441: CompressedId = 0x61110E; ! 442: break; ! 443: ! 444: // ! 445: // COMPAQ Jupiter board ! 446: // ! 447: ! 448: case 1400: ! 449: ! 450: CompressedId = 0x60110E; ! 451: break; ! 452: ! 453: default: ! 454: ! 455: return(ERROR_INVALID_PARAMETER); ! 456: ! 457: } ! 458: ! 459: // ! 460: // Call FindFirst Routine ! 461: // ! 462: ! 463: ReturnValue = FindEisaCard( ! 464: (ULONG)((NetcardId - 1000) / 100), ! 465: BusNumber, ! 466: (BOOLEAN)First, ! 467: CompressedId, ! 468: Confidence ! 469: ); ! 470: ! 471: if (ReturnValue == 0) { ! 472: ! 473: // ! 474: // In this module I use the token as follows: Remember that ! 475: // the token can only be 2 bytes long (the low 2) because of ! 476: // the interface to the upper part of this DLL. ! 477: // ! 478: // The rest of the high byte is the the bus number. ! 479: // The low byte is the driver index number into Adapters. ! 480: // ! 481: // NOTE: This presumes that there are < 129 buses in the ! 482: // system. Is this reasonable? ! 483: // ! 484: ! 485: *Token = (PVOID)((BusNumber & 0x7F) << 8); ! 486: ! 487: *Token = (PVOID)(((ULONG)*Token) | ((NetcardId - 1000) / 100)); ! 488: ! 489: } ! 490: ! 491: return(ReturnValue); ! 492: ! 493: } ! 494: ! 495: extern ! 496: LONG ! 497: EisaOpenHandleHandler( ! 498: IN PVOID Token, ! 499: OUT PVOID *Handle ! 500: ) ! 501: ! 502: /*++ ! 503: ! 504: Routine Description: ! 505: ! 506: This routine takes a token returned by FirstNext and converts it ! 507: into a permanent handle. ! 508: ! 509: Arguments: ! 510: ! 511: Token - The token. ! 512: ! 513: Handle - A pointer to the handle, so we can store the resulting ! 514: handle. ! 515: ! 516: Return Value: ! 517: ! 518: 0 if nothing went wrong, else the appropriate WINERROR.H value. ! 519: ! 520: --*/ ! 521: ! 522: { ! 523: PEISA_ADAPTER Adapter; ! 524: LONG AdapterNumber; ! 525: ULONG BusNumber; ! 526: INTERFACE_TYPE InterfaceType; ! 527: ! 528: // ! 529: // Get info from the token ! 530: // ! 531: ! 532: InterfaceType = Eisa; ! 533: ! 534: BusNumber = (ULONG)(((ULONG)Token >> 8) & 0x7F); ! 535: ! 536: AdapterNumber = ((ULONG)Token) & 0xFF; ! 537: ! 538: // ! 539: // Store information ! 540: // ! 541: ! 542: Adapter = (PEISA_ADAPTER)DetectAllocateHeap( ! 543: sizeof(EISA_ADAPTER) ! 544: ); ! 545: ! 546: if (Adapter == NULL) { ! 547: ! 548: return(ERROR_NOT_ENOUGH_MEMORY); ! 549: ! 550: } ! 551: ! 552: // ! 553: // Copy across address ! 554: // ! 555: ! 556: Adapter->SlotNumber = SearchStates[(ULONG)AdapterNumber].SlotNumber; ! 557: Adapter->CardType = Adapters[AdapterNumber].Index; ! 558: Adapter->InterfaceType = InterfaceType; ! 559: Adapter->BusNumber = BusNumber; ! 560: ! 561: *Handle = (PVOID)Adapter; ! 562: ! 563: return(0); ! 564: } ! 565: ! 566: LONG ! 567: EisaCreateHandleHandler( ! 568: IN LONG NetcardId, ! 569: IN INTERFACE_TYPE InterfaceType, ! 570: IN ULONG BusNumber, ! 571: OUT PVOID *Handle ! 572: ) ! 573: ! 574: /*++ ! 575: ! 576: Routine Description: ! 577: ! 578: This routine is used to force the creation of a handle for cases ! 579: where a card is not found via FirstNext, but the user says it does ! 580: exist. ! 581: ! 582: Arguments: ! 583: ! 584: NetcardId - The id of the card to create the handle for. ! 585: ! 586: InterfaceType - Microchannel ! 587: ! 588: BusNumber - The bus number of the bus in the system. ! 589: ! 590: Handle - A pointer to the handle, for storing the resulting handle. ! 591: ! 592: Return Value: ! 593: ! 594: 0 if nothing went wrong, else the appropriate WINERROR.H value. ! 595: ! 596: --*/ ! 597: ! 598: { ! 599: PEISA_ADAPTER Adapter; ! 600: LONG NumberOfAdapters; ! 601: LONG i; ! 602: ! 603: if (InterfaceType != Eisa) { ! 604: ! 605: return(ERROR_INVALID_PARAMETER); ! 606: ! 607: } ! 608: ! 609: NumberOfAdapters = sizeof(Adapters) / sizeof(ADAPTER_INFO); ! 610: ! 611: for (i=0; i < NumberOfAdapters; i++) { ! 612: ! 613: if (Adapters[i].Index == NetcardId) { ! 614: ! 615: // ! 616: // Store information ! 617: // ! 618: ! 619: Adapter = (PEISA_ADAPTER)DetectAllocateHeap( ! 620: sizeof(EISA_ADAPTER) ! 621: ); ! 622: ! 623: if (Adapter == NULL) { ! 624: ! 625: return(ERROR_NOT_ENOUGH_MEMORY); ! 626: ! 627: } ! 628: ! 629: // ! 630: // Copy across memory address ! 631: // ! 632: ! 633: Adapter->SlotNumber = 1; ! 634: Adapter->CardType = NetcardId; ! 635: Adapter->InterfaceType = InterfaceType; ! 636: Adapter->BusNumber = BusNumber; ! 637: ! 638: *Handle = (PVOID)Adapter; ! 639: ! 640: return(0); ! 641: ! 642: } ! 643: ! 644: } ! 645: ! 646: return(ERROR_INVALID_PARAMETER); ! 647: } ! 648: ! 649: extern ! 650: LONG ! 651: EisaCloseHandleHandler( ! 652: IN PVOID Handle ! 653: ) ! 654: ! 655: /*++ ! 656: ! 657: Routine Description: ! 658: ! 659: This frees any resources associated with a handle. ! 660: ! 661: Arguments: ! 662: ! 663: Handle - The handle. ! 664: ! 665: Return Value: ! 666: ! 667: 0 if nothing went wrong, else the appropriate WINERROR.H value. ! 668: ! 669: --*/ ! 670: ! 671: { ! 672: DetectFreeHeap(Handle); ! 673: ! 674: return(0); ! 675: } ! 676: ! 677: LONG ! 678: EisaQueryCfgHandler( ! 679: IN PVOID Handle, ! 680: OUT WCHAR *Buffer, ! 681: IN LONG BuffSize ! 682: ) ! 683: ! 684: /*++ ! 685: ! 686: Routine Description: ! 687: ! 688: This routine calls the appropriate driver's query config handler to ! 689: get the parameters for the adapter associated with the handle. ! 690: ! 691: Arguments: ! 692: ! 693: Handle - The handle. ! 694: ! 695: Buffer - The resulting parameter list. ! 696: ! 697: BuffSize - Length of the given buffer in WCHARs. ! 698: ! 699: Return Value: ! 700: ! 701: 0 if nothing went wrong, else the appropriate WINERROR.H value. ! 702: ! 703: --*/ ! 704: ! 705: { ! 706: PEISA_ADAPTER Adapter = (PEISA_ADAPTER)(Handle); ! 707: LONG OutputLengthLeft = BuffSize; ! 708: LONG CopyLength; ! 709: ULONG CompressedId; ! 710: PVOID BusHandle; ! 711: ULONG ReturnValue; ! 712: ULONG Confidence; ! 713: ! 714: ULONG StartPointer = (ULONG)Buffer; ! 715: ! 716: if (Adapter->InterfaceType != Eisa) { ! 717: ! 718: return(ERROR_INVALID_PARAMETER); ! 719: ! 720: } ! 721: ! 722: // ! 723: // Verify the SlotNumber ! 724: // ! 725: ! 726: if (!GetEisaKey(Adapter->BusNumber, &BusHandle)) { ! 727: ! 728: return(ERROR_INVALID_PARAMETER); ! 729: ! 730: } ! 731: ! 732: if (!GetEisaCompressedId( ! 733: BusHandle, ! 734: Adapter->SlotNumber, ! 735: &CompressedId ! 736: )) { ! 737: ! 738: // ! 739: // Fail ! 740: // ! 741: ! 742: return(ERROR_INVALID_PARAMETER); ! 743: ! 744: } ! 745: ! 746: // ! 747: // Verify ID ! 748: // ! 749: ! 750: ReturnValue = ERROR_INVALID_PARAMETER; ! 751: ! 752: switch (Adapter->CardType) { ! 753: ! 754: // ! 755: // NE3200 ! 756: // ! 757: ! 758: case 1000: ! 759: ! 760: if (CompressedId == 0x07CC3A) { ! 761: ! 762: ReturnValue = 0; ! 763: ! 764: } else { ! 765: ! 766: CompressedId = 0x07CC3A; ! 767: ! 768: } ! 769: break; ! 770: ! 771: // ! 772: // DEC422 ! 773: // ! 774: ! 775: case 1100: ! 776: ! 777: if (CompressedId == 0x42A310) { ! 778: ! 779: ReturnValue = 0; ! 780: ! 781: } else { ! 782: ! 783: CompressedId = 0x42A310; ! 784: ! 785: } ! 786: break; ! 787: ! 788: // ! 789: // PROTEON 1990 ! 790: // ! 791: ! 792: case 1200: ! 793: ! 794: if (CompressedId == 0x604F42) { ! 795: ! 796: ReturnValue = 0; ! 797: ! 798: } else { ! 799: ! 800: CompressedId = 0x604F42; ! 801: ! 802: } ! 803: break; ! 804: ! 805: // ! 806: // NET FLEX ! 807: // ! 808: ! 809: case 1300: ! 810: ! 811: if (CompressedId == 0x61110E) { ! 812: ! 813: ReturnValue = 0; ! 814: ! 815: } else { ! 816: ! 817: CompressedId = 0x61110E; ! 818: ! 819: } ! 820: break; ! 821: ! 822: // ! 823: // COMPAQ Jupiter board ! 824: // ! 825: ! 826: case 1400: ! 827: ! 828: if (CompressedId == 0x60110E) { ! 829: ! 830: ReturnValue = 0; ! 831: ! 832: } else { ! 833: ! 834: CompressedId = 0x60110E; ! 835: ! 836: } ! 837: break; ! 838: ! 839: default: ! 840: ! 841: return(ERROR_INVALID_PARAMETER); ! 842: ! 843: } ! 844: ! 845: ! 846: if (ReturnValue != 0) { ! 847: ! 848: // ! 849: // Try to find it in another slot ! 850: // ! 851: ! 852: ReturnValue = FindEisaCard( ! 853: Adapter->CardType, ! 854: Adapter->BusNumber, ! 855: TRUE, ! 856: CompressedId, ! 857: &Confidence ! 858: ); ! 859: ! 860: if (Confidence != 100) { ! 861: ! 862: // ! 863: // Confidence is not absolute -- we are out of here. ! 864: // ! 865: ! 866: return(ERROR_INVALID_PARAMETER); ! 867: ! 868: } ! 869: ! 870: Adapter->SlotNumber = SearchStates[(ULONG)Adapter->CardType].SlotNumber; ! 871: ! 872: } ! 873: ! 874: // ! 875: // Build resulting buffer ! 876: // ! 877: ! 878: // ! 879: // Put in SlotNumber ! 880: // ! 881: ! 882: // ! 883: // Copy in the title string ! 884: // ! 885: ! 886: CopyLength = UnicodeStrLen(SlotNumberString) + 1; ! 887: ! 888: if (OutputLengthLeft < CopyLength) { ! 889: ! 890: return(ERROR_INSUFFICIENT_BUFFER); ! 891: ! 892: } ! 893: ! 894: memcpy((PVOID)Buffer, ! 895: (PVOID)SlotNumberString, ! 896: (CopyLength * sizeof(WCHAR)) ! 897: ); ! 898: ! 899: Buffer = &(Buffer[CopyLength]); ! 900: OutputLengthLeft -= CopyLength; ! 901: ! 902: // ! 903: // Copy in the value ! 904: // ! 905: ! 906: if (OutputLengthLeft < 8) { ! 907: ! 908: return(ERROR_INSUFFICIENT_BUFFER); ! 909: ! 910: } ! 911: ! 912: CopyLength = wsprintfW(Buffer,L"0x%x",(ULONG)(Adapter->SlotNumber)); ! 913: ! 914: if (CopyLength < 0) { ! 915: ! 916: return(ERROR_INSUFFICIENT_BUFFER); ! 917: ! 918: } ! 919: ! 920: CopyLength++; // Add in the \0 ! 921: ! 922: Buffer = &(Buffer[CopyLength]); ! 923: OutputLengthLeft -= CopyLength; ! 924: ! 925: // ! 926: // Copy in final \0 ! 927: // ! 928: ! 929: if (OutputLengthLeft < 1) { ! 930: ! 931: return(ERROR_INSUFFICIENT_BUFFER); ! 932: ! 933: } ! 934: ! 935: CopyLength = (ULONG)Buffer - StartPointer; ! 936: Buffer[CopyLength] = L'\0'; ! 937: ! 938: return(0); ! 939: } ! 940: ! 941: extern ! 942: LONG ! 943: EisaVerifyCfgHandler( ! 944: IN PVOID Handle, ! 945: IN WCHAR *Buffer ! 946: ) ! 947: ! 948: /*++ ! 949: ! 950: Routine Description: ! 951: ! 952: This routine verifys that a given parameter list is complete and ! 953: correct for the adapter associated with the handle. ! 954: ! 955: Arguments: ! 956: ! 957: Handle - The handle. ! 958: ! 959: Buffer - The parameter list. ! 960: ! 961: Return Value: ! 962: ! 963: 0 if nothing went wrong, else the appropriate WINERROR.H value. ! 964: ! 965: --*/ ! 966: ! 967: { ! 968: PEISA_ADAPTER Adapter = (PEISA_ADAPTER)(Handle); ! 969: WCHAR *Place; ! 970: ULONG CompressedId; ! 971: ULONG SlotNumber; ! 972: PVOID BusHandle; ! 973: BOOLEAN Found; ! 974: ! 975: if (Adapter->InterfaceType != Eisa) { ! 976: ! 977: return(ERROR_INVALID_DATA); ! 978: ! 979: } ! 980: ! 981: // ! 982: // Parse out the parameter. ! 983: // ! 984: ! 985: // ! 986: // Get the SlotNumber ! 987: // ! 988: ! 989: Place = FindParameterString(Buffer, SlotNumberString); ! 990: ! 991: if (Place == NULL) { ! 992: ! 993: return(ERROR_INVALID_DATA); ! 994: ! 995: } ! 996: ! 997: Place += UnicodeStrLen(SlotNumberString) + 1; ! 998: ! 999: // ! 1000: // Now parse the thing. ! 1001: // ! 1002: ! 1003: ScanForNumber(Place, &SlotNumber, &Found); ! 1004: ! 1005: if (Found == FALSE) { ! 1006: ! 1007: return(ERROR_INVALID_DATA); ! 1008: ! 1009: } ! 1010: ! 1011: // ! 1012: // Verify the SlotNumber ! 1013: // ! 1014: ! 1015: if (!GetEisaKey(Adapter->BusNumber, &BusHandle)) { ! 1016: ! 1017: return(ERROR_INVALID_DATA); ! 1018: ! 1019: } ! 1020: ! 1021: if (!GetEisaCompressedId( ! 1022: BusHandle, ! 1023: SlotNumber, ! 1024: &CompressedId ! 1025: )) { ! 1026: ! 1027: // ! 1028: // Fail ! 1029: // ! 1030: ! 1031: return(ERROR_INVALID_DATA); ! 1032: ! 1033: } ! 1034: ! 1035: // ! 1036: // Verify ID ! 1037: // ! 1038: ! 1039: switch (Adapter->CardType) { ! 1040: ! 1041: // ! 1042: // NE3200 ! 1043: // ! 1044: ! 1045: case 1000: ! 1046: ! 1047: if (CompressedId != 0x07CC3A) { ! 1048: ! 1049: return(ERROR_INVALID_DATA); ! 1050: ! 1051: } ! 1052: break; ! 1053: ! 1054: // ! 1055: // DEC422 ! 1056: // ! 1057: ! 1058: case 1100: ! 1059: ! 1060: if (CompressedId != 0x42A310) { ! 1061: ! 1062: return(ERROR_INVALID_DATA); ! 1063: ! 1064: } ! 1065: break; ! 1066: ! 1067: // ! 1068: // PROTEON 1990 ! 1069: // ! 1070: ! 1071: case 1200: ! 1072: ! 1073: if (CompressedId != 0x604F42) { ! 1074: ! 1075: return(ERROR_INVALID_DATA); ! 1076: ! 1077: } ! 1078: break; ! 1079: ! 1080: // ! 1081: // NET FLEX ! 1082: // ! 1083: ! 1084: case 1300: ! 1085: ! 1086: if (CompressedId != 0x61110E) { ! 1087: ! 1088: return(ERROR_INVALID_DATA); ! 1089: ! 1090: } ! 1091: break; ! 1092: ! 1093: // ! 1094: // COMPAQ Jupiter Board ! 1095: // ! 1096: ! 1097: case 1400: ! 1098: ! 1099: if (CompressedId != 0x60110E) { ! 1100: ! 1101: return(ERROR_INVALID_DATA); ! 1102: ! 1103: } ! 1104: break; ! 1105: ! 1106: default: ! 1107: ! 1108: return(ERROR_INVALID_DATA); ! 1109: ! 1110: } ! 1111: ! 1112: return(0); ! 1113: ! 1114: } ! 1115: ! 1116: extern ! 1117: LONG ! 1118: EisaQueryMaskHandler( ! 1119: IN LONG NetcardId, ! 1120: OUT WCHAR *Buffer, ! 1121: IN LONG BuffSize ! 1122: ) ! 1123: ! 1124: /*++ ! 1125: ! 1126: Routine Description: ! 1127: ! 1128: This routine returns the parameter list information for a specific ! 1129: network card. ! 1130: ! 1131: Arguments: ! 1132: ! 1133: NetcardId - The id of the desired netcard. ! 1134: ! 1135: Buffer - The buffer for storing the parameter information. ! 1136: ! 1137: BuffSize - Length of Buffer in WCHARs. ! 1138: ! 1139: Return Value: ! 1140: ! 1141: 0 if nothing went wrong, else the appropriate WINERROR.H value. ! 1142: ! 1143: --*/ ! 1144: ! 1145: { ! 1146: WCHAR *Result; ! 1147: LONG Length; ! 1148: LONG NumberOfAdapters; ! 1149: LONG i; ! 1150: ! 1151: // ! 1152: // Find the adapter ! 1153: // ! 1154: ! 1155: NumberOfAdapters = sizeof(Adapters) / sizeof(ADAPTER_INFO); ! 1156: ! 1157: for (i=0; i < NumberOfAdapters; i++) { ! 1158: ! 1159: if (Adapters[i].Index == NetcardId) { ! 1160: ! 1161: Result = Adapters[i].Parameters; ! 1162: ! 1163: // ! 1164: // Find the string length (Ends with 2 NULLs) ! 1165: // ! 1166: ! 1167: for (Length=0; ; Length++) { ! 1168: ! 1169: if (Result[Length] == L'\0') { ! 1170: ! 1171: ++Length; ! 1172: ! 1173: if (Result[Length] == L'\0') { ! 1174: ! 1175: break; ! 1176: ! 1177: } ! 1178: ! 1179: } ! 1180: ! 1181: } ! 1182: ! 1183: Length++; ! 1184: ! 1185: if (BuffSize < Length) { ! 1186: ! 1187: return(ERROR_NOT_ENOUGH_MEMORY); ! 1188: ! 1189: } ! 1190: ! 1191: memcpy((PVOID)Buffer, Result, Length * sizeof(WCHAR)); ! 1192: ! 1193: return(0); ! 1194: ! 1195: } ! 1196: ! 1197: } ! 1198: ! 1199: return(ERROR_INVALID_PARAMETER); ! 1200: ! 1201: } ! 1202: ! 1203: extern ! 1204: LONG ! 1205: EisaParamRangeHandler( ! 1206: IN LONG NetcardId, ! 1207: IN WCHAR *Param, ! 1208: OUT LONG *Values, ! 1209: OUT LONG *BuffSize ! 1210: ) ! 1211: ! 1212: /*++ ! 1213: ! 1214: Routine Description: ! 1215: ! 1216: This routine returns a list of valid values for a given parameter name ! 1217: for a given card. ! 1218: ! 1219: Arguments: ! 1220: ! 1221: NetcardId - The Id of the card desired. ! 1222: ! 1223: Param - A WCHAR string of the parameter name to query the values of. ! 1224: ! 1225: Values - A pointer to a list of LONGs into which we store valid values ! 1226: for the parameter. ! 1227: ! 1228: BuffSize - At entry, the length of Values in LONGs. At exit, the ! 1229: number of LONGs stored in Values. ! 1230: ! 1231: Return Value: ! 1232: ! 1233: 0 if nothing went wrong, else the appropriate WINERROR.H value. ! 1234: ! 1235: --*/ ! 1236: ! 1237: { ! 1238: ! 1239: *BuffSize = 0; ! 1240: return(0); ! 1241: ! 1242: } ! 1243: ! 1244: extern ! 1245: LONG ! 1246: EisaQueryParameterNameHandler( ! 1247: IN WCHAR *Param, ! 1248: OUT WCHAR *Buffer, ! 1249: IN LONG BufferSize ! 1250: ) ! 1251: ! 1252: /*++ ! 1253: ! 1254: Routine Description: ! 1255: ! 1256: Returns a localized, displayable name for a specific parameter. All the ! 1257: parameters that this file uses are define by MS, so no strings are ! 1258: needed here. ! 1259: ! 1260: Arguments: ! 1261: ! 1262: Param - The parameter to be queried. ! 1263: ! 1264: Buffer - The buffer to store the result into. ! 1265: ! 1266: BufferSize - The length of Buffer in WCHARs. ! 1267: ! 1268: Return Value: ! 1269: ! 1270: ERROR_INVALID_PARAMETER -- To indicate that the MS supplied strings ! 1271: should be used. ! 1272: ! 1273: --*/ ! 1274: ! 1275: { ! 1276: return(ERROR_INVALID_PARAMETER); ! 1277: } ! 1278: ! 1279: ULONG ! 1280: FindEisaCard( ! 1281: IN ULONG AdapterNumber, ! 1282: IN ULONG BusNumber, ! 1283: IN BOOLEAN First, ! 1284: IN ULONG CompressedId, ! 1285: OUT PULONG Confidence ! 1286: ) ! 1287: ! 1288: /*++ ! 1289: ! 1290: Routine Description: ! 1291: ! 1292: This routine finds the instances of a physical adapter identified ! 1293: by the CompressedId. ! 1294: ! 1295: Arguments: ! 1296: ! 1297: AdapterNumber - The index into the global array of adapters for the card. ! 1298: ! 1299: BusNumber - The bus number of the bus to search. ! 1300: ! 1301: First - TRUE is we are to search for the first instance of an ! 1302: adapter, FALSE if we are to continue search from a previous stopping ! 1303: point. ! 1304: ! 1305: CompressedId - The EISA Compressed Id of the card. ! 1306: ! 1307: Confidence - A pointer to a long for storing the confidence factor ! 1308: that the card exists. ! 1309: ! 1310: Return Value: ! 1311: ! 1312: 0 if nothing went wrong, else the appropriate WINERROR.H value. ! 1313: ! 1314: --*/ ! 1315: ! 1316: { ! 1317: PVOID BusHandle; ! 1318: ULONG TmpCompressedId; ! 1319: ! 1320: if (First) { ! 1321: ! 1322: SearchStates[AdapterNumber].SlotNumber = 1; ! 1323: ! 1324: } else { ! 1325: ! 1326: SearchStates[AdapterNumber].SlotNumber++; ! 1327: ! 1328: } ! 1329: ! 1330: if (!GetEisaKey(BusNumber, &BusHandle)) { ! 1331: ! 1332: return(ERROR_INVALID_PARAMETER); ! 1333: ! 1334: } ! 1335: ! 1336: while (TRUE) { ! 1337: ! 1338: if (!GetEisaCompressedId(BusHandle, ! 1339: SearchStates[AdapterNumber].SlotNumber, ! 1340: &TmpCompressedId)) { ! 1341: ! 1342: *Confidence = 0; ! 1343: return(0); ! 1344: ! 1345: } ! 1346: ! 1347: if (CompressedId == TmpCompressedId) { ! 1348: ! 1349: *Confidence = 100; ! 1350: return(0); ! 1351: ! 1352: } ! 1353: ! 1354: SearchStates[AdapterNumber].SlotNumber++; ! 1355: ! 1356: } ! 1357: ! 1358: DeleteEisaKey(BusHandle); ! 1359: ! 1360: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.