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      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 #include "CompilerSpecific.h"
  25
  26 #include <exec/memory.h>
  27
  28 #include <proto/exec.h>
  29
  30 #include <stdlib.h>
  31
  32 #include <resources/isapnp.h>
  33 #include "isapnp_private.h"
  34
  35
  36 /******************************************************************************
  37 ** Find a PNP ISA card  *******************************************************
  38 ******************************************************************************/
  39
  40 AROS_LH5(struct ISAPNP_Card *, ISAPNP_FindCard,
  41          AROS_LHA(struct ISAPNP_Card *, last_card, A0),
  42          AROS_LHA(LONG, manufacturer, D0),
  43          AROS_LHA(WORD, product, D1),
  44          AROS_LHA(BYTE, revision, D2),
  45          AROS_LHA(LONG, serial, D3),
  46          struct ISAPNPBase *, res, 28, ISAPNP)
  47 {
  48   AROS_LIBFUNC_INIT
  49
  50   struct ISAPNP_Card* card;
  51
  52   if( last_card == NULL )
  53   {
  54     card = (struct ISAPNP_Card*) res->m_Cards.lh_Head;
  55   }
  56   else
  57   {
  58     card = (struct ISAPNP_Card*) last_card->isapnpc_Node.ln_Succ;
  59   }
  60
  61   while( card->isapnpc_Node.ln_Succ != NULL )
  62   {
  63     if( manufacturer == -1 ||
  64         ISAPNP_MAKE_ID( card->isapnpc_ID.isapnpid_Vendor[ 0 ],
  65                         card->isapnpc_ID.isapnpid_Vendor[ 1 ],
  66                         card->isapnpc_ID.isapnpid_Vendor[ 2 ] ) == manufacturer )
  67     {
  68       if( product == -1 || card->isapnpc_ID.isapnpid_ProductID == product )
  69       {
  70         if( revision == -1 || card->isapnpc_ID.isapnpid_Revision == revision )
  71         {
  72           if( serial == -1 || (LONG) card->isapnpc_SerialNumber == serial )
  73           {
  74             return card;
  75           }
  76         }
  77       }
  78     }
  79
  80     card = (struct ISAPNP_Card*) card->isapnpc_Node.ln_Succ;
  81   }
  82
  83   return NULL;
  84
  85   AROS_LIBFUNC_EXIT
  86 }
  87
  88
  89 /******************************************************************************
  90 ** Find a PNP ISA device  *****************************************************
  91 ******************************************************************************/
  92
  93 AROS_LH4(struct ISAPNP_Device *, ISAPNP_FindDevice,
  94          AROS_LHA(struct ISAPNP_Device *, last_device, A0),
  95          AROS_LHA(LONG, manufacturer, D0),
  96          AROS_LHA(WORD, product, D1),
  97          AROS_LHA(BYTE, revision, D2),
  98          struct ISAPNPBase *, res, 29, ISAPNP)
  99 {
 100   AROS_LIBFUNC_INIT
 101
 102   struct ISAPNP_Card*   card;
 103   struct ISAPNP_Device* dev;
 104
 105   if( last_device == NULL )
 106   {
 107     card = (struct ISAPNP_Card*) res->m_Cards.lh_Head;
 108     dev  = (struct ISAPNP_Device*) card->isapnpc_Devices.lh_Head;
 109   }
 110   else
 111   {
 112     card = (struct ISAPNP_Card*) last_device->isapnpd_Card;
 113     dev  = (struct ISAPNP_Device*) last_device->isapnpd_Node.ln_Succ;
 114   }
 115
 116   while( card->isapnpc_Node.ln_Succ != NULL )
 117   {
 118     while( dev->isapnpd_Node.ln_Succ != NULL )
 119     {
 120       struct ISAPNP_Identifier* id;
 121
 122       for( id = (struct ISAPNP_Identifier*) dev->isapnpd_IDs.mlh_Head;
 123            id->isapnpid_MinNode.mln_Succ != NULL;
 124            id = (struct ISAPNP_Identifier*) id->isapnpid_MinNode.mln_Succ )
 125       {
 126         if( manufacturer == -1 ||
 127             ISAPNP_MAKE_ID( id->isapnpid_Vendor[ 0 ],
 128                             id->isapnpid_Vendor[ 1 ],
 129                             id->isapnpid_Vendor[ 2 ] ) == manufacturer )
 130         {
 131           if( product == -1 || id->isapnpid_ProductID == product )
 132           {
 133             if( revision == -1 || id->isapnpid_Revision == revision )
 134             {
 135               return dev;
 136             }
 137           }
 138         }
 139       }
 140
 141       dev = (struct ISAPNP_Device*) dev->isapnpd_Node.ln_Succ;
 142     }
 143
 144     card = (struct ISAPNP_Card*) card->isapnpc_Node.ln_Succ;
 145     dev  = (struct ISAPNP_Device*) card->isapnpc_Devices.lh_Head;
 146   }
 147
 148   return NULL;
 149
 150   AROS_LIBFUNC_EXIT
 151 }
 152
 153
 154
 155 /******************************************************************************
 156 ** Helper functions for the card/device locking functions *********************
 157 ******************************************************************************/
 158
 159 static int
 160 ComparePtr( const void* a,
 161             const void* b )
 162 {
 163   struct ISAPNP_Card* p1 = *( (struct ISAPNP_Card**) a );
 164   struct ISAPNP_Card* p2 = *( (struct ISAPNP_Card**) b );
 165
 166   return p1 - p2;
 167 }
 168
 169
 170 static void**
 171 MakeSortedArray( void** ptrs, struct ISAPNPBase *res)
 172 {
 173   int    size;
 174   void** ptrs_ptr;
 175   void** result;
 176
 177   // Find number of pointers to sort
 178
 179   size      = 0;
 180   ptrs_ptr = ptrs;
 181
 182   while( *ptrs_ptr != NULL )
 183   {
 184     ++size;
 185     ++ptrs_ptr;
 186   }
 187
 188   result = AllocVec( sizeof( *ptrs_ptr ) * size + 1, MEMF_PUBLIC );
 189
 190   if( result != NULL )
 191   {
 192     ptrs_ptr = result;
 193
 194     while( *ptrs != NULL )
 195     {
 196       *ptrs_ptr = *ptrs;
 197       ++ptrs;
 198       ++ptrs_ptr;
 199     }
 200
 201     qsort( result, size, sizeof( *result ), ComparePtr );
 202
 203     result[ size ] = NULL;
 204   }
 205
 206   return result;
 207 }
 208
 209
 210 /******************************************************************************
 211 ** Lock one or more PNP ISA cards  ********************************************
 212 ******************************************************************************/
 213
 214 AROS_LH2(APTR, ISAPNP_LockCardsA,
 215          AROS_LHA(ULONG, flags, D0),
 216          AROS_LHA(struct ISAPNP_Card **, cards, A0),
 217          struct ISAPNPBase *, res, 30, ISAPNP)
 218 {
 219   AROS_LIBFUNC_INIT
 220
 221   struct ISAPNP_Card** cards_ptr;
 222   struct ISAPNP_Card** result;
 223
 224   result = (struct ISAPNP_Card**) MakeSortedArray( (void**) cards, res );
 225
 226   if( result != NULL )
 227   {
 228     for( cards_ptr = result;
 229          *cards_ptr != NULL;
 230          ++cards_ptr )
 231     {
 232       if( flags & ISAPNP_LOCKF_NONBLOCKING )
 233       {
 234         if( ! AttemptSemaphore( &(*cards_ptr)->isapnpc_Lock ) )
 235         {
 236           struct ISAPNP_Card** cards_end;
 237
 238           // Oops! Failed to lock one of the cards!
 239
 240           cards_end = cards_ptr;
 241
 242           for( cards_ptr = result;
 243                cards_ptr != cards_end;
 244                ++cards_ptr );
 245           {
 246             ReleaseSemaphore( &(*cards_ptr)->isapnpc_Lock );
 247           }
 248
 249           FreeVec( result );
 250           result = NULL;
 251           break;
 252         }
 253       }
 254       else
 255       {
 256         ObtainSemaphore( &(*cards_ptr)->isapnpc_Lock );
 257       }
 258     }
 259   }
 260
 261   return (APTR) result;
 262
 263   AROS_LIBFUNC_EXIT
 264 }
 265
 266
 267 /******************************************************************************
 268 ** Unlock one or more PNP ISA cards  ******************************************
 269 ******************************************************************************/
 270
 271 AROS_LH1(void, ISAPNP_UnlockCards,
 272          AROS_LHA(APTR, card_lock_handle, A0),
 273          struct ISAPNPBase *, res, 31, ISAPNP)
 274 {
 275   AROS_LIBFUNC_INIT
 276
 277   struct ISAPNP_Card** cards_ptr;
 278
 279   if( card_lock_handle == NULL )
 280   {
 281     return;
 282   }
 283
 284   for( cards_ptr = (struct ISAPNP_Card**) card_lock_handle;
 285        *cards_ptr != NULL;
 286        ++cards_ptr )
 287   {
 288     ReleaseSemaphore( &(*cards_ptr)->isapnpc_Lock );
 289   }
 290
 291   FreeVec( card_lock_handle );
 292
 293   AROS_LIBFUNC_EXIT
 294 }
 295
 296
 297 /******************************************************************************
 298 ** Lock one or more PNP ISA devices *******************************************
 299 ******************************************************************************/
 300
 301 AROS_LH2(APTR, ISAPNP_LockDevicesA,
 302          AROS_LHA(ULONG, flags, D0),
 303          AROS_LHA(struct ISAPNP_Device **, devices, A0),
 304          struct ISAPNPBase *, res, 32, ISAPNP)
 305 {
 306   AROS_LIBFUNC_INIT
 307
 308   struct ISAPNP_Device** devices_ptr;
 309   struct ISAPNP_Device** result;
 310
 311   result = (struct ISAPNP_Device**) MakeSortedArray( (void**) devices, res );
 312
 313   if( result != NULL )
 314   {
 315     for( devices_ptr = result;
 316          *devices_ptr != NULL;
 317          ++devices_ptr )
 318     {
 319       if( flags & ISAPNP_LOCKF_NONBLOCKING )
 320       {
 321         if( ! AttemptSemaphore( &(*devices_ptr)->isapnpd_Lock ) )
 322         {
 323           struct ISAPNP_Device** devices_end;
 324
 325           // Oops! Failed to lock one of the devices!
 326
 327           devices_end = devices_ptr;
 328
 329           for( devices_ptr = result;
 330                devices_ptr != devices_end;
 331                ++devices_ptr );
 332           {
 333             ReleaseSemaphore( &(*devices_ptr)->isapnpd_Lock );
 334           }
 335
 336           FreeVec( result );
 337           result = NULL;
 338           break;
 339         }
 340       }
 341       else
 342       {
 343         ObtainSemaphore( &(*devices_ptr)->isapnpd_Lock );
 344       }
 345     }
 346   }
 347
 348   return (APTR) result;
 349
 350   AROS_LIBFUNC_EXIT
 351 }
 352
 353
 354 /******************************************************************************
 355 ** Unlock one or more PNP ISA devices  ****************************************
 356 ******************************************************************************/
 357
 358 AROS_LH1(void, ISAPNP_UnlockDevices,
 359          AROS_LHA(APTR, device_lock_handle, A0),
 360          struct ISAPNPBase *, res , 33, ISAPNP)
 361 {
 362   AROS_LIBFUNC_INIT
 363
 364   struct ISAPNP_Device** devices_ptr;
 365
 366   if( device_lock_handle == NULL )
 367   {
 368     return;
 369   }
 370
 371   for( devices_ptr = (struct ISAPNP_Device**) device_lock_handle;
 372        *devices_ptr != NULL;
 373        ++devices_ptr )
 374   {
 375     ReleaseSemaphore( &(*devices_ptr)->isapnpd_Lock );
 376   }
 377
 378   FreeVec( device_lock_handle );
 379
 380   AROS_LIBFUNC_EXIT
 381 }