static int PCILx_Expunge(LIBBASETYPEPTR LIBBASE)
{
BOOL ret = TRUE;
D(bug("[PCILinux] expunge\n"));
/* Try to open PCI subsystem */
OOP_Object *pci = OOP_NewObject(NULL, CLID_Hidd_PCI, NULL);
if (pci)
{
/* If PCI successed to open, remove your driver from subsystem */
struct pHidd_PCI_RemHardwareDriver msg;
msg.driverClass = LIBBASE->psd.driverClass;
msg.mID = OOP_GetMethodID(IID_Hidd_PCI, moHidd_PCI_RemHardwareDriver);
D(bug("[PCILinux] Removing driver\n"));
if (OOP_DoMethod(pci, (OOP_Msg)&msg) == FALSE)
{
ret = FALSE;
D(bug("[PCILinux] PCI class refused to remove driver for some reason. Delaying expunge then\n"));
}
OOP_DisposeObject(pci);
}
return ret;
}
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;
}
OOP_Object *CM__Root__New(OOP_Class *cl, OOP_Object *o, struct pRoot_New *msg)
{
struct Library *UtilityBase = CSD(cl)->cs_UtilityBase;
struct Library *OOPBase = CSD(cl)->cs_OOPBase;
struct colormap_data *data;
ULONG numentries;
struct TagItem *tag, *tstate;
BOOL ok = FALSE;
EnterFunc(bug("ColorMap::New()\n"));
numentries = 256;
for (tstate = msg->attrList; (tag = NextTagItem(&tstate)); )
{
ULONG idx;
if (IS_COLORMAP_ATTR(tag->ti_Tag, idx))
{
switch (idx)
{
case aoHidd_ColorMap_NumEntries:
numentries = tag->ti_Data;
if (numentries > 256 || numentries < 0)
{
D(bug("!!! ILLEGAL value for NumEntries in ColorMap::New()\n"));
}
break;
} /* switch */
}
}
/* Create the object */
o = (OOP_Object *)OOP_DoSuperMethod(cl, o, (OOP_Msg)msg);
if (NULL == o)
return NULL;
data = OOP_INST_DATA(cl, o);
data->clut.entries = numentries;
data->clut.colors = AllocMem(sizeof (HIDDT_Color) * data->clut.entries, MEMF_CLEAR);
if (NULL != data->clut.colors)
{
ok = TRUE;
}
if (!ok)
{
ULONG dispose_mid;
dispose_mid = OOP_GetMethodID(IID_Root, moRoot_Dispose);
OOP_CoerceMethod(cl, o, (OOP_Msg)&dispose_mid);
o = NULL;
}
ReturnPtr("ColorMap::New", OOP_Object *, o);
}
VOID HIDD_ParallelUnit_Stop (OOP_Object *obj)
{
STATIC_MID;
struct pHidd_ParallelUnit_Stop p, *msg = &p;
if(!mid) mid = OOP_GetMethodID(IID_Hidd_ParallelUnit, moHidd_ParallelUnit_Stop);
p.mID = mid;
((VOID) OOP_DoMethod(obj, (OOP_Msg) msg));
}
UWORD HIDD_ParallelUnit_GetStatus(OOP_Object *obj)
{
STATIC_MID;
struct pHidd_ParallelUnit_GetStatus p, *msg = &p;
if (!mid) mid = OOP_GetMethodID(IID_Hidd_ParallelUnit, moHidd_ParallelUnit_GetStatus);
p.mID = mid;
return ((UWORD)OOP_DoMethod(obj, (OOP_Msg) msg));
}
VOID HIDD_SerialUnit_Start(OOP_Object *obj)
{
STATIC_MID;
struct pHidd_SerialUnit_Start p, *msg = &p;
if (!mid) mid = OOP_GetMethodID(IID_Hidd_SerialUnit, moHidd_SerialUnit_Start);
p.mID = mid;
OOP_DoMethod(obj, (OOP_Msg) msg);
}
BYTE HIDD_SerialUnit_SendBreak(OOP_Object *obj, int duration)
{
STATIC_MID;
struct pHidd_SerialUnit_SendBreak p, *msg = &p;
if(!mid) mid = OOP_GetMethodID(IID_Hidd_SerialUnit, moHidd_SerialUnit_SendBreak);
p.mID = mid;
p.duration = duration;
return ((BYTE)OOP_DoMethod(obj, (OOP_Msg) msg));
}
VOID Hidd_SDLMouse_HandleEvent(OOP_Object *o, SDL_Event *e) {
struct pHidd_SDLMouse_HandleEvent msg;
static OOP_MethodID mid;
if (!mid)
mid = OOP_GetMethodID(IID_Hidd_SDLMouse, moHidd_SDLMouse_HandleEvent);
msg.mID = mid;
msg.e = e;
OOP_DoMethod(o, (OOP_Msg) &msg);
}
BOOL HIDD_SerialUnit_SetBaudrate(OOP_Object *obj, ULONG baudrate)
{
STATIC_MID;
struct pHidd_SerialUnit_SetBaudrate p, *msg = &p;
if(!mid) mid = OOP_GetMethodID(IID_Hidd_SerialUnit, moHidd_SerialUnit_SetBaudrate);
p.mID = mid;
p.baudrate = baudrate;
return ((BOOL) OOP_DoMethod(obj, (OOP_Msg) msg));
}
OOP_Object * HIDD_Parallel_NewUnit(OOP_Object *obj, ULONG unitnum)
{
STATIC_MID;
struct pHidd_Parallel_NewUnit p, *msg = &p;
if(!mid) mid = OOP_GetMethodID(IID_Hidd_Parallel, moHidd_Parallel_NewUnit);
p.mID = mid;
p.unitnum = unitnum;
return((OOP_Object *) OOP_DoMethod(obj, (OOP_Msg) msg));
}
VOID HIDD_SerialUnit_GetCapabilities(OOP_Object *obj, struct TagItem * tags)
{
STATIC_MID;
struct pHidd_SerialUnit_GetCapabilities p, *msg = &p;
if (!mid) mid = OOP_GetMethodID(IID_Hidd_SerialUnit, moHidd_SerialUnit_GetCapabilities);
p.mID = mid;
p.taglist = tags;
OOP_DoMethod(obj, (OOP_Msg) msg);
}
BOOL HIDD_SerialUnit_SetParameters(OOP_Object *obj, struct TagItem * tags)
{
STATIC_MID;
struct pHidd_SerialUnit_SetParameters p, *msg = &p;
if(!mid) mid = OOP_GetMethodID(IID_Hidd_SerialUnit, moHidd_SerialUnit_SetParameters);
p.mID = mid;
p.tags = tags;
return ((BOOL) OOP_DoMethod(obj, (OOP_Msg) msg));
}
VOID HIDD_Parallel_DisposeUnit(OOP_Object *obj, OOP_Object *unit)
{
STATIC_MID;
struct pHidd_Parallel_DisposeUnit p, *msg = &p;
if(!mid) mid = OOP_GetMethodID(IID_Hidd_Parallel, moHidd_Parallel_DisposeUnit);
p.mID = mid;
p.unit = unit;
OOP_DoMethod(obj, (OOP_Msg) msg);
}
VOID HIDD_LinuxMouse_HandleEvent(OOP_Object *o, struct pHidd_Mouse_Event *mouseEvent)
{
static OOP_MethodID mid = 0;
struct pHidd_LinuxMouse_HandleEvent p;
if (!mid)
mid = OOP_GetMethodID(IID_Hidd_LinuxMouse, moHidd_LinuxMouse_HandleEvent);
p.mID = mid;
p.mouseEvent = mouseEvent;
OOP_DoMethod(o, (OOP_Msg)&p);
}
ULONG HIDD_ParallelUnit_Write (OOP_Object *obj, UBYTE * data, ULONG length)
{
STATIC_MID;
struct pHidd_ParallelUnit_Write p, *msg = &p;
if(!mid) mid = OOP_GetMethodID(IID_Hidd_ParallelUnit, moHidd_ParallelUnit_Write);
p.mID = mid;
p.Length = length;
p.Outbuffer = data;
return ((ULONG) OOP_DoMethod(obj, (OOP_Msg) msg));
}
BOOL HIDD_ParallelUnit_Init(OOP_Object *obj, VOID * DataReceived, VOID * DataReceivedUserData, VOID * WriteData, VOID * WriteDataUserData)
{
STATIC_MID;
struct pHidd_ParallelUnit_Init p, *msg = &p;
if(!mid) mid = OOP_GetMethodID(IID_Hidd_ParallelUnit, moHidd_ParallelUnit_Init);
p.mID = mid;
p.DataReceived = DataReceived;
p.DataReceivedUserData = DataReceivedUserData;
p.WriteData = WriteData;
p.WriteDataUserData = WriteDataUserData;
return((BOOL) OOP_DoMethod(obj, (OOP_Msg) msg));
}
static int ata_expunge(struct ataBase *ATABase)
{
if (ATABase->ataObj)
{
/*
* CLID_Hidd_Storage is a singletone, you can get it as many times as
* you want. Here we save up some space in struct ataBase by
* obtaining storageRoot object only when we need it. This happens
* rarely, so small performance loss is OK here.
*/
OOP_Object *storageRoot = OOP_NewObject(NULL, CLID_Hidd_Storage, NULL);
if (storageRoot && HW_RemoveDriver(storageRoot, ATABase->ataObj))
{
/* Destroy our singletone */
OOP_MethodID disp_msg = OOP_GetMethodID(IID_Root, moRoot_Dispose);
D(bug("[ATA ] ata_expunge: Stopping Daemon...\n"));
ATABase->daemonParent = FindTask(NULL);
SetSignal(0, SIGF_SINGLE);
Signal(ATABase->ata_Daemon, SIGBREAKF_CTRL_C);
Wait(SIGF_SINGLE);
D(bug("[ATA ] ata_expunge: Done, destroying subystem object\n"));
OOP_DoSuperMethod(ATABase->ataClass, ATABase->ataObj, &disp_msg);
}
else
{
/* Our subsystem is in use, we have some bus driver(s) around. */
D(bug("[ATA ] ata_expunge: ATA subsystem is in use\n"));
return FALSE;
}
}
D(bug("[ATA ] ata_expunge: Releasing attribute bases\n"));
OOP_ReleaseAttrBasesArray(&ATABase->hwAttrBase, attrBaseIDs);
if (ATABase->ata_UtilityBase)
CloseLibrary(ATABase->ata_UtilityBase);
D(bug("[ATA ] ata_expunge: Exiting\n"));
return TRUE;
}
static int PCPCI_Expunge(LIBBASETYPEPTR LIBBASE)
{
int ok;
OOP_Object *pci = OOP_NewObject(NULL, CLID_Hidd_PCI, NULL);
if (pci)
{
struct pHidd_PCI_RemHardwareDriver msg, *pmsg=&msg;
msg.mID = OOP_GetMethodID(IID_Hidd_PCI, moHidd_PCI_RemHardwareDriver);
msg.driverClass = LIBBASE->psd.driverClass;
ok = OOP_DoMethod(pci, (OOP_Msg)pmsg);
OOP_DisposeObject(pci);
}
else
ok = FALSE;
return ok;
}
/*********** BitMap::New() *************************************/
OOP_Object *MNAME_ROOT(New)(OOP_Class *cl, OOP_Object *o, struct pRoot_New *msg)
{
EnterFunc(bug("VesaGfx.BitMap::New()\n"));
o = (OOP_Object *)OOP_DoSuperMethod(cl, o, (OOP_Msg) msg);
if (o)
{
struct BitmapData *data;
IPTR width, height, depth, multi;
OOP_Object *friend, *pf;
data = OOP_INST_DATA(cl, o);
/* clear all data */
memset(data, 0, sizeof(struct BitmapData));
/* Get attr values */
OOP_GetAttr(o, aHidd_BitMap_Width, &width);
OOP_GetAttr(o, aHidd_BitMap_Height, &height);
OOP_GetAttr(o, aHidd_BitMap_GfxHidd, (IPTR *)&data->gfxhidd);
OOP_GetAttr(o, aHidd_BitMap_PixFmt, (IPTR *)&pf);
data->pixfmtobj = pf;
OOP_GetAttr(pf, aHidd_PixFmt_Depth, &depth);
OOP_GetAttr(pf, aHidd_PixFmt_BytesPerPixel, &multi);
/* Get the friend bitmap. This should be a displayable bitmap */
OOP_GetAttr(o, aHidd_BitMap_Friend, (IPTR *)&friend);
/* If you got a friend bitmap, copy its colormap */
if (friend)
{
struct BitmapData *src = OOP_INST_DATA(cl, friend);
CopyMem(&src->cmap, &data->cmap, 4*16);
}
ASSERT (width != 0 && height != 0 && depth != 0);
width=(width+15) & ~15;
data->width = width;
data->height = height;
data->bpp = depth;
data->disp = 0;
data->bytesperpix = multi;
data->bytesperline = width * multi;
data->VideoData = AllocVec(width*height*multi, MEMF_PUBLIC | MEMF_CLEAR);
if (data->VideoData)
{
data->data = &XSD(cl)->data;
if (XSD(cl)->activecallback)
XSD(cl)->activecallback(XSD(cl)->callbackdata, o, TRUE);
ReturnPtr("VesaGfx.BitMap::New()", OOP_Object *, o);
} /* if got data->VideoData */
{
OOP_MethodID disp_mid = OOP_GetMethodID(IID_Root, moRoot_Dispose);
OOP_CoerceMethod(cl, o, (OOP_Msg) &disp_mid);
}
o = NULL;
} /* if created object */
EXAMPLE
BUGS
SEE ALSO
OOP_NewObject()
INTERNALS
HISTORY
29-10-95 digulla automatically created from
intuition_lib.fd and clib/intuition_protos.h
*****************************************************************************/
{
AROS_LIBFUNC_INIT
ULONG mid = OOP_GetMethodID(IID_Root, moRoot_Dispose);
EnterFunc(bug("OOP_DisposeObject(classID=%s)\n",
OOP_OCLASS(obj)->ClassNode.ln_Name));
if (obj == NULL) return;
OOP_DoMethod(obj, (OOP_Msg)&mid);
ReturnVoid("OOP_DisposeObject");
AROS_LIBFUNC_EXIT
} /* OOP_DisposeObject */
OOP_Object *PCVGAOnBM__Root__New(OOP_Class *cl, OOP_Object *o, struct pRoot_New *msg)
{
EnterFunc(bug("VGAGfx.BitMap::New()\n"));
o = (OOP_Object *)OOP_DoSuperMethod(cl, o, (OOP_Msg) msg);
if (o)
{
struct bitmap_data *data;
OOP_Object *pf;
IPTR width, height, depth;
data = OOP_INST_DATA(cl, o);
/* clear all data */
memset(data, 0, sizeof(struct bitmap_data));
/* Get attr values */
OOP_GetAttr(o, aHidd_BitMap_Width, &width);
OOP_GetAttr(o, aHidd_BitMap_Height, &height);
OOP_GetAttr(o, aHidd_BitMap_PixFmt, &pf);
OOP_GetAttr(pf, aHidd_PixFmt_Depth, &depth);
ASSERT (width != 0 && height != 0 && depth != 0);
/*
We must only create depths that are supported by the friend drawable
Currently we only support the default depth
*/
data->width = width;
data->height = height;
data->bpp = depth;
data->Regs = AllocVec(sizeof(struct vgaHWRec),MEMF_PUBLIC|MEMF_CLEAR);
data->disp = -1;
width=(width+15) & ~15;
/*
Here there is brand new method of getting pixelclock data.
It was introduced here to make the code more portable. Besides
it may now be used as a base for creating other low level
video drivers
*/
if (data->Regs)
{
data->VideoData = AllocVec(width*height,MEMF_PUBLIC|MEMF_CLEAR);
if (data->VideoData)
{
struct vgaModeDesc mode;
HIDDT_ModeID modeid;
OOP_Object *sync;
OOP_Object *pf;
ULONG pixelc;
/* We should be able to get modeID from the bitmap */
OOP_GetAttr(o, aHidd_BitMap_ModeID, &modeid);
if (modeid != vHidd_ModeID_Invalid)
{
struct Box box = {0, 0, width-1, height-1};
/* Get Sync and PixelFormat properties */
HIDD_Gfx_GetMode(XSD(cl)->vgahidd, modeid, &sync, &pf);
mode.Width = width;
mode.Height = height;
mode.Depth = depth;
OOP_GetAttr(sync, aHidd_Sync_PixelClock, &pixelc);
mode.clock = (pixelc > 26000000) ? 1 : 0;
mode.Flags = 0;
mode.HSkew = 0;
OOP_GetAttr(sync, aHidd_Sync_HDisp, &mode.HDisplay);
OOP_GetAttr(sync, aHidd_Sync_VDisp, &mode.VDisplay);
OOP_GetAttr(sync, aHidd_Sync_HSyncStart, &mode.HSyncStart);
OOP_GetAttr(sync, aHidd_Sync_VSyncStart, &mode.VSyncStart);
OOP_GetAttr(sync, aHidd_Sync_HSyncEnd, &mode.HSyncEnd);
OOP_GetAttr(sync, aHidd_Sync_VSyncEnd, &mode.VSyncEnd);
OOP_GetAttr(sync, aHidd_Sync_HTotal, &mode.HTotal);
OOP_GetAttr(sync, aHidd_Sync_VTotal, &mode.VTotal);
ObtainSemaphore(&XSD(cl)->HW_acc);
/* Now, when the best display mode is chosen, we can build it */
vgaInitMode(&mode, data->Regs);
vgaLoadPalette(data->Regs,(unsigned char *)NULL);
/*
Because of not defined BitMap_Show method show
bitmap immediately
*/
vgaRestore(data->Regs, FALSE);
vgaRefreshArea(data, 1, &box);
ReleaseSemaphore(&XSD(cl)->HW_acc);
XSD(cl)->visible = data; /* Set created object as visible */
ReturnPtr("VGAGfx.BitMap::New()", OOP_Object *, o);
}
} /* if got data->VideoData */
FreeVec(data->Regs);
} /* if got data->Regs */
{
OOP_MethodID disp_mid = OOP_GetMethodID(IID_Root, moRoot_Dispose);
OOP_CoerceMethod(cl, o, (OOP_Msg) &disp_mid);
}
o = NULL;
} /* if created object */
