VOID CM__Root__Get(OOP_Class *cl, OOP_Object *o, struct pRoot_Get *msg)
{
struct colormap_data *data;
ULONG idx;
EnterFunc(bug("ColorMap::Get()\n"));
data = OOP_INST_DATA(cl, o);
if (IS_COLORMAP_ATTR(msg->attrID, idx))
{
switch (idx)
{
case aoHidd_ColorMap_NumEntries:
*msg->storage = data->clut.entries;
break;
default:
D(bug("!!! Unknow colormap attr in ColorMap::Get()\n"));
OOP_DoSuperMethod(cl, o, (OOP_Msg)msg);
break;
}
}
else
{
OOP_DoSuperMethod(cl, o, (OOP_Msg)msg);
}
ReturnVoid("ColorMap::Get");
}
BOOL MNAME_BM(SetColors)(OOP_Class *cl, OOP_Object *o, struct pHidd_BitMap_SetColors *msg)
{
struct bitmap_data *data = OOP_INST_DATA(cl, o);
HIDDT_PixelFormat *pf;
ULONG xc_i, col_i;
HIDDT_Pixel red, green, blue;
pf = BM_PIXFMT(o);
if ( vHidd_ColorModel_StaticPalette == HIDD_PF_COLMODEL(pf)
|| vHidd_ColorModel_TrueColor == HIDD_PF_COLMODEL(pf) ) {
/* Superclass takes care of this case */
return OOP_DoSuperMethod(cl, o, (OOP_Msg)msg);
}
/* We have a vHidd_GT_Palette bitmap */
if (!OOP_DoSuperMethod(cl, o, (OOP_Msg)msg)) return FALSE;
if ((msg->firstColor + msg->numColors) > (1 << data->bpp))
return FALSE;
for ( xc_i = msg->firstColor, col_i = 0;
col_i < msg->numColors;
xc_i ++, col_i ++ )
{
red = msg->colors[col_i].red >> 8;
green = msg->colors[col_i].green >> 8;
blue = msg->colors[col_i].blue >> 8;
/* Set given color as allocated */
data->cmap[xc_i] = 0x01000000 | red | (green << 8) | (blue << 16);
/* Update DAC registers */
data->Regs->DAC[xc_i*3] = red >> 2;
data->Regs->DAC[xc_i*3+1] = green >> 2;
data->Regs->DAC[xc_i*3+2] = blue >> 2;
msg->colors[col_i].pixval = xc_i;
}
/* Restore palette if OnBitmap */
#ifdef OnBitmap
ObtainSemaphore(&XSD(cl)->HW_acc);
vgaDACLoad(data->Regs, msg->firstColor, msg->numColors);
ReleaseSemaphore(&XSD(cl)->HW_acc);
#endif /* OnBitmap */
return TRUE;
}
OOP_Object *METHOD(VC4Gallium, Root, New)
{
IPTR interfaceVers;
D(bug("[SoftPipe] %s()\n", __PRETTY_FUNCTION__));
interfaceVers = GetTagData(aHidd_Gallium_InterfaceVersion, -1, msg->attrList);
if (interfaceVers != GALLIUM_INTERFACE_VERSION)
return NULL;
o = (OOP_Object *)OOP_DoSuperMethod(cl, o, (OOP_Msg)msg);
if (o)
{
struct HiddGalliumVC4Data * HiddVC4_DATA = OOP_INST_DATA(cl, o);
HiddVC4_DATA->vc4_obj = o;
#if (0)
HiddVC4_DATA->vc4_ws.destroy = NULL;
HiddVC4_DATA->vc4_ws.is_displaytarget_format_supported = NULL;
HiddVC4_DATA->vc4_ws.displaytarget_create = HiddVC4CreateDisplaytarget;
HiddVC4_DATA->vc4_ws.displaytarget_from_handle = NULL;
HiddVC4_DATA->vc4_ws.displaytarget_get_handle = NULL;
HiddVC4_DATA->vc4_ws.displaytarget_map = HiddVC4MapDisplaytarget;
HiddVC4_DATA->vc4_ws.displaytarget_unmap = HiddVC4UnMapDisplaytarget;
HiddVC4_DATA->vc4_ws.displaytarget_display = NULL;
HiddVC4_DATA->vc4_ws.displaytarget_destroy = HiddVC4DestroyDisplaytarget;
#endif
}
return o;
}
/******* TapUnit::Dispose() ***********************************/
OOP_Object *UXTapUnit__Root__Dispose(OOP_Class *cl, OOP_Object *obj, OOP_Msg msg)
{
struct HIDDTapUnitData * data;
EnterFunc(bug("TapUnit::Dispose()\n"));
data = OOP_INST_DATA(cl, obj);
D(bug("Freeing filedescriptor (%d)!\n",data->filedescriptor));
if (-1 != data->filedescriptor) {
Hidd_UnixIO_AbortAsyncIO(data->unixio_read,
data->filedescriptor,
SysBase);
close(data->filedescriptor);
FreeMem(data->replyport_read, sizeof(struct MsgPort));
FreeMem(data->replyport_write, sizeof(struct MsgPort));
FreeMem(data->softint_read , sizeof(struct Interrupt));
FreeMem(data->softint_write, sizeof(struct Interrupt));
OOP_DisposeObject(data->unixio_read);
OOP_DisposeObject(data->unixio_write);
}
OOP_DoSuperMethod(cl, obj, (OOP_Msg)msg);
ReturnPtr("TapUnit::Dispose()", OOP_Object *, obj);
}
OOP_Object *SDLMouse__Root__New(OOP_Class *cl, OOP_Object *o, struct pRoot_New *msg) {
BOOL has_mouse_hidd = FALSE;
struct mousedata *mousedata;
D(bug("[sdl] SDLMouse::New\n"));
ObtainSemaphoreShared(&LIBBASE->lock);
if (LIBBASE->mousehidd != NULL)
has_mouse_hidd = TRUE;
ReleaseSemaphore(&LIBBASE->lock);
if (has_mouse_hidd) {
D(bug("[sdl] mouse hidd already present, can't make another one\n"));
return NULL;
}
if ((o = (OOP_Object *) OOP_DoSuperMethod(cl, o, (OOP_Msg) msg)) == NULL) {
D(bug("[sdl] supermethod failed, bailing out\n"));
return NULL;
}
mousedata = OOP_INST_DATA(cl, o);
mousedata->callback = GetTagData(aHidd_Mouse_IrqHandler, NULL, msg->attrList);
mousedata->callbackdata = GetTagData(aHidd_Mouse_IrqHandlerData, NULL, msg->attrList);
ObtainSemaphore(&LIBBASE->lock);
LIBBASE->mousehidd = o;
ReleaseSemaphore(&LIBBASE->lock);
D(bug("[sdl] created mouse hidd, callback 0x%08x, data 0x%08x\n", mousedata->callback, mousedata->callbackdata));
return (OOP_Object *) o;
}
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 SDLMouse__Root__Dispose(OOP_Class *cl, OOP_Object *o, OOP_Msg msg) {
D(bug("[sdl] SDLMouse::Dispose\n"));
ObtainSemaphore(&LIBBASE->lock);
LIBBASE->mousehidd = NULL;
ReleaseSemaphore(&LIBBASE->lock);
OOP_DoSuperMethod(cl, o, (OOP_Msg) msg);
}
VOID LinuxMouse__Root__Dispose(OOP_Class *cl, OOP_Object *o, OOP_Msg msg)
{
ObtainSemaphore(&LSD(cl)->sema);
LSD(cl)->mousehidd = NULL;
ReleaseSemaphore(&LSD(cl)->sema);
OOP_DoSuperMethod(cl, o, msg);
}
/******* SerialUnit::New() ***********************************/
static OOP_Object *serialunit_new(OOP_Class *cl, OOP_Object *obj, struct pRoot_New *msg)
{
struct HIDDSerialUnitData * data;
struct TagItem *tag, *tstate;
ULONG unitnum = 0;
EnterFunc(bug("SerialUnit::New()\n"));
tstate = msg->attrList;
while ((tag = NextTagItem(&tstate))) {
ULONG idx;
#define csd CSD(cl->UserData)
if (IS_HIDDSERIALUNIT_ATTR(tag->ti_Tag, idx)) {
#undef csd
switch (idx)
{
case aoHidd_SerialUnit_Unit:
unitnum = (ULONG)tag->ti_Data;
break;
}
}
} /* while (tags to process) */
obj = (OOP_Object *)OOP_DoSuperMethod(cl, obj, (OOP_Msg)msg);
if (obj) {
WORD dummy;
data = OOP_INST_DATA(cl, obj);
data->baseaddr = bases[unitnum];
data->datalength = 8;
data->parity = FALSE;
data->baudrate = 0; /* will be initialize in set_baudrate() */
data->unitnum = unitnum;
CSD(cl->UserData)->units[data->unitnum] = data;
D(bug("Unit %d at 0x0%x\n", data->unitnum, data->baseaddr));
/* Init UART - See 14-10 of dragonball documentation */
serial_out_w(data,USTCNT, UEN | RXEN);
dummy = RREG_W(URX1);
serial_out_w(data, USTCNT, (get_ustcnt(data) | UEN | RXEN | TXEN));
set_baudrate(data, SER_DEFAULT_BAUDRATE);
} /* if (obj) */
ReturnPtr("SerialUnit::New()", OOP_Object *, obj);
}
/******* SerialUnit::Dispose() ***********************************/
static OOP_Object *serialunit_dispose(OOP_Class *cl, OOP_Object *obj, OOP_Msg msg)
{
struct HIDDSerialUnitData * data;
EnterFunc(bug("SerialUnit::Dispose()\n"));
data = OOP_INST_DATA(cl, obj);
CSD(cl->UserData)->units[data->unitnum] = NULL;
/* stop all interrupts, disabling the UART (might save power) */
serial_out_w(data, USTCNT, 0);
OOP_DoSuperMethod(cl, obj, (OOP_Msg)msg);
ReturnPtr("SerialUnit::Dispose()", OOP_Object *, obj);
}
VOID MNAME_ROOT(Get)(OOP_Class *cl, OOP_Object *o, struct pRoot_Get *msg)
{
struct bitmap_data *data = OOP_INST_DATA(cl, o);
ULONG idx;
if (IS_VGABM_ATTR(msg->attrID, idx))
{
switch (idx)
{
case aoHidd_VGABitMap_Drawable:
*msg->storage = (ULONG)data->VideoData;
break;
default:
OOP_DoSuperMethod(cl, o, (OOP_Msg)msg);
break;
}
}
else
{
OOP_DoSuperMethod(cl, o, (OOP_Msg)msg);
}
return;
}
VOID LinuxMouse__Root__Get(OOP_Class *cl, OOP_Object *o, struct pRoot_Get *msg)
{
ULONG idx;
if (IS_HIDDMOUSE_ATTR(msg->attrID, idx))
{
switch (idx)
{
case aoHidd_Mouse_RelativeCoords:
*msg->storage = TRUE;
return;
}
}
OOP_DoSuperMethod(cl, o, (OOP_Msg)msg);
}
/******* SerialUnit::Dispose() ***********************************/
OOP_Object *PCSerUnit__Root__Dispose(OOP_Class *cl, OOP_Object *obj, OOP_Msg msg)
{
struct HIDDSerialUnitData * data;
EnterFunc(bug("SerialUnit::Dispose()\n"));
data = OOP_INST_DATA(cl, obj);
Disable();
CSD(cl->UserData)->units[data->unitnum] = NULL;
Enable();
/* stop all interrupts */
serial_outp(data, UART_IER, 0);
OOP_DoSuperMethod(cl, obj, (OOP_Msg)msg);
ReturnPtr("SerialUnit::Dispose()", OOP_Object *, obj);
}
OOP_Object *LinuxMouse__Root__New(OOP_Class *cl, OOP_Object *o, struct pRoot_New *msg)
{
BOOL has_mouse_hidd = FALSE;
ObtainSemaphore(&LSD(cl)->sema);
if (LSD(cl)->mousehidd)
has_mouse_hidd = TRUE;
ReleaseSemaphore(&LSD(cl)->sema);
if (has_mouse_hidd) /* Cannot open twice */
return NULL; /* Should have some error code here */
o = (OOP_Object *)OOP_DoSuperMethod(cl, o, (OOP_Msg)msg);
if (o)
{
struct mouse_data *data = OOP_INST_DATA(cl, o);
struct TagItem *tag, *tstate;
tstate = msg->attrList;
while ((tag = NextTagItem((const struct TagItem **)&tstate)))
{
ULONG idx;
if (IS_HIDDMOUSE_ATTR(tag->ti_Tag, idx))
{
switch (idx)
{
case aoHidd_Mouse_IrqHandler:
data->mouse_callback = (VOID (*)())tag->ti_Data;
break;
case aoHidd_Mouse_IrqHandlerData:
data->callbackdata = (APTR)tag->ti_Data;
break;
}
}
} /* while (tags to process) */
/* Install the mouse hidd */
ObtainSemaphore(&LSD(cl)->sema);
LSD(cl)->mousehidd = o;
ReleaseSemaphore(&LSD(cl)->sema);
}
return o;
}
VOID CM__Root__Dispose(OOP_Class *cl, OOP_Object *o, OOP_Msg msg)
{
struct colormap_data *data;
data = OOP_INST_DATA(cl, o);
if (NULL != data->clut.colors)
{
FreeMem(data->clut.colors, data->clut.entries * sizeof (HIDDT_Color));
/* To detect use of allready freed mem */
data->clut.colors = 0xDEADBEEF;
}
OOP_DoSuperMethod(cl, o, msg);
return;
}
VOID METHOD(VC4Gallium, Root, Get)
{
struct HIDDVC4Data * HIDDVC4_Data = OOP_INST_DATA(cl, o);
ULONG idx;
if (IS_GALLIUM_ATTR(msg->attrID, idx))
{
switch (idx)
{
/* Overload the property */
case aoHidd_Gallium_InterfaceVersion:
*msg->storage = GALLIUM_INTERFACE_VERSION;
return;
}
}
/* Use parent class for all other properties */
OOP_DoSuperMethod(cl, o, (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;
}
VOID PCVesa__Root__Get(OOP_Class *cl, OOP_Object *o, struct pRoot_Get *msg)
{
ULONG idx;
BOOL found = FALSE;
if (IS_GFX_ATTR(msg->attrID, idx))
{
switch (idx)
{
/* Our only gettable attribute is whether we support HW cursor or not.
* We do not have any such support, since we are a simple VESA fb driver */
case aoHidd_Gfx_SupportsHWCursor:
*msg->storage = (IPTR)FALSE;
found = TRUE;
break;
}
}
if (!found)
OOP_DoSuperMethod(cl, o, (OOP_Msg)msg);
}
VOID MNAME_BM(GetImage)(OOP_Class *cl, OOP_Object *o, struct pHidd_BitMap_GetImage *msg)
{
struct bitmap_data *data = OOP_INST_DATA(cl, o);
int i;
switch(msg->pixFmt)
{
case vHidd_StdPixFmt_Native:
HIDD_BM_CopyMemBox8(o,
data->VideoData,
msg->x,
msg->y,
msg->pixels,
0,
0,
msg->width,
msg->height,
data->width,
msg->modulo);
break;
case vHidd_StdPixFmt_Native32:
HIDD_BM_GetMem32Image8(o,
data->VideoData,
msg->x,
msg->y,
msg->pixels,
msg->width,
msg->height,
data->width,
msg->modulo);
break;
default:
OOP_DoSuperMethod(cl, o, (OOP_Msg)msg);
break;
} /* switch(msg->pixFmt) */
}
VOID PCVesa__Root__Dispose(OOP_Class *cl, OOP_Object *o, OOP_Msg msg)
{
if (XSD(cl)->mouse.shape != NULL)
FreeVec(XSD(cl)->mouse.shape);
OOP_DoSuperMethod(cl, o, (OOP_Msg)msg);
}
/*********** 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 */
/******* SerialUnit::New() ***********************************/
OOP_Object *PCSerUnit__Root__New(OOP_Class *cl, OOP_Object *obj, struct pRoot_New *msg)
{
struct HIDDSerialUnitData * data;
struct TagItem *tag, *tstate;
ULONG unitnum = 0;
EnterFunc(bug("SerialUnit::New()\n"));
tstate = msg->attrList;
while ((tag = NextTagItem((const struct TagItem **)&tstate)))
{
ULONG idx;
#define csd CSD(cl->UserData)
if (IS_HIDDSERIALUNIT_ATTR(tag->ti_Tag, idx))
#undef csd
{
switch (idx)
{
case aoHidd_SerialUnit_Unit:
unitnum = (ULONG)tag->ti_Data;
break;
}
}
} /* while (tags to process) */
obj = (OOP_Object *)OOP_DoSuperMethod(cl, obj, (OOP_Msg)msg);
if (obj)
{
struct IntuitionBase * IntuitionBase = (struct IntuitionBase *)OpenLibrary("intuition.library",0);
data = OOP_INST_DATA(cl, obj);
data->baseaddr = bases[unitnum];
if (NULL != IntuitionBase) {
struct Preferences prefs;
GetPrefs(&prefs,sizeof(prefs));
data->baudrate = prefs.BaudRate;
adapt_data(data, &prefs);
CloseLibrary((struct Library *)IntuitionBase);
} else {
data->datalength = 8;
data->parity = FALSE;
data->baudrate = 9600; /* will be initialize in set_baudrate() */
}
data->unitnum = unitnum;
Disable();
CSD(cl->UserData)->units[data->unitnum] = data;
Enable();
D(bug("Unit %d at 0x0%x\n", data->unitnum, data->baseaddr));
/* Wake up UART */
serial_outp(data, UART_LCR, 0xBF);
serial_outp(data, UART_EFR, UART_EFR_ECB);
serial_outp(data, UART_IER, 0);
serial_outp(data, UART_EFR, 0);
serial_outp(data, UART_LCR, 0);
/* clear the FIFOs */
serial_outp(data, UART_FCR, (UART_FCR_CLEAR_RCVR | UART_FCR_CLEAR_XMIT));
/* clear the interrupt registers */
(void)serial_inp(data, UART_RX);
(void)serial_inp(data, UART_IIR);
(void)serial_inp(data, UART_MSR);
/* initilize the UART */
serial_outp(data, UART_LCR, get_lcr(data));
serial_outp(data, UART_MCR, UART_MCR_OUT2 | UART_MCR_DTR | UART_MCR_RTS);
serial_outp(data, UART_IER, UART_IER_RDI | UART_IER_THRI | UART_IER_RLSI | UART_IER_MSI);
/* clear the interrupt registers again ... */
(void)serial_inp(data, UART_LSR);
(void)serial_inp(data, UART_RX);
(void)serial_inp(data, UART_IIR);
(void)serial_inp(data, UART_MSR);
set_baudrate(data, data->baudrate);
} /* if (obj) */
ReturnPtr("SerialUnit::New()", OOP_Object *, obj);
}
/******* TapUnit::New() ***********************************/
OOP_Object *UXTapUnit__Root__New(OOP_Class *cl, OOP_Object *obj, struct pRoot_New *msg)
{
struct HIDDTapUnitData * data;
static const struct TagItem tags[] = {{ TAG_END, 0}};
struct TagItem *tag, *tstate;
ULONG unitnum = 0;
EnterFunc(bug("TapUnit::New()\n"));
tstate = msg->attrList;
while ((tag = NextTagItem((const struct TagItem **)&tstate))) {
ULONG idx;
if (IS_HIDDTAPUNIT_ATTR(tag->ti_Tag, idx)) {
switch (idx) {
case aoHidd_TapUnit_Unit:
unitnum = (ULONG)tag->ti_Data;
break;
}
}
} /* while (tags to process) */
D(bug("!!!!Request for unit number %d\n",unitnum));
obj = (OOP_Object *)OOP_DoSuperMethod(cl, obj, (OOP_Msg)msg);
if (obj) {
data = OOP_INST_DATA(cl, obj);
data->unitnum = unitnum;
D(bug("Creating network device %s.\n",unitname[data->unitnum]));
data->filedescriptor = unix_open_nonblock("/dev/net/tun");
if (data->filedescriptor < 0)
data->filedescriptor = unix_open_nonblock("/dev/tap");
D(bug("Opened %s on handle %d\n",unitname[data->unitnum], data->filedescriptor));
if (-1 != data->filedescriptor) {
struct ifreq ifr;
memset(&ifr, 0, sizeof(ifr));
ifr.ifr_flags = IFF_TAP | IFF_NO_PI;
strncpy(ifr.ifr_name, unitname[data->unitnum], IFNAMSIZ);
/*
** Configure the tty driver ?!?!?!
*/
{
data->replyport_read = AllocMem(sizeof(struct MsgPort), MEMF_PUBLIC|MEMF_CLEAR);
data->replyport_write= AllocMem(sizeof(struct MsgPort), MEMF_PUBLIC|MEMF_CLEAR);
if (data->replyport_read && data->replyport_write) {
/*
** Init the msg ports. They don't need a signal to be allocated
*/
NEWLIST(&data->replyport_read->mp_MsgList);
data->replyport_read ->mp_Node.ln_Type = NT_MSGPORT;
NEWLIST(&data->replyport_write->mp_MsgList);
data->replyport_write->mp_Node.ln_Type = NT_MSGPORT;
data->softint_read = AllocMem(sizeof(struct Interrupt), MEMF_CLEAR);
data->softint_write = AllocMem(sizeof(struct Interrupt), MEMF_CLEAR);
if (data->softint_read && data->softint_write) {
data->softint_read->is_Data = data;
data->softint_read->is_Code = tapunit_receive_data;
data->softint_write->is_Data = data;
data->softint_write->is_Code = tapunit_write_more_data;
data->replyport_read->mp_Flags = PA_SOFTINT;
data->replyport_read->mp_SoftInt = data->softint_read;
data->replyport_write->mp_Flags = PA_SOFTINT;
data->replyport_write->mp_SoftInt = data->softint_write;
data->unixio_read = OOP_NewObject(NULL, CLID_Hidd_UnixIO, (struct TagItem *)tags);
data->unixio_write = OOP_NewObject(NULL, CLID_Hidd_UnixIO, (struct TagItem *)tags);
if (NULL != data->unixio_read && NULL != data->unixio_write)
{
Hidd_UnixIO_IOControlFile(data->unixio_read,
data->filedescriptor,
TUNSETIFF,
&ifr,
NULL);
ULONG error;
D(bug("Creating UnixIO AsyncIO command!\n"));
error = Hidd_UnixIO_AsyncIO(data->unixio_read,
data->filedescriptor,
vHidd_UnixIO_Terminal,
data->replyport_read,
vHidd_UnixIO_Read | vHidd_UnixIO_Keep,
SysBase);
error = Hidd_UnixIO_AsyncIO(data->unixio_write,
data->filedescriptor,
vHidd_UnixIO_Terminal,
data->replyport_write,
vHidd_UnixIO_Write | vHidd_UnixIO_Keep,
SysBase);
goto exit;
}
if (NULL != data->unixio_read)
OOP_DisposeObject(data->unixio_read);
if (NULL != data->unixio_write)
OOP_DisposeObject(data->unixio_write);
}
if (data->softint_read)
FreeMem(data->softint_read, sizeof(struct Interrupt));
if (data->softint_write)
FreeMem(data->softint_write, sizeof(struct Interrupt));
}
if (data->replyport_read)
FreeMem(data->replyport_read , sizeof(struct MsgPort));
if (data->replyport_write)
FreeMem(data->replyport_write, sizeof(struct MsgPort));
}
close(data->filedescriptor);
}
OOP_DisposeObject(obj);
obj = NULL;
} /* if (obj) */
D(bug("%s - an error occurred!\n",__FUNCTION__));
exit:
ReturnPtr("TapUnit::New()", OOP_Object *, obj);
}
VOID MNAME_BM(FillRect)(OOP_Class *cl, OOP_Object *o, struct pHidd_BitMap_DrawRect *msg)
{
struct bitmap_data *data =OOP_INST_DATA(cl, o);
struct Box box = {0, 0, 0, 0};
HIDDT_Pixel fg = GC_FG(msg->gc);
HIDDT_DrawMode mode = GC_DRMD(msg->gc);
EnterFunc(bug("VGAGfx.BitMap::FillRect(%d,%d,%d,%d)\n",
msg->minX, msg->minY, msg->maxX, msg->maxY));
switch(mode)
{
case vHidd_GC_DrawMode_Copy:
HIDD_BM_FillMemRect8(o,
data->VideoData,
msg->minX,
msg->minY,
msg->maxX,
msg->maxY,
data->width,
fg);
break;
case vHidd_GC_DrawMode_Invert:
HIDD_BM_InvertMemRect(o,
data->VideoData,
msg->minX,
msg->minY,
msg->maxX,
msg->maxY,
data->width);
break;
default:
OOP_DoSuperMethod(cl, o, (OOP_Msg)msg);
break;
} /* switch(mode) */
if (data->disp)
{
box.x1 = msg->minX;
box.y1 = msg->minY;
box.x2 = msg->maxX;
box.y2 = msg->maxY;
ObtainSemaphore(&XSD(cl)->HW_acc);
vgaRefreshArea(data, 1, &box);
if ( ( (XSD(cl)->mouseX + XSD(cl)->mouseW - 1 >= box.x1) &&
(XSD(cl)->mouseX <= box.x2) ) ||
( (XSD(cl)->mouseY + XSD(cl)->mouseH - 1 >= box.y1) &&
(XSD(cl)->mouseY <= box.y2) ) )
draw_mouse(XSD(cl));
ReleaseSemaphore(&XSD(cl)->HW_acc);
}
ReturnVoid("VGAGfx.BitMap::FillRect");
}
VOID MNAME_BM(PutImage)(OOP_Class *cl, OOP_Object *o, struct pHidd_BitMap_PutImage *msg)
{
struct bitmap_data *data = OOP_INST_DATA(cl, o);
struct Box box = {0, 0, 0, 0};
BOOL done_by_superclass = FALSE;
int i;
EnterFunc(bug("VGAGfx.BitMap::PutImage(pa=%p, x=%d, y=%d, w=%d, h=%d)\n",
msg->pixels, msg->x, msg->y, msg->width, msg->height));
switch(msg->pixFmt)
{
case vHidd_StdPixFmt_Native:
HIDD_BM_CopyMemBox8(o,
msg->pixels,
0,
0,
data->VideoData,
msg->x,
msg->y,
msg->width,
msg->height,
msg->modulo,
data->width);
break;
case vHidd_StdPixFmt_Native32:
HIDD_BM_PutMem32Image8(o,
msg->pixels,
data->VideoData,
msg->x,
msg->y,
msg->width,
msg->height,
msg->modulo,
data->width);
break;
default:
OOP_DoSuperMethod(cl, o, (OOP_Msg)msg);
done_by_superclass = TRUE;
break;
}
if (data->disp && !done_by_superclass)
{
box.x1 = msg->x;
box.y1 = msg->y;
box.x2 = box.x1 + msg->width - 1;
box.y2 = box.y1 + msg->height - 1;
ObtainSemaphore(&XSD(cl)->HW_acc);
vgaRefreshArea(data, 1, &box);
if ( ( (XSD(cl)->mouseX + XSD(cl)->mouseW - 1 >= box.x1) &&
(XSD(cl)->mouseX <= box.x2) ) ||
( (XSD(cl)->mouseY + XSD(cl)->mouseH - 1 >= box.y1) &&
(XSD(cl)->mouseY <= box.y2) ) )
draw_mouse(XSD(cl));
ReleaseSemaphore(&XSD(cl)->HW_acc);
}
ReturnVoid("VGAGfx.BitMap::PutImage");
}
OOP_Object *PCVesa__Root__New(OOP_Class *cl, OOP_Object *o, struct pRoot_New *msg)
{
struct TagItem pftags[] =
{
{aHidd_PixFmt_RedShift, 0}, /* 0 */
{aHidd_PixFmt_GreenShift, 0}, /* 1 */
{aHidd_PixFmt_BlueShift, 0}, /* 2 */
{aHidd_PixFmt_AlphaShift, 0}, /* 3 */
{aHidd_PixFmt_RedMask, 0}, /* 4 */
{aHidd_PixFmt_GreenMask, 0}, /* 5 */
{aHidd_PixFmt_BlueMask, 0}, /* 6 */
{aHidd_PixFmt_AlphaMask, 0}, /* 7 */
{aHidd_PixFmt_ColorModel, 0}, /* 8 */
{aHidd_PixFmt_Depth, 0}, /* 9 */
{aHidd_PixFmt_BytesPerPixel,0}, /* 10 */
{aHidd_PixFmt_BitsPerPixel, 0}, /* 11 */
{aHidd_PixFmt_StdPixFmt, 0}, /* 12 */
{aHidd_PixFmt_CLUTShift, 0}, /* 13 */
{aHidd_PixFmt_CLUTMask, 0}, /* 14 */
{aHidd_PixFmt_BitMapType, 0}, /* 15 */
{TAG_DONE, 0UL }
};
struct TagItem sync_mode[] =
{
{aHidd_Sync_PixelClock, 0},
{aHidd_Sync_HDisp, 0},
{aHidd_Sync_VDisp, 0},
{aHidd_Sync_Description,0},
{aHidd_Sync_HSyncStart, 0},
{aHidd_Sync_HSyncEnd, 0},
{aHidd_Sync_HTotal, 0},
{aHidd_Sync_VSyncStart, 0},
{aHidd_Sync_VSyncEnd, 0},
{aHidd_Sync_VTotal, 0},
{TAG_DONE, 0UL}
};
struct TagItem modetags[] =
{
{aHidd_Gfx_PixFmtTags, (IPTR)pftags},
{aHidd_Gfx_SyncTags, (IPTR)sync_mode},
{TAG_DONE, 0UL}
};
struct TagItem yourtags[] =
{
{aHidd_Gfx_ModeTags, (IPTR)modetags},
{TAG_MORE, 0UL}
};
struct pRoot_New yourmsg;
pftags[0].ti_Data = XSD(cl)->data.redshift;
pftags[1].ti_Data = XSD(cl)->data.greenshift;
pftags[2].ti_Data = XSD(cl)->data.blueshift;
pftags[3].ti_Data = 0;
pftags[4].ti_Data = XSD(cl)->data.redmask;
pftags[5].ti_Data = XSD(cl)->data.greenmask;
pftags[6].ti_Data = XSD(cl)->data.bluemask;
pftags[7].ti_Data = 0;
pftags[8].ti_Data = (XSD(cl)->data.depth > 8) ? vHidd_ColorModel_TrueColor : vHidd_ColorModel_Palette;
pftags[9].ti_Data = (XSD(cl)->data.depth > 24) ? 24 : XSD(cl)->data.depth;
pftags[10].ti_Data = XSD(cl)->data.bytesperpixel;
pftags[11].ti_Data = (XSD(cl)->data.bitsperpixel > 24) ? 24 : XSD(cl)->data.bitsperpixel;
pftags[12].ti_Data = vHidd_StdPixFmt_Native;
pftags[14].ti_Data = (1 << XSD(cl)->data.depth) - 1;
pftags[15].ti_Data = vHidd_BitMapType_Chunky;
sync_mode[1].ti_Data = XSD(cl)->data.width;
sync_mode[2].ti_Data = XSD(cl)->data.height;
__sprintf(syncdescription, "VESA:%ldx%ld", XSD(cl)->data.width, XSD(cl)->data.height);
sync_mode[3].ti_Data = (IPTR)syncdescription;
yourtags[1].ti_Data = (IPTR)msg->attrList;
yourmsg.mID = msg->mID;
yourmsg.attrList = yourtags;
msg = &yourmsg;
EnterFunc(bug("VesaGfx::New()\n"));
o = (OOP_Object *)OOP_DoSuperMethod(cl, o, (OOP_Msg)msg);
if (o)
{
D(bug("Got object from super\n"));
XSD(cl)->vesagfxhidd = o;
XSD(cl)->mouse.shape = NULL;
ReturnPtr("VesaGfx::New", OOP_Object *, o);
}
ReturnPtr("VesaGfx::New", OOP_Object *, NULL);
}
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 */
