rom/isapnp/pnp_iterators.c

   1
   2 /* $Id: pnp_iterators.c,v 1.6 2001/05/07 12:32:42 lcs Exp $ */
   3
   4 /*
   5      ISA-PnP -- A Plug And Play ISA software layer for AmigaOS.
   6      Copyright (C) 2001 Martin Blom <martin@blom.org>
   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 #include "CompilerSpecific.h"
  25
  26 #include <exec/memory.h>
  27
  28 #include <clib/alib_protos.h>
  29 #include <proto/exec.h>
  30
  31 #include <resources/isapnp.h>
  32 #include "init.h"
  33 #include "pnp_iterators.h"
  34 #include "pnp_structs.h"
  35 #include "isapnp_private.h"
  36
  37
  38 struct ResourceIterator
  39 {
  40   struct MinNode          m_MinNode;
  41   struct ISAPNP_Resource* m_Resource;
  42   UBYTE                   m_IRQBit;
  43   UBYTE                   m_ChannelBit;
  44   UWORD                   m_Base;
  45   UWORD                   m_Length;
  46   BOOL                    m_HasLock;
  47   BOOL                    m_InConflict;
  48 };
  49
  50
  51 #undef DEBUG_ITERATORS
  52
  53 struct ResourceIteratorList
  54 {
  55   struct MinList m_ResourceIterators;
  56 };
  57
  58
  59 struct ResourceIteratorRef
  60 {
  61   struct MinNode           m_MinNode;
  62   struct ResourceIterator* m_Iterator;
  63 };
  64
  65
  66 struct ResourceContext
  67 {
  68   struct ResourceIterator* m_IRQ[ 16 ];
  69   struct ResourceIterator* m_DMA[ 8 ];
  70   struct MinList           m_IO;
  71 };
  72
  73
  74 static struct ResourceIterator*
  75 AllocResourceIterator( struct ISAPNP_Resource* resource,
  76                        struct ResourceContext* ctx );
  77
  78 static BOOL
  79 FreeResourceIterator( struct ResourceIterator* iter,
  80                        struct ResourceContext* ctx );
  81
  82 static BOOL
  83 IncResourceIterator( struct ResourceIterator* iter,
  84                      struct ResourceContext*  ctx );
  85
  86
  87 /******************************************************************************
  88 ** Allocate a clean resource iterator context *********************************
  89 ******************************************************************************/
  90
  91 struct ResourceContext*
  92 AllocResourceIteratorContext( void )
  93 {
  94   struct ResourceContext* ctx;
  95
  96   ctx = AllocVec( sizeof( *ctx ), MEMF_PUBLIC | MEMF_CLEAR );
  97
  98   if( ctx != NULL )
  99   {
 100     NewList( (struct List*) &ctx->m_IO );
 101   }
 102
 103   return ctx;
 104 }
 105
 106
 107 /******************************************************************************
 108 ** Free a resource iterator context *******************************************
 109 ******************************************************************************/
 110
 111 void
 112 FreeResourceIteratorContext( struct ResourceContext* ctx )
 113 {
 114   struct ResourceIteratorRef* ref;
 115
 116   if( ctx == NULL )
 117   {
 118     return;
 119   }
 120
 121   while( ( ref = (struct ResourceIteratorRef*)
 122                  RemHead( (struct List*) &ctx->m_IO ) ) )
 123   {
 124     FreeVec( ref );
 125   }
 126
 127   FreeVec( ctx );
 128 }
 129
 130
 131 /******************************************************************************
 132 ** Lock resources from the context ********************************************
 133 ******************************************************************************/
 134
 135 static BOOL
 136 LockResource( struct ResourceIterator* iter,
 137               struct ResourceContext*  ctx )
 138 {
 139   struct ResourceIterator* conflict = NULL;
 140
 141   switch( iter->m_Resource->isapnpr_Type )
 142   {
 143     case ISAPNP_NT_IRQ_RESOURCE:
 144     {
 145 #ifdef DEBUG_ITERATORS
 146 KPrintF( "L IRQ %ld", iter->m_IRQBit );
 147 #endif
 148       if( ctx->m_IRQ[ iter->m_IRQBit ] == NULL )
 149       {
 150         ctx->m_IRQ[ iter->m_IRQBit ] = iter;
 151       }
 152       else
 153       {
 154         conflict = ctx->m_IRQ[ iter->m_IRQBit ];
 155       }
 156
 157       break;
 158     }
 159
 160
 161     case ISAPNP_NT_DMA_RESOURCE:
 162     {
 163 #ifdef DEBUG_ITERATORS
 164 KPrintF( "L DMA %ld", iter->m_ChannelBit );
 165 #endif
 166       if( ctx->m_DMA[ iter->m_ChannelBit ] == NULL )
 167       {
 168         ctx->m_DMA[ iter->m_ChannelBit ] = iter;
 169       }
 170       else
 171       {
 172         conflict = ctx->m_DMA[ iter->m_ChannelBit ];
 173       }
 174
 175       break;
 176     }
 177
 178
 179     case ISAPNP_NT_IO_RESOURCE:
 180     {
 181       struct ResourceIteratorRef* io;
 182       struct ResourceIteratorRef* new_io;
 183       struct Node*                position = NULL;
 184
 185       UWORD base   = iter->m_Base;
 186       UWORD length = iter->m_Length;
 187
 188 #ifdef DEBUG_ITERATORS
 189 KPrintF( "L IO %lx-%lx", base, base + length );
 190 #endif
 191
 192       for( io = (struct ResourceIteratorRef*) ctx->m_IO.mlh_Head;
 193            io->m_MinNode.mln_Succ != NULL;
 194            io = (struct ResourceIteratorRef*) io->m_MinNode.mln_Succ )
 195       {
 196         UWORD io_base   = io->m_Iterator->m_Base;
 197         UWORD io_length = io->m_Iterator->m_Length;
 198
 199         if( ( base <= io_base && ( base + length ) > io_base )    ||
 200             ( base >= io_base && base < ( io_base + io_length ) ) )
 201         {
 202           // Collision!
 203
 204           conflict = io->m_Iterator;
 205           break;
 206         }
 207
 208         if( base + length <= io_base )
 209         {
 210           // No more collisions possible; insert before this one
 211
 212           position = (struct Node*) io->m_MinNode.mln_Pred;
 213
 214           break;
 215         }
 216       }
 217
 218       if( conflict == NULL )
 219       {
 220         // Insert the node
 221
 222         new_io = AllocVec( sizeof( *new_io ), MEMF_PUBLIC );
 223
 224         if( new_io == NULL )
 225         {
 226           return FALSE;
 227         }
 228         else
 229         {
 230           new_io->m_Iterator = iter;
 231
 232           if( position == NULL )
 233           {
 234             AddTail( (struct List*) &ctx->m_IO, (struct Node*) new_io );
 235           }
 236           else
 237           {
 238             Insert( (struct List*) &ctx->m_IO, (struct Node*) new_io, position );
 239           }
 240         }
 241       }
 242
 243       break;
 244     }
 245
 246     case ISAPNP_NT_MEMORY_RESOURCE:
 247     default:
 248       break;
 249   }
 250
 251   if( conflict != NULL )
 252   {
 253     conflict->m_InConflict = TRUE;
 254     iter->m_HasLock = FALSE;
 255   }
 256   else
 257   {
 258     iter->m_HasLock = TRUE;
 259   }
 260
 261 #ifdef DEBUG_ITERATORS
 262 if( iter->m_HasLock ) KPrintF( " OK\n" ); else KPrintF( " failed\n" );
 263 #endif
 264
 265   return iter->m_HasLock;
 266 }
 267
 268
 269 /******************************************************************************
 270 ** Unlock resources from the context ******************************************
 271 ******************************************************************************/
 272
 273 static void
 274 UnlockResource( struct ResourceIterator* iter,
 275                 struct ResourceContext*  ctx )
 276 {
 277   if( ! iter->m_HasLock )
 278   {
 279     return;
 280   }
 281
 282   switch( iter->m_Resource->isapnpr_Type )
 283   {
 284     case ISAPNP_NT_IRQ_RESOURCE:
 285     {
 286 #ifdef DEBUG_ITERATORS
 287 KPrintF( "U IRQ %ld\n", iter->m_IRQBit );
 288 #endif
 289       ctx->m_IRQ[ iter->m_IRQBit ] = NULL;
 290
 291       break;
 292     }
 293
 294
 295     case ISAPNP_NT_DMA_RESOURCE:
 296     {
 297 #ifdef DEBUG_ITERATORS
 298 KPrintF( "U DMA %ld\n", iter->m_ChannelBit );
 299 #endif
 300       ctx->m_DMA[ iter->m_ChannelBit ] = NULL;
 301
 302       break;
 303     }
 304
 305
 306     case ISAPNP_NT_IO_RESOURCE:
 307     {
 308       struct ResourceIteratorRef* io;
 309
 310 #ifdef DEBUG_ITERATORS
 311 KPrintF( "U IO %lx-%lx\n", iter->m_Base,
 312          iter->m_Base + iter->m_Length );
 313 #endif
 314
 315       for( io = (struct ResourceIteratorRef*) ctx->m_IO.mlh_Head;
 316            io->m_MinNode.mln_Succ != NULL;
 317            io = (struct ResourceIteratorRef*) io->m_MinNode.mln_Succ )
 318       {
 319         if( io->m_Iterator->m_Base == iter->m_Base )
 320         {
 321           Remove( (struct Node*) io );
 322           FreeVec( io );
 323           break;
 324         }
 325       }
 326
 327       break;
 328     }
 329
 330     case ISAPNP_NT_MEMORY_RESOURCE:
 331     default:
 332       break;
 333   }
 334
 335   iter->m_HasLock = FALSE;
 336 }
 337
 338
 339 /******************************************************************************
 340 ** Reset a resource iterator **************************************************
 341 ******************************************************************************/
 342
 343 static BOOL
 344 ResetResourceIterator( struct ResourceIterator* iter,
 345                        struct ResourceContext*  ctx )
 346 {
 347   BOOL rc = FALSE;
 348
 349   switch( iter->m_Resource->isapnpr_Type )
 350   {
 351     case ISAPNP_NT_IRQ_RESOURCE:
 352     {
 353       struct ISAPNP_IRQResource* r;
 354
 355       r = (struct ISAPNP_IRQResource*) iter->m_Resource;
 356
 357       iter->m_IRQBit = 0;
 358
 359       while( iter->m_IRQBit < 16 )
 360       {
 361         if( r->isapnpirqr_IRQMask & ( 1 << iter->m_IRQBit ) )
 362         {
 363           if( LockResource( iter, ctx ) )
 364           {
 365             rc = TRUE;
 366             break;
 367           }
 368         }
 369
 370         ++iter->m_IRQBit;
 371       }
 372
 373       break;
 374     }
 375
 376
 377     case ISAPNP_NT_DMA_RESOURCE:
 378     {
 379       struct ISAPNP_DMAResource* r;
 380
 381       r = (struct ISAPNP_DMAResource*) iter->m_Resource;
 382
 383       iter->m_ChannelBit = 0;
 384
 385       while( iter->m_ChannelBit < 8 )
 386       {
 387         if( r->isapnpdmar_ChannelMask & ( 1 << iter->m_ChannelBit ) )
 388         {
 389           if( LockResource( iter, ctx ) )
 390           {
 391             rc = TRUE;
 392             break;
 393           }
 394         }
 395
 396         ++iter->m_ChannelBit;
 397       }
 398
 399       break;
 400     }
 401
 402
 403     case ISAPNP_NT_IO_RESOURCE:
 404     {
 405       struct ISAPNP_IOResource* r;
 406
 407       r = (struct ISAPNP_IOResource*) iter->m_Resource;
 408
 409       iter->m_Base   = r->isapnpior_MinBase;
 410       iter->m_Length = r->isapnpior_Length;
 411
 412
 413       while( iter->m_Base <= r->isapnpior_MaxBase )
 414       {
 415         if( LockResource( iter, ctx ) )
 416         {
 417           rc = TRUE;
 418           break;
 419         }
 420
 421         iter->m_Base += r->isapnpior_Alignment;
 422       }
 423
 424       break;
 425     }
 426
 427     case ISAPNP_NT_MEMORY_RESOURCE:
 428     default:
 429       break;
 430   }
 431
 432   return rc;
 433 }
 434
 435
 436 /******************************************************************************
 437 ** Allocate a resource iterator ***********************************************
 438 ******************************************************************************/
 439
 440 static struct ResourceIterator*
 441 AllocResourceIterator( struct ISAPNP_Resource* resource,
 442                        struct ResourceContext* ctx )
 443 {
 444   struct ResourceIterator* iter;
 445
 446   iter = AllocVec( sizeof( *iter ), MEMF_PUBLIC | MEMF_CLEAR );
 447
 448   if( iter != NULL )
 449   {
 450     iter->m_Resource = resource;
 451
 452     if( ! ResetResourceIterator( iter, ctx ) )
 453     {
 454       FreeResourceIterator( iter, ctx );
 455       iter = NULL;
 456     }
 457   }
 458
 459   return iter;
 460 }
 461
 462
 463 /******************************************************************************
 464 ** Deallocate a resource iterator *********************************************
 465 ******************************************************************************/
 466
 467 static BOOL
 468 FreeResourceIterator( struct ResourceIterator* iter,
 469                       struct ResourceContext* ctx )
 470 {
 471   BOOL rc = FALSE;
 472
 473   if( iter == NULL )
 474   {
 475     return FALSE;
 476   }
 477
 478   UnlockResource( iter, ctx );
 479
 480   rc = iter->m_InConflict;
 481
 482   FreeVec( iter );
 483
 484   return rc;
 485 }
 486
 487
 488 /******************************************************************************
 489 ** Allocate a resource iterator list ******************************************
 490 ******************************************************************************/
 491
 492 // This function cannot handle conflicts within the list itself
 493
 494 struct ResourceIteratorList*
 495 AllocResourceIteratorList( struct MinList*         resource_list,
 496                            struct ResourceContext* ctx )
 497 {
 498   struct ResourceIteratorList* result;
 499
 500 #ifdef DEBUG_ITERATORS
 501 KPrintF( "AllocResourceIteratorList()\n" );
 502 #endif
 503
 504   result = AllocVec( sizeof( *result ), MEMF_PUBLIC | MEMF_CLEAR );
 505
 506   if( result != NULL )
 507   {
 508     struct ISAPNP_Resource* r;
 509
 510     NewList( (struct List*) &result->m_ResourceIterators );
 511
 512     r = (struct ISAPNP_Resource*) resource_list->mlh_Head;
 513
 514     while( r->isapnpr_MinNode.mln_Succ != NULL )
 515     {
 516       struct ResourceIterator* iter;
 517
 518       iter = AllocResourceIterator( r, ctx );
 519
 520       if( iter == NULL )
 521       {
 522         FreeResourceIteratorList( result, ctx );
 523         result = NULL;
 524         break;
 525       }
 526
 527       AddTail( (struct List*) &result->m_ResourceIterators,
 528                (struct Node*) iter );
 529
 530       r = (struct ISAPNP_Resource*) r->isapnpr_MinNode.mln_Succ;
 531     }
 532   }
 533
 534 #ifdef DEBUG_ITERATORS
 535 if( result ) KPrintF( "AllocResourceIteratorList() succeeded\n" );
 536 else KPrintF( "AllocResourceIteratorList() failed\n" );
 537 #endif
 538
 539   return result;
 540 }
 541
 542
 543 /******************************************************************************
 544 ** Deallocate a resource iterator list ****************************************
 545 ******************************************************************************/
 546
 547 BOOL
 548 FreeResourceIteratorList( struct ResourceIteratorList* list,
 549                           struct ResourceContext*      ctx )
 550 {
 551   BOOL rc = FALSE;
 552
 553   struct ResourceIterator* iter;
 554
 555 #ifdef DEBUG_ITERATORS
 556 KPrintF( "FreeResourceIteratorList()\n" );
 557 #endif
 558
 559   if( list == NULL )
 560   {
 561     return FALSE;
 562   }
 563
 564   while( ( iter = (struct ResourceIterator*)
 565                   RemHead( (struct List*) &list->m_ResourceIterators ) ) )
 566   {
 567     if( FreeResourceIterator( iter, ctx ) )
 568     {
 569       rc = TRUE;
 570     }
 571   }
 572
 573   FreeVec( list );
 574
 575 #ifdef DEBUG_ITERATORS
 576 if( rc ) KPrintF( "FreeResourceIteratorList() T\n" );
 577 else KPrintF( "FreeResourceIteratorList() F\n" );
 578 #endif
 579
 580   return rc;
 581 }
 582
 583
 584 /******************************************************************************
 585 ** Increase a resource iterator ***********************************************
 586 ******************************************************************************/
 587
 588 static BOOL
 589 IncResourceIterator( struct ResourceIterator* iter,
 590                      struct ResourceContext*  ctx )
 591 {
 592   BOOL rc = FALSE;
 593
 594   UnlockResource( iter, ctx );
 595
 596   switch( iter->m_Resource->isapnpr_Type )
 597   {
 598     case ISAPNP_NT_IRQ_RESOURCE:
 599     {
 600       struct ISAPNP_IRQResource* r;
 601
 602       r = (struct ISAPNP_IRQResource*) iter->m_Resource;
 603
 604       while( ! rc && iter->m_IRQBit < 16 )
 605       {
 606         ++iter->m_IRQBit;
 607
 608         if( r->isapnpirqr_IRQMask & ( 1 << iter->m_IRQBit ) )
 609         {
 610           rc = LockResource( iter, ctx );
 611         }
 612       }
 613
 614       break;
 615     }
 616
 617     case ISAPNP_NT_DMA_RESOURCE:
 618     {
 619       struct ISAPNP_DMAResource* r;
 620
 621       r = (struct ISAPNP_DMAResource*) iter->m_Resource;
 622
 623       while( ! rc && iter->m_ChannelBit < 8 )
 624       {
 625         ++iter->m_ChannelBit;
 626
 627         if( r->isapnpdmar_ChannelMask & ( 1 << iter->m_ChannelBit ) )
 628         {
 629           rc = LockResource( iter, ctx );
 630         }
 631       }
 632
 633       break;
 634     }
 635
 636     case ISAPNP_NT_IO_RESOURCE:
 637     {
 638       struct ISAPNP_IOResource* r;
 639
 640       r = (struct ISAPNP_IOResource*) iter->m_Resource;
 641
 642       while( ! rc && iter->m_Base <= r->isapnpior_MaxBase )
 643       {
 644         iter->m_Base += r->isapnpior_Alignment;
 645
 646         if( iter->m_Base <= r->isapnpior_MaxBase )
 647         {
 648           rc = LockResource( iter, ctx );
 649         }
 650       }
 651
 652       break;
 653     }
 654
 655     case ISAPNP_NT_MEMORY_RESOURCE:
 656     default:
 657       break;;
 658   }
 659
 660   return rc;
 661 }
 662
 663
 664 /******************************************************************************
 665 ** Increase a resource iterator list ******************************************
 666 ******************************************************************************/
 667
 668 BOOL
 669 IncResourceIteratorList( struct ResourceIteratorList* iter_list,
 670                          struct ResourceContext*      ctx )
 671 {
 672   BOOL                     rc = FALSE;
 673   struct ResourceIterator* current;
 674
 675 #ifdef DEBUG_ITERATORS
 676 KPrintF( "IncResourceIteratorList()\n" );
 677 #endif
 678
 679   current = (struct ResourceIterator*) iter_list->m_ResourceIterators.mlh_Head;
 680
 681   while( ! rc && current->m_MinNode.mln_Succ != NULL )
 682   {
 683     if( current->m_InConflict )
 684     {
 685       rc = IncResourceIterator( current, ctx );
 686     }
 687     else
 688     {
 689       // This iterator is not in conflict. There is no need to
 690       // try any more combinations
 691
 692       UnlockResource( current, ctx );
 693     }
 694
 695     if( ! rc )
 696     {
 697       ResetResourceIterator( current, ctx );
 698
 699       current = (struct ResourceIterator*) current->m_MinNode.mln_Succ;
 700     }
 701   }
 702
 703 #ifdef DEBUG_ITERATORS
 704 KPrintF( "IncResourceIteratorList(): %ld\n", rc );
 705 #endif
 706
 707   return rc;
 708 }
 709
 710
 711 /******************************************************************************
 712 ** Create a resource from an iterator *****************************************
 713 ******************************************************************************/
 714
 715 struct ISAPNP_Resource*
 716 CreateResource( struct ResourceIterator* iter,
 717                 struct ISAPNPBase*       res )
 718 {
 719   struct ISAPNP_Resource* result = NULL;
 720
 721   result = ISAPNP_AllocResource( iter->m_Resource->isapnpr_Type, res );
 722
 723   if( result == NULL )
 724   {
 725     return NULL;
 726   }
 727
 728   switch( iter->m_Resource->isapnpr_Type )
 729   {
 730     case ISAPNP_NT_IRQ_RESOURCE:
 731     {
 732       struct ISAPNP_IRQResource* r;
 733
 734       r = (struct ISAPNP_IRQResource*) result;
 735
 736       // Make a copy of the iterators resource
 737
 738       CopyMem( iter->m_Resource, r, sizeof( *r ) );
 739       r->isapnpirqr_MinNode.mln_Succ = NULL;
 740       r->isapnpirqr_MinNode.mln_Pred = NULL;
 741
 742       r->isapnpirqr_IRQMask = 1 << iter->m_IRQBit;
 743
 744       break;
 745     }
 746
 747     case ISAPNP_NT_DMA_RESOURCE:
 748     {
 749       struct ISAPNP_DMAResource* r;
 750
 751       r = (struct ISAPNP_DMAResource*) result;
 752
 753       // Make a copy of the iterators resource
 754
 755       CopyMem( iter->m_Resource, r, sizeof( *r ) );
 756       r->isapnpdmar_MinNode.mln_Succ = NULL;
 757       r->isapnpdmar_MinNode.mln_Pred = NULL;
 758
 759       r->isapnpdmar_ChannelMask = 1 << iter->m_ChannelBit;
 760
 761       break;
 762     }
 763
 764     case ISAPNP_NT_IO_RESOURCE:
 765     {
 766       struct ISAPNP_IOResource* r;
 767
 768       r = (struct ISAPNP_IOResource*) result;
 769
 770       // Make a copy of the iterators resource
 771
 772       CopyMem( iter->m_Resource, r, sizeof( *r ) );
 773       r->isapnpior_MinNode.mln_Succ = NULL;
 774       r->isapnpior_MinNode.mln_Pred = NULL;
 775
 776       r->isapnpior_MinBase   = iter->m_Base;
 777       r->isapnpior_MaxBase   = iter->m_Base;
 778       r->isapnpior_Alignment = 1;
 779
 780       break;
 781     }
 782
 783     case ISAPNP_NT_MEMORY_RESOURCE:
 784     default:
 785       ISAPNP_FreeResource( result, res );
 786       result = NULL;
 787       break;;
 788   }
 789
 790   return result;
 791 }
 792
 793
 794 /******************************************************************************
 795 ** Create resources from a list of iterators **********************************
 796 ******************************************************************************/
 797
 798 BOOL
 799 CreateResouces( struct ResourceIteratorList* ril,
 800                 struct List*                 result,
 801                 struct ISAPNPBase*           res )
 802 {
 803   // Allocate resources for current iterators
 804
 805   struct ResourceIterator* iter;
 806
 807   for( iter = (struct ResourceIterator*)
 808               ril->m_ResourceIterators.mlh_Head;
 809        iter->m_MinNode.mln_Succ != NULL;
 810        iter = (struct ResourceIterator*)
 811               iter->m_MinNode.mln_Succ )
 812   {
 813     struct ISAPNP_Resource* resource;
 814
 815     resource = CreateResource( iter, res );
 816
 817     if( resource == NULL )
 818     {
 819       return FALSE;
 820     }
 821
 822     AddTail( result, (struct Node*) resource );
 823   }
 824
 825   return TRUE;
 826 }