rom/isapnp/init.c

   1 /* $Id$ */
   2
   3 /*
   4      ISA-PnP -- A Plug And Play ISA software layer for AmigaOS.
   5      Copyright (C) 2001 Martin Blom <martin@blom.org>
   6      Copyright (C) 2009 The AROS Development Team
   7
   8      This library is free software; you can redistribute it and/or
   9      modify it under the terms of the GNU Library General Public
  10      License as published by the Free Software Foundation; either
  11      version 2 of the License, or (at your option) any later version.
  12
  13      This library is distributed in the hope that it will be useful,
  14      but WITHOUT ANY WARRANTY; without even the implied warranty of
  15      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  16      Library General Public License for more details.
  17
  18      You should have received a copy of the GNU Library General Public
  19      License along with this library; if not, write to the
  20      Free Software Foundation, Inc., 59 Temple Place - Suite 330, Cambridge,
  21      MA 02139, USA.
  22 */
  23
  24 #define DEBUG 1
  25
  26 #include "CompilerSpecific.h"
  27
  28 #include <exec/memory.h>
  29 #include <exec/resident.h>
  30 #include <devices/timer.h>
  31
  32 #include <clib/alib_protos.h>
  33 #include <proto/exec.h>
  34 /*#include <proto/utility.h>*/
  35
  36 #include <stdlib.h>
  37
  38 #include <resources/isapnp.h>
  39 #include "isapnp_private.h"
  40 #include "version.h"
  41
  42 #include "controller.h"
  43 #include "devices.h"
  44 #include "init.h"
  45 #include "pnp.h"
  46 #include "pnp_structs.h"
  47
  48 /*
  49 static BOOL
  50 HandleToolTypes( UBYTE**             tool_types,
  51                  struct ISAPNP_Card* card,
  52                  struct ISAPNPBase*  res );
  53 */
  54 static BOOL
  55 PatchBrokenCards( struct ISAPNPBase* res );
  56 /*
  57 void
  58 ReqA( const char* text, APTR args );
  59
  60 #define Req( text, args...) \
  61         ( { ULONG _args[] = { args }; ReqA( (text), (APTR) _args ); } )
  62 */
  63 #define Req(args...) bug(args); bug("\n")
  64
  65 /******************************************************************************
  66 ** Resource resident structure ************************************************
  67 ******************************************************************************/
  68
  69 extern const char LIBEND;
  70 extern const char ResName[];
  71 extern const char IDString[];
  72 static const APTR InitTable[4];
  73
  74 const struct Resident RomTag =
  75 {
  76   RTC_MATCHWORD,
  77   (struct Resident *) &RomTag,
  78   (struct Resident *) &LIBEND,
  79   RTF_AUTOINIT|RTF_COLDSTART,
  80   VERSION,
  81   NT_RESOURCE,
  82   12,                      /* priority */
  83   (BYTE *) ResName,
  84   (BYTE *) IDString,
  85   (APTR) &InitTable,
  86   0,
  87   0
  88 };
  89
  90
  91 /******************************************************************************
  92 ** Globals ********************************************************************
  93 ******************************************************************************/
  94
  95 struct Device*         TimerBase     = NULL;
  96 /*struct ExecBase*     SysBase       = NULL;*/
  97 /*struct IntuitionBase*  IntuitionBase = NULL;*/
  98 struct ISAPNPBase*     ISAPNPBase    = NULL;
  99 /*struct UtilityBase*    UtilityBase   = NULL;*/
 100
 101 static struct timerequest *TimerIO   = NULL;
 102
 103 const char ResName[]   = ISAPNPNAME;
 104 const char IDString[]  = ISAPNPNAME " " VERS "\r\n";
 105
 106 static const char VersTag[] =
 107  "$VER: " ISAPNPNAME " " VERS " ©2001 Martin Blom.\r\n";
 108
 109 /******************************************************************************
 110 ** Resource initialization ****************************************************
 111 ******************************************************************************/
 112
 113 struct ISAPNPBase* ASMCALL
 114 initRoutine( REG( d0, struct ISAPNPBase* res ),
 115              REG( a0, APTR                    seglist ),
 116              REG( a6, struct ExecBase*        sysbase ) )
 117 {
 118     D(bug("[ISAPNP] Init\n"));
 119 /*  SysBase = sysbase;*/
 120
 121     if(OpenLibs() )
 122     {
 123         // Set up the ISAPNPBase structure
 124
 125         res->m_Library.lib_Node.ln_Type = NT_RESOURCE;
 126         res->m_Library.lib_Node.ln_Name = (STRPTR) ResName;
 127         res->m_Library.lib_Flags        = LIBF_SUMUSED | LIBF_CHANGED;
 128         res->m_Library.lib_Version      = VERSION;
 129         res->m_Library.lib_Revision     = REVISION;
 130         res->m_Library.lib_IdString     = (STRPTR) IDString;
 131
 132         NewList( &res->m_Cards );
 133
 134         /* Base address, on i386 we don't have any mapping
 135         res->m_Base        = NULL; */
 136         res->m_RegReadData = 0x0000;
 137
 138         if( ! ISAPNP_ScanCards( res ) )
 139         {
 140               // No cards found
 141
 142               Req( "No PnP ISA cards found." );
 143               FreeISAPNPBase( res );
 144         }
 145         else
 146         {
 147             if( ! PatchBrokenCards( res ) )
 148             {
 149                 FreeISAPNPBase( res );
 150             }
 151             else
 152             {
 153                 struct ISAPNP_Card* card;
 154
 155                 card = ISAPNP_AllocCard( res );
 156
 157                 if( card == NULL )
 158                 {
 159                   Req( "Out of memory!" );
 160                   FreeISAPNPBase( res );
 161                 }
 162                 else
 163                 {
 164                   static const char descr[] = "Non-PnP devices";
 165                   char*             d;
 166
 167                   d = AllocVec( sizeof( descr ), MEMF_PUBLIC );
 168
 169                   if( d != NULL )
 170                   {
 171                     CopyMem( (void*) descr, d, sizeof( descr ) );
 172                     card->isapnpc_Node.ln_Name = d;
 173                   }
 174
 175                   card->isapnpc_ID.isapnpid_Vendor[ 0 ] = '?';
 176                   card->isapnpc_ID.isapnpid_Vendor[ 1 ] = '?';
 177                   card->isapnpc_ID.isapnpid_Vendor[ 2 ] = '?';
 178                   card->isapnpc_SerialNumber = -1;
 179
 180                   // Add *first*
 181                   AddHead( &res->m_Cards, (struct Node*) card );
 182
 183                   // Let's see if we're to disable any cards or devices etc
 184 /* TODO: We will start up early because we can have even ISA PnP video
 185          cards, disk controllers, etc. Because of this we can't load
 186          any list of disabled devices. Think off what to do with them
 187          is really a big TODO.
 188                   if( ! HandleToolTypes( current_binding.cb_ToolTypes,
 189                                          card, res ) )
 190                   {
 191                     // Error requester already displayed.
 192                     FreeISAPNPBase( res );
 193                   }
 194                   else
 195                   {*/
 196                     if( ! ISAPNP_ConfigureCards( res ) )
 197                     {
 198                       // Unable to configure cards
 199
 200                       Req( "Unable to configure the cards. This is most likely\n"
 201                            "because of an unresolvable hardware conflict.\n\n"
 202                            "Use the DISABLE_DEVICE tool type to disable one of\n"
 203                            "the devices in conflict." );
 204                       FreeISAPNPBase( res );
 205                     }
 206                     else
 207                       ISAPNPBase = res;
 208 /*                }*/
 209                 }
 210             }
 211         }
 212     }
 213
 214     return ISAPNPBase;
 215
 216 }
 217
 218
 219 /******************************************************************************
 220 ** Free all resources from ISAPNPBase *****************************************
 221 ******************************************************************************/
 222
 223 void
 224 FreeISAPNPBase( struct ISAPNPBase* res )
 225 {
 226   struct ISAPNP_Card* card;
 227
 228   while( ( card = (struct ISAPNP_Card*) RemHead( &res->m_Cards ) ) )
 229   {
 230     ISAPNP_FreeCard( card, ISAPNPBase );
 231   }
 232 }
 233
 234
 235 /******************************************************************************
 236 ** Initialization tables ******************************************************
 237 ******************************************************************************/
 238
 239 static const APTR funcTable[] =
 240 {
 241   ISAC_SetMasterInt,
 242   ISAC_GetMasterInt,
 243   ISAC_SetWaitState,
 244   ISAC_GetWaitState,
 245   ISAC_GetInterruptStatus,
 246   ISAC_GetRegByte,
 247   ISAC_SetRegByte,
 248   ISAC_GetRegWord,
 249   ISAC_SetRegWord,
 250   ISAC_GetRegLong,
 251   ISAC_SetRegLong,
 252   ISAC_ReadByte,
 253   ISAC_WriteByte,
 254   ISAC_ReadWord,
 255   ISAC_WriteWord,
 256   ISAC_ReadLong,
 257   ISAC_WriteLong,
 258
 259   ISAPNP_AllocCard,
 260   ISAPNP_FreeCard,
 261   ISAPNP_AllocDevice,
 262   ISAPNP_FreeDevice,
 263   ISAPNP_AllocResourceGroup,
 264   ISAPNP_FreeResourceGroup,
 265   ISAPNP_AllocResource,
 266   ISAPNP_FreeResource,
 267
 268   ISAPNP_ScanCards,
 269   ISAPNP_ConfigureCards,
 270
 271   ISAPNP_FindCard,
 272   ISAPNP_FindDevice,
 273
 274   ISAPNP_LockCardsA,
 275   ISAPNP_UnlockCards,
 276   ISAPNP_LockDevicesA,
 277   ISAPNP_UnlockDevices,
 278
 279   (APTR) -1
 280 };
 281
 282
 283 static const APTR InitTable[4] =
 284 {
 285   (APTR) sizeof( struct ISAPNPBase ),
 286   (APTR) &funcTable,
 287   0,
 288   (APTR) initRoutine
 289 };
 290
 291 /******************************************************************************
 292 ** OpenLibs *******************************************************************
 293 ******************************************************************************/
 294
 295 BOOL
 296 OpenLibs( void )
 297 {
 298   /* Utility Library (libnix depends on it, and our startup-code is not
 299      executed when BindDriver LoadSeg()s us!) */
 300
 301   /* Intuition Library */
 302 /*
 303   IntuitionBase  = (struct IntuitionBase*) OpenLibrary( "intuition.library", 37 );
 304
 305   if( IntuitionBase == NULL )
 306   {
 307     return FALSE;
 308   }
 309
 310   UtilityBase = (struct UtilityBase *) OpenLibrary( "utility.library", 37 );
 311
 312   if( UtilityBase == NULL)
 313   {
 314     return FALSE;
 315   }
 316 */
 317   /* Timer Device */
 318
 319   TimerIO = (struct timerequest *) AllocVec( sizeof(struct timerequest),
 320                                              MEMF_PUBLIC | MEMF_CLEAR );
 321
 322   if( TimerIO == NULL)
 323   {
 324     return FALSE;
 325   }
 326
 327   if( OpenDevice( "timer.device",
 328                   UNIT_MICROHZ,
 329                   (struct IORequest *)
 330                   TimerIO,
 331                   0) != 0 )
 332   {
 333     return FALSE;
 334   }
 335
 336   TimerBase = (struct Device *) TimerIO->tr_node.io_Device;
 337
 338   return TRUE;
 339 }
 340
 341
 342 /******************************************************************************
 343 ** CloseLibs *******************************************************************
 344 ******************************************************************************/
 345
 346 void
 347 CloseLibs( void )
 348 {
 349   if( TimerIO  != NULL )
 350   {
 351     CloseDevice( (struct IORequest *) TimerIO );
 352   }
 353
 354   FreeVec( TimerIO );
 355 /*
 356   CloseLibrary( (struct Library*) UtilityBase );
 357   CloseLibrary( (struct Library*) IntuitionBase );
 358 */
 359   TimerIO       = NULL;
 360   TimerBase     = NULL;
 361 /*IntuitionBase = NULL;
 362   UtilityBase   = NULL;*/
 363 }
 364
 365
 366 /******************************************************************************
 367 ** ReqA ***********************************************************************
 368 ******************************************************************************/
 369 /*
 370 void
 371 ReqA( const char* text, APTR args )
 372 {
 373   struct EasyStruct es =
 374   {
 375     sizeof (struct EasyStruct),
 376     0,
 377     (STRPTR) ISAPNPNAME " " VERS,
 378     (STRPTR) text,
 379     "OK"
 380   };
 381
 382   if( IntuitionBase != NULL )
 383   {
 384     EasyRequestArgs( NULL, &es, NULL, args );
 385   }
 386 }
 387 */
 388
 389 /******************************************************************************
 390 ** Handle the tool types ******************************************************
 391 ******************************************************************************/
 392 /*
 393 static int
 394 HexToInt( UBYTE c )
 395 {
 396   if( c >= '0' && c <= '9' )
 397   {
 398     return c - '0';
 399   }
 400   else if( c >= 'A' && c <= 'F' )
 401   {
 402     return c - 'A' + 10;
 403   }
 404   else if( c >= 'a' && c <= 'f' )
 405   {
 406     return c - 'a' + 10;
 407   }
 408   else
 409   {
 410     return -1;
 411   }
 412 }
 413
 414 // CTL0048        => "CTL\0" 4 8 -1   -1
 415 // CTL0048/1236   => "CTL\0" 4 8 1236 -1
 416 // CTL0048:0      => "CTL\0" 4 8 -1   0
 417 // CTL0048/1236:0 => "CTL\0" 4 8 1236 0
 418
 419 static int
 420 ParseID( UBYTE* string,
 421          LONG*  manufacturer,
 422          WORD*  product,
 423          BYTE*  revision,
 424          LONG*  serial,
 425          WORD*  logical_device )
 426 {
 427   int  chars = 0;
 428   LONG ser   = -1;
 429   LONG dev   = -1;
 430
 431   *manufacturer = ISAPNP_MAKE_ID( ToUpper( string[ 0 ] ),
 432                                   ToUpper( string[ 1 ] ),
 433                                   ToUpper( string[ 2 ] ) );
 434
 435   *product      = ( HexToInt( string[ 3 ] ) << 8 ) |
 436                   ( HexToInt( string[ 4 ] ) << 4 ) |
 437                   ( HexToInt( string[ 5 ] ) );
 438
 439
 440   if( *product == -1 )
 441   {
 442     return 0;
 443   }
 444
 445   *revision = HexToInt( string[ 6 ] );
 446
 447   if( *revision == -1 )
 448   {
 449     return 0;
 450   }
 451
 452   chars = 7;
 453
 454   if( string[ chars ] == '/' )
 455   {
 456     int conv;
 457
 458     if( serial == NULL )
 459     {
 460       // Not allowed if we don't ask for it
 461       return NULL;
 462     }
 463
 464     conv = StrToLong( string + chars + 1, &ser );
 465
 466     if( conv == -1 )
 467     {
 468       return 0;
 469     }
 470     else
 471     {
 472       chars += conv + 1;
 473     }
 474
 475   }
 476
 477   if( serial != NULL )
 478   {
 479     *serial = ser;
 480   }
 481
 482   if( string[ chars ] == ':' )
 483   {
 484     int conv;
 485
 486     if( logical_device == NULL )
 487     {
 488       // Not allowed if we don't ask for it
 489       return NULL;
 490     }
 491
 492     conv = StrToLong( string + chars + 1, &dev );
 493
 494     if( conv == -1 )
 495     {
 496       return 0;
 497     }
 498     else
 499     {
 500       chars += conv + 1;
 501     }
 502
 503   }
 504
 505   if( logical_device != NULL )
 506   {
 507     *logical_device = dev;
 508   }
 509
 510   if( string[ chars ] != 0 && string[ chars ] != ' ' )
 511   {
 512     return 0;
 513   }
 514
 515   return chars;
 516 }
 517
 518
 519 static BOOL
 520 HandleToolTypes( UBYTE**             tool_types,
 521                  struct ISAPNP_Card* card,
 522                  struct ISAPNPBase*  res )
 523 {
 524   while( *tool_types )
 525   {
 526     if( Strnicmp( *tool_types, "DISABLE_CARD=", 13 ) == 0 )
 527     {
 528       LONG manufacturer;
 529       WORD product;
 530       BYTE revision;
 531       LONG serial;
 532
 533       if( ParseID( *tool_types + 13,
 534                    &manufacturer, &product, &revision, &serial, NULL ) )
 535       {
 536         struct ISAPNP_Card* card = NULL;
 537
 538         while( ( card = ISAPNP_FindCard( card,
 539                                          manufacturer,
 540                                          product,
 541                                          revision,
 542                                          serial,
 543                                          res ) ) != NULL )
 544         {
 545           card->isapnpc_Disabled = TRUE;
 546         }
 547       }
 548       else
 549       {
 550         Req( "Illegal tool type: %s\n", (ULONG) *tool_types );
 551         return FALSE;
 552       }
 553     }
 554     else if( Strnicmp( *tool_types, "DISABLE_DEVICE=", 15 ) == 0 )
 555     {
 556       LONG manufacturer;
 557       WORD product;
 558       BYTE revision;
 559       LONG serial;
 560       WORD log_dev;
 561
 562       if( ParseID( *tool_types + 15,
 563                    &manufacturer, &product, &revision, &serial, &log_dev ) )
 564       {
 565         if( log_dev == -1 )
 566         {
 567           struct ISAPNP_Device* dev = NULL;
 568
 569           while( ( dev = ISAPNP_FindDevice( dev,
 570                                             manufacturer,
 571                                             product,
 572                                             revision,
 573                                             res ) ) != NULL )
 574           {
 575             dev->isapnpd_Disabled = TRUE;
 576           }
 577         }
 578         else
 579         {
 580           struct ISAPNP_Card* card = NULL;
 581
 582           while( ( card = ISAPNP_FindCard( card,
 583                                            manufacturer,
 584                                            product,
 585                                            revision,
 586                                            serial,
 587                                            res ) ) != NULL )
 588           {
 589             struct ISAPNP_Device* dev;
 590
 591             for( dev = (struct ISAPNP_Device*) card->isapnpc_Devices.lh_Head;
 592                  dev->isapnpd_Node.ln_Succ != NULL;
 593                  dev = (struct ISAPNP_Device*) dev->isapnpd_Node.ln_Succ )
 594             {
 595               if( dev->isapnpd_DeviceNumber == (UWORD) log_dev )
 596               {
 597                 dev->isapnpd_Disabled = TRUE;
 598               }
 599             }
 600           }
 601         }
 602       }
 603       else
 604       {
 605         Req( "Illegal tool type value: %s\n", (ULONG) *tool_types );
 606         return FALSE;
 607       }
 608     }
 609     else if( Strnicmp( *tool_types, "LEGACY_DEVICE=", 14 ) == 0 )
 610     {
 611       UBYTE* str;
 612       int    conv;
 613       LONG   manufacturer;
 614       WORD   product;
 615       BYTE   revision;
 616       UWORD  dev_num = 0;
 617
 618       str  = *tool_types + 14;
 619       conv = ParseID( str,  &manufacturer, &product, &revision, NULL, NULL );
 620
 621       str += conv;
 622
 623       if( conv != 0 )
 624       {
 625         struct ISAPNP_Device*     dev;
 626         struct ISAPNP_Identifier* id;
 627
 628         dev = ISAPNP_AllocDevice( res );
 629
 630         if( dev == NULL )
 631         {
 632           Req( "Out of memory!" );
 633           return FALSE;
 634         }
 635
 636         dev->isapnpd_Card = card;
 637
 638         id  = AllocVec( sizeof( *id ), MEMF_PUBLIC | MEMF_CLEAR );
 639
 640         if( id == NULL )
 641         {
 642           Req( "Out of memory!" );
 643           ISAPNP_FreeDevice( dev, res );
 644           return FALSE;
 645         }
 646
 647         id->isapnpid_Vendor[ 0 ]  = ( manufacturer >> 24 ) & 0xff;
 648         id->isapnpid_Vendor[ 1 ]  = ( manufacturer >> 16 ) & 0xff;
 649         id->isapnpid_Vendor[ 2 ]  = ( manufacturer >>  8 ) & 0xff;
 650         id->isapnpid_Vendor[ 3 ]  = 0;
 651
 652         id->isapnpid_ProductID    = product;
 653         id->isapnpid_Revision     = revision;
 654
 655         AddTail( (struct List*) &dev->isapnpd_IDs, (struct Node*) id );
 656
 657         if( card->isapnpc_Devices.lh_Head->ln_Succ != NULL )
 658         {
 659           dev_num = ( (struct ISAPNP_Device*)
 660                       card->isapnpc_Devices.lh_TailPred )->isapnpd_DeviceNumber;
 661           ++dev_num;
 662         }
 663
 664         dev->isapnpd_DeviceNumber = dev_num;
 665
 666         AddTail( &card->isapnpc_Devices, (struct Node*) dev );
 667
 668         while( *str != 0 )
 669         {
 670           if( *str != ' ' )
 671           {
 672             if( Strnicmp( str, "IRQ=", 4 ) == 0 )
 673             {
 674               int irq;
 675
 676               irq = strtol( str + 4, (char**) &str, 0 );
 677
 678               if( irq <= 0 || irq >= 16 )
 679               {
 680                 Req( "Invalid IRQ value '%ld' in tooltype line\n"
 681                      "'%s'",
 682                      irq,
 683                      (ULONG) *tool_types );
 684                 return FALSE;
 685               }
 686               else
 687               {
 688                 struct ISAPNP_IRQResource* r;
 689
 690                 r = (struct ISAPNP_IRQResource*)
 691                     ISAPNP_AllocResource( ISAPNP_NT_IRQ_RESOURCE, res );
 692
 693                 if( r == NULL )
 694                 {
 695                   Req( "Out of memory!" );
 696                   return FALSE;
 697                 }
 698
 699                 r->isapnpirqr_IRQMask = 1 << irq;
 700                 r->isapnpirqr_IRQType = ISAPNP_IRQRESOURCE_ITF_HIGH_EDGE;
 701
 702                 AddTail( (struct List*) &dev->isapnpd_Options->isapnprg_Resources,
 703                          (struct Node*) r );
 704               }
 705             }
 706             else if( Strnicmp( str, "DMA=", 4 ) == 0 )
 707             {
 708               int dma;
 709
 710               dma = strtol( str + 4, (char**) &str, 0 );
 711
 712               if( dma <= 0 || dma >= 8 )
 713               {
 714                 Req( "Invalid DMA value '%ld' in tooltype line\n"
 715                      "'%s'",
 716                      dma,
 717                      (ULONG) *tool_types );
 718                 return FALSE;
 719               }
 720               else
 721               {
 722                 struct ISAPNP_DMAResource* r;
 723
 724                 r = (struct ISAPNP_DMAResource*)
 725                     ISAPNP_AllocResource( ISAPNP_NT_DMA_RESOURCE, res );
 726
 727                 if( r == NULL )
 728                 {
 729                   Req( "Out of memory!" );
 730                   return FALSE;
 731                 }
 732
 733                 r->isapnpdmar_ChannelMask = 1 << dma;
 734                 r->isapnpdmar_Flags       = 0;
 735
 736                 AddTail( (struct List*) &dev->isapnpd_Options->isapnprg_Resources,
 737                          (struct Node*) r );
 738               }
 739             }
 740             else if( Strnicmp( str, "IO=", 3 ) == 0 )
 741             {
 742               int base;
 743               int length;
 744
 745               struct ISAPNP_IOResource* r;
 746
 747               base = strtol( str + 3, (char**) &str, 0 );
 748
 749               if( *str != '/' )
 750               {
 751                 Req( "Length missing from IO value in tooltype line\n"
 752                      "'%s'",
 753                      (ULONG) *tool_types );
 754                 return FALSE;
 755               }
 756
 757               ++str;
 758
 759               length = strtol( str, (char**) &str, 0 );
 760
 761               if( base <= 0 || base >= 0xffff )
 762               {
 763                 Req( "Invalid IO base value '%ld' in tooltype line\n"
 764                      "'%s'",
 765                      base,
 766                      (ULONG) *tool_types );
 767                 return FALSE;
 768               }
 769
 770               if( length <= 0 || length >= 0xffff )
 771               {
 772                 Req( "Invalid IO length value '%ld' in tooltype line\n"
 773                      "'%s'",
 774                      length,
 775                      (ULONG) *tool_types );
 776                 return FALSE;
 777               }
 778
 779               r = (struct ISAPNP_IOResource*)
 780                   ISAPNP_AllocResource( ISAPNP_NT_IO_RESOURCE, res );
 781
 782               if( r == NULL )
 783               {
 784                 Req( "Out of memory!" );
 785                 return FALSE;
 786               }
 787
 788               r->isapnpior_MinBase   = base;
 789               r->isapnpior_MaxBase   = base;
 790               r->isapnpior_Length    = length;
 791               r->isapnpior_Alignment = 1;
 792
 793               AddTail( (struct List*) &dev->isapnpd_Options->isapnprg_Resources,
 794                        (struct Node*) r );
 795             }
 796             else
 797             {
 798               Req( "Parse error near '%s'\n"
 799                    "in tooltype line\n"
 800                    "'%s'",
 801                    (ULONG) str,
 802                    (ULONG) *tool_types );
 803               return FALSE;
 804             }
 805           }
 806
 807           if( *str )
 808           {
 809             ++str;
 810           }
 811         }
 812       }
 813       else
 814       {
 815         Req( "Illegal tool type: '%s'\n", (ULONG) *tool_types );
 816         return FALSE;
 817       }
 818     }
 819     else
 820     {
 821       // Ignore unknown tool types
 822     }
 823
 824     ++tool_types;
 825   }
 826
 827   return TRUE;
 828 }
 829 */
 830 /******************************************************************************
 831 ** Fix cards that have broken PnP ROMs ****************************************
 832 ******************************************************************************/
 833
 834 static BOOL
 835 PatchBrokenCards( struct ISAPNPBase* res )
 836 {
 837   struct ISAPNP_Device* dev = NULL;
 838
 839   // Patch the wavetable device on SB AWE32 and AWE64
 840
 841   while( ( dev = ISAPNP_FindDevice( dev,
 842                                     ISAPNP_MAKE_ID('C','T','L'),
 843                                     0x002,
 844                                     1,
 845                                     res ) ) != NULL )
 846   {
 847     struct ISAPNP_ResourceGroup* rg;
 848     struct ISAPNP_IOResource*    r1;
 849     struct ISAPNP_IOResource*    r2;
 850     struct ISAPNP_IOResource*    r3;
 851
 852     // Nuke all dependent options
 853
 854     while( ( rg = (struct ISAPNP_ResourceGroup*)
 855                   RemHead( (struct List*) &dev->isapnpd_Options->isapnprg_ResourceGroups ) )
 856            != NULL )
 857     {
 858       ISAPNP_FreeResourceGroup( rg, res );
 859     }
 860
 861     rg = ISAPNP_AllocResourceGroup( ISAPNP_RG_PRI_ACCEPTABLE, res );
 862
 863     r1 = (struct ISAPNP_IOResource*) ISAPNP_AllocResource( ISAPNP_NT_IO_RESOURCE, res );
 864     r2 = (struct ISAPNP_IOResource*) ISAPNP_AllocResource( ISAPNP_NT_IO_RESOURCE, res );
 865     r3 = (struct ISAPNP_IOResource*) ISAPNP_AllocResource( ISAPNP_NT_IO_RESOURCE, res );
 866
 867     if( rg == NULL || r1 == NULL || r2 == NULL || r3 == NULL )
 868     {
 869       ISAPNP_FreeResourceGroup( rg, res );
 870       ISAPNP_FreeResource( (struct ISAPNP_Resource*) r1, res );
 871       ISAPNP_FreeResource( (struct ISAPNP_Resource*) r2, res );
 872       ISAPNP_FreeResource( (struct ISAPNP_Resource*) r3, res );
 873
 874       return FALSE;
 875     }
 876
 877     r1->isapnpior_Flags = ISAPNP_IORESOURCE_FF_FULL_DECODE;
 878     r2->isapnpior_Flags = ISAPNP_IORESOURCE_FF_FULL_DECODE;
 879     r3->isapnpior_Flags = ISAPNP_IORESOURCE_FF_FULL_DECODE;
 880
 881     r1->isapnpior_Alignment = 1;
 882     r2->isapnpior_Alignment = 1;
 883     r3->isapnpior_Alignment = 1;
 884
 885     r1->isapnpior_Length = 4;
 886     r2->isapnpior_Length = 4;
 887     r3->isapnpior_Length = 4;
 888
 889     r1->isapnpior_MinBase = 0x620;
 890     r2->isapnpior_MinBase = 0xa20;
 891     r3->isapnpior_MinBase = 0xe20;
 892
 893     r1->isapnpior_MaxBase = 0x620;
 894     r2->isapnpior_MaxBase = 0xa20;
 895     r3->isapnpior_MaxBase = 0xe20;
 896
 897     AddTail( (struct List*) &rg->isapnprg_Resources, (struct Node*) r1 );
 898     AddTail( (struct List*) &rg->isapnprg_Resources, (struct Node*) r2 );
 899     AddTail( (struct List*) &rg->isapnprg_Resources, (struct Node*) r3 );
 900
 901     AddTail( (struct List*) &dev->isapnpd_Options->isapnprg_ResourceGroups,
 902              (struct Node*) rg );
 903   }
 904
 905   return TRUE;
 906 }