/* /// "usbReleaseInterfaceBinding()" */
void usbReleaseInterfaceBinding(struct NepHidBase *nh, struct NepClassHid *nch)
{
struct Library *ps;
struct PsdConfig *pc;
struct PsdDevice *pd;
STRPTR devname;
KPRINTF(1, ("nepHidReleaseInterfaceBinding(%08lx)\n", nch));
if((ps = OpenLibrary("poseidon.library", 4)))
{
Forbid();
Remove(&nch->nch_Node);
nch->nch_ReadySignal = SIGB_SINGLE;
nch->nch_ReadySigTask = FindTask(NULL);
if(nch->nch_Task)
{
Signal(nch->nch_Task, SIGBREAKF_CTRL_C);
}
Permit();
while(nch->nch_Task)
{
Wait(1L<<nch->nch_ReadySignal);
}
//FreeSignal(nch->nch_ReadySignal);
psdGetAttrs(PGA_INTERFACE, nch->nch_Interface, IFA_Config, &pc, TAG_END);
psdGetAttrs(PGA_CONFIG, pc, CA_Device, &pd, TAG_END);
psdGetAttrs(PGA_DEVICE, pd, DA_ProductName, &devname, TAG_END);
psdAddErrorMsg(RETURN_OK, (STRPTR) libname,
"'%s' fell silent!",
devname);
psdFreeVec(nch);
CloseLibrary(ps);
}
}
/* /// "usbForceInterfaceBinding()" */
struct NepClassHid * usbForceInterfaceBinding(struct NepHidBase *nh, struct PsdInterface *pif)
{
struct Library *ps;
struct NepClassHid *nch;
struct PsdConfig *pc;
struct PsdDevice *pd;
STRPTR devname;
UBYTE buf[64];
struct Task *tmptask;
KPRINTF(1, ("nepHidAttemptInterfaceBinding(%08lx)\n", pif));
if((ps = OpenLibrary("poseidon.library", 4)))
{
if((nch = psdAllocVec(sizeof(struct NepClassHid))))
{
nch->nch_ClsBase = nh;
nch->nch_Device = NULL;
nch->nch_Interface = pif;
nLoadClassConfig(nh);
psdSafeRawDoFmt(buf, 64, "simplemidi.class<%08lx>", nch);
nch->nch_ReadySignal = SIGB_SINGLE;
nch->nch_ReadySigTask = FindTask(NULL);
SetSignal(0, SIGF_SINGLE);
if((tmptask = psdSpawnSubTask(buf, nHidTask, nch)))
{
psdBorrowLocksWait(tmptask, 1UL<<nch->nch_ReadySignal);
if(nch->nch_Task)
{
nch->nch_ReadySigTask = NULL;
//FreeSignal(nch->nch_ReadySignal);
psdGetAttrs(PGA_INTERFACE, pif, IFA_Config, &pc, TAG_END);
psdGetAttrs(PGA_CONFIG, pc, CA_Device, &pd, TAG_END);
psdGetAttrs(PGA_DEVICE, pd, DA_ProductName, &devname, TAG_END);
psdAddErrorMsg(RETURN_OK, (STRPTR) libname,
"Play it again, '%s'!",
devname);
CloseLibrary(ps);
return(nch);
}
}
nch->nch_ReadySigTask = NULL;
//FreeSignal(nch->nch_ReadySignal);
psdFreeVec(nch);
}
CloseLibrary(ps);
}
return(NULL);
}
/* /// "usbReleaseDeviceBinding()" */
void usbReleaseDeviceBinding(struct NepSerialBase *nh, struct NepClassSerial *ncp)
{
struct Library *ps;
STRPTR devname;
KPRINTF(1, ("nepSerialReleaseDeviceBinding(%08lx)\n", ncp));
if((ps = OpenLibrary("poseidon.library", 4)))
{
Forbid();
ncp->ncp_ReadySignal = SIGB_SINGLE;
ncp->ncp_ReadySigTask = FindTask(NULL);
if(ncp->ncp_Task)
{
Signal(ncp->ncp_Task, SIGBREAKF_CTRL_C);
}
Permit();
while(ncp->ncp_Task)
{
Wait(1L<<ncp->ncp_ReadySignal);
}
//FreeSignal(ncp->ncp_ReadySignal);
psdGetAttrs(PGA_DEVICE, ncp->ncp_Device, DA_ProductName, &devname, TAG_END);
psdAddErrorMsg(RETURN_OK, (STRPTR) libname,
"'%s' annealed and broke off.",
devname);
/*psdFreeVec(ncp);*/
CloseLibrary(ps);
}
}
/* /// "usbAttemptDeviceBinding()" */
struct NepClassSerial * usbAttemptDeviceBinding(struct NepSerialBase *nh, struct PsdDevice *pd)
{
struct Library *ps;
struct AutoBindData *abd = ClassBinds;
IPTR prodid;
IPTR vendid;
KPRINTF(1, ("nepSerialAttemptDeviceBinding(%08lx)\n", pd));
if((ps = OpenLibrary("poseidon.library", 4)))
{
psdGetAttrs(PGA_DEVICE, pd,
DA_VendorID, &vendid,
DA_ProductID, &prodid,
TAG_END);
CloseLibrary(ps);
while(abd->abd_VendID)
{
if((vendid == abd->abd_VendID) && (prodid == abd->abd_ProdID))
{
return(usbForceDeviceBinding(nh, pd));
}
abd++;
}
}
return(NULL);
}
void FreeRocket(struct NepClassRocket *nch)
{
APTR pab;
psdGetAttrs(PGA_DEVICE, nch->nch_Device,
DA_Binding, &pab,
TAG_END);
psdReleaseAppBinding(pab);
psdFreePipe(nch->nch_EP0Pipe);
DeleteMsgPort(nch->nch_TaskMsgPort);
psdFreeVec(nch);
}
struct FELSunxiDevice * AttemptDeviceBinding(LIBBASETYPEPTR LIBBASE, struct PsdDevice *pd) {
mybug(-1,("FELSunxi AttemptDeviceBinding\n"));
struct Library *ps;
IPTR prodid;
IPTR vendid;
if((ps = OpenLibrary("poseidon.library", 4))) {
psdGetAttrs(PGA_DEVICE, pd, DA_VendorID, &vendid, DA_ProductID, &prodid, TAG_END);
CloseLibrary(ps);
if((vendid == 0x1f3a) && (prodid == 0xefe8)) {
return ForceDeviceBinding(LIBBASE, pd);
}
}
return NULL;
}
/* /// "usbAttemptInterfaceBinding()" */
struct NepClassHid * usbAttemptInterfaceBinding(struct NepHidBase *nh, struct PsdInterface *pif)
{
struct Library *ps;
IPTR ifclass;
IPTR subclass;
IPTR proto;
KPRINTF(1, ("nepHidAttemptInterfaceBinding(%08lx)\n", pif));
if((ps = OpenLibrary("poseidon.library", 4)))
{
psdGetAttrs(PGA_INTERFACE, pif,
IFA_Class, &ifclass,
IFA_SubClass, &subclass,
IFA_Protocol, &proto,
TAG_DONE);
CloseLibrary(ps);
if((ifclass == AUDIO_CLASSCODE) && (subclass == AUDIO_MIDI_SUBCLASS))
{
return(usbForceInterfaceBinding(nh, pif));
}
}
return(NULL);
}
/* /// "usbForceDeviceBinding()" */
struct NepClassSerial * usbForceDeviceBinding(struct NepSerialBase *nh, struct PsdDevice *pd)
{
struct Library *ps;
struct NepClassSerial *ncp;
STRPTR devname;
IPTR prodid;
IPTR vendid;
ULONG unitno;
BOOL unitfound;
UBYTE buf[64];
struct Task *tmptask;
KPRINTF(1, ("nepSerialForceDeviceBinding(%08lx)\n", pd));
if((ps = OpenLibrary("poseidon.library", 4)))
{
psdGetAttrs(PGA_DEVICE, pd,
DA_ProductID, &prodid,
DA_VendorID, &vendid,
DA_ProductName, &devname,
TAG_END);
nLoadClassConfig(nh);
Forbid();
/* Find next free unit number */
unitno = 0;
ncp = (struct NepClassSerial *) nh->nh_Units.lh_Head;
while(ncp->ncp_Unit.unit_MsgPort.mp_Node.ln_Succ)
{
if(ncp->ncp_UnitNo == unitno)
{
unitno++;
ncp = (struct NepClassSerial *) nh->nh_Units.lh_Head;
} else {
ncp = (struct NepClassSerial *) ncp->ncp_Unit.unit_MsgPort.mp_Node.ln_Succ;
}
}
unitfound = FALSE;
ncp = (struct NepClassSerial *) nh->nh_Units.lh_Head;
while(ncp->ncp_Unit.unit_MsgPort.mp_Node.ln_Succ)
{
if((ncp->ncp_UnitProdID == prodid) && (ncp->ncp_UnitVendorID == vendid))
{
unitno = ncp->ncp_UnitNo;
unitfound = TRUE;
break;
}
ncp = (struct NepClassSerial *) ncp->ncp_Unit.unit_MsgPort.mp_Node.ln_Succ;
}
if(!unitfound)
{
/* as units are freed in the expunge-vector, the memory is
outside the scope of the poseidon library */
if(!(ncp = AllocVec(sizeof(struct NepClassSerial), MEMF_PUBLIC|MEMF_CLEAR)))
{
Permit();
CloseLibrary(ps);
return(NULL);
}
/* IORequests may be queued even if the task is gone. */
NewList(&ncp->ncp_Unit.unit_MsgPort.mp_MsgList);
NewList(&ncp->ncp_ReadQueue);
NewList(&ncp->ncp_WriteQueue);
AddTail(&nh->nh_Units, &ncp->ncp_Unit.unit_MsgPort.mp_Node);
ncp->ncp_DenyRequests = TRUE;
}
ncp->ncp_DevBase = nh->nh_DevBase;
ncp->ncp_UnitNo = unitno;
ncp->ncp_Device = pd;
ncp->ncp_UnitProdID = prodid;
ncp->ncp_UnitVendorID = vendid;
Permit();
psdSafeRawDoFmt(buf, 64, "palmpda.class<%08lx>", ncp);
ncp->ncp_ReadySignal = SIGB_SINGLE;
ncp->ncp_ReadySigTask = FindTask(NULL);
SetSignal(0, SIGF_SINGLE);
if((tmptask = psdSpawnSubTask(buf, nSerialTask, ncp)))
{
psdBorrowLocksWait(tmptask, 1UL<<ncp->ncp_ReadySignal);
if(ncp->ncp_Task)
{
ncp->ncp_ReadySigTask = NULL;
//FreeSignal(ncp->ncp_ReadySignal);
psdAddErrorMsg(RETURN_OK, (STRPTR) libname,
"This '%s' PDA is hot at %s unit %ld!",
devname, nh->nh_DevBase->np_Library.lib_Node.ln_Name,
ncp->ncp_UnitNo);
CloseLibrary(ps);
return(ncp);
}
}
ncp->ncp_ReadySigTask = NULL;
//FreeSignal(ncp->ncp_ReadySignal);
/* Get rid of unit structure */
/*Forbid();
Remove((struct Node *) ncp);
FreeVec(ncp);
Permit();*/
CloseLibrary(ps);
}
return(NULL);
}
/* /// "usbForceInterfaceBinding()" */
struct NepClassHid * usbForceInterfaceBinding(struct NepHidBase *nh, struct PsdInterface *pif)
{
struct Library *ps;
struct NepClassHid *nch;
struct PsdConfig *pc;
struct PsdDevice *pd;
STRPTR devname;
STRPTR ifidstr;
STRPTR devidstr;
UBYTE buf[64];
struct Task *tmptask;
KPRINTF(1, ("nepHidForceInterfaceBinding(%08lx)\n", pif));
if((ps = OpenLibrary("poseidon.library", 4)))
{
psdGetAttrs(PGA_INTERFACE, pif,
IFA_Config, &pc,
IFA_IDString, &ifidstr,
TAG_DONE);
psdGetAttrs(PGA_CONFIG, pc,
CA_Device, &pd,
TAG_END);
psdGetAttrs(PGA_DEVICE, pd,
DA_ProductName, &devname,
DA_IDString, &devidstr,
TAG_END);
if((nch = psdAllocVec(sizeof(struct NepClassHid))))
{
nch->nch_ClsBase = nh;
nch->nch_CDC = psdAllocVec(sizeof(struct ClsDevCfg));
if(!nch->nch_CDC)
{
psdFreeVec(nch);
CloseLibrary(ps);
return(NULL);
}
nch->nch_Device = pd;
nch->nch_Interface = pif;
nch->nch_DevIDString = devidstr;
nch->nch_IfIDString = ifidstr;
nLoadBindingConfig(nch);
psdSafeRawDoFmt(buf, 64, "bootmouse.class<%08lx>", nch);
nch->nch_ReadySignal = SIGB_SINGLE;
nch->nch_ReadySigTask = FindTask(NULL);
SetSignal(0, SIGF_SINGLE);
if((tmptask = psdSpawnSubTask(buf, nHidTask, nch)))
{
psdBorrowLocksWait(tmptask, 1UL<<nch->nch_ReadySignal);
if(nch->nch_Task)
{
nch->nch_ReadySigTask = NULL;
//FreeSignal(nch->nch_ReadySignal);
psdAddErrorMsg(RETURN_OK, (STRPTR) libname,
"I'm pleased to introduce a mouse alliance to '%s'!",
devname);
Forbid();
AddTail(&nh->nh_Bindings, &nch->nch_Node);
Permit();
CloseLibrary(ps);
return(nch);
}
}
nch->nch_ReadySigTask = NULL;
//FreeSignal(nch->nch_ReadySignal);
psdFreeVec(nch->nch_CDC);
psdFreeVec(nch);
}
CloseLibrary(ps);
}
return(NULL);
}
/* /// "usbForceInterfaceBinding()" */
struct NepClassHid * usbForceInterfaceBinding(struct NepHidBase *nh, struct PsdInterface *pif)
{
struct Library *ps;
struct Library *DOSBase;
struct NepClassHid *nch;
struct PsdConfig *pc;
struct PsdDevice *pd;
STRPTR devname;
UBYTE buf[64];
struct Task *tmptask;
KPRINTF(1, ("nepHidAttemptInterfaceBinding(%08lx)\n", pif));
if((ps = OpenLibrary("poseidon.library", 4)))
{
if((nch = psdAllocVec(sizeof(struct NepClassHid))))
{
STRPTR srcpos;
STRPTR tarpos;
UWORD cnt;
psdGetAttrs(PGA_INTERFACE, pif, IFA_Config, &pc, TAG_END);
psdGetAttrs(PGA_CONFIG, pc, CA_Device, &pd, TAG_END);
psdGetAttrs(PGA_DEVICE, pd, DA_ProductName, &devname, TAG_END);
// generate ID
srcpos = devname;
tarpos = nch->nch_ShortID;
cnt = 31;
while(*srcpos && cnt)
{
if(((*srcpos >= 'A') && (*srcpos <= 'Z')) ||
((*srcpos >= 'a') && (*srcpos <= 'z')) ||
((*srcpos >= '0') && (*srcpos <= '9')))
{
*tarpos++ = *srcpos;
cnt--;
}
srcpos++;
}
*tarpos = 0;
nch->nch_ClsBase = nh;
nch->nch_Device = NULL;
nch->nch_Interface = pif;
nLoadClassConfig(nh);
psdSafeRawDoFmt(buf, 64, "camdusbmidi.class<%08lx>", nch);
nch->nch_ReadySignal = SIGB_SINGLE;
nch->nch_ReadySigTask = FindTask(NULL);
SetSignal(0, SIGF_SINGLE);
if((tmptask = psdSpawnSubTask(buf, nHidTask, nch)))
{
psdBorrowLocksWait(tmptask, 1UL<<nch->nch_ReadySignal);
if(nch->nch_Task)
{
nch->nch_ReadySigTask = NULL;
//FreeSignal(nch->nch_ReadySignal);
Forbid();
AddTail(&nh->nh_Bindings, &nch->nch_Node);
Permit();
psdAddErrorMsg(RETURN_OK, (STRPTR) libname,
"Play it again, '%s'!",
devname);
if((DOSBase = OpenLibrary("dos.library", 37)))
{
BPTR fh;
BPTR lock;
psdSafeRawDoFmt(buf, 64, "%s/%s", (STRPTR) "DEVS:Midi", nch->nch_ShortID);
fh = Open(buf, MODE_OLDFILE);
if(!fh)
{
fh = Open(buf, MODE_NEWFILE);
if(!fh)
{
lock = CreateDir("DEVS:Midi");
if(lock)
{
UnLock(lock);
psdAddErrorMsg(RETURN_OK, (STRPTR) libname,
"Created directory '%s'!",
(STRPTR) "DEVS:Midi");
}
fh = Open(buf, MODE_NEWFILE);
}
if(!fh)
{
psdAddErrorMsg(RETURN_ERROR, (STRPTR) libname,
"Couldn't generate CAMD MIDI driver '%s'!",
buf);
} else {
UBYTE *tmpmem = psdAllocVec(sizeof(CAMDDriver));
if(tmpmem)
{
CopyMemQuick(CAMDDriver, tmpmem, sizeof(CAMDDriver));
// fix name of driver -- position is hardcoded, but unlikely to move
strcpy(&tmpmem[0x46], nch->nch_ShortID);
Write(fh, tmpmem, sizeof(CAMDDriver));
psdFreeVec(tmpmem);
psdAddErrorMsg(RETURN_OK, (STRPTR) libname,
"Generated CAMD MIDI driver '%s'!",
buf);
}
Close(fh);
}
} else {
Close(fh);
}
CloseLibrary(DOSBase);
}
CloseLibrary(ps);
return(nch);
}
}
nch->nch_ReadySigTask = NULL;
//FreeSignal(nch->nch_ReadySignal);
psdFreeVec(nch);
}
CloseLibrary(ps);
}
return(NULL);
}