rom/isapnp/expansion_init.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 #define DEBUG 1
  25
  26 #include "CompilerSpecific.h"
  27
  28 #include <aros/libcall.h>
  29 #include <exec/memory.h>
  30 #include <exec/resident.h>
  31 #include <devices/timer.h>
  32
  33 #include <clib/alib_protos.h>
  34 #include <proto/exec.h>
  35 /*#include <proto/utility.h>*/
  36
  37 #include <stdlib.h>
  38
  39 #include <resources/isapnp.h>
  40 #include "isapnp_private.h"
  41 #include "version.h"
  42
  43 #include "controller.h"
  44 #include "devices.h"
  45 #include "init.h"
  46 #include "pnp.h"
  47 #include "pnp_structs.h"
  48
  49
  50 void
  51 ReqA( const char* text, APTR args );
  52
  53 #define IntReq( text, args...) \
  54         ( { ULONG _args[] = { args }; ReqA( (text), (APTR) _args ); } )
  55
  56 /******************************************************************************
  57 ** ReqA ***********************************************************************
  58 ******************************************************************************/
  59
  60 void
  61 ReqA( const char* text, APTR args, struct ISAPNPBase *res )
  62 {
  63   struct EasyStruct es =
  64   {
  65     sizeof (struct EasyStruct),
  66     0,
  67     (STRPTR) ISAPNPNAME " " VERS,
  68     (STRPTR) text,
  69     "OK"
  70   };
  71   struct IntuitionBase *IntuitionBase;
  72
  73   IntuitionBase = (struct IntuitionBase *)OpenLibrary("intution.library", 36);
  74   if( IntuitionBase != NULL )
  75   {
  76     EasyRequestArgs( NULL, &es, NULL, args );
  77     CloseLibrary(&IntuitionBase->LibNode);
  78   }
  79 }
  80
  81 void Req(const char *text, struct ISAPNPBase *res)
  82 {
  83     ReqA(text, NULL, res);
  84 }
  85
  86 /******************************************************************************
  87 ** Handle the tool types ******************************************************
  88 ******************************************************************************/
  89
  90 static int
  91 HexToInt( UBYTE c )
  92 {
  93   if( c >= '0' && c <= '9' )
  94   {
  95     return c - '0';
  96   }
  97   else if( c >= 'A' && c <= 'F' )
  98   {
  99     return c - 'A' + 10;
 100   }
 101   else if( c >= 'a' && c <= 'f' )
 102   {
 103     return c - 'a' + 10;
 104   }
 105   else
 106   {
 107     return -1;
 108   }
 109 }
 110
 111 // CTL0048        => "CTL\0" 4 8 -1   -1
 112 // CTL0048/1236   => "CTL\0" 4 8 1236 -1
 113 // CTL0048:0      => "CTL\0" 4 8 -1   0
 114 // CTL0048/1236:0 => "CTL\0" 4 8 1236 0
 115
 116 static int
 117 ParseID( UBYTE* string,
 118          LONG*  manufacturer,
 119          WORD*  product,
 120          BYTE*  revision,
 121          LONG*  serial,
 122          WORD*  logical_device )
 123 {
 124   int  chars = 0;
 125   LONG ser   = -1;
 126   LONG dev   = -1;
 127
 128   *manufacturer = ISAPNP_MAKE_ID( ToUpper( string[ 0 ] ),
 129                                   ToUpper( string[ 1 ] ),
 130                                   ToUpper( string[ 2 ] ) );
 131
 132   *product      = ( HexToInt( string[ 3 ] ) << 8 ) |
 133                   ( HexToInt( string[ 4 ] ) << 4 ) |
 134                   ( HexToInt( string[ 5 ] ) );
 135
 136
 137   if( *product == -1 )
 138   {
 139     return 0;
 140   }
 141
 142   *revision = HexToInt( string[ 6 ] );
 143
 144   if( *revision == -1 )
 145   {
 146     return 0;
 147   }
 148
 149   chars = 7;
 150
 151   if( string[ chars ] == '/' )
 152   {
 153     int conv;
 154
 155     if( serial == NULL )
 156     {
 157       // Not allowed if we don't ask for it
 158       return NULL;
 159     }
 160
 161     conv = StrToLong( string + chars + 1, &ser );
 162
 163     if( conv == -1 )
 164     {
 165       return 0;
 166     }
 167     else
 168     {
 169       chars += conv + 1;
 170     }
 171
 172   }
 173
 174   if( serial != NULL )
 175   {
 176     *serial = ser;
 177   }
 178
 179   if( string[ chars ] == ':' )
 180   {
 181     int conv;
 182
 183     if( logical_device == NULL )
 184     {
 185       // Not allowed if we don't ask for it
 186       return NULL;
 187     }
 188
 189     conv = StrToLong( string + chars + 1, &dev );
 190
 191     if( conv == -1 )
 192     {
 193       return 0;
 194     }
 195     else
 196     {
 197       chars += conv + 1;
 198     }
 199
 200   }
 201
 202   if( logical_device != NULL )
 203   {
 204     *logical_device = dev;
 205   }
 206
 207   if( string[ chars ] != 0 && string[ chars ] != ' ' )
 208   {
 209     return 0;
 210   }
 211
 212   return chars;
 213 }
 214
 215
 216 BOOL
 217 HandleStartArgs( struct ISAPNP_Card* card,
 218                  struct ISAPNPBase*  res )
 219 {
 220   UBYTE **tool_types = current_binding.cb_ToolTypes;
 221
 222   while( *tool_types )
 223   {
 224     if( Strnicmp( *tool_types, "DISABLE_CARD=", 13 ) == 0 )
 225     {
 226       LONG manufacturer;
 227       WORD product;
 228       BYTE revision;
 229       LONG serial;
 230
 231       if( ParseID( *tool_types + 13,
 232                    &manufacturer, &product, &revision, &serial, NULL ) )
 233       {
 234         struct ISAPNP_Card* card = NULL;
 235
 236         while( ( card = ISAPNP_FindCard( card,
 237                                          manufacturer,
 238                                          product,
 239                                          revision,
 240                                          serial,
 241                                          res ) ) != NULL )
 242         {
 243           card->isapnpc_Disabled = TRUE;
 244         }
 245       }
 246       else
 247       {
 248         Req( "Illegal tool type: %s\n", (ULONG) *tool_types );
 249         return FALSE;
 250       }
 251     }
 252     else if( Strnicmp( *tool_types, "DISABLE_DEVICE=", 15 ) == 0 )
 253     {
 254       LONG manufacturer;
 255       WORD product;
 256       BYTE revision;
 257       LONG serial;
 258       WORD log_dev;
 259
 260       if( ParseID( *tool_types + 15,
 261                    &manufacturer, &product, &revision, &serial, &log_dev ) )
 262       {
 263         if( log_dev == -1 )
 264         {
 265           struct ISAPNP_Device* dev = NULL;
 266
 267           while( ( dev = ISAPNP_FindDevice( dev,
 268                                             manufacturer,
 269                                             product,
 270                                             revision,
 271                                             res ) ) != NULL )
 272           {
 273             dev->isapnpd_Disabled = TRUE;
 274           }
 275         }
 276         else
 277         {
 278           struct ISAPNP_Card* card = NULL;
 279
 280           while( ( card = ISAPNP_FindCard( card,
 281                                            manufacturer,
 282                                            product,
 283                                            revision,
 284                                            serial,
 285                                            res ) ) != NULL )
 286           {
 287             struct ISAPNP_Device* dev;
 288
 289             for( dev = (struct ISAPNP_Device*) card->isapnpc_Devices.lh_Head;
 290                  dev->isapnpd_Node.ln_Succ != NULL;
 291                  dev = (struct ISAPNP_Device*) dev->isapnpd_Node.ln_Succ )
 292             {
 293               if( dev->isapnpd_DeviceNumber == (UWORD) log_dev )
 294               {
 295                 dev->isapnpd_Disabled = TRUE;
 296               }
 297             }
 298           }
 299         }
 300       }
 301       else
 302       {
 303         Req( "Illegal tool type value: %s\n", (ULONG) *tool_types );
 304         return FALSE;
 305       }
 306     }
 307     else if( Strnicmp( *tool_types, "LEGACY_DEVICE=", 14 ) == 0 )
 308     {
 309       UBYTE* str;
 310       int    conv;
 311       LONG   manufacturer;
 312       WORD   product;
 313       BYTE   revision;
 314       UWORD  dev_num = 0;
 315
 316       str  = *tool_types + 14;
 317       conv = ParseID( str,  &manufacturer, &product, &revision, NULL, NULL );
 318
 319       str += conv;
 320
 321       if( conv != 0 )
 322       {
 323         struct ISAPNP_Device*     dev;
 324         struct ISAPNP_Identifier* id;
 325
 326         dev = ISAPNP_AllocDevice( res );
 327
 328         if( dev == NULL )
 329         {
 330           Req( "Out of memory!" );
 331           return FALSE;
 332         }
 333
 334         dev->isapnpd_Card = card;
 335
 336         id  = AllocVec( sizeof( *id ), MEMF_PUBLIC | MEMF_CLEAR );
 337
 338         if( id == NULL )
 339         {
 340           Req( "Out of memory!" );
 341           ISAPNP_FreeDevice( dev, res );
 342           return FALSE;
 343         }
 344
 345         id->isapnpid_Vendor[ 0 ]  = ( manufacturer >> 24 ) & 0xff;
 346         id->isapnpid_Vendor[ 1 ]  = ( manufacturer >> 16 ) & 0xff;
 347         id->isapnpid_Vendor[ 2 ]  = ( manufacturer >>  8 ) & 0xff;
 348         id->isapnpid_Vendor[ 3 ]  = 0;
 349
 350         id->isapnpid_ProductID    = product;
 351         id->isapnpid_Revision     = revision;
 352
 353         AddTail( (struct List*) &dev->isapnpd_IDs, (struct Node*) id );
 354
 355         if( card->isapnpc_Devices.lh_Head->ln_Succ != NULL )
 356         {
 357           dev_num = ( (struct ISAPNP_Device*)
 358                       card->isapnpc_Devices.lh_TailPred )->isapnpd_DeviceNumber;
 359           ++dev_num;
 360         }
 361
 362         dev->isapnpd_DeviceNumber = dev_num;
 363
 364         AddTail( &card->isapnpc_Devices, (struct Node*) dev );
 365
 366         while( *str != 0 )
 367         {
 368           if( *str != ' ' )
 369           {
 370             if( Strnicmp( str, "IRQ=", 4 ) == 0 )
 371             {
 372               int irq;
 373
 374               irq = strtol( str + 4, (char**) &str, 0 );
 375
 376               if( irq <= 0 || irq >= 16 )
 377               {
 378                 Req( "Invalid IRQ value '%ld' in tooltype line\n"
 379                      "'%s'",
 380                      irq,
 381                      (ULONG) *tool_types );
 382                 return FALSE;
 383               }
 384               else
 385               {
 386                 struct ISAPNP_IRQResource* r;
 387
 388                 r = (struct ISAPNP_IRQResource*)
 389                     ISAPNP_AllocResource( ISAPNP_NT_IRQ_RESOURCE, res );
 390
 391                 if( r == NULL )
 392                 {
 393                   Req( "Out of memory!" );
 394                   return FALSE;
 395                 }
 396
 397                 r->isapnpirqr_IRQMask = 1 << irq;
 398                 r->isapnpirqr_IRQType = ISAPNP_IRQRESOURCE_ITF_HIGH_EDGE;
 399
 400                 AddTail( (struct List*) &dev->isapnpd_Options->isapnprg_Resources,
 401                          (struct Node*) r );
 402               }
 403             }
 404             else if( Strnicmp( str, "DMA=", 4 ) == 0 )
 405             {
 406               int dma;
 407
 408               dma = strtol( str + 4, (char**) &str, 0 );
 409
 410               if( dma <= 0 || dma >= 8 )
 411               {
 412                 Req( "Invalid DMA value '%ld' in tooltype line\n"
 413                      "'%s'",
 414                      dma,
 415                      (ULONG) *tool_types );
 416                 return FALSE;
 417               }
 418               else
 419               {
 420                 struct ISAPNP_DMAResource* r;
 421
 422                 r = (struct ISAPNP_DMAResource*)
 423                     ISAPNP_AllocResource( ISAPNP_NT_DMA_RESOURCE, res );
 424
 425                 if( r == NULL )
 426                 {
 427                   Req( "Out of memory!" );
 428                   return FALSE;
 429                 }
 430
 431                 r->isapnpdmar_ChannelMask = 1 << dma;
 432                 r->isapnpdmar_Flags       = 0;
 433
 434                 AddTail( (struct List*) &dev->isapnpd_Options->isapnprg_Resources,
 435                          (struct Node*) r );
 436               }
 437             }
 438             else if( Strnicmp( str, "IO=", 3 ) == 0 )
 439             {
 440               int base;
 441               int length;
 442
 443               struct ISAPNP_IOResource* r;
 444
 445               base = strtol( str + 3, (char**) &str, 0 );
 446
 447               if( *str != '/' )
 448               {
 449                 Req( "Length missing from IO value in tooltype line\n"
 450                      "'%s'",
 451                      (ULONG) *tool_types );
 452                 return FALSE;
 453               }
 454
 455               ++str;
 456
 457               length = strtol( str, (char**) &str, 0 );
 458
 459               if( base <= 0 || base >= 0xffff )
 460               {
 461                 Req( "Invalid IO base value '%ld' in tooltype line\n"
 462                      "'%s'",
 463                      base,
 464                      (ULONG) *tool_types );
 465                 return FALSE;
 466               }
 467
 468               if( length <= 0 || length >= 0xffff )
 469               {
 470                 Req( "Invalid IO length value '%ld' in tooltype line\n"
 471                      "'%s'",
 472                      length,
 473                      (ULONG) *tool_types );
 474                 return FALSE;
 475               }
 476
 477               r = (struct ISAPNP_IOResource*)
 478                   ISAPNP_AllocResource( ISAPNP_NT_IO_RESOURCE, res );
 479
 480               if( r == NULL )
 481               {
 482                 Req( "Out of memory!" );
 483                 return FALSE;
 484               }
 485
 486               r->isapnpior_MinBase   = base;
 487               r->isapnpior_MaxBase   = base;
 488               r->isapnpior_Length    = length;
 489               r->isapnpior_Alignment = 1;
 490
 491               AddTail( (struct List*) &dev->isapnpd_Options->isapnprg_Resources,
 492                        (struct Node*) r );
 493             }
 494             else
 495             {
 496               Req( "Parse error near '%s'\n"
 497                    "in tooltype line\n"
 498                    "'%s'",
 499                    (ULONG) str,
 500                    (ULONG) *tool_types );
 501               return FALSE;
 502             }
 503           }
 504
 505           if( *str )
 506           {
 507             ++str;
 508           }
 509         }
 510       }
 511       else
 512       {
 513         Req( "Illegal tool type: '%s'\n", (ULONG) *tool_types );
 514         return FALSE;
 515       }
 516     }
 517     else
 518     {
 519       // Ignore unknown tool types
 520     }
 521
 522     ++tool_types;
 523   }
 524
 525   return TRUE;
 526 }