rom/isapnp/devices.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
   7      This library is free software; you can redistribute it and/or
   8      modify it under the terms of the GNU Library General Public
   9      License as published by the Free Software Foundation; either
  10      version 2 of the License, or (at your option) any later version.
  11
  12      This library is distributed in the hope that it will be useful,
  13      but WITHOUT ANY WARRANTY; without even the implied warranty of
  14      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15      Library General Public License for more details.
  16
  17      You should have received a copy of the GNU Library General Public
  18      License along with this library; if not, write to the
  19      Free Software Foundation, Inc., 59 Temple Place - Suite 330, Cambridge,
  20      MA 02139, USA.
  21 */
  22
  23 #include "CompilerSpecific.h"
  24
  25 #include <exec/memory.h>
  26
  27 #include <proto/exec.h>
  28
  29 #include <stdlib.h>
  30
  31 #include <resources/isapnp.h>
  32 #include "isapnp_private.h"
  33
  34
  35 /******************************************************************************
  36 ** Find a PNP ISA card  *******************************************************
  37 ******************************************************************************/
  38
  39 struct ISAPNP_Card* ASMCALL
  40 ISAPNP_FindCard( REG( a0, struct ISAPNP_Card* last_card ),
  41                  REG( d0, LONG                manufacturer ),
  42                  REG( d1, WORD                product ),
  43                  REG( d2, BYTE                revision ),
  44                  REG( d3, LONG                serial ),
  45                  REG( a6, struct ISAPNPBase*  res ) )
  46 {
  47   struct ISAPNP_Card* card;
  48
  49   if( last_card == NULL )
  50   {
  51     card = (struct ISAPNP_Card*) res->m_Cards.lh_Head;
  52   }
  53   else
  54   {
  55     card = (struct ISAPNP_Card*) last_card->isapnpc_Node.ln_Succ;
  56   }
  57
  58   while( card->isapnpc_Node.ln_Succ != NULL )
  59   {
  60     if( manufacturer == -1 ||
  61         ISAPNP_MAKE_ID( card->isapnpc_ID.isapnpid_Vendor[ 0 ],
  62                         card->isapnpc_ID.isapnpid_Vendor[ 1 ],
  63                         card->isapnpc_ID.isapnpid_Vendor[ 2 ] ) == manufacturer )
  64     {
  65       if( product == -1 || card->isapnpc_ID.isapnpid_ProductID == product )
  66       {
  67         if( revision == -1 || card->isapnpc_ID.isapnpid_Revision == revision )
  68         {
  69           if( serial == -1 || (LONG) card->isapnpc_SerialNumber == serial )
  70           {
  71             return card;
  72           }
  73         }
  74       }
  75     }
  76
  77     card = (struct ISAPNP_Card*) card->isapnpc_Node.ln_Succ;
  78   }
  79
  80   return NULL;
  81 }
  82
  83
  84 /******************************************************************************
  85 ** Find a PNP ISA device  *****************************************************
  86 ******************************************************************************/
  87
  88 struct ISAPNP_Device* ASMCALL
  89 ISAPNP_FindDevice( REG( a0, struct ISAPNP_Device* last_device ),
  90                    REG( d0, LONG                  manufacturer ),
  91                    REG( d1, WORD                  product ),
  92                    REG( d2, BYTE                  revision ),
  93                    REG( a6, struct ISAPNPBase*    res ) )
  94 {
  95   struct ISAPNP_Card*   card;
  96   struct ISAPNP_Device* dev;
  97
  98   if( last_device == NULL )
  99   {
 100     card = (struct ISAPNP_Card*) res->m_Cards.lh_Head;
 101     dev  = (struct ISAPNP_Device*) card->isapnpc_Devices.lh_Head;
 102   }
 103   else
 104   {
 105     card = (struct ISAPNP_Card*) last_device->isapnpd_Card;
 106     dev  = (struct ISAPNP_Device*) last_device->isapnpd_Node.ln_Succ;
 107   }
 108
 109   while( card->isapnpc_Node.ln_Succ != NULL )
 110   {
 111     while( dev->isapnpd_Node.ln_Succ != NULL )
 112     {
 113       struct ISAPNP_Identifier* id;
 114
 115       for( id = (struct ISAPNP_Identifier*) dev->isapnpd_IDs.mlh_Head;
 116            id->isapnpid_MinNode.mln_Succ != NULL;
 117            id = (struct ISAPNP_Identifier*) id->isapnpid_MinNode.mln_Succ )
 118       {
 119         if( manufacturer == -1 ||
 120             ISAPNP_MAKE_ID( id->isapnpid_Vendor[ 0 ],
 121                             id->isapnpid_Vendor[ 1 ],
 122                             id->isapnpid_Vendor[ 2 ] ) == manufacturer )
 123         {
 124           if( product == -1 || id->isapnpid_ProductID == product )
 125           {
 126             if( revision == -1 || id->isapnpid_Revision == revision )
 127             {
 128               return dev;
 129             }
 130           }
 131         }
 132       }
 133
 134       dev = (struct ISAPNP_Device*) dev->isapnpd_Node.ln_Succ;
 135     }
 136
 137     card = (struct ISAPNP_Card*) card->isapnpc_Node.ln_Succ;
 138     dev  = (struct ISAPNP_Device*) card->isapnpc_Devices.lh_Head;
 139   }
 140
 141   return NULL;
 142 }
 143
 144
 145
 146 /******************************************************************************
 147 ** Helper functions for the card/device locking functions *********************
 148 ******************************************************************************/
 149
 150 static int
 151 ComparePtr( const void* a,
 152             const void* b )
 153 {
 154   struct ISAPNP_Card* p1 = *( (struct ISAPNP_Card**) a );
 155   struct ISAPNP_Card* p2 = *( (struct ISAPNP_Card**) b );
 156
 157   return p1 - p2;
 158 }
 159
 160
 161 static void**
 162 MakeSortedArray( void** ptrs )
 163 {
 164   int    size;
 165   void** ptrs_ptr;
 166   void** result;
 167
 168   // Find number of pointers to sort
 169
 170   size      = 0;
 171   ptrs_ptr = ptrs;
 172
 173   while( *ptrs_ptr != NULL )
 174   {
 175     ++size;
 176     ++ptrs_ptr;
 177   }
 178
 179   result = AllocVec( sizeof( *ptrs_ptr ) * size + 1, MEMF_PUBLIC );
 180
 181   if( result != NULL )
 182   {
 183     ptrs_ptr = result;
 184
 185     while( *ptrs != NULL )
 186     {
 187       *ptrs_ptr = *ptrs;
 188       ++ptrs;
 189       ++ptrs_ptr;
 190     }
 191
 192     qsort( result, size, sizeof( *result ), ComparePtr );
 193
 194     result[ size ] = NULL;
 195   }
 196
 197   return result;
 198 }
 199
 200
 201 /******************************************************************************
 202 ** Lock one or more PNP ISA cards  ********************************************
 203 ******************************************************************************/
 204
 205 APTR ASMCALL
 206 ISAPNP_LockCardsA( REG( d0, ULONG                flags ),
 207                    REG( a0, struct ISAPNP_Card** cards ),
 208                    REG( a6, struct ISAPNPBase*   res ) )
 209 {
 210   struct ISAPNP_Card** cards_ptr;
 211   struct ISAPNP_Card** result;
 212
 213   result = (struct ISAPNP_Card**) MakeSortedArray( (void**) cards );
 214
 215   if( result != NULL )
 216   {
 217     for( cards_ptr = result;
 218          *cards_ptr != NULL;
 219          ++cards_ptr )
 220     {
 221       if( flags & ISAPNP_LOCKF_NONBLOCKING )
 222       {
 223         if( ! AttemptSemaphore( &(*cards_ptr)->isapnpc_Lock ) )
 224         {
 225           struct ISAPNP_Card** cards_end;
 226
 227           // Oops! Failed to lock one of the cards!
 228
 229           cards_end = cards_ptr;
 230
 231           for( cards_ptr = result;
 232                cards_ptr != cards_end;
 233                ++cards_ptr );
 234           {
 235             ReleaseSemaphore( &(*cards_ptr)->isapnpc_Lock );
 236           }
 237
 238           FreeVec( result );
 239           result = NULL;
 240           break;
 241         }
 242       }
 243       else
 244       {
 245         ObtainSemaphore( &(*cards_ptr)->isapnpc_Lock );
 246       }
 247     }
 248   }
 249
 250   return (APTR) result;
 251 }
 252
 253
 254 /******************************************************************************
 255 ** Unlock one or more PNP ISA cards  ******************************************
 256 ******************************************************************************/
 257
 258 void ASMCALL
 259 ISAPNP_UnlockCards( REG( a0, APTR               card_lock_handle ),
 260                     REG( a6, struct ISAPNPBase* res ) )
 261 {
 262   struct ISAPNP_Card** cards_ptr;
 263
 264   if( card_lock_handle == NULL )
 265   {
 266     return;
 267   }
 268
 269   for( cards_ptr = (struct ISAPNP_Card**) card_lock_handle;
 270        *cards_ptr != NULL;
 271        ++cards_ptr )
 272   {
 273     ReleaseSemaphore( &(*cards_ptr)->isapnpc_Lock );
 274   }
 275
 276   FreeVec( card_lock_handle );
 277 }
 278
 279
 280 /******************************************************************************
 281 ** Lock one or more PNP ISA devices *******************************************
 282 ******************************************************************************/
 283
 284 APTR ASMCALL
 285 ISAPNP_LockDevicesA( REG( d0, ULONG                  flags ),
 286                      REG( a0, struct ISAPNP_Device** devices ),
 287                      REG( a6, struct ISAPNPBase*     res ) )
 288 {
 289   struct ISAPNP_Device** devices_ptr;
 290   struct ISAPNP_Device** result;
 291
 292   result = (struct ISAPNP_Device**) MakeSortedArray( (void**) devices );
 293
 294   if( result != NULL )
 295   {
 296     for( devices_ptr = result;
 297          *devices_ptr != NULL;
 298          ++devices_ptr )
 299     {
 300       if( flags & ISAPNP_LOCKF_NONBLOCKING )
 301       {
 302         if( ! AttemptSemaphore( &(*devices_ptr)->isapnpd_Lock ) )
 303         {
 304           struct ISAPNP_Device** devices_end;
 305
 306           // Oops! Failed to lock one of the devices!
 307
 308           devices_end = devices_ptr;
 309
 310           for( devices_ptr = result;
 311                devices_ptr != devices_end;
 312                ++devices_ptr );
 313           {
 314             ReleaseSemaphore( &(*devices_ptr)->isapnpd_Lock );
 315           }
 316
 317           FreeVec( result );
 318           result = NULL;
 319           break;
 320         }
 321       }
 322       else
 323       {
 324         ObtainSemaphore( &(*devices_ptr)->isapnpd_Lock );
 325       }
 326     }
 327   }
 328
 329   return (APTR) result;
 330 }
 331
 332
 333 /******************************************************************************
 334 ** Unlock one or more PNP ISA devices  ****************************************
 335 ******************************************************************************/
 336
 337 void ASMCALL
 338 ISAPNP_UnlockDevices( REG( a0, APTR               device_lock_handle ),
 339                       REG( a6, struct ISAPNPBase* res ) )
 340 {
 341   struct ISAPNP_Device** devices_ptr;
 342
 343   if( device_lock_handle == NULL )
 344   {
 345     return;
 346   }
 347
 348   for( devices_ptr = (struct ISAPNP_Device**) device_lock_handle;
 349        *devices_ptr != NULL;
 350        ++devices_ptr )
 351   {
 352     ReleaseSemaphore( &(*devices_ptr)->isapnpd_Lock );
 353   }
 354
 355   FreeVec( device_lock_handle );
 356 }