static int KBD_InitClass(struct kbdbase *LIBBASE)
{
struct Library *OOPBase = LIBBASE->csd.cs_OOPBase;
D(bug("[KBD] base class initialization\n"));
LIBBASE->csd.cs_UtilityBase = OpenLibrary("utility.library", 0);
if (!LIBBASE->csd.cs_UtilityBase)
return FALSE;
LIBBASE->csd.hiddKbdAB = OOP_ObtainAttrBase(IID_Hidd_Kbd);
LIBBASE->csd.hwAB = OOP_ObtainAttrBase(IID_HW);
LIBBASE->csd.hwMB = OOP_GetMethodID(IID_HW, 0);
if (LIBBASE->csd.hiddKbdAB && LIBBASE->csd.hwAB)
{
OOP_Object *root = OOP_NewObject(NULL, CLID_HW_Root, NULL);
NewList((struct List *)&LIBBASE->csd.callbacks);
if (HW_AddDriver(root, LIBBASE->csd.hwClass, NULL))
{
D(bug("[KBD] Everything OK\n"));
return TRUE;
}
}
return FALSE;
}
static int GM_UNIQUENAME(Init)(LIBBASETYPEPTR LIBBASE)
{
D(bug("[SiS900] Init()\n"));
UBYTE tmpbuff[100];
sprintf((char *)tmpbuff, SiS900_TASK_NAME, "sis900.0");
if (FindTask(tmpbuff) != NULL)
{
D(bug("[SiS900] device already up and running.\n"));
return FALSE;
}
NEWLIST(&LIBBASE->sis900b_Units);
LIBBASE->sis900b_PCIDeviceAttrBase = OOP_ObtainAttrBase(IID_Hidd_PCIDevice);
if (LIBBASE->sis900b_PCIDeviceAttrBase != 0)
{
D(bug("[SiS900] HiddPCIDeviceAttrBase @ %p\n", LIBBASE->sis900b_PCIDeviceAttrBase));
LIBBASE->sis900b_PCI = OOP_NewObject(NULL, CLID_Hidd_PCI, NULL);
if (LIBBASE->sis900b_PCI)
{
D(bug("[SiS900] PCI Subsystem HIDD object @ %p\n", LIBBASE->sis900b_PCI));
struct Hook FindHook = {
h_Entry: (IPTR (*)())PCI_Enumerator,
h_Data: LIBBASE,
};
BOOL DriverInit( struct DriverBase* AHIsubBase )
{
struct ac97Base* ac97Base = (struct ac97Base*) AHIsubBase;
ac97Base->dosbase = OpenLibrary( DOSNAME, 37 );
ac97Base->sysbase = SysBase;
D(bug("[ac97] Init\n"));
if(DOSBase)
{
ac97Base->oopbase = OpenLibrary(AROSOOP_NAME, 0);
if (ac97Base)
{
__IHidd_PCIDev = OOP_ObtainAttrBase(IID_Hidd_PCIDevice);
D(bug("[ac97] Libraries opened\n"));
if (__IHidd_PCIDev)
{
OOP_Object *pci = OOP_NewObject(NULL, CLID_Hidd_PCI, NULL);
D(bug("[ac97] PCIDevice AttrBase = %x\n",__IHidd_PCIDev));
if (pci)
{
struct Hook FindHook = {
h_Entry: (IPTR(*)())Enumerator,
h_Data: ac97Base,
};
struct TagItem Reqs[] = {
{ tHidd_PCI_Class, 0x04 },
{ tHidd_PCI_SubClass, 0x01 },
{ TAG_DONE, 0UL },
};
struct pHidd_PCI_EnumDevices enummsg = {
mID: OOP_GetMethodID(CLID_Hidd_PCI, moHidd_PCI_EnumDevices),
callback: &FindHook,
requirements: (struct TagItem *)&Reqs,
}, *msg = &enummsg;
D(bug("[ac97] Got PCI object\n"));
ac97Base->cardfound = FALSE;
ac97Base->PCM_out = AllocMem(8*32, MEMF_PUBLIC | MEMF_CLEAR);
OOP_DoMethod(pci, (OOP_Msg)msg);
OOP_DisposeObject(pci);
D(bug("[ac97] PCM out base %08x\n", ac97Base->PCM_out));
return ac97Base->cardfound;
}
}
static int System_Init(LIBBASETYPEPTR LIBBASE)
{
struct class_static_data *csd = &LIBBASE->hsi_csd;
struct Library *OOPBase = csd->cs_OOPBase;
D(bug("[HiddSystem] %s()\n", __PRETTY_FUNCTION__));
OOP_Object *hwroot = OOP_NewObject(NULL, CLID_HW_Root, NULL);
csd->hwAttrBase = OOP_ObtainAttrBase(IID_HW);
if (HW_AddDriver(hwroot, csd->oopclass, NULL))
{
D(bug("[HiddSystem] %s: initialised\n", __PRETTY_FUNCTION__));
return TRUE;
}
D(bug("[HiddSystem] %s: failed\n", __PRETTY_FUNCTION__));
return FALSE;
}
int main(int argc, char **argv)
{
ULONG ret = RETURN_FAIL;
OOP_AttrBase HiddGCAttrBase;
OOP_AttrBase HiddGfxAttrBase;
OOP_AttrBase HiddBitMapAttrBase;
OOP_Object *gfxHidd;
OOP_Object *bitMap;
OOP_Object *gc;
STRPTR hiddName = "graphics.hidd";
ULONG width = 320;
ULONG height = 200;
ULONG depth = 8;
ULONG format = vHidd_BitMap_Format_Planar;
WORD x;
char wait;
struct Args
{
STRPTR hiddName;
IPTR *width;
IPTR *height;
IPTR *depth;
IPTR *chunky;
ULONG displayable;
};
struct Args args = {hiddName, &width, &height, &depth, 0, 0};
struct RDArgs *rda;
if(ght_OpenLibs(LibsArray))
{
rda = ReadArgs("HIDD/K,WIDTH/N/K,HEIGHT/N/K,DEPTH/N/K,CHUNKY/S,DISPLAYABLE=DP/S", (IPTR *)&args, NULL);
if (rda != NULL)
{
if(args.chunky != 0) format = vHidd_BitMap_Format_Chunky;
if(args.displayable != 0) args.displayable = (ULONG) TRUE;
HIDDGraphicsBase = OpenLibrary(args.hiddName, 0);
if(HIDDGraphicsBase)
{
ret = RETURN_ERROR;
HiddGfxAttrBase = OOP_ObtainAttrBase(IID_Hidd_Gfx);
HiddBitMapAttrBase = OOP_ObtainAttrBase(IID_Hidd_BitMap);
HiddGCAttrBase = OOP_ObtainAttrBase(IID_Hidd_GC);
if(HiddGfxAttrBase && HiddBitMapAttrBase && HiddGCAttrBase)
{
gfxHidd = OOP_NewObject(NULL, args.hiddName, NULL);
if(gfxHidd)
{
struct TagItem bm_tags[] =
{
{aHidd_BitMap_Width, (IPTR) *args.width},
{aHidd_BitMap_Height, (IPTR) *args.height},
{aHidd_BitMap_Depth, (IPTR) *args.depth},
{aHidd_BitMap_Format, (IPTR) format},
{aHidd_BitMap_Displayable, (IPTR) args.displayable},
{TAG_DONE, 0UL}
};
bitMap = HIDD_Gfx_NewBitMap(gfxHidd, bm_tags);
if(bitMap)
{
struct TagItem gc_tags[] =
{
{aHidd_GC_BitMap, (IPTR) bitMap},
{TAG_DONE, 0UL}
};
gc = HIDD_Gfx_NewGC(gfxHidd, gc_tags);
if(gc)
{
OOP_SetAttrsTags(gc, aHidd_GC_Foreground, 15, TAG_END);
for(x = 10; x < 30; x++)
{
OOP_SetAttrsTags(gc, aHidd_GC_ColorMask, ~0, TAG_END);
HIDD_BM_DrawPixel(gc, x, 10);
OOP_SetAttrsTags(gc, aHidd_GC_ColorMask, ~0 - 7, TAG_END);
HIDD_BM_DrawPixel(gc, x, 12);
OOP_SetAttrsTags(gc, aHidd_GC_ColorMask, 0, TAG_END);
HIDD_BM_DrawPixel(gc, x, 14);
}
printf("Press enter to continue");
scanf("%c", &wait);
HIDD_Gfx_DisposeGC(gfxHidd, gc);
ret = RETURN_OK;
}
HIDD_Gfx_DisposeBitMap(gfxHidd, bitMap);
}
if(gfxHidd) OOP_DisposeObject(gfxHidd);
}
} /* if(HiddGfxAttrBase && HiddBitMapAttrBase && HiddGCAttrBase) */
if(HiddGfxAttrBase) OOP_ReleaseAttrBase(IID_Hidd_Gfx);
if(HiddBitMapAttrBase) OOP_ReleaseAttrBase(IID_Hidd_BitMap);
if(HiddGCAttrBase) OOP_ReleaseAttrBase(IID_Hidd_GC);
CloseLibrary(HIDDGraphicsBase);
} /* if(HIDDGraphicsBase) */
FreeArgs(rda);
}
else
{
PrintFault(IoErr(), "");
} /* if (rda != NULL) */
} /* if OpenLibs() */
ght_CloseLibs(LibsArray);
return(ret);
}
int main(int argc, char **argv)
{
ULONG ret = RETURN_FAIL;
OOP_AttrBase HiddGfxAttrBase = 0;
OOP_AttrBase HiddGCAttrBase = 0;
OOP_AttrBase HiddBitMapAttrBase = 0;
OOP_Object *gfxHidd;
OOP_Object *bitMap;
OOP_Object *gc;
STRPTR hiddName = "graphics.hidd";
ULONG fg = 1;
ULONG bg = 2;
/* ReadArgs() declarations */
/* each entry must have a size of 4 bytes */
struct Args
{
STRPTR hiddName;
IPTR *fg;
IPTR *bg;
};
struct Args args = {hiddName, &fg, &bg};
struct RDArgs *rda;
if(ght_OpenLibs(LibsArray))
{
rda = ReadArgs("HIDD/K,FG/N/K,BG/N/K", (IPTR *)&args, NULL);
if (rda != NULL)
{
HIDDGraphicsBase = OpenLibrary(args.hiddName, 0);
if(HIDDGraphicsBase)
{
ret = RETURN_ERROR;
HiddGfxAttrBase = OOP_ObtainAttrBase(IID_Hidd_Gfx);
HiddBitMapAttrBase = OOP_ObtainAttrBase(IID_Hidd_BitMap);
HiddGCAttrBase = OOP_ObtainAttrBase(IID_Hidd_GC);
if(HiddGfxAttrBase && HiddBitMapAttrBase && HiddGCAttrBase)
{
gfxHidd = OOP_NewObject(NULL, args.hiddName, NULL);
if(gfxHidd)
{
bitMap = HIDD_Gfx_NewBitMap(gfxHidd, NULL);
if(bitMap)
{
struct TagItem gc_tags[] =
{
{aHidd_GC_BitMap, (IPTR) bitMap},
{aHidd_GC_Foreground, (IPTR) *args.fg},
{aHidd_GC_Background, (IPTR) *args.bg},
{TAG_DONE, 0UL}
};
gc = HIDD_Gfx_NewGC(gfxHidd, gc_tags);
if(gc)
{
printf("GC created:\n");
printf(" fg : %li\n", ght_GetAttr(gc, aHidd_GC_Foreground));
printf(" bg : %li\n", ght_GetAttr(gc, aHidd_GC_Background));
printf(" drMode: %li\n", ght_GetAttr(gc, aHidd_GC_DrawMode));
printf(" bitMap: %li\n", ght_GetAttr(gc, aHidd_GC_BitMap));
HIDD_Gfx_DisposeGC(gfxHidd, gc);
ret = RETURN_OK;
}
HIDD_Gfx_DisposeBitMap(gfxHidd, bitMap);
}
if(gfxHidd) OOP_DisposeObject(gfxHidd);
} /* if(gfxHidd) */
} /* if(HiddGfxAttrBase && HiddBitMapAttrBase && HiddGCAttrBase) */
if(HiddGCAttrBase) OOP_ReleaseAttrBase(IID_Hidd_GC);
if(HiddBitMapAttrBase) OOP_ReleaseAttrBase(IID_Hidd_BitMap);
if(HiddGfxAttrBase) OOP_ReleaseAttrBase(IID_Hidd_Gfx);
CloseLibrary(HIDDGraphicsBase);
} /* if(HIDDGraphicsBase) */
FreeArgs(rda);
}
else
{
PrintFault(IoErr(), "");
} /* if (rda != NULL) */
} /* if OpenLibs() */
ght_CloseLibs(LibsArray);
return(ret);
}
OOP_Class *init_serialunitclass (struct class_static_data *csd)
{
OOP_Class *cl = NULL;
struct OOP_MethodDescr serialunithiddroot_descr[NUM_ROOT_METHODS + 1] =
{
{(IPTR (*)())serialunit_new, moRoot_New},
{(IPTR (*)())serialunit_dispose, moRoot_Dispose},
/*
{(IPTR (*)())serialunit_set, moRoot_Set},
{(IPTR (*)())serialunit_get, moRoot_Get},
*/
{NULL, 0UL}
};
struct OOP_MethodDescr serialunithidd_descr[NUM_SERIALUNIT_METHODS + 1] =
{
{(IPTR (*)())serialunit_init, moHidd_SerialUnit_Init},
{(IPTR (*)())serialunit_write, moHidd_SerialUnit_Write},
{(IPTR (*)())serialunit_setbaudrate, moHidd_SerialUnit_SetBaudrate},
{(IPTR (*)())serialunit_setparameters, moHidd_SerialUnit_SetParameters},
{(IPTR (*)())serialunit_sendbreak, moHidd_SerialUnit_SendBreak},
{(IPTR (*)())serialunit_start, moHidd_SerialUnit_Start},
{(IPTR (*)())serialunit_stop, moHidd_SerialUnit_Stop},
{(IPTR (*)())serialunit_getcapabilities,moHidd_SerialUnit_GetCapabilities},
{(IPTR (*)())serialunit_getstatus ,moHidd_SerialUnit_GetStatus},
{NULL, 0UL}
};
struct OOP_InterfaceDescr ifdescr[] =
{
{serialunithiddroot_descr , IID_Root , NUM_ROOT_METHODS},
{serialunithidd_descr , IID_Hidd_SerialUnit , NUM_SERIALUNIT_METHODS},
{NULL, NULL, 0}
};
OOP_AttrBase MetaAttrBase = OOP_GetAttrBase(IID_Meta);
struct TagItem tags[] =
{
{ aMeta_SuperID, (IPTR)CLID_Root},
{ aMeta_InterfaceDescr, (IPTR)ifdescr},
{ aMeta_ID, (IPTR)CLID_Hidd_SerialUnit},
{ aMeta_InstSize, (IPTR)sizeof (struct HIDDSerialUnitData) },
{TAG_DONE, 0UL}
};
EnterFunc(bug(" init_serialunitclass(csd=%p)\n", csd));
cl = OOP_NewObject(NULL, CLID_HiddMeta, tags);
D(bug("Class=%p\n", cl));
if (cl) {
__IHidd_SerialUnitAB = OOP_ObtainAttrBase(IID_Hidd_SerialUnit);
if (NULL != __IHidd_SerialUnitAB) {
D(bug("SerialUnit Class ok\n"));
cl->UserData = (APTR)csd;
OOP_AddClass(cl);
} else {
free_serialunitclass(csd);
cl = NULL;
}
}
ReturnPtr("init_serialunitclass", OOP_Class *, cl);
}
