rom/hidds/hidd/hiddclass.c

   1 /*
   2     Copyright © 1995-2010, The AROS Development Team. All rights reserved.
   3     $Id$
   4
   5     Desc: Main class for HIDD.
   6     Lang: english
   7 */
   8
   9 #include <exec/types.h>
  10 #include <exec/libraries.h>
  11 #include <exec/lists.h>
  12 #include <exec/semaphores.h>
  13 #include <exec/memory.h>
  14 #include <exec/alerts.h>
  15
  16 #include <utility/tagitem.h>
  17 #include <utility/hooks.h>
  18 #include <oop/oop.h>
  19 #include <hidd/hidd.h>
  20
  21 #include <proto/exec.h>
  22 #include <proto/oop.h>
  23 #include <proto/utility.h>
  24
  25 #include <aros/symbolsets.h>
  26
  27 #include <string.h>
  28
  29 #include "hiddclass_intern.h"
  30
  31 #include LC_LIBDEFS_FILE
  32
  33 #undef  SDEBUG
  34 #undef  DEBUG
  35 #define DEBUG 0
  36 #include <aros/debug.h>
  37
  38 /*****************************************************************************************
  39
  40     NAME
  41         --background--
  42
  43     LOCATION
  44         hiddclass
  45
  46     NOTES
  47         This class is a base class for all object-oriented hardware drivers in AROS. Its
  48         main purpose is to provide some information about the driver itself.
  49
  50         At the moment this class is just a primary design. Many defined attributes and
  51         methods are drafts and reserved. This documentation includes only already
  52         estabilished definitions. Do not use any other methods and attributes, their
  53         definitions may change at any moment.
  54
  55 *****************************************************************************************/
  56
  57 static const char unknown[]  = "--unknown device--";
  58
  59 #define IS_HIDD_ATTR(attr, idx) ((idx = attr - HiddAttrBase) < num_Hidd_Attrs)
  60
  61 /*****************************************************************************************
  62
  63     NAME
  64         aoHidd_Producer
  65
  66     SYNOPSIS
  67         [I.G], ULONG
  68
  69     LOCATION
  70         hiddclass
  71
  72     FUNCTION
  73         Query hardware manufacturer's numeric ID. This ID may come for example from PCI
  74         or Zorro bus configuration data.
  75
  76     NOTES
  77         It is valid to return 0 if your hardware doesn't provide any ID number.
  78
  79         Initial value for this attribute is usually supplied by driver class in its
  80         moRoot_New implementation.
  81
  82     EXAMPLE
  83
  84     BUGS
  85
  86     SEE ALSO
  87         aoHidd_Product
  88
  89     INTERNALS
  90
  91 *****************************************************************************************/
  92
  93 /*****************************************************************************************
  94
  95     NAME
  96         aoHidd_Name
  97
  98     SYNOPSIS
  99         [I.G], STRPTR
 100
 101     LOCATION
 102         hiddclass
 103
 104     FUNCTION
 105         Name of the driver instance under which it is known to the OS. This name is
 106         provided to OS components that use the driver. For example Intuition's MONITORCLASS
 107         expects to find something like "ati_dvi1.monitor", "ati_vga1.monitor" or
 108         "pcvga.monitor" here.
 109
 110         Note that is is instance name, not class name. Different instances of the driver may
 111         need to provide different names for different objects (like in ATI example) in order
 112         to let the OS to distinguish between them.
 113
 114         The supplied string is internally copied, you may destroy it after object creation.
 115
 116     NOTES
 117         Initial value for this attribute is usually supplied by driver class in its
 118         moRoot_New implementation.
 119
 120     EXAMPLE
 121
 122     BUGS
 123
 124     SEE ALSO
 125         aoHidd_HardwareName
 126
 127     INTERNALS
 128
 129 *****************************************************************************************/
 130
 131 /*****************************************************************************************
 132
 133     NAME
 134         aoHidd_HardwareName
 135
 136     SYNOPSIS
 137         [I.G], STRPTR
 138
 139     LOCATION
 140         hiddclass
 141
 142     FUNCTION
 143         Query hardware name string.
 144
 145     NOTES
 146         Initial value for this attribute is usually supplied by driver class in its
 147         moRoot_New implementation.
 148
 149         The supplied string is not copied!
 150
 151     EXAMPLE
 152
 153     BUGS
 154
 155     SEE ALSO
 156         aoHidd_Name
 157
 158     INTERNALS
 159
 160 *****************************************************************************************/
 161
 162 /*****************************************************************************************
 163
 164     NAME
 165         aoHidd_Product
 166
 167     SYNOPSIS
 168         [I.G], ULONG
 169
 170     LOCATION
 171         hiddclass
 172
 173     FUNCTION
 174         Query hardware's numeric produce ID. This ID may come for example from PCI
 175         or Zorro bus configuration data.
 176
 177     NOTES
 178         It is valid to return 0 if your hardware doesn't provide any ID number.
 179
 180         Initial value for this attribute is usually supplied by driver class in its
 181         moRoot_New implementation.
 182
 183     EXAMPLE
 184
 185     BUGS
 186
 187     SEE ALSO
 188         aoHidd_Producer
 189
 190     INTERNALS
 191
 192 *****************************************************************************************/
 193
 194 /*****************************************************************************************
 195
 196     NAME
 197         aoHidd_ProducerName
 198
 199     SYNOPSIS
 200         [I.G], STRPTR
 201
 202     LOCATION
 203         hiddclass
 204
 205     FUNCTION
 206         Query hardware manufacturer string. NULL is a valid value for this attribute
 207         meaning that the information is not specified.
 208
 209     NOTES
 210         Initial value for this attribute is usually supplied by driver class in its
 211         moRoot_New implementation.
 212
 213         The supplied string is not copied!
 214
 215     EXAMPLE
 216
 217     BUGS
 218
 219     SEE ALSO
 220         aoHidd_HardwareName
 221
 222     INTERNALS
 223
 224 *****************************************************************************************/
 225
 226 /* Implementation of root HIDD class methods. */
 227 VOID HIDDCl__Root__Set(OOP_Class *cl, OOP_Object *o, struct pRoot_Set *msg);
 228
 229 /*** HIDD::New() **************************************************************/
 230
 231 OOP_Object *HIDDCl__Root__New(OOP_Class *cl, OOP_Object *o, struct pRoot_New *msg)
 232 {
 233     struct Library *UtilityBase = CSD(cl)->cs_UtilityBase;
 234     EnterFunc(bug("HIDD::New(cl=%s)\n", cl->ClassNode.ln_Name));
 235     D(bug("DoSuperMethod:%p\n", cl->DoSuperMethod));
 236     o = (OOP_Object *)OOP_DoSuperMethod(cl, o, (OOP_Msg)msg);
 237     if(o)
 238     {
 239         struct HIDDData *hd;
 240         struct TagItem *list = msg->attrList;
 241         struct pRoot_Set set_msg;
 242         STRPTR name, name2;
 243
 244         name = (STRPTR)GetTagData(aHidd_Name, 0,  list);
 245         if (name) {
 246             ULONG l = strlen(name)+1;
 247
 248             name2 = AllocVec(l, MEMF_ANY);
 249             if (!name2)
 250                 return NULL;
 251             CopyMem(name, name2, l);
 252         } else
 253             name2 = (STRPTR)unknown;
 254
 255         hd = OOP_INST_DATA(cl, o);
 256
 257         /*  Initialise the HIDD class. These fields are publicly described
 258             as not being settable at Init time, however it is the only way to
 259             get proper abstraction if you ask me. Plus it does reuse code
 260             in a nice way.
 261
 262             To pass these into the init code I would recommend that your
 263             pass in a TagList of your tags, which is linked to the user's
 264             tags by a TAG_MORE. This way you will prevent them from setting
 265             these values.
 266         */
 267
 268         hd->hd_Type     = GetTagData(aHidd_Type,        0, list);
 269         hd->hd_SubType  = GetTagData(aHidd_SubType,     0, list);
 270         hd->hd_Producer = GetTagData(aHidd_Producer,    0, list);
 271
 272         hd->hd_Name     = name2;
 273         hd->hd_HWName   = (STRPTR)GetTagData(aHidd_HardwareName,(IPTR)unknown,  list);
 274         hd->hd_ProducerName = (STRPTR)GetTagData(aHidd_ProducerName, 0, list);
 275
 276         hd->hd_Status   = GetTagData(aHidd_Status,      vHidd_StatusUnknown,    list);
 277         hd->hd_Locking  = GetTagData(aHidd_Locking,     vHidd_LockShared,       list);
 278         hd->hd_ErrorCode= GetTagData(aHidd_ErrorCode,   0, list);
 279
 280         hd->hd_Active   = TRUE; /* Set default, GetTagData() comes later */
 281
 282         /* Use OM_SET to set the rest */
 283
 284
 285         set_msg.attrList = msg->attrList;
 286         HIDDCl__Root__Set(cl, o, &set_msg);
 287     }
 288
 289     ReturnPtr("HIDD::New", OOP_Object *, o);
 290 }
 291
 292 /*** HIDD::Dispose() **********************************************************/
 293 VOID HIDDCl__Root__Dispose(OOP_Class *cl, OOP_Object *o, OOP_Msg msg)
 294 {
 295     struct HIDDData *hd = OOP_INST_DATA(cl, o);
 296
 297     if (hd->hd_Name != (STRPTR)unknown)
 298         FreeVec(hd->hd_Name);
 299
 300     OOP_DoSuperMethod(cl, o, msg);
 301 }
 302
 303 /*** HIDD::Set() **************************************************************/
 304
 305 VOID HIDDCl__Root__Set(OOP_Class *cl, OOP_Object *o, struct pRoot_Set *msg)
 306 {
 307     struct Library  *UtilityBase = CSD(cl)->cs_UtilityBase;
 308     struct TagItem  *tstate = msg->attrList;
 309     struct TagItem  *tag;
 310     struct HIDDData *hd = OOP_INST_DATA(cl, o);
 311
 312     EnterFunc(bug("HIDD::Set(cl=%s)\n", cl->ClassNode.ln_Name));
 313
 314     while((tag = NextTagItem(&tstate)))
 315     {
 316         ULONG idx;
 317
 318         if (IS_HIDD_ATTR(tag->ti_Tag, idx))
 319         {
 320             switch(idx)
 321             {
 322                 case aoHidd_Active:
 323                     hd->hd_Active = tag->ti_Data;
 324                     break;
 325
 326             }
 327         }
 328     }
 329
 330     ReturnVoid("HIDD::Set");
 331 }
 332
 333
 334 /*** HIDD::Get() **************************************************************/
 335
 336 VOID HIDDCl__Root__Get(OOP_Class *cl, OOP_Object *o, struct pRoot_Get *msg)
 337 {
 338     struct HIDDData *hd = OOP_INST_DATA(cl, o);
 339     ULONG idx;
 340
 341     EnterFunc(bug("HIDD::Get(cl=%s)\n", cl->ClassNode.ln_Name));
 342
 343     if (IS_HIDD_ATTR(msg->attrID, idx))
 344     {
 345         switch (idx)
 346         {
 347             case aoHidd_Type        : *msg->storage = hd->hd_Type;         break;
 348             case aoHidd_SubType     : *msg->storage = hd->hd_SubType;      break;
 349             case aoHidd_Producer    : *msg->storage = hd->hd_Producer;     break;
 350             case aoHidd_Name        : *msg->storage = (IPTR)hd->hd_Name;   break;
 351             case aoHidd_HardwareName: *msg->storage = (IPTR)hd->hd_HWName; break;
 352             case aoHidd_Active      : *msg->storage = hd->hd_Active;       break;
 353             case aoHidd_Status      : *msg->storage = hd->hd_Status;       break;
 354             case aoHidd_ErrorCode   : *msg->storage = hd->hd_ErrorCode;    break;
 355             case aoHidd_Locking     : *msg->storage = hd->hd_Locking;      break;
 356             case aoHidd_Product:
 357                 *msg->storage = hd->hd_Product;
 358                 break;
 359             case aoHidd_ProducerName:
 360                 *msg->storage = (IPTR)hd->hd_ProducerName;
 361                 break;
 362             default                 : OOP_DoSuperMethod(cl, o, (OOP_Msg) msg);     break;
 363         }
 364     } else {
 365         OOP_DoSuperMethod(cl, o, (OOP_Msg) msg);
 366     }
 367
 368
 369     ReturnVoid("HIDD::Get");
 370 }
 371
 372
 373 #if 0
 374 /***********************************
 375 **  Unimplemented methods
 376 */
 377
 378
 379
 380
 381 /*    switch(msg->MethodID)
 382     {
 383     case OM_NEW:
 384         retval = OOP_DoSuperMethodA(cl, o, msg);
 385         if(!retval)
 386             break;
 387
 388         hd = OOP_INST_DATA(cl, retval);
 389
 390         if( hd != NULL)
 391         {
 392             struct TagItem *list = ((struct opSet *)msg)->ops_AttrList;
 393             hd->hd_Type = GetTagData(aHidd_Type, 0, list);
 394             hd->hd_SubType = GetTagData(aHidd_SubType, 0, list);
 395             hd->hd_Producer = GetTagData(aHidd_Producer, 0, list);
 396             hd->hd_Name = (STRPTR)GetTagData(aHidd_Name, (IPTR)unknown, list);
 397             hd->hd_HWName = (STRPTR)GetTagData(aHidd_HardwareName, (IPTR)unknown, list);
 398             hd->hd_Active = TRUE;
 399             hd->hd_Status = GetTagData(aHidd_Status, HIDDV_StatusUnknown, list);
 400             hd->hd_ErrorCode = GetTagData(aHidd_ErrorCode, 0, list);
 401             hd->hd_Locking = GetTagData(aHidd_Locking, HIDDV_LockShared, list);
 402         }
 403
 404     case OM_SET:
 405     {
 406         struct TagItem *tstate = ((struct opSet *)msg)->ops_AttrList;
 407         struct TagItem *tag;
 408
 409         while((tag = NextTagItem(&tstate)))
 410         {
 411             switch(tag->ti_Tag)
 412             {
 413             case aHidd_Active:
 414                 hd->hd_Active = tag->ti_Data;
 415                 break;
 416             }
 417         }
 418         break;
 419     }
 420
 421
 422     case OM_GET:
 423     {
 424         switch(((struct opGet *)msg)->opg_AttrID)
 425         {
 426         case aHidd_Type:
 427             *((struct opGet *)msg)->opg_Storage = hd->hd_Type;
 428             break;
 429
 430         case aHidd_SubType:
 431             *((struct opGet *)msg)->opg_Storage = hd->hd_SubType;
 432             break;
 433
 434         case aHidd_Producer:
 435             *((struct opGet *)msg)->opg_Storage = hd->hd_Producer;
 436             break;
 437
 438         case aHidd_Name:
 439             *((struct opGet *)msg)->opg_Storage = (IPTR)hd->hd_Name;
 440             break;
 441
 442         case aHidd_HardwareName:
 443             *((struct opGet *)msg)->opg_Storage = (IPTR)hd->hd_HWName;
 444             break;
 445
 446         case aHidd_Active:
 447             *((struct opGet *)msg)->opg_Storage = hd->hd_Active;
 448             break;
 449
 450         case aHidd_Status:
 451             *((struct opGet *)msg)->opg_Storage = hd->hd_Status;
 452             break;
 453
 454         case aHidd_ErrorCode:
 455             *((struct opGet *)msg)->opg_Storage = hd->hd_ErrorCode;
 456             break;
 457
 458         case aHidd_Locking:
 459             *((struct opGet *)msg)->opg_Storage = hd->hd_Locking;
 460             break;
 461         }
 462     }
 463
 464 */
 465
 466
 467     /* These are the "hiddclass" methods. */
 468
 469     /*  These two are invalid, since we don't have anything to get
 470         from a class, so the superclass should handle these.
 471
 472         This is especially the case since the only place that we can
 473         get the information for these methods is from an object, but
 474         we don't have any objects if this method is called.
 475     */
 476 /*    case HIDDM_Meta_Get:
 477     case HIDDM_Meta_MGet:
 478         retval = 0;
 479         break;
 480 */
 481     /*  Yet to determine the semantics of these so we just let
 482         them return 0 for now.
 483     */
 484 /*    case HIDDM_BeginIO:
 485     case HIDDM_AbortIO:
 486         retval = 0;
 487         break;
 488
 489     case HIDDM_LoadConfigPlugin:
 490     case HIDDM_Lock:
 491     case HIDDM_Unlock:
 492         retval = NULL;
 493         break;
 494
 495     case HIDDM_AddHIDD:
 496     {
 497
 498         Class *hc = ((hmAdd *)msg)->hma_Class;
 499
 500         if( (hc->cl_Flags & CLF_INLIST) == 0 )
 501         {
 502
 503             ObtainSemaphore(&((struct HCD *)cl->cl_UserData)->listLock);
 504             AddTail(
 505                 (struct List *)&((struct HCD *)cl->cl_UserData)->hiddList,
 506                 (struct Node *)hc
 507             );
 508             ReleaseSemaphore(&((struct HCD *)cl->cl_UserData)->listLock);
 509
 510             hc->cl_Flags |= CLF_INLIST;
 511             retval = TRUE;
 512         }
 513         break;
 514     }
 515
 516     case HIDDM_RemoveHIDD:
 517     {
 518         struct IClass *hc = ((hmAdd *)msg)->hma_Class;
 519
 520         if( hc->cl_Flags & CLF_INLIST )
 521         {
 522             ObtainSemaphore(&((struct HCD *)cl->cl_UserData)->listLock);
 523             Remove((struct Node *)hc);
 524             ReleaseSemaphore(&((struct HCD *)cl->cl_UserData)->listLock);
 525             hc->cl_Flags &= ~CLF_INLIST;
 526         }
 527     }
 528
 529     case OM_DISPOSE:
 530
 531     default:
 532         retval = OOP_DoSuperMethod(cl, o, msg);
 533     }
 534
 535     return retval;
 536 }
 537 */
 538 #endif
 539
 540
 541 /*************************** Classes *****************************/
 542
 543 #undef csd
 544
 545 static int init_hiddclass(LIBBASETYPEPTR lh)
 546 {
 547     struct Library *OOPBase = GM_OOPBASE_FIELD(lh);
 548     struct  class_static_data *csd;
 549     ULONG   ok    = 0;
 550
 551     EnterFunc(bug("HIDD::Init()\n"));
 552
 553     /* If you are not running from ROM, don't use Alert() */
 554
 555     csd = &lh->hd_csd;
 556     csd->cs_UtilityBase = OpenLibrary("utility.library", 36);
 557     if (!csd->cs_UtilityBase)
 558         return FALSE;
 559
 560     NEWLIST(&csd->hiddList);
 561     InitSemaphore(&csd->listLock);
 562
 563     HiddAttrBase = OOP_ObtainAttrBase(IID_Hidd);
 564     if(HiddAttrBase)
 565     {
 566         D(bug("Got HiddAttrBase\n"));
 567         ok = 1;
 568     } /* if(HiddAttrBase) */
 569     else
 570     {
 571         /* If you are not running from ROM, don't use Alert() */
 572
 573         Alert(AT_DeadEnd | AN_Unknown | AO_Unknown);
 574     }
 575
 576     ReturnInt("HIDD::Init", ULONG, ok);
 577 }
 578
 579
 580 static int free_hiddclass(LIBBASETYPEPTR lh)
 581 {
 582     struct Library *OOPBase = GM_OOPBASE_FIELD(lh);
 583     struct class_static_data *csd = &lh->hd_csd;
 584
 585     EnterFunc(bug("HIDD::Free()\n"));
 586
 587     if(csd->hiddAttrBase)
 588     {
 589         OOP_ReleaseAttrBase(IID_Hidd);
 590         csd->hiddAttrBase = 0;
 591     }
 592
 593     CloseLibrary(csd->cs_UtilityBase);
 594
 595     ReturnInt("HIDD::Free", ULONG, TRUE);
 596 }
 597
 598 ADD2INITLIB(init_hiddclass, 0)
 599 ADD2EXPUNGELIB(free_hiddclass, 0)