rom/isapnp/pnp.c

   1 /* $Id: pnp.c,v 1.20 2001/05/10 14:07:27 lcs Exp $ */
   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
  30 #include <clib/alib_protos.h>
  31 #include <proto/exec.h>
  32 #include <proto/timer.h>
  33
  34 #include <resources/isapnp.h>
  35 #include "isapnp_private.h"
  36
  37 #include "pnpisa.h"
  38
  39 #include "controller.h"
  40 #include "devices.h"
  41 #include "init.h"
  42 #include "pnp.h"
  43 #include "pnp_iterators.h"
  44 #include "pnp_structs.h"
  45
  46
  47 /******************************************************************************
  48 ** PnP ISA helper functions ***************************************************
  49 ******************************************************************************/
  50
  51 static UBYTE
  52 GetPnPReg( UBYTE              pnp_reg,
  53            struct ISAPNPBase* res )
  54 {
  55   ISAC_SetRegByte( PNPISA_ADDRESS, pnp_reg, res );
  56
  57   return ISAC_GetRegByte( ( res->m_RegReadData << 2 ) | 3, res );
  58 }
  59
  60
  61 static UBYTE
  62 GetLastPnPReg( struct ISAPNPBase* res )
  63 {
  64   return ISAC_GetRegByte( ( res->m_RegReadData << 2 ) | 3, res );
  65 }
  66
  67
  68 static void
  69 SetPnPReg( UBYTE              pnp_reg,
  70            UBYTE              value,
  71            struct ISAPNPBase* res )
  72 {
  73   ISAC_SetRegByte( PNPISA_ADDRESS,    pnp_reg, res );
  74   ISAC_SetRegByte( PNPISA_WRITE_DATA, value,   res );
  75 }
  76
  77
  78 static UBYTE
  79 GetNextResourceData( struct ISAPNPBase* res )
  80 {
  81   // Poll for data
  82   while( ( GetPnPReg( PNPISA_REG_STATUS, res ) & PNPISA_SF_AVAILABLE ) == 0 );
  83
  84   return GetPnPReg( PNPISA_REG_RESOURCE_DATA, res );
  85
  86 }
  87
  88
  89 static void
  90 BusyWait( ULONG micro_seconds )
  91 {
  92   typedef unsigned long long uint64_t;
  93
  94   ULONG            freq;
  95   struct EClockVal eclock;
  96   uint64_t         current;
  97   uint64_t         end;
  98
  99   freq = ReadEClock( &eclock );
 100
 101   current = ( ( (uint64_t) eclock.ev_hi ) << 32 ) + eclock.ev_lo;
 102   end     = current + (uint64_t) freq * micro_seconds / 1000000;
 103
 104   while( current < end )
 105   {
 106     ReadEClock( &eclock );
 107
 108     current = ( ( (uint64_t) eclock.ev_hi ) << 32 ) + eclock.ev_lo;
 109   }
 110 }
 111
 112
 113 static BOOL
 114 DecodeID( UBYTE* buf, struct ISAPNP_Identifier* id )
 115 {
 116   // Decode information
 117
 118   if( buf[ 0 ] & 0x80 )
 119   {
 120     return FALSE;
 121   }
 122
 123   id->isapnpid_Vendor[ 0 ]  = 0x40 + ( buf[ 0 ] >> 2 );
 124   id->isapnpid_Vendor[ 1 ]  = 0x40 + ( ( ( buf[ 0 ] & 0x03 ) << 3 ) |
 125                                        ( buf[ 1 ] >> 5 ) );
 126   id->isapnpid_Vendor[ 2 ]  = 0x40 + ( buf[ 1 ] & 0x1f );
 127   id->isapnpid_Vendor[ 3 ]  = 0;
 128
 129   id->isapnpid_ProductID    = ( buf[ 2 ] << 4 ) | ( buf[ 3 ] >> 4 );
 130   id->isapnpid_Revision     = buf[ 3 ] & 0x0f;
 131
 132   return TRUE;
 133 }
 134
 135
 136 /******************************************************************************
 137 ** Move all cards to Sleep state **********************************************
 138 ******************************************************************************/
 139
 140 static void
 141 SendInitiationKey( struct ISAPNPBase* res )
 142 {
 143   static const UBYTE key[] =
 144   {
 145     PNPISA_INITIATION_KEY
 146   };
 147
 148   unsigned int i;
 149
 150   // Make sure the LFSR is in its initial state
 151
 152   ISAC_SetRegByte( PNPISA_ADDRESS, 0, res );
 153   ISAC_SetRegByte( PNPISA_ADDRESS, 0, res );
 154
 155   for( i = 0; i < sizeof( key ); ++i )
 156   {
 157     ISAC_SetRegByte( PNPISA_ADDRESS, key[ i ], res );
 158   }
 159 }
 160
 161
 162 /******************************************************************************
 163 ** Read the serial identifier from a card *************************************
 164 ******************************************************************************/
 165
 166 static BOOL
 167 ReadSerialIdentifier( struct ISAPNP_Card* card,
 168                       struct ISAPNPBase*  res )
 169 {
 170   UBYTE buf[ 9 ] = { 0, 0, 0, 0, 0, 0, 0, 0, 0 };
 171   int   i;
 172   UBYTE check_sum;
 173
 174   ISAC_SetRegByte( PNPISA_ADDRESS, PNPISA_REG_SERIAL_ISOLATION, res );
 175
 176   // Wait 1 ms before we read the first pair
 177
 178   BusyWait( 1000 );
 179
 180   check_sum = 0x6a;
 181
 182   for( i = 0; i < 72; ++i )
 183   {
 184     UBYTE value1;
 185     UBYTE value2;
 186
 187     value1 = GetLastPnPReg( res );
 188     value2 = GetLastPnPReg( res );
 189
 190     if( value1 == 0x55 && value2 == 0xaa )
 191     {
 192       buf[ i >> 3 ] |= ( 1 << ( i & 7 ) );
 193     }
 194
 195     if( i < 64 )
 196     {
 197       UBYTE bitten = value1 == 0x55 && value2 == 0xaa ? 1 : 0;
 198
 199       check_sum = PNPISA_LFSR( check_sum, bitten );
 200     }
 201
 202     // Wait 250 µs before we read the next pair
 203
 204     BusyWait( 250 );
 205   }
 206
 207   if( check_sum != buf[ 8 ] )
 208   {
 209     return FALSE;
 210   }
 211
 212   if( ! DecodeID( buf, &card->isapnpc_ID ) )
 213   {
 214     return FALSE;
 215   }
 216
 217   card->isapnpc_SerialNumber = ( buf[ 7 ] << 25 ) |
 218                                ( buf[ 6 ] << 16 ) |
 219                                ( buf[ 5 ] << 8 )  |
 220                                  buf[ 4 ];
 221
 222   return TRUE;
 223 }
 224
 225
 226 /******************************************************************************
 227 ** Read the resource data from a card *****************************************
 228 ******************************************************************************/
 229
 230 static BOOL
 231 ReadResourceData( struct ISAPNP_Card* card,
 232                   struct ISAPNPBase*  res )
 233 {
 234   UBYTE                        check_sum     = 0;
 235   UWORD                        dev_num       = 0;
 236   BOOL                         read_more     = TRUE;
 237   struct ISAPNP_Device*        dev           = NULL;
 238   struct ISAPNP_ResourceGroup* options       = NULL;
 239   struct ISAPNP_ResourceGroup* saved_options = NULL;
 240
 241   while( read_more )
 242   {
 243     ULONG i;
 244     UBYTE rd;
 245
 246     UBYTE name;
 247     ULONG length;
 248
 249     rd = GetNextResourceData( res );
 250
 251     check_sum += rd;
 252
 253     if( rd & PNPISA_RDF_LARGE )
 254     {
 255       name    = PNPISA_RD_LARGE_ITEM_NAME( rd );
 256       length  = GetNextResourceData( res );
 257       length |= GetNextResourceData( res ) << 8;
 258     }
 259     else
 260     {
 261       name   = PNPISA_RD_SMALL_ITEM_NAME( rd );
 262       length = PNPISA_RD_SMALL_LENGTH( rd );
 263     }
 264
 265     switch( name )
 266     {
 267       case PNPISA_RDN_PNP_VERSION:
 268       {
 269         UBYTE ver;
 270
 271         ver = GetNextResourceData( res );
 272
 273         card->isapnpc_MinorPnPVersion  = ver & 0x0f;
 274         card->isapnpc_MajorPnPVersion  = ver >> 4;
 275         card->isapnpc_VendorPnPVersion = GetNextResourceData( res );
 276
 277         length -= 2;
 278         break;
 279       }
 280
 281       case PNPISA_RDN_LOGICAL_DEVICE_ID:
 282       {
 283         struct ISAPNP_Identifier* id;
 284         UBYTE                     buf[ 4 ];
 285
 286         dev = ISAPNP_AllocDevice( res );
 287
 288         if( dev == NULL )
 289         {
 290           break;
 291         }
 292
 293         dev->isapnpd_Card = card;
 294
 295         id  = AllocVec( sizeof( *id ), MEMF_PUBLIC | MEMF_CLEAR );
 296
 297         if( id == NULL )
 298         {
 299           ISAPNP_FreeDevice( dev, res );
 300           dev = NULL;
 301           break;
 302         }
 303
 304         buf[ 0 ] = GetNextResourceData( res );
 305         buf[ 1 ] = GetNextResourceData( res );
 306         buf[ 2 ] = GetNextResourceData( res );
 307         buf[ 3 ] = GetNextResourceData( res );
 308
 309         length -= 4;
 310
 311         if( ! DecodeID( buf, id ) )
 312         {
 313           FreeVec( id );
 314           ISAPNP_FreeDevice( dev, res );
 315           dev = NULL;
 316           break;
 317         }
 318
 319         AddTail( (struct List*) &dev->isapnpd_IDs, (struct Node*) id );
 320
 321         options = dev->isapnpd_Options;
 322
 323         dev->isapnpd_SupportedCommands = GetNextResourceData( res );
 324         --length;
 325
 326         if( length > 0 )
 327         {
 328           dev->isapnpd_SupportedCommands |= GetNextResourceData( res ) << 8;
 329         }
 330
 331         dev->isapnpd_DeviceNumber = dev_num;
 332         ++dev_num;
 333
 334         AddTail( &card->isapnpc_Devices, (struct Node*) dev );
 335
 336         break;
 337       }
 338
 339
 340       case PNPISA_RDN_COMPATIBLE_DEVICE_ID:
 341       {
 342         struct ISAPNP_Identifier* id;
 343         UBYTE                     buf[ 4 ];
 344
 345         if( dev == NULL )
 346         {
 347           break;
 348         }
 349
 350         id  = AllocVec( sizeof( *id ), MEMF_PUBLIC | MEMF_CLEAR );
 351
 352         if( id == NULL )
 353         {
 354           break;
 355         }
 356
 357         buf[ 0 ] = GetNextResourceData( res );
 358         buf[ 1 ] = GetNextResourceData( res );
 359         buf[ 2 ] = GetNextResourceData( res );
 360         buf[ 3 ] = GetNextResourceData( res );
 361
 362         length -= 4;
 363
 364         if( ! DecodeID( buf, id ) )
 365         {
 366           FreeVec( id );
 367           break;
 368         }
 369
 370         AddTail( (struct List*) &dev->isapnpd_IDs, (struct Node*) id );
 371
 372         break;
 373       }
 374
 375       case PNPISA_RDN_IRQ_FORMAT:
 376       {
 377         struct ISAPNP_IRQResource* r;
 378
 379         r = (struct ISAPNP_IRQResource*)
 380             ISAPNP_AllocResource( ISAPNP_NT_IRQ_RESOURCE, res );
 381
 382         if( r == NULL )
 383         {
 384           break;
 385         }
 386
 387         r->isapnpirqr_IRQMask  = GetNextResourceData( res );
 388         r->isapnpirqr_IRQMask |= GetNextResourceData( res ) << 8;
 389         length -= 2;
 390
 391         if( length > 0 )
 392         {
 393           r->isapnpirqr_IRQType = GetNextResourceData( res );
 394           --length;
 395         }
 396         else
 397         {
 398           r->isapnpirqr_IRQType = ISAPNP_IRQRESOURCE_ITF_HIGH_EDGE;
 399         }
 400
 401         AddTail( (struct List*) &options->isapnprg_Resources, (struct Node*) r );
 402
 403         break;
 404       }
 405
 406
 407       case PNPISA_RDN_DMA_FORMAT:
 408       {
 409         struct ISAPNP_DMAResource* r;
 410
 411         r = (struct ISAPNP_DMAResource*)
 412             ISAPNP_AllocResource( ISAPNP_NT_DMA_RESOURCE, res );
 413
 414         if( r == NULL )
 415         {
 416           break;
 417         }
 418
 419         r->isapnpdmar_ChannelMask = GetNextResourceData( res );
 420         r->isapnpdmar_Flags       = GetNextResourceData( res );
 421
 422         length -= 2;
 423
 424         AddTail( (struct List*) &options->isapnprg_Resources, (struct Node*) r );
 425
 426         break;
 427       }
 428
 429       case PNPISA_RDN_START_DF:
 430       {
 431         struct ISAPNP_ResourceGroup* rg;
 432         UBYTE  pri;
 433
 434         if( length > 0 )
 435         {
 436           pri = GetNextResourceData( res );
 437           --length;
 438         }
 439         else
 440         {
 441           pri = 1;
 442         }
 443
 444         switch( pri )
 445         {
 446           case 0:
 447             pri = ISAPNP_RG_PRI_GOOD;
 448             break;
 449
 450           case 1:
 451           default:
 452             pri = ISAPNP_RG_PRI_ACCEPTABLE;
 453             break;
 454
 455           case 2:
 456             pri = ISAPNP_RG_PRI_SUBOPTIMAL;
 457             break;
 458         }
 459
 460         rg = ISAPNP_AllocResourceGroup( pri, res );
 461
 462         if( rg == NULL )
 463         {
 464           break;
 465         }
 466
 467         // Insert in priority order
 468
 469         if( saved_options == NULL )
 470         {
 471           saved_options = options;
 472         }
 473
 474         Enqueue( (struct List*) &saved_options->isapnprg_ResourceGroups,
 475                  (struct Node*) rg );
 476
 477         options = rg;
 478
 479         break;
 480       }
 481
 482
 483       case PNPISA_RDN_END_DF:
 484       {
 485         options       = saved_options;
 486         saved_options = NULL;
 487
 488         break;
 489       }
 490
 491       case PNPISA_RDN_IO_PORT:
 492       {
 493         struct ISAPNP_IOResource* r;
 494
 495         r = (struct ISAPNP_IOResource*)
 496             ISAPNP_AllocResource( ISAPNP_NT_IO_RESOURCE, res );
 497
 498         if( r == NULL )
 499         {
 500           break;
 501         }
 502
 503         r->isapnpior_Flags      = GetNextResourceData( res );
 504
 505         r->isapnpior_MinBase    = GetNextResourceData( res );
 506         r->isapnpior_MinBase   |= GetNextResourceData( res ) << 8;
 507
 508         r->isapnpior_MaxBase    = GetNextResourceData( res );
 509         r->isapnpior_MaxBase   |= GetNextResourceData( res ) << 8;
 510
 511         r->isapnpior_Alignment  = GetNextResourceData( res );
 512         r->isapnpior_Length     = GetNextResourceData( res );
 513
 514         length -= 7;
 515
 516         AddTail( (struct List*) &options->isapnprg_Resources, (struct Node*) r );
 517
 518         break;
 519       }
 520
 521
 522       case PNPISA_RDN_FIXED_IO_PORT:
 523       {
 524         struct ISAPNP_IOResource* r;
 525
 526         r = (struct ISAPNP_IOResource*)
 527             ISAPNP_AllocResource( ISAPNP_NT_IO_RESOURCE, res );
 528
 529         if( r == NULL )
 530         {
 531           break;
 532         }
 533
 534         r->isapnpior_Flags      = 0;
 535         r->isapnpior_MinBase    = GetNextResourceData( res );
 536         r->isapnpior_MinBase   |= GetNextResourceData( res ) << 8;
 537         r->isapnpior_MaxBase    = r->isapnpior_MinBase;
 538         r->isapnpior_Alignment  = 1;
 539         r->isapnpior_Length     = GetNextResourceData( res );
 540
 541         length -= 3;
 542
 543         AddTail( (struct List*) &options->isapnprg_Resources, (struct Node*) r );
 544
 545         break;
 546       }
 547
 548
 549       case PNPISA_RDN_ANSI_IDENTIFIER:
 550       {
 551         STRPTR id = AllocVec( length + 1, MEMF_PUBLIC );
 552
 553         if( id == NULL )
 554         {
 555           break;
 556         }
 557
 558         // Attach identifier to either the card or the logical device
 559
 560         if( dev == NULL )
 561         {
 562           FreeVec( card->isapnpc_Node.ln_Name );
 563
 564           card->isapnpc_Node.ln_Name = id;
 565         }
 566         else
 567         {
 568           FreeVec( dev->isapnpd_Node.ln_Name );
 569
 570           dev->isapnpd_Node.ln_Name = id;
 571         }
 572
 573         while( length > 0 )
 574         {
 575           *id = GetNextResourceData( res );
 576
 577           ++id;
 578           --length;
 579         }
 580
 581         // Terminate the string
 582
 583         *id = '\0';
 584
 585         break;
 586       }
 587
 588
 589       case PNPISA_RDN_END_TAG:
 590       {
 591         UBYTE cs;
 592
 593         cs = GetNextResourceData( res );
 594         --length;
 595
 596         if( cs == 0 )
 597         {
 598           check_sum = 0;
 599         }
 600         else
 601         {
 602           check_sum += cs;
 603         }
 604
 605         read_more = FALSE;
 606         break;
 607       }
 608
 609
 610       default:
 611         bug( "UNKNOWN RESOURCE: %02lx, length %ld: ", name, length );
 612
 613         while( length > 0 )
 614         {
 615           bug( "%02lx ", GetNextResourceData( res ) );
 616           --length;
 617         }
 618
 619         bug( "\n" );
 620         break;
 621     }
 622
 623     // Make sure we have read all data for this name
 624
 625     while( length > 0 )
 626     {
 627       bug( "*** " );
 628       GetNextResourceData( res );
 629       --length;
 630     }
 631   }
 632
 633   D(bug( "Check sum: %ld\n", check_sum ));
 634
 635   return TRUE;
 636 }
 637
 638
 639 /******************************************************************************
 640 ** Assign a CSN to all cards and build the card/device database ***************
 641 ******************************************************************************/
 642
 643 static ULONG
 644 AddCards( UBYTE              rd_data_port_value,
 645           struct ISAPNPBase* res )
 646 {
 647   UBYTE csn = 0;
 648
 649   while( TRUE )
 650   {
 651     struct ISAPNP_Card* card;
 652
 653     // Move all cards (without a CSN) to the isolate state and the card
 654     // in config state to the sleep state.
 655
 656     SetPnPReg( PNPISA_REG_WAKE, 0, res );
 657
 658     // Set port to read from
 659
 660     SetPnPReg( PNPISA_REG_SET_RD_DATA_PORT, rd_data_port_value, res );
 661     res->m_RegReadData = rd_data_port_value;
 662
 663     card = ISAPNP_AllocCard( res );
 664
 665     if( card == NULL )
 666     {
 667       break;
 668     }
 669
 670     if( ReadSerialIdentifier( card, res ) )
 671     {
 672       // Assign a CSN to the card and move it to the config state
 673
 674       ++csn;
 675       SetPnPReg( PNPISA_REG_CARD_SELECT_NUMBER, csn, res );
 676
 677       // Read the resource data
 678
 679       if( ReadResourceData( card, res ) )
 680       {
 681         card->isapnpc_CSN = csn;
 682
 683         AddTail( &res->m_Cards, (struct Node*) card );
 684       }
 685       else
 686       {
 687         ISAPNP_FreeCard( card, res );
 688       }
 689     }
 690     else
 691     {
 692       ISAPNP_FreeCard( card, res );
 693
 694       break;
 695     }
 696   }
 697
 698   return csn;
 699 }
 700
 701
 702 /******************************************************************************
 703 ** Scan for all PNP ISA cards *************************************************
 704 ******************************************************************************/
 705
 706 BOOL ASMCALL
 707 ISAPNP_ScanCards( REG( a6, struct ISAPNPBase* res ) )
 708 {
 709   int read_port_value;
 710   int cards = 0;
 711
 712   SendInitiationKey( res );
 713
 714   // Make all cards lose their CSN
 715
 716   SetPnPReg( PNPISA_REG_CONFIG_CONTROL,
 717              PNPISA_CCF_RESET_CSN,
 718              res );
 719
 720   for( read_port_value = 0x80;
 721        read_port_value <= 0xff;
 722        read_port_value += 0x10 )
 723   {
 724     cards = AddCards( read_port_value, res );
 725
 726     if( cards > 0 )
 727     {
 728       break;
 729     }
 730   }
 731
 732   // Reset all cards
 733 /*
 734   SetPnPReg( PNPISA_REG_CONFIG_CONTROL,
 735              PNPISA_CCF_RESET        |
 736              PNPISA_CCF_WAIT_FOR_KEY |
 737              PNPISA_CCF_RESET_CSN,
 738              res );
 739 */
 740   return cards != 0;
 741 }
 742
 743
 744 /******************************************************************************
 745 ** Configure all cards ********************************************************
 746 ******************************************************************************/
 747
 748
 749 static BOOL
 750 FindNextCardConfiguration( struct ISAPNP_Device*   dev,
 751                            struct ResourceContext* ctx,
 752                            struct ISAPNPBase*      res );
 753
 754
 755 int cp = 0;
 756
 757 static BOOL
 758 FindConfiguration( struct ISAPNP_Device*   dev,
 759                    struct ResourceContext* ctx,
 760                    struct ISAPNPBase*      res )
 761 {
 762   BOOL rc = FALSE;
 763
 764   struct ISAPNP_ResourceGroup* rg;
 765   struct ResourceIteratorList* ril = NULL;
 766
 767   if( dev->isapnpd_Disabled || dev->isapnpd_Card->isapnpc_Disabled )
 768   {
 769     // Skip to next device
 770
 771     return FindNextCardConfiguration( dev, ctx, res );
 772   }
 773
 774   ril = AllocResourceIteratorList( &dev->isapnpd_Options->isapnprg_Resources, ctx );
 775
 776   if( ril != NULL )
 777   {
 778     BOOL ril_iter_ok = TRUE;
 779
 780     while( ! rc && ril_iter_ok )
 781     {
 782       if( dev->isapnpd_Options->isapnprg_ResourceGroups.mlh_Head->mln_Succ != NULL )
 783       {
 784         // Handle resource options as well
 785
 786         for( rg = (struct ISAPNP_ResourceGroup*)
 787                   dev->isapnpd_Options->isapnprg_ResourceGroups.mlh_Head;
 788              ! rc && rg->isapnprg_MinNode.mln_Succ != NULL;
 789              rg = (struct ISAPNP_ResourceGroup*) rg->isapnprg_MinNode.mln_Succ )
 790         {
 791           struct ResourceIteratorList* ril_option = NULL;
 792
 793           ril_option = AllocResourceIteratorList( &rg->isapnprg_Resources, ctx );
 794
 795           if( ril_option != NULL )
 796           {
 797             BOOL ril2_iter_ok = TRUE;
 798
 799             while( ! rc && ril2_iter_ok )
 800             {
 801               rc = FindNextCardConfiguration( dev, ctx, res );
 802
 803 //if( cp > 2 ) return FALSE; else ++cp;
 804
 805               if( ! rc )
 806               {
 807                 ril2_iter_ok = IncResourceIteratorList( ril_option, ctx );
 808               }
 809               else
 810               {
 811                 // Allocate resources for current iterators
 812
 813                 rc = CreateResouces( ril_option,
 814                                      (struct List*) &dev->isapnpd_Resources,
 815                                      res );
 816                 break;
 817               }
 818             }
 819
 820             if( ! FreeResourceIteratorList( ril_option, ctx ) )
 821             {
 822               break;
 823             }
 824           }
 825         }
 826       }
 827       else
 828       {
 829         // Fixed resources only
 830
 831         rc = FindNextCardConfiguration( dev, ctx, res );
 832       }
 833
 834       if( ! rc )
 835       {
 836         ril_iter_ok = IncResourceIteratorList( ril, ctx );
 837       }
 838       else
 839       {
 840         // Allocate resources for current iterators
 841
 842         // NOTE! These resources muct be FIRST in the resource list
 843         // in order to maintain the descriptor order.
 844
 845         struct MinList tmp;
 846         struct Node*   n;
 847
 848         NewList( (struct List* ) &tmp );
 849
 850         rc = CreateResouces( ril, (struct List*) &tmp,
 851                              res );
 852
 853         while( ( n = RemTail( (struct List* ) &tmp ) ) != NULL )
 854         {
 855           AddHead( (struct List*) &dev->isapnpd_Resources, n );
 856         }
 857
 858         break;
 859       }
 860     }
 861
 862     FreeResourceIteratorList( ril, ctx );
 863   }
 864
 865   return rc;
 866 }
 867
 868
 869 static BOOL
 870 FindNextCardConfiguration( struct ISAPNP_Device*   dev,
 871                            struct ResourceContext* ctx,
 872                            struct ISAPNPBase*      res )
 873 {
 874   BOOL rc = FALSE;
 875
 876   // Configure next logical device, if any
 877
 878   if( dev->isapnpd_Node.ln_Succ->ln_Succ != NULL )
 879   {
 880     // Same card, next device
 881     rc = FindConfiguration( (struct ISAPNP_Device*) dev->isapnpd_Node.ln_Succ,
 882                             ctx, res );
 883   }
 884   else
 885   {
 886     struct ISAPNP_Card* next_card = (struct ISAPNP_Card*)
 887                                     dev->isapnpd_Card->isapnpc_Node.ln_Succ;
 888
 889     if( next_card->isapnpc_Node.ln_Succ != NULL &&
 890         next_card->isapnpc_Devices.lh_Head->ln_Succ != NULL )
 891
 892     {
 893       rc = FindConfiguration( (struct ISAPNP_Device*)
 894                               next_card->isapnpc_Devices.lh_Head,
 895                               ctx, res );
 896     }
 897     else
 898     {
 899       // This was the last device on the last card!
 900
 901       rc = TRUE;
 902     }
 903   }
 904
 905   return rc;
 906 }
 907
 908
 909 BOOL
 910 ProgramConfiguration( struct ISAPNPBase* res )
 911 {
 912   struct ISAPNP_Device* dev = NULL;
 913
 914   UBYTE csn     = 0;
 915
 916   while( ( dev = ISAPNP_FindDevice( dev, -1, -1, -1, res ) ) != NULL )
 917   {
 918     struct ISAPNP_Resource* resource;
 919
 920     UBYTE mem_reg = PNPISA_REG_MEMORY_BASE_ADDRESS_HIGH_0;
 921     UBYTE io_reg  = PNPISA_REG_IO_PORT_BASE_ADDRESS_HIGH_0;
 922     UBYTE int_reg = PNPISA_REG_INTERRUPT_REQUEST_LEVEL_SELECT_0;
 923     UBYTE dma_reg = PNPISA_REG_DMA_CHANNEL_SELECT_0;
 924
 925     if( dev->isapnpd_Card->isapnpc_CSN != 0 )
 926     {
 927       // Don't program non-pnp devices!
 928
 929       if( dev->isapnpd_Card->isapnpc_CSN != csn )
 930       {
 931         csn = dev->isapnpd_Card->isapnpc_CSN;
 932
 933         // Wake the new card
 934
 935         D(bug( "Woke up card %ld\n", dev->isapnpd_Card->isapnpc_CSN ));
 936         SetPnPReg( PNPISA_REG_WAKE, dev->isapnpd_Card->isapnpc_CSN, res );
 937       }
 938
 939       // Select logical device
 940
 941       D(bug( "Selected device %ld\n", dev->isapnpd_DeviceNumber ));
 942       SetPnPReg( PNPISA_REG_LOGICAL_DEVICE_NUMBER, dev->isapnpd_DeviceNumber, res );
 943
 944       for( resource = (struct ISAPNP_Resource*) dev->isapnpd_Resources.mlh_Head;
 945            resource->isapnpr_MinNode.mln_Succ != NULL;
 946            resource = (struct ISAPNP_Resource*) resource->isapnpr_MinNode.mln_Succ )
 947       {
 948         switch( resource->isapnpr_Type )
 949         {
 950           case ISAPNP_NT_IRQ_RESOURCE:
 951           {
 952             struct ISAPNP_IRQResource* r = (struct ISAPNP_IRQResource*) resource;
 953             int                        b;
 954
 955             for( b = 0; b < 16; ++b )
 956             {
 957               if( r->isapnpirqr_IRQMask & ( 1 << b ) )
 958               {
 959                 D(bug( "Programmed interrupt %ld in %lx\n", b, int_reg ));
 960                 SetPnPReg( int_reg, b, res);
 961                 break;
 962               }
 963             }
 964
 965             b = 0;
 966
 967             if( ( r->isapnpirqr_IRQType & ISAPNP_IRQRESOURCE_ITF_HIGH_EDGE ) ||
 968                 ( r->isapnpirqr_IRQType & ISAPNP_IRQRESOURCE_ITF_HIGH_LEVEL ) )
 969             {
 970               b |= 2;
 971             }
 972
 973             if( ( r->isapnpirqr_IRQType & ISAPNP_IRQRESOURCE_ITF_HIGH_LEVEL ) ||
 974                 ( r->isapnpirqr_IRQType & ISAPNP_IRQRESOURCE_ITF_LOW_LEVEL ) )
 975             {
 976               b |= 1;
 977             }
 978
 979             D(bug( "Programmed interrupt mode %ld in %lx\n", b, int_reg + 1 ));
 980             SetPnPReg( int_reg + 1, b, res );
 981
 982             int_reg += 2;
 983
 984             break;
 985           }
 986
 987           case ISAPNP_NT_DMA_RESOURCE:
 988           {
 989             struct ISAPNP_DMAResource* r = (struct ISAPNP_DMAResource*) resource;
 990             int                        b;
 991
 992             for( b = 0; b < 8; ++b )
 993             {
 994               if( r->isapnpdmar_ChannelMask & ( 1 << b ) )
 995               {
 996                 D(bug( "Programmed dma channel %ld in %lx\n", b, dma_reg ));
 997                 SetPnPReg( dma_reg, b, res );
 998                 break;
 999               }
1000             }
1001
1002             dma_reg += 1;
1003
1004             break;
1005           }
1006
1007           case ISAPNP_NT_IO_RESOURCE:
1008           {
1009             struct ISAPNP_IOResource* r = (struct ISAPNP_IOResource*) resource;
1010
1011             D(bug( "Programmed IO base %04lx in %lx\n", r->isapnpior_MinBase, io_reg ));
1012
1013             SetPnPReg( io_reg, r->isapnpior_MinBase >> 8, res );
1014             SetPnPReg( io_reg + 1, r->isapnpior_MinBase & 0xff, res );
1015
1016             io_reg += 2;
1017
1018             break;
1019           }
1020
1021           default:
1022             bug( "Unsupported resource!\n" );
1023             return FALSE;
1024         }
1025       }
1026
1027       // Activate the device
1028       D(bug( "Activated the device\n" ));
1029       SetPnPReg( PNPISA_REG_ACTIVATE, 1, res );
1030     }
1031   }
1032
1033   // Move all cards to the wfk state
1034
1035   D(bug( "Moved cards to wfk\n" ));
1036
1037   SetPnPReg( PNPISA_REG_CONFIG_CONTROL,
1038              PNPISA_CCF_WAIT_FOR_KEY,
1039              res );
1040
1041   return TRUE;
1042 }
1043
1044
1045 BOOL ASMCALL
1046 ISAPNP_ConfigureCards( REG( a6, struct ISAPNPBase* res ) )
1047 {
1048   BOOL rc = FALSE;
1049
1050   struct ISAPNP_Device* dev;
1051
1052   dev = ISAPNP_FindDevice( NULL, -1, -1, -1, res );
1053
1054   if( dev != NULL )
1055   {
1056     struct ResourceContext* ctx;
1057
1058     ctx = AllocResourceIteratorContext();
1059
1060     if( ctx != NULL )
1061     {
1062       if( ! FindConfiguration( dev, ctx, res ) )
1063       {
1064           D(bug( "Unable to find a usable configuration.\n" ));
1065       }
1066       else
1067       {
1068         if( ! ProgramConfiguration( res ) )
1069         {
1070             D(bug( "Failed to program configuration!\n" ));
1071         }
1072         else
1073         {
1074           rc = TRUE;
1075         }
1076       }
1077
1078       FreeResourceIteratorContext( ctx );
1079     }
1080   }
1081
1082   return rc;
1083 }