rom/isapnp/pnp.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-2013 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 AROS_LH0(BOOL, ISAPNP_ScanCards,
 707          struct ISAPNPBase *, res, 26, ISAPNP)
 708 {
 709   AROS_LIBFUNC_INIT
 710
 711   int read_port_value;
 712   int cards = 0;
 713
 714   SendInitiationKey( res );
 715
 716   // Make all cards lose their CSN
 717
 718   SetPnPReg( PNPISA_REG_CONFIG_CONTROL,
 719              PNPISA_CCF_RESET_CSN,
 720              res );
 721
 722   for( read_port_value = 0x80;
 723        read_port_value <= 0xff;
 724        read_port_value += 0x10 )
 725   {
 726     cards = AddCards( read_port_value, res );
 727
 728     if( cards > 0 )
 729     {
 730       break;
 731     }
 732   }
 733
 734   // Reset all cards
 735 /*
 736   SetPnPReg( PNPISA_REG_CONFIG_CONTROL,
 737              PNPISA_CCF_RESET        |
 738              PNPISA_CCF_WAIT_FOR_KEY |
 739              PNPISA_CCF_RESET_CSN,
 740              res );
 741 */
 742   return cards != 0;
 743
 744   AROS_LIBFUNC_EXIT
 745 }
 746
 747
 748 /******************************************************************************
 749 ** Configure all cards ********************************************************
 750 ******************************************************************************/
 751
 752
 753 static BOOL
 754 FindNextCardConfiguration( struct ISAPNP_Device*   dev,
 755                            struct ResourceContext* ctx,
 756                            struct ISAPNPBase*      res );
 757
 758
 759 int cp = 0;
 760
 761 static BOOL
 762 FindConfiguration( struct ISAPNP_Device*   dev,
 763                    struct ResourceContext* ctx,
 764                    struct ISAPNPBase*      res )
 765 {
 766   BOOL rc = FALSE;
 767
 768   struct ISAPNP_ResourceGroup* rg;
 769   struct ResourceIteratorList* ril = NULL;
 770
 771   if( dev->isapnpd_Disabled || dev->isapnpd_Card->isapnpc_Disabled )
 772   {
 773     // Skip to next device
 774
 775     return FindNextCardConfiguration( dev, ctx, res );
 776   }
 777
 778   ril = AllocResourceIteratorList( &dev->isapnpd_Options->isapnprg_Resources, ctx );
 779
 780   if( ril != NULL )
 781   {
 782     BOOL ril_iter_ok = TRUE;
 783
 784     while( ! rc && ril_iter_ok )
 785     {
 786       if( dev->isapnpd_Options->isapnprg_ResourceGroups.mlh_Head->mln_Succ != NULL )
 787       {
 788         // Handle resource options as well
 789
 790         for( rg = (struct ISAPNP_ResourceGroup*)
 791                   dev->isapnpd_Options->isapnprg_ResourceGroups.mlh_Head;
 792              ! rc && rg->isapnprg_MinNode.mln_Succ != NULL;
 793              rg = (struct ISAPNP_ResourceGroup*) rg->isapnprg_MinNode.mln_Succ )
 794         {
 795           struct ResourceIteratorList* ril_option = NULL;
 796
 797           ril_option = AllocResourceIteratorList( &rg->isapnprg_Resources, ctx );
 798
 799           if( ril_option != NULL )
 800           {
 801             BOOL ril2_iter_ok = TRUE;
 802
 803             while( ! rc && ril2_iter_ok )
 804             {
 805               rc = FindNextCardConfiguration( dev, ctx, res );
 806
 807 //if( cp > 2 ) return FALSE; else ++cp;
 808
 809               if( ! rc )
 810               {
 811                 ril2_iter_ok = IncResourceIteratorList( ril_option, ctx );
 812               }
 813               else
 814               {
 815                 // Allocate resources for current iterators
 816
 817                 rc = CreateResouces( ril_option,
 818                                      (struct List*) &dev->isapnpd_Resources,
 819                                      res );
 820                 break;
 821               }
 822             }
 823
 824             if( ! FreeResourceIteratorList( ril_option, ctx ) )
 825             {
 826               break;
 827             }
 828           }
 829         }
 830       }
 831       else
 832       {
 833         // Fixed resources only
 834
 835         rc = FindNextCardConfiguration( dev, ctx, res );
 836       }
 837
 838       if( ! rc )
 839       {
 840         ril_iter_ok = IncResourceIteratorList( ril, ctx );
 841       }
 842       else
 843       {
 844         // Allocate resources for current iterators
 845
 846         // NOTE! These resources muct be FIRST in the resource list
 847         // in order to maintain the descriptor order.
 848
 849         struct MinList tmp;
 850         struct Node*   n;
 851
 852         NewList( (struct List* ) &tmp );
 853
 854         rc = CreateResouces( ril, (struct List*) &tmp,
 855                              res );
 856
 857         while( ( n = RemTail( (struct List* ) &tmp ) ) != NULL )
 858         {
 859           AddHead( (struct List*) &dev->isapnpd_Resources, n );
 860         }
 861
 862         break;
 863       }
 864     }
 865
 866     FreeResourceIteratorList( ril, ctx );
 867   }
 868
 869   return rc;
 870 }
 871
 872
 873 static BOOL
 874 FindNextCardConfiguration( struct ISAPNP_Device*   dev,
 875                            struct ResourceContext* ctx,
 876                            struct ISAPNPBase*      res )
 877 {
 878   BOOL rc = FALSE;
 879
 880   // Configure next logical device, if any
 881
 882   if( dev->isapnpd_Node.ln_Succ->ln_Succ != NULL )
 883   {
 884     // Same card, next device
 885     rc = FindConfiguration( (struct ISAPNP_Device*) dev->isapnpd_Node.ln_Succ,
 886                             ctx, res );
 887   }
 888   else
 889   {
 890     struct ISAPNP_Card* next_card = (struct ISAPNP_Card*)
 891                                     dev->isapnpd_Card->isapnpc_Node.ln_Succ;
 892
 893     if( next_card->isapnpc_Node.ln_Succ != NULL &&
 894         next_card->isapnpc_Devices.lh_Head->ln_Succ != NULL )
 895
 896     {
 897       rc = FindConfiguration( (struct ISAPNP_Device*)
 898                               next_card->isapnpc_Devices.lh_Head,
 899                               ctx, res );
 900     }
 901     else
 902     {
 903       // This was the last device on the last card!
 904
 905       rc = TRUE;
 906     }
 907   }
 908
 909   return rc;
 910 }
 911
 912
 913 BOOL
 914 ProgramConfiguration( struct ISAPNPBase* res )
 915 {
 916   struct ISAPNP_Device* dev = NULL;
 917
 918   UBYTE csn     = 0;
 919
 920   while( ( dev = ISAPNP_FindDevice( dev, -1, -1, -1, res ) ) != NULL )
 921   {
 922     struct ISAPNP_Resource* resource;
 923
 924     UBYTE mem_reg = PNPISA_REG_MEMORY_BASE_ADDRESS_HIGH_0;
 925     UBYTE io_reg  = PNPISA_REG_IO_PORT_BASE_ADDRESS_HIGH_0;
 926     UBYTE int_reg = PNPISA_REG_INTERRUPT_REQUEST_LEVEL_SELECT_0;
 927     UBYTE dma_reg = PNPISA_REG_DMA_CHANNEL_SELECT_0;
 928
 929     if( dev->isapnpd_Card->isapnpc_CSN != 0 )
 930     {
 931       // Don't program non-pnp devices!
 932
 933       if( dev->isapnpd_Card->isapnpc_CSN != csn )
 934       {
 935         csn = dev->isapnpd_Card->isapnpc_CSN;
 936
 937         // Wake the new card
 938
 939         D(bug( "Woke up card %ld\n", dev->isapnpd_Card->isapnpc_CSN ));
 940         SetPnPReg( PNPISA_REG_WAKE, dev->isapnpd_Card->isapnpc_CSN, res );
 941       }
 942
 943       // Select logical device
 944
 945       D(bug( "Selected device %ld\n", dev->isapnpd_DeviceNumber ));
 946       SetPnPReg( PNPISA_REG_LOGICAL_DEVICE_NUMBER, dev->isapnpd_DeviceNumber, res );
 947
 948       for( resource = (struct ISAPNP_Resource*) dev->isapnpd_Resources.mlh_Head;
 949            resource->isapnpr_MinNode.mln_Succ != NULL;
 950            resource = (struct ISAPNP_Resource*) resource->isapnpr_MinNode.mln_Succ )
 951       {
 952         switch( resource->isapnpr_Type )
 953         {
 954           case ISAPNP_NT_IRQ_RESOURCE:
 955           {
 956             struct ISAPNP_IRQResource* r = (struct ISAPNP_IRQResource*) resource;
 957             int                        b;
 958
 959             for( b = 0; b < 16; ++b )
 960             {
 961               if( r->isapnpirqr_IRQMask & ( 1 << b ) )
 962               {
 963                 D(bug( "Programmed interrupt %ld in %lx\n", b, int_reg ));
 964                 SetPnPReg( int_reg, b, res);
 965                 break;
 966               }
 967             }
 968
 969             b = 0;
 970
 971             if( ( r->isapnpirqr_IRQType & ISAPNP_IRQRESOURCE_ITF_HIGH_EDGE ) ||
 972                 ( r->isapnpirqr_IRQType & ISAPNP_IRQRESOURCE_ITF_HIGH_LEVEL ) )
 973             {
 974               b |= 2;
 975             }
 976
 977             if( ( r->isapnpirqr_IRQType & ISAPNP_IRQRESOURCE_ITF_HIGH_LEVEL ) ||
 978                 ( r->isapnpirqr_IRQType & ISAPNP_IRQRESOURCE_ITF_LOW_LEVEL ) )
 979             {
 980               b |= 1;
 981             }
 982
 983             D(bug( "Programmed interrupt mode %ld in %lx\n", b, int_reg + 1 ));
 984             SetPnPReg( int_reg + 1, b, res );
 985
 986             int_reg += 2;
 987
 988             break;
 989           }
 990
 991           case ISAPNP_NT_DMA_RESOURCE:
 992           {
 993             struct ISAPNP_DMAResource* r = (struct ISAPNP_DMAResource*) resource;
 994             int                        b;
 995
 996             for( b = 0; b < 8; ++b )
 997             {
 998               if( r->isapnpdmar_ChannelMask & ( 1 << b ) )
 999               {
1000                 D(bug( "Programmed dma channel %ld in %lx\n", b, dma_reg ));
1001                 SetPnPReg( dma_reg, b, res );
1002                 break;
1003               }
1004             }
1005
1006             dma_reg += 1;
1007
1008             break;
1009           }
1010
1011           case ISAPNP_NT_IO_RESOURCE:
1012           {
1013             struct ISAPNP_IOResource* r = (struct ISAPNP_IOResource*) resource;
1014
1015             D(bug( "Programmed IO base %04lx in %lx\n", r->isapnpior_MinBase, io_reg ));
1016
1017             SetPnPReg( io_reg, r->isapnpior_MinBase >> 8, res );
1018             SetPnPReg( io_reg + 1, r->isapnpior_MinBase & 0xff, res );
1019
1020             io_reg += 2;
1021
1022             break;
1023           }
1024
1025           default:
1026             bug( "Unsupported resource!\n" );
1027             return FALSE;
1028         }
1029       }
1030
1031       // Activate the device
1032       D(bug( "Activated the device\n" ));
1033       SetPnPReg( PNPISA_REG_ACTIVATE, 1, res );
1034     }
1035   }
1036
1037   // Move all cards to the wfk state
1038
1039   D(bug( "Moved cards to wfk\n" ));
1040
1041   SetPnPReg( PNPISA_REG_CONFIG_CONTROL,
1042              PNPISA_CCF_WAIT_FOR_KEY,
1043              res );
1044
1045   return TRUE;
1046 }
1047
1048
1049 AROS_LH0(BOOL, ISAPNP_ConfigureCards,
1050          struct ISAPNPBase *, res, 27, ISAPNP)
1051 {
1052   AROS_LIBFUNC_INIT
1053
1054   BOOL rc = FALSE;
1055
1056   struct ISAPNP_Device* dev;
1057
1058   dev = ISAPNP_FindDevice( NULL, -1, -1, -1, res );
1059
1060   if( dev != NULL )
1061   {
1062     struct ResourceContext* ctx;
1063
1064     ctx = AllocResourceIteratorContext();
1065
1066     if( ctx != NULL )
1067     {
1068       if( ! FindConfiguration( dev, ctx, res ) )
1069       {
1070           D(bug( "Unable to find a usable configuration.\n" ));
1071       }
1072       else
1073       {
1074         if( ! ProgramConfiguration( res ) )
1075         {
1076             D(bug( "Failed to program configuration!\n" ));
1077         }
1078         else
1079         {
1080           rc = TRUE;
1081         }
1082       }
1083
1084       FreeResourceIteratorContext( ctx );
1085     }
1086   }
1087
1088   return rc;
1089
1090   AROS_LIBFUNC_EXIT
1091 }