/******* 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);
}
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;
}
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;
}
}
void free_serialunitclass(struct class_static_data *csd)
{
EnterFunc(bug("free_serialhiddclass(csd=%p)\n", csd));
if(csd) {
OOP_RemoveClass(csd->serialhiddclass);
if(csd->serialhiddclass) OOP_DisposeObject((OOP_Object *) csd->serialhiddclass);
csd->serialhiddclass = NULL;
}
ReturnVoid("free_serialhiddclass");
}
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;
}
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);
}
/******* 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);
}
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);
}
static VOID inputtask_entry(struct inputtask_params *inputparams)
{
struct linux_staticdata *lsd;
struct inputtask_params itp;
UBYTE lastcode = 0xFF;
struct MsgPort *kbd_port = NULL;
struct MsgPort *mouse_port = NULL;
struct mouse_state oldstate = { { 0, 0, 0 }, 0, 0 };
struct pHidd_Mouse_Event mouse_event;
HIDD *unixio = NULL;
ULONG kbdsig, mousesig, sigs;
/* We must copy the parameter struct because they are allocated
on the parent's stack */
kprintf("INSIDE INPUT TASK\n");
itp = *inputparams;
lsd = itp.lsd;
kprintf("in inputtask: lsd = %p\n", lsd);
kprintf("CREATING UNIXIO,,, OOPBase=%p\n", OOPBase);
kprintf("now\n");
unixio = (HIDD)New_UnixIO(OOPBase, SysBase);
kprintf("UNIXIO %p\n", unixio);
if (NULL == unixio) {
goto failexit;
}
kbd_port = CreateMsgPort();
mouse_port = CreateMsgPort();
if (NULL == kbd_port || NULL == mouse_port)
goto failexit;
Signal(itp.parent, itp.ok_signal);
kbdsig = 1L << kbd_port->mp_SigBit;
mousesig = 1L << mouse_port->mp_SigBit;
kprintf("SIGS: %p, %p\n", kbdsig, mousesig);
kprintf("FDS: %d, %d\n", lsd->kbdfd, lsd->mousefd);
Hidd_UnixIO_AsyncIO(unixio, lsd->kbdfd, vHidd_UnixIO_Terminal, kbd_port, vHidd_UnixIO_Read, SysBase);
Hidd_UnixIO_AsyncIO(unixio, lsd->mousefd, vHidd_UnixIO_Terminal, mouse_port, vHidd_UnixIO_Read, SysBase);
for (;;) {
LONG err_kbd, err_mouse;
//kprintf("GETTING INPUT FROM UNIXIO\n");
/* Turn on kbd support */
// init_kbd(lsd);
// ret = (int)Hidd_UnixIO_Wait( unixio, lsd->kbdfd, vHidd_UnixIO_Read, NULL, NULL);
// cleanup_kbd(lsd);
// kprintf("GOT INPUT FROM UNIXIO\n");
sigs = Wait( kbdsig | mousesig );
if (sigs & kbdsig) {
//kprintf("---------- GOT KBD INPUT --------------------\n");
for (;;) {
UBYTE code;
size_t bytesread;
bytesread = read(lsd->kbdfd, &code, 1);
if (-1 == bytesread) {
kprintf("!!! COULD NOT READ FROM LINUX KBD DEVICE: %s\n"
, strerror(errno));
break;
} else {
/* Let the kbd hidd handle it */
/* Key doewn ? */
//kprintf("## code %d\n", code);
if (code == lastcode)
break;
// if (!(code & 0x80)) kprintf("GOT SCANCODE %d from kbd hidd\n", code);
if (code == 88) /* F12 */
{
kill(getpid(), SIGTERM);
}
/* Send code to the application */
ObtainSemaphore(&lsd->sema);
if (lsd->kbdhidd) HIDD_LinuxKbd_HandleEvent(lsd->kbdhidd, code);
ReleaseSemaphore(&lsd->sema);
lastcode = code;
}
break;
} /* for (;;) */
free_unixio_message(kbd_port, lsd);
err_kbd = Hidd_UnixIO_AsyncIO(unixio, lsd->kbdfd, vHidd_UnixIO_Terminal, kbd_port, vHidd_UnixIO_Read, SysBase);
} /* if (sigs & kbdsig) */
if (sigs & mousesig)
{
ULONG i;
LONG bytesread;
UBYTE buf[4];
BYTE dx = 0, dy = 0;
struct mouse_state newstate;
/* Got mouse event */
//kprintf("------------- MOUSE EVENT ------------\n");
for (i = 0; i < 4; i ++) {
bytesread = read(lsd->mousefd, &buf[i], 1);
if (-1 == bytesread)
{
if (errno == EAGAIN)
{
i--;
continue;
}
kprintf("!!! linux input task: Could not read from mouse device: %s\n", strerror(errno));
goto end_mouse_event;
}
if ((buf[0] & 8) != 8) i--;
}
//kprintf("%02x: %02x: %02x\n", buf[0], buf[1], buf[2]);
/* Get button states */
newstate.buts[0] = (buf[0] & 0x01) ? 1 : 0;
newstate.buts[1] = (buf[0] & 0x02) ? 1 : 0;
newstate.buts[2] = (buf[0] & 0x04) ? 1 : 0;
if (buf[1] != 0) {
dx = (buf[0] & 0x10) ? buf[1] - 256 : buf[1];
}
if (buf[2] != 0) {
dy = (buf[0] & 0x20) ? buf[2] - 256 : buf[2];
}
newstate.dx = dx;
newstate.dy = -dy;
//kprintf("EVENT: STATE 1:%d, 2:%d, 3:%d, dx:%d, dy:%d\n"
// , newstate.buts[0], newstate.buts[1], newstate.buts[2]
// , newstate.dx, newstate.dy);
ObtainSemaphore(&lsd->sema);
if (lsd->mousehidd)
{
mouse_event.x = newstate.dx;
mouse_event.y = newstate.dy;
if (newstate.dx || newstate.dy)
{
mouse_event.button = vHidd_Mouse_NoButton;
mouse_event.type = vHidd_Mouse_Motion;
HIDD_LinuxMouse_HandleEvent(lsd->mousehidd, &mouse_event);
}
if (newstate.buts[0] != oldstate.buts[0])
{
mouse_event.button = vHidd_Mouse_Button1;
mouse_event.type = newstate.buts[0] ? vHidd_Mouse_Press : vHidd_Mouse_Release;
HIDD_LinuxMouse_HandleEvent(lsd->mousehidd, &mouse_event);
}
if (newstate.buts[1] != oldstate.buts[1])
{
mouse_event.button = vHidd_Mouse_Button2;
mouse_event.type = newstate.buts[1] ? vHidd_Mouse_Press : vHidd_Mouse_Release;
HIDD_LinuxMouse_HandleEvent(lsd->mousehidd, &mouse_event);
}
if (newstate.buts[2] != oldstate.buts[2])
{
mouse_event.button = vHidd_Mouse_Button3;
mouse_event.type = newstate.buts[2] ? vHidd_Mouse_Press : vHidd_Mouse_Release;
HIDD_LinuxMouse_HandleEvent(lsd->mousehidd, &mouse_event);
}
}
ReleaseSemaphore(&lsd->sema);
oldstate = newstate;
end_mouse_event:
free_unixio_message(mouse_port, lsd);
err_mouse = Hidd_UnixIO_AsyncIO(unixio, lsd->mousefd, vHidd_UnixIO_Terminal, mouse_port, vHidd_UnixIO_Read, SysBase);
}
} /* Forever */
failexit:
if (NULL != kbd_port)
DeleteMsgPort(kbd_port);
if (NULL != mouse_port)
DeleteMsgPort(mouse_port);
if (NULL != unixio)
OOP_DisposeObject((OOP_Object *)unixio);
Signal(itp.parent, itp.fail_signal);
return;
}
