rom/isapnp/pnp_structs.c

   1 /* $Id: pnp_structs.c,v 1.5 2001/05/07 12:32:42 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
   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 <clib/alib_protos.h>
  28 #include <proto/exec.h>
  29
  30 #include <resources/isapnp.h>
  31 #include "isapnp_private.h"
  32
  33 #include "init.h"
  34 #include "pnp_structs.h"
  35
  36 /******************************************************************************
  37 ** Allocate a card structure **************************************************
  38 ******************************************************************************/
  39
  40 // You should set isapnpc_Node.ln_Name. Allocate the string with AllocVec()!
  41
  42 struct ISAPNP_Card* ASMCALL
  43 ISAPNP_AllocCard( REG( a6, struct ISAPNPBase* res ) )
  44 {
  45   struct ISAPNP_Card* card;
  46
  47   card = AllocVec( sizeof( *card ), MEMF_PUBLIC | MEMF_CLEAR );
  48
  49   if( card != NULL )
  50   {
  51     card->isapnpc_Node.ln_Type = ISAPNP_NT_CARD;
  52
  53     NewList( &card->isapnpc_Devices );
  54     InitSemaphore( &card->isapnpc_Lock );
  55   }
  56
  57   return card;
  58 }
  59
  60 /******************************************************************************
  61 ** Deallocate a card structure ************************************************
  62 ******************************************************************************/
  63
  64 void ASMCALL
  65 ISAPNP_FreeCard( REG( a0, struct ISAPNP_Card* card ),
  66                  REG( a6, struct ISAPNPBase*  res ) )
  67 {
  68   struct ISAPNP_Device* dev;
  69
  70   if( card == NULL )
  71   {
  72     return;
  73   }
  74
  75 //  KPrintF( "Nuking card %s%03lx%lx ('%s')\n",
  76 //           card->isapnpc_ID.isapnpid_Vendor, card->isapnpc_ID.isapnpid_ProductID, card->isapnpc_ID.isapnpid_Revision,
  77 //           card->isapnpc_Node.ln_Name != NULL ? card->isapnpc_Node.ln_Name : "" );
  78
  79   while( ( dev = (struct ISAPNP_Device*) RemHead( &card->isapnpc_Devices ) ) )
  80   {
  81     ISAPNP_FreeDevice( dev, res );
  82   }
  83
  84   if( card->isapnpc_Node.ln_Name != NULL )
  85   {
  86     FreeVec( card->isapnpc_Node.ln_Name );
  87   }
  88
  89   FreeVec( card );
  90 }
  91
  92
  93 /******************************************************************************
  94 ** Allocate a device structure ************************************************
  95 ******************************************************************************/
  96
  97 // You should set isapnpiod_Node.ln_Name. Allocate the string with AllocVec()!
  98
  99 struct ISAPNP_Device* ASMCALL
 100 ISAPNP_AllocDevice( REG( a6, struct ISAPNPBase* res ) )
 101 {
 102   struct ISAPNP_Device* dev;
 103
 104   dev = AllocVec( sizeof( *dev ), MEMF_PUBLIC | MEMF_CLEAR );
 105
 106   if( dev != NULL )
 107   {
 108     dev->isapnpd_Node.ln_Type = ISAPNP_NT_DEVICE;
 109
 110     NewList( (struct List*) &dev->isapnpd_IDs );
 111
 112     dev->isapnpd_Options = ISAPNP_AllocResourceGroup( ISAPNP_RG_PRI_GOOD, res );
 113
 114     if( dev->isapnpd_Options == NULL )
 115     {
 116       ISAPNP_FreeDevice( dev, res );
 117       dev = NULL;
 118     }
 119
 120     NewList( (struct List*) &dev->isapnpd_Resources );
 121     InitSemaphore( &dev->isapnpd_Lock );
 122   }
 123
 124   return dev;
 125 }
 126
 127
 128 /******************************************************************************
 129 ** Deallocate a device structure **********************************************
 130 ******************************************************************************/
 131
 132 void ASMCALL
 133 ISAPNP_FreeDevice( REG( a0, struct ISAPNP_Device* dev ),
 134                    REG( a6, struct ISAPNPBase*    res ) )
 135 {
 136   struct ISAPNP_Identifier* id;
 137   struct ISAPNP_Resource*   r;
 138
 139   if( dev == NULL )
 140   {
 141     return;
 142   }
 143
 144 //  KPrintF( "Nuking logical device '%s'\n",
 145 //           dev->isapnpd_Node.ln_Name != NULL ? dev->isapnpd_Node.ln_Name : "" );
 146
 147
 148   while( ( id = (struct ISAPNP_Identifier*)
 149              RemHead( (struct List*) &dev->isapnpd_IDs ) ) )
 150   {
 151 //    KPrintF( "Nuking (compatible) device %s%03lx%lx\n",
 152 //             id->isapnpid_Vendor, id->isapnpid_ProductID, id->isapnpid_Revision );
 153
 154     FreeVec( id );
 155   }
 156
 157   ISAPNP_FreeResourceGroup( dev->isapnpd_Options, res );
 158
 159   while( ( r = (struct ISAPNP_Resource*)
 160                RemHead( (struct List*) &dev->isapnpd_Resources ) ) )
 161   {
 162     ISAPNP_FreeResource( r, res );
 163   }
 164
 165
 166   if( dev->isapnpd_Node.ln_Name != NULL )
 167   {
 168     FreeVec( dev->isapnpd_Node.ln_Name );
 169   }
 170
 171   FreeVec( dev );
 172 }
 173
 174
 175 /******************************************************************************
 176 ** Allocate a resource group **************************************************
 177 ******************************************************************************/
 178
 179 struct ISAPNP_ResourceGroup* ASMCALL
 180 ISAPNP_AllocResourceGroup( REG( d0, UBYTE              pri ),
 181                            REG( a6, struct ISAPNPBase* res ) )
 182 {
 183   struct ISAPNP_ResourceGroup* rg;
 184
 185   rg = AllocVec( sizeof( *rg ), MEMF_PUBLIC | MEMF_CLEAR );
 186
 187   if( rg != NULL )
 188   {
 189     rg->isapnprg_Type = ISAPNP_NT_RESOURCE_GROUP;
 190     rg->isapnprg_Pri  = pri;
 191
 192     NewList( (struct List*) &rg->isapnprg_Resources );
 193     NewList( (struct List*) &rg->isapnprg_ResourceGroups );
 194   }
 195
 196   return rg;
 197 }
 198
 199
 200 /******************************************************************************
 201 ** Deallocate a resource group ************************************************
 202 ******************************************************************************/
 203
 204 void ASMCALL
 205 ISAPNP_FreeResourceGroup( REG( a0, struct ISAPNP_ResourceGroup* rg ),
 206                           REG( a6, struct ISAPNPBase*           res ) )
 207 {
 208   struct ISAPNP_ResourceGroup* child_rg;
 209   struct ISAPNP_Resource*      r;
 210
 211   if( rg == NULL )
 212   {
 213     return;
 214   }
 215
 216 //  KPrintF( "Nuking resource group.\n" );
 217
 218   while( ( r = (struct ISAPNP_Resource*)
 219                RemHead( (struct List*) &rg->isapnprg_Resources ) ) )
 220   {
 221     ISAPNP_FreeResource( r, res );
 222   }
 223
 224   while( ( child_rg = (struct ISAPNP_ResourceGroup*)
 225                       RemHead( (struct List*) &rg->isapnprg_ResourceGroups ) ) )
 226   {
 227     ISAPNP_FreeResourceGroup( child_rg, res );
 228   }
 229
 230   FreeVec( rg );
 231 }
 232
 233
 234 /******************************************************************************
 235 ** Allocate a resource ********************************************************
 236 ******************************************************************************/
 237
 238 struct ISAPNP_Resource* ASMCALL
 239 ISAPNP_AllocResource( REG( d0, UBYTE              type ),
 240                       REG( a6, struct ISAPNPBase* res ) )
 241 {
 242   struct ISAPNP_Resource* r;
 243   ULONG                   size;
 244
 245   switch( type )
 246   {
 247     case ISAPNP_NT_IRQ_RESOURCE:
 248       size = sizeof( struct ISAPNP_IRQResource );
 249       break;
 250
 251     case ISAPNP_NT_DMA_RESOURCE:
 252       size = sizeof( struct ISAPNP_DMAResource );
 253       break;
 254
 255     case ISAPNP_NT_IO_RESOURCE:
 256       size = sizeof( struct ISAPNP_IOResource );
 257       break;
 258
 259     case ISAPNP_NT_MEMORY_RESOURCE:
 260     default:
 261       return NULL;
 262   }
 263
 264   r = AllocVec( size, MEMF_PUBLIC | MEMF_CLEAR );
 265
 266   if( r != NULL )
 267   {
 268     r->isapnpr_Type = type;
 269   }
 270
 271   return r;
 272 }
 273
 274
 275 /******************************************************************************
 276 ** Deallocate a resource ******************************************************
 277 ******************************************************************************/
 278
 279 void ASMCALL
 280 ISAPNP_FreeResource( REG( a0, struct ISAPNP_Resource* r ),
 281                      REG( a6, struct ISAPNPBase*      res ) )
 282 {
 283   if( r == NULL )
 284   {
 285     return;
 286   }
 287
 288 //  KPrintF( "Nuking resource %ld.\n", r->isapnpr_Type );
 289
 290   FreeVec( r );
 291 }