summaryrefslogtreecommitdiffstats
path: root/private/ntos/ndis/pcimac/idd_init.c
diff options
context:
space:
mode:
Diffstat (limited to 'private/ntos/ndis/pcimac/idd_init.c')
-rw-r--r--private/ntos/ndis/pcimac/idd_init.c909
1 files changed, 909 insertions, 0 deletions
diff --git a/private/ntos/ndis/pcimac/idd_init.c b/private/ntos/ndis/pcimac/idd_init.c
new file mode 100644
index 000000000..998b73a72
--- /dev/null
+++ b/private/ntos/ndis/pcimac/idd_init.c
@@ -0,0 +1,909 @@
+/*
+ * IDD_INIT.C - IDD initialization
+ */
+
+#include <ndis.h>
+//#include <ndismini.h>
+#include <ndiswan.h>
+#include <ndistapi.h>
+#include <mytypes.h>
+#include <mydefs.h>
+#include <disp.h>
+#include <util.h>
+#include <opcodes.h>
+#include <adapter.h>
+#include <idd.h>
+#include <mtl.h>
+#include <cm.h>
+#include <res.h>
+#include <trc.h>
+#include <io.h>
+
+//IDD* IddTbl[MAX_IDD_IN_SYSTEM];
+typedef struct
+{
+ NDIS_SPIN_LOCK lock;
+ ULONG NumberOfIddsInSystem;
+ ULONG LastIddPolled;
+ ADAPTER *CurrentAdapter;
+ ADAPTER *LastAdapter;
+ IDD* Idd[MAX_IDD_IN_SYSTEM];
+}IDD_TABLE;
+
+IDD_TABLE IddTbl;
+
+BOOLEAN IsThisAdapterNext(ADAPTER *Adapter);
+
+/* driver global vars */
+extern DRIVER_BLOCK Pcimac;
+
+#ifdef OLD
+ULONG
+EnumIddInSystem()
+{
+ ULONG n;
+
+ for (n = 0; n < MAX_IDD_IN_SYSTEM; n++)
+ {
+ if (IddTbl[n] == NULL)
+ break;
+ }
+ return(n);
+}
+
+IDD*
+GetIddByIndex(
+ ULONG Index
+ )
+{
+ return(IddTbl[Index]);
+}
+
+#endif
+
+ULONG
+EnumIddInSystem()
+{
+ ULONG NumberOfIddsInSystem;
+
+ NdisAcquireSpinLock(&IddTbl.lock);
+
+ NumberOfIddsInSystem = IddTbl.NumberOfIddsInSystem;
+
+ NdisReleaseSpinLock(&IddTbl.lock);
+
+ return(NumberOfIddsInSystem);
+}
+
+IDD*
+GetIddByIndex(
+ ULONG Index
+ )
+{
+ IDD *idd;
+
+ NdisAcquireSpinLock(&IddTbl.lock);
+
+ idd = IddTbl.Idd[Index];
+
+ NdisReleaseSpinLock(&IddTbl.lock);
+
+ return(idd);
+}
+
+ULONG
+EnumIddPerAdapter(
+ VOID *Adapter_1
+ )
+{
+ ADAPTER *Adapter = (ADAPTER*)Adapter_1;
+
+ return(Adapter->NumberOfIddOnAdapter);
+}
+
+
+INT
+IoEnumIdd(VOID *cmd_1)
+{
+ ULONG n;
+ IO_CMD *cmd = (IO_CMD*)cmd_1;
+
+ NdisAcquireSpinLock(&IddTbl.lock);
+
+ cmd->val.enum_idd.num = (USHORT)IddTbl.NumberOfIddsInSystem;
+
+ for (n = 0; n < IddTbl.NumberOfIddsInSystem; n++)
+ {
+ IDD *idd;
+
+ idd = cmd->val.enum_idd.tbl[n] = IddTbl.Idd[n];
+
+ NdisMoveMemory(&cmd->val.enum_idd.name[n],
+ idd->name,
+ sizeof(cmd->val.enum_idd.name[n]));
+ }
+
+ NdisReleaseSpinLock(&IddTbl.lock);
+
+ return(0);
+}
+
+#pragma NDIS_INIT_FUNCTION(idd_init)
+
+ULONG
+idd_init(VOID)
+{
+ //
+ // clear out idd table
+ //
+ NdisZeroMemory(&IddTbl, sizeof(IDD_TABLE));
+
+ NdisAllocateSpinLock(&IddTbl.lock);
+
+ return(IDD_E_SUCC);
+}
+
+#pragma NDIS_INIT_FUNCTION(idd_create)
+
+/* allocate & initialize an idd object */
+INT
+idd_create(VOID **ret_idd, USHORT btype)
+{
+ IDD *idd;
+ INT n;
+ NDIS_PHYSICAL_ADDRESS pa = NDIS_PHYSICAL_ADDRESS_CONST(-1, -1);
+
+ D_LOG(D_ENTRY, ("idd_create: BoardType: %d", btype));
+
+ /* allocate memory object */
+ NdisAllocateMemory((PVOID*)&idd, sizeof(IDD), 0, pa);
+ if ( !idd )
+ {
+ D_LOG(D_ALWAYS, ("idd_create: memory allocate failed!"));
+ return(IDD_E_NOMEM);
+ }
+
+ NdisAcquireSpinLock(&IddTbl.lock);
+
+ //
+ // store idd in system idd table
+ //
+ for (n = 0; n < MAX_IDD_IN_SYSTEM; n++)
+ if (!IddTbl.Idd[n])
+ break;
+
+ if (n >= MAX_IDD_IN_SYSTEM)
+ {
+ /* free memory for idd */
+ NdisFreeMemory(idd, sizeof(*idd), 0);
+
+ NdisReleaseSpinLock(&IddTbl.lock);
+
+ return(IDD_E_NOROOM);
+ }
+
+ IddTbl.Idd[n] = idd;
+ IddTbl.NumberOfIddsInSystem++;
+
+ NdisReleaseSpinLock(&IddTbl.lock);
+
+ D_LOG(D_ALWAYS, ("idd_create: idd: 0x%p", idd));
+ NdisZeroMemory(idd, sizeof(IDD));
+
+ /* setup init state, adapter handle */
+ idd->state = IDD_S_INIT;
+ idd->trc = NULL;
+
+ /* allocate root spinlock */
+ NdisAllocateSpinLock(&idd->lock);
+
+ /* initialize send queues */
+ for ( n = 0 ; n < IDD_TX_PORTS ; n++ )
+ {
+ INT max;
+ /* initialize queue */
+ idd->sendq[n].max = max = IDD_MAX_SEND / IDD_TX_PORTS;
+
+ idd->sendq[n].tbl = idd->smsg_pool + max * n;
+
+ /* allocate spin lock */
+ NdisAllocateSpinLock(&idd->sendq[n].lock);
+ }
+
+ /* initialize receiver tables */
+ for ( n = 0 ; n < IDD_RX_PORTS ; n++ )
+ {
+ INT max;
+
+ /* initialize table */
+ idd->recit[n].max = max = IDD_MAX_HAND / IDD_RX_PORTS;
+ idd->recit[n].tbl = idd->rhand_pool + max * n;
+
+ /* allocate spin lock */
+ NdisAllocateSpinLock(&idd->recit[n].lock);
+ }
+
+ /* initialize board specific functions */
+ switch ( btype )
+ {
+ case IDD_BT_PCIMAC :
+ idd->CheckIO = (VOID*)IdpCheckIO;
+ idd->CheckMem = (VOID*)IdpCheckMem;
+ idd->SetBank = (VOID*)IdpPcSetBank;
+ idd->SetPage = (VOID*)IdpPcSetPage;
+ idd->SetBasemem = (VOID*)IdpPcSetBasemem;
+ idd->LoadCode = (VOID*)IdpLoadCode;
+ idd->PollTx = (VOID*)IdpPollTx;
+ idd->PollRx = (VOID*)IdpPollRx;
+ idd->Execute = (VOID*)IdpExec;
+ idd->OutToPort = (VOID*)IdpOutp;
+ idd->InFromPort = (VOID*)IdpInp;
+ idd->ApiGetPort = (VOID*)IdpGetPort;
+ idd->ApiBindPort = (VOID*)IdpBindPort;
+ idd->ApiAllocBuffer = (VOID*)IdpAllocBuf;
+ idd->ResetAdapter = (VOID*)IdpResetBoard;
+ idd->NVRamRead = (VOID*)IdpNVRead;
+ idd->ChangePage = (VOID*)IdpCPage;
+ break;
+
+ case IDD_BT_PCIMAC4 :
+ idd->SetBank = (VOID*)IdpPc4SetBank;
+ idd->SetPage = (VOID*)IdpPc4SetPage;
+ idd->SetBasemem = (VOID*)IdpPc4SetBasemem;
+ idd->CheckIO = (VOID*)IdpCheckIO;
+ idd->CheckMem = (VOID*)IdpCheckMem;
+ idd->LoadCode = (VOID*)IdpLoadCode;
+ idd->PollTx = (VOID*)IdpPollTx;
+ idd->PollRx = (VOID*)IdpPollRx;
+ idd->Execute = (VOID*)IdpExec;
+ idd->OutToPort = (VOID*)IdpOutp;
+ idd->InFromPort = (VOID*)IdpInp;
+ idd->ApiGetPort = (VOID*)IdpGetPort;
+ idd->ApiBindPort = (VOID*)IdpBindPort;
+ idd->ApiAllocBuffer = (VOID*)IdpAllocBuf;
+ idd->ResetAdapter = (VOID*)IdpResetBoard;
+ idd->NVRamRead = (VOID*)IdpNVRead;
+ idd->ChangePage = (VOID*)IdpCPage;
+ break;
+
+ case IDD_BT_MCIMAC :
+ idd->SetBank = (VOID*)IdpMcSetBank;
+ idd->SetPage = (VOID*)IdpMcSetPage;
+ idd->SetBasemem = (VOID*)IdpMcSetBasemem;
+ idd->CheckIO = (VOID*)IdpCheckIO;
+ idd->CheckMem = (VOID*)IdpCheckMem;
+ idd->LoadCode = (VOID*)IdpLoadCode;
+ idd->PollTx = (VOID*)IdpPollTx;
+ idd->PollRx = (VOID*)IdpPollRx;
+ idd->Execute = (VOID*)IdpExec;
+ idd->OutToPort = (VOID*)IdpOutp;
+ idd->InFromPort = (VOID*)IdpInp;
+ idd->ApiGetPort = (VOID*)IdpGetPort;
+ idd->ApiBindPort = (VOID*)IdpBindPort;
+ idd->ApiAllocBuffer = (VOID*)IdpAllocBuf;
+ idd->ResetAdapter = (VOID*)IdpResetBoard;
+ idd->NVRamRead = (VOID*)IdpNVRead;
+ idd->ChangePage = (VOID*)IdpCPage;
+ break;
+
+ case IDD_BT_DATAFIREU :
+ idd->SetBank = (VOID*)AdpSetBank;
+ idd->SetPage = (VOID*)AdpSetPage;
+ idd->SetBasemem = (VOID*)AdpSetBasemem;
+ idd->CheckIO = (VOID*)AdpCheckIO;
+ idd->CheckMem = (VOID*)AdpCheckMem;
+ idd->LoadCode = (VOID*)AdpLoadCode;
+ idd->PollTx = (VOID*)AdpPollTx;
+ idd->PollRx = (VOID*)AdpPollRx;
+ idd->Execute = (VOID*)AdpExec;
+ idd->OutToPort = (VOID*)AdpOutp;
+ idd->InFromPort = (VOID*)AdpInp;
+ idd->ApiGetPort = (VOID*)AdpGetPort;
+ idd->ApiBindPort = (VOID*)AdpBindPort;
+ idd->ApiAllocBuffer = (VOID*)AdpAllocBuf;
+ idd->ResetAdapter = (VOID*)AdpResetBoard;
+ idd->NVRamRead = (VOID*)AdpNVRead;
+ idd->ChangePage = (VOID*)AdpCPage;
+ break;
+ }
+
+
+ /* init sema */
+ sema_init(&idd->proc_sema);
+
+ //
+ // attach idd frame detection handlers
+ // these must be attached 1st for all data handlers
+ //
+ idd_attach(idd, IDD_PORT_B1_RX, (VOID*)DetectFramingHandler, idd);
+ idd_attach(idd, IDD_PORT_B2_RX, (VOID*)DetectFramingHandler, idd);
+
+ // attach a command handler to get area info from idp
+ idd_attach (idd, IDD_PORT_CMD_RX, (VOID*)idd__cmd_handler, idd);
+
+ /* return address & success */
+ *ret_idd = idd;
+ D_LOG(D_EXIT, ("idd_create: exit"));
+ return(IDD_E_SUCC);
+}
+
+/* free idd object */
+INT
+idd_destroy(VOID *idd_1)
+{
+ IDD *idd = (IDD*)idd_1;
+ INT n;
+
+ D_LOG(D_ENTRY, ("idd_destroy: entry, idd: 0x%p", idd));
+
+ // detach command handler from this idd
+ idd_detach (idd, IDD_PORT_CMD_RX, (VOID*)idd__cmd_handler, idd);
+
+ /* perform a shutdown (maybe null) */
+ idd_shutdown(idd);
+
+ /* if file handle for binary file open, close it */
+ if ( idd->phw.fbin )
+ NdisCloseFile(idd->phw.fbin);
+
+ /* free spin locks for send queue */
+ for ( n = 0 ; n < IDD_TX_PORTS ; n++ )
+ NdisFreeSpinLock(&idd->sendq[n].lock);
+
+ /* free spin locks for reciever tables */
+ for ( n = 0 ; n < IDD_RX_PORTS ; n++ )
+ NdisFreeSpinLock(&idd->recit[n].lock);
+
+ /* free resource handles */
+ if ( idd->res_io != NULL)
+ res_destroy(idd->res_io);
+
+ if ( idd->res_mem != NULL)
+ res_destroy(idd->res_mem);
+
+ // free trc object
+ if (idd->trc != NULL)
+ {
+ trc_deregister_idd(idd);
+ trc_destroy (idd->trc);
+ }
+
+ /* term sema */
+ sema_term(&idd->proc_sema);
+
+ /* free spinlock (while allocated!) */
+ NdisFreeSpinLock(&idd->lock);
+
+ NdisAcquireSpinLock(&IddTbl.lock);
+
+ //
+ // store idd in system idd table
+ //
+ for (n = 0; n < MAX_IDD_IN_SYSTEM; n++)
+ if (IddTbl.Idd[n] == idd)
+ break;
+
+ if (n < MAX_IDD_IN_SYSTEM)
+ IddTbl.Idd[n] = NULL;
+
+ IddTbl.NumberOfIddsInSystem--;
+
+ NdisReleaseSpinLock(&IddTbl.lock);
+
+ /* free memory for idd */
+ NdisFreeMemory(idd, sizeof(*idd), 0);
+
+
+ /* return success */
+ D_LOG(D_EXIT, ("idd_destroy: exit"));
+ return(IDD_E_SUCC);
+}
+
+
+//#ifdef PERADAPTER
+
+VOID
+IddPollFunction(
+ VOID *a1,
+ VOID *Adapter_1,
+ VOID *a3,
+ VOID *a4
+ )
+{
+#define MAX_EVENTS 1000
+ ULONG i, j, EventNum, TotalEventNum = 0;
+ ULONG FirstIdd, NumberOfIddOnAdapter;
+ ADAPTER *Adapter = (ADAPTER*)Adapter_1;
+ IDD *idd;
+
+ //
+ // check to see if there is someone else already polling
+ // an adapter that has the same shared memory window
+ // as this adapter. if someone is then get out so that we
+ // don't burn up this processor waiting for the other to complete
+ // if this adapter is supposed to be the next adapter to be polled
+ // only send him away for awhile, else send him away for normal polling
+ // time
+ //
+ if (CheckInDriverFlag(Adapter))
+ {
+ if (IsThisAdapterNext(Adapter))
+ {
+ //
+ // we want to come back asap
+ //
+ NdisMSetTimer(&Adapter->IddPollTimer, 0);
+ }
+ else
+ {
+ //
+ // we want to come back at our regular time
+ //
+ NdisMSetTimer(&Adapter->IddPollTimer, IDD_POLL_T);
+ }
+ return;
+ }
+
+ SetInDriverFlag(Adapter);
+
+ //
+ // this will be the first idd that we will poll
+ //
+ FirstIdd = Adapter->LastIddPolled;
+
+ //
+ // this will be the number of idds that we will poll
+ //
+ NumberOfIddOnAdapter = Adapter->NumberOfIddOnAdapter;
+
+ do
+ {
+ EventNum = 0;
+
+ //
+ // we will service all of the idd's in the system
+ // first lets do some receives
+ //
+
+ for (i = FirstIdd, j = FirstIdd + NumberOfIddOnAdapter; i < j; i++)
+ {
+ idd = Adapter->IddTbl[i % NumberOfIddOnAdapter];
+
+ if (idd && (idd->state == IDD_S_RUN))
+ EventNum += idd->PollRx(idd);
+ }
+
+
+ //
+ // we will service all of the idd's in the system
+ // now lets do the send queue
+ //
+ for (i = FirstIdd, j = FirstIdd + NumberOfIddOnAdapter; i < j; i++)
+ {
+ idd = Adapter->IddTbl[i % NumberOfIddOnAdapter];
+
+ if (idd && (idd->state == IDD_S_RUN))
+ {
+ EventNum += idd->PollTx(idd);
+ EventNum += idd->PollRx(idd);
+ }
+ }
+
+ TotalEventNum += EventNum;
+
+ } while (EventNum && (TotalEventNum < MAX_EVENTS) );
+
+ //
+ // bump so we start at next idd next time
+ //
+ Adapter->LastIddPolled++;
+
+ if (Adapter->LastIddPolled == NumberOfIddOnAdapter)
+ Adapter->LastIddPolled = 0;
+
+ ClearInDriverFlag(Adapter);
+
+ NdisMSetTimer(&Adapter->IddPollTimer, IDD_POLL_T);
+
+ //
+ // lets go ahead and give some of this data up to the wrapper
+ // hopefully this will keep us from running out of room in our
+ // assembly descriptor table
+ //
+ TryToIndicateMtlReceives(Adapter);
+}
+
+//#endif
+
+BOOLEAN
+IsThisAdapterNext(
+ ADAPTER *Adapter
+ )
+{
+ BOOLEAN ThisIsIt = FALSE;
+
+ NdisAcquireSpinLock(&Pcimac.lock);
+
+ if (Adapter == Pcimac.AdapterTbl[Pcimac.NextAdapterToPoll])
+ ThisIsIt = TRUE;
+
+ NdisReleaseSpinLock(&Pcimac.lock);
+
+ return(ThisIsIt);
+}
+
+
+#ifdef ALLADAPTERS
+VOID
+IddPollFunction(
+ VOID *a1,
+ VOID *Adapter_1,
+ VOID *a3,
+ VOID *a4
+ )
+{
+#define MAX_EVENTS 1000
+ ULONG i, j, EventNum, TotalEventNum = 0;
+ ULONG FirstIdd, NumberOfIddsInSystem;
+ ADAPTER *Adapter = (ADAPTER*)Adapter_1;
+ IDD *idd;
+
+
+ NdisAcquireSpinLock(&IddTbl.lock);
+
+ IddTbl.LastAdapter = IddTbl.CurrentAdapter;
+
+ IddTbl.CurrentAdapter = Adapter;
+
+ //
+ // this will be the first idd that we will poll
+ //
+ FirstIdd = IddTbl.LastIddPolled;
+
+ //
+ // this will be the number of idds that we will poll
+ //
+ NumberOfIddsInSystem = IddTbl.NumberOfIddsInSystem;
+
+ do
+ {
+ EventNum = 0;
+
+ //
+ // we will service all of the idd's in the system
+ // first lets do some receives
+ //
+ for (i = FirstIdd, j = FirstIdd + NumberOfIddsInSystem; i < j; i++)
+ {
+ idd = IddTbl.Idd[i % NumberOfIddsInSystem];
+
+ if (idd->state == IDD_S_RUN)
+ EventNum += idd->PollRx(idd);
+ }
+
+ //
+ // we will service all of the idd's in the system
+ // now lets do the send queue
+ //
+ for (i = FirstIdd, j = FirstIdd + NumberOfIddsInSystem; i < j; i++)
+ {
+ idd = IddTbl.Idd[i % NumberOfIddsInSystem];
+
+ if (idd->state == IDD_S_RUN)
+ {
+ EventNum += idd->PollTx(idd);
+ EventNum += idd->PollRx(idd);
+ }
+ }
+
+ TotalEventNum += EventNum;
+
+ } while (EventNum && (TotalEventNum < MAX_EVENTS) );
+
+ IddTbl.LastIddPolled++;
+
+ if (IddTbl.LastIddPolled == NumberOfIddsInSystem)
+ IddTbl.LastIddPolled = 0;
+
+ NdisReleaseSpinLock(&IddTbl.lock);
+
+ //
+ // lets go ahead and give some of this data up to the wrapper
+ // hopefully this will keep us from running out of room in our
+ // assembly descriptor table
+ //
+// TryToIndicateMtlReceives(Adapter);
+
+ NdisMSetTimer(&Adapter->IddPollTimer, IDD_POLL_T);
+}
+
+#endif
+
+#ifdef OLD
+VOID
+IddPollFunction(
+ VOID *a1,
+ VOID *Adapter_1,
+ VOID *a3,
+ VOID *a4
+ )
+{
+#define MAX_EVENTS 1000
+ ULONG n, EventNum, TotalEventNum = 0;
+
+ ADAPTER *Adapter = (ADAPTER*)Adapter_1;
+
+ do
+ {
+ EventNum = 0;
+
+ //
+ // we will service all of the idd's in the system
+ // first lets do some receives
+ //
+ for (n = 0; n < MAX_IDD_IN_SYSTEM; n++)
+ {
+ IDD *idd = IddTbl[n];
+
+ if (idd && (idd->state == IDD_S_RUN))
+ EventNum += idd->PollRx(idd);
+ }
+
+ //
+ // we will service all of the idd's in the system
+ // now lets do the send queue
+ //
+ for (n = 0; n < MAX_IDD_IN_SYSTEM; n++)
+ {
+ IDD *idd = IddTbl[n];
+
+ if (idd && (idd->state == IDD_S_RUN))
+ EventNum += idd->PollTx(idd);
+ }
+
+ TotalEventNum += EventNum;
+
+ } while (EventNum && (TotalEventNum < MAX_EVENTS) );
+
+ //
+ // lets go ahead and give some of this data up to the wrapper
+ // hopefully this will keep us from running out of room in our
+ // assembly descriptor table
+ //
+// TryToIndicateMtlReceives(Adapter);
+
+ NdisMSetTimer(&Adapter->IddPollTimer, IDD_POLL_T);
+}
+#endif
+
+/* get idd name */
+CHAR*
+idd_get_name(VOID *idd_1)
+{
+ IDD *idd = (IDD*)idd_1;
+ return(idd->name);
+}
+
+USHORT
+idd_get_bline(VOID *idd_1)
+{
+ IDD *idd = (IDD*)idd_1;
+ return(idd->bline);
+}
+
+USHORT
+idd_get_btype(VOID *idd_1)
+{
+ IDD *idd = (IDD*)idd_1;
+ return(idd->btype);
+}
+
+VOID*
+idd_get_trc (VOID *idd_1)
+{
+ IDD *idd = (IDD*)idd_1;
+ return(idd->trc);
+}
+
+VOID
+idd_set_trc (VOID *idd_1, TRC* Trace)
+{
+ IDD *idd = (IDD*)idd_1;
+ idd->trc = Trace;
+}
+
+INT
+idd_reset_area (VOID* idd_1)
+{
+ IDD *idd = (IDD*)idd_1;
+
+ idd->Area.area_state = AREA_ST_IDLE;
+
+ return(IDD_E_SUCC);
+}
+
+INT
+idd_get_area_stat (VOID *idd_1, IDD_AREA *IddStat)
+{
+ IDD *idd = (IDD*)idd_1;
+
+ *IddStat = idd->Area;
+
+ return(IDD_E_SUCC);
+}
+
+
+/* get an idd area (really start operation, complete on handler callback) */
+INT
+idd_get_area(VOID *idd_1, ULONG area_id, VOID (*handler)(), VOID *handler_arg)
+{
+ IDD *idd = (IDD*)idd_1;
+ IDD_MSG msg;
+
+ D_LOG(D_ENTRY, ("idd_get_area: entry, idd: 0x%p, area_id: %ld", idd, area_id));
+ D_LOG(D_ENTRY, ("idd_get_area: handler: 0x%p, handler_arg: 0x%p", handler, handler_arg));
+
+ /* check if area is not busy */
+ if ( idd->Area.area_state == AREA_ST_PEND )
+ return(IDD_E_BUSY);
+
+ /* mark area is pending, store arguments */
+ idd->Area.area_state = AREA_ST_PEND;
+ idd->Area.area_id = area_id;
+ idd->Area.area_idd = idd;
+ idd->Area.area_len = 0;
+ idd->Area.area_handler = handler;
+ idd->Area.area_handler_arg = handler_arg;
+
+ /* issue idd command to get area */
+ NdisZeroMemory(&msg, sizeof(msg));
+ msg.opcode = CMD_DUMP_PARAM;
+ msg.param = msg.bufid = area_id;
+ if ( idd_send_msg(idd, &msg, IDD_PORT_CMD_TX, NULL, NULL) != IDD_E_SUCC )
+ {
+ /* idd op failed! */
+ idd->Area.area_state = AREA_ST_IDLE;
+ return(IDD_E_AREA);
+ }
+
+ /* succ here */
+ return(IDD_E_SUCC);
+}
+
+VOID
+IddSetRxFraming(
+ IDD *idd,
+ USHORT bchan,
+ ULONG FrameType
+ )
+{
+ idd->recit[bchan].RxFrameType = FrameType;
+}
+
+VOID
+DetectFramingHandler(
+ IDD *idd,
+ USHORT port,
+ ULONG RxFrameType,
+ IDD_XMSG *msg
+ )
+{
+ UCHAR DetectBytes[2];
+
+ if (RxFrameType & IDD_FRAME_DETECT)
+ {
+ //
+ // get detection bytes
+ //
+ IddGetDataFromAdapter(idd,
+ (PUCHAR)&DetectBytes,
+ (PUCHAR)msg->bufptr,
+ 2);
+
+// NdisMoveMemory ((PUCHAR)&DetectBytes, (PUCHAR)msg->bufptr, 2);
+
+ D_LOG(D_ENTRY, ("DetectRxFraming: 0x%x, 0x%x\n",DetectBytes[0], DetectBytes[1]));
+
+ if ((DetectBytes[0] == DKF_UUS_SIG) && (!DetectBytes[1]))
+ idd->recit[port].RxFrameType = IDD_FRAME_DKF;
+
+ else if ((DetectBytes[0] == PPP_SIG_0) && (DetectBytes[1] == PPP_SIG_1))
+ {
+ idd->recit[port].RxFrameType = IDD_FRAME_PPP;
+ cm__ppp_conn(idd, port);
+ }
+ }
+}
+
+VOID
+idd__cmd_handler(IDD *idd, USHORT chan, ULONG Reserved, IDD_MSG *msg)
+{
+ ULONG bytes;
+
+ /* check for show area more/last frames (3/4) */
+ if ( msg->bufid >= 2 )
+ {
+ if ( (idd->Area.area_state == AREA_ST_PEND) &&
+ (idd->Area.area_idd == idd) )
+ {
+ /* copy frame data, as much as possible */
+ bytes = MIN(msg->buflen, (sizeof(idd->Area.area_buf) - idd->Area.area_len));
+
+ IddGetDataFromAdapter(idd,
+ (PUCHAR)idd->Area.area_buf + idd->Area.area_len,
+ (PUCHAR)msg->bufptr,
+ (USHORT)bytes);
+
+// NdisMoveMemory (idd->Area.area_buf + idd->Area.area_len, msg->bufptr, bytes);
+
+ idd->Area.area_len += bytes;
+
+ /* if last, complete */
+ if ( msg->bufid == 3 )
+ {
+ idd->Area.area_state = AREA_ST_DONE;
+ if ( idd->Area.area_handler )
+ (*idd->Area.area_handler)(idd->Area.area_handler_arg,
+ idd->Area.area_id,
+ idd->Area.area_buf,
+ idd->Area.area_len);
+ }
+ }
+ }
+}
+
+#pragma NDIS_INIT_FUNCTION(idd_add_def)
+
+/* add a definition to initialization definition database */
+INT
+idd_add_def(IDD *idd, CHAR *name, CHAR *val)
+{
+ INT name_len = strlen(name) + 1;
+ INT val_len = strlen(val) + 1;
+
+ D_LOG(D_ENTRY, ("idd_add_def: entry"));
+
+ _strlwr(name);
+
+ _strlwr(val);
+
+ D_LOG(D_ENTRY, ("idd_add_def: name: [%s], val: [%s]", name, val));
+ /* check for room */
+
+ if ( (idd->DefinitionTableLength + name_len + val_len) > IDD_DEF_SIZE )
+ {
+ D_LOG(D_ALWAYS, ("idd_add_def: no room in definition table!"));
+ return(IDD_E_NOROOM);
+ }
+
+ /* enter into table */
+ NdisMoveMemory(idd->DefinitionTable + idd->DefinitionTableLength, name, name_len);
+ idd->DefinitionTableLength += name_len;
+
+ NdisMoveMemory(idd->DefinitionTable + idd->DefinitionTableLength, val, val_len);
+ idd->DefinitionTableLength += val_len;
+
+ /* return success */
+ return(IDD_E_SUCC);
+}
+
+#pragma NDIS_INIT_FUNCTION(idd_get_nvram)
+
+/* get an nvram location */
+INT
+idd_get_nvram(VOID *idd_1, USHORT addr, USHORT *val)
+{
+ IDD *idd = (IDD*)idd_1;
+ D_LOG(D_ENTRY, ("idd_get_nvram: entry, idd: 0x%p, addr: 0x%x", idd, addr));
+
+ /* lock card */
+ NdisAcquireSpinLock(&idd->lock);
+
+ /* do the read */
+ *val = idd->NVRamRead(idd, addr);
+
+ /* release card & return */
+ NdisReleaseSpinLock(&idd->lock);
+ D_LOG(D_EXIT, ("idd_get_nvram: exit, val: 0x%x", *val));
+ return(IDD_E_SUCC);
+}
generated by cgit v1.2.3 (git 2.25.1) at 2024-10-03 12:46:15 +0200