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